ar_sync 1.1.0 → 1.1.2

data/src/core/ArSyncStore.ts

@@ -1,4 +1,7 @@
 import ArSyncApi from './ArSyncApi'
+export type Request = { api: string; query: any; params?: any; id?: IDType }
+
+type IDType = number | string
 
 class ModelBatchRequest {
   timer: number | null = null
@@ -6,8 +9,8 @@ class ModelBatchRequest {
     Map<string,
       {
         query,
-        requests: Map<number, {
-          id: number
+        requests: Map<IDType, {
+          id: IDType
           model?
           callbacks: {
             resolve: (model: any) => void
@@ -17,7 +20,7 @@ class ModelBatchRequest {
       }
     >
   >()
-  fetch(api: string, query, id: number) {
+  fetch(api: string, query, id: IDType) {
     this.setTimer()
     return new Promise((resolve, reject) => {
       const queryJSON = JSON.stringify(query)
@@ -36,7 +39,7 @@ class ModelBatchRequest {
         const ids = Array.from(requests.keys())
         ArSyncApi.syncFetch({ api, query, params: { ids } }).then((models: any[]) => {
           for (const model of models) {
-            const req = requests.get(model.id)
+            const req = requests.get(model._sync.id)
             if (req) req.model = model
           }
           requests.forEach(({ model, callbacks }) => {
@@ -67,18 +70,18 @@ type ParsedQuery = {
   params: any
 } | {}
 
+type SyncField = { id: IDType; keys: string[] }
 type Unsubscribable = { unsubscribe: () => void }
 
 class ArSyncContainerBase {
   data
   listeners: Unsubscribable[] = []
   networkSubscriber?: Unsubscribable
-  parentModel
+  parentModel: ArSyncRecord | ArSyncCollection | null = null
   parentKey
   children: ArSyncContainerBase[] | { [key: string]: ArSyncContainerBase | null }
-  sync_keys: string[]
   onConnectionChange?: (status: boolean) => void
-  replaceData(_data, _sync_keys?) {}
+  replaceData(_data, _parentSyncKeys?) {}
   initForReload(request) {
     this.networkSubscriber = ArSyncStore.connectionManager.subscribeNetwork((state) => {
       if (!state) {
@@ -124,7 +127,7 @@ class ArSyncContainerBase {
     for (const l of this.listeners) l.unsubscribe()
     this.listeners = []
   }
-  static compactQuery(query: ParsedQuery) {
+  static compactQueryAttributes(query: ParsedQuery) {
     function compactAttributes(attributes: Record<string, ParsedQuery>): [ParsedQuery, boolean] {
       const attrs = {}
       const keys: string[] = []
@@ -160,6 +163,7 @@ class ArSyncContainerBase {
       return result
     }
     const result = compactQuery(query)
+    if (typeof result === 'object' && 'attributes' in result) return result.attributes
     return result === true ? {} : result
   }
   static parseQuery(query, attrsonly: true): Record<string, ParsedQuery>
@@ -196,63 +200,52 @@ class ArSyncContainerBase {
     if (attrsonly) return attributes
     return { attributes, as: column, params }
   }
-  static _load({ api, id, params, query }, root) {
+  static load({ api, id, params, query }: Request, root: ArSyncStore) {
     const parsedQuery = ArSyncRecord.parseQuery(query)
-    const compactQuery = ArSyncRecord.compactQuery(parsedQuery)
+    const compactQueryAttributes = ArSyncRecord.compactQueryAttributes(parsedQuery)
     if (id != null) {
-      return modelBatchRequest.fetch(api, compactQuery, id).then(data => {
+      return modelBatchRequest.fetch(api, compactQueryAttributes, id).then(data => {
         if (!data) throw { retry: false }
-        const request = { api, id, query: compactQuery }
-        return new ArSyncRecord(parsedQuery, data, request, root)
+        const request = { api, id, query: compactQueryAttributes }
+        return new ArSyncRecord(parsedQuery, data, request, root, null, null)
       })
     } else {
-      const request = { api, query: compactQuery, params }
+      const request = { api, query: compactQueryAttributes, params }
       return ArSyncApi.syncFetch(request).then((response: any) => {
         if (!response) {
           throw { retry: false }
-        } else if (response.collection && response.order) {
-          return new ArSyncCollection(response.sync_keys, 'collection', parsedQuery, response, request, root)
+        } else if (response.collection && response.order && response._sync) {
+          return new ArSyncCollection(response._sync.keys, 'collection', parsedQuery, response, request, root, null, null)
         } else if (response instanceof Array) {
-          return new ArSyncCollection([], '', parsedQuery, response, request, root)
+          return new ArSyncCollection([], '', parsedQuery, response, request, root, null, null)
         } else {
-          return new ArSyncRecord(parsedQuery, response, request, root)
+          return new ArSyncRecord(parsedQuery, response, request, root, null, null)
         }
       })
     }
   }
-  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)
-        })
-      })
-    })
-  }
 }
 
 type NotifyData = {
   action: 'add' | 'remove' | 'update'
-  class_name: string
-  id: number
+  class: string
+  id: IDType
   field?: string
 }
 
 class ArSyncRecord extends ArSyncContainerBase {
-  id: number
-  root
+  id: IDType
+  root: ArSyncStore
   query
   queryAttributes
   data
+  syncKeys: string[]
   children: { [key: string]: ArSyncContainerBase | null }
   paths: string[]
   reloadQueryCache
-  constructor(query, data, request, root) {
+  rootRecord: boolean
+  fetching = new Set<string>()
+  constructor(query, data, request, root: ArSyncStore, parentModel: ArSyncRecord | ArSyncCollection | null, parentKey: string | number | null) {
     super()
     this.root = root
     if (request) this.initForReload(request)
@@ -260,48 +253,43 @@ class ArSyncRecord extends ArSyncContainerBase {
     this.queryAttributes = query.attributes || {}
     this.data = {}
     this.children = {}
+    this.rootRecord = !parentModel
+    this.id = data._sync.id
+    this.syncKeys = data._sync.keys
     this.replaceData(data)
+    this.parentModel = parentModel
+    this.parentKey = parentKey
   }
-  setSyncKeys(sync_keys: string[] | undefined) {
-    this.sync_keys = sync_keys ?? []
-  }
-  replaceData(data) {
-    this.setSyncKeys(data.sync_keys)
+  replaceData(data: { _sync: SyncField }) {
+    this.id = data._sync.id
+    this.syncKeys = 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.queryAttributes) {
       const subQuery = this.queryAttributes[key]
       const aliasName = subQuery.as || key
       const subData = data[aliasName]
       const child = this.children[aliasName]
-      if (key === 'sync_keys') continue
-      if (subData instanceof Array || (subData && subData.collection && subData.order)) {
+      if (key === '_sync') continue
+      if (subData instanceof Array || (subData && subData.collection && subData.order && subData._sync)) {
         if (child) {
-          child.replaceData(subData, this.sync_keys)
+          child.replaceData(subData, this.syncKeys)
         } else {
-          const collection = new ArSyncCollection(this.sync_keys, key, subQuery, subData, null, this.root)
+          const collection = new ArSyncCollection(this.syncKeys, key, subQuery, subData, null, this.root, this, aliasName)
           this.mark()
           this.children[aliasName] = collection
           this.data[aliasName] = collection.data
-          collection.parentModel = this
-          collection.parentKey = aliasName
         }
       } else {
         if (subQuery.attributes && Object.keys(subQuery.attributes).length > 0) this.paths.push(key)
-        if (subData && subData.sync_keys) {
+        if (subData && subData._sync) {
           if (child) {
             child.replaceData(subData)
           } else {
-            const model = new ArSyncRecord(subQuery, subData, null, this.root)
+            const model = new ArSyncRecord(subQuery, subData, null, this.root, this, aliasName)
             this.mark()
             this.children[aliasName] = model
             this.data[aliasName] = model.data
-            model.parentModel = this
-            model.parentKey = aliasName
           }
         } else {
           if(child) {
@@ -317,6 +305,7 @@ class ArSyncRecord extends ArSyncContainerBase {
     }
     if (this.queryAttributes['*']) {
       for (const key in data) {
+        if (key === '_sync') continue
         if (!this.queryAttributes[key] && this.data[key] !== data[key]) {
           this.mark()
           this.data[key] = data[key]
@@ -326,28 +315,34 @@ class ArSyncRecord extends ArSyncContainerBase {
     this.subscribeAll()
   }
   onNotify(notifyData: NotifyData, path?: string) {
-    const { action, class_name: className, id } = notifyData
+    const { action, class: className, id } = notifyData
     const query = path && this.queryAttributes[path]
     const aliasName = (query && query.as) || path;
     if (action === 'remove') {
       const child = this.children[aliasName]
+      this.fetching.delete(`${aliasName}:${id}`) // To cancel consumeAdd
       if (child) child.release()
       this.children[aliasName] = null
       this.mark()
       this.data[aliasName] = null
       this.onChange([aliasName], null)
     } else if (action === 'add') {
-      if (this.data[aliasName] && this.data[aliasName].id === id) return
-      modelBatchRequest.fetch(className, ArSyncRecord.compactQuery(query), id).then(data => {
+      const child = this.children[aliasName]
+      if (child instanceof ArSyncRecord && child.id === id) return
+      const fetchKey = `${aliasName}:${id}`
+      this.fetching.add(fetchKey)
+      modelBatchRequest.fetch(className, ArSyncRecord.compactQueryAttributes(query), id).then(data => {
+        // Record already removed
+        if (!this.fetching.has(fetchKey)) return
+
+        this.fetching.delete(fetchKey)
         if (!data || !this.data) return
-        const model = new ArSyncRecord(query, data, null, this.root)
+        const model = new ArSyncRecord(query, data, null, this.root, this, aliasName)
         const child = this.children[aliasName]
         if (child) child.release()
         this.children[aliasName] = model
         this.mark()
         this.data[aliasName] = model.data
-        model.parentModel = this
-        model.parentKey = aliasName
         this.onChange([aliasName], model.data)
       }).catch(e => {
         console.error(`failed to load ${className}:${id} ${e}`)
@@ -365,42 +360,42 @@ class ArSyncRecord extends ArSyncContainerBase {
   }
   subscribeAll() {
     const callback = data => this.onNotify(data)
-    for (const key of this.sync_keys) {
+    for (const key of this.syncKeys) {
       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)
+      for (const key of this.syncKeys) this.subscribe(key + path, pathCallback)
+    }
+    if (this.rootRecord) {
+      const key = this.syncKeys[0]
+      if (key) this.subscribe(key + '_destroy', () => this.root.handleDestroy())
     }
   }
   patchQuery(key: string) {
-    const val = this.queryAttributes[key]
-    if (!val) return
-    let { attributes, as, params } = val
-    if (attributes && Object.keys(val.attributes).length === 0) attributes = null
-    if (!attributes && !as && !params) return key
-    const result: { attributes?; as?; params? } = {}
-    if (attributes) result.attributes = attributes
-    if (as) result.as = as
-    if (params) result.params = params
-    return result
+    const subQuery = this.queryAttributes[key]
+    if (subQuery) return { [key]: subQuery }
   }
   reloadQuery() {
     if (this.reloadQueryCache) return this.reloadQueryCache
-    const reloadQuery = this.reloadQueryCache = { attributes: [] as any[] }
+    let arrayQuery = [] as string[] | null
+    const hashQuery = {}
     for (const key in this.queryAttributes) {
-      if (key === 'sync_keys') continue
+      if (key === '_sync') continue
       const val = this.queryAttributes[key]
       if (!val || !val.attributes) {
-        reloadQuery.attributes.push(key)
+        arrayQuery?.push(key)
+        hashQuery[key] = true
       } else if (!val.params && Object.keys(val.attributes).length === 0) {
-        reloadQuery.attributes.push({ [key]: val })
+        arrayQuery = null
+        hashQuery[key] = val
       }
     }
-    return reloadQuery
+    return this.reloadQueryCache = arrayQuery || hashQuery
   }
   update(data) {
     for (const key in data) {
+      if (key === '_sync') continue
       const subQuery = this.queryAttributes[key]
       if (subQuery && subQuery.attributes && Object.keys(subQuery.attributes).length > 0) continue
       if (this.data[key] === data[key]) continue
@@ -417,35 +412,39 @@ class ArSyncRecord extends ArSyncContainerBase {
     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)
+    if (this.parentModel && this.parentKey) (this.parentModel as { markAndSet(key: string | number, data: any): any }).markAndSet(this.parentKey, this.data)
   }
 }
 
 type Ordering = { first?: number; last?: number; orderBy: string; direction: 'asc' | 'desc' }
 class ArSyncCollection extends ArSyncContainerBase {
-  root
+  root: ArSyncStore
   path: string
   ordering: Ordering = { orderBy: 'id', direction: 'asc' }
   query
   queryAttributes
-  compactQuery
+  compactQueryAttributes
+  syncKeys: string[]
   data: any[]
   children: ArSyncRecord[]
   aliasOrderKey = 'id'
-  constructor(sync_keys: string[], path: string, query, data: any[], request, root){
+  fetching = new Set<IDType>()
+  constructor(parentSyncKeys: string[], path: string, query, data: any[], request, root: ArSyncStore, parentModel: ArSyncRecord | null, parentKey: string | null){
     super()
     this.root = root
     this.path = path
     this.query = query
     this.queryAttributes = query.attributes || {}
-    this.compactQuery = ArSyncRecord.compactQuery(query)
+    this.compactQueryAttributes = ArSyncRecord.compactQueryAttributes(query)
     if (request) this.initForReload(request)
     if (query.params) {
       this.setOrdering(query.params)
     }
     this.data = []
     this.children = []
-    this.replaceData(data, sync_keys)
+    this.replaceData(data, parentSyncKeys)
+    this.parentModel = parentModel
+    this.parentKey = parentKey
   }
   setOrdering(ordering: { first?: unknown; last?: unknown; orderBy?: unknown; direction?: unknown }) {
     let direction: 'asc' | 'desc' = 'asc'
@@ -460,17 +459,17 @@ class ArSyncCollection extends ArSyncContainerBase {
     this.aliasOrderKey = (subQuery && subQuery.as) || orderBy
     this.ordering = { first, last, direction, orderBy }
   }
-  setSyncKeys(sync_keys: string[]) {
-    if (sync_keys) {
-      this.sync_keys = sync_keys.map(key => key + this.path)
+  setSyncKeys(parentSyncKeys: string[] | undefined) {
+    if (parentSyncKeys) {
+      this.syncKeys = parentSyncKeys.map(key => key + this.path)
     } else {
-      this.sync_keys = []
+      this.syncKeys = []
     }
   }
-  replaceData(data: any[] | { collection: any[]; ordering: Ordering }, sync_keys: string[]) {
-    this.setSyncKeys(sync_keys)
-    const existings = new Map<number, ArSyncRecord>()
-    for (const child of this.children) existings.set(child.data.id, child)
+  replaceData(data: any[] | { collection: any[]; ordering: Ordering }, parentSyncKeys: string[]) {
+    this.setSyncKeys(parentSyncKeys)
+    const existings = new Map<IDType, ArSyncRecord>()
+    for (const child of this.children) existings.set(child.id, child)
     let collection: any[]
     if (Array.isArray(data)) {
       collection = data
@@ -482,14 +481,12 @@ class ArSyncCollection extends ArSyncContainerBase {
     const newData: any[] = []
     for (const subData of collection) {
       let model: ArSyncRecord | undefined = undefined
-      if (typeof(subData) === 'object' && subData && 'sync_keys' in subData) model = existings.get(subData.id)
+      if (typeof(subData) === 'object' && subData && '_sync' in subData) model = existings.get(subData._sync.id)
       let data = subData
       if (model) {
         model.replaceData(subData)
-      } else if (subData.sync_keys) {
-        model = new ArSyncRecord(this.query, subData, null, this.root)
-        model.parentModel = this
-        model.parentKey = subData.id
+      } else if (subData._sync) {
+        model = new ArSyncRecord(this.query, subData, null, this.root, this, subData._sync.id)
       }
       if (model) {
         newChildren.push(model)
@@ -499,7 +496,7 @@ class ArSyncCollection extends ArSyncContainerBase {
     }
     while (this.children.length) {
       const child = this.children.pop()!
-      if (!existings.has(child.data.id)) child.release()
+      if (!existings.has(child.id)) child.release()
     }
     if (this.data.length || newChildren.length) this.mark()
     while (this.data.length) this.data.pop()
@@ -507,13 +504,13 @@ class ArSyncCollection extends ArSyncContainerBase {
     for (const el of newData) this.data.push(el)
     this.subscribeAll()
   }
-  consumeAdd(className: string, id: number) {
+  consumeAdd(className: string, id: IDType) {
     const { first, last, direction } = this.ordering
     const limit = first || last
-    if (this.data.findIndex(a => a.id === id) >= 0) return
-    if (limit && limit <= this.data.length) {
-      const lastItem = this.data[this.data.length - 1]
-      const firstItem = this.data[0]
+    if (this.children.find(a => a.id === id)) return
+    if (limit && limit <= this.children.length) {
+      const lastItem = this.children[this.children.length - 1]
+      const firstItem = this.children[0]
       if (direction === 'asc') {
         if (first) {
           if (lastItem && lastItem.id < id) return
@@ -528,11 +525,14 @@ class ArSyncCollection extends ArSyncContainerBase {
         }
       }
     }
-    modelBatchRequest.fetch(className, this.compactQuery, id).then((data: any) => {
+    this.fetching.add(id)
+    modelBatchRequest.fetch(className, this.compactQueryAttributes, id).then((data: any) => {
+      // Record already removed
+      if (!this.fetching.has(id)) return
+
+      this.fetching.delete(id)
       if (!data || !this.data) return
-      const model = new ArSyncRecord(this.query, data, null, this.root)
-      model.parentModel = this
-      model.parentKey = id
+      const model = new ArSyncRecord(this.query, data, null, this.root, this, id)
       const overflow = limit && limit <= this.data.length
       let rmodel: ArSyncRecord | undefined
       this.mark()
@@ -587,8 +587,9 @@ class ArSyncCollection extends ArSyncContainerBase {
       this.data.sort((a, b) => a[orderKey] > b[orderKey] ? -1 : +1)
     }
   }
-  consumeRemove(id: number) {
-    const idx = this.data.findIndex(a => a.id === id)
+  consumeRemove(id: IDType) {
+    const idx = this.children.findIndex(a => a.id === id)
+    this.fetching.delete(id) // To cancel consumeAdd
     if (idx < 0) return
     this.mark()
     this.children[idx].release()
@@ -596,58 +597,64 @@ class ArSyncCollection extends ArSyncContainerBase {
     this.data.splice(idx, 1)
     this.onChange([id], null)
   }
-  onNotify(notifyData) {
+  onNotify(notifyData: NotifyData) {
     if (notifyData.action === 'add') {
-      this.consumeAdd(notifyData.class_name, notifyData.id)
+      this.consumeAdd(notifyData.class, 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)
+    for (const key of this.syncKeys) this.subscribe(key, callback)
   }
   onChange(path: (string | number)[], data) {
     super.onChange(path, data)
     if (path[1] === this.aliasOrderKey) this.markAndSort()
   }
-  markAndSet(id: number, data) {
+  markAndSet(id: IDType, data) {
     this.mark()
-    const idx = this.data.findIndex(a => a.id === id)
+    const idx = this.children.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)
+    if (this.parentModel && this.parentKey) (this.parentModel as { markAndSet(key: string | number, data: any): any }).markAndSet(this.parentKey, this.data)
   }
 }
 
-export default class ArSyncStore {
+export class ArSyncStore {
   immutable: boolean
   markedForFreezeObjects: any[]
   changes
   eventListeners
   markForRelease: true | undefined
   container
-  request
-  complete: boolean
+  request: Request
+  complete = false
   notfound?: boolean
+  destroyed = false
   data
   changesBufferTimer: number | undefined | null
   retryLoadTimer: number | undefined | null
   static connectionManager
-  constructor(request, { immutable } = {} as { immutable?: boolean }) {
+  constructor(request: 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)
   }
+  handleDestroy() {
+    this.release()
+    this.data = null
+    this.destroyed = true
+    this.trigger('destroy')
+  }
   load(retryCount: number) {
     ArSyncContainerBase.load(this.request, this).then((container: ArSyncContainerBase) => {
       if (this.markForRelease) {

data/src/core/hooks.ts

@@ -21,11 +21,11 @@ function checkHooks() {
   if (!useState) throw 'uninitialized. needs `initializeHooks({ useState, useEffect, useMemo, useRef })`'
 }
 
-interface ModelStatus { complete: boolean; notfound?: boolean; connected: boolean }
+interface ModelStatus { complete: boolean; notfound?: boolean; connected: boolean; destroyed: boolean }
 export type DataAndStatus<T> = [T | null, ModelStatus]
 export interface Request { api: string; params?: any; id?: number; query: any }
 
-const initialResult: DataAndStatus<any> = [null, { complete: false, notfound: undefined, connected: true }]
+const initialResult: DataAndStatus<any> = [null, { complete: false, notfound: undefined, connected: true, destroyed: false }]
 export function useArSyncModel<T>(request: Request | null): DataAndStatus<T> {
   checkHooks()
   const [result, setResult] = useState<DataAndStatus<T>>(initialResult)
@@ -39,12 +39,12 @@ export function useArSyncModel<T>(request: Request | null): DataAndStatus<T> {
     }
     const model = new ArSyncModel<T>(request, { immutable: true })
     function update() {
-      const { complete, notfound, connected, data } = model
+      const { complete, notfound, connected, destroyed, data } = model
       setResult(resultWas => {
         const [dataWas, statusWas] = resultWas
-        const statusPersisted = statusWas.complete === complete && statusWas.notfound === notfound && statusWas.connected === connected
+        const statusPersisted = statusWas.complete === complete && statusWas.notfound === notfound && statusWas.connected === connected && statusWas.destroyed === destroyed
         if (dataWas === data && statusPersisted) return resultWas
-        const status = statusPersisted ? statusWas : { complete, notfound, connected }
+        const status = statusPersisted ? statusWas : { complete, notfound, connected, destroyed }
         return [data, status]
       })
     }
@@ -55,6 +55,7 @@ export function useArSyncModel<T>(request: Request | null): DataAndStatus<T> {
     }
     model.subscribe('load', update)
     model.subscribe('change', update)
+    model.subscribe('destroy', update)
     model.subscribe('connection', update)
     return () => model.release()
   }, [requestString])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ar_sync
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.2
 platform: ruby
 authors:
 - tompng
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-04-17 00:00:00.000000000 Z
+date: 2024-07-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -52,20 +52,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -105,7 +91,6 @@ files:
 - ".gitignore"
 - ".travis.yml"
 - Gemfile
-- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -129,7 +114,8 @@ files:
 - core/hooks.d.ts
 - core/hooks.js
 - gemfiles/Gemfile-rails-6
-- gemfiles/Gemfile-rails-7
+- gemfiles/Gemfile-rails-7-0
+- gemfiles/Gemfile-rails-7-1
 - index.d.ts
 - index.js
 - lib/ar_sync.rb
@@ -176,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: ActiveRecord - JavaScript Sync