zero-rails-adapter 0.2.0 → 0.3.1

data/lib/zero_rails_adapter/crud/dispatcher.rb

@@ -68,7 +68,8 @@ module ZeroRailsAdapter
       def update(model, attributes)
         record = find_record!(model, attributes)
         authorize!(:update, record, attributes)
-        changes = writable(model, :update, attributes).except(*primary_keys(model))
+        immutable_keys = zero_keys(model) + Array(model.primary_key).compact.map(&:to_s)
+        changes = writable(model, :update, attributes).except(*immutable_keys)
         record.update!(changes)
         nil
       end
@@ -81,21 +82,26 @@ module ZeroRailsAdapter
       end
 
       def find_record!(model, attributes)
-        keys = primary_keys(model)
+        keys = zero_keys(model)
         values = attributes.slice(*keys)
         missing = keys - values.keys
         if missing.any?
           raise ValidationError.new(
-            "Missing primary key attributes: #{missing.join(', ')}",
-            details: {"primaryKey" => missing}
+            "Missing Zero key attributes: #{missing.join(', ')}",
+            details: {"zeroKey" => missing}
           )
         end
 
         model.find_by!(values)
       end
 
-      def primary_keys(model)
-        Array(model.primary_key).map(&:to_s)
+      def zero_keys(model)
+        keys = Array(
+          ZeroRailsAdapter.configuration.zero_key.call(model)
+        ).compact.map(&:to_s)
+        return keys if keys.any?
+
+        raise ValidationError, "#{model.name} must define at least one Zero key"
       end
 
       def authorize!(action, target, attributes)

data/lib/zero_rails_adapter/errors.rb

@@ -17,6 +17,8 @@ module ZeroRailsAdapter
   class UnauthorizedError < Error; end
   class UnknownMutatorError < ApplicationError; end
   class UnsupportedColumnTypeError < Error; end
+  class UnsafePublicationError < Error; end
+  class InvalidRelationshipError < Error; end
 
   class ProtocolError < Error
     attr_reader :mutation_ids

data/lib/zero_rails_adapter/mutator.rb

@@ -61,7 +61,9 @@ module ZeroRailsAdapter
 
     def authorize!
       callback = self.class.authorization_callback
-      return true unless callback
+      unless callback
+        raise ForbiddenError, "Mutator authorization is not configured"
+      end
       return true if instance_exec(context, &callback)
 
       raise ForbiddenError, "Mutation is not authorized"

data/lib/zero_rails_adapter/postgresql/publication_generator.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ZeroRailsAdapter
+  module PostgreSQL
+    class PublicationGenerator
+      DEFAULT_NAME = "zero_data"
+
+      def initialize(name: DEFAULT_NAME, published_schema: nil)
+        @name = name.to_s
+        @published_schema = PublishedSchema.new(
+          published_schema || ZeroRailsAdapter.configuration.published_schema.call,
+          zero_key: ZeroRailsAdapter.configuration.zero_key
+        )
+      end
+
+      def sql
+        entries = @published_schema.models.map do |model|
+          connection = model.connection
+          quoted_columns = @published_schema.column_names_for(model).map do |column|
+            connection.quote_column_name(column)
+          end
+
+          "#{connection.quote_table_name(model.table_name)} (#{quoted_columns.join(', ')})"
+        end
+
+        raise UnsafePublicationError, "Published schema must include at least one table" if entries.empty?
+
+        connection = @published_schema.models.first.connection
+        <<~SQL
+          CREATE PUBLICATION #{connection.quote_column_name(@name)} FOR TABLE
+            #{entries.join(",\n  ")};
+        SQL
+      end
+    end
+  end
+end

data/lib/zero_rails_adapter/processor.rb

@@ -3,6 +3,16 @@
 module ZeroRailsAdapter
   class Processor
     CLEANUP_MUTATION_NAME = "_zero_cleanupResults"
+    DATABASE_ERROR_MESSAGE = "Database error"
+    INTERNAL_ERROR_MESSAGE = "Internal server error"
+    PERSISTABLE_MUTATION_ERRORS = [
+      ActiveModel::UnknownAttributeError,
+      ActiveModel::ValidationError,
+      ActiveRecord::RecordInvalid,
+      ActiveRecord::RecordNotDestroyed,
+      ActiveRecord::RecordNotFound,
+      ActiveRecord::RecordNotSaved
+    ].freeze
 
     attr_reader :request, :context, :storage
 
@@ -47,16 +57,20 @@ module ZeroRailsAdapter
         mutation_ids: request.mutation_ids.drop(processed_count)
       )
     rescue ActiveRecord::ActiveRecordError => error
+      mutation_ids = request.mutation_ids.drop(processed_count)
+      log_push_failure(error, reason: "database", mutation_ids:)
       push_failed(
         reason: "database",
-        message: error.message,
-        mutation_ids: request.mutation_ids.drop(processed_count)
+        message: DATABASE_ERROR_MESSAGE,
+        mutation_ids:
       )
     rescue StandardError => error
+      mutation_ids = request.mutation_ids.drop(processed_count)
+      log_push_failure(error, reason: "internal", mutation_ids:)
       push_failed(
         reason: "internal",
-        message: error.message,
-        mutation_ids: request.mutation_ids.drop(processed_count)
+        message: INTERNAL_ERROR_MESSAGE,
+        mutation_ids:
       )
     end
 
@@ -84,7 +98,7 @@ module ZeroRailsAdapter
       already_processed_response(mutation, error)
     rescue OutOfOrderMutationError
       raise
-    rescue StandardError => error
+    rescue ApplicationError, *PERSISTABLE_MUTATION_ERRORS => error
       application_error = normalize_application_error(error)
       begin
         persist_failure(mutation, application_error)
@@ -138,8 +152,10 @@ module ZeroRailsAdapter
     def normalize_application_error(error)
       return error if error.is_a?(ApplicationError)
 
-      if error.respond_to?(:record) && error.record.respond_to?(:errors)
-        return ApplicationError.new(error.message, details: error.record.errors.to_hash)
+      model = error.record if error.respond_to?(:record)
+      model ||= error.model if error.respond_to?(:model)
+      if model.respond_to?(:errors)
+        return ApplicationError.new(error.message, details: model.errors.to_hash)
       end
 
       ApplicationError.new(error.message)
@@ -174,5 +190,17 @@ module ZeroRailsAdapter
         "mutationIDs" => mutation_ids
       }
     end
+
+    def log_push_failure(error, reason:, mutation_ids:)
+      ZeroRailsAdapter.configuration.logger&.error(
+        "ZeroRailsAdapter push failed: " \
+        "reason=#{reason} request_id=#{request.request_id.inspect} " \
+        "mutation_ids=#{mutation_ids.inspect} " \
+        "#{error.class}: #{error.message}\n" \
+        "#{Array(error.backtrace).join("\n")}"
+      )
+    rescue StandardError
+      nil
+    end
   end
 end

data/lib/zero_rails_adapter/published_schema.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module ZeroRailsAdapter
+  class PublishedSchema
+    SUPPORTED_COLUMN_TYPES = %i[
+      bigint boolean date datetime decimal enum float integer json jsonb
+      string text time timestamp uuid
+    ].freeze
+    FORBIDDEN_COLUMN_NAMES = %w[
+      access_token api_key api_key_digest device_token key_digest
+      password password_digest password_hash refresh_token secret secret_key
+      token token_digest
+    ].freeze
+    FORBIDDEN_TABLE_PREFIXES = %w[
+      action_mailbox_ active_storage_
+    ].freeze
+    FORBIDDEN_TABLE_NAMES = %w[
+      user_login_change_keys user_lockouts user_password_reset_keys
+      user_previous_password_hashes user_recovery_codes user_remember_keys
+      user_verification_keys
+    ].freeze
+
+    attr_reader :models
+
+    def initialize(mapping, zero_key: ZeroRailsAdapter.configuration.zero_key)
+      value = mapping.respond_to?(:call) ? mapping.call : mapping
+      unless value.respond_to?(:to_h)
+        raise UnsafePublicationError,
+          "Published schema must be a model-to-columns mapping"
+      end
+
+      @zero_key = zero_key
+      @columns_by_model = value.to_h.each_with_object({}) do |(model, names), result|
+        validate_model!(model)
+        result[model] = validate_columns!(model, names)
+      end
+      @models = @columns_by_model.keys.freeze
+    end
+
+    def empty?
+      models.empty?
+    end
+
+    def column_names_for(model)
+      columns_for(model).map(&:name)
+    end
+
+    def columns_for(model)
+      @columns_by_model.fetch(model)
+    end
+
+    def zero_keys_for(model)
+      keys = Array(@zero_key.call(model)).compact.map(&:to_s)
+      return keys.freeze if keys.any?
+
+      label = model.name.presence || model.table_name
+      raise UnsafePublicationError, "#{label} must define at least one Zero key"
+    end
+
+    private
+
+    def validate_model!(model)
+      unless model.is_a?(Class) &&
+          model < ActiveRecord::Base &&
+          !model.abstract_class?
+        raise UnsafePublicationError,
+          "#{model.inspect} is not an Active Record model"
+      end
+
+      if FORBIDDEN_TABLE_PREFIXES.any? { |prefix| model.table_name.start_with?(prefix) }
+        raise UnsafePublicationError,
+          "#{model.table_name} is an internal framework table"
+      end
+
+      if FORBIDDEN_TABLE_NAMES.include?(model.table_name)
+        raise UnsafePublicationError,
+          "#{model.table_name} is an authentication table"
+      end
+    end
+
+    def validate_columns!(model, names)
+      names = Array(names).map(&:to_s).uniq
+      label = model.name.presence || model.table_name
+      raise UnsafePublicationError, "#{label} must publish at least one column" if names.empty?
+
+      unknown = names - model.column_names
+      if unknown.any?
+        raise UnsafePublicationError, "#{label}.#{unknown.first} does not exist"
+      end
+
+      forbidden = names.find { |name| FORBIDDEN_COLUMN_NAMES.include?(name) }
+      if forbidden
+        raise UnsafePublicationError, "#{label}.#{forbidden} is forbidden"
+      end
+
+      columns = names.map { |name| model.columns_hash.fetch(name) }
+      unsupported = columns.find do |column|
+        !SUPPORTED_COLUMN_TYPES.include?(column.type.to_sym)
+      end
+      if unsupported
+        raise UnsafePublicationError,
+          "#{label}.#{unsupported.name} uses unsupported PostgreSQL type " \
+          "#{unsupported.sql_type}"
+      end
+
+      missing_keys = Array(model.primary_key).compact.map(&:to_s) - names
+      if missing_keys.any?
+        key_label = missing_keys.one? ? "column" : "columns"
+        raise UnsafePublicationError,
+          "#{label} publication must include primary key #{key_label} " \
+          "#{missing_keys.join(', ')}"
+      end
+
+      validate_zero_key!(model, names, label)
+      columns.freeze
+    end
+
+    def validate_zero_key!(model, published_names, label)
+      keys = zero_keys_for(model)
+      missing_keys = keys - published_names
+      if missing_keys.any?
+        key_label = missing_keys.one? ? "column" : "columns"
+        raise UnsafePublicationError,
+          "#{label} publication must include Zero key #{key_label} " \
+          "#{missing_keys.join(', ')}"
+      end
+
+      active_record_keys = Array(model.primary_key).compact.map(&:to_s)
+      return if keys == active_record_keys
+
+      columns = keys.map { |key| model.columns_hash.fetch(key) }
+      unique_index = model.connection.indexes(model.table_name).any? do |index|
+        index.unique &&
+          index.where.blank? &&
+          Array(index.columns).map(&:to_s) == keys
+      end
+      return if columns.none?(&:null) && unique_index
+
+      raise UnsafePublicationError,
+        "#{label} Zero key #{keys.join(', ')} must be backed by a unique, non-null index"
+    end
+  end
+end

data/lib/zero_rails_adapter/relationship.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module ZeroRailsAdapter
+  class Relationship
+    Hop = Struct.new(
+      :source_fields,
+      :destination,
+      :destination_fields,
+      keyword_init: true
+    )
+
+    attr_reader :source, :name, :kind, :hops
+
+    def self.from_definition(definition, published_schema:)
+      unless definition.respond_to?(:to_h)
+        raise InvalidRelationshipError, "Relationship definition must be an object"
+      end
+
+      attributes = definition.to_h.symbolize_keys
+      hop_definitions = if attributes.key?(:through)
+        Array(attributes[:through])
+      else
+        [{
+          source_fields: attributes[:source_fields],
+          destination: attributes[:destination],
+          destination_fields: attributes[:destination_fields]
+        }]
+      end
+
+      new(
+        source: attributes[:source],
+        name: attributes[:name],
+        kind: attributes[:kind],
+        hops: hop_definitions,
+        published_schema:
+      )
+    end
+
+    def initialize(source:, name:, kind:, hops:, published_schema:)
+      @source = source
+      @name = name.to_s
+      @kind = kind.to_s
+      @published_schema = published_schema
+
+      validate_header!
+      @hops = validate_hops!(hops).freeze
+    end
+
+    private
+
+    def validate_header!
+      unless @published_schema.models.include?(source)
+        raise InvalidRelationshipError,
+          "Relationship source #{model_label(source)} is not published"
+      end
+      if name.empty?
+        raise InvalidRelationshipError, "Relationship name must not be empty"
+      end
+      unless %w[one many].include?(kind)
+        raise InvalidRelationshipError,
+          "Relationship #{name} kind must be one or many"
+      end
+    end
+
+    def validate_hops!(definitions)
+      definitions = Array(definitions)
+      if definitions.empty?
+        raise InvalidRelationshipError,
+          "Relationship #{name} must define at least one hop"
+      end
+      if definitions.length > 2
+        raise InvalidRelationshipError,
+          "Relationship #{name} supports at most two hops"
+      end
+
+      current_source = source
+      definitions.map do |definition|
+        unless definition.respond_to?(:to_h)
+          raise InvalidRelationshipError,
+            "Relationship #{name} hop must be an object"
+        end
+
+        attributes = definition.to_h.symbolize_keys
+        source_fields = normalize_fields(attributes[:source_fields])
+        destination = attributes[:destination]
+        destination_fields = normalize_fields(attributes[:destination_fields])
+
+        validate_model!(destination)
+        validate_fields!(current_source, source_fields, "source")
+        validate_fields!(destination, destination_fields, "destination")
+        if source_fields.length != destination_fields.length
+          raise InvalidRelationshipError,
+            "Relationship #{name} hop fields must have matching arity"
+        end
+
+        current_source = destination
+        Hop.new(source_fields:, destination:, destination_fields:).freeze
+      end
+    end
+
+    def validate_model!(model)
+      return if @published_schema.models.include?(model)
+
+      raise InvalidRelationshipError,
+        "Relationship #{name} destination #{model_label(model)} is not published"
+    end
+
+    def validate_fields!(model, fields, side)
+      if fields.empty?
+        raise InvalidRelationshipError,
+          "Relationship #{name} #{side} fields must not be empty"
+      end
+
+      missing = fields - @published_schema.column_names_for(model)
+      return if missing.empty?
+
+      raise InvalidRelationshipError,
+        "Relationship #{name} #{side} field #{missing.first} is not published"
+    end
+
+    def normalize_fields(value)
+      Array(value).compact.map(&:to_s)
+    end
+
+    def model_label(model)
+      model.respond_to?(:name) && model.name.present? ? model.name : model.inspect
+    end
+  end
+end