@veryfront/ext-redis 0.1.1185

package/esm/redis-runtime-provider.js

@@ -0,0 +1,326 @@
+import * as NodeRedis from "redis";
+import { createRedisEventPublisher } from "./event-publisher.js";
+import { createRedisClientManager, openRedisClient, takeRedisClientSetupCleanupClient, } from "./redis-client-manager.js";
+const PROVIDER_ID = "redis@5.11.0";
+const NODE_CLIENT_METHODS = [
+    "connect",
+    "hSet",
+    "hGetAll",
+    "hDel",
+    "del",
+    "sAdd",
+    "sRem",
+    "sMembers",
+    "rPush",
+    "lRange",
+    "lIndex",
+    "lSet",
+    "lLen",
+    "xAdd",
+    "xGroupCreate",
+    "xReadGroup",
+    "xAck",
+    "keys",
+    "exists",
+    "expire",
+    "set",
+    "get",
+    "publish",
+    "subscribe",
+    "unsubscribe",
+    "eval",
+    "close",
+    "destroy",
+    "on",
+];
+const CLIENT_METHODS = [
+    "connect",
+    "disconnect",
+    "get",
+    "mGet",
+    "set",
+    "del",
+    "scan",
+    "expire",
+    "eval",
+    "incr",
+    "pExpire",
+    "pTTL",
+];
+const OPTIONAL_CLIENT_METHODS = ["ttl", "on"];
+function readOptionalClientMethod(target, name) {
+    let owner = target;
+    const visited = new Set();
+    while (owner) {
+        if (visited.has(owner))
+            return undefined;
+        visited.add(owner);
+        let descriptor;
+        try {
+            descriptor = Object.getOwnPropertyDescriptor(owner, name);
+        }
+        catch {
+            return undefined;
+        }
+        if (descriptor) {
+            return "value" in descriptor && typeof descriptor.value === "function"
+                ? descriptor.value
+                : undefined;
+        }
+        try {
+            owner = Object.getPrototypeOf(owner);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
+function bindClientMethods(target, methods, options = {}) {
+    const adapter = Object.fromEntries(methods.map((name) => [
+        name,
+        (...args) => {
+            const method = Reflect.get(target, name);
+            if (typeof method !== "function") {
+                throw new TypeError(`Redis client must expose ${name}`);
+            }
+            return Reflect.apply(method, target, args);
+        },
+    ]));
+    for (const name of options.optionalMethods ?? []) {
+        const method = readOptionalClientMethod(target, name);
+        if (!method)
+            continue;
+        Object.defineProperty(adapter, name, {
+            enumerable: true,
+            value: (...args) => Reflect.apply(method, target, args),
+        });
+    }
+    for (const property of options.properties ?? []) {
+        Object.defineProperty(adapter, property, {
+            enumerable: true,
+            get() {
+                return Reflect.get(target, property, target);
+            },
+        });
+    }
+    return Object.freeze(adapter);
+}
+/** Construct an isolated Redis runtime provider. */
+export function createRedisRuntimeProvider(dependencies = {}) {
+    const clientManagerDependencies = dependencies.clientManagerDependencies ?? {};
+    const clientManager = createRedisClientManager(clientManagerDependencies);
+    const publishers = new Set();
+    const clientHandles = new Set();
+    const failedSetupHandles = new Set();
+    const forcedHandleClosers = new WeakMap();
+    const openingAbortControllers = new Set();
+    const exposedClients = new WeakMap();
+    const connectClient = dependencies.openClient ??
+        ((options, lifecycle) => openRedisClient(options, clientManagerDependencies, lifecycle));
+    const moduleAdapter = Object.freeze({
+        createClient(options) {
+            requireOpen();
+            const client = NodeRedis.createClient(options);
+            return bindClientMethods(client, NODE_CLIENT_METHODS);
+        },
+    });
+    let state = "open";
+    let closePromise = null;
+    function requireOpen() {
+        if (state !== "open")
+            throw new Error(`Redis runtime provider is ${state}`);
+    }
+    function createPublisher(config) {
+        requireOpen();
+        const implementation = createRedisEventPublisher(config, {
+            createClient(url) {
+                return NodeRedis.createClient({ url });
+            },
+        });
+        const publisher = {
+            publish(event) {
+                return implementation.publish(event);
+            },
+            subscribe(runId, handler) {
+                return implementation.subscribe(runId, handler);
+            },
+            async close() {
+                await implementation.close();
+                publishers.delete(publisher);
+            },
+        };
+        publishers.add(publisher);
+        return publisher;
+    }
+    function createClientHandle(client) {
+        let closed = false;
+        let closePromise = null;
+        let exposedClient = exposedClients.get(client);
+        if (!exposedClient) {
+            exposedClient = bindClientMethods(client, CLIENT_METHODS, {
+                optionalMethods: OPTIONAL_CLIENT_METHODS,
+                properties: ["isOpen"],
+            });
+            exposedClients.set(client, exposedClient);
+        }
+        const closeClient = (force) => {
+            if (force) {
+                closed = false;
+                clientHandles.add(handle);
+            }
+            if (closed) {
+                closed = true;
+                clientHandles.delete(handle);
+                failedSetupHandles.delete(handle);
+                return Promise.resolve();
+            }
+            if (closePromise)
+                return closePromise;
+            const closing = Promise.resolve()
+                .then(() => client.isOpen === false ? undefined : client.disconnect())
+                .then(() => {
+                closed = true;
+                clientHandles.delete(handle);
+                failedSetupHandles.delete(handle);
+            });
+            const tracked = closing.finally(() => {
+                if (closePromise === tracked)
+                    closePromise = null;
+            });
+            closePromise = tracked;
+            return tracked;
+        };
+        const handle = {
+            client: exposedClient,
+            close() {
+                return closeClient(false);
+            },
+        };
+        forcedHandleClosers.set(handle, () => closeClient(true));
+        clientHandles.add(handle);
+        return handle;
+    }
+    async function drainFailedSetups() {
+        const results = await Promise.allSettled([...failedSetupHandles].map((handle) => handle.close()));
+        const failures = results
+            .filter((result) => result.status === "rejected")
+            .map((result) => result.reason);
+        if (failures.length === 1)
+            throw failures[0];
+        if (failures.length > 1) {
+            throw new AggregateError(failures, "Redis failed-client cleanup failed");
+        }
+    }
+    function openOwnedClient(options = {}, signal) {
+        requireOpen();
+        const abortController = new AbortController();
+        const abortFromCaller = () => abortController.abort(signal?.reason);
+        if (signal?.aborted)
+            abortFromCaller();
+        else
+            signal?.addEventListener("abort", abortFromCaller, { once: true });
+        openingAbortControllers.add(abortController);
+        let provisionalHandle;
+        const opening = (async () => {
+            await drainFailedSetups();
+            requireOpen();
+            let client;
+            try {
+                client = await connectClient(options, {
+                    signal: abortController.signal,
+                    onClientCreated(createdClient) {
+                        provisionalHandle = createClientHandle(createdClient);
+                        return forcedHandleClosers.get(provisionalHandle);
+                    },
+                });
+            }
+            catch (error) {
+                if (provisionalHandle && clientHandles.has(provisionalHandle)) {
+                    failedSetupHandles.add(provisionalHandle);
+                }
+                const failedClient = takeRedisClientSetupCleanupClient(error);
+                if (failedClient && !provisionalHandle) {
+                    const failedHandle = createClientHandle(failedClient);
+                    failedSetupHandles.add(failedHandle);
+                }
+                throw error;
+            }
+            const handle = provisionalHandle ?? createClientHandle(client);
+            if (state === "open" && !abortController.signal.aborted)
+                return handle;
+            await handle.close();
+            throw abortController.signal.reason ?? new Error(`Redis runtime provider is ${state}`);
+        })();
+        const tracked = opening.finally(() => {
+            openingAbortControllers.delete(abortController);
+            signal?.removeEventListener("abort", abortFromCaller);
+        });
+        return tracked;
+    }
+    return {
+        id: PROVIDER_ID,
+        loadModule() {
+            requireOpen();
+            return Promise.resolve(moduleAdapter);
+        },
+        async getClient(options = {}) {
+            requireOpen();
+            const client = await clientManager.getClient(options);
+            let exposedClient = exposedClients.get(client);
+            if (!exposedClient) {
+                exposedClient = bindClientMethods(client, CLIENT_METHODS, {
+                    optionalMethods: OPTIONAL_CLIENT_METHODS,
+                    properties: ["isOpen"],
+                });
+                exposedClients.set(client, exposedClient);
+            }
+            return exposedClient;
+        },
+        disconnectClient() {
+            // Shared-client owners may outlive registry replacement or extension
+            // teardown. The manager cleanup is therefore independently idempotent.
+            return clientManager.disconnect();
+        },
+        openClient(options = {}, signal) {
+            return openOwnedClient(options, signal);
+        },
+        async createEventPublisher(config) {
+            return createPublisher(config);
+        },
+        close() {
+            if (closePromise)
+                return closePromise;
+            if (state === "closed")
+                return Promise.resolve();
+            state = "closing";
+            for (const controller of openingAbortControllers) {
+                controller.abort(new Error("Redis runtime provider is closing"));
+            }
+            const closing = Promise.allSettled([
+                ...[...publishers].map((publisher) => publisher.close()),
+                ...[...clientHandles].map((handle) => handle.close()),
+                clientManager.disconnect(),
+            ]).then((results) => {
+                const failures = results
+                    .filter((result) => result.status === "rejected")
+                    .map((result) => result.reason);
+                if (failures.length === 0) {
+                    state = "closed";
+                    return;
+                }
+                state = "close-failed";
+                if (failures.length === 1)
+                    throw failures[0];
+                if (failures.length > 1) {
+                    throw new AggregateError(failures, "Redis runtime provider close failed");
+                }
+            }).finally(() => {
+                if (closePromise === closing)
+                    closePromise = null;
+            });
+            closePromise = closing;
+            return closing;
+        },
+    };
+}

package/package.json

@@ -0,0 +1,76 @@
+{
+  "name": "@veryfront/ext-redis",
+  "version": "0.1.1185",
+  "description": "Veryfront first-party extension package for ext-redis",
+  "keywords": [
+    "veryfront",
+    "extension",
+    "ext-redis"
+  ],
+  "author": "Veryfront",
+  "homepage": "https://github.com/veryfront/veryfront-code/tree/main/extensions/ext-redis",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/veryfront/veryfront-code.git",
+    "directory": "extensions/ext-redis"
+  },
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/veryfront/veryfront-code/issues"
+  },
+  "module": "./esm/index.js",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "types": "./esm/index.d.ts"
+    }
+  },
+  "scripts": {},
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "veryfront": {
+    "extension": true,
+    "activation": "explicit",
+    "contracts": {
+      "provides": [
+        "RedisRuntimeProvider"
+      ]
+    },
+    "capabilities": [
+      {
+        "type": "net:outbound",
+        "hosts": [
+          "*"
+        ]
+      },
+      {
+        "type": "env:read",
+        "keys": [
+          "NODE_ENV",
+          "REDIS_PASSWORD",
+          "REDIS_URL",
+          "REDIS_USERNAME"
+        ]
+      }
+    ]
+  },
+  "dependencies": {
+    "@redis/client": "1.5.8",
+    "redis": "5.11.0"
+  },
+  "peerDependencies": {
+    "veryfront": "^0.1.1185"
+  },
+  "type": "module",
+  "types": "./esm/index.d.ts",
+  "files": [
+    "esm",
+    "LICENSE",
+    "NOTICE",
+    "README.md"
+  ]
+}