ar_sync 1.0.3 → 1.1.0

data/core/ConnectionManager.d.ts

@@ -11,7 +11,7 @@ export default class ConnectionManager {
         unsubscribe: () => void;
     };
     subscribe(key: any, func: any): {
-        unsubscribe: () => void;
+        unsubscribe(): void;
     };
     connect(key: any): any;
     disconnect(key: any): void;

data/core/ConnectionManager.js

@@ -1,75 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class ConnectionManager {
-    constructor(adapter) {
+var ConnectionManager = /** @class */ (function () {
+    function ConnectionManager(adapter) {
+        var _this = this;
         this.subscriptions = {};
         this.adapter = adapter;
         this.networkListeners = {};
         this.networkListenerSerial = 0;
         this.networkStatus = true;
-        adapter.ondisconnect = () => {
-            this.unsubscribeAll();
-            this.triggerNetworkChange(false);
+        adapter.ondisconnect = function () {
+            _this.unsubscribeAll();
+            _this.triggerNetworkChange(false);
         };
-        adapter.onreconnect = () => this.triggerNetworkChange(true);
+        adapter.onreconnect = function () { return _this.triggerNetworkChange(true); };
     }
-    triggerNetworkChange(status) {
+    ConnectionManager.prototype.triggerNetworkChange = function (status) {
         if (this.networkStatus == status)
             return;
         this.networkStatus = status;
-        for (const id in this.networkListeners)
+        for (var id in this.networkListeners)
             this.networkListeners[id](status);
-    }
-    unsubscribeAll() {
-        for (const id in this.subscriptions) {
-            const subscription = this.subscriptions[id];
+    };
+    ConnectionManager.prototype.unsubscribeAll = function () {
+        for (var id in this.subscriptions) {
+            var subscription = this.subscriptions[id];
             subscription.listeners = {};
             subscription.connection.unsubscribe();
         }
         this.subscriptions = {};
-    }
-    subscribeNetwork(func) {
-        const id = this.networkListenerSerial++;
+    };
+    ConnectionManager.prototype.subscribeNetwork = function (func) {
+        var _this = this;
+        var id = this.networkListenerSerial++;
         this.networkListeners[id] = func;
-        const unsubscribe = () => {
-            delete this.networkListeners[id];
+        var unsubscribe = function () {
+            delete _this.networkListeners[id];
         };
-        return { unsubscribe };
-    }
-    subscribe(key, func) {
-        const subscription = this.connect(key);
-        const id = subscription.serial++;
+        return { unsubscribe: unsubscribe };
+    };
+    ConnectionManager.prototype.subscribe = function (key, func) {
+        var _this = this;
+        if (!this.networkStatus)
+            return { unsubscribe: function () { } };
+        var subscription = this.connect(key);
+        var id = subscription.serial++;
         subscription.ref++;
         subscription.listeners[id] = func;
-        const unsubscribe = () => {
+        var unsubscribe = function () {
             if (!subscription.listeners[id])
                 return;
             delete subscription.listeners[id];
             subscription.ref--;
             if (subscription.ref === 0)
-                this.disconnect(key);
+                _this.disconnect(key);
         };
-        return { unsubscribe };
-    }
-    connect(key) {
+        return { unsubscribe: unsubscribe };
+    };
+    ConnectionManager.prototype.connect = function (key) {
+        var _this = this;
         if (this.subscriptions[key])
             return this.subscriptions[key];
-        const connection = this.adapter.subscribe(key, data => this.received(key, data));
-        return this.subscriptions[key] = { connection, listeners: {}, ref: 0, serial: 0 };
-    }
-    disconnect(key) {
-        const subscription = this.subscriptions[key];
+        var connection = this.adapter.subscribe(key, function (data) { return _this.received(key, data); });
+        return this.subscriptions[key] = { connection: connection, listeners: {}, ref: 0, serial: 0 };
+    };
+    ConnectionManager.prototype.disconnect = function (key) {
+        var subscription = this.subscriptions[key];
         if (!subscription || subscription.ref !== 0)
             return;
         delete this.subscriptions[key];
         subscription.connection.unsubscribe();
-    }
-    received(key, data) {
-        const subscription = this.subscriptions[key];
+    };
+    ConnectionManager.prototype.received = function (key, data) {
+        var subscription = this.subscriptions[key];
         if (!subscription)
             return;
-        for (const id in subscription.listeners)
+        for (var id in subscription.listeners)
             subscription.listeners[id](data);
-    }
-}
+    };
+    return ConnectionManager;
+}());
 exports.default = ConnectionManager;

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

@@ -1,10 +1,14 @@
 declare let useState: <T>(t: T | (() => T)) => [T, (t: T | ((t: T) => T)) => void];
 declare let useEffect: (f: (() => void) | (() => (() => void)), deps: any[]) => void;
 declare let useMemo: <T>(f: () => T, deps: any[]) => T;
+declare let useRef: <T>(value: T) => {
+    current: T;
+};
 declare type InitializeHooksParams = {
     useState: typeof useState;
     useEffect: typeof useEffect;
     useMemo: typeof useMemo;
+    useRef: typeof useRef;
 };
 export declare function initializeHooks(hooks: InitializeHooksParams): void;
 interface ModelStatus {
@@ -16,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,37 +1,45 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ArSyncApi_1 = require("./ArSyncApi");
-const ArSyncModel_1 = require("./ArSyncModel");
-let useState;
-let useEffect;
-let useMemo;
+exports.useArSyncFetch = exports.useArSyncModel = exports.initializeHooks = void 0;
+var ArSyncApi_1 = require("./ArSyncApi");
+var ArSyncModel_1 = require("./ArSyncModel");
+var useState;
+var useEffect;
+var useMemo;
+var useRef;
 function initializeHooks(hooks) {
     useState = hooks.useState;
     useEffect = hooks.useEffect;
     useMemo = hooks.useMemo;
+    useRef = hooks.useRef;
 }
 exports.initializeHooks = initializeHooks;
 function checkHooks() {
     if (!useState)
-        throw 'uninitialized. needs `initializeHooks({ useState, useEffect, useMemo })`';
+        throw 'uninitialized. needs `initializeHooks({ useState, useEffect, useMemo, useRef })`';
 }
-const initialResult = [null, { complete: false, notfound: undefined, connected: true }];
+var initialResult = [null, { complete: false, notfound: undefined, connected: true }];
 function useArSyncModel(request) {
+    var _a;
     checkHooks();
-    const [result, setResult] = useState(initialResult);
-    const requestString = JSON.stringify(request && request.params);
-    useEffect(() => {
+    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;
         if (!request) {
             setResult(initialResult);
-            return () => { };
+            return function () { };
         }
-        const model = new ArSyncModel_1.default(request, { immutable: true });
+        var model = new ArSyncModel_1.default(request, { immutable: true });
         function update() {
-            const { complete, notfound, connected, data } = model;
-            setResult(resultWas => {
-                const [, statusWas] = resultWas;
-                const statusPersisted = statusWas.complete === complete && statusWas.notfound === notfound && statusWas.connected === connected;
-                const status = statusPersisted ? statusWas : { complete, notfound, connected };
+            var complete = model.complete, notfound = model.notfound, connected = model.connected, data = model.data;
+            setResult(function (resultWas) {
+                var dataWas = resultWas[0], statusWas = resultWas[1];
+                var statusPersisted = statusWas.complete === complete && statusWas.notfound === notfound && statusWas.connected === connected;
+                if (dataWas === data && statusPersisted)
+                    return resultWas;
+                var status = statusPersisted ? statusWas : { complete: complete, notfound: notfound, connected: connected };
                 return [data, status];
             });
         }
@@ -41,21 +49,39 @@ function useArSyncModel(request) {
         else {
             setResult(initialResult);
         }
+        model.subscribe('load', update);
         model.subscribe('change', update);
         model.subscribe('connection', update);
-        return () => model.release();
+        return function () { return model.release(); };
     }, [requestString]);
-    return result;
+    return prevRequestStringRef.current === requestString ? result : initialResult;
 }
 exports.useArSyncModel = useArSyncModel;
-const initialFetchState = { data: null, status: { complete: false, notfound: undefined } };
+var initialFetchState = { data: null, status: { complete: false, notfound: undefined } };
+function extractParams(query, output) {
+    if (output === void 0) { output = []; }
+    if (typeof (query) !== 'object' || query == null || Array.isArray(query))
+        return output;
+    if ('params' in query)
+        output.push(query.params);
+    for (var key in query) {
+        extractParams(query[key], output);
+    }
+    return output;
+}
 function useArSyncFetch(request) {
+    var _a;
     checkHooks();
-    const [state, setState] = useState(initialFetchState);
-    const requestString = JSON.stringify(request && request.params);
-    const loader = useMemo(() => {
-        let lastLoadId = 0;
-        let timer = null;
+    var _b = useState(initialFetchState), state = _b[0], setState = _b[1];
+    var query = request && request.query;
+    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, [resourceIdentifier]));
+    }, [query, resourceIdentifier]);
+    var prevRequestStringRef = useRef(requestString);
+    var loader = useMemo(function () {
+        var lastLoadId = 0;
+        var timer = null;
         function cancel() {
             if (timer)
                 clearTimeout(timer);
@@ -64,28 +90,28 @@ function useArSyncFetch(request) {
         }
         function fetch(request, retryCount) {
             cancel();
-            const currentLoadingId = lastLoadId;
-            ArSyncApi_1.default.fetch(request).then((response) => {
+            var currentLoadingId = lastLoadId;
+            ArSyncApi_1.default.fetch(request).then(function (response) {
                 if (currentLoadingId !== lastLoadId)
                     return;
                 setState({ data: response, status: { complete: true, notfound: false } });
-            }).catch(e => {
+            }).catch(function (e) {
                 if (currentLoadingId !== lastLoadId)
                     return;
                 if (!e.retry) {
                     setState({ data: null, status: { complete: true, notfound: true } });
                     return;
                 }
-                timer = setTimeout(() => fetch(request, retryCount + 1), 1000 * Math.min(4 ** retryCount, 30));
+                timer = setTimeout(function () { return fetch(request, retryCount + 1); }, 1000 * Math.min(Math.pow(4, retryCount), 30));
             });
         }
         function update() {
             if (request) {
-                setState(state => {
-                    const { data, status } = state;
+                setState(function (state) {
+                    var data = state.data, status = state.status;
                     if (!status.complete && status.notfound === undefined)
                         return state;
-                    return { data, status: { complete: false, notfound: undefined } };
+                    return { data: data, status: { complete: false, notfound: undefined } };
                 });
                 fetch(request, 0);
             }
@@ -93,13 +119,15 @@ function useArSyncFetch(request) {
                 setState(initialFetchState);
             }
         }
-        return { update, cancel };
+        return { update: update, cancel: cancel };
     }, [requestString]);
-    useEffect(() => {
+    useEffect(function () {
+        prevRequestStringRef.current = requestString;
         setState(initialFetchState);
         loader.update();
-        return () => loader.cancel();
+        return function () { return loader.cancel(); };
     }, [requestString]);
-    return [state.data, state.status, loader.update];
+    var responseState = prevRequestStringRef.current === requestString ? state : initialFetchState;
+    return [responseState.data, responseState.status, loader.update];
 }
 exports.useArSyncFetch = useArSyncFetch;

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
@@ -21,7 +22,7 @@ module ArSync::ModelBase::ClassMethods
   end
 
   def _each_sync_parent(&block)
-    _sync_parents_info.each(&block)
+    _sync_parents_info.each { |parent, options| block.call(parent, **options) }
     superclass._each_sync_parent(&block) if superclass < ActiveRecord::Base
   end
 
@@ -46,44 +47,73 @@ module ArSync::ModelBase::ClassMethods
     @_sync_self = true
     names.each do |name|
       _sync_children_info[name] = nil
-      _sync_define name, option, &data_block
+      _sync_define name, **option, &data_block
     end
   end
 
   def sync_has_many(name, **option, &data_block)
     _sync_children_info[name] = [:many, option, data_block]
-    _sync_has_many name, option, &data_block
+    _sync_has_many name, **option, &data_block
   end
 
   def sync_has_one(name, **option, &data_block)
     _sync_children_info[name] = [:one, option, data_block]
-    _sync_define name, option, &data_block
+    _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
-      preload = lambda do |records, _context, params|
+      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
+      data_block = lambda do |preloaded, _context, **params|
+        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)
+      serializer_data_block = lambda do |preloaded, _context, **_params|
+        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
@@ -150,12 +191,6 @@ module ArSync::ModelBase::ClassMethods
       @_sync_belongs_to_info_before_mutation ||= _sync_current_belongs_to_info
     end
 
-    before_save on: :create do
-      @_sync_parents_info_before_mutation ||= {}
-      @_sync_watch_values_before_mutation ||= {}
-      @_sync_belongs_to_info_before_mutation ||= {}
-    end
-
     %i[create update destroy].each do |action|
       after_commit on: action do
         next if ArSync.skip_notification?

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