js-bao 0.2.9 → 0.2.11

package/dist/codegen.cjs

@@ -1007,7 +1007,7 @@ ${methods.map((method) => `    ${method}`).join("\n")}
 // package.json
 var package_default = {
   name: "js-bao",
-  version: "0.2.9",
+  version: "0.2.11",
   description: "A library providing data modeling capabilities which support live updates and queries.",
   types: "dist/index.d.ts",
   type: "module",
@@ -1067,7 +1067,7 @@ var package_default = {
   },
   dependencies: {
     "async-mutex": "^0.5.0",
-    "sql.js": "^1.13.0",
+    "sql.js": "~1.13.0",
     ulid: "^3.0.0"
   },
   devDependencies: {

package/dist/index.cjs

@@ -1310,7 +1310,7 @@ var init_BaseModel = __esm({
         Object.setPrototypeOf(this, _RecordNotFoundError.prototype);
       }
     };
-    SCHEMA_ACCESSORS_KEY = Symbol("jsBaoSchemaAccessors");
+    SCHEMA_ACCESSORS_KEY = /* @__PURE__ */ Symbol("jsBaoSchemaAccessors");
     BaseModel = class _BaseModel {
       static modelName;
       static listenersMap = /* @__PURE__ */ new Map();
@@ -2093,6 +2093,114 @@ var init_BaseModel = __esm({
         Logger.verbose(
           `[${this.name}] Setting up YMap observer for document ${docId}/${modelName}...`
         );
+        const buildUniqueKey = (recordData, fields) => {
+          const keyParts = [];
+          for (const field of fields) {
+            const value = recordData instanceof Y.Map ? recordData.get(field) : recordData[field];
+            if (value === null || value === void 0) {
+              return null;
+            }
+            keyParts.push(String(value));
+          }
+          return keyParts.join("|");
+        };
+        const extractItemData = (key, recordData) => {
+          let itemData;
+          if (recordData instanceof Y.Map) {
+            itemData = {};
+            const unknownFields = [];
+            for (const [fieldKey, value] of recordData.entries()) {
+              const fieldOptions = schema.fields.get(fieldKey);
+              if (!fieldOptions) {
+                unknownFields.push(fieldKey);
+                continue;
+              }
+              if (fieldOptions.type === "stringset") {
+                continue;
+              }
+              if (value !== void 0) {
+                itemData[fieldKey] = value;
+              }
+            }
+            if (unknownFields.length > 0) {
+              Logger.warn(
+                `[${this.name}] Ignoring unknown fields [${unknownFields.join(
+                  ", "
+                )}] when syncing record ${key} from document ${docId}`
+              );
+            }
+          } else {
+            const unknownFields = [];
+            const filteredData = {};
+            for (const [fieldKey, value] of Object.entries(recordData)) {
+              const fieldOptions = schema.fields.get(fieldKey);
+              if (!fieldOptions) {
+                unknownFields.push(fieldKey);
+                continue;
+              }
+              if (fieldOptions.type === "stringset") {
+                continue;
+              }
+              if (value !== void 0) {
+                filteredData[fieldKey] = value;
+              }
+            }
+            if (unknownFields.length > 0) {
+              Logger.warn(
+                `[${this.name}] Ignoring unknown fields [${unknownFields.join(
+                  ", "
+                )}] when syncing legacy record ${key} from document ${docId}`
+              );
+            }
+            itemData = filteredData;
+          }
+          if (!itemData.id) return null;
+          return itemData;
+        };
+        const resolveConflictsForBatch = (candidateRecords) => {
+          if (schema.resolvedUniqueConstraints.length === 0) {
+            return /* @__PURE__ */ new Set();
+          }
+          const recordIdsToDiscard = /* @__PURE__ */ new Set();
+          const recordIdsToKeep = /* @__PURE__ */ new Set();
+          const allRecords = /* @__PURE__ */ new Map();
+          for (const [recordId, recordData] of documentYMap.entries()) {
+            if (recordData && !candidateRecords.has(recordId)) {
+              allRecords.set(recordId, recordData);
+            }
+          }
+          for (const [recordId, recordData] of candidateRecords.entries()) {
+            allRecords.set(recordId, recordData);
+          }
+          for (const constraint of schema.resolvedUniqueConstraints) {
+            const recordsByUniqueKey = /* @__PURE__ */ new Map();
+            for (const [recordId, recordData] of allRecords.entries()) {
+              if (recordIdsToDiscard.has(recordId)) continue;
+              const uniqueKey = buildUniqueKey(recordData, constraint.fields);
+              if (uniqueKey === null) continue;
+              if (!recordsByUniqueKey.has(uniqueKey)) {
+                recordsByUniqueKey.set(uniqueKey, []);
+              }
+              recordsByUniqueKey.get(uniqueKey).push(recordId);
+            }
+            for (const [uniqueKey, recordIds] of recordsByUniqueKey.entries()) {
+              if (recordIds.length <= 1) continue;
+              Logger.warn(
+                `[${this.name}] CRDT conflict detected for unique constraint '${constraint.name}' on key '${uniqueKey.substring(0, 50)}${uniqueKey.length > 50 ? "..." : ""}': ${recordIds.length} records found.`
+              );
+              recordIds.sort();
+              const idToKeep = recordIds[recordIds.length - 1];
+              recordIdsToKeep.add(idToKeep);
+              for (let i = 0; i < recordIds.length - 1; i++) {
+                recordIdsToDiscard.add(recordIds[i]);
+              }
+            }
+          }
+          for (const idToKeep of recordIdsToKeep) {
+            recordIdsToDiscard.delete(idToKeep);
+          }
+          return recordIdsToDiscard;
+        };
         documentYMap.observe(async (event) => {
           Logger.verbose(
             `[${this.name}] Document YMap change detected for ${modelName}/${docId}:`,
@@ -2105,89 +2213,31 @@ var init_BaseModel = __esm({
             );
             return;
           }
+          const isRemoteChange = !event.transaction.local;
+          const remoteAdds = /* @__PURE__ */ new Map();
+          const localAddsAndUpdates = [];
           for (const [key, change] of event.changes.keys.entries()) {
             const recordData = documentYMap.get(key);
             if (change.action === "add" || change.action === "update") {
               if (!recordData || !key) continue;
-              let itemData;
-              if (recordData instanceof Y.Map) {
-                itemData = {};
-                const unknownFields = [];
-                for (const [fieldKey, value] of recordData.entries()) {
-                  const fieldOptions = schema.fields.get(fieldKey);
-                  if (!fieldOptions) {
-                    unknownFields.push(fieldKey);
-                    continue;
-                  }
-                  if (fieldOptions.type === "stringset") {
-                    continue;
-                  }
-                  if (value !== void 0) {
-                    itemData[fieldKey] = value;
-                  }
-                }
-                if (unknownFields.length > 0) {
-                  Logger.warn(
-                    `[${this.name}] Ignoring unknown fields [${unknownFields.join(
-                      ", "
-                    )}] when syncing record ${key} from document ${docId}`
-                  );
-                }
-                if (change.action === "add") {
-                  Logger.verbose(
-                    `[${this.name}] Setting up observer on newly added nested YMap for record ${key} in document ${docId}`
-                  );
-                  this.setupNestedYMapObserverForDocument(
-                    key,
-                    recordData,
-                    docId,
-                    permissionHint
-                  );
-                }
-              } else {
-                const unknownFields = [];
-                const filteredData = {};
-                for (const [fieldKey, value] of Object.entries(recordData)) {
-                  const fieldOptions = schema.fields.get(fieldKey);
-                  if (!fieldOptions) {
-                    unknownFields.push(fieldKey);
-                    continue;
-                  }
-                  if (fieldOptions.type === "stringset") {
-                    continue;
-                  }
-                  if (value !== void 0) {
-                    filteredData[fieldKey] = value;
-                  }
-                }
-                if (unknownFields.length > 0) {
-                  Logger.warn(
-                    `[${this.name}] Ignoring unknown fields [${unknownFields.join(
-                      ", "
-                    )}] when syncing legacy record ${key} from document ${docId}`
-                  );
-                }
-                itemData = filteredData;
-              }
-              if (!itemData.id) continue;
-              try {
+              const itemData = extractItemData(key, recordData);
+              if (!itemData) continue;
+              if (change.action === "add" && recordData instanceof Y.Map) {
                 Logger.verbose(
-                  `[${this.name}] Syncing item to db from document ${docId} (${modelName}):`,
-                  itemData
+                  `[${this.name}] Setting up observer on newly added nested YMap for record ${key} in document ${docId}`
                 );
-                await currentDbInstance.insert(modelName, {
-                  ...itemData,
-                  type: modelName,
-                  _meta_doc_id: docId,
-                  _meta_permission_hint: permissionHint
-                });
-              } catch (error) {
-                Logger.error(
-                  `[${this.name}] Error syncing item to db from document ${docId} (${modelName}):`,
-                  error,
-                  itemData
+                this.setupNestedYMapObserverForDocument(
+                  key,
+                  recordData,
+                  docId,
+                  permissionHint
                 );
               }
+              if (isRemoteChange && change.action === "add") {
+                remoteAdds.set(key, { recordData, itemData });
+              } else {
+                localAddsAndUpdates.push({ key, action: change.action, recordData, itemData });
+              }
             } else if (change.action === "delete") {
               Logger.verbose(
                 `[${this.name}] Deleting item from db (${modelName}/${docId}):`,
@@ -2204,6 +2254,110 @@ var init_BaseModel = __esm({
               }
             }
           }
+          for (const { itemData } of localAddsAndUpdates) {
+            try {
+              Logger.verbose(
+                `[${this.name}] Syncing local item to db from document ${docId} (${modelName}):`,
+                itemData
+              );
+              await currentDbInstance.insert(modelName, {
+                ...itemData,
+                type: modelName,
+                _meta_doc_id: docId,
+                _meta_permission_hint: permissionHint
+              });
+            } catch (error) {
+              Logger.error(
+                `[${this.name}] Error syncing local item to db from document ${docId} (${modelName}):`,
+                error,
+                itemData
+              );
+            }
+          }
+          if (remoteAdds.size > 0) {
+            Logger.verbose(
+              `[${this.name}] Processing ${remoteAdds.size} remote add(s) with conflict resolution for ${modelName}/${docId}`
+            );
+            const candidateRecords = /* @__PURE__ */ new Map();
+            for (const [key, { recordData }] of remoteAdds.entries()) {
+              candidateRecords.set(key, recordData);
+            }
+            const idsToDiscard = resolveConflictsForBatch(candidateRecords);
+            if (idsToDiscard.size > 0) {
+              Logger.info(
+                `[${this.name}] Discarding ${idsToDiscard.size} duplicate record(s) from remote sync for ${modelName}/${docId}: ${Array.from(idsToDiscard).join(", ")}`
+              );
+            }
+            for (const [key, { itemData }] of remoteAdds.entries()) {
+              if (idsToDiscard.has(key)) {
+                Logger.verbose(
+                  `[${this.name}] Skipping SQLite insert for discarded duplicate: ${key}`
+                );
+                continue;
+              }
+              try {
+                Logger.verbose(
+                  `[${this.name}] Syncing remote item to db from document ${docId} (${modelName}):`,
+                  itemData
+                );
+                await currentDbInstance.insert(modelName, {
+                  ...itemData,
+                  type: modelName,
+                  _meta_doc_id: docId,
+                  _meta_permission_hint: permissionHint
+                });
+              } catch (error) {
+                Logger.error(
+                  `[${this.name}] Error syncing remote item to db from document ${docId} (${modelName}):`,
+                  error,
+                  itemData
+                );
+              }
+            }
+            if (idsToDiscard.size > 0) {
+              yDoc.transact(() => {
+                for (const idToDiscard of idsToDiscard) {
+                  const recordData = documentYMap.get(idToDiscard);
+                  if (!recordData) continue;
+                  for (const constraint of schema.resolvedUniqueConstraints) {
+                    const uniqueKey = buildUniqueKey(recordData, constraint.fields);
+                    if (uniqueKey === null) continue;
+                    const constraintMapName = `_uniqueIdx_${modelName}_${constraint.name}`;
+                    const constraintMap = yDoc.getMap(constraintMapName);
+                    const currentIndexValue = constraintMap.get(uniqueKey);
+                    if (currentIndexValue === idToDiscard) {
+                      constraintMap.delete(uniqueKey);
+                      Logger.verbose(
+                        `[${this.name}] Removed discarded record ${idToDiscard} from unique index ${constraintMapName}`
+                      );
+                    }
+                  }
+                  documentYMap.delete(idToDiscard);
+                  Logger.verbose(
+                    `[${this.name}] Removed discarded record ${idToDiscard} from Y.Doc`
+                  );
+                }
+              }, `conflict-resolution-${modelName}-${docId}`);
+              yDoc.transact(() => {
+                for (const constraint of schema.resolvedUniqueConstraints) {
+                  const constraintMapName = `_uniqueIdx_${modelName}_${constraint.name}`;
+                  const constraintMap = yDoc.getMap(constraintMapName);
+                  for (const [recordId, recordData] of documentYMap.entries()) {
+                    if (!recordData) continue;
+                    const uniqueKey = buildUniqueKey(recordData, constraint.fields);
+                    if (uniqueKey === null) continue;
+                    const currentIndexValue = constraintMap.get(uniqueKey);
+                    if (currentIndexValue !== recordId) {
+                      constraintMap.set(uniqueKey, recordId);
+                      Logger.verbose(
+                        `[${this.name}] Updated unique index ${constraintMapName}['${uniqueKey.substring(0, 30)}...'] to point to ${recordId}`
+                      );
+                    }
+                  }
+                }
+              }, `update-indexes-${modelName}-${docId}`);
+            }
+          }
           Logger.verbose(
             `[${this.name}] Document YMap observation transaction for ${modelName}/${docId} completed.`
           );