@digicatapult/sqnc-process-management 2.2.130 → 2.2.132

package/build/src/lib/process/index.js

@@ -1,311 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
-    if (value !== null && value !== void 0) {
-        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-        var dispose, inner;
-        if (async) {
-            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-            dispose = value[Symbol.asyncDispose];
-        }
-        if (dispose === void 0) {
-            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-            dispose = value[Symbol.dispose];
-            if (async) inner = dispose;
-        }
-        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
-        env.stack.push({ value: value, dispose: dispose, async: async });
-    }
-    else if (async) {
-        env.stack.push({ async: true });
-    }
-    return value;
-};
-var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
-    return function (env) {
-        function fail(e) {
-            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-            env.hasError = true;
-        }
-        var r, s = 0;
-        function next() {
-            while (r = env.stack.pop()) {
-                try {
-                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
-                    if (r.dispose) {
-                        var result = r.dispose.call(r.value);
-                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-                    }
-                    else s |= 1;
-                }
-                catch (e) {
-                    fail(e);
-                }
-            }
-            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
-            if (env.hasError) throw env.error;
-        }
-        return next();
-    };
-})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-});
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { createNodeApi } from '../utils/polkadot.js';
-import { createProcessTransaction, disableProcessTransaction, getVersion, getProcess } from './api.js';
-import { utf8ToHex } from './hex.js';
-import { processValidation, simpleProcesssValidation } from '../types/validation.js';
-import { CliInputParseError, DisableError, ProgramError, VersionError } from '../types/error.js';
-import { ZodError } from 'zod';
-export const defaultOptions = {
-    API_HOST: 'localhost',
-    API_PORT: 9944,
-    USER_URI: '//Alice',
-};
-const textify = (obj) => {
-    return JSON.stringify(obj, (_key, val) => {
-        // convert snake case to camel case
-        if (val && typeof val === 'object') {
-            return Object.fromEntries(Object.entries(val).map(([k, v]) => {
-                return [
-                    [...k]
-                        .map((c, i) => (k[i - 1] === '_' ? c.toUpperCase() : c))
-                        .filter((c) => c != '_')
-                        .join(''),
-                    v,
-                ];
-            }));
-        }
-        if (typeof val === 'number')
-            return val.toString();
-        return val;
-    });
-};
-export const sanitizeInput = (data) => {
-    try {
-        return {
-            type: 'ok',
-            result: simpleProcesssValidation.parse(JSON.parse(data)),
-        };
-    }
-    catch (err) {
-        if (err instanceof Error) {
-            return {
-                type: 'error',
-                error: new CliInputParseError(err),
-                message: err.message,
-            };
-        }
-        throw err;
-    }
-};
-export const loadProcesses = (_a) => __awaiter(void 0, [_a], void 0, function* ({ data, options, dryRun, verbose, }) {
-    const env_1 = { stack: [], error: void 0, hasError: false };
-    try {
-        const parsedRes = sanitizeInput(data);
-        if (parsedRes.type === 'error') {
-            return parsedRes;
-        }
-        const processes = parsedRes.result;
-        const processTxs = new Map();
-        const polkadot = __addDisposableResource(env_1, yield createNodeApi(options), true);
-        for (const process of processes) {
-            const { waitForFinalised } = yield createProcess(process, dryRun, polkadot, options, verbose);
-            processTxs.set(process.name, waitForFinalised);
-        }
-        yield Promise.all(processTxs.values());
-        const result = {};
-        let successCount = 0;
-        for (const [key, processTxProm] of processTxs) {
-            let response = yield processTxProm;
-            result[key] = response;
-            if (response.type === 'ok') {
-                successCount = successCount + 1;
-            }
-        }
-        // calculate the result and successCount
-        return {
-            type: 'ok',
-            result,
-            message: `Successfully loaded ${successCount}/${processes.length} processes`,
-        };
-    }
-    catch (e_1) {
-        env_1.error = e_1;
-        env_1.hasError = true;
-    }
-    finally {
-        const result_1 = __disposeResources(env_1);
-        if (result_1)
-            yield result_1;
-    }
-});
-export const listTransforming = (res, options) => {
-    let processes;
-    if (options.active) {
-        processes = res.filter(({ status }) => status === 'Enabled');
-    }
-    else if (options.disabled) {
-        processes = res.filter(({ status }) => status === 'Disabled');
-    }
-    else {
-        processes = res;
-    }
-    if (options.raw) {
-        return processes.map((_a) => {
-            var { name, program } = _a, p = __rest(_a, ["name", "program"]);
-            return (Object.assign(Object.assign({ name: utf8ToHex(name) }, (options.verbose ? { program } : {})), p));
-        });
-    }
-    else {
-        return processes.map((p) => {
-            return Object.assign({ name: p.name, version: p.version, status: p.status }, (options.verbose ? { program: p.program } : {}));
-        });
-    }
-};
-export const handleVerbose = (res, verbose) => {
-    if (verbose) {
-        return res;
-    }
-    const { program } = res, rest = __rest(res, ["program"]);
-    return rest;
-};
-export const createProcess = (processRaw_1, ...args_1) => __awaiter(void 0, [processRaw_1, ...args_1], void 0, function* (processRaw, dryRun = false, polkadot, options = defaultOptions, verbose = false) {
-    const handleErr = (err) => {
-        // err is basically from errors.ts or any exception
-        // process errors will contain specific messages and/or process
-        // Promise<Process.Result> is in try {} and any exception is in catch {}
-        if (err instanceof ProgramError || err instanceof VersionError || err instanceof ZodError) {
-            const result = {
-                type: 'error',
-                error: err,
-                message: err.message,
-            };
-            return {
-                waitForFinalised: Promise.resolve(result),
-            };
-        }
-        else if (err instanceof Error) {
-            const result = {
-                type: 'error',
-                error: err,
-                message: 'An unknown error occurred',
-            };
-            return {
-                waitForFinalised: Promise.resolve(result),
-            };
-        }
-        throw err;
-    };
-    try {
-        const { name, version, program } = processValidation.parse(processRaw);
-        const processId = utf8ToHex(name);
-        const currentVersion = yield getVersion(polkadot, processId);
-        const expectedVersion = currentVersion + 1;
-        if (version > expectedVersion || version < currentVersion)
-            throw new VersionError(version, expectedVersion, name);
-        if (version === currentVersion) {
-            const process = yield getProcess(polkadot, processId, version);
-            if (program.length !== process.program.length)
-                throw new ProgramError('existing: programs are different lengths', process);
-            if (!program.every((step, i) => textify(step) === textify(process.program[i])))
-                throw new ProgramError('existing: program steps did not match', process);
-            return {
-                waitForFinalised: Promise.resolve({
-                    type: 'ok',
-                    message: `Skipping: process ${name} is already created.`,
-                    result: handleVerbose({
-                        name,
-                        version,
-                        program,
-                        status: process.status,
-                    }, verbose),
-                }),
-            };
-        }
-        if (dryRun)
-            return {
-                waitForFinalised: Promise.resolve({
-                    type: 'ok',
-                    message: 'Dry run: transaction has not been created',
-                    result: handleVerbose({
-                        name,
-                        version,
-                        program,
-                        status: 'Enabled (dry-run)',
-                    }, verbose),
-                }),
-            };
-        const createProcessTx = yield createProcessTransaction(polkadot, processId, program, options);
-        return {
-            waitForFinalised: createProcessTx.waitForFinal
-                .then((process) => {
-                const result = {
-                    type: 'ok',
-                    message: `Transaction for new process ${name} has been successfully submitted`,
-                    result: handleVerbose(process, verbose),
-                };
-                return result;
-            })
-                .catch((err) => handleErr(err).waitForFinalised),
-        };
-    }
-    catch (err) {
-        return handleErr(err);
-    }
-});
-export const disableProcess = (name_1, processVersion_1, ...args_1) => __awaiter(void 0, [name_1, processVersion_1, ...args_1], void 0, function* (name, processVersion, dryRun = false, options = defaultOptions) {
-    const env_2 = { stack: [], error: void 0, hasError: false };
-    try {
-        const processId = utf8ToHex(name);
-        const polkadot = __addDisposableResource(env_2, yield createNodeApi(options), true);
-        const currentProcess = yield getProcess(polkadot, processId, processVersion);
-        if (currentProcess.status === 'Disabled') {
-            throw new DisableError(`${name} with version ${processVersion} doesn't exist or is already disabled`);
-        }
-        if (dryRun) {
-            return {
-                type: 'ok',
-                message: `This will DISABLE the following process ${name}`,
-                result: {
-                    name,
-                    version: processVersion,
-                    status: 'Disabled (dry-run)',
-                },
-            };
-        }
-        return {
-            type: 'ok',
-            message: 'Process has been disabled',
-            result: yield disableProcessTransaction(polkadot, processId, processVersion, options),
-        };
-    }
-    catch (e_2) {
-        env_2.error = e_2;
-        env_2.hasError = true;
-    }
-    finally {
-        const result_2 = __disposeResources(env_2);
-        if (result_2)
-            yield result_2;
-    }
-});

package/build/src/lib/types/error.d.ts

@@ -1,14 +0,0 @@
-export declare class DisableError extends Error {
-    constructor(m: string);
-}
-export declare class VersionError extends Error {
-    constructor(version: number, expected: number, name: string);
-}
-export declare class CliInputParseError extends Error {
-    baseError: Error;
-    constructor(baseError: Error);
-}
-export declare class ProgramError extends Error {
-    process?: Process.Payload;
-    constructor(m: string, process?: Process.Payload);
-}