@jcbuisson/express-x-client 3.0.3 → 3.1.0

package/CLAUDE.md

@@ -0,0 +1,71 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Overview
+
+`@jcbuisson/express-x-client` is the browser-side client library for the ExpressX framework. It wraps a socket.io socket and provides service proxies, pub/sub, and optional offline-first sync. The entire library lives in a single file: `src/client.mts`.
+
+The package is ESM-only (`"type": "module"`). The `main` field in `package.json` points directly to `src/client.mts` — there is no compilation or build step. No build, lint, or test scripts are defined.
+
+The file uses TypeScript syntax (type annotations) despite the absence of a `tsconfig.json`.
+
+## Architecture
+
+The library exports three main factory functions and one utility class that follow a plugin composition pattern:
+
+### `createClient(socket, options)`
+Core factory. Wraps a socket.io `socket` and returns an `app` object. Communication uses two custom socket events:
+- `client-request` / `client-response` — request/response using socket.io acknowledgments to correlate responses to waiting promises
+- `service-event` — server-to-client pub/sub notifications
+- `app-event` — application-wide broadcast events (outside any service)
+
+`app.configure(callback)` is the standard plugin composition hook — it calls `callback(app)` and is how plugins extend the app.
+
+The `service(name, serviceOptions)` method returns a `Proxy` that intercepts any property access and turns it into a `serviceMethodRequest` call, so callers can write `app.service('user').findMany(...)` without pre-declaring methods. `serviceOptions` supports:
+- `timeout` (default 20000 ms) — socket acknowledgment timeout
+- `volatile: true` — uses `socket.volatile` (fire-and-forget, drops if disconnected)
+
+### `reloadPlugin(app)`
+Enriches `app` with page-reload session continuity. On reconnect it emits `cnx-transfer` carrying the previous socket ID (persisted in `sessionStorage` via `@vueuse/core`'s `useSessionStorage`) so the server can migrate state.
+
+### `offlinePlugin(app)`
+Enriches `app` with offline-first IndexedDB CRUD via Dexie. Call `app.createOfflineModel(modelName, fields)` to get a model object.
+
+This plugin also adds three dynamic attributes to `app`:
+- `app.isConnected` — boolean, updated on socket connect/disconnect
+- `app.connectedDate` — `Date` of the last connection, or `null`
+- `app.disconnectedDate` — `Date` of the last disconnection, or `null` (used as `cutoffDate` for sync)
+
+Each model maintains three Dexie stores under the same DB name:
+- `values` — the actual records (indexed on `uid`, `__deleted__`)
+- `metadata` — per-record `created_at / updated_at / deleted_at`
+- `whereList` — set of active `where` filters to scope synchronization
+
+`createOfflineModel` auto-registers pub/sub handlers for the service named `modelName`:
+- `createWithMeta` / `updateWithMeta` / `deleteWithMeta` — keep the local cache in sync with server-pushed events
+
+**Optimistic writes**: `create`, `update`, `remove` write to IndexedDB immediately, then call the server service method. On server error they roll back the local change.
+
+**Sync on reconnect**: When the socket reconnects, every registered model calls `synchronizeAll`, which iterates its `whereList` and calls the server's `sync.go(modelName, where, cutoffDate, clientMetadataDict)` service. The response contains five buckets (`addClient`, `updateClient`, `deleteClient`, `addDatabase`, `updateDatabase`) that are applied in order.
+
+**Real-time observables**: `getObservable(where)` returns an RxJS `Observable` backed by Dexie's `liveQuery`. It also registers the `where` in `whereList` and triggers a sync if it is a new, unregistered filter. Vue component lifecycle cleanup is handled by `tryOnScopeDispose`.
+
+A shared `Mutex` serializes all sync and `whereList` mutations to avoid concurrent IndexedDB race conditions.
+
+### `where` filter syntax
+Used throughout for querying local cache and scoping server sync:
+- Equality: `{ field: value }`
+- Range: `{ field: { lt, lte, gt, gte } }` — `null`/`undefined` fields never satisfy range clauses (matches SQL NULL semantics)
+
+### Utilities
+- `Mutex` — exported; simple async mutex backed by a promise queue
+- `wherePredicate(where)` — (module-private) turns a `where` object into a filter function
+- `isSubset` / `isSubsetAmong` — (module-private) checks if a `where` is covered by an existing entry in `whereList` (avoids redundant syncs)
+- `stringifyWithSortedKeys` — (module-private) deterministic JSON stringify used as canonical `whereList` keys
+- `generateUID(length)` — (module-private) alphanumeric random string used to correlate request/response pairs
+
+## Notes
+- `uuidv7` is used for client-side record IDs (monotonically increasing, good for B-tree indexes).
+- The `prisma/` directory with a SQLite schema is an unrelated artifact and not part of the library.
+- All imported packages (`dexie`, `rxjs`, `uuid`, `@vueuse/core`) are consumed by the library but are not listed as `dependencies` — they are expected to be provided by the consuming application.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x-client",
-  "version": "3.0.3",
+  "version": "3.1.0",
   "type": "module",
   "description": "Client library for ExpressX framework",
   "main": "src/client.mts",

package/src/client.mts

@@ -13,7 +13,6 @@ import { useSessionStorage } from '@vueuse/core'
 export function createClient(socket, options={}) {
    if (options.debug === undefined) options.debug = false
 
-   const waitingPromisesByUid = {}
    const action2service2handlers = {}
    const type2appHandler = {}
    let connectListeners = []
@@ -49,36 +48,23 @@ export function createClient(socket, options={}) {
       connectListeners.push(func)
    }
    function removeConnectListener(func) {
-      connectListeners = connectListeners.filter(f !== func)
+      connectListeners = connectListeners.filter(f => f !== func)
    }
 
    function addDisconnectListener(func) {
       disconnectListeners.push(func)
    }
-   function removeDisonnectListener(func) {
-      disconnectListeners = disconnectListeners.filter(f !== func)
+   function removeDisconnectListener(func) {
+      disconnectListeners = disconnectListeners.filter(f => f !== func)
    }
 
    function addErrorListener(func) {
       errorListeners.push(func)
    }
    function removeErrorListener(func) {
-      errorListeners = errorListeners.filter(f !== func)
+      errorListeners = errorListeners.filter(f => f !== func)
    }
 
-   // on receiving response from service request
-   socket.on('client-response', ({ uid, error, result }) => {
-      if (options.debug) console.log('client-response', uid, error, result)
-      if (!waitingPromisesByUid[uid]) return // may not exist because a timeout removed it
-      const [resolve, reject] = waitingPromisesByUid[uid]
-      if (error) {
-         reject(error)
-      } else {
-         resolve(result)
-      }
-      delete waitingPromisesByUid[uid]
-   })
-
    // on receiving service events from pub/sub
    socket.on('service-event', ({ name, action, result }) => {
       if (options.debug) console.log('service-event', name, action, result)
@@ -89,28 +75,14 @@ export function createClient(socket, options={}) {
    })
    
    async function serviceMethodRequest(name, action, serviceOptions, ...args) {
-      // create a promise which will resolve or reject by an event 'client-response'
-      const uid = generateUID(20)
-      const promise = new Promise((resolve, reject) => {
-         waitingPromisesByUid[uid] = [resolve, reject]
-         // a timeout may also reject the promise
-         if (serviceOptions.timeout && !serviceOptions.volatile) {
-            setTimeout(() => {
-               delete waitingPromisesByUid[uid]
-               reject(`Error: timeout on service '${name}', action '${action}', args: ${JSON.stringify(args)}`)
-            }, serviceOptions.timeout)
-         }
-      })
-      // send request to server through websocket
-      if (options.debug) console.log('client-request', uid, name, action, args)
-      if (serviceOptions.volatile) {
-         // event is not sent if connection is not active
-         socket.volatile.emit('client-request', { uid, name, action, args, })
-      } else {
-         // event is buffered if connection is not active (default)
-         socket.emit('client-request', { uid, name, action, args, })
-      }
-      return promise
+      if (options.debug) console.log('client-request', name, action, args)
+      // use socket.io acknowledgment for request/response correlation
+      const emitter = serviceOptions.volatile
+         ? socket.volatile
+         : socket.timeout(serviceOptions.timeout || 20000)
+      const { error, result } = await emitter.emitWithAck('client-request', { name, action, args })
+      if (error) throw error
+      return result
    }
 
    function service(name, serviceOptions={}) {
@@ -136,13 +108,14 @@ export function createClient(socket, options={}) {
       return new Proxy(service, handler)
    }
 
+   //--------------------         APPLICATION-LEVEL EVENTS         --------------------
+
    // There is a need for application-wide events sent outside any service method call, for example when backend state changes
    // without front-end interactions
    socket.on('app-event', ({ type, value }) => {
       if (options.debug) console.log('app-event', type, value)
-      if (!type2appHandler[type]) type2appHandler[type] = {}
       const handler = type2appHandler[type]
-      if (handler) handler(value)
+      if (typeof handler === 'function') handler(value)
    })
 
    // add a handler for application-wide events
@@ -150,28 +123,17 @@ export function createClient(socket, options={}) {
       type2appHandler[type] = handler
    }
 
-   function connect() {
-      if (options.debug) console.log('connecting...')
-      socket.connect()
-   }
-
-   function disconnect() {
-      if (options.debug) console.log('disconnecting...')
-      socket.disconnect()
-   }
-
    const app = {
       configure,
       addConnectListener,
       removeConnectListener,
       addDisconnectListener,
-      removeDisonnectListener,
+      removeDisconnectListener,
       addErrorListener,
       removeErrorListener,
    
       service,
       on,
-      connect, disconnect,
    }
 
    return app
@@ -179,7 +141,7 @@ export function createClient(socket, options={}) {
 
 
 //////////////////////////       RELOAD PLUGIN       //////////////////////////
-// enrich `app` with listeners handling socket data transfer on page reload
+// Enrich `app` with listeners handling socket data transfer on page reload
 
 export async function reloadPlugin(app) {
 
@@ -188,19 +150,12 @@ export async function reloadPlugin(app) {
    app.addConnectListener(async (socket) => {
       const socketId = socket.id
       console.log('connect', socketId)
-      // handle reconnections & reloads
-      // look for a previously stored connection id
       const prevSocketId = cnxid.value
       if (prevSocketId) {
-         // it's a connection after a reload/refresh
-         // ask server to transfer all data from connection `prevSocketId` to connection `socketId`
          console.log('cnx-transfer', prevSocketId, 'to', socketId)
          await socket.emit('cnx-transfer', prevSocketId, socketId)
-         // update connection id
          cnxid.value = socketId
-
       } else {
-         // set connection id
          cnxid.value = socketId
       }
 
@@ -210,30 +165,23 @@ export async function reloadPlugin(app) {
 
       socket.on('cnx-transfer-error', async (fromSocketId, toSocketId) => {
          console.log('ERR ERR!!!', fromSocketId, toSocketId)
-         // appState.value.unrecoverableError = true
       })
    })
 }
 
 
 //////////////////////////       OFFLINE PLUGIN       //////////////////////////
-// enrich `app` with methods, attributes and listeners to handle offline-first database access
+// Enrich `app` with methods, attributes and listeners to handle offline-first crud database access
 
 export function offlinePlugin(app) {
 
+   const modelSyncFunctions = []
+
    function createOfflineModel(modelName, fields) {
 
       const dbName = modelName;
       const db = getOrCreateDB(dbName, fields);
 
-      db.open().then(() => {
-         // console.log('db ready', dbName, modelName)
-      });
-
-      db.values.hook("updating", (changes, primaryKey, previousValue) => {
-         // console.log("CHANGES", primaryKey, changes, previousValue);
-      });
-
       const reset = async () => {
          console.log('reset', modelName);
          await db.whereList.clear();
@@ -252,20 +200,30 @@ export function offlinePlugin(app) {
 
       app.service(modelName).on('updateWithMeta', async ([value, meta]) => {
          console.log(`${modelName} EVENT updateWithMeta`, value);
-         await db.values.put(value);
+         // value may be undefined when the server's UPDATE RETURNING yielded 0 rows
+         // (concurrent delete race: record was removed between the sync's findMany
+         // snapshot and the actual UPDATE).  Guard to avoid a TypeError crash that
+         // would prevent db.metadata.put(meta) from running.
+         if (value?.uid) await db.values.put(value);
          await db.metadata.put(meta);
       });
 
       app.service(modelName).on('deleteWithMeta', async ([value, meta]) => {
          console.log(`${modelName} EVENT deleteWithMeta`, value)
-         await db.values.delete(value.uid)
-         await db.metadata.put(meta)
+         // value may be undefined when the server's DELETE RETURNING yielded 0 rows
+         // (double-delete race).  Guard before accessing .uid.
+         if (value?.uid) await db.values.delete(value.uid)
+         // delete, not put: synchronize() step 2 also deletes idbMetadata for the same
+         // uid.  If the pub/sub handler fires AFTER step 2, put() would re-create the
+         // metadata row as a permanent orphan.  delete() is idempotent regardless of order.
+         await db.metadata.delete(meta.uid)
       });
 
 
       /////////////          CREATE/UPDATE/REMOVE          /////////////
 
       async function create(data) {
+         // in offline-first context, uid is created client-side, since server may not be accessible
          const uid = uuidv7()
          // optimistic update
          const now = new Date()
@@ -278,6 +236,7 @@ export function offlinePlugin(app) {
                console.log(`*** err sync ${modelName} create`, err)
                // rollback
                await db.values.delete(uid)
+               await db.metadata.delete(uid)
             })
          }
          return await db.values.get(uid)
@@ -298,8 +257,11 @@ export function offlinePlugin(app) {
                // rollback
                delete previousValue.uid
                await db.values.update(uid, previousValue)
-               delete previousMetadata.uid
-               await db.metadata.update(uid, previousMetadata)
+               // Only restore updated_at — the optimistic write only touched that field.
+               // Restoring the full previousMetadata snapshot would overwrite any
+               // deleted_at that remove() set while the socket round-trip was in flight,
+               // silently un-deleting the record.
+               await db.metadata.update(uid, { updated_at: previousMetadata.updated_at ?? null })
             })
          }
          return await db.values.get(uid)
@@ -337,7 +299,6 @@ export function offlinePlugin(app) {
 
       function getObservable(where = {}) {
          addSynchroWhere(where).then((isNew: boolean) => {
-            // console.log('getObservable addSynchroWhere', modelName, where, isNew);
             if (isNew && app.isConnected) {
                synchronize(modelName, db.values, db.metadata, where, app.disconnectedDate)
             }
@@ -378,6 +339,8 @@ export function offlinePlugin(app) {
          }
       })
 
+      modelSyncFunctions.push(synchronizeAll)
+
       return {
          db, reset,
          create, update, remove,
@@ -391,8 +354,11 @@ export function offlinePlugin(app) {
    app.addConnectListener(async (_socket) => {
       app.connectedDate = new Date()
       console.log('onConnect', app.connectedDate)
-      app.disconnectedDate = null
       app.isConnected = true
+      if (app.disconnectedDate) {
+         modelSyncFunctions.forEach(sync => sync())
+      }
+      app.disconnectedDate = null
    })
 
    app.addDisconnectListener(async (_socket) => {
@@ -410,7 +376,6 @@ export function offlinePlugin(app) {
       await mutex.acquire()
       console.log('synchronize', modelName, where)
 
-      let toAdd = []
       try {
          const requestPredicate = wherePredicate(where)
 
@@ -429,41 +394,51 @@ export function offlinePlugin(app) {
          }
 
          // call sync service on `where` perimeter
-         const syncResult = await app.service('sync').go(modelName, where, cutoffDate, clientMetadataDict)
-         toAdd = syncResult.toAdd
-         const { toUpdate, toDelete, addDatabase, updateDatabase } = syncResult
-         console.log('-> service.sync', modelName, where, toAdd, toUpdate, toDelete, addDatabase, updateDatabase)
+         const { addClient, updateClient, deleteClient, addDatabase, updateDatabase } =
+            await app.service('sync').go(modelName, where, cutoffDate, clientMetadataDict)
+         console.log('-> service.sync', modelName, where, addClient, updateClient, deleteClient, addDatabase, updateDatabase)
 
          // 1- add missing elements in indexedDB cache
-         // Use a single transaction for all adds to ensure atomicity
-         if (toAdd.length > 0) {
+         // Use a single transaction for all adds to ensure atomicity.
+         // put() instead of add() for metadata: a deleteWithMeta pub/sub event leaves
+         // an orphaned metadata row (value deleted, metadata kept with deleted_at).
+         // add() would throw a ConstraintError on that orphan; put() upserts safely.
+         if (addClient.length > 0) {
             await idbValues.db.transaction('rw', [idbValues, idbMetadata], async () => {
-               for (const [value, metaData] of toAdd) {
-                  await idbValues.add(value)
-                  await idbMetadata.add(metaData)
+               for (const [value, metaData] of addClient) {
+                  // put() instead of add(): if create() ran concurrently and added this
+                  // uid to Dexie between the idbValues.filter snapshot and this step,
+                  // add() would throw ConstraintError and abort the entire transaction,
+                  // silently dropping every other addClient record in the batch.
+                  await idbValues.put(value)
+                  await idbMetadata.put(metaData)
                }
             })
          }
          // 2- delete elements from indexedDB cache
-         for (const [uid, deleted_at] of toDelete) {
+         for (const [uid] of deleteClient) {
             await idbValues.delete(uid)
-            await idbMetadata.update(uid, { deleted_at })
+            await idbMetadata.delete(uid)
          }
-         // 3- update elements of cache
-         for (const elt of toUpdate) {
-            // get full value of element to update
-            const value = await app.service(modelName).findUnique({ where:{ uid: elt.uid }})
+         // 3- update elements of cache with server's newer version
+         for (const [elt, serverMeta] of updateClient) {
+            const value = { ...elt }
             delete value.uid
             delete value.__deleted__
             await idbValues.update(elt.uid, value)
-            const metadata = await idbMetadata.get(elt.uid)
-            await idbMetadata.update(elt.uid, { updated_at: metadata.updated_at })
+            await idbMetadata.update(elt.uid, { updated_at: serverMeta.updated_at })
          }
 
          // 4- create elements of `addDatabase` with full data from cache
          for (const elt of addDatabase) {
+            // elt.uid is undefined when the clientMetadataDict fallback {} was used
+            // (record exists in idbValues but metadata is missing).  Guard before the
+            // get() call: idbValues.get(undefined) itself throws before fullValue is
+            // assigned, so checking fullValue == null afterwards is too late.
+            if (elt.uid == null) continue
             const fullValue = await idbValues.get(elt.uid)
             const meta = await idbMetadata.get(elt.uid)
+            if (fullValue == null) continue  // record deleted concurrently
             delete fullValue.uid
             delete fullValue.__deleted__
             try {
@@ -478,19 +453,17 @@ export function offlinePlugin(app) {
 
          // 5- update elements of `updateDatabase` with full data from cache
          for (const elt of updateDatabase) {
+            if (elt.uid == null) continue
             const fullValue = await idbValues.get(elt.uid)
             const meta = await idbMetadata.get(elt.uid)
+            if (fullValue == null) continue  // record deleted concurrently
             delete fullValue.uid
             delete fullValue.__deleted__
             try {
                await app.service(modelName).updateWithMeta(elt.uid, fullValue, meta.updated_at)
             } catch(err) {
                console.log("*** err sync user updateDatabase", err)
-               // rollback
-               const previousDatabaseValue = await app.service(modelName).findUnique({ where:{ uid: elt.uid }})
-               const previousDatabaseMetadata = await app.service('metadata').findUnique({ where:{ uid: elt.uid }})
-               await idbValues.update(elt.uid, previousDatabaseValue)
-               await idbMetadata.update(elt.uid, previousDatabaseMetadata)
+               // Leave client's local version intact; it will be retried on the next sync.
             }
          }
       } catch(err) {
@@ -500,30 +473,20 @@ export function offlinePlugin(app) {
       }
    }
 
-   function wherePredicate(where) {
-      return (elt) => {
-         for (const [attr, value] of Object.entries(where)) {
-            const eltAttrValue = elt[attr]
-
-            if (typeof(value) === 'string' || typeof(value) === 'number') {
-               // 'attr = value' clause
-               if (eltAttrValue !== value) return false
-
-            } else if (typeof(value) === 'object') {
-               // 'attr = { lt/lte/gt/gte: value }' clause
-               if (value.lte) {
-                  if (eltAttrValue > value.lte) return false
-               } else if (value.lt) {
-                  if (eltAttrValue >= value.lt) return false
-               } else if (value.gte) {
-                  if (eltAttrValue < value.gte) return false
-               } else if (value.gt) {
-                  if (eltAttrValue <= value.gt) return false
-               }
-            }
-         }
-         return true
+   // Singleton map to reuse Dexie instances per database name
+   const dbInstances = new Map();
+
+   function getOrCreateDB(dbName: string, fields: string[]) {
+      if (!dbInstances.has(dbName)) {
+         const db = new Dexie(dbName);
+         db.version(1).stores({
+            whereList: "sortedjson",
+            values: ['uid', '__deleted__', ...fields].join(','),
+            metadata: "uid, created_at, updated_at, deleted_at",
+         });
+         dbInstances.set(dbName, db);
       }
+      return dbInstances.get(dbName);
    }
 
    async function getWhereList(whereDb) {
@@ -568,22 +531,6 @@ export function offlinePlugin(app) {
       }
    }
 
-   // Singleton map to reuse Dexie instances per database name
-   const dbInstances = new Map();
-
-   function getOrCreateDB(dbName: string, fields: string[]) {
-      if (!dbInstances.has(dbName)) {
-         const db = new Dexie(dbName);
-         db.version(1).stores({
-            whereList: "sortedjson",
-            values: ['uid', '__deleted__', ...fields].join(','),
-            metadata: "uid, created_at, updated_at, deleted_at",
-         });
-         dbInstances.set(dbName, db);
-      }
-      return dbInstances.get(dbName);
-   }
-
    // enrich `app` with new methods and attributes
    return Object.assign(app, {
       createOfflineModel,
@@ -593,17 +540,6 @@ export function offlinePlugin(app) {
 
 //////////////////////////       UTILITIES       //////////////////////////
 
-function generateUID(length) {
-   const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-   let uid = ''
-
-   for (let i = 0; i < length; i++) {
-     const randomIndex = Math.floor(Math.random() * characters.length)
-     uid += characters.charAt(randomIndex)
-   }
-   return uid
-}
-
 
 function stringifyWithSortedKeys(obj, space = null) {
    return JSON.stringify(obj, (key, value) => {
@@ -646,10 +582,49 @@ export class Mutex {
    }
 }
 
+function wherePredicate(where) {
+   return (elt) => {
+      for (const [attr, value] of Object.entries(where)) {
+         const eltAttrValue = elt[attr]
+
+         if (typeof(value) === 'string' || typeof(value) === 'number' || typeof(value) === 'boolean') {
+            // 'attr = value' clause
+            if (eltAttrValue !== value) return false
+
+         } else if (value === null) {
+            // 'attr = null' clause
+            if (eltAttrValue !== null) return false
+
+         } else if (typeof(value) === 'object') {
+            // 'attr = { lt/lte/gt/gte: value }' clause — all bounds apply.
+            // A missing (undefined) or null field never satisfies a range constraint,
+            // consistent with SQL NULL behaviour (NULL op anything = NULL = unknown).
+            // JS coerces null → 0 so range guards like `null > 10` silently pass;
+            // undefined coerces to NaN and all NaN comparisons return false — both
+            // must be excluded explicitly.
+            if (eltAttrValue === undefined || eltAttrValue === null) return false
+            if ('lte' in value && eltAttrValue > value.lte) return false
+            if ('lt'  in value && eltAttrValue >= value.lt)  return false
+            if ('gte' in value && eltAttrValue < value.gte)  return false
+            if ('gt'  in value && eltAttrValue <= value.gt)  return false
+         }
+      }
+      return true
+   }
+}
+
 function isSubset(subset, fullObject) {
-   // return Object.entries(subset).some(([key, value]) => fullObject[key] === value)
    for (const key in fullObject) {
-      if (fullObject[key] !== subset[key]) return false
+      const fVal = fullObject[key]
+      const sVal = subset[key]
+      // Primitive values: use reference/value equality (works for string, number, boolean).
+      // Object values (e.g. range operators { gte: 1 }): use structural equality via
+      // sorted JSON so that two freshly-created identical objects compare as equal.
+      if (typeof fVal === 'object' && fVal !== null) {
+         if (stringifyWithSortedKeys(fVal) !== stringifyWithSortedKeys(sVal)) return false
+      } else {
+         if (fVal !== sVal) return false
+      }
    }
    return true
 }
@@ -663,4 +638,3 @@ function isSubsetAmong(subset, fullObjectList) {
    return fullObjectList.some(fullObject => isSubset(subset, fullObject));
 }
 // console.log('isSubsetAmong({a: 1, b: 2}, [{c: 3}, {b: 2}])=true', isSubsetAmong({a: 1, b: 2}, [{c: 3}, {b: 2}]))
-

package/prisma/migrations/20230629052809_init/migration.sql

@@ -1,17 +0,0 @@
--- CreateTable
-CREATE TABLE "User" (
-    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    "name" TEXT NOT NULL,
-    "email" TEXT NOT NULL
-);
-
--- CreateTable
-CREATE TABLE "Post" (
-    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
-    "text" TEXT NOT NULL,
-    "authorId" INTEGER NOT NULL,
-    CONSTRAINT "Post_authorId_fkey" FOREIGN KEY ("authorId") REFERENCES "User" ("id") ON DELETE CASCADE ON UPDATE CASCADE
-);
-
--- CreateIndex
-CREATE UNIQUE INDEX "User_email_key" ON "User"("email");

package/prisma/migrations/migration_lock.toml

@@ -1,3 +0,0 @@
-# Please do not edit this file manually
-# It should be added in your version-control system (i.e. Git)
-provider = "sqlite"

package/prisma/schema.prisma

@@ -1,22 +0,0 @@
-generator client {
-   provider = "prisma-client-js"
-}
-
-model User {
-   id          Int       @default(autoincrement()) @id
-   name        String
-   email       String    @unique
-   posts       Post[]
-}
-
-model Post {
-   id          Int       @default(autoincrement()) @id
-   text        String
-   author      User      @relation(fields: [authorId], references: [id], onDelete: Cascade)
-   authorId    Int
-}
-
-datasource db {
-   provider = "sqlite"
-   url      = "file:./dev.db"
-}