@versori/run 0.2.19 → 0.2.21

package/script/src/kv/sdk/SDKKeyValueProvider.js

@@ -0,0 +1,133 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SDKKeyValueProvider = void 0;
+const StoresService_js_1 = require("../../dsl/http/versori/kvapi/services/StoresService.js");
+const KvOperationsService_js_1 = require("../../dsl/http/versori/kvapi/services/KvOperationsService.js");
+const KeyValue_js_1 = require("../KeyValue.js");
+const SDKKeyValue_js_1 = require("./SDKKeyValue.js");
+function getOptionsFromEnv() {
+    return {
+        organizationId: Deno.env.get('RUN_ORGANISATION_ID'),
+        projectId: Deno.env.get('RUN_SERVICE_ID'),
+        environment: Deno.env.get('RUN_ENVIRONMENT'),
+        kvApiUrl: Deno.env.get('RUN_SDK_API_URL') || 'http://localhost:8092'
+    };
+}
+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(storeName) {
+    try {
+        try {
+            const existingStore = await StoresService_js_1.StoresService.listStores(Deno.env.get('RUN_ORGANISATION_ID'));
+            if (existingStore.stores?.find(store => store.name === storeName)) {
+                return existingStore.stores.find(store => store.name === storeName);
+            }
+        }
+        catch (error) {
+            console.error('Failed to list stores, creating...', error);
+        }
+        const store = await StoresService_js_1.StoresService.createStore({
+            name: storeName,
+            orgId: Deno.env.get('RUN_ORGANISATION_ID')
+        });
+        return store;
+    }
+    catch (error) {
+        throw error;
+    }
+}
+class SDKKeyValueProvider {
+    constructor(kvOrgScope, kvProjectScope, kvExecutionScope, opts) {
+        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 [orgKv, projKv, execKv] = await Promise.all([
+            openOrCreateKV(`ORG_${parsedOpts.organizationId}`),
+            openOrCreateKV(`PROJECT_${parsedOpts.projectId}`),
+            openOrCreateKV(`EXECUTION_${parsedOpts.projectId}`),
+        ]);
+        return new SDKKeyValueProvider(orgKv, projKv, execKv, parsedOpts);
+    }
+    static fromEnv() {
+        return SDKKeyValueProvider.newInstance(getOptionsFromEnv());
+    }
+    [Symbol.asyncDispose]() {
+        return Promise.resolve();
+    }
+    kv(options) {
+        switch (options.scope) {
+            case ':organization:':
+                return new SDKKeyValue_js_1.SDKKeyValue(this.kvOrgScope, this.subjectPrefix(options));
+            case ':project:':
+                return new SDKKeyValue_js_1.SDKKeyValue(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 SDKKeyValue_js_1.SDKKeyValue(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:');
+            }
+            await KvOperationsService_js_1.KvOperationsService.deleteKv(this.kvExecutionScope.id, options.executionId, {
+                options: {
+                    cascade: true
+                }
+            });
+        }
+        // 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.SDKKeyValueProvider = SDKKeyValueProvider;

package/script/src/kv/sdk/mod.d.ts

@@ -0,0 +1,3 @@
+export * from './SDKKeyValue.js';
+export * from './SDKKeyValueProvider.js';
+//# sourceMappingURL=mod.d.ts.map

package/script/src/kv/sdk/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../src/src/kv/sdk/mod.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,0BAA0B,CAAC"}

package/script/src/kv/sdk/mod.js

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./SDKKeyValue.js"), exports);
+__exportStar(require("./SDKKeyValueProvider.js"), exports);