ar_sync 1.0.0

data/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "ar_sync",
+  "version": "0.0.1",
+  "scripts": {
+    "prepare": "tsc",
+    "build": "tsc"
+  },
+  "dependencies": {},
+  "devDependencies": {
+    "react": "^16.8.6",
+    "@types/react": "^16.8.6",
+    "actioncable": "^5.2.0",
+    "@types/actioncable": "^5.2.0",
+    "eslint": "^5.16.0",
+    "typescript": "^3.4.5",
+    "@typescript-eslint/eslint-plugin": "^1.6.0",
+    "@typescript-eslint/parser": "^1.6.0"
+  }
+}

data/src/core/ActioncableAdapter.ts

@@ -0,0 +1,30 @@
+import * as ActionCable from 'actioncable'
+import ConnectionAdapter from './ConnectionAdapter'
+
+export default class ActionCableAdapter implements ConnectionAdapter {
+  connected: boolean
+  _cable: ActionCable.Cable
+  constructor() {
+    this.connected = true
+    this.subscribe(Math.random().toString(), () => {})
+  }
+  subscribe(key: string, received: (data: any) => void) {
+    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() {}
+}

data/src/core/ArSyncApi.ts

@@ -0,0 +1,75 @@
+async function apiBatchFetch(endpoint: string, requests: object[]) {
+  const headers = {
+    'Accept': 'application/json',
+    'Content-Type': 'application/json'
+  }
+  const body = JSON.stringify({ requests })
+  const option = { credentials: 'include', method: 'POST', headers, body } as const
+  const res = await fetch(endpoint, option)
+  if (res.status === 200) return res.json()
+  throw new Error(res.statusText)
+}
+
+interface PromiseCallback {
+  resolve: (data: object) => void
+  reject: (error: object) => void
+}
+
+class ApiFetcher {
+  endpoint: string
+  batches: [object, PromiseCallback][] = []
+  batchFetchTimer: number | null = null
+  constructor(endpoint: string) {
+    this.endpoint = endpoint
+  }
+  fetch(request: object) {
+    return new Promise((resolve, reject) => {
+      this.batches.push([request, { resolve, reject }])
+      if (this.batchFetchTimer) return
+      this.batchFetchTimer = setTimeout(() => {
+        this.batchFetchTimer = null
+        const compacts: { [key: string]: PromiseCallback[] } = {}
+        const requests: object[] = []
+        const callbacksList: PromiseCallback[][] = []
+        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')
+export default {
+  fetch: (request: object) => staticFetcher.fetch(request),
+  syncFetch: (request: object) => syncFetcher.fetch(request),
+}

data/src/core/ArSyncModelBase.ts

@@ -0,0 +1,126 @@
+interface Request { api: string; query: any; params?: any }
+type Path = (string | number)[]
+interface Change { path: Path; value: any }
+type ChangeCallback = (change: Change) => void
+type LoadCallback = () => void
+type ConnectionCallback = (status: boolean) => void
+type SubscriptionType = 'load' | 'change' | 'connection'
+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: number
+  private _listeners
+  complete: boolean
+  notfound?: boolean
+  connected: boolean
+  data: T | null
+  static _cache: { [key: string]: { key: string; count: number; timer: number | null; model } }
+  static cacheTimeout: number
+  abstract refManagerClass(): any
+  abstract connectionManager(): { networkStatus: boolean }
+  constructor(request: Request, option?: { immutable: boolean }) {
+    this._ref = this.refManagerClass().retrieveRef(request, option)
+    this._listenerSerial = 0
+    this._listeners = {}
+    this.complete = false
+    this.connected = this.connectionManager().networkStatus
+    const setData = () => {
+      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: boolean) => {
+      this.connected = status
+    })
+  }
+  onload(callback: LoadCallback) {
+    this.subscribeOnce('load', callback)
+  }
+  subscribeOnce(event: SubscriptionType, callback: SubscriptionCallback) {
+    const subscription = this.subscribe(event, (arg) => {
+      (callback as (arg: any) => void)(arg)
+      subscription.unsubscribe()
+    })
+    return subscription
+  }
+  subscribe(event: SubscriptionType, callback: SubscriptionCallback): { unsubscribe: () => void } {
+    const id = this._listenerSerial++
+    const subscription = this._ref.model.subscribe(event, callback)
+    let unsubscribed = false
+    const unsubscribe = () => {
+      unsubscribed = true
+      subscription.unsubscribe()
+      delete this._listeners[id]
+    }
+    if (this.complete) {
+      if (event === 'load') setTimeout(() => {
+        if (!unsubscribed) (callback as LoadCallback)()
+      }, 0)
+      if (event === 'change') setTimeout(() => {
+        if (!unsubscribed) (callback as ChangeCallback)({ path: [], value: this.data })
+      }, 0)
+    }
+    return this._listeners[id] = { unsubscribe }
+  }
+  release() {
+    for (const id in this._listeners) this._listeners[id].unsubscribe()
+    this._listeners = {}
+    this.refManagerClass()._detach(this._ref)
+    this._ref = null
+  }
+  static retrieveRef(
+    request: Request,
+    option?: { immutable: boolean }
+  ): { key: string; count: number; timer: number | null; model } {
+    const key = JSON.stringify([request, option])
+    let ref = this._cache[key]
+    if (!ref) {
+      const model = this.createRefModel(request, option)
+      ref = this._cache[key] = { key, count: 0, timer: null, model }
+    }
+    this._attach(ref)
+    return ref
+  }
+  static createRefModel(_request: Request, _option?: { immutable: boolean }) {
+    throw 'abstract method'
+  }
+  static _detach(ref) {
+    ref.count--
+    const timeout = this.cacheTimeout
+    if (ref.count !== 0) return
+    const timedout = () => {
+      ref.model.release()
+      delete this._cache[ref.key]
+    }
+    if (timeout) {
+      ref.timer = setTimeout(timedout, timeout)
+    } else {
+      timedout()
+    }
+  }
+  private static _attach(ref) {
+    ref.count++
+    if (ref.timer) clearTimeout(ref.timer)
+  }
+  static setConnectionAdapter(_adapter: Adapter) {}
+  static waitForLoad(...models: ArSyncModelBase<{}>[]) {
+    return new Promise((resolve) => {
+      let count = 0
+      for (const model of models) {
+        model.onload(() => {
+          count++
+          if (models.length == count) resolve(models)
+        })
+      }
+    })
+  }
+}

data/src/core/ConnectionAdapter.ts

@@ -0,0 +1,5 @@
+export default interface ConnectionAdapter {
+  ondisconnect: (() => void) | null
+  onreconnect: (() => void) | null
+  subscribe(key: string, callback: (data: any) => void): { unsubscribe: () => void }
+}

data/src/core/ConnectionManager.ts

@@ -0,0 +1,69 @@
+export default class ConnectionManager {
+  subscriptions
+  adapter
+  networkListeners
+  networkListenerSerial
+  networkStatus
+  constructor(adapter) {
+    this.subscriptions = {}
+    this.adapter = adapter
+    this.networkListeners = {}
+    this.networkListenerSerial = 0
+    this.networkStatus = true
+    adapter.ondisconnect = () => {
+      this.unsubscribeAll()
+      this.triggerNetworkChange(false)
+    }
+    adapter.onreconnect = () => this.triggerNetworkChange(true)
+  }
+  triggerNetworkChange(status) {
+    if (this.networkStatus == status) return
+    this.networkStatus = status
+    for (const id in this.networkListeners) this.networkListeners[id](status)
+  }
+  unsubscribeAll() {
+    for (const id in this.subscriptions) {
+      const subscription = this.subscriptions[id]
+      subscription.listeners = {}
+      subscription.connection.unsubscribe()
+    }
+    this.subscriptions = {}
+  }
+  subscribeNetwork(func) {
+    const id = this.networkListenerSerial++
+    this.networkListeners[id] = func
+    const unsubscribe = () => {
+      delete this.networkListeners[id]
+    }
+    return { unsubscribe }
+  }
+  subscribe(key, func) {
+    const subscription = this.connect(key)
+    const id = subscription.serial++
+    subscription.ref++
+    subscription.listeners[id] = func
+    const unsubscribe = () => {
+      if (!subscription.listeners[id]) return
+      delete subscription.listeners[id]
+      subscription.ref--
+      if (subscription.ref === 0) this.disconnect(key)
+    }
+    return { unsubscribe }
+  }
+  connect(key) {
+    if (this.subscriptions[key]) return this.subscriptions[key]
+    const connection = this.adapter.subscribe(key, data => this.received(key, data))
+    return this.subscriptions[key] = { connection, listeners: {}, ref: 0, serial: 0 }
+  }
+  disconnect(key) {
+    const subscription = this.subscriptions[key]
+    if (!subscription || subscription.ref !== 0) return
+    delete this.subscriptions[key]
+    subscription.connection.unsubscribe()
+  }
+  received(key, data) {
+    const subscription = this.subscriptions[key]
+    if (!subscription) return
+    for (const id in subscription.listeners) subscription.listeners[id](data)
+  }
+}

data/src/core/DataType.ts

@@ -0,0 +1,73 @@
+type RecordType = { _meta?: { query: any } }
+type Values<T> = T extends { [K in keyof T]: infer U } ? U : never
+type DataTypeExtractField<BaseType, Key extends keyof BaseType> = BaseType[Key] extends RecordType
+  ? (null extends BaseType[Key] ? {} | null : {})
+  : BaseType[Key] extends RecordType[]
+  ? {}[]
+  : BaseType[Key]
+
+type DataTypeExtractFieldsFromQuery<BaseType, Fields> = '*' extends Fields
+  ? { [key in Exclude<keyof BaseType, '_meta'>]: DataTypeExtractField<BaseType, key> }
+  : { [key in Fields & keyof (BaseType)]: DataTypeExtractField<BaseType, key> }
+
+interface ExtraFieldErrorType {
+  extraFieldError: any
+}
+
+type DataTypeExtractFromQueryHash<BaseType, QueryType> = '*' extends keyof QueryType
+  ? {
+      [key in Exclude<(keyof BaseType) | (keyof QueryType), '_meta' | '_params' | '*'>]: (key extends keyof BaseType
+        ? (key extends keyof QueryType
+            ? (QueryType[key] extends true
+                ? DataTypeExtractField<BaseType, key>
+                : DataTypeFromQuery<BaseType[key] & {}, QueryType[key]>)
+            : DataTypeExtractField<BaseType, key>)
+        : ExtraFieldErrorType)
+    }
+  : {
+      [key in keyof QueryType]: (key extends keyof BaseType
+        ? (QueryType[key] extends true
+            ? DataTypeExtractField<BaseType, key>
+            : DataTypeFromQuery<BaseType[key] & {}, QueryType[key]>)
+        : ExtraFieldErrorType)
+    }
+
+type _DataTypeFromQuery<BaseType, QueryType> = QueryType extends keyof BaseType | '*'
+  ? DataTypeExtractFieldsFromQuery<BaseType, QueryType>
+  : QueryType extends Readonly<(keyof BaseType | '*')[]>
+  ? DataTypeExtractFieldsFromQuery<BaseType, Values<QueryType>>
+  : QueryType extends { as: string }
+  ? { error: 'type for alias field is not supported' } | undefined
+  : DataTypeExtractFromQueryHash<BaseType, QueryType>
+
+export type DataTypeFromQuery<BaseType, QueryType> = BaseType extends any[]
+  ? CheckAttributesField<BaseType[0], QueryType>[]
+  : null extends BaseType
+  ? CheckAttributesField<BaseType & {}, QueryType> | null
+  : CheckAttributesField<BaseType & {}, QueryType>
+
+type CheckAttributesField<P, Q> = Q extends { attributes: infer R }
+  ? _DataTypeFromQuery<P, R>
+  : _DataTypeFromQuery<P, Q>
+
+type IsAnyCompareLeftType = { __any: never }
+
+type CollectExtraFields<Type, Path> = ExtraFieldErrorType extends Type
+  ? (IsAnyCompareLeftType extends Type ? null : Path)
+  : _CollectExtraFields<Type extends (infer R)[] ? R : (Type extends object ? Type : null)>
+
+type _CollectExtraFields<Type> = keyof (Type) extends never
+  ? null
+  : Values<{ [key in keyof Type]: CollectExtraFields<Type[key], [key]> }>
+
+type SelectString<T> = T extends string ? T : never
+type _ValidateDataTypeExtraFileds<Extra, Type> = SelectString<Values<Extra>> extends never
+  ? Type
+  : { error: { extraFields: SelectString<Values<Extra>> } }
+type ValidateDataTypeExtraFileds<Type> = _ValidateDataTypeExtraFileds<CollectExtraFields<Type, []>, Type>
+
+type RequestBase = { api: string; query: any; params?: any; _meta?: { data: any } }
+type DataTypeBaseFromRequestType<R> = R extends { _meta?: { data: infer DataType } } ? DataType : never
+export type DataTypeFromRequest<Req extends RequestBase, R extends RequestBase> = ValidateDataTypeExtraFileds<
+  DataTypeFromQuery<DataTypeBaseFromRequestType<Req>, R['query']>
+>

data/src/core/hooksBase.ts

@@ -0,0 +1,86 @@
+import { useState, useEffect, useCallback } from 'react'
+import ArSyncAPI from './ArSyncApi'
+
+interface ModelStatus { complete: boolean; notfound?: boolean; connected: boolean }
+export type DataAndStatus<T> = [T | null, ModelStatus]
+export interface Request { api: string; params?: any; query: any }
+
+interface ArSyncModel<T> {
+  data: T | null
+  complete: boolean
+  connected: boolean
+  notfound?: boolean
+  release(): void
+  subscribe(type: any, callback: any): any
+}
+export function useArSyncModelWithClass<T>(modelClass: { new<T>(req: Request, option?: any): ArSyncModel<T> }, request: Request | null): DataAndStatus<T> {
+  const [data, setData] = useState<T | null>(null)
+  const [status, setStatus] = useState<ModelStatus>({ complete: false, connected: true })
+  const updateStatus = (complete: boolean, notfound: boolean | undefined, connected: boolean) => {
+    if (complete === status.complete || notfound === status.notfound || connected === status.notfound) return
+    setStatus({ complete, notfound, connected })
+  }
+  useEffect(() => {
+    if (!request) return () => {}
+    const model = new modelClass<T>(request, { immutable: true })
+    if (model.complete) setData(model.data)
+    updateStatus(model.complete, model.notfound, model.connected)
+    model.subscribe('change', () => {
+      updateStatus(model.complete, model.notfound, model.connected)
+      setData(model.data)
+    })
+    model.subscribe('connection', () => {
+      updateStatus(model.complete, model.notfound, model.connected)
+    })
+    return () => model.release()
+  }, [JSON.stringify(request && request.params)])
+  return [data, status]
+}
+
+
+interface FetchStatus { complete: boolean; notfound?: boolean }
+type DataAndStatusAndUpdater<T> = [T | null, FetchStatus, () => void]
+export function useArSyncFetch<T>(request: Request | null): DataAndStatusAndUpdater<T> {
+  const [response, setResponse] = useState<T | null>(null)
+  const [status, setStatus] = useState<FetchStatus>({ complete: false })
+  const requestString = JSON.stringify(request && request.params)
+  let canceled = false
+  let timer: number | null = null
+  const update = useCallback(() => {
+    if (!request) {
+      setStatus({ complete: false, notfound: undefined })
+      return () => {}
+    }
+    canceled = false
+    timer = null
+    const fetch = (count: number) => {
+      if (timer) clearTimeout(timer)
+      timer = null
+      ArSyncAPI.fetch(request)
+        .then((response) => {
+          if (canceled) return
+          setResponse(response as T)
+          setStatus({ complete: true, notfound: false })
+        })
+        .catch(e => {
+          if (canceled) return
+          if (!e.retry) {
+            setResponse(null)
+            setStatus({ complete: true, notfound: true })
+            return
+          }
+          timer = setTimeout(() => fetch(count + 1), 1000 * Math.min(4 ** count, 30))
+        })
+    }
+    fetch(0)
+  }, [requestString])
+  useEffect(() => {
+    update()
+    return () => {
+      canceled = true
+      if (timer) clearTimeout(timer)
+      timer = null
+    }
+  }, [requestString])
+  return [response, status, update]
+}