ar_sync 1.1.0 → 1.1.2

data/lib/ar_sync/instance_methods.rb

@@ -1,7 +1,18 @@
 module ArSync::ModelBase::InstanceMethods
+  def sync_keys(current_user)
+    [ArSync.sync_key(self), ArSync.sync_key(self, current_user)]
+  end
+
+  def _sync_field(current_user)
+    { id:, keys: sync_keys(current_user) }
+  end
+
   def _sync_notify(action)
     _sync_notify_parent action
-    _sync_notify_self if self.class._sync_self? && action == :update
+    if self.class._sync_self?
+      _sync_notify_self if action == :update
+      _sync_notify_self_destroy if action == :destroy
+    end
   end
 
   def _sync_current_watch_values
@@ -121,4 +132,8 @@ module ArSync::ModelBase::InstanceMethods
     end
     ArSync.sync_send to: self, action: :update, model: self
   end
+
+  def _sync_notify_self_destroy
+    ArSync.sync_send to: self, action: :destroy, path: :_destroy, model: nil
+  end
 end

data/lib/ar_sync/rails.rb

@@ -47,8 +47,8 @@ module ArSync
     end
 
     def sync_call
-      _api_call :sync do |model, current_user, query|
-        ArSync.sync_serialize model, current_user, query
+      _api_call :sync do |schema, current_user, query|
+        ArSync.sync_serialize schema, current_user, query
       end
     end
 
@@ -69,15 +69,8 @@ module ArSync
     end
 
     def static_call
-      _api_call :static do |model, current_user, query|
-        case model
-        when ArSync::Collection, ActiveRecord::Relation, Array
-          ArSerializer.serialize model.to_a, query, context: current_user
-        when ArSerializer::Serializable
-          ArSerializer.serialize model, query, context: current_user
-        else
-          model
-        end
+      _api_call :static do |schema, current_user, query|
+        ArSerializer.serialize schema, query, context: current_user
       end
     end
 
@@ -87,15 +80,19 @@ module ArSync
       if respond_to?(ArSync.config.current_user_method)
         current_user = send ArSync.config.current_user_method
       end
+      sch = schema
       responses = params[:requests].map do |request|
         begin
           api_name = request[:api]
-          sch = schema
-          info = sch.class._serializer_field_info api_name
-          raise ArSync::ApiNotFound, "#{type.to_s.capitalize} API named `#{api_name}` not configured" unless info
-          api_params = (request[:params].as_json || {}).transform_keys(&:to_sym)
-          model = sch.instance_exec(current_user, **api_params, &info.data_block)
-          { data: yield(model, current_user, request[:query].as_json) }
+          raise ArSync::ApiNotFound, "#{type.to_s.capitalize} API named `#{api_name}` not configured" unless sch.class._serializer_field_info api_name
+          query = {
+            api_name => {
+              as: :data,
+              params: request[:params].as_json,
+              attributes: request[:query].as_json
+            }
+          }
+          yield schema, current_user, query
         rescue StandardError => e
           { error: handle_exception(e) }
         end

data/lib/ar_sync/version.rb

@@ -1,3 +1,3 @@
 module ArSync
-  VERSION = '1.1.0'
+  VERSION = '1.1.2'
 end

data/src/core/ArSyncModel.ts

@@ -1,15 +1,15 @@
-import ArSyncStore from './ArSyncStore'
+import { ArSyncStore, Request } from './ArSyncStore'
 import ArSyncConnectionManager from './ConnectionManager'
 import ConnectionAdapter from './ConnectionAdapter'
 
-interface Request { api: string; query: any; params?: any }
 type Path = Readonly<(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 SubscriptionType = 'load' | 'change' | 'connection' | 'destroy'
 type SubscriptionCallback = ChangeCallback | LoadCallback | ConnectionCallback
+type ArSyncModelRef = { key: string; count: number; timer: number | null; model: ArSyncStore }
 
 type PathFirst<P extends Readonly<any[]>> = ((...args: P) => void) extends (first: infer First, ...other: any) => void ? First : never
 
@@ -30,11 +30,12 @@ type DigResult<Data, P extends Readonly<any[]>> =
   : undefined
 
 export default class ArSyncModel<T> {
-  private _ref
+  private _ref: ArSyncModelRef
   private _listenerSerial: number
   private _listeners
-  complete: boolean
+  complete = false
   notfound?: boolean
+  destroyed = false
   connected: boolean
   data: T | null
   static _cache: { [key: string]: { key: string; count: number; timer: number | null; model } } = {}
@@ -43,16 +44,17 @@ export default class ArSyncModel<T> {
     this._ref = ArSyncModel.retrieveRef(request, option)
     this._listenerSerial = 0
     this._listeners = {}
-    this.complete = false
     this.connected = ArSyncStore.connectionManager.networkStatus
     const setData = () => {
       this.data = this._ref.model.data
       this.complete = this._ref.model.complete
       this.notfound = this._ref.model.notfound
+      this.destroyed = this._ref.model.destroyed
     }
     setData()
     this.subscribe('load', setData)
     this.subscribe('change', setData)
+    this.subscribe('destroy', setData)
     this.subscribe('connection', (status: boolean) => {
       this.connected = status
     })
@@ -107,12 +109,11 @@ export default class ArSyncModel<T> {
     for (const id in this._listeners) this._listeners[id].unsubscribe()
     this._listeners = {}
     ArSyncModel._detach(this._ref)
-    this._ref = null
   }
   static retrieveRef(
     request: Request,
     option?: { immutable: boolean }
-  ): { key: string; count: number; timer: number | null; model } {
+  ): ArSyncModelRef {
     const key = JSON.stringify([request, option])
     let ref = this._cache[key]
     if (!ref) {