ar_sync 1.0.0

data/lib/ar_sync/field.rb

@@ -0,0 +1,96 @@
+class ArSync::Field
+  attr_reader :name
+  def initialize(name)
+    @name = name
+  end
+
+  def skip_propagation?(_parent, _child, _path)
+    false
+  end
+
+  def action_convert(action)
+    action
+  end
+
+  def order_param; end
+end
+
+class ArSync::DataField < ArSync::Field
+  def type
+    :data
+  end
+
+  def data(parent, _child, to_user:, **)
+    ArSync.serialize parent, name, user: to_user
+  end
+
+  def path(_child)
+    []
+  end
+
+  def action_convert(_action)
+    :update
+  end
+
+  def skip_propagation?(_parent, _child, path)
+    !path.nil?
+  end
+end
+
+class ArSync::HasOneField < ArSync::Field
+  def type
+    :one
+  end
+
+  def data(_parent, child, action:, **)
+    child._sync_data new_record: action == :create
+  end
+
+  def path(_child)
+    [name]
+  end
+end
+
+class ArSync::HasManyField < ArSync::Field
+  attr_reader :limit, :order, :association, :propagate_when
+  def type
+    :many
+  end
+
+  def initialize(name, association: nil, limit: nil, order: nil, propagate_when: nil)
+    super name
+    @limit = limit
+    @order = order
+    @association = association || name
+    @propagate_when = propagate_when
+  end
+
+  def skip_propagation?(parent, child, _path)
+    return false unless limit
+    return !propagate_when.call(child) if propagate_when
+    ids = parent.send(association).order(id: order).limit(limit).ids
+    if child.destroyed?
+      ids.size == limit && (order == :asc ? ids.max < child.id : child.id < ids.min)
+    else
+      !ids.include? child.id
+    end
+  end
+
+  def data(_parent, child, action:, **)
+    child._sync_data new_record: action == :create
+  end
+
+  def order_param
+    { limit: limit, order: order } if order
+  end
+
+  def path(child)
+    [name, child.id]
+  end
+end
+
+class ArSync::CollectionField < ArSync::HasManyField
+  def path(child)
+    [child.id]
+  end
+end

data/lib/ar_sync/instance_methods.rb

@@ -0,0 +1,130 @@
+module ArSync::TreeSync::InstanceMethods
+  def _sync_notify(action)
+    if self.class._sync_self?
+      data = action == :destroy ? nil : _sync_data
+      ArSync.sync_tree_send to: self, action: action, path: [], data: data
+    end
+    _sync_notify_parent action
+  end
+
+  def _sync_data(new_record: false)
+    fallbacks = {}
+    names = []
+    self.class._each_sync_child do |name, info|
+      names << name if info.type == :data
+      if new_record
+        fallbacks[name] = [] if info.type == :many
+        fallbacks[name] = nil if info.type == :one
+      end
+    end
+    data = ArSync.serialize self, names
+    fallbacks.update data
+  end
+
+  def sync_send_event(type:, relation: nil, to_user: nil, data:)
+    path = [*relation]
+    event_data = { type: type, data: data }
+    if self.class._sync_self?
+      ArSync.sync_tree_send to: self, action: :event, path: path, data: event_data, to_user: to_user
+    end
+    _sync_notify_parent(:event, path: path, data: event_data, only_to_user: to_user)
+  end
+
+  def _sync_notify_parent(action, path: nil, data: nil, order_param: nil, only_to_user: nil)
+    self.class._each_sync_parent do |parent, inverse_name:, only_to:|
+      parent = send(parent) if parent.is_a? Symbol
+      parent = instance_exec(&parent) if parent.is_a? Proc
+      next unless parent
+      next if parent.respond_to?(:destroyed?) && parent.destroyed?
+      inverse_name = instance_exec(&inverse_name) if inverse_name.is_a? Proc
+      next unless inverse_name
+      association_field = parent.class._sync_child_info inverse_name
+      next if association_field.skip_propagation? parent, self, path
+      action2 = association_field.action_convert action
+      only_to_user2 = only_to_user
+      if only_to
+        to_user = only_to.is_a?(Symbol) ? instance_eval(&only_to) : instance_exec(&only_to)
+        next unless to_user
+        next if only_to_user && only_to_user != to_user
+        only_to_user2 = to_user
+      end
+      data2 = path || action2 == :destroy ? data : association_field.data(parent, self, to_user: to_user, action: action)
+      order_param2 = path ? order_param : association_field.order_param
+      path2 = [*association_field.path(self), *path]
+      ArSync.sync_tree_send(
+        to: parent, action: action2, path: path2, data: data2,
+        to_user: only_to_user2,
+        ordering: order_param2
+      )
+      parent._sync_notify_parent action2, path: path2, data: data2, order_param: order_param2, only_to_user: to_user || only_to_user
+    end
+  end
+end
+
+module ArSync::GraphSync::InstanceMethods
+  def _sync_notify(action)
+    _sync_notify_parent action
+    _sync_notify_self if self.class._sync_self? && action == :update
+  end
+
+  def _sync_current_parents_info
+    parents = []
+    self.class._each_sync_parent do |parent, inverse_name:, only_to:|
+      parent = send parent if parent.is_a? Symbol
+      parent = instance_exec(&parent) if parent.is_a? Proc
+      if only_to
+        to_user = only_to.is_a?(Symbol) ? instance_eval(&only_to) : instance_exec(&only_to)
+        parent = nil unless to_user
+      end
+      owned = parent.class._sync_child_info(inverse_name).present? if parent
+      parents << [parent, [inverse_name, to_user, owned]]
+    end
+    parents
+  end
+
+  def _sync_notify_parent(action)
+    if action == :create
+      parents = _sync_current_parents_info
+      parents_was = parents.map { nil }
+    elsif action == :destroy
+      parents_was = _sync_parents_info_before_mutation
+      parents = parents_was.map { nil }
+    else
+      parents_was = _sync_parents_info_before_mutation
+      parents = _sync_current_parents_info
+    end
+    parents_was.zip(parents).each do |(parent_was, info_was), (parent, info)|
+      if parent_was == parent && info_was == info
+        parent&._sync_notify_child_changed self, *info
+      else
+        parent_was&._sync_notify_child_removed self, *info_was
+        parent&._sync_notify_child_added self, *info
+      end
+    end
+  end
+
+  def _sync_notify_child_removed(child, name, to_user, owned)
+    if owned
+      ArSync.sync_graph_send to: self, action: :remove, model: child, path: name, to_user: to_user
+    else
+      ArSync.sync_graph_send to: self, action: :update, model: self, to_user: to_user
+    end
+  end
+
+  def _sync_notify_child_added(child, name, to_user, owned)
+    if owned
+      ArSync.sync_graph_send to: self, action: :add, model: child, path: name, to_user: to_user
+    else
+      ArSync.sync_graph_send to: self, action: :update, model: self, to_user: to_user
+    end
+  end
+
+  def _sync_notify_child_changed(_child, _name, to_user, owned)
+    return if owned
+    ArSync.sync_graph_send(to: self, action: :update, model: self, to_user: to_user)
+  end
+
+  def _sync_notify_self
+    ArSync.sync_graph_send(to: self, action: :update, model: self)
+  end
+end

data/lib/ar_sync/rails.rb

@@ -0,0 +1,155 @@
+module ArSync
+  module Rails
+    class Engine < ::Rails::Engine; end
+  end
+
+  class ApiNotFound < StandardError; end
+
+  on_notification do |events|
+    events.each do |key, patch|
+      ActionCable.server.broadcast key, patch
+    end
+  end
+
+  module StaticJsonConcern
+    def ar_sync_static_json(record_or_records, query)
+      if respond_to?(ArSync.config.current_user_method)
+        current_user = send ArSync.config.current_user_method
+      end
+      ArSync.serialize(record_or_records, query.as_json, user: current_user)
+    end
+  end
+
+  ActionController::Base.class_eval do
+    include StaticJsonConcern
+    def action_with_compact_ar_sync_notification(&block)
+      ArSync.with_compact_notification(&block)
+    end
+    around_action :action_with_compact_ar_sync_notification
+  end
+
+  module ApiControllerConcern
+    extend ActiveSupport::Concern
+    include ArSerializer::Serializable
+
+    included do
+      protect_from_forgery except: %i[sync_call static_call graphql_call]
+      serializer_field :__schema do
+        ArSerializer::GraphQL::SchemaClass.new self.class
+      end
+    end
+
+    def sync_call
+      _api_call :sync do |model, current_user, query|
+        case model
+        when ArSync::Collection::Graph, ArSync::GraphSync
+          serialized = ArSerializer.serialize model, query, context: current_user, include_id: true, use: :sync
+          next serialized if model.is_a? ArSync::GraphSync
+          {
+            sync_keys: ArSync.sync_graph_keys(model, current_user),
+            order: { mode: model.order, limit: model.limit },
+            collection: serialized
+          }
+        when ArSync::Collection::Tree
+          ArSync.sync_collection_api model, current_user, query
+        when ActiveRecord::Relation, Array
+          ArSync.serialize model.to_a, query, user: current_user
+        when ActiveRecord::Base
+          ArSync.sync_api model, current_user, query
+        else
+          model
+        end
+      end
+    end
+
+    def graphql_schema
+      render plain: ArSerializer::GraphQL.definition(self.class)
+    end
+
+    def graphql_call
+      render json: ArSerializer::GraphQL.serialize(
+        self,
+        params[:query],
+        operation_name: params[:operationName],
+        variables: (params[:variables] || {}).as_json,
+        context: current_user
+      )
+    rescue StandardError => e
+      render json: { error: handle_exception(e) }
+    end
+
+    def static_call
+      _api_call :static do |model, current_user, query|
+        case model
+        when ArSync::Collection, ActiveRecord::Relation, Array
+          ArSerializer.serialize model.to_a, query, context: current_user
+        when ActiveRecord::Base
+          ArSerializer.serialize model, query, context: current_user
+        else
+          model
+        end
+      end
+    end
+
+    private
+
+    def _api_call(type)
+      if respond_to?(ArSync.config.current_user_method)
+        current_user = send ArSync.config.current_user_method
+      end
+      responses = params[:requests].map do |request|
+        begin
+          api_name = request[:api]
+          info = self.class._serializer_field_info api_name
+          raise ArSync::ApiNotFound, "#{type.to_s.capitalize} API named `#{api_name}` not configured" unless info
+          api_params = (request[:params].as_json || {}).transform_keys(&:to_sym)
+          model = instance_exec(current_user, api_params, &info.data_block)
+          { data: yield(model, current_user, request[:query].as_json) }
+        rescue StandardError => e
+          { error: handle_exception(e) }
+        end
+      end
+      render json: responses
+    end
+
+    def log_internal_exception_trace(trace)
+      if logger.formatter&.respond_to? :tags_text
+        logger.fatal trace.join("\n#{logger.formatter.tags_text}")
+      else
+        logger.fatal trace.join("\n")
+      end
+    end
+
+    def exception_trace(exception)
+      backtrace_cleaner = request.get_header 'action_dispatch.backtrace_cleaner'
+      wrapper = ActionDispatch::ExceptionWrapper.new backtrace_cleaner, exception
+      trace = wrapper.application_trace
+      trace.empty? ? wrapper.framework_trace : trace
+    end
+
+    def log_internal_exception(exception)
+      ActiveSupport::Deprecation.silence do
+        logger.fatal '  '
+        logger.fatal "#{exception.class} (#{exception.message}):"
+        log_internal_exception_trace exception.annoted_source_code if exception.respond_to?(:annoted_source_code)
+        logger.fatal '  '
+        log_internal_exception_trace exception_trace(exception)
+      end
+    end
+
+    def handle_exception(exception)
+      log_internal_exception exception
+      backtrace = exception_trace exception unless ::Rails.env.production?
+      case exception
+      when ArSerializer::InvalidQuery, ArSync::ApiNotFound, ArSerializer::GraphQL::Parser::ParseError
+        { type: 'Bad Request', message: exception.message, backtrace: backtrace }
+      when ActiveRecord::RecordNotFound
+        message = exception.message unless ::Rails.env.production?
+        { type: 'Record Not Found', message: message.to_s, backtrace: backtrace }
+      else
+        message = "#{exception.class} (#{exception.message})" unless ::Rails.env.production?
+        { type: 'Internal Server Error', message: message.to_s, backtrace: backtrace }
+      end
+    end
+  end
+end

data/lib/ar_sync/type_script.rb

@@ -0,0 +1,80 @@
+module ArSync::TypeScript
+  def self.generate_typed_files(api_class, dir:, mode: nil, comment: nil)
+    mode ||= :graph if ActiveRecord::Base.include? ArSync::GraphSync
+    mode ||= :tree if ActiveRecord::Base.include? ArSync::TreeSync
+    raise 'ar_sync mode: graph or tree, is not specified.' unless mode
+    {
+      'types.ts' => generate_type_definition(api_class),
+      'ArSyncModel.ts' => generate_model_script(mode),
+      'hooks.ts' => generate_hooks_script(mode)
+    }.each { |file, code| File.write File.join(dir, file), "#{comment}#{code}" }
+  end
+
+  def self.generate_type_definition(api_class)
+    [
+      ArSerializer::TypeScript.generate_type_definition(api_related_classes(api_class)),
+      request_type_definition(api_class)
+    ].join "\n"
+  end
+
+  def self.api_related_classes(api_class)
+    classes = ArSerializer::TypeScript.related_serializer_types([api_class]).map(&:type)
+    classes - [api_class]
+  end
+
+  def self.request_type_definition(api_class)
+    type = ArSerializer::GraphQL::TypeClass.from api_class
+    definitions = []
+    request_types = {}
+    type.fields.each do |field|
+      association_type = field.type.association_type
+      next unless association_type
+      prefix = 'Class' if field.name.match?(/\A[A-Z]/) # for class reload query
+      request_type_name = "Type#{prefix}#{field.name.camelize}Request"
+      request_types[field.name] = request_type_name
+      multiple = field.type.is_a? ArSerializer::GraphQL::ListTypeClass
+      definitions << <<~CODE
+        export interface #{request_type_name} {
+          api: '#{field.name}'
+          params?: #{field.args_ts_type}
+          query: Type#{association_type.name}Query
+          _meta?: { data: Type#{field.type.association_type.name}#{'[]' if multiple} }
+        }
+      CODE
+    end
+    [
+      'export type TypeRequest = ',
+      request_types.values.map { |value| "  | #{value}" },
+      'export type ApiNameRequests =  {',
+      request_types.map { |key, value| "  #{key}: #{value}" },
+      '}',
+      definitions
+    ].join("\n")
+  end
+
+  def self.generate_model_script(mode)
+    <<~CODE
+      import { TypeRequest, ApiNameRequests } from './types'
+      import { DataTypeFromRequest } from 'ar_sync/core/DataType'
+      import ArSyncModelBase from 'ar_sync/#{mode}/ArSyncModel'
+      export default class ArSyncModel<R extends TypeRequest> extends ArSyncModelBase<{}> {
+        constructor(r: R) { super(r) }
+        data: DataTypeFromRequest<ApiNameRequests[R['api']], R> | null
+      }
+    CODE
+  end
+
+  def self.generate_hooks_script(mode)
+    <<~CODE
+      import { TypeRequest, ApiNameRequests } from './types'
+      import { DataTypeFromRequest } from 'ar_sync/core/DataType'
+      import { useArSyncModel as useArSyncModelBase, useArSyncFetch as useArSyncFetchBase } from 'ar_sync/#{mode}/hooks'
+      export function useArSyncModel<R extends TypeRequest>(request: R | null) {
+        return useArSyncModelBase<DataTypeFromRequest<ApiNameRequests[R['api']], R>>(request)
+      }
+      export function useArSyncFetch<R extends TypeRequest>(request: R | null) {
+        return useArSyncFetchBase<DataTypeFromRequest<ApiNameRequests[R['api']], R>>(request)
+      }
+    CODE
+  end
+end