ar_sync 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c79d18d97624ed5b34f6471838d6b96eb6cfb71bba00cee9344a370dbb309498
-  data.tar.gz: c967bed5ff59000fcc8c1de827e98f1b8caef20d71d67532d8203eff4d97724a
+  metadata.gz: 377f042b14b49b79d357904e68e4382639dc1c37159ad9215385fe7e0dc3ecfa
+  data.tar.gz: 808503bd17cf312fdfca041cf7aad54c645c164a77ab1ce83888e5e93c9397ec
 SHA512:
-  metadata.gz: 5966a10dfdce14e70e2df1a0d722889db8ff4bece153bf4d1bd73a8148dd6f79cb4581e254a26deed31c2fe09acbdcd9333cdbf6616ec8d892bfc0758ccd44e3
-  data.tar.gz: 87b53c9634f5afd4b4a1a708ce128d094290d3e5db9a24b70146dc4fc96091760efcdb5b8edf851f3ce83afb13f85e464e556d2c00890c4b36fa852871908d7a
+  metadata.gz: 9eb9a61473330c89049a89bb5ff8448d51b1c47a41b5d52f68d9a2b9826dc69454ea3fef0dceae5287b1c073600354a0be01eea96fc6f6d6a91cc64e611b4d05
+  data.tar.gz: 1a9cc66d3184ec1aca56d6812aa950b1496072b6d1bdab3c7bf9b2c3241e6126359e9900adef7b54cce7cf498181430a8eef211083ddbede087dd616caf08fcb

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    ar_sync (1.0.1)
+    ar_sync (1.0.2)
       activerecord
-      ar_serializer
+      ar_serializer (= 1.0.0)
 
 GEM
   remote: https://rubygems.org/
@@ -14,6 +14,8 @@ GEM
       activemodel (= 5.2.3)
       activesupport (= 5.2.3)
       arel (>= 9.0)
+    activerecord-import (1.0.2)
+      activerecord (>= 3.2)
     activesupport (5.2.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
@@ -44,6 +46,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  activerecord-import
   ar_sync!
   pry
   rake

data/README.md

@@ -39,15 +39,14 @@ end
 
 2. Define apis
 ```ruby
-# app/controllers/sync_api_controller.rb
-class SyncApiController < ApplicationController
-  include ArSync::ApiControllerConcern
+# app/models/sync_schema.rb
+class SyncSchema < ArSync::SyncSchemaBase
   # User-defined api
   serializer_field :my_simple_profile_api do |current_user|
     current_user
   end
-  serializer_field :my_simple_user_api do |current_user, id:|
-    User.where(condition).find id
+  serializer_field :my_simple_friends_api do |current_user, age:|
+    current_user.friends.where(age: age)
   end
   # Reload api (field name = classname, params = `ids:`)
   serializer_field :User do |current_user, ids:|
@@ -103,7 +102,8 @@ rails g ar_sync:types path_to_generated_code_dir/
 ```ts
 import ArSyncModel from 'path_to_generated_code_dir/ArSyncModel'
 import ActionCableAdapter from 'ar_sync/core/ActionCableAdapter'
-ArSyncModel.setConnectionAdapter(new ActionCableAdapter)
+import * as ActionCable from 'actioncable'
+ArSyncModel.setConnectionAdapter(new ActionCableAdapter(ActionCable))
 // ArSyncModel.setConnectionAdapter(new MyCustomConnectionAdapter) // If you are using other transports
 ```
 

data/ar_sync.gemspec

@@ -21,8 +21,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'activerecord'
-  spec.add_dependency 'ar_serializer'
-  %w[rake pry sqlite3].each do |gem_name|
+  spec.add_dependency 'ar_serializer', '1.0.0'
+  %w[rake pry sqlite3 activerecord-import].each do |gem_name|
     spec.add_development_dependency gem_name
   end
 end

data/bin/console

@@ -3,8 +3,7 @@
 require 'bundler/setup'
 require 'ar_sync'
 require 'pry'
-require_relative '../test/model_tree'
-require_relative '../test/model_graph'
+require_relative '../test/model'
 ArSync.on_notification do |events|
   puts "\e[1m#{events.inspect}\e[m"
 end

data/core/ActioncableAdapter.d.ts

@@ -1,10 +1,34 @@
-import * as ActionCable from 'actioncable';
 import ConnectionAdapter from './ConnectionAdapter';
+declare module ActionCable {
+    function createConsumer(): Cable;
+    interface Cable {
+        subscriptions: Subscriptions;
+    }
+    interface CreateMixin {
+        connected: () => void;
+        disconnected: () => void;
+        received: (obj: any) => void;
+    }
+    interface ChannelNameWithParams {
+        channel: string;
+        [key: string]: any;
+    }
+    interface Subscriptions {
+        create(channel: ChannelNameWithParams, obj: CreateMixin): Channel;
+    }
+    interface Channel {
+        unsubscribe(): void;
+        perform(action: string, data: {}): void;
+        send(data: any): boolean;
+    }
+}
 export default class ActionCableAdapter implements ConnectionAdapter {
     connected: boolean;
     _cable: ActionCable.Cable;
-    constructor();
+    actionCableClass: typeof ActionCable;
+    constructor(actionCableClass: typeof ActionCable);
     subscribe(key: string, received: (data: any) => void): ActionCable.Channel;
     ondisconnect(): void;
     onreconnect(): void;
 }
+export {};

data/core/ActioncableAdapter.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ActionCable = require("actioncable");
 class ActionCableAdapter {
-    constructor() {
+    constructor(actionCableClass) {
         this.connected = true;
+        this.actionCableClass = actionCableClass;
         this.subscribe(Math.random().toString(), () => { });
     }
     subscribe(key, received) {
@@ -20,7 +20,7 @@ class ActionCableAdapter {
             this.onreconnect();
         };
         if (!this._cable)
-            this._cable = ActionCable.createConsumer();
+            this._cable = this.actionCableClass.createConsumer();
         return this._cable.subscriptions.create({ channel: 'SyncChannel', key }, { received, disconnected, connected });
     }
     ondisconnect() { }

data/core/ArSyncApi.d.ts

@@ -1,5 +1,8 @@
-declare const _default: {
-    fetch: (request: object) => Promise<{}>;
-    syncFetch: (request: object) => Promise<{}>;
+declare function apiBatchFetch(endpoint: string, requests: object[]): Promise<any>;
+declare const ArSyncApi: {
+    domain: string | null;
+    _batchFetch: typeof apiBatchFetch;
+    fetch: (request: object) => Promise<unknown>;
+    syncFetch: (request: object) => Promise<unknown>;
 };
-export default _default;
+export default ArSyncApi;

data/core/ArSyncApi.js

@@ -7,6 +7,8 @@ async function apiBatchFetch(endpoint, requests) {
     };
     const body = JSON.stringify({ requests });
     const option = { credentials: 'include', method: 'POST', headers, body };
+    if (ArSyncApi.domain)
+        endpoint = ArSyncApi.domain + endpoint;
     const res = await fetch(endpoint, option);
     if (res.status === 200)
         return res.json();
@@ -41,7 +43,7 @@ class ApiFetcher {
                     }
                 }
                 this.batches = [];
-                apiBatchFetch(this.endpoint, requests).then((results) => {
+                ArSyncApi._batchFetch(this.endpoint, requests).then((results) => {
                     for (const i in callbacksList) {
                         const result = results[i];
                         const callbacks = callbacksList[i];
@@ -51,11 +53,11 @@ class ApiFetcher {
                             }
                             else {
                                 const error = result.error || { type: 'Unknown Error' };
-                                callback.reject(error);
+                                callback.reject(Object.assign(Object.assign({}, error), { retry: false }));
                             }
                         }
                     }
-                }).catch((e) => {
+                }).catch(e => {
                     const error = { type: e.name, message: e.message, retry: true };
                     for (const callbacks of callbacksList) {
                         for (const callback of callbacks)
@@ -68,7 +70,10 @@ class ApiFetcher {
 }
 const staticFetcher = new ApiFetcher('/static_api');
 const syncFetcher = new ApiFetcher('/sync_api');
-exports.default = {
+const ArSyncApi = {
+    domain: null,
+    _batchFetch: apiBatchFetch,
     fetch: (request) => staticFetcher.fetch(request),
     syncFetch: (request) => syncFetcher.fetch(request),
 };
+exports.default = ArSyncApi;

data/core/{ArSyncModelBase.d.ts → ArSyncModel.d.ts}

@@ -1,9 +1,10 @@
+import ConnectionAdapter from './ConnectionAdapter';
 interface Request {
     api: string;
     query: any;
     params?: any;
 }
-declare type Path = (string | number)[];
+declare type Path = Readonly<(string | number)[]>;
 interface Change {
     path: Path;
     value: any;
@@ -13,14 +14,13 @@ declare type LoadCallback = () => void;
 declare type ConnectionCallback = (status: boolean) => void;
 declare type SubscriptionType = 'load' | 'change' | 'connection';
 declare type SubscriptionCallback = ChangeCallback | LoadCallback | ConnectionCallback;
-interface Adapter {
-    subscribe: (key: string, received: (data: any) => void) => {
-        unsubscribe: () => void;
-    };
-    ondisconnect: () => void;
-    onreconnect: () => void;
-}
-export default abstract class ArSyncModelBase<T> {
+declare type PathFirst<P extends Readonly<any[]>> = ((...args: P) => void) extends (first: infer First, ...other: any) => void ? First : never;
+declare type PathRest<U> = U extends Readonly<any[]> ? ((...args: U) => any) extends (head: any, ...args: infer T) => any ? U extends Readonly<[any, any, ...any[]]> ? T : never : never : never;
+declare type DigResult<Data, P extends Readonly<any[]>> = Data extends null | undefined ? Data : PathFirst<P> extends never ? Data : PathFirst<P> extends keyof Data ? (Data extends Readonly<any[]> ? undefined : never) | {
+    0: Data[PathFirst<P>];
+    1: DigResult<Data[PathFirst<P>], PathRest<P>>;
+}[PathRest<P> extends never ? 0 : 1] : undefined;
+export default class ArSyncModel<T> {
     private _ref;
     private _listenerSerial;
     private _listeners;
@@ -37,10 +37,6 @@ export default abstract class ArSyncModelBase<T> {
         };
     };
     static cacheTimeout: number;
-    abstract refManagerClass(): any;
-    abstract connectionManager(): {
-        networkStatus: boolean;
-    };
     constructor(request: Request, option?: {
         immutable: boolean;
     });
@@ -48,6 +44,8 @@ export default abstract class ArSyncModelBase<T> {
     subscribeOnce(event: SubscriptionType, callback: SubscriptionCallback): {
         unsubscribe: () => void;
     };
+    dig<P extends Path>(path: P): DigResult<T, P> | null;
+    static digData<Data, P extends Path>(data: Data, path: P): DigResult<Data, P>;
     subscribe(event: SubscriptionType, callback: SubscriptionCallback): {
         unsubscribe: () => void;
     };
@@ -60,12 +58,9 @@ export default abstract class ArSyncModelBase<T> {
         timer: number | null;
         model: any;
     };
-    static createRefModel(_request: Request, _option?: {
-        immutable: boolean;
-    }): void;
     static _detach(ref: any): void;
     private static _attach;
-    static setConnectionAdapter(_adapter: Adapter): void;
-    static waitForLoad(...models: ArSyncModelBase<{}>[]): Promise<{}>;
+    static setConnectionAdapter(adapter: ConnectionAdapter): void;
+    static waitForLoad(...models: ArSyncModel<{}>[]): Promise<unknown>;
 }
 export {};

data/core/{ArSyncModelBase.js → ArSyncModel.js}

@@ -1,12 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-class ArSyncModelBase {
+const ArSyncStore_1 = require("./ArSyncStore");
+const ConnectionManager_1 = require("./ConnectionManager");
+class ArSyncModel {
     constructor(request, option) {
-        this._ref = this.refManagerClass().retrieveRef(request, option);
+        this._ref = ArSyncModel.retrieveRef(request, option);
         this._listenerSerial = 0;
         this._listeners = {};
         this.complete = false;
-        this.connected = this.connectionManager().networkStatus;
+        this.connected = ArSyncStore_1.default.connectionManager.networkStatus;
         const setData = () => {
             this.data = this._ref.model.data;
             this.complete = this._ref.model.complete;
@@ -29,6 +31,26 @@ class ArSyncModelBase {
         });
         return subscription;
     }
+    dig(path) {
+        return ArSyncModel.digData(this.data, path);
+    }
+    static digData(data, path) {
+        function dig(data, path) {
+            if (path.length === 0)
+                return data;
+            if (data == null)
+                return data;
+            const key = path[0];
+            const other = path.slice(1);
+            if (Array.isArray(data)) {
+                return this.digData(data.find(el => el.id === key), other);
+            }
+            else {
+                return this.digData(data[key], other);
+            }
+        }
+        return dig(data, path);
+    }
     subscribe(event, callback) {
         const id = this._listenerSerial++;
         const subscription = this._ref.model.subscribe(event, callback);
@@ -56,22 +78,19 @@ class ArSyncModelBase {
         for (const id in this._listeners)
             this._listeners[id].unsubscribe();
         this._listeners = {};
-        this.refManagerClass()._detach(this._ref);
+        ArSyncModel._detach(this._ref);
         this._ref = null;
     }
     static retrieveRef(request, option) {
         const key = JSON.stringify([request, option]);
         let ref = this._cache[key];
         if (!ref) {
-            const model = this.createRefModel(request, option);
+            const model = new ArSyncStore_1.default(request, option);
             ref = this._cache[key] = { key, count: 0, timer: null, model };
         }
         this._attach(ref);
         return ref;
     }
-    static createRefModel(_request, _option) {
-        throw 'abstract method';
-    }
     static _detach(ref) {
         ref.count--;
         const timeout = this.cacheTimeout;
@@ -93,7 +112,9 @@ class ArSyncModelBase {
         if (ref.timer)
             clearTimeout(ref.timer);
     }
-    static setConnectionAdapter(_adapter) { }
+    static setConnectionAdapter(adapter) {
+        ArSyncStore_1.default.connectionManager = new ConnectionManager_1.default(adapter);
+    }
     static waitForLoad(...models) {
         return new Promise((resolve) => {
             let count = 0;
@@ -107,4 +128,6 @@ class ArSyncModelBase {
         });
     }
 }
-exports.default = ArSyncModelBase;
+exports.default = ArSyncModel;
+ArSyncModel._cache = {};
+ArSyncModel.cacheTimeout = 10 * 1000;

data/{graph → core}/ArSyncStore.d.ts

@@ -1,9 +1,9 @@
 export default class ArSyncStore {
-    immutable: any;
-    markedForFreezeObjects: any;
+    immutable: boolean;
+    markedForFreezeObjects: any[];
     changes: any;
     eventListeners: any;
-    markForRelease: any;
+    markForRelease: true | undefined;
     container: any;
     request: any;
     complete: boolean;

data/{graph → core}/ArSyncStore.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ArSyncApi_1 = require("../core/ArSyncApi");
+const ArSyncApi_1 = require("./ArSyncApi");
 const ModelBatchRequest = {
     timer: null,
     apiRequests: {},
@@ -87,7 +87,59 @@ class ArSyncContainerBase {
             l.unsubscribe();
         this.listeners = [];
     }
-    static parseQuery(query, attrsonly = false) {
+    static compactQuery(query) {
+        function compactAttributes(attributes) {
+            const attrs = {};
+            const keys = [];
+            for (const key in attributes) {
+                const c = compactQuery(attributes[key]);
+                if (c === true) {
+                    keys.push(key);
+                }
+                else {
+                    attrs[key] = c;
+                }
+            }
+            if (Object.keys(attrs).length === 0) {
+                if (keys.length === 0)
+                    return [true, false];
+                if (keys.length === 1)
+                    return [keys[0], false];
+                return [keys];
+            }
+            const needsEscape = attrs['attributes'] || attrs['params'] || attrs['as'];
+            if (keys.length === 0)
+                return [attrs, needsEscape];
+            return [[...keys, attrs], needsEscape];
+        }
+        function compactQuery(query) {
+            if (!('attributes' in query))
+                return true;
+            const { as, params } = query;
+            const [attributes, needsEscape] = compactAttributes(query.attributes);
+            if (as == null && params == null) {
+                if (needsEscape)
+                    return { attributes };
+                return attributes;
+            }
+            const result = {};
+            if (as)
+                result.as = as;
+            if (params)
+                result.params = params;
+            if (attributes !== true)
+                result.attributes = attributes;
+            return result;
+        }
+        try {
+            const result = compactQuery(query);
+            return result === true ? {} : result;
+        }
+        catch (e) {
+            throw JSON.stringify(query) + e.stack;
+        }
+    }
+    static parseQuery(query, attrsonly) {
         const attributes = {};
         let column = null;
         let params = null;
@@ -129,15 +181,19 @@ class ArSyncContainerBase {
     }
     static _load({ api, id, params, query }, root) {
         const parsedQuery = ArSyncRecord.parseQuery(query);
+        const compactQuery = ArSyncRecord.compactQuery(parsedQuery);
         if (id) {
-            return ModelBatchRequest.fetch(api, query, id).then(data => new ArSyncRecord(parsedQuery, data[0], null, root));
+            return ModelBatchRequest.fetch(api, compactQuery, id).then(data => new ArSyncRecord(parsedQuery, data, null, root));
         }
         else {
-            const request = { api, query, params };
+            const request = { api, query: compactQuery, params };
             return ArSyncApi_1.default.syncFetch(request).then((response) => {
                 if (response.collection && response.order) {
                     return new ArSyncCollection(response.sync_keys, 'collection', parsedQuery, response, request, root);
                 }
+                else if (response instanceof Array) {
+                    return new ArSyncCollection([], '', parsedQuery, response, request, root);
+                }
                 else {
                     return new ArSyncRecord(parsedQuery, response, request, root);
                 }
@@ -176,7 +232,6 @@ class ArSyncRecord extends ArSyncContainerBase {
         this.sync_keys = sync_keys;
         if (!this.sync_keys) {
             this.sync_keys = [];
-            console.error('warning: no sync_keys');
         }
     }
     replaceData(data) {
@@ -191,11 +246,12 @@ class ArSyncRecord extends ArSyncContainerBase {
             const subQuery = this.query.attributes[key];
             const aliasName = subQuery.as || key;
             const subData = data[aliasName];
+            const child = this.children[aliasName];
             if (key === 'sync_keys')
                 continue;
-            if (subQuery.attributes && (subData instanceof Array || (subData && subData.collection && subData.order))) {
-                if (this.children[aliasName]) {
-                    this.children[aliasName].replaceData(subData, this.sync_keys);
+            if (subData instanceof Array || (subData && subData.collection && subData.order)) {
+                if (child) {
+                    child.replaceData(subData, this.sync_keys);
                 }
                 else {
                     const collection = new ArSyncCollection(this.sync_keys, key, subQuery, subData, null, this.root);
@@ -207,11 +263,11 @@ class ArSyncRecord extends ArSyncContainerBase {
                 }
             }
             else {
-                if (subQuery.attributes)
+                if (subQuery.attributes && Object.keys(subQuery.attributes).length > 0)
                     this.paths.push(key);
                 if (subData && subData.sync_keys) {
-                    if (this.children[aliasName]) {
-                        this.children[aliasName].replaceData(subData);
+                    if (child) {
+                        child.replaceData(subData);
                     }
                     else {
                         const model = new ArSyncRecord(subQuery, subData, null, this.root);
@@ -223,8 +279,8 @@ class ArSyncRecord extends ArSyncContainerBase {
                     }
                 }
                 else {
-                    if (this.children[aliasName]) {
-                        this.children[aliasName].release();
+                    if (child) {
+                        child.release();
                         delete this.children[aliasName];
                     }
                     if (this.data[aliasName] !== subData) {
@@ -234,39 +290,55 @@ class ArSyncRecord extends ArSyncContainerBase {
                 }
             }
         }
+        if (this.query.attributes['*']) {
+            for (const key in data) {
+                if (!this.query.attributes[key] && this.data[key] !== data[key]) {
+                    this.mark();
+                    this.data[key] = data[key];
+                }
+            }
+        }
         this.subscribeAll();
     }
     onNotify(notifyData, path) {
         const { action, class_name, id } = notifyData;
+        const query = path && this.query.attributes[path];
+        const aliasName = (query && query.as) || path;
         if (action === 'remove') {
-            this.children[path].release();
-            this.children[path] = null;
+            const child = this.children[aliasName];
+            if (child)
+                child.release();
+            this.children[aliasName] = null;
             this.mark();
-            this.data[path] = null;
-            this.onChange([path], null);
+            this.data[aliasName] = null;
+            this.onChange([aliasName], null);
         }
         else if (action === 'add') {
-            if (this.data.id === id)
+            if (this.data[aliasName] && this.data[aliasName].id === id)
                 return;
-            const query = this.query.attributes[path];
-            ModelBatchRequest.fetch(class_name, query, id).then(data => {
-                if (!data)
+            ModelBatchRequest.fetch(class_name, ArSyncRecord.compactQuery(query), id).then(data => {
+                if (!data || !this.data)
                     return;
                 const model = new ArSyncRecord(query, data, null, this.root);
-                if (this.children[path])
-                    this.children[path].release();
-                this.children[path] = model;
+                const child = this.children[aliasName];
+                if (child)
+                    child.release();
+                this.children[aliasName] = model;
                 this.mark();
-                this.data[path] = model.data;
+                this.data[aliasName] = model.data;
                 model.parentModel = this;
-                model.parentKey = path;
-                this.onChange([path], model.data);
+                model.parentKey = aliasName;
+                this.onChange([aliasName], model.data);
             });
         }
         else {
-            ModelBatchRequest.fetch(class_name, this.reloadQuery(), id).then(data => {
-                this.update(data);
-            });
+            const { field } = notifyData;
+            const query = field ? this.patchQuery(field) : this.reloadQuery();
+            if (query)
+                ModelBatchRequest.fetch(class_name, query, id).then(data => {
+                    if (this.data)
+                        this.update(data);
+                });
         }
     }
     subscribeAll() {
@@ -280,6 +352,24 @@ class ArSyncRecord extends ArSyncContainerBase {
                 this.subscribe(key + path, pathCallback);
         }
     }
+    patchQuery(key) {
+        const val = this.query.attributes[key];
+        if (!val)
+            return;
+        let { attributes, as, params } = val;
+        if (attributes && Object.keys(val.attributes).length === 0)
+            attributes = null;
+        if (!attributes && !as && !params)
+            return key;
+        const result = {};
+        if (attributes)
+            result.attributes = attributes;
+        if (as)
+            result.as = as;
+        if (params)
+            result.params = params;
+        return result;
+    }
     reloadQuery() {
         if (this.reloadQueryCache)
             return this.reloadQueryCache;
@@ -299,6 +389,9 @@ class ArSyncRecord extends ArSyncContainerBase {
     }
     update(data) {
         for (const key in data) {
+            const subQuery = this.query.attributes[key];
+            if (subQuery && subQuery.attributes && Object.keys(subQuery.attributes).length > 0)
+                continue;
             if (this.data[key] === data[key])
                 continue;
             this.mark();
@@ -318,35 +411,51 @@ class ArSyncRecord extends ArSyncContainerBase {
         if (this.parentModel)
             this.parentModel.markAndSet(this.parentKey, this.data);
     }
-    onChange(path, data) {
-        if (this.parentModel)
-            this.parentModel.onChange([this.parentKey, ...path], data);
-    }
 }
 class ArSyncCollection extends ArSyncContainerBase {
     constructor(sync_keys, path, query, data, request, root) {
         super();
+        this.order = { limit: null, mode: 'asc', key: 'id' };
+        this.aliasOrderKey = 'id';
         this.root = root;
         this.path = path;
+        this.query = query;
+        this.compactQuery = ArSyncRecord.compactQuery(query);
         if (request)
             this.initForReload(request);
         if (query.params && (query.params.order || query.params.limit)) {
-            this.order = { limit: query.params.limit, mode: query.params.order || 'asc' };
-        }
-        else {
-            this.order = { limit: null, mode: 'asc' };
+            this.setOrdering(query.params.limit, query.params.order);
         }
-        this.query = query;
         this.data = [];
         this.children = [];
         this.replaceData(data, sync_keys);
     }
+    setOrdering(limit, order) {
+        let mode = 'asc';
+        let key = 'id';
+        if (order === 'asc' || order === 'desc') {
+            mode = order;
+        }
+        else if (typeof order === 'object' && order) {
+            const keys = Object.keys(order);
+            if (keys.length > 1)
+                throw 'multiple order keys are not supported';
+            if (keys.length === 1)
+                key = keys[0];
+            mode = order[key] === 'asc' ? 'asc' : 'desc';
+        }
+        const limitNumber = (typeof limit === 'number') ? limit : null;
+        if (limitNumber !== null && key !== 'id')
+            throw 'limit with custom order key is not supported';
+        const subQuery = this.query.attributes[key];
+        this.aliasOrderKey = (subQuery && subQuery.as) || key;
+        this.order = { limit: limitNumber, mode, key };
+    }
     setSyncKeys(sync_keys) {
         if (sync_keys) {
             this.sync_keys = sync_keys.map(key => key + this.path);
         }
         else {
-            console.error('warning: no sync_keys');
             this.sync_keys = [];
         }
     }
@@ -356,9 +465,9 @@ class ArSyncCollection extends ArSyncContainerBase {
         for (const child of this.children)
             existings[child.data.id] = child;
         let collection;
-        if (data.collection && data.order) {
+        if ('collection' in data && 'order' in data) {
             collection = data.collection;
-            this.order = data.order;
+            this.setOrdering(data.order.limit, data.order.mode);
         }
         else {
             collection = data;
@@ -366,17 +475,23 @@ class ArSyncCollection extends ArSyncContainerBase {
         const newChildren = [];
         const newData = [];
         for (const subData of collection) {
-            let model = existings[subData.id];
+            let model = null;
+            if (typeof (subData) === 'object' && subData && 'id' in subData)
+                model = existings[subData.id];
+            let data = subData;
             if (model) {
                 model.replaceData(subData);
             }
-            else {
+            else if (subData.id) {
                 model = new ArSyncRecord(this.query, subData, null, this.root);
                 model.parentModel = this;
                 model.parentKey = subData.id;
             }
-            newChildren.push(model);
-            newData.push(model.data);
+            if (model) {
+                newChildren.push(model);
+                data = model.data;
+            }
+            newData.push(data);
         }
         while (this.children.length) {
             const child = this.children.pop();
@@ -408,8 +523,8 @@ class ArSyncCollection extends ArSyncContainerBase {
                     return;
             }
         }
-        ModelBatchRequest.fetch(className, this.query, id).then((data) => {
-            if (!data)
+        ModelBatchRequest.fetch(className, this.compactQuery, id).then((data) => {
+            if (!data || !this.data)
                 return;
             const model = new ArSyncRecord(this.query, data, null, this.root);
             model.parentModel = this;
@@ -417,14 +532,13 @@ class ArSyncCollection extends ArSyncContainerBase {
             const overflow = this.order.limit && this.order.limit === this.data.length;
             let rmodel;
             this.mark();
+            const orderKey = this.aliasOrderKey;
             if (this.order.mode === 'asc') {
                 const last = this.data[this.data.length - 1];
                 this.children.push(model);
                 this.data.push(model.data);
-                if (last && last.id > id) {
-                    this.children.sort((a, b) => a.data.id < b.data.id ? -1 : +1);
-                    this.data.sort((a, b) => a.id < b.id ? -1 : +1);
-                }
+                if (last && last[orderKey] > data[orderKey])
+                    this.markAndSort();
                 if (overflow) {
                     rmodel = this.children.shift();
                     rmodel.release();
@@ -435,10 +549,8 @@ class ArSyncCollection extends ArSyncContainerBase {
                 const first = this.data[0];
                 this.children.unshift(model);
                 this.data.unshift(model.data);
-                if (first && first.id > id) {
-                    this.children.sort((a, b) => a.data.id > b.data.id ? -1 : +1);
-                    this.data.sort((a, b) => a.id > b.id ? -1 : +1);
-                }
+                if (first && first[orderKey] > data[orderKey])
+                    this.markAndSort();
                 if (overflow) {
                     rmodel = this.children.pop();
                     rmodel.release();
@@ -450,6 +562,18 @@ class ArSyncCollection extends ArSyncContainerBase {
                 this.onChange([rmodel.id], null);
         });
     }
+    markAndSort() {
+        this.mark();
+        const orderKey = this.aliasOrderKey;
+        if (this.order.mode === 'asc') {
+            this.children.sort((a, b) => a.data[orderKey] < b.data[orderKey] ? -1 : +1);
+            this.data.sort((a, b) => a[orderKey] < b[orderKey] ? -1 : +1);
+        }
+        else {
+            this.children.sort((a, b) => a.data[orderKey] > b.data[orderKey] ? -1 : +1);
+            this.data.sort((a, b) => a[orderKey] > b[orderKey] ? -1 : +1);
+        }
+    }
     consumeRemove(id) {
         const idx = this.data.findIndex(a => a.id === id);
         if (idx < 0)
@@ -473,6 +597,11 @@ class ArSyncCollection extends ArSyncContainerBase {
         for (const key of this.sync_keys)
             this.subscribe(key, callback);
     }
+    onChange(path, data) {
+        super.onChange(path, data);
+        if (path[1] === this.aliasOrderKey)
+            this.markAndSort();
+    }
     markAndSet(id, data) {
         this.mark();
         const idx = this.data.findIndex(a => a.id === id);
@@ -490,7 +619,7 @@ class ArSyncCollection extends ArSyncContainerBase {
 }
 class ArSyncStore {
     constructor(request, { immutable } = {}) {
-        this.immutable = immutable;
+        this.immutable = !!immutable;
         this.markedForFreezeObjects = [];
         this.changes = [];
         this.eventListeners = { events: {}, serial: 0 };
@@ -521,6 +650,8 @@ class ArSyncStore {
                 this.trigger('connection', state);
             };
         }).catch(e => {
+            if (!e || e.retry === undefined)
+                throw e;
             if (this.markForRelease)
                 return;
             if (!e.retry) {