ar_sync 1.0.1 → 1.0.2

data/lib/ar_sync/core.rb

@@ -4,14 +4,9 @@ require_relative 'class_methods'
 require_relative 'instance_methods'
 
 module ArSync
-  ArSync::TreeSync.module_eval do
+  ArSync::ModelBase.module_eval do
     extend ActiveSupport::Concern
-    include ArSync::TreeSync::InstanceMethods
-  end
-
-  ArSync::GraphSync.module_eval do
-    extend ActiveSupport::Concern
-    include ArSync::GraphSync::InstanceMethods
+    include ArSync::ModelBase::InstanceMethods
   end
 
   def self.on_notification(&block)
@@ -41,20 +36,15 @@ module ArSync
     Thread.current[key] = flag_was
   end
 
-  def self.sync_tree_send(to:, action:, path:, data:, to_user: nil, ordering: nil)
-    key = sync_key to, path.grep(Symbol), to_user, signature: false
-    event = [key, action: action, path: path, data: data, ordering: ordering]
-    buffer = Thread.current[:ar_sync_compact_notifications]
-    if buffer
-      buffer << event
-    else
-      @sync_send_block&.call [event]
+  def self.sync_send(to:, action:, model:, path: nil, field: nil, to_user: nil)
+    key = sync_key to, to_user, signature: false
+    e = { action: action }
+    e[:field] = field if field
+    if model
+      e[:class_name] = model.class.base_class.name
+      e[:id] = model.id
     end
-  end
-
-  def self.sync_graph_send(to:, action:, model:, path: nil, to_user: nil)
-    key = sync_graph_key to, to_user, signature: false
-    event = ["#{key}#{path}", action: action, class_name: model.class.base_class.name, id: model.id]
+    event = ["#{key}#{path}", e]
     buffer = Thread.current[:ar_sync_compact_notifications]
     if buffer
       buffer << event
@@ -63,23 +53,20 @@ module ArSync
     end
   end
 
-  def self.sync_graph_key(model, to_user = nil, signature: true)
-    sync_key(model, :graph_sync, to_user, signature: signature) + ';/'
-  end
-
-  def self.sync_graph_keys(model, user)
-    [sync_graph_key(model), sync_graph_key(model, user)]
+  def self.sync_keys(model, user)
+    [sync_key(model), sync_key(model, user)]
   end
 
-  def self.sync_key(model, path, to_user = nil, signature: true)
+  def self.sync_key(model, to_user = nil, signature: true)
     if model.is_a? ArSync::Collection
-      key = [to_user&.id, model.klass.name, model.name, path].join '/'
+      key = [to_user&.id, model.klass.name, model.name].join '/'
     else
-      key = [to_user&.id, model.class.name, model.id, path].join '/'
+      key = [to_user&.id, model.class.name, model.id].join '/'
     end
     key = Digest::SHA256.hexdigest("#{config.key_secret}#{key}")[0, 32] if config.key_secret
     key = "#{config.key_prefix}#{key}" if config.key_prefix
-    signature && config.key_expires_in ? signed_key(key, Time.now.to_i.to_s) : key
+    key = signature && config.key_expires_in ? signed_key(key, Time.now.to_i.to_s) : key
+    key + ';/'
   end
 
   def self.validate_expiration(signed_key)
@@ -94,45 +81,26 @@ module ArSync
     "#{key};#{time};#{Digest::SHA256.hexdigest("#{config.key_secret}#{key};#{time}")[0, 16]}"
   end
 
-  def self.sync_collection_api(collection, current_user, args)
-    paths = _extract_paths args
-    keys = paths.flat_map do |path|
-      [sync_key(collection, path), sync_key(collection, path, current_user)]
-    end
-    {
-      keys: keys,
-      data: serialize(collection.to_a, args, user: current_user)
-    }
-  end
-
-  def self.sync_api(model, current_user, args)
-    paths = _extract_paths args
-    keys = paths.flat_map do |path|
-      [sync_key(model, path), sync_key(model, path, current_user)]
-    end
-    {
-      keys: keys,
-      data: serialize(model, args, user: current_user)
-    }
+  def self.serialize(record_or_records, query, user: nil)
+    ArSerializer.serialize record_or_records, query, context: user, include_id: true, use: :sync
   end
 
-  def self._extract_paths(args)
-    parsed = ArSerializer::Serializer.parse_args args
-    paths = []
-    extract = lambda do |path, attributes|
-      paths << path
-      attributes.each do |key, value|
-        sub_attributes = value[:attributes]
-        next unless sub_attributes
-        sub_path = [*path, key]
-        extract.call sub_path, sub_attributes
-      end
+  def self.sync_serialize(target, user, query)
+    case target
+    when ArSync::Collection, ArSync::ModelBase
+      serialized = ArSerializer.serialize target, query, context: user, include_id: true, use: :sync
+      return serialized if target.is_a? ArSync::ModelBase
+      {
+        sync_keys: ArSync.sync_keys(target, user),
+        order: { mode: target.order, limit: target.limit },
+        collection: serialized
+      }
+    when ActiveRecord::Relation, Array
+      ArSync.serialize target.to_a, query, user: user
+    when ArSerializer::Serializable
+      ArSync.serialize target, query, user: user
+    else
+      target
     end
-    extract.call [], parsed[:attributes]
-    paths
-  end
-
-  def self.serialize(record_or_records, query, user: nil)
-    ArSerializer.serialize record_or_records, query, context: user, include_id: true, use: :sync
   end
 end

data/lib/ar_sync/instance_methods.rb

@@ -1,83 +1,31 @@
-module ArSync::TreeSync::InstanceMethods
+module ArSync::ModelBase::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
+    _sync_notify_self if self.class._sync_self? && action == :update
   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
+  def _sync_current_watch_values
+    values = {}
+    self.class._each_sync_parent do |_, info|
+      [*info[:watch]].each do |watch|
+        values[watch] = watch.is_a?(Proc) ? instance_exec(&watch) : send(watch)
       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
+    values
   end
 
   def _sync_current_parents_info
     parents = []
-    self.class._each_sync_parent do |parent, inverse_name:, only_to:|
+    self.class._each_sync_parent do |parent, inverse_name:, only_to:, watch:|
       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
+      inverse_name = instance_exec(&inverse_name) if inverse_name.is_a? Proc
       owned = parent.class._sync_child_info(inverse_name).present? if parent
-      parents << [parent, [inverse_name, to_user, owned]]
+      parents << [parent, [inverse_name, to_user, owned, watch]]
     end
     parents
   end
@@ -121,36 +69,42 @@ module ArSync::GraphSync::InstanceMethods
     else
       parents_was = _sync_parents_info_before_mutation
       parents = _sync_current_parents_info
+      column_values_was = _sync_watch_values_before_mutation
+      column_values = _sync_current_watch_values
     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
+      name, to_user, owned, watch = info
+      name_was, to_user_was, owned_was = info_was
+      if parent_was != parent || info_was != info
+        if owned_was
+          parent_was&._sync_notify_child_removed self, name_was, to_user_was
+        else
+          parent_was&._sync_notify_child_changed name_was, to_user_was
+        end
+        if owned
+          parent&._sync_notify_child_added self, name, to_user
+        else
+          parent&._sync_notify_child_changed name, to_user
+        end
+      elsif parent
+        changed = [*watch].any? do |w|
+          column_values_was[w] != column_values[w]
+        end
+        parent._sync_notify_child_changed name, to_user if changed
       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
+  def _sync_notify_child_removed(child, name, to_user)
+    ArSync.sync_send to: self, action: :remove, model: child, path: name, to_user: to_user
   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
+  def _sync_notify_child_added(child, name, to_user)
+    ArSync.sync_send to: self, action: :add, model: child, path: name, to_user: to_user
   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)
+  def _sync_notify_child_changed(name, to_user)
+    ArSync.sync_send to: self, action: :update, model: self, field: name, to_user: to_user
   end
 
   def _sync_notify_self
@@ -159,9 +113,9 @@ module ArSync::GraphSync::InstanceMethods
     belongs.each do |name, info|
       next if belongs_was[name] == info
       value = info.key?(:value) ? info[:value] : _serializer_field_value(name)
-      _sync_notify_child_added value, name, nil, true if value.is_a? ArSerializer::Serializable
-      _sync_notify_child_removed value, name, nil, true if value.nil?
+      _sync_notify_child_added value, name, nil if value.is_a? ArSerializer::Serializable
+      _sync_notify_child_removed value, name, nil if value.nil?
     end
-    ArSync.sync_graph_send(to: self, action: :update, model: self)
+    ArSync.sync_send to: self, action: :update, model: self
   end
 end

data/lib/ar_sync/rails.rb

@@ -28,47 +28,37 @@ module ArSync
     around_action :action_with_compact_ar_sync_notification
   end
 
+  class SyncSchemaBase
+    include ArSerializer::Serializable
+    serializer_field :__schema do
+      ArSerializer::GraphQL::SchemaClass.new self.class
+    end
+  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 schema
+      raise 'you must implement method `schema`'
     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
+        ArSync.sync_serialize model, current_user, query
       end
     end
 
     def graphql_schema
-      render plain: ArSerializer::GraphQL.definition(self.class)
+      render plain: ArSerializer::GraphQL.definition(schema.class)
     end
 
     def graphql_call
       render json: ArSerializer::GraphQL.serialize(
-        self,
+        schema,
         params[:query],
         operation_name: params[:operationName],
         variables: (params[:variables] || {}).as_json,
@@ -83,7 +73,7 @@ module ArSync
         case model
         when ArSync::Collection, ActiveRecord::Relation, Array
           ArSerializer.serialize model.to_a, query, context: current_user
-        when ActiveRecord::Base
+        when ArSerializer::Serializable
           ArSerializer.serialize model, query, context: current_user
         else
           model
@@ -100,10 +90,11 @@ module ArSync
       responses = params[:requests].map do |request|
         begin
           api_name = request[:api]
-          info = self.class._serializer_field_info api_name
+          sch = schema
+          info = sch.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)
+          model = sch.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) }

data/lib/ar_sync/type_script.rb

@@ -1,12 +1,11 @@
 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
+  def self.generate_typed_files(api_class, dir:, comment: nil)
     {
       'types.ts' => generate_type_definition(api_class),
-      'ArSyncModel.ts' => generate_model_script(mode),
-      'hooks.ts' => generate_hooks_script(mode)
+      'ArSyncModel.ts' => generate_model_script,
+      'ArSyncApi.ts' => generate_api_script,
+      'hooks.ts' => generate_hooks_script,
+      'DataTypeFromRequest.ts' => generate_type_util_script
     }.each { |file, code| File.write File.join(dir, file), "#{comment}#{code}" }
   end
 
@@ -52,28 +51,50 @@ module ArSync::TypeScript
     ].join("\n")
   end
 
-  def self.generate_model_script(mode)
+  def self.generate_model_script
     <<~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
+      import { TypeRequest } from './types'
+      import DataTypeFromRequest from './DataTypeFromRequest'
+      import { default as ArSyncModelBase } from 'ar_sync/core/ArSyncModel'
+      declare class ArSyncModel<R extends TypeRequest> extends ArSyncModelBase<DataTypeFromRequest<R>> {
+        constructor(r: R, option?: { immutable: boolean })
+      }
+      export default ArSyncModelBase as typeof ArSyncModel
+    CODE
+  end
+
+  def self.generate_api_script
+    <<~CODE
+      import { TypeRequest } from './types'
+      import DataTypeFromRequest from './DataTypeFromRequest'
+      import ArSyncApi from 'ar_sync/core/ArSyncApi'
+      export function fetch<R extends TypeRequest>(request: R) {
+        return ArSyncApi.fetch(request) as Promise<DataTypeFromRequest<R>>
       }
     CODE
   end
 
-  def self.generate_hooks_script(mode)
+  def self.generate_type_util_script
     <<~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'
+      import { DataTypeFromRequest as DataTypeFromRequestPair } from 'ar_sync/core/DataType'
+      type DataTypeFromRequest<R extends TypeRequest> = DataTypeFromRequestPair<ApiNameRequests[R['api']], R>
+      export default DataTypeFromRequest
+    CODE
+  end
+
+  def self.generate_hooks_script
+    <<~CODE
+      import { useState, useEffect, useMemo } from 'react'
+      import { TypeRequest } from './types'
+      import DataTypeFromRequest from './DataTypeFromRequest'
+      import { initializeHooks, useArSyncModel as useArSyncModelBase, useArSyncFetch as useArSyncFetchBase } from 'ar_sync/core/hooks'
+      initializeHooks({ useState, useEffect, useMemo })
       export function useArSyncModel<R extends TypeRequest>(request: R | null) {
-        return useArSyncModelBase<DataTypeFromRequest<ApiNameRequests[R['api']], R>>(request)
+        return useArSyncModelBase<DataTypeFromRequest<R>>(request)
       }
       export function useArSyncFetch<R extends TypeRequest>(request: R | null) {
-        return useArSyncFetchBase<DataTypeFromRequest<ApiNameRequests[R['api']], R>>(request)
+        return useArSyncFetchBase<DataTypeFromRequest<R>>(request)
       }
     CODE
   end