@versori/run 0.0.1-alpha.9 → 0.1.0-alpha.11

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

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsKeyValue = void 0;
+const KVNotFoundError_js_1 = require("../KVNotFoundError.js");
+class NatsKeyValue {
+    constructor(kv, prefix) {
+        Object.defineProperty(this, "kv", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: kv
+        });
+        Object.defineProperty(this, "prefix", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: prefix
+        });
+    }
+    async get(key, options = {}) {
+        let entry;
+        try {
+            entry = await this.kv.get(this.generateKey(key));
+        }
+        catch (error) {
+            console.error('Unknown error reading from KV store', error);
+            throw new Error('Unknown error reading from KV store');
+        }
+        if (!entry || ['DEL', 'PURGE'].includes(entry.operation)) {
+            if (options.throwOnNotFound) {
+                throw new KVNotFoundError_js_1.KVNotFoundError(key);
+            }
+            else if (typeof options.defaultValue !== 'undefined') {
+                return options.defaultValue;
+            }
+            return undefined;
+        }
+        return entry.json();
+    }
+    async set(key, value) {
+        const payload = JSON.stringify(value);
+        await this.kv.put(this.generateKey(key), payload);
+    }
+    async delete(key) {
+        await this.kv.delete(this.generateKey(key));
+    }
+    generateKey(key) {
+        return `${this.prefix}.${key}`;
+    }
+}
+exports.NatsKeyValue = NatsKeyValue;

package/script/src/kv/nats/NatsKeyValueProvider.d.ts

@@ -0,0 +1,26 @@
+import { TlsOptions } from '@nats-io/transport-deno';
+import { DestroyOptions, KeyValue, KeyValueProvider, KVOptions } from '../KeyValue.js';
+export type NatsKeyValueProviderOptions = {
+    organizationId: string;
+    projectId: string;
+    environment: string;
+    nats: {
+        url: string;
+        credsFile?: string;
+        tls?: TlsOptions;
+    };
+};
+export declare class NatsKeyValueProvider implements KeyValueProvider, AsyncDisposable {
+    private readonly kvm;
+    private readonly kvOrgScope;
+    private readonly kvProjectScope;
+    private readonly kvExecutionScope;
+    private readonly opts;
+    private constructor();
+    static newInstance(opts?: Partial<NatsKeyValueProviderOptions>): Promise<NatsKeyValueProvider>;
+    static fromEnv(): Promise<NatsKeyValueProvider>;
+    kv(options: KVOptions): KeyValue;
+    destroy(options: DestroyOptions): Promise<void>;
+    private subjectPrefix;
+}
+//# sourceMappingURL=NatsKeyValueProvider.d.ts.map

package/script/src/kv/nats/NatsKeyValueProvider.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"NatsKeyValueProvider.d.ts","sourceRoot":"","sources":["../../../../src/src/kv/nats/NatsKeyValueProvider.ts"],"names":[],"mappings":"AAEA,OAAO,EAA+B,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAClF,OAAO,EACH,cAAc,EAEd,QAAQ,EACR,gBAAgB,EAChB,SAAS,EACZ,MAAM,gBAAgB,CAAC;AA4CxB,MAAM,MAAM,2BAA2B,GAAG;IACtC,cAAc,EAAE,MAAM,CAAC;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE;QACF,GAAG,EAAE,MAAM,CAAC;QACZ,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,GAAG,CAAC,EAAE,UAAU,CAAC;KACpB,CAAC;CACL,CAAC;AAuBF,qBAAa,oBAAqB,YAAW,gBAAgB,EAAE,eAAe;IAEtE,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,cAAc;IAC/B,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IACjC,OAAO,CAAC,QAAQ,CAAC,IAAI;IALzB,OAAO;WAQM,WAAW,CACpB,IAAI,GAAE,OAAO,CAAC,2BAA2B,CAAM,GAChD,OAAO,CAAC,oBAAoB,CAAC;IA0BhC,MAAM,CAAC,OAAO,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAQ/C,EAAE,CAAC,OAAO,EAAE,SAAS,GAAG,QAAQ;IAqB1B,OAAO,CAAC,OAAO,EAAE,cAAc,GAAG,OAAO,CAAC,IAAI,CAAC;IAuBrD,OAAO,CAAC,aAAa;CAYxB"}

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

@@ -0,0 +1,158 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NatsKeyValueProvider = void 0;
+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 transport_deno_1 = require("@nats-io/transport-deno");
+const KeyValue_js_1 = require("../KeyValue.js");
+const NatsKeyValue_js_1 = require("./NatsKeyValue.js");
+function getOptionsFromEnv() {
+    const natsTlsCaFile = Deno.env.get('RUN_NATS_TLS_CA_FILE');
+    return {
+        organizationId: Deno.env.get('RUN_ORGANISATION_ID'),
+        projectId: Deno.env.get('RUN_SERVICE_ID'),
+        environment: Deno.env.get('RUN_ENVIRONMENT'),
+        nats: {
+            url: Deno.env.get('RUN_NATS_URL') || 'nats://localhost:4222',
+            credsFile: 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 Deno.readFile(parsedOpts.nats.credsFile)
+            : undefined;
+        const conn = await (0, transport_deno_1.connect)({
+            servers: [parsedOpts.nats.url],
+            authenticator: credsFile ? (0, transport_deno_1.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;

package/esm/deps/jsr.io/@std/fs/1.0.15/exists.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.15/exists.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAqCT"}

package/script/deps/jsr.io/@std/fs/1.0.15/exists.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exists.d.ts","sourceRoot":"","sources":["../../../../../../src/deps/jsr.io/@std/fs/1.0.15/exists.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;;;OAKG;IACH,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgGG;AACH,wBAAsB,MAAM,CAC1B,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAAC,OAAO,CAAC,CAsClB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+FG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,MAAM,GAAG,GAAG,EAClB,OAAO,CAAC,EAAE,aAAa,GACtB,OAAO,CAqCT"}