ar_sync 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '01944ab2f90f657d412a17a52cb72eb249b5a3a96ca0531f273c1045900aae92'
+  data.tar.gz: 5f64eb0b5c66b24f886b693b9bee94a4f4ba95661768af4526fc3eda9be63d07
+SHA512:
+  metadata.gz: 1305699ff98f51f6f8bb63bc8724c022c65475036b533b865fa48eabe4353c29805653c1204c81a1ee51a2e3d8f06de37b75eaabb3e7baa8b2f5dd0a9b04e08e
+  data.tar.gz: 7a25e40259ee1ff0baa93f783dddb1a9af36cab92ecd8686b2f22885022004aaf716e18a004cb6a2c4b44e15ae3bb9216e1f7c7def0f59920eed77ef4e062f5a

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/test/*.sqlite3
+/test/generated_*
+.ruby-version
+/node_modules/
+tsconfig.tsbuildinfo

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.2
+before_install: gem install bundler -v 1.16.0

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in ar_sync.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,53 @@
+PATH
+  remote: .
+  specs:
+    ar_sync (1.0.0)
+      activerecord
+      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)
+    activesupport (5.2.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    ar_serializer (1.0.0)
+      activerecord
+      top_n_loader
+    arel (9.0.0)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.5)
+    i18n (1.6.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)
+      activerecord
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  ar_sync!
+  pry
+  rake
+  sqlite3
+
+BUNDLED WITH
+   1.16.1

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 tompng
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,128 @@
+# ArSync - Reactive Programming with Ruby on Rails
+
+Frontend JSON data will be synchronized with ActiveRecord.
+
+- Provides an json api with query(shape of the json)
+- Send a notificaiton with ActionCable and automaticaly updates the data
+
+## Installation
+
+1. Add this line to your application's Gemfile:
+```ruby
+gem 'ar_sync'
+```
+
+2. Run generator
+```shell
+rails g ar_sync:install
+```
+
+## Usage
+
+1. Define parent, data, has_one, has_many to your models
+```ruby
+class User < ApplicationRecord
+  has_many :posts
+  ...
+  sync_has_data :id, :name
+  sync_has_many :posts
+end
+
+class Post < ApplicationRecord
+  belongs_to :user
+  ...
+  sync_parent :user, inverse_of: :posts
+  sync_has_data :id, :title, :body, :createdAt, :updatedAt
+  sync_has_one :user, only: [:id, :name]
+end
+```
+
+2. Define apis
+```ruby
+# app/controllers/sync_api_controller.rb
+class SyncApiController < ApplicationController
+  include ArSync::ApiControllerConcern
+  # 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
+  end
+  # Reload api (field name = classname, params = `ids:`)
+  serializer_field :User do |current_user, ids:|
+    User.where(condition).where id: ids
+  end
+  serializer_field :Post do |current_user, ids:|
+    Post.where(condition).where id: ids
+  end
+end
+```
+
+3. Write your view
+```html
+<!-- if you're using vue -->
+<script>
+  const userModel = new ArSyncModel({
+    api: 'my_simple_profile_api ',
+    query: { id: true, name: true, posts: ['title', 'createdAt'] }
+  })
+  userModel.onload(() => {
+    new Vue({ el: '#root', data: { user: userModel.data } })
+  })
+</script>
+<div id='root'>
+  <h1>{{user.name}}'s page</h1>
+  <ul>
+    <li v-for='post in user.posts'>
+      <a :href="'/posts/' + post.id">
+        {{post.title}}
+      </a>
+      <small>date: {{post.createdAt}}</small>
+    </li>
+  </ul>
+  <form action='/posts' data-remote=true method=post>
+    <input name='post[title]'>
+    <textarea name=post[body]></textarea>
+    <input type=submit>
+  </form>
+</div>
+```
+Now, your view and ActiveRecord are synchronized.
+
+
+# With typescript
+1. Add `"ar_sync": "git://github.com/tompng/ar_sync.git"` to your package.json
+
+2. Generate types
+```shell
+rails g ar_sync:types path_to_generated_code_dir/
+```
+
+3. Connection Setting
+```ts
+import ArSyncModel from 'path_to_generated_code_dir/ArSyncModel'
+import ActionCableAdapter from 'ar_sync/core/ActionCableAdapter'
+ArSyncModel.setConnectionAdapter(new ActionCableAdapter)
+// ArSyncModel.setConnectionAdapter(new MyCustomConnectionAdapter) // If you are using other transports
+```
+
+4. Write your components
+```ts
+import { useArSyncModel } from 'path_to_generated_code_dir/hooks'
+const HelloComponent: React.FC = () => {
+  const [user, status] = useArSyncModel({
+    api: 'my_simple_profile_api',
+    query: ['id', 'name']
+  })
+  // user // => { id: number; name: string } | null
+  if (!user) return <>loading...</>
+  // user.id // => number
+  // user.name // => string
+  // user.foobar // => compile error
+  return <h1>Hello, {user.name}!</h1>
+}
+```
+
+# Examples
+https://github.com/tompng/ar_sync_sampleapp

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/ar_sync.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ar_sync/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ar_sync'
+  spec.version       = ArSync::VERSION
+  spec.authors       = ['tompng']
+  spec.email         = ['tomoyapenguin@gmail.com']
+
+  spec.summary       = %(ActiveRecord - JavaScript Sync)
+  spec.description   = %(ActiveRecord data synchronized with frontend DataStore)
+  spec.homepage      = "https://github.com/tompng/#{spec.name}"
+  spec.license       = 'MIT'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features|sampleapp)/})
+  end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord'
+  spec.add_dependency 'ar_serializer'
+  %w[rake pry sqlite3].each do |gem_name|
+    spec.add_development_dependency gem_name
+  end
+end

data/bin/console

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ar_sync'
+require 'pry'
+require_relative '../test/model_tree'
+require_relative '../test/model_graph'
+ArSync.on_notification do |events|
+  puts "\e[1m#{events.inspect}\e[m"
+end
+
+Pry.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/core/ActioncableAdapter.d.ts

@@ -0,0 +1,10 @@
+import * as ActionCable from 'actioncable';
+import ConnectionAdapter from './ConnectionAdapter';
+export default class ActionCableAdapter implements ConnectionAdapter {
+    connected: boolean;
+    _cable: ActionCable.Cable;
+    constructor();
+    subscribe(key: string, received: (data: any) => void): ActionCable.Channel;
+    ondisconnect(): void;
+    onreconnect(): void;
+}

data/core/ActioncableAdapter.js

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

data/core/ArSyncApi.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    fetch: (request: object) => Promise<{}>;
+    syncFetch: (request: object) => Promise<{}>;
+};
+export default _default;

data/core/ArSyncApi.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+async function apiBatchFetch(endpoint, requests) {
+    const headers = {
+        'Accept': 'application/json',
+        'Content-Type': 'application/json'
+    };
+    const body = JSON.stringify({ requests });
+    const option = { credentials: 'include', method: 'POST', headers, body };
+    const res = await fetch(endpoint, option);
+    if (res.status === 200)
+        return res.json();
+    throw new Error(res.statusText);
+}
+class ApiFetcher {
+    constructor(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)
+                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);
+                    if (compacts[key]) {
+                        compacts[key].push(callback);
+                    }
+                    else {
+                        requests.push(request);
+                        callbacksList.push(compacts[key] = [callback]);
+                    }
+                }
+                this.batches = [];
+                apiBatchFetch(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) {
+                                callback.resolve(result.data);
+                            }
+                            else {
+                                const error = result.error || { type: 'Unknown Error' };
+                                callback.reject(error);
+                            }
+                        }
+                    }
+                }).catch((e) => {
+                    const error = { type: e.name, message: e.message, retry: true };
+                    for (const callbacks of callbacksList) {
+                        for (const callback of callbacks)
+                            callback.reject(error);
+                    }
+                });
+            }, 16);
+        });
+    }
+}
+const staticFetcher = new ApiFetcher('/static_api');
+const syncFetcher = new ApiFetcher('/sync_api');
+exports.default = {
+    fetch: (request) => staticFetcher.fetch(request),
+    syncFetch: (request) => syncFetcher.fetch(request),
+};

data/core/ArSyncModelBase.d.ts

@@ -0,0 +1,71 @@
+interface Request {
+    api: string;
+    query: any;
+    params?: any;
+}
+declare type Path = (string | number)[];
+interface Change {
+    path: Path;
+    value: any;
+}
+declare type ChangeCallback = (change: Change) => void;
+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> {
+    private _ref;
+    private _listenerSerial;
+    private _listeners;
+    complete: boolean;
+    notfound?: boolean;
+    connected: boolean;
+    data: T | null;
+    static _cache: {
+        [key: string]: {
+            key: string;
+            count: number;
+            timer: number | null;
+            model: any;
+        };
+    };
+    static cacheTimeout: number;
+    abstract refManagerClass(): any;
+    abstract connectionManager(): {
+        networkStatus: boolean;
+    };
+    constructor(request: Request, option?: {
+        immutable: boolean;
+    });
+    onload(callback: LoadCallback): void;
+    subscribeOnce(event: SubscriptionType, callback: SubscriptionCallback): {
+        unsubscribe: () => void;
+    };
+    subscribe(event: SubscriptionType, callback: SubscriptionCallback): {
+        unsubscribe: () => void;
+    };
+    release(): void;
+    static retrieveRef(request: Request, option?: {
+        immutable: boolean;
+    }): {
+        key: string;
+        count: number;
+        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<{}>;
+}
+export {};