@wxn0brp/db-crdt 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 wxn0brP
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# @wxn0brp/db-crdt
+
+CRDT integration for @wxn0brp/db-core.
+
+This library provides a CRDT (Conflict-free Replicated Data Type) implementation on top of the `@wxn0brp/db-core` library. It allows you to have eventually consistent data in a distributed environment.
+
+## Installation
+
+```bash
+yarn add github:wxn0brP/ValtheraDB-crdt#dist
+```
+
+## Usage
+
+```typescript
+import { crdtValthera } from "@wxn0brp/db-crdt";
+import { Valthera } from "@wxn0brp/db";
+
+const db = crdtValthera(new Valthera("dir"));
+
+// All operations are now CRDT-enabled
+await db.add("my-collection", { name: "John Doe" });
+```
+
+## API
+
+### `crdtValthera(target: ValtheraCompatible): ValtheraCRDT`
+
+This is the main function that wraps a `@wxn0brp/db-core` compatible database instance and returns a `ValtheraCRDT` instance.
+
+### `ValtheraCRDT`
+
+The `ValtheraCRDT` interface extends the `ValtheraCompatible` interface and adds the following methods:
+
+- `rebuild(collection: string): Promise<void>`: Rebuilds a collection from its operation log.
+- `sync(other: ValtheraCRDT, collection: string, rebuild?: boolean): Promise<void>`: Syncs a collection from another `ValtheraCRDT` instance.
+- `makeSnapshot(collection: string): Promise<void>`: Creates a snapshot of a collection, effectively replacing the operation log with the current state of the data.
+
+### `reverseSync(my: ValtheraCRDT, other: ValtheraCRDT, collection: string)`
+
+Sync a collection from `my` to `other`.
+
+## License
+
+This project is licensed under the MIT License.

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { ValtheraCompatible } from "@wxn0brp/db-core";
+import { ValtheraCRDT } from "./types.js";
+export declare function createCrdtValthera(target: ValtheraCompatible): ValtheraCRDT;
+/**
+ * Sync a collection from my to other.
+ * @param my The target database that should be synced.
+ * @param other The source database that should be synced from.
+ * @param collection The collection to sync.
+ */
+export declare function reverseSync(my: ValtheraCRDT, other: ValtheraCRDT, collection: string): Promise<void>;

package/dist/index.js

@@ -0,0 +1,70 @@
+import { rebuild } from "./rebuild.js";
+import { makeSnapshot } from "./snapshot.js";
+import { collectionPrefix } from "./static.js";
+import { sync } from "./sync.js";
+import { VEE } from "@wxn0brp/event-emitter";
+const proxyList = [
+    "add",
+    "update",
+    "updateOne",
+    "updateOneOrAdd",
+    "remove",
+    "removeOne",
+    "toggleOne"
+];
+async function processOperation(target, op, result, args) {
+    const collection = collectionPrefix + "/" + args[0];
+    const opLow = op.toLowerCase();
+    let res = null;
+    if (opLow === "add") {
+        res = await target._target().add(collection, { a: result }, true);
+    }
+    else if (!opLow.includes("find") && !opLow.includes("collection")) {
+        res = await target._target().add(collection, { d: args.slice(1), op }, true);
+    }
+    return res?._id || null;
+}
+export function createCrdtValthera(target) {
+    const proxy = new Proxy(target, {
+        get(target, prop, receiver) {
+            const original = Reflect.get(target, prop, receiver);
+            if (proxyList.includes(prop) && typeof original === "function") {
+                return async function (...args) {
+                    const result = await original.apply(target, args);
+                    const opId = await processOperation(proxy, prop, result, args);
+                    if ("emiter" in target && opId) {
+                        const emiter = target.emiter;
+                        if (emiter instanceof VEE) {
+                            emiter.emit("crdt", opId);
+                        }
+                    }
+                    return result;
+                };
+            }
+            return original;
+        },
+        set(target, prop, value, receiver) {
+            return Reflect.set(target, prop, value, receiver);
+        }
+    });
+    proxy.rebuild = async (collection) => {
+        return await rebuild(proxy, collection);
+    };
+    proxy.sync = async (other, collection, rebuild = false) => {
+        return await sync(proxy, other, collection, rebuild);
+    };
+    proxy.makeSnapshot = async (collection) => {
+        return await makeSnapshot(proxy, collection);
+    };
+    proxy._target = () => target;
+    return proxy;
+}
+/**
+ * Sync a collection from my to other.
+ * @param my The target database that should be synced.
+ * @param other The source database that should be synced from.
+ * @param collection The collection to sync.
+ */
+export async function reverseSync(my, other, collection) {
+    return await sync(other, my, collection);
+}

package/dist/rebuild.d.ts

@@ -0,0 +1,2 @@
+import { ValtheraCRDT } from "./types.js";
+export declare function rebuild(db: ValtheraCRDT, collection: string): Promise<void>;

package/dist/rebuild.js

@@ -0,0 +1,15 @@
+import { sortByIds } from "@wxn0brp/db-core";
+import { collectionPrefix } from "./static.js";
+export async function rebuild(db, collection) {
+    const operations = await db.find(collectionPrefix + "/" + collection, {}).then(res => sortByIds(res));
+    await db.removeCollection(collection);
+    const _db = db._target();
+    for (const op of operations) {
+        if (op.a) {
+            await _db.add(collection, op.a, false);
+        }
+        else if (op.d) {
+            await _db[op.op](collection, ...op.d);
+        }
+    }
+}

package/dist/snapshot.d.ts

@@ -0,0 +1,2 @@
+import { ValtheraCRDT } from "./types.js";
+export declare function makeSnapshot(db: ValtheraCRDT, collection: string): Promise<void>;

package/dist/snapshot.js

@@ -0,0 +1,9 @@
+import { collectionPrefix } from "./static.js";
+export async function makeSnapshot(db, collection) {
+    const data = await db.find(collection, {});
+    await db.removeCollection(collectionPrefix + "/" + collection);
+    await db._target().updateOneOrAdd(collectionPrefix, { _id: collection }, { time: Date.now() });
+    for (const d of data) {
+        await db._target().add(collectionPrefix + "/" + collection, d, false);
+    }
+}

package/dist/static.d.ts

@@ -0,0 +1 @@
+export declare const collectionPrefix = "__vcrdt__";

package/dist/static.js

@@ -0,0 +1 @@
+export const collectionPrefix = "__vcrdt__";

package/dist/sync.d.ts

@@ -0,0 +1,2 @@
+import { ValtheraCRDT } from "./types.js";
+export declare function sync(my: ValtheraCRDT, other: ValtheraCRDT, collection: string, rebuild?: boolean): Promise<void>;

package/dist/sync.js

@@ -0,0 +1,17 @@
+import { collectionPrefix } from "./static.js";
+async function getIds(db, collection) {
+    const data = await db.find(collection, {}, {}, {}, { select: ["_id"] });
+    return data.map((d) => d._id);
+}
+export async function sync(my, other, collection, rebuild = false) {
+    const crdtCol = collectionPrefix + "/" + collection;
+    const myIds = await getIds(my, crdtCol);
+    const otherIds = await getIds(other, crdtCol);
+    const missing = otherIds.filter(id => !myIds.includes(id));
+    const getData = await other.find(crdtCol, { $in: { _id: missing } });
+    for (const data of getData) {
+        await my._target().add(crdtCol, data, false);
+    }
+    if (rebuild)
+        await my.rebuild(collection);
+}

package/dist/types.d.ts

@@ -0,0 +1,7 @@
+import { ValtheraCompatible } from "@wxn0brp/db-core";
+export interface ValtheraCRDT extends ValtheraCompatible {
+    _target: () => ValtheraCompatible;
+    rebuild: (collection: string) => Promise<void>;
+    sync: (other: ValtheraCRDT, collection: string, rebuild?: boolean) => Promise<void>;
+    makeSnapshot: (collection: string) => Promise<void>;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,42 @@
+{
+    "name": "@wxn0brp/db-crdt",
+    "version": "0.0.1",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "description": "CRDT integration for ValtheraDB",
+    "author": "wxn0brP",
+    "license": "MIT",
+    "type": "module",
+    "homepage": "https://github.com/wxn0brP/ValtheraDB-crdt",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/wxn0brP/ValtheraDB-crdt.git"
+    },
+    "scripts": {
+        "build": "tsc && tsc-alias"
+    },
+    "devDependencies": {
+        "@types/node": "*",
+        "@wxn0brp/db": "^0.41.0",
+        "tsc-alias": "*",
+        "typescript": "*"
+    },
+    "peerDependencies": {
+        "@wxn0brp/db-core": ">=0.3.0"
+    },
+    "files": [
+        "dist"
+    ],
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "default": "./dist/index.js",
+            "import": "./dist/index.js"
+        },
+        "./*": {
+            "types": "./dist/*.d.ts",
+            "default": "./dist/*.js",
+            "import": "./dist/*.js"
+        }
+    }
+}