@roc-db/in-memory 0.2.0-pre.7 → 0.2.0-pre.71

package/dist/index.js

@@ -10,85 +10,157 @@ var __export = (target, all) => {
 };
 
 // src/createInMemoryAdapter.ts
-import { createAdapter, Snowflake } from "roc-db";
+import {
+  createAdapter,
+  Snowflake
+} from "roc-db";
 
 // src/functions/index.ts
 var exports_functions = {};
 __export(exports_functions, {
-  updateEntity: () => updateEntity,
   saveMutation: () => saveMutation,
+  refByUniqueField: () => refByUniqueField,
   readMutation: () => readMutation,
   readEntity: () => readEntity,
-  patchEntity: () => patchEntity,
   pageMutations: () => pageMutations,
+  pageEntitiesByIndex: () => pageEntitiesByIndex,
+  pageEntities: () => pageEntities,
   getChangeSetMutations: () => getChangeSetMutations,
   findDebounceMutation: () => findDebounceMutation,
-  deleteEntity: () => deleteEntity,
-  createEntity: () => createEntity,
-  begin: () => begin
+  commit: () => commit,
+  batchReadEntities: () => batchReadEntities
 });
 
-// src/functions/begin.ts
-var begin = (request, engineOpts, callback) => {
-  return callback({
-    ...engineOpts,
-    changeSet: request.changeSetRef ? {
-      entities: new Map([]),
-      mutations: new Map([])
-    } : null
-  });
+// src/functions/readEntity.ts
+var readEntity = (txn, ref) => txn.engineOpts.entities.get(ref);
+
+// src/functions/batchReadEntities.ts
+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);
+  return 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];
 };
-// src/functions/createEntity.ts
-import { entityFromRef } from "roc-db";
-var createEntity = (txn, ref, {
-  data = {},
-  indexedData = {},
-  children = {},
-  parents = {},
-  ancestors = {}
+var commit = (txn, mutation, {
+  created,
+  updated,
+  deleted
 }) => {
-  const entity = entityFromRef(ref);
-  const document = {
-    ref,
-    entity,
-    created: {
-      timestamp: txn.mutation.timestamp,
-      mutationRef: txn.mutation.ref
-    },
-    updated: {
-      timestamp: txn.mutation.timestamp,
-      mutationRef: txn.mutation.ref
-    },
-    data: {
-      ...data,
-      ...indexedData
-    },
-    children,
-    parents,
-    ancestors
-  };
-  if (txn.request.changeSetRef) {
-    if (txn.engineOpts.changeSet.entities.has(ref)) {
-      throw new Error("Entity already exists in changeSet");
+  const { mutations } = txn.engineOpts;
+  const currentMutation = mutations.get(txn.mutation.ref);
+  if (currentMutation) {
+    if (currentMutation && mutation.appliedAt === txn.timestamp) {
+      saveMutation(txn, mutation);
+    } else if (currentMutation && mutation.debounceCount > currentMutation.debounceCount) {
+      saveMutation(txn, mutation);
     } else {
-      txn.engineOpts.changeSet.entities.set(ref, document);
-      return document;
+      throw new Error("Mutation already exists");
     }
   } else {
-    txn.engineOpts.entities.set(ref, document);
-    return document;
+    saveMutation(txn, mutation);
   }
-};
-// src/functions/deleteEntity.ts
-import { DELETED_IN_CHANGE_SET_SYMBOL } from "roc-db";
-var deleteEntity = (txn, ref) => {
-  if (txn.request.changeSetRef) {
-    txn.engineOpts.changeSet.entities.set(ref, DELETED_IN_CHANGE_SET_SYMBOL);
-    return true;
-  } else {
-    txn.engineOpts.entities.delete(ref);
-    return true;
+  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 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);
+    }
   }
+  return mutation;
+};
+// src/functions/findDebounceMutation.ts
+var findDebounceMutation = (request, engine, now, mutationName) => {
+  const debounceTime = request.operation.debounce;
+  const thresholdTime = new Date(now - debounceTime * 1000).toISOString();
+  const res = engine.mutations.values().find((mutation) => {
+    if (mutation.operation.name === mutationName && mutation.timestamp > thresholdTime && mutation.payload.ref === request.payload.ref) {
+      return true;
+    }
+  });
+  return res;
 };
 // src/functions/getChangeSetMutations.ts
 var getChangeSetMutations = (txn, changeSetRef) => {
@@ -102,17 +174,33 @@ var getChangeSetMutations = (txn, changeSetRef) => {
   });
   return res;
 };
-// src/functions/findDebounceMutation.ts
-var findDebounceMutation = (request, engine, now) => {
-  const debounceTime = request.settings.debounce;
-  const mutationName = request.schema.shape.name.value;
-  const thresholdTime = new Date(now - debounceTime * 1000).toISOString();
-  const res = engine.mutations.values().find((mutation) => {
-    if (mutation.name === mutationName && mutation.timestamp > thresholdTime && mutation.payload.ref === request.payload.ref) {
-      return true;
+// src/functions/pageEntities.ts
+var pageEntities = (txn, args) => {
+  const { size, entities, childrenOf } = args;
+  const result = [];
+  for (const [, doc] of txn.engineOpts.entities) {
+    if (size && result.length >= size) {
+      break;
     }
-  });
-  return res;
+    if (entities && entities !== "*" && !entities.includes(doc.entity)) {
+      continue;
+    } else {
+      if (childrenOf && childrenOf.length > 0) {
+        if (!childrenOf.some((childRef) => doc.__.parentRefs.includes(childRef))) {
+          continue;
+        }
+      }
+      result.push(doc);
+    }
+  }
+  return result;
+};
+// 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, {
@@ -135,94 +223,39 @@ var pageMutations = (txn, {
   }
   return res;
 };
-// src/functions/patchEntity.ts
-import { deepPatch, NotFoundError } from "roc-db";
-
-// src/functions/readEntity.ts
-import { DELETED_IN_CHANGE_SET_SYMBOL as DELETED_IN_CHANGE_SET_SYMBOL2 } from "roc-db";
-var readEntity = (txn, ref) => {
-  if (txn.request.changeSetRef) {
-    const doc = txn.engineOpts.changeSet.entities.get(ref);
-    if (doc === DELETED_IN_CHANGE_SET_SYMBOL2)
-      return;
-    if (doc)
-      return doc;
-  }
-  return txn.engineOpts.entities.get(ref);
-};
-
-// src/functions/patchEntity.ts
-var patchEntity = (txn, ref, { data = {}, children = {}, parents = {}, ancestors = {} }) => {
-  const existingDocument = readEntity(txn, ref);
-  if (!existingDocument)
-    throw new NotFoundError(ref);
-  const updatedDocument = {
-    ...existingDocument,
-    updated: {
-      timestamp: txn.mutation.timestamp,
-      mutationRef: txn.mutation.ref
-    },
-    data: deepPatch(existingDocument.data, data),
-    children: deepPatch(existingDocument.children, children),
-    parents: deepPatch(existingDocument.parents, parents),
-    ancestors: deepPatch(existingDocument.ancestors, ancestors)
-  };
-  if (txn.request.changeSetRef) {
-    txn.engineOpts.changeSet.entities.set(ref, updatedDocument);
-    return updatedDocument;
-  } else {
-    txn.engineOpts.entities.set(ref, updatedDocument);
-    return updatedDocument;
-  }
-};
 // src/functions/readMutation.ts
 var readMutation = (engineOpts, ref) => {
   return engineOpts.mutations.get(ref);
 };
-// src/functions/saveMutation.ts
-var saveMutation = (txn, finalizedMutation) => {
-  txn.engineOpts.mutations.set(finalizedMutation.ref, finalizedMutation);
-  return finalizedMutation;
-};
-// src/functions/updateEntity.ts
-import { NotFoundError as NotFoundError2 } from "roc-db";
-var updateEntity = (txn, ref, { data = {}, children = {}, parents = {}, ancestors = {} }) => {
-  const currentEntity = readEntity(txn, ref);
-  if (!currentEntity)
-    throw new NotFoundError2(ref);
-  const document = {
-    ...currentEntity,
-    updated: {
-      mutationRef: txn.mutation.ref,
-      timestamp: txn.mutation.timestamp
-    },
-    data,
-    children,
-    parents,
-    ancestors
-  };
-  if (txn.request.changeSetRef) {
-    throw new Error("TODO support changeSetRef");
-  } else {
-    txn.engineOpts.entities.set(ref, document);
-    return document;
+// 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,
   entities,
-  snowflake = new Snowflake(1, 1)
+  snowflake = new Snowflake(1, 1),
+  optimistic = true,
+  session
 }) => {
   return createAdapter({
     name: "in-memory",
     operations,
     entities,
     functions: exports_functions,
-    snowflake
+    snowflake,
+    optimistic,
+    session
   }, {
     entities: new Map,
-    mutations: new Map
+    mutations: new Map,
+    entitiesUnique: new Map,
+    entitiesIndex: new Map
   });
 };
 export {

package/dist/types/createInMemoryAdapter.d.ts

@@ -1,11 +1,13 @@
-import { Snowflake, type Adapter, type Operation } from "roc-db";
+import { Snowflake, type Adapter, type Operation, type Session } from "roc-db";
 import type { z } from "zod";
 type Entity = z.ZodObject<{
     entity: z.ZodLiteral<string>;
 }>;
-export declare const createInMemoryAdapter: <const Name extends string, const Operations extends readonly Operation[], const Entities extends readonly Entity[]>({ operations, entities, snowflake, }: {
+export declare const createInMemoryAdapter: <const Name extends string, const Operations extends readonly Operation[], const Entities extends readonly Entity[]>({ operations, entities, snowflake, optimistic, session, }: {
     operations: Operations;
     entities: Entities;
     snowflake?: Snowflake;
+    optimistic?: boolean;
+    session: Session;
 }) => Adapter;
 export {};

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

@@ -0,0 +1,2 @@
+import type { Ref } from "roc-db";
+export declare const batchReadEntities: (txn: any, refs: Ref[]) => any[];

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

@@ -0,0 +1,6 @@
+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[];
+    deleted: Ref[];
+}) => Mutation;

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

@@ -1,3 +1,3 @@
-import type { WriteOperation } from "roc-db";
+import type { WriteRequest } from "roc-db";
 import type { InMemoryEngine } from "../types/InMemoryEngine";
-export declare const findDebounceMutation: (request: WriteOperation, engine: InMemoryEngine, now: any) => import("roc-db").Mutation | undefined;
+export declare const findDebounceMutation: (request: WriteRequest, engine: InMemoryEngine, now: number, mutationName: string) => import("roc-db").Mutation | undefined;

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

@@ -1,11 +1,11 @@
-export { begin } from "./begin";
-export { createEntity } from "./createEntity";
-export { deleteEntity } from "./deleteEntity";
-export { getChangeSetMutations } from "./getChangeSetMutations";
+export { batchReadEntities } from "./batchReadEntities";
+export { commit } from "./commit";
 export { findDebounceMutation } from "./findDebounceMutation";
+export { getChangeSetMutations } from "./getChangeSetMutations";
+export { pageEntities } from "./pageEntities";
+export { pageEntitiesByIndex } from "./pageEntitiesByIndex";
 export { pageMutations } from "./pageMutations";
-export { patchEntity } from "./patchEntity";
 export { readEntity } from "./readEntity";
 export { readMutation } from "./readMutation";
+export { refByUniqueField } from "./refByUniqueField";
 export { saveMutation } from "./saveMutation";
-export { updateEntity } from "./updateEntity";

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

@@ -0,0 +1 @@
+export declare const pageEntities: (txn: any, args: any) => any[];

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/pageMutations.d.ts

@@ -4,4 +4,4 @@ export declare const pageMutations: (txn: ReadTransaction<any, InMemoryEngine, a
     size?: number;
     skip?: number;
     changeSetRef?: string;
-}) => import("roc-db").Mutation[];
+}) => any[];

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

@@ -1 +1,2 @@
-export declare const readEntity: (txn: any, ref: any) => any;
+import type { Ref, Transaction } from "roc-db";
+export declare const readEntity: (txn: Transaction, ref: Ref) => 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.7",
+    "version": "0.2.0-pre.71",
     "type": "module",
     "exports": {
         ".": {
@@ -13,8 +13,8 @@
     ],
     "sideEffects": false,
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.7",
-        "zod": "3.24.2"
+        "roc-db": "0.2.0-pre.71",
+        "zod": "^3.0.0"
     },
     "keywords": [],
     "author": "Eigil Sagafos",

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

@@ -1 +0,0 @@
-export declare const begin: (request: any, engineOpts: any, callback: any) => any;

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

@@ -1,24 +0,0 @@
-import { type Ref } from "roc-db";
-import type { InMemoryWriteTransaction } from "../types/InMemoryWriteTransaction";
-export declare const createEntity: (txn: InMemoryWriteTransaction, ref: Ref, { data, indexedData, children, parents, ancestors, }: {
-    data?: {} | undefined;
-    indexedData?: {} | undefined;
-    children?: {} | undefined;
-    parents?: {} | undefined;
-    ancestors?: {} | undefined;
-}) => {
-    ref: `${string}/${string}`;
-    entity: string;
-    created: {
-        timestamp: any;
-        mutationRef: any;
-    };
-    updated: {
-        timestamp: any;
-        mutationRef: any;
-    };
-    data: {};
-    children: {};
-    parents: {};
-    ancestors: {};
-};

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

@@ -1 +0,0 @@
-export declare const deleteEntity: (txn: any, ref: any) => boolean;

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

@@ -1,6 +0,0 @@
-export declare const patchEntity: (txn: any, ref: any, { data, children, parents, ancestors }: {
-    data?: {} | undefined;
-    children?: {} | undefined;
-    parents?: {} | undefined;
-    ancestors?: {} | undefined;
-}) => any;

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

@@ -1,6 +0,0 @@
-export declare const updateEntity: (txn: any, ref: any, { data, children, parents, ancestors }: {
-    data?: {} | undefined;
-    children?: {} | undefined;
-    parents?: {} | undefined;
-    ancestors?: {} | undefined;
-}) => any;