Class: Cloudflare::DurableObjectStorage

Inherits:
Object
  • Object
show all
Defined in:
lib/homura/runtime/durable_object.rb

Overview

Thin Ruby wrapper around state.storage. Values are serialised to JSON on ‘put` and parsed on `get`, so user code can pass/retrieve plain Ruby Hashes, Arrays, numbers, strings, booleans without reaching for a backtick.

Instance Method Summary collapse

Constructor Details

#initialize(js_storage) ⇒ DurableObjectStorage

Returns a new instance of DurableObjectStorage.



480
481
482
 
# File 'lib/homura/runtime/durable_object.rb', line 480

def initialize(js_storage)
  @js = js_storage
end

Instance Method Details

#delete(key) ⇒ Object

Remove a key. Returns a JS Promise resolving to a boolean (true if a key was deleted). We coerce to Ruby true/false.



503
504
505
506
507
 
# File 'lib/homura/runtime/durable_object.rb', line 503

def delete(key)
  js = @js
  err_klass = Cloudflare::DurableObjectError
  `#{js}.delete(#{key.to_s}).then(function(v) { return v ? true : false; }).catch(function(e) { #{Kernel}.$raise(#{err_klass}.$new(e && e.message ? e.message : String(e), Opal.hash({ operation: 'storage.delete' }))); })`
end

#delete_all ⇒ Object

Clear every key. Returns a JS Promise.



510
511
512
513
514
 
# File 'lib/homura/runtime/durable_object.rb', line 510

def delete_all
  js = @js
  err_klass = Cloudflare::DurableObjectError
  `#{js}.deleteAll().catch(function(e) { #{Kernel}.$raise(#{err_klass}.$new(e && e.message ? e.message : String(e), Opal.hash({ operation: 'storage.deleteAll' }))); })`
end

#get(key) ⇒ Object

Returns a JS Promise resolving to the stored Ruby value, or nil.



485
486
487
488
489
 
# File 'lib/homura/runtime/durable_object.rb', line 485

def get(key)
  js = @js
  err_klass = Cloudflare::DurableObjectError
  `#{js}.get(#{key.to_s}).then(function(v) { if (v == null) return nil; if (typeof v === 'string') { try { return JSON.parse(v); } catch (e) { return v; } } return v; }).catch(function(e) { #{Kernel}.$raise(#{err_klass}.$new(e && e.message ? e.message : String(e), Opal.hash({ operation: 'storage.get' }))); })`
end

#list(prefix: nil, limit: nil, reverse: nil, start: nil, end_key: nil) ⇒ Object

List keys. Returns a JS Promise resolving to a Ruby ‘Hash` of `{ key => parsed-value }` (values are JSON-parsed when they round-tripped through `put`; opaque strings are returned as-is). Options `prefix:`, `limit:`, `reverse:`, `start:`, `end_key:` forward to the underlying Workers `storage.list(…)` call.

The earlier iteration returned a JS ‘Map`; that was documented as a Ruby Hash but forced callers to reach for JS iteration, which Copilot review (#9) flagged. The JS side still builds the intermediate Map (the Workers runtime also gives us a Map) and we copy it into a Ruby Hash before resolving so downstream code can use `each` / `[]` / `keys` without backticks.



528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
 
# File 'lib/homura/runtime/durable_object.rb', line 528

def list(prefix: nil, limit: nil, reverse: nil, start: nil, end_key: nil)
  js = @js
  err_klass = Cloudflare::DurableObjectError
  js_opts = `({})`
  `#{js_opts}.prefix  = #{prefix.to_s}` unless prefix.nil?
  `#{js_opts}.limit   = #{limit.to_i}`  unless limit.nil?
  `#{js_opts}.reverse = #{!!reverse}`   unless reverse.nil?
  `#{js_opts}.start   = #{start.to_s}`  unless start.nil?
  `#{js_opts}.end     = #{end_key.to_s}` unless end_key.nil?
  js_promise = `#{js}.list(#{js_opts}).catch(function(e) { #{Kernel}.$raise(#{err_klass}.$new(e && e.message ? e.message : String(e), Opal.hash({ operation: 'storage.list' }))); })`
  js_result = js_promise.__await__
  out = {}
  return out if `#{js_result} == null`
  `(#{js_result}.forEach && typeof #{js_result}.forEach === 'function') && #{js_result}.forEach(function(v, k) { var pv = v; if (typeof pv === 'string') { try { pv = JSON.parse(pv); } catch (_) {} } #{out}.$store(String(k), pv); })`
  out
end

#put(key, value) ⇒ Object

Store any JSON-serialisable Ruby value. Always serialises via ‘to_json` to avoid the JS-side “$$is_hash:true” Opal leakage. Returns a JS Promise.



494
495
496
497
498
499
 
# File 'lib/homura/runtime/durable_object.rb', line 494

def put(key, value)
  js = @js
  err_klass = Cloudflare::DurableObjectError
  js_value = value.nil? ? 'null' : value.to_json
  `#{js}.put(#{key.to_s}, #{js_value}).catch(function(e) { #{Kernel}.$raise(#{err_klass}.$new(e && e.message ? e.message : String(e), Opal.hash({ operation: 'storage.put' }))); })`
end