ar_sync 1.0.5 → 1.1.1

data/core/DataType.d.ts

@@ -3,9 +3,7 @@ declare type RecordType = {
         query: any;
     };
 };
-declare type Values<T> = T extends {
-    [K in keyof T]: infer U;
-} ? U : never;
+declare type Values<T> = T[keyof T];
 declare type AddNullable<Test, Type> = null extends Test ? Type | null : Type;
 declare type DataTypeExtractField<BaseType, Key extends keyof BaseType> = Exclude<BaseType[Key], null> extends RecordType ? AddNullable<BaseType[Key], {}> : BaseType[Key] extends RecordType[] ? {}[] : BaseType[Key];
 declare type DataTypeExtractFieldsFromQuery<BaseType, Fields> = '*' extends Fields ? {
@@ -33,17 +31,24 @@ declare type CheckAttributesField<P, Q> = Q extends {
 declare type IsAnyCompareLeftType = {
     __any: never;
 };
-declare type CollectExtraFields<Type, Path> = IsAnyCompareLeftType extends Type ? null : Type extends ExtraFieldErrorType ? Path : Type extends (infer R)[] ? _CollectExtraFields<R> : _CollectExtraFields<Type>;
-declare type _CollectExtraFields<Type> = Type extends object ? (keyof (Type) extends never ? null : Values<{
-    [key in keyof Type]: CollectExtraFields<Type[key], key>;
-}>) : null;
+declare type CollectExtraFields<Type, Key> = IsAnyCompareLeftType extends Type ? never : Type extends ExtraFieldErrorType ? Key : Type extends (infer R)[] ? {
+    0: Values<{
+        [key in keyof R]: CollectExtraFields<R[key], key>;
+    }>;
+    1: never;
+}[R extends object ? 0 : 1] : {
+    0: Values<{
+        [key in keyof Type]: CollectExtraFields<Type[key], key>;
+    }>;
+    1: never;
+}[Type extends object ? 0 : 1];
 declare type SelectString<T> = T extends string ? T : never;
 declare type _ValidateDataTypeExtraFileds<Extra, Type> = SelectString<Extra> extends never ? Type : {
     error: {
-        extraFields: SelectString<Extra>;
+        extraFields: Extra;
     };
 };
-declare type ValidateDataTypeExtraFileds<Type> = _ValidateDataTypeExtraFileds<CollectExtraFields<Type, []>, Type>;
+declare type ValidateDataTypeExtraFileds<Type> = _ValidateDataTypeExtraFileds<CollectExtraFields<Type, never>, Type>;
 declare type RequestBase = {
     api: string;
     query: any;

data/core/hooks.d.ts

@@ -20,6 +20,7 @@ export declare type DataAndStatus<T> = [T | null, ModelStatus];
 export interface Request {
     api: string;
     params?: any;
+    id?: number;
     query: any;
 }
 export declare function useArSyncModel<T>(request: Request | null): DataAndStatus<T>;

data/core/hooks.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.useArSyncFetch = exports.useArSyncModel = exports.initializeHooks = void 0;
 var ArSyncApi_1 = require("./ArSyncApi");
 var ArSyncModel_1 = require("./ArSyncModel");
 var useState;
@@ -19,9 +20,10 @@ function checkHooks() {
 }
 var initialResult = [null, { complete: false, notfound: undefined, connected: true }];
 function useArSyncModel(request) {
+    var _a;
     checkHooks();
-    var _a = useState(initialResult), result = _a[0], setResult = _a[1];
-    var requestString = JSON.stringify(request && request.params);
+    var _b = useState(initialResult), result = _b[0], setResult = _b[1];
+    var requestString = JSON.stringify((_a = request === null || request === void 0 ? void 0 : request.id) !== null && _a !== void 0 ? _a : request === null || request === void 0 ? void 0 : request.params);
     var prevRequestStringRef = useRef(requestString);
     useEffect(function () {
         prevRequestStringRef.current = requestString;
@@ -68,13 +70,14 @@ function extractParams(query, output) {
     return output;
 }
 function useArSyncFetch(request) {
+    var _a;
     checkHooks();
-    var _a = useState(initialFetchState), state = _a[0], setState = _a[1];
+    var _b = useState(initialFetchState), state = _b[0], setState = _b[1];
     var query = request && request.query;
-    var params = request && request.params;
+    var resourceIdentifier = (_a = request === null || request === void 0 ? void 0 : request.id) !== null && _a !== void 0 ? _a : request === null || request === void 0 ? void 0 : request.params;
     var requestString = useMemo(function () {
-        return JSON.stringify(extractParams(query, [params]));
-    }, [query, params]);
+        return JSON.stringify(extractParams(query, [resourceIdentifier]));
+    }, [query, resourceIdentifier]);
     var prevRequestStringRef = useRef(requestString);
     var loader = useMemo(function () {
         var lastLoadId = 0;

data/gemfiles/Gemfile-rails-6

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ar_sync.gemspec
+gemspec path: ".."
+
+gem "activerecord", "~> 6.0.0"
+gem 'ar_serializer', github: 'tompng/ar_serializer'

data/gemfiles/Gemfile-rails-7

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ar_sync.gemspec
+gemspec path: ".."
+
+gem "activerecord", "~> 7.0.0"
+gem 'ar_serializer', github: 'tompng/ar_serializer'

data/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var ArSyncModel_1 = require("./core/ArSyncModel");
-exports.ArSyncModel = ArSyncModel_1.default;
+Object.defineProperty(exports, "ArSyncModel", { enumerable: true, get: function () { return ArSyncModel_1.default; } });
 var ArSyncApi_1 = require("./core/ArSyncApi");
-exports.ArSyncApi = ArSyncApi_1.default;
+Object.defineProperty(exports, "ArSyncApi", { enumerable: true, get: function () { return ArSyncApi_1.default; } });

data/lib/ar_sync/class_methods.rb

@@ -1,9 +1,10 @@
-require_relative 'field'
 require_relative 'collection'
 
 module ArSync::ModelBase::ClassMethods
   def _sync_self?
-    instance_variable_defined? '@_sync_self'
+    return true if defined?(@_sync_self)
+
+    superclass._sync_self? if superclass < ActiveRecord::Base
   end
 
   def _sync_parents_info
@@ -60,30 +61,59 @@ module ArSync::ModelBase::ClassMethods
     _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
+  def _sync_has_many(name, direction: :asc, first: nil, last: nil, preload: nil, association: nil, **option, &data_block)
+    raise ArgumentError, 'direction not in [:asc, :desc]' unless %i[asc desc].include? direction
+    raise ArgumentError, 'first and last cannot be both specified' if first && last
+    raise ArgumentError, 'cannot use first or last with direction: :desc' if direction != :asc && !first && !last
     if data_block.nil? && preload.nil?
-      underscore_name = name.to_s.underscore.to_sym
+      association_name = association || name.to_s.underscore.to_sym
+      order_option_from_params = lambda do |params|
+        if first || last
+          params_first = first && [first, params[:first]&.to_i].compact.min
+          params_last = last && [last, params[:last]&.to_i].compact.min
+          { direction: direction, first: params_first, last: params_last }
+        else
+          {
+            first: params[:first]&.to_i,
+            last: params[:last]&.to_i,
+            order_by: params[:order_by],
+            direction: params[:direction] || :asc
+          }
+        end
+      end
       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
+          self,
+          records,
+          association_name,
+          **order_option_from_params.call(params)
         )
       end
       data_block = lambda do |preloaded, _context, **params|
-        records = preloaded ? preloaded[id] || [] : send(name)
-        next records unless limit || order == :asc
+        records = preloaded ? preloaded[id] || [] : __send__(name)
+        next records unless first || last
         ArSync::CollectionWithOrder.new(
           records,
-          order: (!limit && params && params[:order]) || order,
-          limit: [params && params[:limit]&.to_i, limit].compact.min
+          **order_option_from_params.call(params)
         )
       end
       serializer_data_block = lambda do |preloaded, _context, **_params|
-        preloaded ? preloaded[id] || [] : send(name)
+        preloaded ? preloaded[id] || [] : __send__(name)
+      end
+      if first
+        params_type = { first?: :int }
+      elsif last
+        params_type = { last?: :int }
+      else
+        params_type = lambda do
+          orderable_keys = reflect_on_association(association_name)&.klass&._serializer_orderable_field_keys || []
+          orderable_keys &= [*option[:only]].map(&:to_s) if option[:only]
+          orderable_keys -= [*option[:except]].map(&:to_s) if option[:except]
+          orderable_keys |= ['id']
+          order_by = orderable_keys.size == 1 ? orderable_keys.first : orderable_keys.sort
+          { first?: :int, last?: :int, direction?: %w[asc desc], orderBy?: order_by }
+        end
       end
-      params_type = { limit?: :int, order?: [{ :* => %w[asc desc] }, 'asc', 'desc'] }
     else
       params_type = {}
     end
@@ -104,18 +134,25 @@ module ArSync::ModelBase::ClassMethods
     serializer_field name, **option, namespace: :sync, &data_block
   end
 
-  def sync_define_collection(name, limit: nil, order: :asc)
+  def sync_define_collection(name, first: nil, last: nil, direction: :asc)
     _initialize_sync_callbacks
-    collection = ArSync::Collection.new self, name, limit: limit, order: order
+    collection = ArSync::Collection.new self, name, first: first, last: last, direction: direction
     sync_parent collection, inverse_of: [self, name]
   end
 
   module WriteHook
     def _initialize_sync_info_before_mutation
-      self.class.default_scoped.scoping do
-        @_sync_watch_values_before_mutation ||= _sync_current_watch_values
-        @_sync_parents_info_before_mutation ||= _sync_current_parents_info
-        @_sync_belongs_to_info_before_mutation ||= _sync_current_belongs_to_info
+      return unless defined? @_initialized
+      if new_record?
+        @_sync_watch_values_before_mutation ||= {}
+        @_sync_parents_info_before_mutation ||= {}
+        @_sync_belongs_to_info_before_mutation ||= {}
+      else
+        self.class.default_scoped.scoping do
+          @_sync_watch_values_before_mutation ||= _sync_current_watch_values
+          @_sync_parents_info_before_mutation ||= _sync_current_parents_info
+          @_sync_belongs_to_info_before_mutation ||= _sync_current_belongs_to_info
+        end
       end
     end
     def _write_attribute(attr_name, value)
@@ -129,7 +166,7 @@ module ArSync::ModelBase::ClassMethods
   end
 
   def _initialize_sync_callbacks
-    return if instance_variable_defined? '@_sync_callbacks_initialized'
+    return if defined? @_sync_callbacks_initialized
     @_sync_callbacks_initialized = true
     prepend WriteHook
     attr_reader :_sync_parents_info_before_mutation, :_sync_belongs_to_info_before_mutation, :_sync_watch_values_before_mutation
@@ -140,8 +177,12 @@ module ArSync::ModelBase::ClassMethods
       ArSync.sync_keys self, current_user
     end
 
-    _sync_define :defaults, namespace: :sync do |current_user|
-      { sync_keys: ArSync.sync_keys(self, current_user) }
+    serializer_defaults namespace: :sync do |current_user|
+      { id: id, sync_keys: ArSync.sync_keys(self, current_user) }
+    end
+
+    after_initialize do
+      @_initialized = true
     end
 
     before_destroy do

data/lib/ar_sync/collection.rb

@@ -1,21 +1,26 @@
-require_relative 'field'
-
 class ArSync::Collection
-  attr_reader :klass, :name, :limit, :order
-  def initialize(klass, name, limit: nil, order: nil)
+  attr_reader :klass, :name, :first, :last, :direction, :ordering
+  def initialize(klass, name, first: nil, last: nil, direction: nil)
+    direction ||= :asc
     @klass = klass
     @name = name
-    @limit = limit
-    @order = order
+    @first = first
+    @last = last
+    @direction = direction
+    @ordering = { first: first, last: last, direction: direction }.compact
     self.class.defined_collections[[klass, name]] = self
     define_singleton_method(name) { to_a }
   end
 
   def to_a
-    all = klass.all
-    all = all.order id: order if order
-    all = all.limit limit if limit
-    all
+    if first
+      klass.order(id: direction).limit(first).to_a
+    elsif last
+      rev = direction == :asc ? :desc : :asc
+      klass.order(id: rev).limit(last).reverse
+    else
+      klass.all.to_a
+    end
   end
 
   def self.defined_collections
@@ -45,14 +50,13 @@ class ArSync::Collection
   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)]
+class ArSync::CollectionWithOrder < ArSerializer::CustomSerializable
+  def initialize(records, direction:, first: nil, last: nil)
+    super records do |results|
+      {
+        ordering: { direction: direction || :asc, first: first, last: last }.compact,
+        collection: records.map(&results).compact
+      }
+    end
   end
 end

data/lib/ar_sync/core.rb

@@ -82,17 +82,17 @@ module ArSync
   end
 
   def self.serialize(record_or_records, query, user: nil)
-    ArSerializer.serialize record_or_records, query, context: user, include_id: true, use: :sync
+    ArSerializer.serialize record_or_records, query, context: user, use: :sync
   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
+      serialized = ArSerializer.serialize target, query, context: user, use: :sync
       return serialized if target.is_a? ArSync::ModelBase
       {
         sync_keys: ArSync.sync_keys(target, user),
-        order: { mode: target.order, limit: target.limit },
+        ordering: target.ordering,
         collection: serialized
       }
     when ActiveRecord::Relation, Array

data/lib/ar_sync/instance_methods.rb

@@ -8,7 +8,7 @@ module ArSync::ModelBase::InstanceMethods
     values = {}
     self.class._each_sync_parent do |_, info|
       [*info[:watch]].each do |watch|
-        values[watch] = watch.is_a?(Proc) ? instance_exec(&watch) : send(watch)
+        values[watch] = watch.is_a?(Proc) ? instance_exec(&watch) : __send__(watch)
       end
     end
     values

data/lib/ar_sync/rails.rb

@@ -47,8 +47,8 @@ module ArSync
     end
 
     def sync_call
-      _api_call :sync do |model, current_user, query|
-        ArSync.sync_serialize model, current_user, query
+      _api_call :sync do |schema, current_user, query|
+        ArSync.sync_serialize schema, current_user, query
       end
     end
 
@@ -69,15 +69,8 @@ module ArSync
     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 ArSerializer::Serializable
-          ArSerializer.serialize model, query, context: current_user
-        else
-          model
-        end
+      _api_call :static do |schema, current_user, query|
+        ArSerializer.serialize schema, query, context: current_user
       end
     end
 
@@ -87,15 +80,19 @@ module ArSync
       if respond_to?(ArSync.config.current_user_method)
         current_user = send ArSync.config.current_user_method
       end
+      sch = schema
       responses = params[:requests].map do |request|
         begin
           api_name = request[:api]
-          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 = sch.instance_exec(current_user, api_params, &info.data_block)
-          { data: yield(model, current_user, request[:query].as_json) }
+          raise ArSync::ApiNotFound, "#{type.to_s.capitalize} API named `#{api_name}` not configured" unless sch.class._serializer_field_info api_name
+          query = {
+            api_name => {
+              as: :data,
+              params: request[:params].as_json,
+              attributes: request[:query].as_json
+            }
+          }
+          yield schema, current_user, query
         rescue StandardError => e
           { error: handle_exception(e) }
         end

data/lib/ar_sync/version.rb

@@ -1,3 +1,3 @@
 module ArSync
-  VERSION = '1.0.5'
+  VERSION = '1.1.1'
 end