ar_sync 1.0.0

data/src/graph/ArSyncModel.ts

@@ -0,0 +1,21 @@
+import ArSyncStore from './ArSyncStore'
+import ArSyncConnectionManager from '../core/ConnectionManager'
+import ArSyncModelBase from '../core/ArSyncModelBase'
+import ConnectionAdapter from '../core/ConnectionAdapter'
+
+export default class ArSyncModel<T> extends ArSyncModelBase<T> {
+  static setConnectionAdapter(adapter: ConnectionAdapter) {
+    ArSyncStore.connectionManager = new ArSyncConnectionManager(adapter)
+  }
+  static createRefModel(request, option): any {
+    return new ArSyncStore(request, option)
+  }
+  refManagerClass() {
+    return ArSyncModel
+  }
+  connectionManager() {
+    return ArSyncStore.connectionManager
+  }
+  static _cache = {}
+  static cacheTimeout = 10 * 1000
+}

data/src/graph/ArSyncStore.ts

@@ -0,0 +1,567 @@
+import ArSyncAPI from '../core/ArSyncApi'
+
+const ModelBatchRequest = {
+  timer: null,
+  apiRequests: {} as {
+    [api: string]: {
+      [queryJSON: string]: {
+        query
+        requests: {
+          [id: number]: {
+            id: number
+            model?
+            callbacks: ((model) => void)[]
+          }
+        }
+      }
+    }
+  },
+  fetch(api, query, id) {
+    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)
+    })
+  },
+  batchFetch() {
+    const { apiRequests } = this as typeof ModelBatchRequest
+    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.syncFetch({ api, query, params: { ids } }).then((models: any[]) => {
+          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)
+          }
+        })
+      }
+    }
+    this.apiRequests = {}
+  },
+  setTimer() {
+    if (this.timer) return
+    this.timer = setTimeout(() => {
+      this.timer = null
+      this.batchFetch()
+    }, 20)
+  }
+}
+
+class ArSyncContainerBase {
+  data
+  listeners
+  networkSubscriber
+  parentModel
+  parentKey
+  children: ArSyncContainerBase[]
+  onConnectionChange
+  constructor() {
+    this.listeners = []
+  }
+  replaceData(_data, _sync_keys?) {}
+  initForReload(request) {
+    this.networkSubscriber = ArSyncStore.connectionManager.subscribeNetwork((state) => {
+      if (state) {
+        ArSyncAPI.syncFetch(request).then(data => {
+          if (this.data) {
+            this.replaceData(data)
+            if (this.onConnectionChange) this.onConnectionChange(true)
+            if (this.onChange) this.onChange([], this.data)
+          }
+        })
+      } else {
+        if (this.onConnectionChange) this.onConnectionChange(false)
+      }
+    })
+  }
+  release() {
+    if (this.networkSubscriber) this.networkSubscriber.unsubscribe()
+    this.unsubscribeAll()
+    for (const child of Object.values(this.children)) {
+      if (child) child.release()
+    }
+    this.data = null
+  }
+  onChange(path, data) {
+    if (this.parentModel) this.parentModel.onChange([this.parentKey, ...path], data)
+  }
+  subscribe(key, listener) {
+    this.listeners.push(ArSyncStore.connectionManager.subscribe(key, listener))
+  }
+  unsubscribeAll() {
+    for (const l of this.listeners) l.unsubscribe()
+    this.listeners = []
+  }
+  static parseQuery(query, attrsonly = false){
+    const attributes = {}
+    let column = null
+    let params = null
+    if (!query) query = []
+    if (query.constructor !== Array) query = [query]
+    for (const arg of query) {
+      if (typeof(arg) === 'string') {
+        attributes[arg] = {}
+      } else if (typeof(arg) === 'object') {
+        for (const key in arg){
+          const 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) attributes[k] = child[k]
+          } else if (key === 'as') {
+            column = value
+          } else if (key === 'params') {
+            params = value
+          } else {
+            attributes[key] = this.parseQuery(value)
+          }
+        }
+      }
+    }
+    if (attrsonly) return attributes
+    return { attributes, as: column, params }
+  }
+  static _load({ api, id, params, query }, root) {
+    const parsedQuery = ArSyncRecord.parseQuery(query)
+    if (id) {
+      return ModelBatchRequest.fetch(api, query, id).then(data => new ArSyncRecord(parsedQuery, data[0], null, root))
+    } else {
+      const request = { api, query, params }
+      return ArSyncAPI.syncFetch(request).then((response: any) => {
+        if (response.collection && response.order) {
+          return new ArSyncCollection(response.sync_keys, 'collection', parsedQuery, response, request, root)
+        } else {
+          return new ArSyncRecord(parsedQuery, response, request, root)
+        }
+      })
+    }
+  }
+  static load(apiParams, root) {
+    if (!(apiParams instanceof Array)) return this._load(apiParams, root)
+    return new Promise((resolve, _reject) => {
+      const resultModels: any[] = []
+      let countdown = apiParams.length
+      apiParams.forEach((param, i) => {
+        this._load(param, root).then(model => {
+          resultModels[i] = model
+          countdown --
+          if (countdown === 0) resolve(resultModels)
+        })
+      })
+    })
+  }
+}
+
+class ArSyncRecord extends ArSyncContainerBase {
+  id
+  root
+  query
+  data
+  children
+  sync_keys
+  paths
+  reloadQueryCache
+  constructor(query, data, request, root) {
+    super()
+    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 = []
+      console.error('warning: no sync_keys')
+    }
+  }
+  replaceData(data) {
+    this.setSyncKeys(data.sync_keys)
+    this.unsubscribeAll()
+    if (this.data.id !== data.id) {
+      this.mark()
+      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]
+      if (key === 'sync_keys') continue
+      if (subQuery.attributes && (subData instanceof Array || (subData && subData.collection && subData.order))) {
+        if (this.children[aliasName]) {
+          this.children[aliasName].replaceData(subData, this.sync_keys)
+        } else {
+          const collection = new ArSyncCollection(this.sync_keys, key, subQuery, subData, null, this.root)
+          this.mark()
+          this.children[aliasName] = collection
+          this.data[aliasName] = collection.data
+          collection.parentModel = this
+          collection.parentKey = aliasName
+        }
+      } else {
+        if (subQuery.attributes) this.paths.push(key);
+        if (subData && subData.sync_keys) {
+          if (this.children[aliasName]) {
+            this.children[aliasName].replaceData(subData)
+          } else {
+            const model = new ArSyncRecord(subQuery, subData, null, this.root)
+            this.mark()
+            this.children[aliasName] = model
+            this.data[aliasName] = model.data
+            model.parentModel = this
+            model.parentKey = aliasName
+          }
+        } else {
+          if(this.children[aliasName]) {
+            this.children[aliasName].release()
+            delete this.children[aliasName]
+          }
+          if (this.data[aliasName] !== subData) {
+            this.mark()
+            this.data[aliasName] = subData
+          }
+        }
+      }
+    }
+    this.subscribeAll()
+  }
+  onNotify(notifyData, path?) {
+    const { action, class_name, id } = notifyData
+    if (action === 'remove') {
+      this.children[path].release()
+      this.children[path] = null
+      this.mark()
+      this.data[path] = null
+      this.onChange([path], null)
+    } else if (action === 'add') {
+      if (this.data.id === id) return
+      const query = this.query.attributes[path]
+      ModelBatchRequest.fetch(class_name, query, id).then(data => {
+        if (!data) return
+        const model = new ArSyncRecord(query, data, null, this.root)
+        if (this.children[path]) this.children[path].release()
+        this.children[path] = model
+        this.mark()
+        this.data[path] = model.data
+        model.parentModel = this
+        model.parentKey = path
+        this.onChange([path], model.data)
+      })
+    } else {
+      ModelBatchRequest.fetch(class_name, this.reloadQuery(), id).then(data => {
+        this.update(data)
+      })
+    }
+  }
+  subscribeAll() {
+    const callback = data => this.onNotify(data)
+    for (const key of this.sync_keys) {
+      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)
+    }
+  }
+  reloadQuery() {
+    if (this.reloadQueryCache) return this.reloadQueryCache
+    const reloadQuery = this.reloadQueryCache = { attributes: [] as any[] }
+    for (const key in this.query.attributes) {
+      if (key === 'sync_keys') continue
+      const val = this.query.attributes[key]
+      if (!val || !val.attributes) {
+        reloadQuery.attributes.push(key)
+      } else if (!val.params && Object.keys(val.attributes).length === 0) {
+        reloadQuery.attributes.push({ [key]: val })
+      }
+    }
+    return reloadQuery
+  }
+  update(data) {
+    for (const key in data) {
+      if (this.data[key] === data[key]) continue
+      this.mark()
+      this.data[key] = data[key]
+      this.onChange([key], data[key])
+    }
+  }
+  markAndSet(key, data) {
+    this.mark()
+    this.data[key] = data
+  }
+  mark() {
+    if (!this.root || !this.root.immutable || !Object.isFrozen(this.data)) return
+    this.data = { ...this.data }
+    this.root.mark(this.data)
+    if (this.parentModel) this.parentModel.markAndSet(this.parentKey, this.data)
+  }
+  onChange(path, data) {
+    if (this.parentModel) this.parentModel.onChange([this.parentKey, ...path], data)
+  }
+}
+class ArSyncCollection extends ArSyncContainerBase {
+  root
+  path
+  order
+  query
+  data
+  children
+  sync_keys
+  constructor(sync_keys, path, query, data, request, root){
+    super()
+    this.root = root
+    this.path = path
+    if (request) this.initForReload(request)
+    if (query.params && (query.params.order || query.params.limit)) {
+      this.order = { limit: query.params.limit, mode: query.params.order || 'asc' }
+    } else {
+      this.order = { limit: null, mode: 'asc' }
+    }
+    this.query = query
+    this.data = []
+    this.children = []
+    this.replaceData(data, sync_keys)
+  }
+  setSyncKeys(sync_keys) {
+    if (sync_keys) {
+      this.sync_keys = sync_keys.map(key => key + this.path)
+    } else {
+      console.error('warning: no sync_keys')
+      this.sync_keys = []
+    }
+  }
+  replaceData(data, sync_keys) {
+    this.setSyncKeys(sync_keys)
+    const existings = {}
+    for (const child of this.children) existings[child.data.id] = child
+    let collection
+    if (data.collection && data.order) {
+      collection = data.collection
+      this.order = data.order
+    } else {
+      collection = data
+    }
+    const newChildren: any[] = []
+    const newData: any[] = []
+    for (const subData of collection) {
+      let model = existings[subData.id]
+      if (model) {
+        model.replaceData(subData)
+      } else {
+        model = new ArSyncRecord(this.query, subData, null, this.root)
+        model.parentModel = this
+        model.parentKey = subData.id
+      }
+      newChildren.push(model)
+      newData.push(model.data)
+    }
+    while (this.children.length) {
+      const child = this.children.pop()
+      if (!existings[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) this.children.push(child)
+    for (const el of newData) this.data.push(el)
+    this.subscribeAll()
+  }
+  consumeAdd(className, id) {
+    if (this.data.findIndex(a => 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
+      } else {
+        const last = this.data[this.data.length - 1]
+        if (last && last.id > id) return
+      }
+    }
+    ModelBatchRequest.fetch(className, this.query, id).then((data) => {
+      if (!data) return
+      const 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()
+      if (this.order.mode === 'asc') {
+        const last = this.data[this.data.length - 1]
+        this.children.push(model)
+        this.data.push(model.data)
+        if (last && last.id > id) {
+          this.children.sort((a, b) => a.data.id < b.data.id ? -1 : +1)
+          this.data.sort((a, b) => a.id < b.id ? -1 : +1)
+        }
+        if (overflow) {
+          rmodel = this.children.shift()
+          rmodel.release()
+          this.data.shift()
+        }
+      } else {
+        const first = this.data[0]
+        this.children.unshift(model)
+        this.data.unshift(model.data)
+        if (first && first.id > id) {
+          this.children.sort((a, b) => a.data.id > b.data.id ? -1 : +1)
+          this.data.sort((a, b) => a.id > b.id ? -1 : +1)
+        }
+        if (overflow) {
+          rmodel = this.children.pop()
+          rmodel.release()
+          this.data.pop()
+        }
+      }
+      this.onChange([model.id], model.data)
+      if (rmodel) this.onChange([rmodel.id], null)
+    })
+  }
+  consumeRemove(id) {
+    const idx = this.data.findIndex(a => a.id === id)
+    if (idx < 0) return
+    this.mark()
+    this.children[idx].release()
+    this.children.splice(idx, 1)
+    this.data.splice(idx, 1)
+    this.onChange([id], null)
+  }
+  onNotify(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) this.subscribe(key, callback)
+  }
+  markAndSet(id, data) {
+    this.mark()
+    const idx = this.data.findIndex(a => a.id === id)
+    if (idx >= 0) this.data[idx] = data
+  }
+  mark() {
+    if (!this.root || !this.root.immutable || !Object.isFrozen(this.data)) return
+    this.data = [...this.data]
+    this.root.mark(this.data)
+    if (this.parentModel) this.parentModel.markAndSet(this.parentKey, this.data)
+  }
+}
+
+export default class ArSyncStore {
+  immutable
+  markedForFreezeObjects
+  changes
+  eventListeners
+  markForRelease
+  container
+  request
+  complete: boolean
+  notfound?: boolean
+  data
+  changesBufferTimer: number | undefined | null
+  retryLoadTimer: number | undefined | null
+  static connectionManager
+  constructor(request, { immutable } = {} as { immutable?: boolean }) {
+    this.immutable = immutable
+    this.markedForFreezeObjects = []
+    this.changes = []
+    this.eventListeners = { events: {}, serial: 0 }
+    this.request = request
+    this.complete = false
+    this.data = null
+    this.load(0)
+  }
+  load(retryCount: number) {
+    ArSyncContainerBase.load(this.request, this).then((container: ArSyncContainerBase) => {
+      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()
+      }
+      container.onConnectionChange = state => {
+        this.trigger('connection', state)
+      }
+    }).catch(e => {
+      if (this.markForRelease) return
+      if (!e.retry) {
+        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)
+        },
+        sleepSeconds * 1000
+      )
+    })
+  }
+  setChangesBufferTimer() {
+    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))
+    }, 20)
+  }
+  subscribe(event, callback) {
+    let listeners = this.eventListeners.events[event]
+    if (!listeners) this.eventListeners.events[event] = listeners = {}
+    const id = this.eventListeners.serial++
+    listeners[id] = callback
+    return { unsubscribe: () => { delete listeners[id] } }
+  }
+  trigger(event, arg?) {
+    const listeners = this.eventListeners.events[event]
+    if (!listeners) return
+    for (const id in listeners) listeners[id](arg)
+  }
+  mark(object) {
+    this.markedForFreezeObjects.push(object)
+  }
+  freezeRecursive(obj) {
+    if (Object.isFrozen(obj)) return obj
+    for (const key in obj) this.freezeRecursive(obj[key])
+    Object.freeze(obj)
+  }
+  freezeMarked() {
+    this.markedForFreezeObjects.forEach(obj => this.freezeRecursive(obj))
+    this.markedForFreezeObjects = []
+  }
+  release() {
+    if (this.retryLoadTimer) clearTimeout(this.retryLoadTimer)
+    if (this.changesBufferTimer) clearTimeout(this.changesBufferTimer)
+    if (this.container) {
+      this.container.release()
+    } else {
+      this.markForRelease = true
+    }
+  }
+}