zero-rails-adapter 0.2.0

data/lib/zero_rails_adapter/request.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module ZeroRailsAdapter
+  class Request
+    REQUIRED_KEYS = %w[clientGroupID mutations pushVersion timestamp requestID].freeze
+
+    attr_reader :client_group_id, :mutations, :push_version, :timestamp,
+      :request_id, :schema, :app_id, :body
+
+    def self.parse(body, query:)
+      body = body.to_h.stringify_keys if body.respond_to?(:to_h)
+      query = query.to_h.stringify_keys if query.respond_to?(:to_h)
+      mutation_ids = extract_mutation_ids(body)
+
+      validate_body!(body, mutation_ids:)
+      validate_query!(query, mutation_ids:)
+
+      unless body["pushVersion"] == 1
+        raise UnsupportedPushVersionError.new(body["pushVersion"], mutation_ids:)
+      end
+
+      mutations = body["mutations"].map { |value| Mutation.parse(value) }
+      new(
+        body:,
+        client_group_id: body["clientGroupID"],
+        mutations:,
+        push_version: body["pushVersion"],
+        timestamp: body["timestamp"],
+        request_id: body["requestID"],
+        schema: query["schema"],
+        app_id: query["appID"]
+      )
+    rescue ParseError => error
+      if error.mutation_ids.empty?
+        raise ParseError.new(error.message, mutation_ids:, source: error.source)
+      end
+
+      raise
+    end
+
+    def self.validate_body!(body, mutation_ids:)
+      raise ParseError.new("Push body must be an object", mutation_ids:) unless body.is_a?(Hash)
+
+      missing = REQUIRED_KEYS.reject { |key| body.key?(key) }
+      raise ParseError.new("Push body is missing #{missing.join(', ')}", mutation_ids:) if missing.any?
+      raise ParseError.new("clientGroupID must be a string", mutation_ids:) unless body["clientGroupID"].is_a?(String)
+      raise ParseError.new("mutations must be an array", mutation_ids:) unless body["mutations"].is_a?(Array)
+      raise ParseError.new("pushVersion must be a number", mutation_ids:) unless body["pushVersion"].is_a?(Numeric)
+      raise ParseError.new("timestamp must be a number", mutation_ids:) unless body["timestamp"].is_a?(Numeric)
+      raise ParseError.new("requestID must be a string", mutation_ids:) unless body["requestID"].is_a?(String)
+    end
+    private_class_method :validate_body!
+
+    def self.validate_query!(query, mutation_ids:)
+      unless query.is_a?(Hash) && query["schema"].is_a?(String) && query["appID"].is_a?(String)
+        raise ParseError.new(
+          "Query parameters schema and appID are required",
+          mutation_ids:,
+          source: :query
+        )
+      end
+
+      unless query["schema"].match?(/\A[a-z0-9_]+\z/)
+        raise ParseError.new(
+          "Query parameter schema is invalid",
+          mutation_ids:,
+          source: :query
+        )
+      end
+    end
+    private_class_method :validate_query!
+
+    def self.extract_mutation_ids(body)
+      return [] unless body.is_a?(Hash) && body["mutations"].is_a?(Array)
+
+      body["mutations"].filter_map do |mutation|
+        next unless mutation.is_a?(Hash)
+        next unless mutation["clientID"].is_a?(String) && mutation["id"].is_a?(Numeric)
+
+        {"clientID" => mutation["clientID"], "id" => mutation["id"]}
+      end
+    end
+    private_class_method :extract_mutation_ids
+
+    def initialize(**attributes)
+      attributes.each { |name, value| instance_variable_set(:"@#{name}", value) }
+    end
+
+    def mutation_ids
+      mutations.map(&:identifier)
+    end
+  end
+end

data/lib/zero_rails_adapter/request_verifiers/api_key.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "active_support/security_utils"
+
+module ZeroRailsAdapter
+  module RequestVerifiers
+    class ApiKey
+      def initialize(key:, header: "X-Api-Key")
+        @key = key.to_s
+        @header = header
+      end
+
+      def call(request)
+        candidate = request.headers[@header].to_s
+        return false if @key.empty? || candidate.bytesize != @key.bytesize
+
+        ActiveSupport::SecurityUtils.secure_compare(candidate, @key)
+      end
+    end
+  end
+end

data/lib/zero_rails_adapter/storage/zero_schema.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module ZeroRailsAdapter
+  module Storage
+    class ZeroSchema
+      class << self
+        def model(base_class:, table_name:, primary_key:)
+          key = [base_class, table_name, primary_key]
+          models_mutex.synchronize do
+            models[key] ||= Class.new(base_class) do
+              self.table_name = table_name
+              self.primary_key = primary_key
+              self.inheritance_column = :_zero_rails_adapter_type
+            end
+          end
+        end
+
+        private
+
+        def models
+          @models ||= {}
+        end
+
+        def models_mutex
+          @models_mutex ||= Mutex.new
+        end
+      end
+
+      attr_reader :request, :transaction_class, :client_model,
+        :mutation_result_model
+
+      def initialize(request:, transaction_class:)
+        @request = request
+        @transaction_class = transaction_class
+        @client_model = self.class.model(
+          base_class: transaction_class,
+          table_name: "#{request.schema}.clients",
+          primary_key: %w[clientGroupID clientID]
+        )
+        @mutation_result_model = self.class.model(
+          base_class: transaction_class,
+          table_name: "#{request.schema}.mutations",
+          primary_key: %w[clientGroupID clientID mutationID]
+        )
+      end
+
+      def transaction(&block)
+        transaction_class.transaction(requires_new: true, &block)
+      end
+
+      def increment_lmid!(client_id)
+        attributes = client_identity(client_id)
+        record = client_model.create_or_find_by!(attributes) do |client|
+          client["lastMutationID"] = 1
+        end
+        created = record.previously_new_record?
+        record.lock!
+        record.update!("lastMutationID" => record["lastMutationID"].to_i + 1) unless created
+        record["lastMutationID"].to_i
+      rescue ActiveRecord::RecordNotUnique
+        retry
+      end
+
+      def write_result(client_id:, mutation_id:, result:)
+        mutation_result_model.create!(
+          "clientGroupID" => request.client_group_id,
+          "clientID" => client_id,
+          "mutationID" => mutation_id,
+          "result" => result
+        )
+      end
+
+      def cleanup(args)
+        scope = mutation_result_model.where("clientGroupID" => args["clientGroupID"])
+
+        if args["type"] == "bulk"
+          scope.where("clientID" => Array(args["clientIDs"])).delete_all
+        elsif args["clientID"].is_a?(String) && args["upToMutationID"].is_a?(Numeric)
+          scope.where("clientID" => args["clientID"])
+            .where('"mutationID" <= ?', args["upToMutationID"])
+            .delete_all
+        end
+      end
+
+      private
+
+      def client_identity(client_id)
+        {
+          "clientGroupID" => request.client_group_id,
+          "clientID" => client_id
+        }
+      end
+    end
+  end
+end

data/lib/zero_rails_adapter/type_script/generator.rb

@@ -0,0 +1,421 @@
+# frozen_string_literal: true
+
+module ZeroRailsAdapter
+  module TypeScript
+    class Generator
+      SCHEMA_TYPES = {
+        string: "string()",
+        text: "string()",
+        uuid: "string()",
+        integer: "number()",
+        bigint: "number()",
+        float: "number()",
+        decimal: "number()",
+        boolean: "boolean()",
+        date: "number()",
+        datetime: "number()",
+        timestamp: "number()",
+        time: "number()",
+        json: "json()",
+        jsonb: "json()"
+      }.freeze
+
+      ZOD_TYPES = {
+        string: "z.string()",
+        text: "z.string()",
+        uuid: "z.string().uuid()",
+        integer: "z.number()",
+        bigint: "z.number()",
+        float: "z.number()",
+        decimal: "z.number()",
+        boolean: "z.boolean()",
+        date: "z.number()",
+        datetime: "z.number()",
+        timestamp: "z.number()",
+        time: "z.number()",
+        json: "z.json()",
+        jsonb: "z.json()"
+      }.freeze
+
+      attr_reader :models
+
+      def initialize(models: nil)
+        @models = Array(models || ZeroRailsAdapter.configuration.model_provider.call)
+          .select { |model| active_record_model?(model) }
+          .uniq
+          .sort_by(&:table_name)
+      end
+
+      def schema
+        sections = [
+          "import {#{schema_imports.join(', ')}} from '@rocicorp/zero'",
+          table_definitions,
+          relationship_definitions,
+          schema_export
+        ]
+
+        sections.reject(&:empty?).join("\n\n") << "\n"
+      end
+
+      def mutators
+        sections = [
+          "import {defineMutator, defineMutators} from '@rocicorp/zero'\nimport {z} from 'zod'",
+          argument_schemas,
+          mutator_export
+        ]
+
+        sections.reject(&:empty?).join("\n\n") << "\n"
+      end
+
+      private
+
+      def active_record_model?(model)
+        model.is_a?(Class) && model < ActiveRecord::Base && !model.abstract_class?
+      end
+
+      def table_definitions
+        models.map do |model|
+          columns = model.columns.map do |column|
+            "    #{property_name(column.name)}: #{zero_type(model, column)},"
+          end.join("\n")
+          keys = primary_keys(model).map { |key| quote(key) }.join(", ")
+
+          <<~TYPESCRIPT.chomp
+            const #{variable_name(model)} = table(#{quote(model.table_name)})
+              .columns({
+            #{columns}
+              })
+              .primaryKey(#{keys})
+          TYPESCRIPT
+        end.join("\n\n")
+      end
+
+      def relationship_definitions
+        relationships.group_by(&:first).map do |model, definitions|
+          kinds = definitions.map do |_source, reflection, _destination|
+            reflection.collection? ? "many" : "one"
+          end.uniq.sort.join(", ")
+          entries = definitions.map do |_source, reflection, destination|
+            source_fields, destination_fields =
+              relationship_fields(model, reflection, destination)
+            kind = reflection.collection? ? "many" : "one"
+
+            [
+              "#{property_name(reflection.name)}: #{kind}({",
+              "  sourceField: [#{source_fields.map { |field| quote(field) }.join(', ')}],",
+              "  destSchema: #{variable_name(destination)},",
+              "  destField: [#{destination_fields.map { |field| quote(field) }.join(', ')}],",
+              "}),"
+            ].join("\n")
+          end.join("\n")
+
+          [
+            "const #{relationship_variable_name(model)} = relationships(#{variable_name(model)}, ({#{kinds}}) => ({",
+            indent(entries, 2),
+            "}))"
+          ].join("\n")
+        end.join("\n\n")
+      end
+
+      def schema_export
+        table_vars = models.map { |model| variable_name(model) }.join(", ")
+        relation_vars = relationships.map(&:first).uniq.map do |model|
+          relationship_variable_name(model)
+        end.join(", ")
+
+        lines = ["export const schema = createSchema({", "  tables: [#{table_vars}],"]
+        lines << "  relationships: [#{relation_vars}]," unless relation_vars.empty?
+        lines.concat([
+          "})",
+          "",
+          "export type Schema = typeof schema",
+          "",
+          "declare module '@rocicorp/zero' {",
+          "  interface DefaultTypes {",
+          "    schema: Schema",
+          "  }",
+          "}"
+        ])
+        lines.join("\n")
+      end
+
+      def argument_schemas
+        models.flat_map do |model|
+          [
+            zod_schema(model, :create),
+            zod_schema(model, :update),
+            zod_schema(model, :destroy)
+          ]
+        end.join("\n\n")
+      end
+
+      def zod_schema(model, action)
+        columns = mutation_columns(model, action).map do |column|
+          "  #{property_name(column.name)}: #{zod_type(model, column, action)},"
+        end.join("\n")
+
+        <<~TYPESCRIPT.chomp
+          const #{variable_name(model)}#{action.to_s.camelize}Args = z.object({
+          #{columns}
+          })
+        TYPESCRIPT
+      end
+
+      def mutator_export
+        tables = models.map do |model|
+          variable = variable_name(model)
+          table = property_name(model.table_name)
+          create_values = create_insert_values(model)
+          update_values = update_insert_values(model)
+
+          [
+            "#{table}: {",
+            "  create: defineMutator(#{variable}CreateArgs, async ({tx, args}) => {",
+            "    const now = Date.now()",
+            "    await tx.mutate.#{table}.insert(#{create_values})",
+            "  }),",
+            "  update: defineMutator(#{variable}UpdateArgs, async ({tx, args}) => {",
+            "    await tx.mutate.#{table}.update(#{update_values})",
+            "  }),",
+            "  destroy: defineMutator(#{variable}DestroyArgs, async ({tx, args}) => {",
+            "    await tx.mutate.#{table}.delete(args)",
+            "  }),",
+            "},"
+          ].join("\n")
+        end.join("\n")
+
+        [
+          "export const mutators = defineMutators({",
+          indent(tables, 2),
+          "})"
+        ].join("\n")
+      end
+
+      def create_insert_values(model)
+        additions = []
+        additions << "created_at: now" if model.column_names.include?("created_at")
+        additions << "updated_at: now" if model.column_names.include?("updated_at")
+        defaulted_columns(model).each do |column|
+          value = if generated_attribute_names(model, :create).include?(column.name)
+            "args.#{property_name(column.name)} ?? #{typescript_default(column)}"
+          else
+            typescript_default(column)
+          end
+          additions << "#{property_name(column.name)}: #{value}"
+        end
+        object_with_additions(additions)
+      end
+
+      def update_insert_values(model)
+        additions = []
+        additions << "updated_at: Date.now()" if model.column_names.include?("updated_at")
+        object_with_additions(additions)
+      end
+
+      def object_with_additions(additions)
+        return "args" if additions.empty?
+
+        "{...args, #{additions.join(', ')}}"
+      end
+
+      def mutation_columns(model, action)
+        primary = primary_keys(model)
+        case action
+        when :create
+          allowed = generated_attribute_names(model, action)
+          model.columns.select do |column|
+            !timestamp_column?(column) &&
+              (primary.include?(column.name) || allowed.include?(column.name))
+          end
+        when :update
+          allowed = generated_attribute_names(model, action)
+          model.columns.select do |column|
+            primary.include?(column.name) ||
+              (!timestamp_column?(column) && allowed.include?(column.name))
+          end
+        when :destroy
+          model.columns.select { |column| primary.include?(column.name) }
+        end
+      end
+
+      def generated_attribute_names(model, action)
+        Array(
+          ZeroRailsAdapter.configuration.generated_attributes.call(model, action)
+        ).map(&:to_s)
+      end
+
+      def timestamp_column?(column)
+        %w[created_at updated_at].include?(column.name)
+      end
+
+      def defaulted_columns(model)
+        primary = primary_keys(model)
+        model.columns.select do |column|
+          !primary.include?(column.name) &&
+            !timestamp_column?(column) &&
+            !column.null &&
+            !column.default.nil?
+        end
+      end
+
+      def zero_type(model, column)
+        if column.respond_to?(:array) && column.array
+          type = "json<readonly #{typescript_scalar(column)}[]>()"
+          return column.null ? "#{type}.optional()" : type
+        end
+
+        type = enum_values(model, column)&.then do |values|
+          "enumeration<#{values.map { |value| quote(value) }.join(' | ')}>()"
+        end
+        type ||= mapped_type(SCHEMA_TYPES, model, column)
+        type += ".optional()" if column.null
+        type
+      end
+
+      def zod_type(model, column, action)
+        values = enum_values(model, column)
+        type = if column.respond_to?(:array) && column.array
+          "z.array(#{mapped_type(ZOD_TYPES, model, column)})"
+        elsif values
+          "z.enum([#{values.map { |value| quote(value) }.join(', ')}])"
+        else
+          mapped_type(ZOD_TYPES, model, column)
+        end
+
+        if column.null
+          "#{type}.nullish()"
+        elsif action == :update && !primary_keys(model).include?(column.name)
+          "#{type}.optional()"
+        elsif action == :create && !column.default.nil?
+          "#{type}.optional()"
+        else
+          type
+        end
+      end
+
+      def mapped_type(mapping, model, column)
+        mapping.fetch(column.type.to_sym) do
+          raise UnsupportedColumnTypeError,
+            "Cannot generate Zero TypeScript for #{model.name}.#{column.name} (#{column.type})"
+        end
+      end
+
+      def enum_values(model, column)
+        definition = model.defined_enums[column.name]
+        definition&.keys
+      end
+
+      def schema_imports
+        imports = %w[createSchema table]
+        imports << "relationships" if relationships.any?
+        imports << "enumeration" if models.any? { |model| model.defined_enums.any? }
+        models.each do |model|
+          model.columns.each do |column|
+            imports << if enum_values(model, column)
+              "enumeration"
+            elsif column.respond_to?(:array) && column.array
+              "json"
+            else
+              mapped_type(SCHEMA_TYPES, model, column).delete_suffix("()")
+            end
+          end
+        end
+        imports.uniq.sort
+      end
+
+      def typescript_scalar(column)
+        case column.type.to_sym
+        when :string, :text, :uuid then "string"
+        when :integer, :bigint, :float, :decimal, :date, :datetime, :timestamp, :time
+          "number"
+        when :boolean then "boolean"
+        else "unknown"
+        end
+      end
+
+      def relationships
+        @relationships ||= models.flat_map do |model|
+          model.reflect_on_all_associations.filter_map do |reflection|
+            next if reflection.polymorphic? || reflection.options[:through]
+
+            destination = reflection.klass
+            [model, reflection, destination] if models.include?(destination)
+          rescue NameError
+            nil
+          end
+        end
+      end
+
+      def relationship_fields(model, reflection, destination)
+        if reflection.belongs_to?
+          [
+            Array(reflection.foreign_key).map(&:to_s),
+            association_primary_keys(reflection, destination)
+          ]
+        else
+          [
+            association_primary_keys(reflection, model),
+            Array(reflection.foreign_key).map(&:to_s)
+          ]
+        end
+      end
+
+      def association_primary_keys(reflection, model)
+        configured = reflection.options[:primary_key]
+        Array(configured || model.primary_key).map(&:to_s)
+      end
+
+      def primary_keys(model)
+        keys = Array(model.primary_key).compact.map(&:to_s)
+        return keys if keys.any?
+
+        raise UnsupportedColumnTypeError, "#{model.name} has no primary key"
+      end
+
+      def relationship_variable_name(model)
+        "#{variable_name(model)}Relationships"
+      end
+
+      def variable_name(model)
+        model.table_name.gsub(/[^a-zA-Z0-9_]/, "_").camelize(:lower)
+      end
+
+      def property_name(value)
+        string = value.to_s
+        string.match?(/\A[$A-Z_a-z][$\w]*\z/) ? string : quote(string)
+      end
+
+      def quote(value)
+        "'#{value.to_s.gsub('\\', '\\\\\\\\').gsub("'", "\\\\'")}'"
+      end
+
+      def typescript_literal(value)
+        case value
+        when String then quote(value)
+        when Numeric then value.to_s
+        when true then "true"
+        when false then "false"
+        else
+          raise UnsupportedColumnTypeError, "Cannot serialize database default #{value.inspect}"
+        end
+      end
+
+      def typescript_default(column)
+        value = column.default
+        case column.type.to_sym
+        when :boolean
+          ActiveModel::Type::Boolean.new.cast(value) ? "true" : "false"
+        when :integer, :bigint, :float, :decimal
+          value.to_s
+        else
+          typescript_literal(value)
+        end
+      end
+
+      def indent(value, spaces)
+        prefix = " " * spaces
+        value.lines.map { |line| "#{prefix}#{line}" }.join.chomp
+      end
+    end
+  end
+end

data/lib/zero_rails_adapter/version.rb

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

data/lib/zero_rails_adapter.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "rails"
+require "active_record"
+require "active_model"
+require "active_support"
+require "active_support/core_ext/hash/keys"
+require "active_support/core_ext/string/inflections"
+require_relative "zero_rails_adapter/version"
+require_relative "zero_rails_adapter/errors"
+require_relative "zero_rails_adapter/identity"
+require_relative "zero_rails_adapter/context"
+require_relative "zero_rails_adapter/configuration"
+require_relative "zero_rails_adapter/request_verifiers/api_key"
+require_relative "zero_rails_adapter/registry"
+require_relative "zero_rails_adapter/mutator"
+require_relative "zero_rails_adapter/mutation"
+require_relative "zero_rails_adapter/request"
+require_relative "zero_rails_adapter/crud/dispatcher"
+require_relative "zero_rails_adapter/type_script/generator"
+require_relative "zero_rails_adapter/storage/zero_schema"
+require_relative "zero_rails_adapter/processor"
+require_relative "zero_rails_adapter/engine"
+
+module ZeroRailsAdapter
+  class << self
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield configuration
+    end
+
+    def reset_configuration!
+      @configuration = Configuration.new
+    end
+
+    def registry
+      @registry ||= Registry.new
+    end
+
+    def define_mutator(name, superclass: Mutator, &definition)
+      Class.new(superclass).tap do |mutator_class|
+        mutator_class.mutation_name(name)
+        mutator_class.class_eval(&definition)
+      end
+    end
+  end
+end