@roc-db/in-memory 0.2.0-pre.51 → 0.2.0-pre.53

package/dist/index.js

@@ -19,9 +19,11 @@ import {
 var exports_functions = {};
 __export(exports_functions, {
   saveMutation: () => saveMutation,
+  refByUniqueField: () => refByUniqueField,
   readMutation: () => readMutation,
   readEntity: () => readEntity,
   pageMutations: () => pageMutations,
+  pageEntitiesByIndex: () => pageEntitiesByIndex,
   getChangeSetMutations: () => getChangeSetMutations,
   findDebounceMutation: () => findDebounceMutation,
   commit: () => commit,
@@ -35,6 +37,11 @@ var readEntity = (txn, ref) => txn.engineOpts.entities.get(ref);
 var batchReadEntities = (txn, refs) => {
   return refs.map((ref) => readEntity(txn, ref));
 };
+// src/functions/commit.ts
+import {
+  createUniqueConstraintConflictError
+} from "roc-db";
+
 // src/functions/saveMutation.ts
 var saveMutation = (txn, finalizedMutation) => {
   txn.engineOpts.mutations.set(finalizedMutation.ref, finalizedMutation);
@@ -42,6 +49,11 @@ var saveMutation = (txn, finalizedMutation) => {
 };
 
 // src/functions/commit.ts
+var findAddedAndRemovedEntries = (oldArr, newArr) => {
+  const removed = newArr?.filter(([k1, v1]) => !oldArr.some(([k2, v2]) => k1 === k2 && v1 === v2));
+  const added = oldArr?.filter(([k1, v1]) => !newArr.some(([k2, v2]) => k1 === k2 && v1 === v2));
+  return [added, removed];
+};
 var commit = (txn, mutation, {
   created,
   updated,
@@ -63,15 +75,76 @@ var commit = (txn, mutation, {
   if (txn.request.changeSetRef)
     return mutation;
   for (const doc of created) {
+    if (doc.__.unique?.length) {
+      doc.__.unique.forEach(([key, value]) => {
+        const uniqueKey = `${doc.entity}:${key}:${JSON.stringify(value)}`;
+        if (txn.engineOpts.entitiesUnique.has(uniqueKey))
+          throw createUniqueConstraintConflictError(doc.entity);
+        txn.engineOpts.entitiesUnique.set(uniqueKey, doc.ref);
+      });
+    }
+    if (doc.__.index?.length) {
+      doc.__.index.forEach(([key, value]) => {
+        const indexKey = `${doc.entity}:${key}:${JSON.stringify(value)}`;
+        const arr = txn.engineOpts.entitiesIndex.get(indexKey) ?? [];
+        txn.engineOpts.entitiesIndex.set(indexKey, [...arr, doc.ref]);
+      });
+    }
     txn.engineOpts.entities.set(doc.ref, doc);
   }
-  for (const doc of updated) {
-    txn.engineOpts.entities.set(doc.ref, doc);
+  for (const updatedDocument of updated) {
+    const existingDocument = txn.engineOpts.entities.get(updatedDocument.ref);
+    if (updatedDocument.__.unique?.length || existingDocument.__.unique?.length) {
+      const { ref, entity } = updatedDocument;
+      const [added, removed] = findAddedAndRemovedEntries(updatedDocument.__.unique, existingDocument.__.unique);
+      removed.forEach(([key, value]) => {
+        const uniqueKey = `${updatedDocument.entity}:${key}:${JSON.stringify(value)}`;
+        txn.engineOpts.entitiesUnique.delete(uniqueKey);
+      });
+      added.forEach(([key, value]) => {
+        const uniqueKey = `${updatedDocument.entity}:${key}:${JSON.stringify(value)}`;
+        if (txn.engineOpts.entitiesUnique.has(uniqueKey))
+          throw createUniqueConstraintConflictError(entity);
+        txn.engineOpts.entitiesUnique.set(uniqueKey, ref);
+      });
+    }
+    if (updatedDocument.__.index?.length || existingDocument.__.index?.length) {
+      const { ref, entity } = updatedDocument;
+      const [added, removed] = findAddedAndRemovedEntries(updatedDocument.__.index, existingDocument.__.index);
+      removed.forEach(([key, value]) => {
+        const indexKey = `${updatedDocument.entity}:${key}:${JSON.stringify(value)}`;
+        const arr = txn.engineOpts.entitiesIndex.get(indexKey);
+        txn.engineOpts.entitiesIndex.set(indexKey, arr.filter((ref2) => ref2 !== updatedDocument.ref));
+      });
+      added.forEach(([key, value]) => {
+        const indexKey = `${updatedDocument.entity}:${key}:${JSON.stringify(value)}`;
+        const arr = txn.engineOpts.entitiesIndex.get(indexKey) ?? [];
+        txn.engineOpts.entitiesIndex.set(indexKey, [
+          ...arr,
+          updatedDocument.ref
+        ]);
+      });
+    }
+    txn.engineOpts.entities.set(updatedDocument.ref, updatedDocument);
   }
   for (const ref of deleted) {
     if (ref.startsWith("Mutation/")) {
       txn.engineOpts.mutations.delete(ref);
     } else {
+      const existingDocument = txn.engineOpts.entities.get(ref);
+      if (existingDocument.__.unique?.length) {
+        existingDocument.__.unique.forEach(([key, value]) => {
+          const uniqueKey = `${existingDocument.entity}:${key}:${JSON.stringify(value)}`;
+          txn.engineOpts.entitiesUnique.delete(uniqueKey);
+        });
+      }
+      if (existingDocument.__.index?.length) {
+        existingDocument.__.index.forEach(([key, value]) => {
+          const indexKey = `${existingDocument.entity}:${key}:${JSON.stringify(value)}`;
+          const arr = txn.engineOpts.entitiesIndex.get(indexKey) ?? [];
+          txn.engineOpts.entitiesIndex.set(indexKey, arr.filter((ref2) => ref2 !== existingDocument.ref));
+        });
+      }
       txn.engineOpts.entities.delete(ref);
     }
   }
@@ -100,6 +173,13 @@ var getChangeSetMutations = (txn, changeSetRef) => {
   });
   return res;
 };
+// src/functions/pageEntitiesByIndex.ts
+var pageEntitiesByIndex = (txn, entity, field, value) => {
+  const { entitiesIndex } = txn.engineOpts;
+  const indexKey = `${entity}:${field}:${JSON.stringify(value)}`;
+  const refs = entitiesIndex.get(indexKey) ?? [];
+  return refs.map((ref) => txn.engineOpts.entities.get(ref));
+};
 // src/functions/pageMutations.ts
 var pageMutations = (txn, {
   size = 30,
@@ -125,6 +205,14 @@ var pageMutations = (txn, {
 var readMutation = (engineOpts, ref) => {
   return engineOpts.mutations.get(ref);
 };
+// src/functions/refByUniqueField.ts
+var refByUniqueField = (txn, entity, field, fieldIndex, value) => {
+  const key = `${entity}:${field}:${JSON.stringify(value)}`;
+  const { entitiesUnique } = txn.engineOpts;
+  if (entitiesUnique.has(key)) {
+    return entitiesUnique.get(key);
+  }
+};
 // src/createInMemoryAdapter.ts
 var createInMemoryAdapter = ({
   operations,
@@ -143,7 +231,9 @@ var createInMemoryAdapter = ({
     session
   }, {
     entities: new Map,
-    mutations: new Map
+    mutations: new Map,
+    entitiesUnique: new Map,
+    entitiesIndex: new Map
   });
 };
 export {

package/dist/types/functions/commit.d.ts

@@ -1,4 +1,4 @@
-import type { Entity, Mutation, Ref, WriteTransaction } from "roc-db";
+import { type Entity, type Mutation, type Ref, type WriteTransaction } from "roc-db";
 export declare const commit: (txn: WriteTransaction, mutation: Mutation, { created, updated, deleted, }: {
     created: Entity[];
     updated: Entity[];

package/dist/types/functions/index.d.ts

@@ -2,7 +2,9 @@ export { batchReadEntities } from "./batchReadEntities";
 export { commit } from "./commit";
 export { findDebounceMutation } from "./findDebounceMutation";
 export { getChangeSetMutations } from "./getChangeSetMutations";
+export { pageEntitiesByIndex } from "./pageEntitiesByIndex";
 export { pageMutations } from "./pageMutations";
 export { readEntity } from "./readEntity";
 export { readMutation } from "./readMutation";
+export { refByUniqueField } from "./refByUniqueField";
 export { saveMutation } from "./saveMutation";

package/dist/types/functions/pageEntitiesByIndex.d.ts

@@ -0,0 +1 @@
+export declare const pageEntitiesByIndex: (txn: any, entity: any, field: any, value: any) => any;

package/dist/types/functions/refByUniqueField.d.ts

@@ -0,0 +1 @@
+export declare const refByUniqueField: (txn: WriteTransaction, entity: string, field: string, fieldIndex: number, value: any) => any;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@roc-db/in-memory",
-    "version": "0.2.0-pre.51",
+    "version": "0.2.0-pre.53",
     "type": "module",
     "exports": {
         ".": {
@@ -13,7 +13,7 @@
     ],
     "sideEffects": false,
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.51",
+        "roc-db": "0.2.0-pre.53",
         "zod": "^3.0.0"
     },
     "keywords": [],