@digicatapult/sqnc-process-management 2.2.16 → 2.2.17

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@digicatapult/sqnc-process-management",
-    "version": "2.2.16",
+    "version": "2.2.17",
     "description": "SQNC Process Management Flow",
     "main": "./lib/index.js",
     "bin": {

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

@@ -1,4 +1,6 @@
-export declare const createProcessTransaction: (polkadot: Polkadot.Polkadot, processId: Process.Hex, program: ValidationProgram, options: Polkadot.Options) => Promise<Process.Payload>;
+export declare const createProcessTransaction: (polkadot: Polkadot.Polkadot, processId: Process.Hex, program: ValidationProgram, options: Polkadot.Options) => Promise<{
+    waitForFinal: 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;

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

@@ -25,32 +25,39 @@ export const createProcessTransaction = (polkadot, processId, program, options)
     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);
+    let resolve = () => { };
+    let reject = () => { };
+    const result = new Promise((res, rej) => {
+        resolve = res;
+        reject = rej;
+    });
+    try {
+        const unsub = yield polkadot.api.tx.sudo
+            .sudo(polkadot.api.tx.processValidation.createProcess(processId, program))
+            .signAndSend(sudo, { nonce: -1 }, (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);
-        }
-    }));
+    }
+    catch (err) {
+        reject(err);
+    }
+    return {
+        waitForFinal: result,
+    };
 });
 export const disableProcessTransaction = (polkadot, processId, version, options) => __awaiter(void 0, void 0, void 0, function* () {
     const sudo = polkadot.keyring.addFromUri(options.USER_URI);

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

@@ -17,5 +17,7 @@ export declare const listTransforming: (res: Process.RawPayload[], options: Proc
     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 createProcess: (processRaw: ValidationProcess, dryRun?: boolean, options?: Polkadot.Options, verbose?: boolean) => Promise<{
+    waitForFinalised: 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

@@ -72,13 +72,22 @@ export const loadProcesses = (_a) => __awaiter(void 0, [_a], void 0, function* (
         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]));
+    const processTxs = new Map();
+    for (const process of processes) {
+        const { waitForFinalised } = yield createProcess(process, dryRun, 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,
@@ -116,6 +125,32 @@ export const handleVerbose = (res, verbose) => {
     return rest;
 };
 export const createProcess = (processRaw_1, ...args_1) => __awaiter(void 0, [processRaw_1, ...args_1], void 0, function* (processRaw, dryRun = false, 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);
@@ -131,52 +166,47 @@ export const createProcess = (processRaw_1, ...args_1) => __awaiter(void 0, [pro
             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),
+                waitForFinalised: Promise.resolve({
+                    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),
+                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 {
-            type: 'ok',
-            message: `Transaction for new process ${name} has been successfully submitted`,
-            result: handleVerbose(yield createProcessTransaction(polkadot, processId, program, options), verbose),
+            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) {
-        // 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;
+        return handleErr(err);
     }
 });
 export const disableProcess = (name_1, processVersion_1, ...args_2) => __awaiter(void 0, [name_1, processVersion_1, ...args_2], void 0, function* (name, processVersion, dryRun = false, options = defaultOptions) {

package/build/tests/integration/command-functions.test.js

@@ -18,11 +18,16 @@ import { getAll } from '../../src/lib/process/api.js';
 /* fixtures */
 import processesExample from '../fixtures/processes.js';
 const polkadotOptions = { API_HOST: 'localhost', API_PORT: 9944, USER_URI: '//Alice', MANUAL_SEAL: true };
+const createProcessAndWait = (processRaw, dryRun, options, verbose) => __awaiter(void 0, void 0, void 0, function* () {
+    const { waitForFinalised } = yield createProcess(processRaw, dryRun, options, verbose);
+    const result = yield waitForFinalised;
+    return result;
+});
 describe('Process creation and deletion, listing', () => {
     describe('Happy path', () => {
         describe('Multiple processes', () => {
             it('skips already created processes and creates new ones', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield createProcess({
+                yield createProcessAndWait({
                     name: 'existing-process-test',
                     version: 1,
                     program: simple2,
@@ -113,7 +118,7 @@ describe('Process creation and deletion, listing', () => {
             const processName = '0';
             const currentVersion = yield getVersionHelper(processName);
             const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcess({ name: processName, version: bumpedVersion, program: simple }, false, polkadotOptions);
+            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: simple }, false, polkadotOptions);
             if (newProcess.type !== 'ok') {
                 expect.fail('Expected process creation to succeed');
             }
@@ -137,7 +142,7 @@ describe('Process creation and deletion, listing', () => {
             const processName = '0';
             const currentVersion = yield getVersionHelper(processName);
             const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcess({ name: processName, version: bumpedVersion, program: validAllRestrictions }, true, polkadotOptions);
+            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: validAllRestrictions }, true, polkadotOptions);
             if (newProcess.type !== 'ok') {
                 expect.fail('Expected process create to succeed');
             }
@@ -152,7 +157,7 @@ describe('Process creation and deletion, listing', () => {
             const processName = '0';
             const currentVersion = yield getVersionHelper(processName);
             const bumpedVersion = currentVersion + 1;
-            const newProcess = yield createProcess({ name: processName, version: bumpedVersion, program: validAllRestrictions }, false, polkadotOptions);
+            const newProcess = yield createProcessAndWait({ name: processName, version: bumpedVersion, program: validAllRestrictions }, false, polkadotOptions);
             expect(newProcess.type).to.equal('ok');
             const disabledProcess = yield disableProcess(processName, bumpedVersion, true, polkadotOptions);
             if (disabledProcess.type !== 'ok') {
@@ -186,7 +191,7 @@ describe('Process creation and deletion, listing', () => {
             describe('Multiple uploads', () => {
                 // TODO could prestage in before if more scenarios
                 it('skips and notifies if process programs are different', () => __awaiter(void 0, void 0, void 0, function* () {
-                    yield createProcess({ name: 'existing-length', version: 1, program: validAllRestrictions }, false, polkadotOptions);
+                    yield createProcessAndWait({ name: 'existing-length', version: 1, program: validAllRestrictions }, false, polkadotOptions);
                     const process2Name = 'should-create-1';
                     const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
                     const res = yield loadProcesses({
@@ -208,7 +213,7 @@ describe('Process creation and deletion, listing', () => {
                     expect(process2Res.message).to.equal('Transaction for new process should-create-1 has been successfully submitted');
                 }));
                 it('also fails if number of steps matches but POSTFIX does not', () => __awaiter(void 0, void 0, void 0, function* () {
-                    yield createProcess({ name: 'existing-steps', version: 1, program: simple }, false, polkadotOptions);
+                    yield createProcessAndWait({ name: 'existing-steps', version: 1, program: simple }, false, polkadotOptions);
                     const process2Name = 'should-create-2';
                     const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
                     const res = yield loadProcesses({
@@ -224,8 +229,8 @@ describe('Process creation and deletion, listing', () => {
                 }));
             });
             it('does not create new one and notifies if programs are different length', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield createProcess({ name: 'existing-single', version: 1, program: validAllRestrictions }, false, polkadotOptions);
-                const res = yield createProcess({ name: 'existing-single', version: 1, program: simple }, false, polkadotOptions);
+                yield createProcessAndWait({ name: 'existing-single', version: 1, program: validAllRestrictions }, false, polkadotOptions);
+                const res = yield createProcessAndWait({ name: 'existing-single', version: 1, program: simple }, false, polkadotOptions);
                 if (res.type !== 'error') {
                     expect.fail('Expected program create with different lengths to fail');
                 }
@@ -233,8 +238,8 @@ describe('Process creation and deletion, listing', () => {
                 expect(res.error).to.instanceOf(ProgramError);
             }));
             it('does not create new one and notifies if programs same are length but do not match', () => __awaiter(void 0, void 0, void 0, function* () {
-                yield createProcess({ name: 'existing-steps-single', version: 1, program: simple2 }, false, polkadotOptions);
-                const res = yield createProcess({ name: 'existing-steps-single', version: 1, program: [{ Restriction: 'None' }] }, false, polkadotOptions);
+                yield createProcessAndWait({ name: 'existing-steps-single', version: 1, program: simple2 }, false, polkadotOptions);
+                const res = yield createProcessAndWait({ name: 'existing-steps-single', version: 1, program: [{ Restriction: 'None' }] }, false, polkadotOptions);
                 if (res.type !== 'error') {
                     expect.fail('Expected program create with different lengths to fail');
                 }
@@ -249,7 +254,7 @@ describe('Process creation and deletion, listing', () => {
             }));
         });
         it('fails for invalid POSTFIX notation', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcess({ name: validProcessName, version: validVersionNumber, program: invalidPOSIX }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: invalidPOSIX }, false, polkadotOptions);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -257,7 +262,7 @@ describe('Process creation and deletion, listing', () => {
             expect(res.message).to.equal('invalid program');
         }));
         it('fails for invalid restriction key', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcess({
+            const res = yield createProcessAndWait({
                 name: validProcessName,
                 version: validVersionNumber,
                 program: invalidRestrictionKey,
@@ -273,14 +278,14 @@ describe('Process creation and deletion, listing', () => {
             });
         }));
         it('fails for invalid restriction value', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcess({ name: validProcessName, version: validVersionNumber, program: invalidRestrictionValue }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: invalidRestrictionValue }, false, polkadotOptions);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
             expect(res.error).to.be.instanceOf(ZodError);
         }));
         it('fails for invalid json', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcess({ name: validProcessName, version: validVersionNumber, program: 'invalidJson' }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: 'invalidJson' }, false, polkadotOptions);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -288,7 +293,7 @@ describe('Process creation and deletion, listing', () => {
         }));
         it('fails to create for too low version', () => __awaiter(void 0, void 0, void 0, function* () {
             // - 2 because -1 would make current = valid
-            const res = yield createProcess({ name: validProcessName, version: validVersionNumber - 2, program: validAllRestrictions }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber - 2, program: validAllRestrictions }, false, polkadotOptions);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -296,7 +301,7 @@ describe('Process creation and deletion, listing', () => {
             expect(res.error).to.be.instanceOf(VersionError);
         }));
         it('fails to create for too high version', () => __awaiter(void 0, void 0, void 0, function* () {
-            const res = yield createProcess({ name: validProcessName, version: validVersionNumber + 1, program: validAllRestrictions }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber + 1, program: validAllRestrictions }, false, polkadotOptions);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -305,7 +310,7 @@ describe('Process creation and deletion, listing', () => {
         }));
         it('fails to create with too long process id', () => __awaiter(void 0, void 0, void 0, function* () {
             const processName = '0'.repeat(Constants.PROCESS_ID_LENGTH + 1);
-            const res = yield createProcess({ name: processName, version: 1, program: validAllRestrictions }, false, polkadotOptions);
+            const res = yield createProcessAndWait({ name: processName, version: 1, program: validAllRestrictions }, false, polkadotOptions);
             if (res.type !== 'error') {
                 expect.fail('Expected process create to fail');
             }
@@ -322,7 +327,7 @@ describe('Process creation and deletion, listing', () => {
             expect(err).instanceOf(DisableError);
         }));
         it('fails to disable process a second time', () => __awaiter(void 0, void 0, void 0, function* () {
-            const newProcess = yield createProcess({ name: validProcessName, version: validVersionNumber, program: simple }, false, polkadotOptions);
+            const newProcess = yield createProcessAndWait({ name: validProcessName, version: validVersionNumber, program: simple }, false, polkadotOptions);
             expect(newProcess.type).to.equal('ok');
             const firstDisable = yield disableProcess(validProcessName, validVersionNumber, false, polkadotOptions);
             expect(firstDisable.type).to.equal('ok');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@digicatapult/sqnc-process-management",
-  "version": "2.2.16",
+  "version": "2.2.17",
   "description": "SQNC Process Management Flow",
   "main": "./lib/index.js",
   "bin": {