@roc-db/in-memory 0.1.0-pre.2

package/dist/index.js

@@ -0,0 +1,213 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+
+// src/createInMemoryAdapter.ts
+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
+});
+
+// src/functions/begin.ts
+var begin = (request, engineOpts) => {
+  return {
+    ...engineOpts,
+    changeSet: request.changeSetRef ? {
+      entities: new Map([]),
+      mutations: new Map([])
+    } : null
+  };
+};
+// 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");
+    } else {
+      txn.engineOpts.changeSet.entities.set(ref, document);
+      return document;
+    }
+  } else {
+    txn.engineOpts.entities.set(ref, document);
+    return document;
+  }
+};
+// 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;
+  }
+};
+// src/functions/getChangeSetMutations.ts
+var getChangeSetMutations = (txn, changeSetRef) => {
+  if (!changeSetRef)
+    throw new Error("changeSetRef is required");
+  const res = [];
+  txn.engineOpts.mutations.forEach((mutation) => {
+    if (mutation.changeSetRef === changeSetRef) {
+      res.push(mutation);
+    }
+  });
+  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;
+  }
+};
+// 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)
+}) => {
+  return createAdapter({
+    name: "in-memory",
+    operations,
+    entities,
+    functions: exports_functions,
+    snowflake
+  }, {
+    entities: new Map,
+    mutations: new Map
+  });
+};
+export {
+  createInMemoryAdapter
+};

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, }: {
+    operations: Operations;
+    entities: Entities;
+    snowflake?: Snowflake;
+}) => Adapter;
+export {};

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

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

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

@@ -0,0 +1,24 @@
+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

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

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) => 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,11 @@
+export { begin } from "./begin";
+export { createEntity } from "./createEntity";
+export { deleteEntity } from "./deleteEntity";
+export { getChangeSetMutations } from "./getChangeSetMutations";
+export { findDebounceMutation } from "./findDebounceMutation";
+export { pageMutations } from "./pageMutations";
+export { patchEntity } from "./patchEntity";
+export { readEntity } from "./readEntity";
+export { readMutation } from "./readMutation";
+export { saveMutation } from "./saveMutation";
+export { updateEntity } from "./updateEntity";

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

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

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

@@ -0,0 +1,6 @@
+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/readEntity.d.ts

@@ -0,0 +1 @@
+export declare const readEntity: (txn: any, ref: any) => 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/functions/updateEntity.d.ts

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

@@ -0,0 +1,33 @@
+{
+    "name": "@roc-db/in-memory",
+    "version": "0.1.0-pre.2",
+    "type": "module",
+    "exports": {
+        ".": "./src/index.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.1.0-pre.1",
+        "roc-db": "0.1.0-pre.1",
+        "zod": "3.24.2"
+    },
+    "peerDependencies": {
+        "roc-db": "0.1.0-pre.1",
+        "zod": "3.24.2"
+    },
+    "keywords": [],
+    "author": "Eigil Sagafos",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/eigilsagafos/roc-db.git"
+    },
+    "license": "MIT"
+}