ar_sync 1.0.3 → 1.1.0

data/core/ArSyncStore.js

@@ -1,98 +1,167 @@
 "use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __spreadArrays = (this && this.__spreadArrays) || function () {
+    for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
+    for (var r = Array(s), k = 0, i = 0; i < il; i++)
+        for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
+            r[k] = a[j];
+    return r;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const ArSyncApi_1 = require("./ArSyncApi");
-const ModelBatchRequest = {
-    timer: null,
-    apiRequests: {},
-    fetch(api, query, id) {
+var ArSyncApi_1 = require("./ArSyncApi");
+var ModelBatchRequest = /** @class */ (function () {
+    function ModelBatchRequest() {
+        this.timer = null;
+        this.apiRequests = new Map();
+    }
+    ModelBatchRequest.prototype.fetch = function (api, query, id) {
+        var _this = this;
         this.setTimer();
-        return new Promise(resolve => {
-            const queryJSON = JSON.stringify(query);
-            const apiRequest = this.apiRequests[api] = this.apiRequests[api] || {};
-            const queryRequests = apiRequest[queryJSON] = apiRequest[queryJSON] || { query, requests: {} };
-            const request = queryRequests.requests[id] = queryRequests.requests[id] || { id, callbacks: [] };
-            request.callbacks.push(resolve);
+        return new Promise(function (resolve, reject) {
+            var queryJSON = JSON.stringify(query);
+            var apiRequest = _this.apiRequests.get(api);
+            if (!apiRequest)
+                _this.apiRequests.set(api, apiRequest = new Map());
+            var queryRequests = apiRequest.get(queryJSON);
+            if (!queryRequests)
+                apiRequest.set(queryJSON, queryRequests = { query: query, requests: new Map() });
+            var request = queryRequests.requests.get(id);
+            if (!request)
+                queryRequests.requests.set(id, request = { id: id, callbacks: [] });
+            request.callbacks.push({ resolve: resolve, reject: reject });
         });
-    },
-    batchFetch() {
-        const { apiRequests } = this;
-        for (const api in apiRequests) {
-            const apiRequest = apiRequests[api];
-            for (const { query, requests } of Object.values(apiRequest)) {
-                const ids = Object.values(requests).map(({ id }) => id);
-                ArSyncApi_1.default.syncFetch({ api, query, params: { ids } }).then((models) => {
-                    for (const model of models)
-                        requests[model.id].model = model;
-                    for (const { model, callbacks } of Object.values(requests)) {
-                        for (const callback of callbacks)
-                            callback(model);
+    };
+    ModelBatchRequest.prototype.batchFetch = function () {
+        this.apiRequests.forEach(function (apiRequest, api) {
+            apiRequest.forEach(function (_a) {
+                var query = _a.query, requests = _a.requests;
+                var ids = Array.from(requests.keys());
+                ArSyncApi_1.default.syncFetch({ api: api, query: query, params: { ids: ids } }).then(function (models) {
+                    for (var _i = 0, models_1 = models; _i < models_1.length; _i++) {
+                        var model = models_1[_i];
+                        var req = requests.get(model.id);
+                        if (req)
+                            req.model = model;
                     }
+                    requests.forEach(function (_a) {
+                        var model = _a.model, callbacks = _a.callbacks;
+                        callbacks.forEach(function (cb) { return cb.resolve(model); });
+                    });
+                }).catch(function (e) {
+                    requests.forEach(function (_a) {
+                        var callbacks = _a.callbacks;
+                        callbacks.forEach(function (cb) { return cb.reject(e); });
+                    });
                 });
-            }
-        }
-        this.apiRequests = {};
-    },
-    setTimer() {
+            });
+        });
+        this.apiRequests.clear();
+    };
+    ModelBatchRequest.prototype.setTimer = function () {
+        var _this = this;
         if (this.timer)
             return;
-        this.timer = setTimeout(() => {
-            this.timer = null;
-            this.batchFetch();
+        this.timer = setTimeout(function () {
+            _this.timer = null;
+            _this.batchFetch();
         }, 20);
-    }
-};
-class ArSyncContainerBase {
-    constructor() {
+    };
+    return ModelBatchRequest;
+}());
+var modelBatchRequest = new ModelBatchRequest;
+var ArSyncContainerBase = /** @class */ (function () {
+    function ArSyncContainerBase() {
         this.listeners = [];
     }
-    replaceData(_data, _sync_keys) { }
-    initForReload(request) {
-        this.networkSubscriber = ArSyncStore.connectionManager.subscribeNetwork((state) => {
-            if (state) {
-                ArSyncApi_1.default.syncFetch(request).then(data => {
-                    if (this.data) {
-                        this.replaceData(data);
-                        if (this.onConnectionChange)
-                            this.onConnectionChange(true);
-                        if (this.onChange)
-                            this.onChange([], this.data);
+    ArSyncContainerBase.prototype.replaceData = function (_data, _sync_keys) { };
+    ArSyncContainerBase.prototype.initForReload = function (request) {
+        var _this = this;
+        this.networkSubscriber = ArSyncStore.connectionManager.subscribeNetwork(function (state) {
+            if (!state) {
+                if (_this.onConnectionChange)
+                    _this.onConnectionChange(false);
+                return;
+            }
+            if (request.id != null) {
+                modelBatchRequest.fetch(request.api, request.query, request.id).then(function (data) {
+                    if (_this.data && data) {
+                        _this.replaceData(data);
+                        if (_this.onConnectionChange)
+                            _this.onConnectionChange(true);
+                        if (_this.onChange)
+                            _this.onChange([], _this.data);
                     }
                 });
             }
             else {
-                if (this.onConnectionChange)
-                    this.onConnectionChange(false);
+                ArSyncApi_1.default.syncFetch(request).then(function (data) {
+                    if (_this.data && data) {
+                        _this.replaceData(data);
+                        if (_this.onConnectionChange)
+                            _this.onConnectionChange(true);
+                        if (_this.onChange)
+                            _this.onChange([], _this.data);
+                    }
+                }).catch(function (e) {
+                    console.error("failed to reload. " + e);
+                });
             }
         });
-    }
-    release() {
+    };
+    ArSyncContainerBase.prototype.release = function () {
         if (this.networkSubscriber)
             this.networkSubscriber.unsubscribe();
         this.unsubscribeAll();
-        for (const child of Object.values(this.children)) {
+        for (var _i = 0, _a = Object.values(this.children); _i < _a.length; _i++) {
+            var child = _a[_i];
             if (child)
                 child.release();
         }
         this.data = null;
-    }
-    onChange(path, data) {
+    };
+    ArSyncContainerBase.prototype.onChange = function (path, data) {
         if (this.parentModel)
-            this.parentModel.onChange([this.parentKey, ...path], data);
-    }
-    subscribe(key, listener) {
+            this.parentModel.onChange(__spreadArrays([this.parentKey], path), data);
+    };
+    ArSyncContainerBase.prototype.subscribe = function (key, listener) {
         this.listeners.push(ArSyncStore.connectionManager.subscribe(key, listener));
-    }
-    unsubscribeAll() {
-        for (const l of this.listeners)
+    };
+    ArSyncContainerBase.prototype.unsubscribeAll = function () {
+        for (var _i = 0, _a = this.listeners; _i < _a.length; _i++) {
+            var l = _a[_i];
             l.unsubscribe();
+        }
         this.listeners = [];
-    }
-    static compactQuery(query) {
+    };
+    ArSyncContainerBase.compactQuery = function (query) {
         function compactAttributes(attributes) {
-            const attrs = {};
-            const keys = [];
-            for (const key in attributes) {
-                const c = compactQuery(attributes[key]);
+            var attrs = {};
+            var keys = [];
+            for (var key in attributes) {
+                var c = compactQuery(attributes[key]);
                 if (c === true) {
                     keys.push(key);
                 }
@@ -105,24 +174,24 @@ class ArSyncContainerBase {
                     return [true, false];
                 if (keys.length === 1)
                     return [keys[0], false];
-                return [keys];
+                return [keys, false];
             }
-            const needsEscape = attrs['attributes'] || attrs['params'] || attrs['as'];
+            var needsEscape = attrs['attributes'] || attrs['params'] || attrs['as'];
             if (keys.length === 0)
                 return [attrs, needsEscape];
-            return [[...keys, attrs], needsEscape];
+            return [__spreadArrays(keys, [attrs]), needsEscape];
         }
         function compactQuery(query) {
             if (!('attributes' in query))
                 return true;
-            const { as, params } = query;
-            const [attributes, needsEscape] = compactAttributes(query.attributes);
+            var as = query.as, params = query.params;
+            var _a = compactAttributes(query.attributes), attributes = _a[0], needsEscape = _a[1];
             if (as == null && params == null) {
                 if (needsEscape)
-                    return { attributes };
+                    return { attributes: attributes };
                 return attributes;
             }
-            const result = {};
+            var result = {};
             if (as)
                 result.as = as;
             if (params)
@@ -131,36 +200,32 @@ class ArSyncContainerBase {
                 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;
+        var result = compactQuery(query);
+        return result === true ? {} : result;
+    };
+    ArSyncContainerBase.parseQuery = function (query, attrsonly) {
+        var attributes = {};
+        var column = null;
+        var params = null;
         if (!query)
             query = [];
         if (query.constructor !== Array)
             query = [query];
-        for (const arg of query) {
+        for (var _i = 0, query_1 = query; _i < query_1.length; _i++) {
+            var arg = query_1[_i];
             if (typeof (arg) === 'string') {
                 attributes[arg] = {};
             }
             else if (typeof (arg) === 'object') {
-                for (const key in arg) {
-                    const value = arg[key];
+                for (var key in arg) {
+                    var value = arg[key];
                     if (attrsonly) {
                         attributes[key] = this.parseQuery(value);
                         continue;
                     }
                     if (key === 'attributes') {
-                        const child = this.parseQuery(value, true);
-                        for (const k in child)
+                        var child = this.parseQuery(value, true);
+                        for (var k in child)
                             attributes[k] = child[k];
                     }
                     else if (key === 'as') {
@@ -177,37 +242,47 @@ class ArSyncContainerBase {
         }
         if (attrsonly)
             return attributes;
-        return { attributes, as: column, params };
-    }
-    static _load({ api, id, params, query }, root) {
-        const parsedQuery = ArSyncRecord.parseQuery(query);
-        const compactQuery = ArSyncRecord.compactQuery(parsedQuery);
-        if (id) {
-            return ModelBatchRequest.fetch(api, compactQuery, id).then(data => new ArSyncRecord(parsedQuery, data, null, root));
+        return { attributes: attributes, as: column, params: params };
+    };
+    ArSyncContainerBase._load = function (_a, root) {
+        var api = _a.api, id = _a.id, params = _a.params, query = _a.query;
+        var parsedQuery = ArSyncRecord.parseQuery(query);
+        var compactQuery = ArSyncRecord.compactQuery(parsedQuery);
+        if (id != null) {
+            return modelBatchRequest.fetch(api, compactQuery, id).then(function (data) {
+                if (!data)
+                    throw { retry: false };
+                var request = { api: api, id: id, query: compactQuery };
+                return new ArSyncRecord(parsedQuery, data, request, root);
+            });
         }
         else {
-            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);
+            var request_1 = { api: api, query: compactQuery, params: params };
+            return ArSyncApi_1.default.syncFetch(request_1).then(function (response) {
+                if (!response) {
+                    throw { retry: false };
+                }
+                else if (response.collection && response.order) {
+                    return new ArSyncCollection(response.sync_keys, 'collection', parsedQuery, response, request_1, root);
                 }
                 else if (response instanceof Array) {
-                    return new ArSyncCollection([], '', parsedQuery, response, request, root);
+                    return new ArSyncCollection([], '', parsedQuery, response, request_1, root);
                 }
                 else {
-                    return new ArSyncRecord(parsedQuery, response, request, root);
+                    return new ArSyncRecord(parsedQuery, response, request_1, root);
                 }
             });
         }
-    }
-    static load(apiParams, root) {
+    };
+    ArSyncContainerBase.load = function (apiParams, root) {
+        var _this = this;
         if (!(apiParams instanceof Array))
             return this._load(apiParams, root);
-        return new Promise((resolve, _reject) => {
-            const resultModels = [];
-            let countdown = apiParams.length;
-            apiParams.forEach((param, i) => {
-                this._load(param, root).then(model => {
+        return new Promise(function (resolve, _reject) {
+            var resultModels = [];
+            var countdown = apiParams.length;
+            apiParams.forEach(function (param, i) {
+                _this._load(param, root).then(function (model) {
                     resultModels[i] = model;
                     countdown--;
                     if (countdown === 0)
@@ -215,26 +290,27 @@ class ArSyncContainerBase {
                 });
             });
         });
-    }
-}
-class ArSyncRecord extends ArSyncContainerBase {
-    constructor(query, data, request, root) {
-        super();
-        this.root = root;
+    };
+    return ArSyncContainerBase;
+}());
+var ArSyncRecord = /** @class */ (function (_super) {
+    __extends(ArSyncRecord, _super);
+    function ArSyncRecord(query, data, request, root) {
+        var _this = _super.call(this) || this;
+        _this.root = root;
         if (request)
-            this.initForReload(request);
-        this.query = query;
-        this.data = {};
-        this.children = {};
-        this.replaceData(data);
-    }
-    setSyncKeys(sync_keys) {
-        this.sync_keys = sync_keys;
-        if (!this.sync_keys) {
-            this.sync_keys = [];
-        }
-    }
-    replaceData(data) {
+            _this.initForReload(request);
+        _this.query = query;
+        _this.queryAttributes = query.attributes || {};
+        _this.data = {};
+        _this.children = {};
+        _this.replaceData(data);
+        return _this;
+    }
+    ArSyncRecord.prototype.setSyncKeys = function (sync_keys) {
+        this.sync_keys = sync_keys !== null && sync_keys !== void 0 ? sync_keys : [];
+    };
+    ArSyncRecord.prototype.replaceData = function (data) {
         this.setSyncKeys(data.sync_keys);
         this.unsubscribeAll();
         if (this.data.id !== data.id) {
@@ -242,11 +318,11 @@ class ArSyncRecord extends ArSyncContainerBase {
             this.data.id = data.id;
         }
         this.paths = [];
-        for (const key in this.query.attributes) {
-            const subQuery = this.query.attributes[key];
-            const aliasName = subQuery.as || key;
-            const subData = data[aliasName];
-            const child = this.children[aliasName];
+        for (var key in this.queryAttributes) {
+            var subQuery = this.queryAttributes[key];
+            var aliasName = subQuery.as || key;
+            var subData = data[aliasName];
+            var child = this.children[aliasName];
             if (key === 'sync_keys')
                 continue;
             if (subData instanceof Array || (subData && subData.collection && subData.order)) {
@@ -254,7 +330,7 @@ class ArSyncRecord extends ArSyncContainerBase {
                     child.replaceData(subData, this.sync_keys);
                 }
                 else {
-                    const collection = new ArSyncCollection(this.sync_keys, key, subQuery, subData, null, this.root);
+                    var collection = new ArSyncCollection(this.sync_keys, key, subQuery, subData, null, this.root);
                     this.mark();
                     this.children[aliasName] = collection;
                     this.data[aliasName] = collection.data;
@@ -270,7 +346,7 @@ class ArSyncRecord extends ArSyncContainerBase {
                         child.replaceData(subData);
                     }
                     else {
-                        const model = new ArSyncRecord(subQuery, subData, null, this.root);
+                        var model = new ArSyncRecord(subQuery, subData, null, this.root);
                         this.mark();
                         this.children[aliasName] = model;
                         this.data[aliasName] = model.data;
@@ -290,22 +366,23 @@ class ArSyncRecord extends ArSyncContainerBase {
                 }
             }
         }
-        if (this.query.attributes['*']) {
-            for (const key in data) {
-                if (!this.query.attributes[key] && this.data[key] !== data[key]) {
+        if (this.queryAttributes['*']) {
+            for (var key in data) {
+                if (!this.queryAttributes[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;
+    };
+    ArSyncRecord.prototype.onNotify = function (notifyData, path) {
+        var _this = this;
+        var action = notifyData.action, className = notifyData.class_name, id = notifyData.id;
+        var query = path && this.queryAttributes[path];
+        var aliasName = (query && query.as) || path;
         if (action === 'remove') {
-            const child = this.children[aliasName];
+            var child = this.children[aliasName];
             if (child)
                 child.release();
             this.children[aliasName] = null;
@@ -316,52 +393,66 @@ class ArSyncRecord extends ArSyncContainerBase {
         else if (action === 'add') {
             if (this.data[aliasName] && this.data[aliasName].id === id)
                 return;
-            ModelBatchRequest.fetch(class_name, ArSyncRecord.compactQuery(query), id).then(data => {
-                if (!data || !this.data)
+            modelBatchRequest.fetch(className, ArSyncRecord.compactQuery(query), id).then(function (data) {
+                if (!data || !_this.data)
                     return;
-                const model = new ArSyncRecord(query, data, null, this.root);
-                const child = this.children[aliasName];
+                var model = new ArSyncRecord(query, data, null, _this.root);
+                var child = _this.children[aliasName];
                 if (child)
                     child.release();
-                this.children[aliasName] = model;
-                this.mark();
-                this.data[aliasName] = model.data;
-                model.parentModel = this;
+                _this.children[aliasName] = model;
+                _this.mark();
+                _this.data[aliasName] = model.data;
+                model.parentModel = _this;
                 model.parentKey = aliasName;
-                this.onChange([aliasName], model.data);
+                _this.onChange([aliasName], model.data);
+            }).catch(function (e) {
+                console.error("failed to load " + className + ":" + id + " " + e);
             });
         }
         else {
-            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);
-                });
+            var field = notifyData.field;
+            var query_2 = field ? this.patchQuery(field) : this.reloadQuery();
+            if (!query_2)
+                return;
+            modelBatchRequest.fetch(className, query_2, id).then(function (data) {
+                if (_this.data)
+                    _this.update(data);
+            }).catch(function (e) {
+                console.error("failed to load patch " + className + ":" + id + " " + e);
+            });
         }
-    }
-    subscribeAll() {
-        const callback = data => this.onNotify(data);
-        for (const key of this.sync_keys) {
+    };
+    ArSyncRecord.prototype.subscribeAll = function () {
+        var _this = this;
+        var callback = function (data) { return _this.onNotify(data); };
+        for (var _i = 0, _a = this.sync_keys; _i < _a.length; _i++) {
+            var key = _a[_i];
             this.subscribe(key, callback);
         }
-        for (const path of this.paths) {
-            const pathCallback = data => this.onNotify(data, path);
-            for (const key of this.sync_keys)
-                this.subscribe(key + path, pathCallback);
-        }
-    }
-    patchQuery(key) {
-        const val = this.query.attributes[key];
+        var _loop_1 = function (path) {
+            var pathCallback = function (data) { return _this.onNotify(data, path); };
+            for (var _i = 0, _a = this_1.sync_keys; _i < _a.length; _i++) {
+                var key = _a[_i];
+                this_1.subscribe(key + path, pathCallback);
+            }
+        };
+        var this_1 = this;
+        for (var _b = 0, _c = this.paths; _b < _c.length; _b++) {
+            var path = _c[_b];
+            _loop_1(path);
+        }
+    };
+    ArSyncRecord.prototype.patchQuery = function (key) {
+        var val = this.queryAttributes[key];
         if (!val)
             return;
-        let { attributes, as, params } = val;
+        var attributes = val.attributes, as = val.as, params = val.params;
         if (attributes && Object.keys(val.attributes).length === 0)
             attributes = null;
         if (!attributes && !as && !params)
             return key;
-        const result = {};
+        var result = {};
         if (attributes)
             result.attributes = attributes;
         if (as)
@@ -369,27 +460,28 @@ class ArSyncRecord extends ArSyncContainerBase {
         if (params)
             result.params = params;
         return result;
-    }
-    reloadQuery() {
+    };
+    ArSyncRecord.prototype.reloadQuery = function () {
+        var _a;
         if (this.reloadQueryCache)
             return this.reloadQueryCache;
-        const reloadQuery = this.reloadQueryCache = { attributes: [] };
-        for (const key in this.query.attributes) {
+        var reloadQuery = this.reloadQueryCache = { attributes: [] };
+        for (var key in this.queryAttributes) {
             if (key === 'sync_keys')
                 continue;
-            const val = this.query.attributes[key];
+            var val = this.queryAttributes[key];
             if (!val || !val.attributes) {
                 reloadQuery.attributes.push(key);
             }
             else if (!val.params && Object.keys(val.attributes).length === 0) {
-                reloadQuery.attributes.push({ [key]: val });
+                reloadQuery.attributes.push((_a = {}, _a[key] = val, _a));
             }
         }
         return reloadQuery;
-    }
-    update(data) {
-        for (const key in data) {
-            const subQuery = this.query.attributes[key];
+    };
+    ArSyncRecord.prototype.update = function (data) {
+        for (var key in data) {
+            var subQuery = this.queryAttributes[key];
             if (subQuery && subQuery.attributes && Object.keys(subQuery.attributes).length > 0)
                 continue;
             if (this.data[key] === data[key])
@@ -398,184 +490,224 @@ class ArSyncRecord extends ArSyncContainerBase {
             this.data[key] = data[key];
             this.onChange([key], data[key]);
         }
-    }
-    markAndSet(key, data) {
+    };
+    ArSyncRecord.prototype.markAndSet = function (key, data) {
         this.mark();
         this.data[key] = data;
-    }
-    mark() {
+    };
+    ArSyncRecord.prototype.mark = function () {
         if (!this.root || !this.root.immutable || !Object.isFrozen(this.data))
             return;
-        this.data = Object.assign({}, this.data);
+        this.data = __assign({}, this.data);
         this.root.mark(this.data);
         if (this.parentModel)
             this.parentModel.markAndSet(this.parentKey, this.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);
+    };
+    return ArSyncRecord;
+}(ArSyncContainerBase));
+var ArSyncCollection = /** @class */ (function (_super) {
+    __extends(ArSyncCollection, _super);
+    function ArSyncCollection(sync_keys, path, query, data, request, root) {
+        var _this = _super.call(this) || this;
+        _this.ordering = { orderBy: 'id', direction: 'asc' };
+        _this.aliasOrderKey = 'id';
+        _this.root = root;
+        _this.path = path;
+        _this.query = query;
+        _this.queryAttributes = query.attributes || {};
+        _this.compactQuery = ArSyncRecord.compactQuery(query);
         if (request)
-            this.initForReload(request);
-        if (query.params && (query.params.order || query.params.limit)) {
-            this.setOrdering(query.params.limit, query.params.order);
-        }
-        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) {
+            _this.initForReload(request);
+        if (query.params) {
+            _this.setOrdering(query.params);
+        }
+        _this.data = [];
+        _this.children = [];
+        _this.replaceData(data, sync_keys);
+        return _this;
+    }
+    ArSyncCollection.prototype.setOrdering = function (ordering) {
+        var direction = 'asc';
+        var orderBy = 'id';
+        var first = undefined;
+        var last = undefined;
+        if (ordering.direction === 'desc')
+            direction = ordering.direction;
+        if (typeof ordering.orderBy === 'string')
+            orderBy = ordering.orderBy;
+        if (typeof ordering.first === 'number')
+            first = ordering.first;
+        if (typeof ordering.last === 'number')
+            last = ordering.last;
+        var subQuery = this.queryAttributes[orderBy];
+        this.aliasOrderKey = (subQuery && subQuery.as) || orderBy;
+        this.ordering = { first: first, last: last, direction: direction, orderBy: orderBy };
+    };
+    ArSyncCollection.prototype.setSyncKeys = function (sync_keys) {
+        var _this = this;
         if (sync_keys) {
-            this.sync_keys = sync_keys.map(key => key + this.path);
+            this.sync_keys = sync_keys.map(function (key) { return key + _this.path; });
         }
         else {
             this.sync_keys = [];
         }
-    }
-    replaceData(data, sync_keys) {
+    };
+    ArSyncCollection.prototype.replaceData = function (data, sync_keys) {
         this.setSyncKeys(sync_keys);
-        const existings = {};
-        for (const child of this.children)
-            existings[child.data.id] = child;
-        let collection;
-        if ('collection' in data && 'order' in data) {
-            collection = data.collection;
-            this.setOrdering(data.order.limit, data.order.mode);
+        var existings = new Map();
+        for (var _i = 0, _a = this.children; _i < _a.length; _i++) {
+            var child = _a[_i];
+            existings.set(child.data.id, child);
         }
-        else {
+        var collection;
+        if (Array.isArray(data)) {
             collection = data;
         }
-        const newChildren = [];
-        const newData = [];
-        for (const subData of collection) {
-            let model = null;
-            if (typeof (subData) === 'object' && subData && 'id' in subData)
-                model = existings[subData.id];
-            let data = subData;
+        else {
+            collection = data.collection;
+            this.setOrdering(data.ordering);
+        }
+        var newChildren = [];
+        var newData = [];
+        for (var _b = 0, collection_1 = collection; _b < collection_1.length; _b++) {
+            var subData = collection_1[_b];
+            var model = undefined;
+            if (typeof (subData) === 'object' && subData && 'sync_keys' in subData)
+                model = existings.get(subData.id);
+            var data_1 = subData;
             if (model) {
                 model.replaceData(subData);
             }
-            else if (subData.id) {
+            else if (subData.sync_keys) {
                 model = new ArSyncRecord(this.query, subData, null, this.root);
                 model.parentModel = this;
                 model.parentKey = subData.id;
             }
             if (model) {
                 newChildren.push(model);
-                data = model.data;
+                data_1 = model.data;
             }
-            newData.push(data);
+            newData.push(data_1);
         }
         while (this.children.length) {
-            const child = this.children.pop();
-            if (!existings[child.data.id])
+            var child = this.children.pop();
+            if (!existings.has(child.data.id))
                 child.release();
         }
         if (this.data.length || newChildren.length)
             this.mark();
         while (this.data.length)
             this.data.pop();
-        for (const child of newChildren)
+        for (var _c = 0, newChildren_1 = newChildren; _c < newChildren_1.length; _c++) {
+            var child = newChildren_1[_c];
             this.children.push(child);
-        for (const el of newData)
+        }
+        for (var _d = 0, newData_1 = newData; _d < newData_1.length; _d++) {
+            var el = newData_1[_d];
             this.data.push(el);
+        }
         this.subscribeAll();
-    }
-    consumeAdd(className, id) {
-        if (this.data.findIndex(a => a.id === id) >= 0)
+    };
+    ArSyncCollection.prototype.consumeAdd = function (className, id) {
+        var _this = this;
+        var _a = this.ordering, first = _a.first, last = _a.last, direction = _a.direction;
+        var limit = first || last;
+        if (this.data.findIndex(function (a) { return a.id === id; }) >= 0)
             return;
-        if (this.order.limit === this.data.length) {
-            if (this.order.mode === 'asc') {
-                const last = this.data[this.data.length - 1];
-                if (last && last.id < id)
-                    return;
+        if (limit && limit <= this.data.length) {
+            var lastItem = this.data[this.data.length - 1];
+            var firstItem = this.data[0];
+            if (direction === 'asc') {
+                if (first) {
+                    if (lastItem && lastItem.id < id)
+                        return;
+                }
+                else {
+                    if (firstItem && id < firstItem.id)
+                        return;
+                }
             }
             else {
-                const last = this.data[this.data.length - 1];
-                if (last && last.id > id)
-                    return;
+                if (first) {
+                    if (lastItem && id < lastItem.id)
+                        return;
+                }
+                else {
+                    if (firstItem && firstItem.id < id)
+                        return;
+                }
             }
         }
-        ModelBatchRequest.fetch(className, this.compactQuery, id).then((data) => {
-            if (!data || !this.data)
+        modelBatchRequest.fetch(className, this.compactQuery, id).then(function (data) {
+            if (!data || !_this.data)
                 return;
-            const model = new ArSyncRecord(this.query, data, null, this.root);
-            model.parentModel = this;
+            var model = new ArSyncRecord(_this.query, data, null, _this.root);
+            model.parentModel = _this;
             model.parentKey = id;
-            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[orderKey] > data[orderKey])
-                    this.markAndSort();
-                if (overflow) {
-                    rmodel = this.children.shift();
-                    rmodel.release();
-                    this.data.shift();
+            var overflow = limit && limit <= _this.data.length;
+            var rmodel;
+            _this.mark();
+            var orderKey = _this.aliasOrderKey;
+            var firstItem = _this.data[0];
+            var lastItem = _this.data[_this.data.length - 1];
+            if (direction === 'asc') {
+                if (firstItem && data[orderKey] < firstItem[orderKey]) {
+                    _this.children.unshift(model);
+                    _this.data.unshift(model.data);
+                }
+                else {
+                    var skipSort = lastItem && lastItem[orderKey] < data[orderKey];
+                    _this.children.push(model);
+                    _this.data.push(model.data);
+                    if (!skipSort)
+                        _this.markAndSort();
                 }
             }
             else {
-                const first = this.data[0];
-                this.children.unshift(model);
-                this.data.unshift(model.data);
-                if (first && first[orderKey] > data[orderKey])
-                    this.markAndSort();
-                if (overflow) {
-                    rmodel = this.children.pop();
-                    rmodel.release();
-                    this.data.pop();
+                if (firstItem && data[orderKey] > firstItem[orderKey]) {
+                    _this.children.unshift(model);
+                    _this.data.unshift(model.data);
+                }
+                else {
+                    var skipSort = lastItem && lastItem[orderKey] > data[orderKey];
+                    _this.children.push(model);
+                    _this.data.push(model.data);
+                    if (!skipSort)
+                        _this.markAndSort();
+                }
+            }
+            if (overflow) {
+                if (first) {
+                    rmodel = _this.children.pop();
+                    _this.data.pop();
                 }
+                else {
+                    rmodel = _this.children.shift();
+                    _this.data.shift();
+                }
+                rmodel.release();
             }
-            this.onChange([model.id], model.data);
+            _this.onChange([model.id], model.data);
             if (rmodel)
-                this.onChange([rmodel.id], null);
+                _this.onChange([rmodel.id], null);
+        }).catch(function (e) {
+            console.error("failed to load " + className + ":" + id + " " + e);
         });
-    }
-    markAndSort() {
+    };
+    ArSyncCollection.prototype.markAndSort = function () {
         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);
+        var orderKey = this.aliasOrderKey;
+        if (this.ordering.direction === 'asc') {
+            this.children.sort(function (a, b) { return a.data[orderKey] < b.data[orderKey] ? -1 : +1; });
+            this.data.sort(function (a, b) { return 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);
+            this.children.sort(function (a, b) { return a.data[orderKey] > b.data[orderKey] ? -1 : +1; });
+            this.data.sort(function (a, b) { return a[orderKey] > b[orderKey] ? -1 : +1; });
         }
-    }
-    consumeRemove(id) {
-        const idx = this.data.findIndex(a => a.id === id);
+    };
+    ArSyncCollection.prototype.consumeRemove = function (id) {
+        var idx = this.data.findIndex(function (a) { return a.id === id; });
         if (idx < 0)
             return;
         this.mark();
@@ -583,42 +715,47 @@ class ArSyncCollection extends ArSyncContainerBase {
         this.children.splice(idx, 1);
         this.data.splice(idx, 1);
         this.onChange([id], null);
-    }
-    onNotify(notifyData) {
+    };
+    ArSyncCollection.prototype.onNotify = function (notifyData) {
         if (notifyData.action === 'add') {
             this.consumeAdd(notifyData.class_name, notifyData.id);
         }
         else if (notifyData.action === 'remove') {
             this.consumeRemove(notifyData.id);
         }
-    }
-    subscribeAll() {
-        const callback = data => this.onNotify(data);
-        for (const key of this.sync_keys)
+    };
+    ArSyncCollection.prototype.subscribeAll = function () {
+        var _this = this;
+        var callback = function (data) { return _this.onNotify(data); };
+        for (var _i = 0, _a = this.sync_keys; _i < _a.length; _i++) {
+            var key = _a[_i];
             this.subscribe(key, callback);
-    }
-    onChange(path, data) {
-        super.onChange(path, data);
+        }
+    };
+    ArSyncCollection.prototype.onChange = function (path, data) {
+        _super.prototype.onChange.call(this, path, data);
         if (path[1] === this.aliasOrderKey)
             this.markAndSort();
-    }
-    markAndSet(id, data) {
+    };
+    ArSyncCollection.prototype.markAndSet = function (id, data) {
         this.mark();
-        const idx = this.data.findIndex(a => a.id === id);
+        var idx = this.data.findIndex(function (a) { return a.id === id; });
         if (idx >= 0)
             this.data[idx] = data;
-    }
-    mark() {
+    };
+    ArSyncCollection.prototype.mark = function () {
         if (!this.root || !this.root.immutable || !Object.isFrozen(this.data))
             return;
-        this.data = [...this.data];
+        this.data = __spreadArrays(this.data);
         this.root.mark(this.data);
         if (this.parentModel)
             this.parentModel.markAndSet(this.parentKey, this.data);
-    }
-}
-class ArSyncStore {
-    constructor(request, { immutable } = {}) {
+    };
+    return ArSyncCollection;
+}(ArSyncContainerBase));
+var ArSyncStore = /** @class */ (function () {
+    function ArSyncStore(request, _a) {
+        var immutable = (_a === void 0 ? {} : _a).immutable;
         this.immutable = !!immutable;
         this.markedForFreezeObjects = [];
         this.changes = [];
@@ -628,87 +765,90 @@ class ArSyncStore {
         this.data = null;
         this.load(0);
     }
-    load(retryCount) {
-        ArSyncContainerBase.load(this.request, this).then((container) => {
-            if (this.markForRelease) {
+    ArSyncStore.prototype.load = function (retryCount) {
+        var _this = this;
+        ArSyncContainerBase.load(this.request, this).then(function (container) {
+            if (_this.markForRelease) {
                 container.release();
                 return;
             }
-            this.container = container;
-            this.data = container.data;
-            if (this.immutable)
-                this.freezeRecursive(this.data);
-            this.complete = true;
-            this.notfound = false;
-            this.trigger('load');
-            this.trigger('change', { path: [], value: this.data });
-            container.onChange = (path, value) => {
-                this.changes.push({ path, value });
-                this.setChangesBufferTimer();
+            _this.container = container;
+            _this.data = container.data;
+            if (_this.immutable)
+                _this.freezeRecursive(_this.data);
+            _this.complete = true;
+            _this.notfound = false;
+            _this.trigger('load');
+            _this.trigger('change', { path: [], value: _this.data });
+            container.onChange = function (path, value) {
+                _this.changes.push({ path: path, value: value });
+                _this.setChangesBufferTimer();
             };
-            container.onConnectionChange = state => {
-                this.trigger('connection', state);
+            container.onConnectionChange = function (state) {
+                _this.trigger('connection', state);
             };
-        }).catch(e => {
+        }).catch(function (e) {
             if (!e || e.retry === undefined)
                 throw e;
-            if (this.markForRelease)
+            if (_this.markForRelease)
                 return;
             if (!e.retry) {
-                this.complete = true;
-                this.notfound = true;
-                this.trigger('load');
+                _this.complete = true;
+                _this.notfound = true;
+                _this.trigger('load');
                 return;
             }
-            const sleepSeconds = Math.min(Math.pow(2, retryCount), 30);
-            this.retryLoadTimer = setTimeout(() => {
-                this.retryLoadTimer = null;
-                this.load(retryCount + 1);
+            var sleepSeconds = Math.min(Math.pow(2, retryCount), 30);
+            _this.retryLoadTimer = setTimeout(function () {
+                _this.retryLoadTimer = null;
+                _this.load(retryCount + 1);
             }, sleepSeconds * 1000);
         });
-    }
-    setChangesBufferTimer() {
+    };
+    ArSyncStore.prototype.setChangesBufferTimer = function () {
+        var _this = this;
         if (this.changesBufferTimer)
             return;
-        this.changesBufferTimer = setTimeout(() => {
-            this.changesBufferTimer = null;
-            const changes = this.changes;
-            this.changes = [];
-            this.freezeMarked();
-            this.data = this.container.data;
-            changes.forEach(patch => this.trigger('change', patch));
+        this.changesBufferTimer = setTimeout(function () {
+            _this.changesBufferTimer = null;
+            var changes = _this.changes;
+            _this.changes = [];
+            _this.freezeMarked();
+            _this.data = _this.container.data;
+            changes.forEach(function (patch) { return _this.trigger('change', patch); });
         }, 20);
-    }
-    subscribe(event, callback) {
-        let listeners = this.eventListeners.events[event];
+    };
+    ArSyncStore.prototype.subscribe = function (event, callback) {
+        var listeners = this.eventListeners.events[event];
         if (!listeners)
             this.eventListeners.events[event] = listeners = {};
-        const id = this.eventListeners.serial++;
+        var id = this.eventListeners.serial++;
         listeners[id] = callback;
-        return { unsubscribe: () => { delete listeners[id]; } };
-    }
-    trigger(event, arg) {
-        const listeners = this.eventListeners.events[event];
+        return { unsubscribe: function () { delete listeners[id]; } };
+    };
+    ArSyncStore.prototype.trigger = function (event, arg) {
+        var listeners = this.eventListeners.events[event];
         if (!listeners)
             return;
-        for (const id in listeners)
+        for (var id in listeners)
             listeners[id](arg);
-    }
-    mark(object) {
+    };
+    ArSyncStore.prototype.mark = function (object) {
         this.markedForFreezeObjects.push(object);
-    }
-    freezeRecursive(obj) {
+    };
+    ArSyncStore.prototype.freezeRecursive = function (obj) {
         if (Object.isFrozen(obj))
             return obj;
-        for (const key in obj)
+        for (var key in obj)
             this.freezeRecursive(obj[key]);
         Object.freeze(obj);
-    }
-    freezeMarked() {
-        this.markedForFreezeObjects.forEach(obj => this.freezeRecursive(obj));
+    };
+    ArSyncStore.prototype.freezeMarked = function () {
+        var _this = this;
+        this.markedForFreezeObjects.forEach(function (obj) { return _this.freezeRecursive(obj); });
         this.markedForFreezeObjects = [];
-    }
-    release() {
+    };
+    ArSyncStore.prototype.release = function () {
         if (this.retryLoadTimer)
             clearTimeout(this.retryLoadTimer);
         if (this.changesBufferTimer)
@@ -719,6 +859,7 @@ class ArSyncStore {
         else {
             this.markForRelease = true;
         }
-    }
-}
+    };
+    return ArSyncStore;
+}());
 exports.default = ArSyncStore;