@digicatapult/sqnc-process-management 2.2.0

package/build/src/lib/process/_tests_/unit.test.js

@@ -0,0 +1,112 @@
+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());
+    });
+};
+import { expect } from 'chai';
+import { utf8ToHex, hexToUtf8 } from '../hex.js';
+import { listTransforming, handleVerbose } from '../index.js';
+import sample from '../../../../tests/fixtures/processes.js';
+const defaultPolkadot = {
+    port: '9044',
+    user: 'alice',
+    host: 'localhost',
+    file: './exampleProcess.json',
+};
+describe('utf8ToHex', () => {
+    it('converts a utf8 string to hexadecimal', () => {
+        expect(utf8ToHex('test123')).to.equal('0x74657374313233');
+    });
+});
+describe('hexToUtf8', () => {
+    it('converts a prefixed string to hex', () => {
+        expect(hexToUtf8('0x74657374313233')).to.equal('test123');
+    });
+});
+describe('listTranforming', () => {
+    it('returns all transformed processes without a program (--verbose=false)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Enabled', createdAtHash: 'abc', initialU8aLength: '32' });
+        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { verbose: false }));
+        expect(res[0]).to.deep.contain({
+            name: '123',
+            status: 'Enabled',
+            version: 1,
+        });
+    }));
+    it('returns all transformed processes with a program (--verbose=true)', () => __awaiter(void 0, void 0, void 0, function* () {
+        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
+        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { verbose: true }));
+        expect(res[0]).to.deep.contain({
+            name: '123',
+            status: 'Disabled',
+            version: 1,
+        });
+    }));
+    it('returns all options active', () => __awaiter(void 0, void 0, void 0, function* () {
+        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Enabled', createdAtHash: 'abc', initialU8aLength: '32' });
+        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { active: true }));
+        expect(res[0]).to.deep.contain({
+            name: '123',
+            status: 'Enabled',
+            version: 1,
+        });
+    }));
+    it('returns all options disabled but with active true', () => __awaiter(void 0, void 0, void 0, function* () {
+        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
+        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { active: true }));
+        expect(res[0]).to.equal(undefined);
+    }));
+    it('returns all options disabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
+        const res = listTransforming([enriched], Object.assign({}, defaultPolkadot));
+        expect(res[0]).to.deep.contain({
+            name: '123',
+            status: 'Disabled',
+            version: 1,
+        });
+    }));
+    it('returns all options active with status enabled', () => __awaiter(void 0, void 0, void 0, function* () {
+        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
+        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { active: false }));
+        expect(res[0]).to.deep.contain({
+            name: '123',
+            status: 'Disabled',
+            version: 1,
+        });
+    }));
+    it('returns additional properties with raw', () => __awaiter(void 0, void 0, void 0, function* () {
+        const enriched = Object.assign(Object.assign({}, sample[0]), { name: '123', status: 'Disabled', createdAtHash: 'abc', initialU8aLength: '32' });
+        const res = listTransforming([enriched], Object.assign(Object.assign({}, defaultPolkadot), { active: false, raw: true }));
+        expect(res[0]).to.deep.contain({
+            name: '0x313233',
+            status: 'Disabled',
+            version: 1,
+            createdAtHash: 'abc',
+            initialU8aLength: '32',
+        });
+    }));
+});
+describe('handleVerbose', function () {
+    it('should remove program when verbose == false', function () {
+        const result = handleVerbose({
+            name: 'test',
+            status: 'Enabled',
+            version: 1,
+            program: [],
+        }, false);
+        expect(result).to.deep.equal({ name: 'test', status: 'Enabled', version: 1 });
+    });
+    it('should include program when verbose == false', function () {
+        const result = handleVerbose({
+            name: 'test',
+            status: 'Enabled',
+            version: 1,
+            program: [],
+        }, true);
+        expect(result).to.deep.equal({ name: 'test', status: 'Enabled', version: 1, program: [] });
+    });
+});

package/build/src/lib/process/api.d.ts

@@ -0,0 +1,7 @@
+export declare const createProcessTransaction: (polkadot: Polkadot.Polkadot, processId: Process.Hex, program: ValidationProgram, options: Polkadot.Options) => Promise<Process.Payload>;
+export declare const disableProcessTransaction: (polkadot: Polkadot.Polkadot, processId: Process.Hex, version: number, options: Polkadot.Options) => Promise<Process.Payload>;
+type GetAllFn = (options: Polkadot.Options) => Promise<Process.RawPayload[]>;
+export declare const getAll: GetAllFn;
+export declare const getVersion: (polkadot: Polkadot.Polkadot, processId: Process.Hex) => Promise<number>;
+export declare const getProcess: (polkadot: Polkadot.Polkadot, processId: Process.Hex, version: number) => Promise<Process.Payload>;
+export {};

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

@@ -0,0 +1,112 @@
+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());
+    });
+};
+import { ProgramError } from '../types/error.js';
+import * as api from '../utils/polkadot.js';
+import { hexToUtf8 } from './hex.js';
+// TODO - refactor to validate payload?
+// for some reason reduce did not work with Process.Program or ProgramStep[] type due to symbol.iterator
+const isProgramValid = (program, out = { ops: 0, restrictions: -1 }) => {
+    program.forEach((step) => {
+        out = Object.hasOwn(step, 'Op') ? Object.assign(Object.assign({}, out), { ops: out.ops + 1 }) : Object.assign(Object.assign({}, out), { restrictions: out.restrictions + 1 });
+    });
+    return out.ops === out.restrictions;
+};
+// TODO refactor since api.ts other should be a util
+// since createNodeApi, set's all routes we could use in process.index.ts
+export const createProcessTransaction = (polkadot, processId, program, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const sudo = polkadot.keyring.addFromUri(options.USER_URI);
+    const supportsManualSeal = !!polkadot.api.rpc.engine.createBlock;
+    if (!isProgramValid(program))
+        throw new ProgramError('invalid program');
+    return new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const unsub = yield polkadot.api.tx.sudo
+                .sudo(polkadot.api.tx.processValidation.createProcess(processId, program))
+                .signAndSend(sudo, (result) => {
+                if (result.status.isFinalized) {
+                    const { event } = result.events.find(({ event: { method } }) => method === 'ProcessCreated');
+                    const data = event.data;
+                    const newProcess = {
+                        name: data[0].toHuman(),
+                        version: data[1].toNumber(),
+                        status: 'Enabled',
+                        program,
+                    };
+                    unsub();
+                    resolve(newProcess);
+                }
+            });
+            if (supportsManualSeal) {
+                yield polkadot.api.rpc.engine.createBlock(true, true);
+            }
+        }
+        catch (err) {
+            reject(err);
+        }
+    }));
+});
+export const disableProcessTransaction = (polkadot, processId, version, options) => __awaiter(void 0, void 0, void 0, function* () {
+    const sudo = polkadot.keyring.addFromUri(options.USER_URI);
+    const supportsManualSeal = !!polkadot.api.rpc.engine.createBlock;
+    return new Promise((resolve, reject) => __awaiter(void 0, void 0, void 0, function* () {
+        try {
+            const unsub = yield polkadot.api.tx.sudo
+                .sudo(polkadot.api.tx.processValidation.disableProcess(processId, version))
+                .signAndSend(sudo, (result) => {
+                if (result.status.isFinalized) {
+                    const { event } = result.events.find(({ event: { method } }) => method === 'ProcessDisabled');
+                    const data = event.data;
+                    const disabledProcess = {
+                        name: data[0].toHuman(),
+                        version: data[1].toNumber(),
+                        status: 'Disabled',
+                    };
+                    unsub();
+                    resolve(disabledProcess);
+                }
+            });
+            if (supportsManualSeal) {
+                yield polkadot.api.rpc.engine.createBlock(true, true);
+            }
+        }
+        catch (err) {
+            reject(err);
+        }
+    }));
+});
+export const getAll = (options) => __awaiter(void 0, void 0, void 0, function* () {
+    const polkadot = yield api.createNodeApi(options);
+    const processesRaw = yield polkadot.api.query.processValidation.processModel.entries();
+    return processesRaw.map(([idRaw, data]) => {
+        const id = idRaw.toHuman();
+        return {
+            name: id[0],
+            version: parseInt(id[1]),
+            status: data.status.toString(),
+            program: data.program.toJSON(),
+            createdAtHash: data.createdAtHash.toHuman(),
+            initialU8aLength: data.initialU8aLength,
+        };
+    });
+});
+export const getVersion = (polkadot, processId) => __awaiter(void 0, void 0, void 0, function* () {
+    const id = yield polkadot.api.query.processValidation.versionModel(processId);
+    return Number(id.toString());
+});
+export const getProcess = (polkadot, processId, version) => __awaiter(void 0, void 0, void 0, function* () {
+    const result = yield polkadot.api.query.processValidation.processModel(processId, version);
+    const data = Object(result.toHuman());
+    return {
+        name: hexToUtf8(processId),
+        version,
+        status: data.status,
+        program: data.program,
+    };
+});

package/build/src/lib/process/constants.d.ts

@@ -0,0 +1,3 @@
+export declare abstract class Constants {
+    static readonly PROCESS_ID_LENGTH: number;
+}

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

@@ -0,0 +1,3 @@
+export class Constants {
+}
+Constants.PROCESS_ID_LENGTH = 32;

package/build/src/lib/process/hex.d.ts

@@ -0,0 +1,2 @@
+export declare const utf8ToHex: (str: string) => Process.Hex;
+export declare const hexToUtf8: (str: Process.Hex) => string;

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

@@ -0,0 +1,9 @@
+export const utf8ToHex = (str) => {
+    const buffer = Buffer.from(str, 'utf8');
+    const bufferHex = buffer.toString('hex');
+    return `0x${bufferHex}`;
+};
+export const hexToUtf8 = (str) => {
+    const stripped = str.substring(2);
+    return Buffer.from(stripped, 'hex').toString('utf8');
+};

package/build/src/lib/process/index.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { CliInputParseError } from '../types/error.js';
+export declare const defaultOptions: Polkadot.Options;
+export declare const sanitizeInput: (data: string) => Process.Result<{
+    name: string;
+}[], CliInputParseError>;
+export declare const loadProcesses: ({ data, options, dryRun, verbose, }: {
+    data: string;
+    options?: Polkadot.Options | undefined;
+    dryRun?: boolean | undefined;
+    verbose?: boolean | undefined;
+}) => Promise<Process.Response>;
+export declare const listTransforming: (res: Process.RawPayload[], options: Process.CLIOptions) => {
+    program?: any;
+    name: string;
+    version: number;
+    status: "Enabled" | "Disabled" | "Enabled (dry-run)" | "Disabled (dry-run)";
+}[];
+export declare const handleVerbose: (res: Process.Payload, verbose: boolean) => Process.Payload;
+export declare const createProcess: (processRaw: ValidationProcess, dryRun?: boolean, options?: Polkadot.Options, verbose?: boolean) => Promise<Process.ProcessResponse>;
+export declare const disableProcess: (name: string, processVersion: number, dryRun?: boolean, options?: Polkadot.Options) => Promise<Process.ProcessResponse>;

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

@@ -0,0 +1,205 @@
+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 __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 = ({ data, options, dryRun, verbose, }) => __awaiter(void 0, void 0, void 0, function* () {
+    const parsedRes = sanitizeInput(data);
+    if (parsedRes.type === 'error') {
+        return parsedRes;
+    }
+    const processes = parsedRes.result;
+    const [result, successCount] = yield processes.reduce((acc, process) => __awaiter(void 0, void 0, void 0, function* () {
+        const [result, oldCount] = yield acc;
+        const processResult = yield createProcess(process, dryRun, options, verbose);
+        const newCount = processResult.type === 'ok' ? oldCount + 1 : oldCount;
+        result[process.name] = processResult;
+        return [result, newCount];
+    }), Promise.resolve([{}, 0]));
+    return {
+        type: 'ok',
+        result,
+        message: `Successfully loaded ${successCount}/${processes.length} processes`,
+    };
+});
+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, dryRun = false, options = defaultOptions, verbose = false) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const { name, version, program } = processValidation.parse(processRaw);
+        const processId = utf8ToHex(name);
+        const polkadot = yield createNodeApi(options);
+        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 {
+                type: 'ok',
+                message: `Skipping: process ${name} is already created.`,
+                result: handleVerbose({
+                    name,
+                    version,
+                    program,
+                    status: process.status,
+                }, verbose),
+            };
+        }
+        if (dryRun)
+            return {
+                type: 'ok',
+                message: 'Dry run: transaction has not been created',
+                result: handleVerbose({
+                    name,
+                    version,
+                    program,
+                    status: 'Enabled (dry-run)',
+                }, verbose),
+            };
+        return {
+            type: 'ok',
+            message: `Transaction for new process ${name} has been successfully submitted`,
+            result: handleVerbose(yield createProcessTransaction(polkadot, processId, program, options), verbose),
+        };
+    }
+    catch (err) {
+        // err is basically from errors.ts or any exception
+        // process errors will comntain 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) {
+            return {
+                type: 'error',
+                error: err,
+                message: err.message,
+            };
+        }
+        else if (err instanceof Error) {
+            return {
+                type: 'error',
+                error: err,
+                message: 'An unknown error occurred',
+            };
+        }
+        throw err;
+    }
+});
+export const disableProcess = (name, processVersion, dryRun = false, options = defaultOptions) => __awaiter(void 0, void 0, void 0, function* () {
+    const processId = utf8ToHex(name);
+    const polkadot = yield createNodeApi(options);
+    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),
+    };
+});

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

@@ -0,0 +1,14 @@
+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);
+}

package/build/src/lib/types/error.js

@@ -0,0 +1,26 @@
+export class DisableError extends Error {
+    constructor(m) {
+        super(m);
+        Object.setPrototypeOf(this, DisableError.prototype);
+    }
+}
+export class VersionError extends Error {
+    constructor(version, expected, name) {
+        super(`Process version ${version} is invalid. If you are trying to create a new version of process ${name} version should be ${expected}`);
+        Object.setPrototypeOf(this, VersionError.prototype);
+    }
+}
+export class CliInputParseError extends Error {
+    constructor(baseError) {
+        super(`Error parsing input: ${baseError.message}`);
+        this.baseError = baseError;
+        Object.setPrototypeOf(this, CliInputParseError.prototype);
+    }
+}
+export class ProgramError extends Error {
+    constructor(m, process) {
+        super(m);
+        this.process = process;
+        Object.setPrototypeOf(this, ProgramError.prototype);
+    }
+}