ar_sync 1.0.3 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 949fc166a975785ab522fe3a2714bf334a56c1f2d4e32931aced7b3ee1de65ac
-  data.tar.gz: f9428cc4dbf7e2e7cea7c2f958198e628f7ad92241d71c351e8328b856a315de
+  metadata.gz: ab145d5094c25600e95e01ab625c0128782b2a0592be95d8c9333539a5128bd1
+  data.tar.gz: 062fcf8cb8996e145dfa35eb25b31f2ecc2b4a486183bc70678d055db2bf2bc8
 SHA512:
-  metadata.gz: dff083ce7735e475c3104b7581da185e8bd872e76afd8addeecfd5ebc9d292cb299358edeb9d445c5aac268813d4bd358a886bd89dff761eab8dbbac2fa75593
-  data.tar.gz: 54ce2594a8749284200924456188fc7b7a3836f8719cbaea4b2626823e9bbe1879cc6a8d7dad327e82f83d7f48d488620eef18f94bda6297aecf1c87d3893b85
+  metadata.gz: 556a1c954088cea90d44bb61cec1fc250804f1fc5ec4e1c4101ff642343af49bc4ce8870be152de4627802931409d3c5f25707fa34b59ba8e53e9873a99e9b54
+  data.tar.gz: 28846608f3314be4a117d1ffbf265702f2170755f027696300f991b01a9228302d7e218fce757826c7528c8643d98f66e1073741305c1d851f1fe6602c9f185b

data/.github/workflows/test.yml

@@ -0,0 +1,27 @@
+name: Test
+on: [push, pull_request]
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: [ '2.7', '3.0', '3.1' ]
+        gemfiles:
+          - gemfiles/Gemfile-rails-6
+          - gemfiles/Gemfile-rails-7
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v2
+    - uses: ruby/setup-ruby@v1
+      with:
+        ruby-version: ${{ matrix.ruby }}
+    - uses: actions/setup-node@v1
+      with:
+        node-version: '14.x'
+    - run: |
+        sudo apt-get update
+        sudo apt-get install -y libsqlite3-dev
+    - run: bundle install --gemfile ${{ matrix.gemfiles }} --jobs 4 --retry 3
+    - run: npm install
+    - run: npm run build
+    - run: bundle exec --gemfile ${{ matrix.gemfiles }} rake

data/Gemfile

@@ -4,3 +4,4 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 # Specify your gem's dependencies in ar_sync.gemspec
 gemspec
+gem 'ar_serializer'

data/Gemfile.lock

@@ -1,56 +1,54 @@
 PATH
   remote: .
   specs:
-    ar_sync (1.0.3)
+    ar_sync (1.1.0)
       activerecord
-      ar_serializer (= 1.0.0)
+      ar_serializer
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.2.3)
-      activesupport (= 5.2.3)
-    activerecord (5.2.3)
-      activemodel (= 5.2.3)
-      activesupport (= 5.2.3)
-      arel (>= 9.0)
-    activerecord-import (1.0.2)
-      activerecord (>= 3.2)
-    activesupport (5.2.3)
+    activemodel (7.0.2.3)
+      activesupport (= 7.0.2.3)
+    activerecord (7.0.2.3)
+      activemodel (= 7.0.2.3)
+      activesupport (= 7.0.2.3)
+    activerecord-import (1.4.0)
+      activerecord (>= 4.2)
+    activesupport (7.0.2.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    ar_serializer (1.0.0)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+    ar_serializer (1.2.0)
       activerecord
       top_n_loader
-    arel (9.0.0)
-    coderay (1.1.2)
-    concurrent-ruby (1.1.5)
-    i18n (1.6.0)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.10)
+    i18n (1.10.0)
       concurrent-ruby (~> 1.0)
-    method_source (0.9.2)
-    minitest (5.11.3)
-    pry (0.12.2)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rake (12.3.2)
-    sqlite3 (1.3.13)
-    thread_safe (0.3.6)
-    top_n_loader (1.0.0)
+    method_source (1.0.0)
+    minitest (5.15.0)
+    pry (0.14.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    rake (13.0.6)
+    sqlite3 (1.4.2)
+    top_n_loader (1.0.2)
       activerecord
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   activerecord-import
+  ar_serializer
   ar_sync!
   pry
   rake
   sqlite3
 
 BUNDLED WITH
-   1.16.1
+   2.1.2

data/ar_sync.gemspec

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

data/core/ActionCableAdapter.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var ActionCableAdapter = /** @class */ (function () {
+    function ActionCableAdapter(actionCableClass) {
+        this.connected = true;
+        this.actionCableClass = actionCableClass;
+        this.subscribe(Math.random().toString(), function () { });
+    }
+    ActionCableAdapter.prototype.subscribe = function (key, received) {
+        var _this = this;
+        var disconnected = function () {
+            if (!_this.connected)
+                return;
+            _this.connected = false;
+            _this.ondisconnect();
+        };
+        var connected = function () {
+            if (_this.connected)
+                return;
+            _this.connected = true;
+            _this.onreconnect();
+        };
+        if (!this._cable)
+            this._cable = this.actionCableClass.createConsumer();
+        return this._cable.subscriptions.create({ channel: 'SyncChannel', key: key }, { received: received, disconnected: disconnected, connected: connected });
+    };
+    ActionCableAdapter.prototype.ondisconnect = function () { };
+    ActionCableAdapter.prototype.onreconnect = function () { };
+    return ActionCableAdapter;
+}());
+exports.default = ActionCableAdapter;

data/core/ArSyncApi.d.ts

@@ -1,8 +1,14 @@
 declare function apiBatchFetch(endpoint: string, requests: object[]): Promise<any>;
+declare type Request = {
+    api: string;
+    params?: any;
+    query: any;
+    id?: number;
+};
 declare const ArSyncApi: {
     domain: string | null;
     _batchFetch: typeof apiBatchFetch;
-    fetch: (request: object) => Promise<unknown>;
-    syncFetch: (request: object) => Promise<unknown>;
+    fetch: (request: Request) => Promise<unknown>;
+    syncFetch: (request: Request) => Promise<unknown>;
 };
 export default ArSyncApi;

data/core/ArSyncApi.js

@@ -1,79 +1,153 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-async function apiBatchFetch(endpoint, requests) {
-    const headers = {
-        'Accept': 'application/json',
-        'Content-Type': 'application/json'
+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;
     };
-    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();
-    throw new Error(res.statusText);
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+function apiBatchFetch(endpoint, requests) {
+    return __awaiter(this, void 0, void 0, function () {
+        var headers, body, option, res;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    headers = {
+                        'Accept': 'application/json',
+                        'Content-Type': 'application/json'
+                    };
+                    body = JSON.stringify({ requests: requests });
+                    option = { credentials: 'include', method: 'POST', headers: headers, body: body };
+                    if (ArSyncApi.domain)
+                        endpoint = ArSyncApi.domain + endpoint;
+                    return [4 /*yield*/, fetch(endpoint, option)];
+                case 1:
+                    res = _a.sent();
+                    if (res.status === 200)
+                        return [2 /*return*/, res.json()];
+                    throw new Error(res.statusText);
+            }
+        });
+    });
 }
-class ApiFetcher {
-    constructor(endpoint) {
+var ApiFetcher = /** @class */ (function () {
+    function ApiFetcher(endpoint) {
         this.batches = [];
         this.batchFetchTimer = null;
         this.endpoint = endpoint;
     }
-    fetch(request) {
-        return new Promise((resolve, reject) => {
-            this.batches.push([request, { resolve, reject }]);
-            if (this.batchFetchTimer)
+    ApiFetcher.prototype.fetch = function (request) {
+        var _this = this;
+        if (request.id != null) {
+            return new Promise(function (resolve, reject) {
+                _this.fetch({ api: request.api, params: { ids: [request.id] }, query: request.query }).then(function (result) {
+                    if (result[0])
+                        resolve(result[0]);
+                    else
+                        reject({ type: 'Not Found', retry: false });
+                }).catch(reject);
+            });
+        }
+        return new Promise(function (resolve, reject) {
+            _this.batches.push([request, { resolve: resolve, reject: reject }]);
+            if (_this.batchFetchTimer)
                 return;
-            this.batchFetchTimer = setTimeout(() => {
-                this.batchFetchTimer = null;
-                const compacts = {};
-                const requests = [];
-                const callbacksList = [];
-                for (const batch of this.batches) {
-                    const request = batch[0];
-                    const callback = batch[1];
-                    const key = JSON.stringify(request);
+            _this.batchFetchTimer = setTimeout(function () {
+                _this.batchFetchTimer = null;
+                var compacts = {};
+                var requests = [];
+                var callbacksList = [];
+                for (var _i = 0, _a = _this.batches; _i < _a.length; _i++) {
+                    var batch = _a[_i];
+                    var request_1 = batch[0];
+                    var callback = batch[1];
+                    var key = JSON.stringify(request_1);
                     if (compacts[key]) {
                         compacts[key].push(callback);
                     }
                     else {
-                        requests.push(request);
+                        requests.push(request_1);
                         callbacksList.push(compacts[key] = [callback]);
                     }
                 }
-                this.batches = [];
-                ArSyncApi._batchFetch(this.endpoint, requests).then((results) => {
-                    for (const i in callbacksList) {
-                        const result = results[i];
-                        const callbacks = callbacksList[i];
-                        for (const callback of callbacks) {
-                            if (result.data) {
+                _this.batches = [];
+                ArSyncApi._batchFetch(_this.endpoint, requests).then(function (results) {
+                    for (var i in callbacksList) {
+                        var result = results[i];
+                        var callbacks = callbacksList[i];
+                        for (var _i = 0, callbacks_1 = callbacks; _i < callbacks_1.length; _i++) {
+                            var callback = callbacks_1[_i];
+                            if (result.data !== undefined) {
                                 callback.resolve(result.data);
                             }
                             else {
-                                const error = result.error || { type: 'Unknown Error' };
-                                callback.reject(Object.assign(Object.assign({}, error), { retry: false }));
+                                var error = result.error || { type: 'Unknown Error' };
+                                callback.reject(__assign(__assign({}, error), { retry: false }));
                             }
                         }
                     }
-                }).catch(e => {
-                    const error = { type: e.name, message: e.message, retry: true };
-                    for (const callbacks of callbacksList) {
-                        for (const callback of callbacks)
+                }).catch(function (e) {
+                    var error = { type: e.name, message: e.message, retry: true };
+                    for (var _i = 0, callbacksList_1 = callbacksList; _i < callbacksList_1.length; _i++) {
+                        var callbacks = callbacksList_1[_i];
+                        for (var _a = 0, callbacks_2 = callbacks; _a < callbacks_2.length; _a++) {
+                            var callback = callbacks_2[_a];
                             callback.reject(error);
+                        }
                     }
                 });
             }, 16);
         });
-    }
-}
-const staticFetcher = new ApiFetcher('/static_api');
-const syncFetcher = new ApiFetcher('/sync_api');
-const ArSyncApi = {
+    };
+    return ApiFetcher;
+}());
+var staticFetcher = new ApiFetcher('/static_api');
+var syncFetcher = new ApiFetcher('/sync_api');
+var ArSyncApi = {
     domain: null,
     _batchFetch: apiBatchFetch,
-    fetch: (request) => staticFetcher.fetch(request),
-    syncFetch: (request) => syncFetcher.fetch(request),
+    fetch: function (request) { return staticFetcher.fetch(request); },
+    syncFetch: function (request) { return syncFetcher.fetch(request); },
 };
 exports.default = ArSyncApi;

data/core/ArSyncModel.js

@@ -1,104 +1,107 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const ArSyncStore_1 = require("./ArSyncStore");
-const ConnectionManager_1 = require("./ConnectionManager");
-class ArSyncModel {
-    constructor(request, option) {
+var ArSyncStore_1 = require("./ArSyncStore");
+var ConnectionManager_1 = require("./ConnectionManager");
+var ArSyncModel = /** @class */ (function () {
+    function ArSyncModel(request, option) {
+        var _this = this;
         this._ref = ArSyncModel.retrieveRef(request, option);
         this._listenerSerial = 0;
         this._listeners = {};
         this.complete = false;
         this.connected = ArSyncStore_1.default.connectionManager.networkStatus;
-        const setData = () => {
-            this.data = this._ref.model.data;
-            this.complete = this._ref.model.complete;
-            this.notfound = this._ref.model.notfound;
+        var setData = function () {
+            _this.data = _this._ref.model.data;
+            _this.complete = _this._ref.model.complete;
+            _this.notfound = _this._ref.model.notfound;
         };
         setData();
         this.subscribe('load', setData);
         this.subscribe('change', setData);
-        this.subscribe('connection', (status) => {
-            this.connected = status;
+        this.subscribe('connection', function (status) {
+            _this.connected = status;
         });
     }
-    onload(callback) {
+    ArSyncModel.prototype.onload = function (callback) {
         this.subscribeOnce('load', callback);
-    }
-    subscribeOnce(event, callback) {
-        const subscription = this.subscribe(event, (arg) => {
+    };
+    ArSyncModel.prototype.subscribeOnce = function (event, callback) {
+        var subscription = this.subscribe(event, function (arg) {
             callback(arg);
             subscription.unsubscribe();
         });
         return subscription;
-    }
-    dig(path) {
+    };
+    ArSyncModel.prototype.dig = function (path) {
         return ArSyncModel.digData(this.data, path);
-    }
-    static digData(data, path) {
+    };
+    ArSyncModel.digData = function (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);
+            var key = path[0];
+            var other = path.slice(1);
             if (Array.isArray(data)) {
-                return this.digData(data.find(el => el.id === key), other);
+                return this.digData(data.find(function (el) { return 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);
-        let unsubscribed = false;
-        const unsubscribe = () => {
+    };
+    ArSyncModel.prototype.subscribe = function (event, callback) {
+        var _this = this;
+        var id = this._listenerSerial++;
+        var subscription = this._ref.model.subscribe(event, callback);
+        var unsubscribed = false;
+        var unsubscribe = function () {
             unsubscribed = true;
             subscription.unsubscribe();
-            delete this._listeners[id];
+            delete _this._listeners[id];
         };
         if (this.complete) {
             if (event === 'load')
-                setTimeout(() => {
+                setTimeout(function () {
                     if (!unsubscribed)
                         callback();
                 }, 0);
             if (event === 'change')
-                setTimeout(() => {
+                setTimeout(function () {
                     if (!unsubscribed)
-                        callback({ path: [], value: this.data });
+                        callback({ path: [], value: _this.data });
                 }, 0);
         }
-        return this._listeners[id] = { unsubscribe };
-    }
-    release() {
-        for (const id in this._listeners)
+        return this._listeners[id] = { unsubscribe: unsubscribe };
+    };
+    ArSyncModel.prototype.release = function () {
+        for (var id in this._listeners)
             this._listeners[id].unsubscribe();
         this._listeners = {};
         ArSyncModel._detach(this._ref);
         this._ref = null;
-    }
-    static retrieveRef(request, option) {
-        const key = JSON.stringify([request, option]);
-        let ref = this._cache[key];
+    };
+    ArSyncModel.retrieveRef = function (request, option) {
+        var key = JSON.stringify([request, option]);
+        var ref = this._cache[key];
         if (!ref) {
-            const model = new ArSyncStore_1.default(request, option);
-            ref = this._cache[key] = { key, count: 0, timer: null, model };
+            var model = new ArSyncStore_1.default(request, option);
+            ref = this._cache[key] = { key: key, count: 0, timer: null, model: model };
         }
         this._attach(ref);
         return ref;
-    }
-    static _detach(ref) {
+    };
+    ArSyncModel._detach = function (ref) {
+        var _this = this;
         ref.count--;
-        const timeout = this.cacheTimeout;
+        var timeout = this.cacheTimeout;
         if (ref.count !== 0)
             return;
-        const timedout = () => {
+        var timedout = function () {
             ref.model.release();
-            delete this._cache[ref.key];
+            delete _this._cache[ref.key];
         };
         if (timeout) {
             ref.timer = setTimeout(timedout, timeout);
@@ -106,28 +109,34 @@ class ArSyncModel {
         else {
             timedout();
         }
-    }
-    static _attach(ref) {
+    };
+    ArSyncModel._attach = function (ref) {
         ref.count++;
         if (ref.timer)
             clearTimeout(ref.timer);
-    }
-    static setConnectionAdapter(adapter) {
+    };
+    ArSyncModel.setConnectionAdapter = function (adapter) {
         ArSyncStore_1.default.connectionManager = new ConnectionManager_1.default(adapter);
-    }
-    static waitForLoad(...models) {
-        return new Promise((resolve) => {
-            let count = 0;
-            for (const model of models) {
-                model.onload(() => {
+    };
+    ArSyncModel.waitForLoad = function () {
+        var models = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            models[_i] = arguments[_i];
+        }
+        return new Promise(function (resolve) {
+            var count = 0;
+            for (var _i = 0, models_1 = models; _i < models_1.length; _i++) {
+                var model = models_1[_i];
+                model.onload(function () {
                     count++;
                     if (models.length == count)
                         resolve(models);
                 });
             }
         });
-    }
-}
+    };
+    ArSyncModel._cache = {};
+    ArSyncModel.cacheTimeout = 10 * 1000;
+    return ArSyncModel;
+}());
 exports.default = ArSyncModel;
-ArSyncModel._cache = {};
-ArSyncModel.cacheTimeout = 10 * 1000;