@roc-db/in-memory 0.2.0-pre.4 → 0.2.0-pre.40

package/dist/index.js

@@ -15,80 +15,67 @@ import { createAdapter, Snowflake } from "roc-db";
 // src/functions/index.ts
 var exports_functions = {};
 __export(exports_functions, {
-  updateEntity: () => updateEntity,
   saveMutation: () => saveMutation,
   readMutation: () => readMutation,
   readEntity: () => readEntity,
-  patchEntity: () => patchEntity,
   pageMutations: () => pageMutations,
   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/saveMutation.ts
+var saveMutation = (txn, finalizedMutation) => {
+  txn.engineOpts.mutations.set(finalizedMutation.ref, finalizedMutation);
+  return finalizedMutation;
+};
+
+// src/functions/commit.ts
+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 {
+  if (txn.request.changeSetRef)
+    return mutation;
+  for (const doc of created) {
+    txn.engineOpts.entities.set(doc.ref, doc);
+  }
+  for (const doc of updated) {
+    txn.engineOpts.entities.set(doc.ref, doc);
+  }
+  for (const ref of deleted) {
     txn.engineOpts.entities.delete(ref);
-    return true;
   }
+  return mutation;
+};
+// src/functions/findDebounceMutation.ts
+var findDebounceMutation = (request, engine, now, mutationName) => {
+  const debounceTime = request.settings.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,107 +89,47 @@ 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;
-    }
-  });
-  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);
-};
-
-// 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;
+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/createInMemoryAdapter.ts
 var createInMemoryAdapter = ({
   operations,
   entities,
-  snowflake = new Snowflake(1, 1)
+  snowflake = new Snowflake(1, 1),
+  session,
+  optimistic = true
 }) => {
   return createAdapter({
     name: "in-memory",
     operations,
     entities,
     functions: exports_functions,
-    snowflake
+    snowflake,
+    session,
+    optimistic
   }, {
     entities: new Map,
     mutations: new Map

package/dist/types/createInMemoryAdapter.d.ts

@@ -0,0 +1,11 @@
+import { Snowflake, type Adapter, type Operation } 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, session, optimistic, }: {
+    operations: Operations;
+    entities: Entities;
+    snowflake?: Snowflake;
+}) => 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,5 @@
+export declare const commit: (txn: any, mutation: any, { created, updated, deleted }: {
+    created: any;
+    updated: any;
+    deleted: any;
+}) => any;

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

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

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

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

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

@@ -0,0 +1,8 @@
+export { batchReadEntities } from "./batchReadEntities";
+export { commit } from "./commit";
+export { findDebounceMutation } from "./findDebounceMutation";
+export { getChangeSetMutations } from "./getChangeSetMutations";
+export { pageMutations } from "./pageMutations";
+export { readEntity } from "./readEntity";
+export { readMutation } from "./readMutation";
+export { saveMutation } from "./saveMutation";

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

@@ -0,0 +1,7 @@
+import type { ReadTransaction } from "roc-db";
+import type { InMemoryEngine } from "../types/InMemoryEngine";
+export declare const pageMutations: (txn: ReadTransaction<any, InMemoryEngine, any, any>, { size, skip, changeSetRef, }?: {
+    size?: number;
+    skip?: number;
+    changeSetRef?: string;
+}) => any[];

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

@@ -0,0 +1,2 @@
+import type { Ref, Transaction } from "roc-db";
+export declare const readEntity: (txn: Transaction, ref: Ref) => any;

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

@@ -0,0 +1 @@
+export declare const readMutation: (engineOpts: any, ref: any) => any;

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

@@ -0,0 +1,2 @@
+import type { InMemoryWriteTransaction } from "../types/InMemoryWriteTransaction";
+export declare const saveMutation: (txn: InMemoryWriteTransaction, finalizedMutation: any) => any;

package/dist/types/index.d.ts

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

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

@@ -0,0 +1,5 @@
+import type { Entity, Ref, Mutation } from "roc-db";
+export type InMemoryEngine = {
+    entities: Map<Ref, Entity>;
+    mutations: Map<Ref, Mutation>;
+};

package/dist/types/types/InMemoryWriteTransaction.d.ts

@@ -0,0 +1,3 @@
+import type { WriteTransaction } from "roc-db";
+import type { InMemoryEngine } from "./InMemoryEngine";
+export type InMemoryWriteTransaction = WriteTransaction<any, InMemoryEngine, any, any>;

package/package.json

@@ -1,27 +1,20 @@
 {
     "name": "@roc-db/in-memory",
-    "version": "0.2.0-pre.4",
+    "version": "0.2.0-pre.40",
     "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.4",
-        "roc-db": "0.2.0-pre.4",
-        "zod": "3.24.2"
-    },
     "peerDependencies": {
-        "roc-db": "0.2.0-pre.4",
-        "zod": "3.24.2"
+        "roc-db": "0.2.0-pre.40",
+        "zod": "^3.0.0"
     },
     "keywords": [],
     "author": "Eigil Sagafos",