volcano-sdk 0.30.0 → 0.32.0

data/lib/volcano/storage_resumable_upload.rb

@@ -30,7 +30,7 @@ module Volcano
     def upload_session_parts(path, source, session, total_size, on_progress)
       uploaded = 0
       session.total_parts.times do |part_index|
-        part = source.read(session.part_size)
+        part = source.read(session.part_size) || raise(IOError, 'upload source ended before completion')
         upload_part(
           path,
           session_id: session.session_id,
@@ -64,11 +64,22 @@ module Volcano
     def remaining_upload_bytes(source)
       return unless source.respond_to?(:size) && source.respond_to?(:pos)
 
-      source.size - source.pos
+      dimensions = upload_source_dimensions(source)
+      return unless dimensions
+
+      dimensions.fetch(0) - dimensions.fetch(1)
     rescue IOError, SystemCallError
       nil
     end
 
+    def upload_source_dimensions(source)
+      size = source.method(:size).call
+      position = source.method(:pos).call
+      return unless size.is_a?(Integer) && position.is_a?(Integer)
+
+      [size, position]
+    end
+
     def with_spooled_upload_source(source)
       Tempfile.create('volcano-upload') do |file|
         file.binmode

data/lib/volcano/storage_session_adapter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Validates the client methods that storage uses for session-scoped requests.
+  class StorageSessionAdapter
+    def initialize(client)
+      @client = client
+    end
+
+    def capture_session_binding
+      binding = storage_binding_array(@client.method(:capture_session_binding).call)
+      generation, owner, session = binding
+      [storage_generation(generation), storage_owner(owner), storage_session(session)]
+    end
+
+    def session_token
+      token = @client.method(:session_token).call
+      raise Error::TransportError, 'invalid storage session token' unless token.is_a?(String)
+
+      token
+    end
+
+    def session_request(binding:, &)
+      method_name = :session_request
+      response = @client.public_send(method_name, binding: binding) do |token|
+        raise Error::TransportError, 'invalid storage session token' unless token.is_a?(String)
+
+        yield token
+      end
+      raise Error::TransportError, 'invalid storage session response' unless response.is_a?(Transport::Response)
+
+      response
+    end
+
+    private
+
+    def storage_binding_array(value)
+      raise Error::TransportError, 'invalid storage session binding' unless value.is_a?(Array) && value.size == 3
+
+      value
+    end
+
+    def storage_generation(value)
+      raise Error::TransportError, 'invalid storage session binding' unless value.is_a?(Integer)
+
+      value
+    end
+
+    def storage_owner(value)
+      raise Error::TransportError, 'invalid storage session binding' unless value.is_a?(SessionOperations)
+
+      value
+    end
+
+    def storage_session(value)
+      raise Error::TransportError, 'invalid storage session binding' unless value.nil? || value.is_a?(Session)
+
+      value
+    end
+  end
+end

data/lib/volcano/storage_transport_adapter.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Narrows generated and test transport calls to checked storage responses.
+  class StorageTransportAdapter
+    def initialize(transport)
+      @transport = transport
+    end
+
+    def upload_storage_object(authorization:, bucket_name:, path:, data:, content_type:)
+      invoke(:upload_storage_object, authorization: authorization, bucket_name: bucket_name,
+                                     path: path, data: data, content_type: content_type)
+    end
+
+    def download_storage_object(authorization:, bucket_name:, path:, byte_range:)
+      invoke(:download_storage_object, authorization: authorization, bucket_name: bucket_name,
+                                       path: path, byte_range: byte_range)
+    end
+
+    def list_storage_objects(authorization:, bucket_name:, prefix:, limit:, cursor:)
+      invoke(:list_storage_objects, authorization: authorization, bucket_name: bucket_name,
+                                    prefix: prefix, limit: limit, cursor: cursor)
+    end
+
+    def delete_storage_object(authorization:, bucket_name:, path:)
+      invoke(:delete_storage_object, authorization: authorization, bucket_name: bucket_name, path: path)
+    end
+
+    def move_storage_object(authorization:, bucket_name:, from_path:, to_path:)
+      invoke(:move_storage_object, authorization: authorization, bucket_name: bucket_name,
+                                   from_path: from_path, to_path: to_path)
+    end
+
+    def copy_storage_object(authorization:, bucket_name:, from_path:, to_path:)
+      invoke(:copy_storage_object, authorization: authorization, bucket_name: bucket_name,
+                                   from_path: from_path, to_path: to_path)
+    end
+
+    def update_storage_object_visibility(authorization:, bucket_name:, path:, is_public:)
+      invoke(:update_storage_object_visibility, authorization: authorization, bucket_name: bucket_name,
+                                                path: path, is_public: is_public)
+    end
+
+    def create_upload_session(authorization:, bucket_name:, request:)
+      invoke(:create_upload_session, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    def upload_part(authorization:, bucket_name:, request:)
+      invoke(:upload_part, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    def complete_upload_session(authorization:, bucket_name:, request:)
+      invoke(:complete_upload_session, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    def get_upload_session(authorization:, bucket_name:, request:)
+      invoke(:get_upload_session, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    def abort_upload_session(authorization:, bucket_name:, request:)
+      invoke(:abort_upload_session, authorization: authorization, bucket_name: bucket_name, request: request)
+    end
+
+    private
+
+    def invoke(name, **arguments)
+      response = @transport.public_send(name, **arguments)
+      raise Error::TransportError, 'invalid storage transport response' unless response.is_a?(Transport::Response)
+
+      response
+    end
+  end
+end

data/lib/volcano/storage_upload_models.rb

@@ -1,51 +1,68 @@
 # frozen_string_literal: true
 
 module Volcano
-  UploadSessionRequest = Data.define(:path, :content_type, :total_size, :part_size) do
+  UploadSessionRequest = Data.define(:path, :content_type, :total_size, :part_size)
+
+  # Freezes the arguments sent to create a resumable upload.
+  class UploadSessionRequest
+    # @dynamic path, content_type, total_size, part_size
     def initialize(path:, content_type:, total_size:, part_size: nil)
-      super(
-        path: path.dup.freeze,
-        content_type: content_type.dup.freeze,
-        total_size: total_size,
-        part_size: part_size
-      )
+      path = path.dup.freeze
+      content_type = content_type.dup.freeze
+      super
     end
   end
   private_constant :UploadSessionRequest
 
-  UploadPartRequest = Data.define(:path, :session_id, :part_number, :data) do
+  UploadPartRequest = Data.define(:path, :session_id, :part_number, :data)
+
+  # Freezes one resumable upload part before transport dispatch.
+  class UploadPartRequest
+    # @dynamic path, session_id, part_number, data
     def initialize(path:, session_id:, part_number:, data:)
-      super(
-        path: path.dup.freeze,
-        session_id: session_id.dup.freeze,
-        part_number: part_number,
-        data: data.dup.freeze
-      )
+      path = path.dup.freeze
+      session_id = session_id.dup.freeze
+      data = data.dup.freeze
+      super
     end
   end
   private_constant :UploadPartRequest
 
-  UploadSessionReference = Data.define(:path, :session_id) do
+  UploadSessionReference = Data.define(:path, :session_id)
+
+  # Freezes the path and identifier used for upload session operations.
+  class UploadSessionReference
+    # @dynamic path, session_id
     def initialize(path:, session_id:)
-      super(path: path.dup.freeze, session_id: session_id.dup.freeze)
+      path = path.dup.freeze
+      session_id = session_id.dup.freeze
+      super
     end
   end
   private_constant :UploadSessionReference
 
-  UploadSession = Data.define(:session_id, :part_size, :total_parts, :expires_at) do
+  UploadSession = Data.define(:session_id, :part_size, :total_parts, :expires_at)
+
+  # Describes a newly created upload session.
+  class UploadSession
+    # @dynamic session_id, part_size, total_parts, expires_at, members, with, to_h, deconstruct, deconstruct_keys
+    # @dynamic self.[], self.members
     def initialize(session_id:, part_size:, total_parts:, expires_at:)
-      super(
-        session_id: session_id.dup.freeze,
-        part_size: part_size,
-        total_parts: total_parts,
-        expires_at: expires_at.dup.freeze
-      )
+      session_id = session_id.dup.freeze
+      expires_at = expires_at.dup.freeze
+      super
     end
   end
 
-  UploadPart = Data.define(:part_number, :etag, :size) do
+  UploadPart = Data.define(:part_number, :etag, :size)
+
+  # Describes an accepted upload part.
+  class UploadPart
+    # @dynamic part_number, etag, size, members, with, to_h, deconstruct, deconstruct_keys
+    # @dynamic self.[], self.members
     def initialize(part_number:, etag:, size:)
-      super(part_number: part_number, etag: etag.dup.freeze, size: size)
+      etag = etag.dup.freeze
+      super
     end
   end
 
@@ -55,7 +72,13 @@ module Volcano
   ].freeze
   private_constant :UPLOAD_SESSION_STATUS_ATTRIBUTES
 
-  UploadSessionStatus = Data.define(*UPLOAD_SESSION_STATUS_ATTRIBUTES) do
+  UploadSessionStatus = Data.define(*UPLOAD_SESSION_STATUS_ATTRIBUTES)
+
+  # Freezes upload progress returned by storage.
+  class UploadSessionStatus
+    # @dynamic session_id, status, path, content_type, total_size, part_size
+    # @dynamic total_parts, parts_uploaded, bytes_uploaded, parts, expires_at, created_at
+    # @dynamic members, with, to_h, deconstruct, deconstruct_keys, self.[], self.members
     def initialize(**attributes)
       unknown = attributes.keys - UPLOAD_SESSION_STATUS_ATTRIBUTES
       raise ArgumentError, "unknown keywords: #{unknown.join(', ')}" unless unknown.empty?
@@ -66,7 +89,8 @@ module Volcano
       values = UPLOAD_SESSION_STATUS_ATTRIBUTES.to_h do |name|
         [name, immutable_value(attributes.fetch(name))]
       end
-      super(**values)
+      attributes = values
+      super
     end
 
     private

data/lib/volcano/storage_upload_sessions.rb

@@ -51,7 +51,7 @@ module Volcano
           request: request
         )
       end
-      storage_object(Transport.body(response, 200).fetch('object'))
+      storage_object(storage_payload(Transport.body(response, 200)).fetch('object'))
     end
 
     def get_upload_session(path, session_id:)
@@ -78,39 +78,5 @@ module Volcano
       Transport.body(response, 200)
       nil
     end
-
-    private
-
-    def upload_session(payload)
-      UploadSession.new(
-        session_id: payload.fetch('session_id'),
-        part_size: payload.fetch('part_size'),
-        total_parts: payload.fetch('total_parts'),
-        expires_at: parse_time(payload.fetch('expires_at'))
-      )
-    end
-
-    def upload_part_metadata(payload)
-      UploadPart.new(
-        part_number: payload.fetch('part_number'),
-        etag: payload.fetch('etag'),
-        size: payload.fetch('size')
-      )
-    end
-
-    def upload_session_status(payload)
-      attributes = upload_session_status_attributes(payload)
-      attributes[:parts] = attributes.fetch(:parts).map { |part| upload_part_metadata(part) }
-      attributes[:expires_at] = parse_time(attributes.fetch(:expires_at))
-      attributes[:created_at] = parse_time(attributes.fetch(:created_at))
-      UploadSessionStatus.new(**attributes)
-    end
-
-    def upload_session_status_attributes(payload)
-      UPLOAD_SESSION_STATUS_ATTRIBUTES.to_h do |name|
-        value = name == :parts ? payload.fetch(name.to_s, []) : payload.fetch(name.to_s)
-        [name, value]
-      end
-    end
   end
 end

data/lib/volcano/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Volcano
-  VERSION = '0.30.0'
+  VERSION = '0.32.0'
 end

data/lib/volcano.rb

@@ -26,6 +26,7 @@ require_relative 'volcano/auth_get_user'
 require_relative 'volcano/auth_update_user'
 require_relative 'volcano/auth_email_change'
 require_relative 'volcano/auth_sessions'
+require_relative 'volcano/auth_session_construction'
 require_relative 'volcano/auth'
 require_relative 'volcano/auth_sign_up'
 require_relative 'volcano/sign_up_result'
@@ -44,6 +45,10 @@ require_relative 'volcano/function_resolution'
 require_relative 'volcano/functions'
 require_relative 'volcano/durable'
 require_relative 'volcano/logs'
+require_relative 'volcano/storage_session_adapter'
+require_relative 'volcano/storage_transport_adapter'
+require_relative 'volcano/storage_response'
+require_relative 'volcano/storage_object_response'
 require_relative 'volcano/storage'
 require_relative 'volcano/storage_upload_sessions'
 require_relative 'volcano/storage_resumable_upload'
@@ -63,7 +68,7 @@ require_relative 'volcano/client'
 # Public namespace for the Volcano Ruby SDK.
 module Volcano
   private_constant :AuthRefresh, :AuthSignOut, :AuthProfile, :AuthProfileFields, :AuthUpdateUser, :AuthEmailChange,
-                   :AuthSessions,
+                   :AuthSessions, :AuthSessionConstruction,
                    :GeneratedTransport, :LockAutoRenewal, :LockLeaseClock, :LockRenewer,
                    :LockSession, :LockResponse, :Redaction, :SessionOperations
 

data/sig/auth_credentials.rbs

@@ -0,0 +1,15 @@
+module Volcano
+  class Auth
+    def current_session: () -> Session?
+    def current_session=: (Session session) -> void
+    def on_auth_state_change: () { (Symbol, Session?) -> void } -> AuthSubscription
+    def sign_in: (email: String, password: String) -> Session
+    def sign_up: (email: String, password: String, ?metadata: session_user_input, ?sign_in_when_allowed: bool) -> SignUpResult
+    def sign_in_anonymously: (?metadata: session_user_input) -> Session
+    def convert_anonymous: (email: String, password: String, ?metadata: session_user_input) -> User
+    def confirm_email: (token: String) -> nil
+    def resend_confirmation: (email: String) -> nil
+    def reset_password_for_email: (email: String) -> nil
+    def reset_password: (token: String, new_password: String) -> nil
+  end
+end

data/sig/realtime.rbs

@@ -0,0 +1,46 @@
+module Volcano
+  class Client
+    attr_reader auth: Auth
+    attr_reader realtime: Realtime
+
+    def initialize: (anon_key: String, ?api_url: String, ?service_key: String?, ?timeout: Integer, ?access_token: String?, ?refresh_token: String?) -> void
+  end
+
+  class Realtime
+    def channel: (String name, ?type: String | Symbol, ?auto_fetch: bool, ?fetch_batch_window_ms: Integer, ?fetch_max_batch_size: Integer) -> Channel
+    def connected?: () -> bool
+    def disconnect: () -> void
+    def remove_channel: (String name, ?type: String | Symbol) -> nil
+    def remove_all_channels: () -> nil
+
+    def on_connect: (^(ConnectContext) -> void callback) -> ^() -> Proc?
+                  | () { (ConnectContext) -> void } -> ^() -> Proc?
+    def on_disconnect: (^(DisconnectContext) -> void callback) -> ^() -> Proc?
+                     | () { (DisconnectContext) -> void } -> ^() -> Proc?
+    def on_error: (^(ErrorContext) -> void callback) -> ^() -> Proc?
+                | () { (ErrorContext) -> void } -> ^() -> Proc?
+
+    def database_name: () -> String?
+    def database_name=: (String? name) -> String?
+
+    class Channel
+      attr_reader name: String
+
+      def subscribe: () -> nil
+      def unsubscribe: () -> nil
+      def send: (event: String | Symbol, **json_value payload) -> nil
+
+      def on: (String event, ^(Object?) -> void callback) -> self
+            | (String event) { (Object?) -> void } -> self
+      def on_presence_sync: (^(Hash[String, PresenceInfo]) -> void callback) -> self
+                          | () { (Hash[String, PresenceInfo]) -> void } -> self
+      def on_postgres_changes: (String | Symbol event, schema: String, table: String, callback: ^(PostgresChange) -> void) -> self
+                             | (String | Symbol event, schema: String, table: String) { (PostgresChange) -> void } -> self
+
+      def track: (?Hash[String, json_value] state) -> nil
+      def presence_state: () -> Hash[String, PresenceInfo]
+      def get_presence_state: () -> Hash[String, PresenceInfo]
+      def tracked_state: () -> Hash[String, json_value]
+    end
+  end
+end

data/sig/realtime_postgres_change.rbs

@@ -17,8 +17,7 @@ module Volcano
                  | (type: String, schema: String, table: String, timestamp: String, ?record: Hash[String, json_value]?, ?old_record: Hash[String, json_value]?, ?columns: Array[json_value]?, ?id: json_value, ?mode: String?) -> PostgresChange
       def self.members: () -> [:type, :schema, :table, :record, :old_record, :columns, :timestamp, :id, :mode]
 
-      def initialize: (type: String, schema: String, table: String, timestamp: String, ?record: Hash[String, json_value]?, ?old_record: Hash[String, json_value]?, ?columns: Array[json_value]?, ?id: json_value, ?mode: String?) -> void
-                    | (String type, String schema, String table, Hash[String, json_value]? record, Hash[String, json_value]? old_record, Array[json_value]? columns, String timestamp, json_value id, String? mode) -> void
+      def initialize: (type: String, schema: String, table: String, timestamp: String, **Object? payload) -> void
       def members: () -> [:type, :schema, :table, :record, :old_record, :columns, :timestamp, :id, :mode]
       def with: (?type: String, ?schema: String, ?table: String, ?record: Hash[String, json_value]?, ?old_record: Hash[String, json_value]?, ?columns: Array[json_value]?, ?timestamp: String, ?id: json_value, ?mode: String?) -> PostgresChange
       def to_h: () -> { type: String, schema: String, table: String, record: Hash[String, json_value]?, old_record: Hash[String, json_value]?, columns: Array[json_value]?, timestamp: String, id: json_value, mode: String? }

data/sig/storage.rbs

@@ -0,0 +1,29 @@
+module Volcano
+  interface _StorageReadable
+    def read: (?Integer length) -> String?
+    def is_a?: (Class) -> bool
+    def respond_to?: (Symbol) -> bool
+    def method: (Symbol) -> Method
+  end
+
+  class Storage
+    def from: (String bucket) -> StorageBucket
+  end
+
+  class StorageBucket
+    def upload: (String path, String | _StorageReadable value, ?content_type: String?) -> Hash[String, Object?]
+    def download: (String path, ?range: String?) -> String
+    def list: (?String prefix, ?limit: Integer?, ?cursor: String?) -> StoragePage
+    def remove: (String | Array[String] paths) -> Array[String]
+    def move: (String from_path, String to_path) -> StorageObject
+    def copy: (String from_path, String to_path) -> StorageObject
+    def update_visibility: (String path, public: bool) -> StorageObject
+
+    def create_upload_session: (String path, total_size: Integer, ?content_type: String, ?part_size: Integer?) -> UploadSession
+    def upload_part: (String path, session_id: String, part_number: Integer, data: String | _StorageReadable) -> UploadPart
+    def complete_upload_session: (String path, session_id: String) -> StorageObject
+    def get_upload_session: (String path, session_id: String) -> UploadSessionStatus
+    def abort_upload_session: (String path, session_id: String) -> nil
+    def upload_resumable: (String path, String | _StorageReadable value, ?content_type: String, ?part_size: Integer?, ?on_progress: (^(Integer, Integer) -> void)?) -> StorageObject
+  end
+end

data/sig/storage_records.rbs

@@ -1,4 +1,6 @@
 module Volcano
+  type storage_object_attribute = String | Integer | bool | Hash[String, json_value] | Time | nil
+
   class StorageObject < Data
     attr_reader id: String
     attr_reader bucket_id: String
@@ -19,7 +21,7 @@ module Volcano
                | (id: String, bucket_id: String, name: String, size: Integer, mime_type: String, is_public: bool, ?owner_id: String?, ?etag: String?, ?metadata: Hash[String, json_value]?, ?created_at: Time?, ?updated_at: Time?, ?public_url: String?) -> StorageObject
     def self.members: () -> [:id, :bucket_id, :name, :size, :mime_type, :is_public, :owner_id, :etag, :metadata, :created_at, :updated_at, :public_url]
 
-    def initialize: (id: String, bucket_id: String, name: String, size: Integer, mime_type: String, is_public: bool, ?owner_id: String?, ?etag: String?, ?metadata: Hash[String, json_value]?, ?created_at: Time?, ?updated_at: Time?, ?public_url: String?) -> void
+    def initialize: (**storage_object_attribute attributes) -> void
     def members: () -> [:id, :bucket_id, :name, :size, :mime_type, :is_public, :owner_id, :etag, :metadata, :created_at, :updated_at, :public_url]
     def with: (?id: String, ?bucket_id: String, ?name: String, ?size: Integer, ?mime_type: String, ?is_public: bool, ?owner_id: String?, ?etag: String?, ?metadata: Hash[String, json_value]?, ?created_at: Time?, ?updated_at: Time?, ?public_url: String?) -> StorageObject
     def to_h: () -> { id: String, bucket_id: String, name: String, size: Integer, mime_type: String, is_public: bool, owner_id: String?, etag: String?, metadata: Hash[String, json_value]?, created_at: Time?, updated_at: Time?, public_url: String? }

data/sig/upload_session_status.rbs

@@ -1,4 +1,6 @@
 module Volcano
+  type upload_status_attribute = String | Integer | Array[UploadPart] | Time
+
   class UploadSessionStatus < Data
     attr_reader session_id: String
     attr_reader status: String
@@ -19,7 +21,7 @@ module Volcano
                | (session_id: String, status: String, path: String, content_type: String, total_size: Integer, part_size: Integer, total_parts: Integer, parts_uploaded: Integer, bytes_uploaded: Integer, parts: Array[UploadPart], expires_at: Time, created_at: Time) -> UploadSessionStatus
     def self.members: () -> [:session_id, :status, :path, :content_type, :total_size, :part_size, :total_parts, :parts_uploaded, :bytes_uploaded, :parts, :expires_at, :created_at]
 
-    def initialize: (session_id: String, status: String, path: String, content_type: String, total_size: Integer, part_size: Integer, total_parts: Integer, parts_uploaded: Integer, bytes_uploaded: Integer, parts: Array[UploadPart], expires_at: Time, created_at: Time) -> void
+    def initialize: (**upload_status_attribute attributes) -> void
     def members: () -> [:session_id, :status, :path, :content_type, :total_size, :part_size, :total_parts, :parts_uploaded, :bytes_uploaded, :parts, :expires_at, :created_at]
     def with: (?session_id: String, ?status: String, ?path: String, ?content_type: String, ?total_size: Integer, ?part_size: Integer, ?total_parts: Integer, ?parts_uploaded: Integer, ?bytes_uploaded: Integer, ?parts: Array[UploadPart], ?expires_at: Time, ?created_at: Time) -> UploadSessionStatus
     def to_h: () -> { session_id: String, status: String, path: String, content_type: String, total_size: Integer, part_size: Integer, total_parts: Integer, parts_uploaded: Integer, bytes_uploaded: Integer, parts: Array[UploadPart], expires_at: Time, created_at: Time }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: volcano-sdk
 version: !ruby/object:Gem::Version
-  version: 0.30.0
+  version: 0.32.0
 platform: ruby
 authors:
 - Kong
@@ -147,6 +147,7 @@ files:
 - lib/volcano/auth_reset_password.rb
 - lib/volcano/auth_reset_password_for_email.rb
 - lib/volcano/auth_session_binding.rb
+- lib/volcano/auth_session_construction.rb
 - lib/volcano/auth_sessions.rb
 - lib/volcano/auth_sign_out.rb
 - lib/volcano/auth_sign_up.rb
@@ -602,13 +603,18 @@ files:
 - lib/volcano/storage.rb
 - lib/volcano/storage_models.rb
 - lib/volcano/storage_mutations.rb
+- lib/volcano/storage_object_response.rb
 - lib/volcano/storage_public_url.rb
+- lib/volcano/storage_response.rb
 - lib/volcano/storage_resumable_upload.rb
+- lib/volcano/storage_session_adapter.rb
+- lib/volcano/storage_transport_adapter.rb
 - lib/volcano/storage_upload_models.rb
 - lib/volcano/storage_upload_sessions.rb
 - lib/volcano/transport.rb
 - lib/volcano/user.rb
 - lib/volcano/version.rb
+- sig/auth_credentials.rbs
 - sig/auth_oauth.rbs
 - sig/auth_profile.rbs
 - sig/auth_session_records.rbs
@@ -623,10 +629,12 @@ files:
 - sig/lock_records.rbs
 - sig/log_responses.rbs
 - sig/oauth_records.rbs
+- sig/realtime.rbs
 - sig/realtime_contexts.rbs
 - sig/realtime_postgres_change.rbs
 - sig/session.rbs
 - sig/sign_up_result.rbs
+- sig/storage.rbs
 - sig/storage_public_url.rbs
 - sig/storage_records.rbs
 - sig/upload_records.rbs