@roc-db/in-memory 0.2.0-pre.1 → 0.2.0-pre.100

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) => {
-  return {
-    ...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/createEntity.ts
-import { entityFromRef } from "roc-db";
-var createEntity = (txn, ref, {
-  data = {},
-  indexedData = {},
-  children = {},
-  parents = {},
-  ancestors = {}
-}) => {
-  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");
+// 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];
+};
+var commit = (txn, mutation, { created, updated, deleted }) => {
+  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 (txn.adapter.models?.[doc.entity]?.singleton && txn.engineOpts.entities.has(doc.ref)) {
+      throw createUniqueConstraintConflictError(doc.entity);
+    }
+    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, identityRef) => {
+  const debounceTime = request.operation.debounce;
+  const thresholdTime = new Date(now.getTime() - debounceTime * 1000).toISOString();
+  const payloadRef = request.payload?.ref;
+  const res = engine.mutations.values().find((mutation) => {
+    if (mutation.operation.name === mutationName && mutation.timestamp > thresholdTime && mutation.payload?.ref === payloadRef && (mutation.changeSetRef ?? null) === (request.changeSetRef ?? null) && mutation.identityRef === identityRef) {
+      return true;
+    }
+  });
+  return res;
 };
 // src/functions/getChangeSetMutations.ts
 var getChangeSetMutations = (txn, changeSetRef) => {
@@ -102,110 +174,85 @@ 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;
+    }
+    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 res;
-};
-// src/functions/pageMutations.ts
-var pageMutations = (txn, { size = 30, skip = 0 } = {}) => {
-  return txn.engineOpts.mutations.values().drop(skip).take(size).toArray();
-};
-// 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);
+  return result;
 };
-
-// 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/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, skip = 0, changeSetRef } = {}) => {
+  const res = [];
+  const iterator = txn.engineOpts.mutations.values().drop(skip);
+  let next = iterator.next();
+  while (!next.done && res.length < size) {
+    if (changeSetRef) {
+      if (next.value.changeSetRef === changeSetRef) {
+        res.push(next.value);
+      }
+    } else {
+      res.push(next.value);
+    }
+    next = iterator.next();
   }
+  return res;
 };
 // 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,
+  engine
 }) => {
   return createAdapter({
     name: "in-memory",
     operations,
     entities,
     functions: exports_functions,
-    snowflake
-  }, {
+    snowflake,
+    optimistic,
+    session
+  }, engine ?? {
     entities: new Map,
-    mutations: new Map
+    mutations: new Map,
+    entitiesUnique: new Map,
+    entitiesIndex: new Map
   });
 };
 export {

package/dist/types/createInMemoryAdapter.d.ts

@@ -0,0 +1,14 @@
+import { Snowflake, type Adapter, type Entity, type Operation, type Session } from "roc-db";
+export declare const createInMemoryAdapter: <const Name extends string, const Operations extends readonly Operation[], const Entities extends readonly Entity<any>[]>({ operations, entities, snowflake, optimistic, session, engine, }: {
+    operations: Operations;
+    entities: Entities;
+    snowflake?: Snowflake;
+    optimistic?: boolean;
+    session: Session;
+    engine?: {
+        entities: Map<string, any>;
+        mutations: Map<string, any>;
+        entitiesUnique: Map<string, any>;
+        entitiesIndex: Map<string, any>;
+    };
+}) => Adapter;

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

@@ -0,0 +1,3 @@
+import type { Ref, Transaction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const batchReadEntities: (txn: Transaction<InMemoryEngine>, refs: Ref[]) => any[];

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

@@ -0,0 +1,3 @@
+import { type CommitFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const commit: CommitFunction<InMemoryEngine>;

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

@@ -0,0 +1,3 @@
+import type { FindDebounceMutationFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const findDebounceMutation: FindDebounceMutationFunction<InMemoryEngine>;

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

@@ -0,0 +1,3 @@
+import type { GetChangeSetMutationsFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const getChangeSetMutations: GetChangeSetMutationsFunction<InMemoryEngine>;

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

@@ -0,0 +1,11 @@
+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 { readEntity } from "./readEntity";
+export { readMutation } from "./readMutation";
+export { refByUniqueField } from "./refByUniqueField";
+export { saveMutation } from "./saveMutation";

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

@@ -0,0 +1,3 @@
+import type { PageEntitiesFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const pageEntities: PageEntitiesFunction<InMemoryEngine>;

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

@@ -0,0 +1,3 @@
+import type { PageEntitiesByIndexFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const pageEntitiesByIndex: PageEntitiesByIndexFunction<InMemoryEngine>;

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

@@ -0,0 +1,3 @@
+import type { PageMutationsFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const pageMutations: PageMutationsFunction<InMemoryEngine>;

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

@@ -0,0 +1,3 @@
+import type { ReadEntityFunctiun } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const readEntity: ReadEntityFunctiun<InMemoryEngine>;

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

@@ -0,0 +1,3 @@
+import type { ReadMutationFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const readMutation: ReadMutationFunction<InMemoryEngine>;

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

@@ -0,0 +1,3 @@
+import type { RefByUniqueFieldFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const refByUniqueField: RefByUniqueFieldFunction<InMemoryEngine>;

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

@@ -0,0 +1,3 @@
+import type { SaveMutationFunction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const saveMutation: SaveMutationFunction<InMemoryEngine>;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { createInMemoryAdapter } from "./createInMemoryAdapter";

package/dist/types/types/InMemoryEngine.d.ts

@@ -0,0 +1,7 @@
+import type { EntityDocument, Mutation, Ref } from "roc-db";
+export type InMemoryEngine = {
+    entities: Map<Ref, EntityDocument>;
+    mutations: Map<Ref, Mutation>;
+    entitiesUnique: Map<string, Ref>;
+    entitiesIndex: Map<string, Ref[]>;
+};

package/package.json

@@ -1,27 +1,20 @@
 {
     "name": "@roc-db/in-memory",
-    "version": "0.2.0-pre.1",
+    "version": "0.2.0-pre.100",
     "type": "module",
     "exports": {
-        ".": "./src/index.ts"
+        ".": {
+            "import": "./dist/index.js",
+            "types": "./dist/types/index.d.ts"
+        }
     },
     "files": [
         "dist"
     ],
     "sideEffects": false,
-    "scripts": {
-        "build": "NODE_ENV=production bun run scripts/build.ts",
-        "build:types": "rm -rf dist/types && bun run tsc --noCheck",
-        "test": "bun test"
-    },
-    "devDependencies": {
-        "@roc-db/test-utils": "0.2.0-pre.1",
-        "roc-db": "0.2.0-pre.1",
-        "zod": "3.24.2"
-    },
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.1",
-        "zod": "3.24.2"
+        "roc-db": ">=0.2.0-pre.98 <1.0.0",
+        "zod": ">=4.0.0"
     },
     "keywords": [],
     "author": "Eigil Sagafos",
@@ -29,5 +22,9 @@
         "type": "git",
         "url": "git+https://github.com/eigilsagafos/roc-db.git"
     },
-    "license": "MIT"
+    "license": "MIT",
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    }
 }