@pluv/persistence-cloudflare-transactional-storage 0.25.0

package/.eslintrc.js

@@ -0,0 +1,4 @@
+module.exports = {
+  root: true,
+  extends: ["pluv"],
+};

package/.turbo/turbo-build.log

@@ -0,0 +1,18 @@
+
+> @pluv/persistence-cloudflare-transactional-storage@0.25.0 build /home/runner/work/pluv/pluv/packages/persistence-cloudflare-transactional-storage
+> tsup src/index.ts --format esm,cjs --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.2.4
+CLI Target: es6
+ESM Build start
+CJS Build start
+ESM dist/index.mjs 3.57 KB
+ESM ⚡️ Build success in 44ms
+CJS dist/index.js 4.63 KB
+CJS ⚡️ Build success in 45ms
+DTS Build start
+DTS ⚡️ Build success in 2228ms
+DTS dist/index.d.mts 1.07 KB
+DTS dist/index.d.ts  1.07 KB

package/CHANGELOG.md

@@ -0,0 +1,15 @@
+# @pluv/persistence-cloudflare-transactional-storage
+
+## 0.25.0
+
+### Minor Changes
+
+- 9db06ba: Added new package.
+
+### Patch Changes
+
+- Updated dependencies [4e078ca]
+- Updated dependencies [f556d30]
+- Updated dependencies [9db06ba]
+  - @pluv/io@0.25.0
+  - @pluv/types@0.25.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Shoubhit Dash
+
+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,20 @@
+## `@pluv/persistence-cloudflare-transactional-storage`
+
+> Crdt storage persistence for [@pluv/io](https://www.npmjs.com/package/@pluv/io) rooms on Cloudflare Workers.
+
+**👉 See full documentation on [pluv.io](https://pluv.io/docs/introduction). 👈**
+
+This is a dependency of `@pluv/platform-cloudflare`. You probably don't mean to install this yourself.
+
+## Installation
+
+```bash
+# npm
+npm install @pluv/persistence-cloudflare-transactional-storage
+
+# yarn
+yarn add @pluv/persistence-cloudflare-transactional-storage
+
+# pnpm
+pnpm add @pluv/persistence-cloudflare-transactional-storage
+```

package/dist/index.d.mts

@@ -0,0 +1,23 @@
+import { AbstractPersistence } from '@pluv/io';
+import { JsonObject } from '@pluv/types';
+
+interface PersistenceCloudflareTransactionalStorageConfig {
+    state: DurableObjectState;
+}
+declare class PersistenceCloudflareTransactionalStorage extends AbstractPersistence {
+    private _state;
+    constructor(config: PersistenceCloudflareTransactionalStorageConfig);
+    addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void>;
+    deleteStorageState(room: string): Promise<void>;
+    deleteUser(room: string, connectionId: string): Promise<void>;
+    deleteUsers(room: string): Promise<void>;
+    getSize(room: string): Promise<number>;
+    getStorageState(room: string): Promise<string | null>;
+    getUser(room: string, connectionId: string): Promise<JsonObject | null>;
+    getUsers(room: string): Promise<readonly (JsonObject | null)[]>;
+    setStorageState(room: string, state: string): Promise<void>;
+    private _getStorageKey;
+    private _getUserKey;
+}
+
+export { PersistenceCloudflareTransactionalStorage, type PersistenceCloudflareTransactionalStorageConfig };

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+import { AbstractPersistence } from '@pluv/io';
+import { JsonObject } from '@pluv/types';
+
+interface PersistenceCloudflareTransactionalStorageConfig {
+    state: DurableObjectState;
+}
+declare class PersistenceCloudflareTransactionalStorage extends AbstractPersistence {
+    private _state;
+    constructor(config: PersistenceCloudflareTransactionalStorageConfig);
+    addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void>;
+    deleteStorageState(room: string): Promise<void>;
+    deleteUser(room: string, connectionId: string): Promise<void>;
+    deleteUsers(room: string): Promise<void>;
+    getSize(room: string): Promise<number>;
+    getStorageState(room: string): Promise<string | null>;
+    getUser(room: string, connectionId: string): Promise<JsonObject | null>;
+    getUsers(room: string): Promise<readonly (JsonObject | null)[]>;
+    setStorageState(room: string, state: string): Promise<void>;
+    private _getStorageKey;
+    private _getUserKey;
+}
+
+export { PersistenceCloudflareTransactionalStorage, type PersistenceCloudflareTransactionalStorageConfig };

package/dist/index.js

@@ -0,0 +1,143 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  PersistenceCloudflareTransactionalStorage: () => PersistenceCloudflareTransactionalStorage
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/PersistenceCloudflareTransactionalStorage.ts
+var import_io = require("@pluv/io");
+
+// src/utils/partitionByLength.ts
+var partitionByLength = (arr, length) => {
+  if (!arr.length) return [];
+  const head = arr.slice(0, length);
+  const tail = arr.slice(length);
+  return [head, ...partitionByLength(tail, length)];
+};
+
+// src/PersistenceCloudflareTransactionalStorage.ts
+var CLOUDFLARE_DELETE_BATCH_LIMIT = 128;
+var STORAGE_PREFIX = "$PLUV_STORAGE;";
+var USER_PREFIX = "$PLUV_USER";
+var PersistenceCloudflareTransactionalStorage = class extends import_io.AbstractPersistence {
+  constructor(config) {
+    super();
+    const { state } = config;
+    this._state = state;
+  }
+  addUser(room, connectionId, user) {
+    return __async(this, null, function* () {
+      yield this._state.storage.put(this._getUserKey(room, connectionId), user);
+    });
+  }
+  deleteStorageState(room) {
+    return __async(this, null, function* () {
+      yield this._state.storage.delete(this._getStorageKey(room));
+    });
+  }
+  deleteUser(room, connectionId) {
+    return __async(this, null, function* () {
+      yield this._state.storage.delete(this._getUserKey(room, connectionId));
+    });
+  }
+  deleteUsers(room) {
+    return __async(this, null, function* () {
+      const map = yield this._state.storage.list({
+        allowConcurrency: true,
+        noCache: true,
+        prefix: USER_PREFIX
+      });
+      const partitions = partitionByLength(Array.from(map.keys()), CLOUDFLARE_DELETE_BATCH_LIMIT);
+      yield this._state.storage.transaction((tx) => __async(this, null, function* () {
+        yield partitions.reduce((promise, partition) => __async(this, null, function* () {
+          return yield promise.then(() => __async(this, null, function* () {
+            yield tx.delete(partition);
+          }));
+        }), Promise.resolve());
+      }));
+    });
+  }
+  getSize(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.list({ prefix: USER_PREFIX });
+      return storage.size;
+    });
+  }
+  getStorageState(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.get(this._getStorageKey(room));
+      return storage != null ? storage : null;
+    });
+  }
+  getUser(room, connectionId) {
+    return __async(this, null, function* () {
+      const user = yield this._state.storage.get(this._getUserKey(room, connectionId));
+      return user != null ? user : null;
+    });
+  }
+  getUsers(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.list({
+        prefix: USER_PREFIX
+      });
+      return Array.from(storage.values());
+    });
+  }
+  setStorageState(room, state) {
+    return __async(this, null, function* () {
+      yield this._state.storage.put(this._getStorageKey(room), state, {
+        allowConcurrency: true
+      });
+    });
+  }
+  _getStorageKey(room) {
+    return `${STORAGE_PREFIX}::${room}`;
+  }
+  _getUserKey(room, connectionId) {
+    return `${USER_PREFIX}::${room}::${connectionId}`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PersistenceCloudflareTransactionalStorage
+});

package/dist/index.mjs

@@ -0,0 +1,117 @@
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/PersistenceCloudflareTransactionalStorage.ts
+import { AbstractPersistence } from "@pluv/io";
+
+// src/utils/partitionByLength.ts
+var partitionByLength = (arr, length) => {
+  if (!arr.length) return [];
+  const head = arr.slice(0, length);
+  const tail = arr.slice(length);
+  return [head, ...partitionByLength(tail, length)];
+};
+
+// src/PersistenceCloudflareTransactionalStorage.ts
+var CLOUDFLARE_DELETE_BATCH_LIMIT = 128;
+var STORAGE_PREFIX = "$PLUV_STORAGE;";
+var USER_PREFIX = "$PLUV_USER";
+var PersistenceCloudflareTransactionalStorage = class extends AbstractPersistence {
+  constructor(config) {
+    super();
+    const { state } = config;
+    this._state = state;
+  }
+  addUser(room, connectionId, user) {
+    return __async(this, null, function* () {
+      yield this._state.storage.put(this._getUserKey(room, connectionId), user);
+    });
+  }
+  deleteStorageState(room) {
+    return __async(this, null, function* () {
+      yield this._state.storage.delete(this._getStorageKey(room));
+    });
+  }
+  deleteUser(room, connectionId) {
+    return __async(this, null, function* () {
+      yield this._state.storage.delete(this._getUserKey(room, connectionId));
+    });
+  }
+  deleteUsers(room) {
+    return __async(this, null, function* () {
+      const map = yield this._state.storage.list({
+        allowConcurrency: true,
+        noCache: true,
+        prefix: USER_PREFIX
+      });
+      const partitions = partitionByLength(Array.from(map.keys()), CLOUDFLARE_DELETE_BATCH_LIMIT);
+      yield this._state.storage.transaction((tx) => __async(this, null, function* () {
+        yield partitions.reduce((promise, partition) => __async(this, null, function* () {
+          return yield promise.then(() => __async(this, null, function* () {
+            yield tx.delete(partition);
+          }));
+        }), Promise.resolve());
+      }));
+    });
+  }
+  getSize(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.list({ prefix: USER_PREFIX });
+      return storage.size;
+    });
+  }
+  getStorageState(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.get(this._getStorageKey(room));
+      return storage != null ? storage : null;
+    });
+  }
+  getUser(room, connectionId) {
+    return __async(this, null, function* () {
+      const user = yield this._state.storage.get(this._getUserKey(room, connectionId));
+      return user != null ? user : null;
+    });
+  }
+  getUsers(room) {
+    return __async(this, null, function* () {
+      const storage = yield this._state.storage.list({
+        prefix: USER_PREFIX
+      });
+      return Array.from(storage.values());
+    });
+  }
+  setStorageState(room, state) {
+    return __async(this, null, function* () {
+      yield this._state.storage.put(this._getStorageKey(room), state, {
+        allowConcurrency: true
+      });
+    });
+  }
+  _getStorageKey(room) {
+    return `${STORAGE_PREFIX}::${room}`;
+  }
+  _getUserKey(room, connectionId) {
+    return `${USER_PREFIX}::${room}::${connectionId}`;
+  }
+};
+export {
+  PersistenceCloudflareTransactionalStorage
+};

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@pluv/persistence-cloudflare-transactional-storage",
+  "version": "0.25.0",
+  "description": "@pluv/io crdt storage persistence for cloudflare via transactional storage",
+  "author": "leedavidcs",
+  "license": "MIT",
+  "homepage": "https://github.com/pluv-io/pluv",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pluv-io/pluv.git",
+    "directory": "packages/persistence-cloudflare-transactional-storage"
+  },
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@pluv/io": "^0.25.0",
+    "@pluv/types": "^0.25.0"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20240821.1",
+    "eslint": "^8.57.0",
+    "tsup": "^8.2.4",
+    "typescript": "^5.5.4",
+    "@pluv/tsconfig": "^0.25.0",
+    "eslint-config-pluv": "^0.25.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts",
+    "dev": "tsup src/index.ts --format esm,cjs --watch --dts",
+    "lint": "eslint src/**/*.ts* --fix",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist"
+  }
+}

package/src/PersistenceCloudflareTransactionalStorage.ts

@@ -0,0 +1,99 @@
+import { AbstractPersistence } from "@pluv/io";
+import type { JsonObject } from "@pluv/types";
+import { partitionByLength } from "./utils";
+
+/**
+ * !HACK
+ * @description The max amount of keys a Cloudflare transactional storage may delete at once
+ * @see https://developers.cloudflare.com/durable-objects/api/transactional-storage-api/#delete
+ * @date July 8, 2024
+ */
+const CLOUDFLARE_DELETE_BATCH_LIMIT = 128;
+const STORAGE_PREFIX = "$PLUV_STORAGE;";
+const USER_PREFIX = "$PLUV_USER";
+
+export interface PersistenceCloudflareTransactionalStorageConfig {
+    state: DurableObjectState;
+}
+
+export class PersistenceCloudflareTransactionalStorage extends AbstractPersistence {
+    private _state: DurableObjectState;
+
+    constructor(config: PersistenceCloudflareTransactionalStorageConfig) {
+        super();
+
+        const { state } = config;
+
+        this._state = state;
+    }
+
+    public async addUser(room: string, connectionId: string, user: JsonObject | null): Promise<void> {
+        await this._state.storage.put(this._getUserKey(room, connectionId), user);
+    }
+
+    public async deleteStorageState(room: string): Promise<void> {
+        await this._state.storage.delete(this._getStorageKey(room));
+    }
+
+    public async deleteUser(room: string, connectionId: string): Promise<void> {
+        await this._state.storage.delete(this._getUserKey(room, connectionId));
+    }
+
+    public async deleteUsers(room: string): Promise<void> {
+        const map = await this._state.storage.list({
+            allowConcurrency: true,
+            noCache: true,
+            prefix: USER_PREFIX,
+        });
+
+        const partitions = partitionByLength(Array.from(map.keys()), CLOUDFLARE_DELETE_BATCH_LIMIT);
+
+        await this._state.storage.transaction(async (tx) => {
+            await partitions.reduce(async (promise, partition) => {
+                return await promise.then(async () => {
+                    await tx.delete(partition as string[]);
+                });
+            }, Promise.resolve());
+        });
+    }
+
+    public async getSize(room: string): Promise<number> {
+        const storage = await this._state.storage.list({ prefix: USER_PREFIX });
+
+        return storage.size;
+    }
+
+    public async getStorageState(room: string): Promise<string | null> {
+        const storage = await this._state.storage.get<string>(this._getStorageKey(room));
+
+        return storage ?? null;
+    }
+
+    public async getUser(room: string, connectionId: string): Promise<JsonObject | null> {
+        const user = await this._state.storage.get<JsonObject | null>(this._getUserKey(room, connectionId));
+
+        return user ?? null;
+    }
+
+    public async getUsers(room: string): Promise<readonly (JsonObject | null)[]> {
+        const storage = await this._state.storage.list({
+            prefix: USER_PREFIX,
+        });
+
+        return Array.from(storage.values()) as (JsonObject | null)[];
+    }
+
+    public async setStorageState(room: string, state: string): Promise<void> {
+        await this._state.storage.put(this._getStorageKey(room), state, {
+            allowConcurrency: true,
+        });
+    }
+
+    private _getStorageKey(room: string): string {
+        return `${STORAGE_PREFIX}::${room}`;
+    }
+
+    private _getUserKey(room: string, connectionId: string): string {
+        return `${USER_PREFIX}::${room}::${connectionId}`;
+    }
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { PersistenceCloudflareTransactionalStorage } from "./PersistenceCloudflareTransactionalStorage";
+export type { PersistenceCloudflareTransactionalStorageConfig } from "./PersistenceCloudflareTransactionalStorage";

package/src/utils/index.ts

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

package/src/utils/partitionByLength.ts

@@ -0,0 +1,8 @@
+export const partitionByLength = <T>(arr: readonly T[] | T[], length: number): readonly (readonly T[])[] => {
+    if (!arr.length) return [];
+
+    const head = arr.slice(0, length);
+    const tail = arr.slice(length);
+
+    return [head, ...partitionByLength(tail, length)];
+};

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+	"extends": "@pluv/tsconfig/library.json",
+	"include": ["next-env.d.ts", "**/*.ts", "**/*.tsx"],
+	"exclude": ["node_modules"],
+	"compilerOptions": {
+		"types": ["@cloudflare/workers-types"]
+	}
+}