ar_sync 1.0.0

data/graph/hooks.d.ts

@@ -0,0 +1,3 @@
+export { useArSyncFetch } from '../core/hooksBase';
+import { Request, DataAndStatus } from '../core/hooksBase';
+export declare function useArSyncModel<T>(request: Request | null): DataAndStatus<T>;

data/graph/hooks.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var hooksBase_1 = require("../core/hooksBase");
+exports.useArSyncFetch = hooksBase_1.useArSyncFetch;
+const hooksBase_2 = require("../core/hooksBase");
+const ArSyncModel_1 = require("./ArSyncModel");
+function useArSyncModel(request) {
+    return hooksBase_2.useArSyncModelWithClass(ArSyncModel_1.default, request);
+}
+exports.useArSyncModel = useArSyncModel;

data/graph/index.d.ts

@@ -0,0 +1,2 @@
+import ArSyncModel from './ArSyncModel';
+export default ArSyncModel;

data/graph/index.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ArSyncModel_1 = require("./ArSyncModel");
+exports.default = ArSyncModel_1.default;

data/lib/ar_sync.rb

@@ -0,0 +1,25 @@
+module ArSync
+  module GraphSync; end
+  module TreeSync; end
+  def self.use(mode, klass: ActiveRecord::Base)
+    case mode
+    when :tree
+      if klass.ancestors.include? ArSync::GraphSync
+        raise ArgumentError, 'already activated ArSync::GraphSync'
+      end
+      klass.include ArSync::TreeSync
+    when :graph
+      if klass.ancestors.include? ArSync::TreeSync
+        raise ArgumentError, 'already activated ArSync::TreeSync'
+      end
+      klass.include ArSync::GraphSync
+    else
+      raise ArgumentError, 'argument should be :tree or :graph'
+    end
+  end
+end
+require 'ar_sync/version'
+require 'ar_sync/core'
+require 'ar_sync/config'
+require 'ar_sync/type_script'
+require 'ar_sync/rails' if Kernel.const_defined?('Rails')

data/lib/ar_sync/class_methods.rb

@@ -0,0 +1,215 @@
+require_relative 'field'
+require_relative 'collection'
+
+module ArSync::ClassMethodsBase
+  def _sync_self?
+    instance_variable_defined? '@_sync_self'
+  end
+
+  def _sync_parents_info
+    @_sync_parents_info ||= []
+  end
+
+  def _sync_children_info
+    @_sync_children_info ||= {}
+  end
+
+  def _sync_child_info(name)
+    info = _sync_children_info[name]
+    return info if info
+    superclass._sync_child_info name if superclass < ActiveRecord::Base
+  end
+
+  def _each_sync_parent(&block)
+    _sync_parents_info.each(&block)
+    superclass._each_sync_parent(&block) if superclass < ActiveRecord::Base
+  end
+
+  def _each_sync_child(&block)
+    _sync_children_info.each(&block)
+    superclass._each_sync_child(&block) if superclass < ActiveRecord::Base
+  end
+
+  def sync_parent(parent, inverse_of:, only_to: nil)
+    _initialize_sync_callbacks
+    _sync_parents_info << [
+      parent,
+      { inverse_name: inverse_of, only_to: only_to }
+    ]
+  end
+end
+
+module ArSync::TreeSync::ClassMethods
+  include ArSync::ClassMethodsBase
+  def sync_collection(name)
+    ArSync::Collection::Tree.find self, name
+  end
+
+  def sync_has_data(*names, **option, &original_data_block)
+    @_sync_self = true
+    option = option.dup
+    if original_data_block
+      data_block = ->(*args) { instance_exec(*args, &original_data_block).as_json }
+    end
+    option[:params_type] = {}
+    names.each do |name|
+      type_override = data_block.nil? && reflect_on_association(name.to_s.underscore) ? { type: :any } : {}
+      _sync_define ArSync::DataField.new(name), option.merge(type_override), &data_block
+    end
+  end
+
+  def sync_has_one(name, **option, &data_block)
+    _sync_define ArSync::HasOneField.new(name), option, &data_block
+  end
+
+  def sync_has_many(name, order: :asc, propagate_when: nil, params_type: nil, limit: nil, preload: nil, association: nil, **option, &data_block)
+    if data_block.nil? && preload.nil?
+      underscore_name = name.to_s.underscore.to_sym
+      preload = lambda do |records, _context, params|
+        ArSerializer::Field.preload_association(
+          self, records, association || underscore_name,
+          order: (!limit && params && params[:order]) || order,
+          limit: [params && params[:limit]&.to_i, limit].compact.min
+        )
+      end
+      data_block = lambda do |preloaded, _context, _params|
+        preloaded ? preloaded[id] || [] : send(name)
+      end
+      params_type = { limit?: :int, order?: [{ :* => %w[asc desc] }, 'asc', 'desc'] }
+    else
+      params_type = {}
+    end
+    field = ArSync::HasManyField.new name, association: association, order: order, limit: limit, propagate_when: propagate_when
+    _sync_define field, preload: preload, association: association, params_type: params_type, **option, &data_block
+  end
+
+  def _sync_define(info, **option, &data_block)
+    _initialize_sync_callbacks
+    _sync_children_info[info.name] = info
+    serializer_field info.name, **option, &data_block unless _serializer_field_info info.name
+    serializer_field info.name, **option, namespace: :sync, &data_block
+  end
+
+  def sync_define_collection(name, limit: nil, order: :asc)
+    _initialize_sync_callbacks
+    collection = ArSync::Collection::Tree.new self, name, limit: limit, order: order
+    sync_parent collection, inverse_of: [self, name]
+  end
+
+  def _initialize_sync_callbacks
+    return if instance_variable_defined? '@_sync_callbacks_initialized'
+    @_sync_callbacks_initialized = true
+    _sync_define ArSync::DataField.new(:id)
+    %i[create update destroy].each do |action|
+      after_commit on: action do
+        next if ArSync.skip_notification?
+        self.class.default_scoped.scoping { _sync_notify action }
+      end
+    end
+  end
+end
+
+module ArSync::GraphSync::ClassMethods
+  include ArSync::ClassMethodsBase
+  def sync_collection(name)
+    ArSync::Collection::Graph.find self, name
+  end
+
+  def sync_has_data(*names, **option, &data_block)
+    @_sync_self = true
+    names.each do |name|
+      _sync_children_info[name] = nil
+      _sync_define name, option, &data_block
+    end
+  end
+
+  def sync_has_many(name, **option, &data_block)
+    _sync_children_info[name] = :many
+    _sync_has_many name, option, &data_block
+  end
+
+  def sync_has_one(name, **option, &data_block)
+    _sync_children_info[name] = :one
+    _sync_define name, option, &data_block
+  end
+
+  def _sync_has_many(name, order: :asc, limit: nil, preload: nil, association: nil, **option, &data_block)
+    raise "order not in [:asc, :desc] : #{order}" unless %i[asc desc].include? order
+    if data_block.nil? && preload.nil?
+      underscore_name = name.to_s.underscore.to_sym
+      preload = lambda do |records, _context, params|
+        ArSerializer::Field.preload_association(
+          self, records, association || underscore_name,
+          order: (!limit && params && params[:order]) || order,
+          limit: [params && params[:limit]&.to_i, limit].compact.min
+        )
+      end
+      data_block = lambda do |preloaded, _context, params|
+        records = preloaded ? preloaded[id] || [] : send(name)
+        next records unless limit || order == :asc
+        ArSync::CollectionWithOrder.new(
+          records,
+          order: (!limit && params && params[:order]) || order,
+          limit: [params && params[:limit]&.to_i, limit].compact.min
+        )
+      end
+      params_type = { limit?: :int, order?: [{ :* => %w[asc desc] }, 'asc', 'desc'] }
+    else
+      params_type = {}
+    end
+    _sync_define name, preload: preload, association: association, **option.merge(params_type: params_type), &data_block
+  end
+
+  def _sync_define(name, **option, &data_block)
+    _initialize_sync_callbacks
+    serializer_field name, **option, &data_block unless _serializer_field_info name
+    serializer_field name, **option, namespace: :sync, &data_block
+  end
+
+  def sync_define_collection(name, limit: nil, order: :asc)
+    _initialize_sync_callbacks
+    collection = ArSync::Collection::Graph.new self, name, limit: limit, order: order
+    sync_parent collection, inverse_of: [self, name]
+  end
+
+  def _initialize_sync_callbacks
+    return if instance_variable_defined? '@_sync_callbacks_initialized'
+    @_sync_callbacks_initialized = true
+    mod = Module.new do
+      def write_attribute(attr_name, value)
+        self.class.default_scoped.scoping do
+          @_sync_parents_info_before_mutation ||= _sync_current_parents_info
+        end
+        super attr_name, value
+      end
+    end
+    prepend mod
+    attr_reader :_sync_parents_info_before_mutation
+
+    _sync_define :id
+
+    _sync_define :sync_keys, type: [:string] do |current_user|
+      ArSync.sync_graph_keys self, current_user
+    end
+
+    _sync_define :defaults, namespace: :sync do |current_user|
+      { sync_keys: ArSync.sync_graph_keys(self, current_user) }
+    end
+
+    before_destroy do
+      @_sync_parents_info_before_mutation ||= _sync_current_parents_info
+    end
+
+    before_save on: :create do
+      @_sync_parents_info_before_mutation ||= _sync_current_parents_info
+    end
+
+    %i[create update destroy].each do |action|
+      after_commit on: action do
+        next if ArSync.skip_notification?
+        self.class.default_scoped.scoping { _sync_notify action }
+        @_sync_parents_info_before_mutation = nil
+      end
+    end
+  end
+end

data/lib/ar_sync/collection.rb

@@ -0,0 +1,83 @@
+require_relative 'field'
+
+class ArSync::Collection
+  attr_reader :klass, :name, :limit, :order
+  def initialize(klass, name, limit: nil, order: nil)
+    @klass = klass
+    @name = name
+    @limit = limit
+    @order = order
+    self.class.defined_collections[[klass, name]] = self
+    define_singleton_method(name) { to_a }
+  end
+
+  def sync_send_event(type:, to_user: nil, data:)
+    event_data = { type: type, data: data }
+    ArSync.sync_tree_send to: self, action: :event, path: [], data: event_data, to_user: to_user
+  end
+
+  def to_a
+    all = klass.all
+    all = all.order id: order if order
+    all = all.limit limit if limit
+    all
+  end
+
+  def self.defined_collections
+    @defined_collections ||= {}
+  end
+
+  def self.find(klass, name)
+    defined_collections[[klass, name]]
+  end
+end
+
+class ArSync::Collection::Tree < ArSync::Collection
+  def initialize(*)
+    super
+    @field = ArSync::CollectionField.new @name, limit: @limit, order: @order
+    self.class._sync_children_info[[@klass, @name]] = @field
+  end
+
+  def _sync_notify_parent(*); end
+
+  def self._sync_children_info
+    @sync_children_info ||= {}
+  end
+
+  def self._sync_child_info(key)
+    _sync_children_info[key]
+  end
+end
+
+class ArSync::Collection::Graph < ArSync::Collection
+  def _sync_notify_child_changed(_child, _name, _to_user, _owned); end
+
+  def _sync_notify_child_added(child, _name, to_user, _owned)
+    ArSync.sync_graph_send to: self, action: :add, model: child, path: :collection, to_user: to_user
+  end
+
+  def _sync_notify_child_removed(child, _name, to_user, _owned)
+    ArSync.sync_graph_send to: self, action: :remove, model: child, path: :collection, to_user: to_user
+  end
+
+  def self._sync_children_info
+    @sync_children_info ||= {}
+  end
+
+  def self._sync_child_info(key)
+    _sync_children_info[key]
+  end
+end
+
+class ArSync::CollectionWithOrder < ArSerializer::CompositeValue
+  def initialize(records, order:, limit:)
+    @records = records
+    @order = { mode: order, limit: limit }
+  end
+
+  def ar_serializer_build_sub_calls
+    values = @records.map { {} }
+    [{ order: @order, collection: values }, @records.zip(values)]
+  end
+end

data/lib/ar_sync/config.rb

@@ -0,0 +1,18 @@
+require 'ostruct'
+module ArSync
+  config_keys = %i[
+    current_user_method
+    key_secret
+    key_prefix
+    key_expires_in
+  ]
+  Config = Struct.new(*config_keys)
+
+  def self.config
+    @config ||= Config.new :current_user, nil, nil
+  end
+
+  def self.configure
+    yield config
+  end
+end

data/lib/ar_sync/core.rb

@@ -0,0 +1,138 @@
+require 'ar_serializer'
+require_relative 'collection'
+require_relative 'class_methods'
+require_relative 'instance_methods'
+
+module ArSync
+  ArSync::TreeSync.module_eval do
+    extend ActiveSupport::Concern
+    include ArSync::TreeSync::InstanceMethods
+  end
+
+  ArSync::GraphSync.module_eval do
+    extend ActiveSupport::Concern
+    include ArSync::GraphSync::InstanceMethods
+  end
+
+  def self.on_notification(&block)
+    @sync_send_block = block
+  end
+
+  def self.with_compact_notification
+    key = :ar_sync_compact_notifications
+    Thread.current[key] = []
+    yield
+  ensure
+    events = Thread.current[key]
+    Thread.current[key] = nil
+    @sync_send_block&.call events if events.present?
+  end
+
+  def self.skip_notification?
+    Thread.current[:ar_sync_skip_notification]
+  end
+
+  def self.without_notification
+    key = :ar_sync_skip_notification
+    flag_was = Thread.current[key]
+    Thread.current[key] = true
+    yield
+  ensure
+    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]
+    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]
+    buffer = Thread.current[:ar_sync_compact_notifications]
+    if buffer
+      buffer << event
+    else
+      @sync_send_block&.call [event]
+    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)]
+  end
+
+  def self.sync_key(model, path, to_user = nil, signature: true)
+    if model.is_a? ArSync::Collection
+      key = [to_user&.id, model.klass.name, model.name, path].join '/'
+    else
+      key = [to_user&.id, model.class.name, model.id, path].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
+  end
+
+  def self.validate_expiration(signed_key)
+    signed_key = signed_key.to_s
+    return signed_key unless config.key_expires_in
+    key, time, signature, other = signed_key.split ';', 4
+    return unless signed_key(key, time) == [key, time, signature].join(';')
+    [key, other].compact.join ';' if Time.now.to_i - time.to_i < config.key_expires_in
+  end
+
+  def self.signed_key(key, time)
+    "#{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)
+    }
+  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
+    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