@versori/run 0.1.0-alpha.8 → 0.1.0-alpha.9

package/script/src/kv/nats/NatsKeyValueProvider.js

@@ -0,0 +1,182 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsKeyValueProvider = void 0;
+const dntShim = __importStar(require("../../../_dnt.shims.js"));
+const mod_js_1 = require("../../../deps/jsr.io/@nats-io/jetstream/3.0.2/src/mod.js");
+const mod_js_2 = require("../../../deps/jsr.io/@nats-io/kv/3.0.2/src/mod.js");
+const mod_js_3 = require("../../../deps/jsr.io/@nats-io/transport-deno/3.0.2/src/mod.js");
+const KeyValue_js_1 = require("../KeyValue.js");
+const NatsKeyValue_js_1 = require("./NatsKeyValue.js");
+function getOptionsFromEnv() {
+    const natsTlsCaFile = dntShim.Deno.env.get('RUN_NATS_TLS_CA_FILE');
+    return {
+        organizationId: dntShim.Deno.env.get('RUN_ORGANISATION_ID'),
+        projectId: dntShim.Deno.env.get('RUN_SERVICE_ID'),
+        environment: dntShim.Deno.env.get('RUN_ENVIRONMENT'),
+        nats: {
+            url: dntShim.Deno.env.get('RUN_NATS_URL') || 'nats://localhost:4222',
+            credsFile: dntShim.Deno.env.get('RUN_NATS_CREDS_FILE'),
+            ...(natsTlsCaFile && {
+                tls: {
+                    caFile: natsTlsCaFile,
+                },
+            }),
+        },
+    };
+}
+function mergeOptions(defaults, provided) {
+    const merged = {
+        ...defaults,
+        ...provided,
+    };
+    if (!merged.organizationId) {
+        throw new Error('organizationId is required but not provided and VERSORI_ORGANIZATION_ID is not set');
+    }
+    if (!merged.projectId) {
+        throw new Error('projectId is required but not provided and VERSORI_PROJECT_ID is not set');
+    }
+    return merged;
+}
+async function openOrCreateKV(kvm, bucket) {
+    try {
+        const kv = await kvm.open(bucket);
+        await kv.status();
+        return kv;
+    }
+    catch (error) {
+        if (error instanceof mod_js_1.JetStreamApiError &&
+            error.code === mod_js_1.JetStreamApiCodes.StreamNotFound) {
+            console.log('stream not found, creating...');
+            return await kvm.create(bucket);
+        }
+        throw error;
+    }
+}
+class NatsKeyValueProvider {
+    constructor(kvm, kvOrgScope, kvProjectScope, kvExecutionScope, opts) {
+        Object.defineProperty(this, "kvm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kvm
+        });
+        Object.defineProperty(this, "kvOrgScope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kvOrgScope
+        });
+        Object.defineProperty(this, "kvProjectScope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kvProjectScope
+        });
+        Object.defineProperty(this, "kvExecutionScope", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kvExecutionScope
+        });
+        Object.defineProperty(this, "opts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: opts
+        });
+    }
+    static async newInstance(opts = {}) {
+        const parsedOpts = mergeOptions(getOptionsFromEnv(), opts);
+        const credsFile = parsedOpts.nats.credsFile
+            ? await dntShim.Deno.readFile(parsedOpts.nats.credsFile)
+            : undefined;
+        const conn = await (0, mod_js_3.connect)({
+            servers: [parsedOpts.nats.url],
+            authenticator: credsFile ? (0, mod_js_3.credsAuthenticator)(credsFile) : undefined,
+            ...(parsedOpts.nats.tls && {
+                tls: parsedOpts.nats.tls,
+            }),
+        });
+        const kvm = new mod_js_2.Kvm(conn);
+        const [orgKv, projKv, execKv] = await Promise.all([
+            openOrCreateKV(kvm, `ORG_${parsedOpts.organizationId}`),
+            openOrCreateKV(kvm, `PROJECT_${parsedOpts.projectId}`),
+            openOrCreateKV(kvm, `EXECUTION_${parsedOpts.projectId}`),
+        ]);
+        return new NatsKeyValueProvider(kvm, orgKv, projKv, execKv, parsedOpts);
+    }
+    static fromEnv() {
+        return NatsKeyValueProvider.newInstance(getOptionsFromEnv());
+    }
+    [Symbol.asyncDispose]() {
+        return this.kvm.js.nc.close();
+    }
+    kv(options) {
+        switch (options.scope) {
+            case ':organization:':
+                return new NatsKeyValue_js_1.NatsKeyValue(this.kvOrgScope, this.subjectPrefix(options));
+            case ':project:':
+                return new NatsKeyValue_js_1.NatsKeyValue(this.kvProjectScope, this.subjectPrefix(options));
+            case ':execution:':
+                if (!(0, KeyValue_js_1.isKVOptionsExecution)(options)) {
+                    throw new Error('invalid KV options, executionId is required for :execution: scope');
+                }
+                return new NatsKeyValue_js_1.NatsKeyValue(this.kvExecutionScope, this.subjectPrefix(options));
+            default:
+                throw new Error(`invalid KV options, scope ${options.scope} is not supported`);
+        }
+    }
+    async destroy(options) {
+        if (options.scope === ':execution:') {
+            if (typeof options.executionId === 'undefined') {
+                throw new Error('executionId is required when scope is :execution:');
+            }
+            const keys = await this.kvExecutionScope.keys(`${this.subjectPrefix(options)}.>`);
+            for await (const key of keys) {
+                try {
+                    await this.kvExecutionScope.purge(key);
+                }
+                catch (error) {
+                    console.error(`Failed to purge key: ${key}`, error);
+                }
+            }
+        }
+        // TODO: interface may need updating, workers should not be deleting KV buckets, only execution keys should be purged.
+        return;
+    }
+    subjectPrefix(options) {
+        const activationSuffix = options.activationId ? `.${options.activationId}` : '';
+        switch (options.scope) {
+            case ':organization:':
+                return `${this.opts.organizationId}${activationSuffix}`;
+            case ':project:':
+                return `${this.opts.organizationId}.${this.opts.projectId}.${this.opts.environment}${activationSuffix}`;
+            case ':execution:':
+                return `${this.opts.organizationId}.${this.opts.projectId}.${this.opts.environment}.${options.executionId}${activationSuffix}`;
+        }
+    }
+}
+exports.NatsKeyValueProvider = NatsKeyValueProvider;