ruby-object-framework 1.0.0

data/lib/object_framework/sqlite/schema.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ObjectFramework
+  module SQLite
+    ForeignKey = Data.define(:table, :column, :target)
+    Migration = Data.define(:version, :actions)
+
+    class Schema
+      TYPES = { string: "TEXT", integer: "INTEGER", float: "REAL", boolean: "INTEGER", blob: "BLOB" }.freeze
+      attr_reader :tables, :foreign_keys, :migrations
+
+      def self.from_mappings(mappings)
+        mappings.validate!
+        keys = mappings.flat_map do |mapping|
+          mapping.associations.select { |item| item.kind == :belongs_to }.map do |association|
+            ForeignKey.new(table: mapping.table, column: association.foreign_key, target: mappings.fetch(association.target).table)
+          end
+        end
+        new(tables: mappings.to_h { |mapping| [mapping.table, mapping.schema] }, foreign_keys: keys)
+      end
+
+      def initialize(tables:, foreign_keys: [])
+        @tables = tables.to_h do |name, columns|
+          fields = columns.to_h { |column, type| [identifier(column), validate_type(type)] }
+          raise ConfigurationError, "SQLite tables require a string id" unless fields[:id] == :string
+          [identifier(name), fields]
+        end
+        @foreign_keys = foreign_keys.dup.freeze
+        @initial_tables = @tables.transform_values { |columns| columns.dup.freeze }.freeze
+        @migrations = [Migration.new(version: 1, actions: [].freeze)]
+      end
+
+      def migration(version, &declaration)
+        raise ConfigurationError, "Schema is finalized" if frozen?
+        raise ConfigurationError, "Migration versions must be consecutive" unless version == @migrations.last.version + 1
+        editor = Editor.new(self)
+        editor.instance_eval(&declaration)
+        @migrations << Migration.new(version:, actions: editor.actions.each(&:freeze).freeze)
+        self
+      end
+
+      def version; @migrations.last.version; end
+
+      def table(name)
+        @tables.fetch(identifier(name)) { raise ConfigurationError, "Unregistered SQLite table" }
+      end
+
+      def type(table_name, column)
+        table(table_name).fetch(identifier(column)) { raise ConfigurationError, "Unregistered SQLite column" }
+      end
+
+      def quote(name); '"' + identifier(name).to_s + '"'; end
+      def identifier(name); Persistence::Query.identifier(name); end
+
+      def validate_type(type)
+        raise ConfigurationError, "Unknown SQLite field type" unless TYPES.key?(type)
+        type
+      end
+
+      def finalize!
+        return self if frozen?
+        foreign_keys.each { |key| type(key.table, key.column); type(key.target, :id) }
+        @tables.each_value(&:freeze)
+        @tables.freeze
+        @migrations.freeze
+        freeze
+      end
+
+      def create_statements
+        @initial_tables.map do |name, columns|
+          fields = columns.map do |column, type|
+            "#{quote(column)} #{TYPES.fetch(type)}#{column == :id ? ' PRIMARY KEY NOT NULL' : ''}"
+          end
+          foreign_keys.select { |key| key.table == name }.each do |key|
+            fields << "FOREIGN KEY (#{quote(key.column)}) REFERENCES #{quote(key.target)} (\"id\") DEFERRABLE INITIALLY DEFERRED"
+          end
+          "CREATE TABLE #{quote(name)} (#{fields.join(', ')}) STRICT"
+        end
+      end
+
+      class Editor
+        attr_reader :actions
+        def initialize(schema); @schema, @actions = schema, []; end
+
+        def add_column(table, column, type: :string)
+          table, column = @schema.identifier(table), @schema.identifier(column)
+          fields = @schema.table(table)
+          raise ConfigurationError, "Column already exists" if fields.key?(column)
+          fields[column] = @schema.validate_type(type)
+          @actions << "ALTER TABLE #{@schema.quote(table)} ADD COLUMN #{@schema.quote(column)} #{TYPES.fetch(type)}"
+        end
+      end
+    end
+  end
+end

data/lib/object_framework/sqlite/storage.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module ObjectFramework
+  module SQLite
+    module ErrorTranslation
+      def self.raise_translated(error)
+        code = error.code
+        type = case code
+        when 1555, 2067 then Duplicate
+        when 517 then Conflict
+        when 787, 1299, 275, 3091 then InvalidInput
+        else
+          case code & 255
+          when 5, 6, 10, 13, 14 then Unavailable
+          when 19, 20, 18 then InvalidInput
+          else nil
+          end
+        end
+        raise(type.new("SQLite operation failed"), cause: error) if type
+        raise error
+      end
+    end
+
+    class Storage
+      attr_reader :schema_version
+
+      def initialize(path:, schema:, lock_timeout: 1)
+        raise ConfigurationError, "SQLite requires a database file path" if path.to_s.empty? || path.to_s == ":memory:"
+        raise ConfigurationError, "Lock timeout must be positive" unless lock_timeout.is_a?(Numeric) && lock_timeout.positive?
+        @path, @schema, @lock_timeout = File.expand_path(path), schema.finalize!, lock_timeout
+        @mutex, @connections, @closed = Mutex.new, 0, false
+        migrate
+      end
+
+      def open_connection_count; @mutex.synchronize { @connections }; end
+
+      def begin_transaction(mode:)
+        begin_transaction_for(mode:, context: ExecutionContext.new)
+      end
+
+      def begin_transaction_for(mode:, context:)
+        @mutex.synchronize { raise Unavailable, "Storage is closed" if @closed }
+        context.cancellation.check!
+        database = connect(cancellation: context.cancellation)
+        Transaction.new(database:, schema: @schema, mode:, cancellation: context.cancellation,
+          closed: -> { disconnected })
+      rescue Exception
+        if database && !database.closed?
+          database.close
+          disconnected
+        end
+        raise
+      end
+
+      def close
+        @mutex.synchronize { @closed = true }
+      end
+
+      private
+
+      def connect(cancellation: Cancellation.new)
+        database = ::SQLite3::Database.new(@path, results_as_hash: true)
+        @mutex.synchronize { @connections += 1 }
+        database.extended_result_codes = true
+        lock_started = nil
+        database.busy_handler do |count|
+          cancellation.check!
+          lock_started = monotonic if count.zero? || lock_started.nil?
+          remaining = @lock_timeout - (monotonic - lock_started)
+          if remaining.positive?
+            sleep [remaining, 0.005].min
+            true
+          else
+            false
+          end
+        end
+        database.execute("PRAGMA foreign_keys = ON")
+        database.execute("PRAGMA synchronous = FULL")
+        database
+      rescue Exception => error
+        if database
+          database.close unless database.closed?
+          disconnected
+        end
+        ErrorTranslation.raise_translated(error) if error.is_a?(::SQLite3::Exception)
+        raise
+      end
+
+      def disconnected
+        @mutex.synchronize { @connections -= 1 }
+      end
+
+      def migrate
+        database = connect
+        database.execute("PRAGMA journal_mode = DELETE")
+        database.execute("BEGIN IMMEDIATE")
+        current = database.get_first_value("PRAGMA user_version")
+        raise ConfigurationError, "Database schema is newer than the application" if current > @schema.version
+        @schema.migrations.each do |migration|
+          next if migration.version <= current
+          statements = migration.version == 1 ? @schema.create_statements : migration.actions
+          statements.each { |statement| database.execute(statement) }
+          database.execute("PRAGMA user_version = #{migration.version}")
+        end
+        validate_schema(database)
+        database.execute("COMMIT")
+        @schema_version = @schema.version
+      rescue ::SQLite3::Exception => error
+        ErrorTranslation.raise_translated(error)
+      ensure
+        if database
+          database.close
+          disconnected
+        end
+      end
+
+      def monotonic
+        Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      end
+
+      def validate_schema(database)
+        @schema.tables.each do |name, columns|
+          actual = database.execute("PRAGMA table_info(#{@schema.quote(name)})").to_h { |row| [row.fetch("name"), row.fetch("type")] }
+          expected = columns.to_h { |column, type| [column.to_s, Schema::TYPES.fetch(type)] }
+          raise ConfigurationError, "SQLite schema does not match its declared version" unless actual == expected
+        end
+      end
+    end
+
+    class Transaction < Persistence::Transaction
+      def initialize(database:, schema:, mode:, cancellation:, closed:)
+        super(mode:)
+        @database, @schema, @cancellation, @closed_callback = database, schema, cancellation, closed
+        @compiler = Compiler.new(schema:)
+        execute(mode == :write ? "BEGIN IMMEDIATE" : "BEGIN DEFERRED")
+        @database.execute("PRAGMA query_only = ON") if mode == :read
+      end
+
+      def configuration
+        active!
+        %i[foreign_keys journal_mode synchronous].to_h { |name| [name, @database.get_first_value("PRAGMA #{name}")] }
+      end
+
+      def find(table, id)
+        query(Persistence::Query.new(table:).where(id:).limit(1)).first
+      end
+
+      def query(query)
+        active!
+        sql, bindings = @compiler.query(query)
+        execute(sql, bindings).map { |row| @compiler.decode(query.table, row) }
+      end
+
+      def insert(table, row)
+        writable!
+        value = row_value(row)
+        @schema.table(table)
+        columns = value.keys
+        bindings = columns.map { |column| @compiler.encode(table, column, value[column]) }
+        execute("INSERT INTO #{@schema.quote(table)} (#{columns.map { |column| @schema.quote(column) }.join(', ')}) VALUES (#{(['?'] * columns.size).join(', ')})", bindings)
+        value[:id]
+      end
+
+      def update(table, id, row)
+        writable!
+        value = row_value(row, id:)
+        @schema.table(table)
+        columns = @schema.table(table).keys - [:id]
+        if columns.empty?
+          raise NotFound, "Unknown identity" unless find(table, id)
+          return
+        end
+        values = columns.map { |column| @compiler.encode(table, column, value[column]) }
+        sql = "UPDATE #{@schema.quote(table)} SET #{columns.map { |column| "#{@schema.quote(column)} = ?" }.join(', ')} WHERE \"id\" = ?"
+        execute(sql, values + [id])
+        raise NotFound, "Unknown identity" if @database.changes.zero?
+      end
+
+      def delete(table, id)
+        writable!
+        @schema.table(table)
+        execute("DELETE FROM #{@schema.quote(table)} WHERE \"id\" = ?", [id])
+        raise NotFound, "Unknown identity" if @database.changes.zero?
+      end
+
+      def commit
+        active!
+        begin
+          execute("COMMIT")
+          @state = :committed
+        rescue StandardError
+          @state = :indeterminate unless @database.transaction_active?
+          raise
+        end
+      end
+
+      private
+
+      def execute(sql, bindings = [])
+        @cancellation.check!
+        @database.execute(sql, bindings)
+      rescue ::SQLite3::Exception => error
+        ErrorTranslation.raise_translated(error)
+      end
+
+      def rollback_storage
+        # Cleanup must remain possible after deadline expiry or cancellation.
+        @database.execute("ROLLBACK")
+      rescue ::SQLite3::Exception => error
+        ErrorTranslation.raise_translated(error)
+      end
+
+      def close_storage
+        @database.close
+      ensure
+        @closed_callback.call
+      end
+    end
+  end
+end

data/lib/object_framework/sqlite.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require "sqlite3"
+require_relative "sqlite/schema"
+require_relative "sqlite/compiler"
+require_relative "sqlite/storage"

data/lib/object_framework/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module ObjectFramework
+  VERSION = "1.0.0"
+end

data/lib/object_framework.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "thread"
+require_relative "object_framework/version"
+require_relative "object_framework/errors"
+require_relative "object_framework/execution"
+require_relative "object_framework/application"
+require_relative "object_framework/persistence/query"
+require_relative "object_framework/persistence/transaction"
+require_relative "object_framework/persistence/mapping"
+require_relative "object_framework/persistence/session"
+require_relative "object_framework/memory/storage"
+require_relative "object_framework/http/protocol"
+require_relative "object_framework/http/router"
+require_relative "object_framework/http/presentation"
+require_relative "object_framework/http/io"
+require_relative "object_framework/http/server"
+require_relative "object_framework/protobuf"
+require_relative "object_framework/grpc/service"
+require_relative "object_framework/http2/hpack"
+require_relative "object_framework/http2/frame"
+require_relative "object_framework/http2/inbound"
+require_relative "object_framework/grpc/messages"
+require_relative "object_framework/http2/connection"
+require_relative "object_framework/grpc/server"
+
+module ObjectFramework
+  autoload :SQLite, File.expand_path("object_framework/sqlite", __dir__)
+  autoload :Capabilities, File.expand_path("object_framework/capabilities", __dir__)
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: ruby-object-framework
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Gastón Caruso
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Explicit application composition, scoped execution, Data Mapper persistence,
+  HTTP and native gRPC, with an optional SQLite adapter.
+email:
+- gstn.caruso@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- API.md
+- README.md
+files:
+- API.md
+- README.md
+- THIRD_PARTY_NOTICES.md
+- examples/guides/01_plain_use_case.rb
+- examples/guides/02_composed_application.rb
+- examples/guides/03_order_domain.rb
+- examples/guides/04_scoped_resources.rb
+- examples/guides/05_mapping.rb
+- examples/guides/06_associations.rb
+- examples/guides/07_http.rb
+- examples/guides/08_errors.rb
+- examples/guides/09_sqlite.rb
+- examples/guides/10_grpc.rb
+- examples/guides/11_ractor.rb
+- examples/guides/12_box.rb
+- examples/guides/13_testing.rb
+- examples/guides/manifest.yml
+- examples/orders/application.rb
+- examples/orders/contracts.rb
+- examples/orders/domain.rb
+- examples/orders/export_proto.rb
+- examples/orders/grpc_client.py
+- examples/orders/grpc_server.rb
+- examples/orders/server.rb
+- lib/object_framework.rb
+- lib/object_framework/application.rb
+- lib/object_framework/capabilities.rb
+- lib/object_framework/errors.rb
+- lib/object_framework/execution.rb
+- lib/object_framework/grpc/messages.rb
+- lib/object_framework/grpc/server.rb
+- lib/object_framework/grpc/service.rb
+- lib/object_framework/http/io.rb
+- lib/object_framework/http/presentation.rb
+- lib/object_framework/http/protocol.rb
+- lib/object_framework/http/router.rb
+- lib/object_framework/http/server.rb
+- lib/object_framework/http2/connection.rb
+- lib/object_framework/http2/frame.rb
+- lib/object_framework/http2/hpack.rb
+- lib/object_framework/http2/hpack_tables.rb
+- lib/object_framework/http2/inbound.rb
+- lib/object_framework/memory/storage.rb
+- lib/object_framework/persistence/mapping.rb
+- lib/object_framework/persistence/query.rb
+- lib/object_framework/persistence/session.rb
+- lib/object_framework/persistence/transaction.rb
+- lib/object_framework/protobuf.rb
+- lib/object_framework/sqlite.rb
+- lib/object_framework/sqlite/compiler.rb
+- lib/object_framework/sqlite/schema.rb
+- lib/object_framework/sqlite/storage.rb
+- lib/object_framework/version.rb
+homepage: https://github.com/gstn-caruso/ruby-object-framework
+licenses:
+- Nonstandard
+metadata:
+  source_code_uri: https://github.com/gstn-caruso/ruby-object-framework
+  documentation_uri: https://gstn-caruso.github.io/ruby-object-framework/
+  changelog_uri: https://github.com/gstn-caruso/ruby-object-framework/releases
+  allowed_push_host: https://rubygems.org
+  rubygems_mfa_required: 'true'
+rdoc_options:
+- "--main"
+- API.md
+- "--visibility"
+- public
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: 4.0.8
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.20
+specification_version: 4
+summary: A modular Ruby framework built from collaborating objects
+test_files: []