@digicatapult/sqnc-process-management 2.2.0

package/build/tests/fixtures/programs.d.ts

@@ -0,0 +1,14 @@
+export declare const simple: Process.Program;
+export declare const simple2: {
+    Restriction: {
+        SenderHasInputRole: {
+            index: number;
+            role_key: string;
+        };
+    };
+}[];
+export declare const invalidPOSIX: Process.Program;
+export declare const validAllRestrictions: Process.Program;
+export declare const invalidRestrictionKey: Process.Program;
+export declare const invalidRestrictionValue: Process.Program;
+export declare const multiple: (process1Name: string, process1BumpedV: number, process2Name: string, process2BumpedV: number) => string;

package/build/tests/fixtures/programs.js

@@ -0,0 +1,211 @@
+export const simple = [{ Restriction: 'None' }];
+export const simple2 = [
+    {
+        Restriction: {
+            SenderHasInputRole: {
+                index: 0,
+                role_key: 'Supplier',
+            },
+        },
+    },
+];
+export const invalidPOSIX = [
+    { Restriction: 'None' },
+    {
+        Restriction: {
+            SenderHasInputRole: {
+                index: 0,
+                role_key: 'Supplier',
+            },
+        },
+    },
+    { Op: 'Or' },
+    {
+        Restriction: {
+            SenderHasOutputRole: {
+                index: 0,
+                role_key: 'Supplier',
+            },
+        },
+    },
+];
+export const validAllRestrictions = [
+    { Restriction: 'None' },
+    {
+        Restriction: {
+            SenderHasInputRole: {
+                index: 0,
+                role_key: 'Supplier',
+            },
+        },
+    },
+    { Op: 'Or' },
+    {
+        Restriction: {
+            SenderHasOutputRole: {
+                index: 0,
+                role_key: 'Supplier',
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            OutputHasRole: {
+                index: 0,
+                role_key: 'Supplier',
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            OutputHasMetadata: {
+                index: 0,
+                metadata_key: 'SomeMetadataKey',
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            InputHasRole: {
+                index: 0,
+                role_key: 'Supplier',
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            InputHasMetadata: {
+                index: 0,
+                metadata_key: 'SomeMetadataKey',
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            MatchInputOutputRole: {
+                input_index: 0,
+                input_role_key: 'Supplier',
+                output_index: 0,
+                output_role_key: 'Supplier',
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            MatchInputOutputMetadataValue: {
+                input_index: 0,
+                input_metadata_key: 'SomeMetadataKey',
+                output_index: 0,
+                output_metadata_key: 'SomeMetadataKey',
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            MatchInputIdOutputMetadataValue: {
+                input_index: 0,
+                output_index: 0,
+                output_metadata_key: 'SomeMetadataKey',
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            FixedNumberOfInputs: {
+                num_inputs: 0,
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            FixedNumberOfOutputs: {
+                num_outputs: 0,
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            FixedInputMetadataValue: {
+                index: 0,
+                metadata_key: 'SomeMetadataKey',
+                metadata_value: {
+                    Literal: 'a',
+                },
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            FixedOutputMetadataValue: {
+                index: 0,
+                metadata_key: 'SomeMetadataKey',
+                metadata_value: {
+                    Literal: 'a',
+                },
+            },
+        },
+    },
+    { Op: 'And' },
+    {
+        Restriction: {
+            FixedOutputMetadataValueType: {
+                index: 0,
+                metadata_key: 'SomeMetadataKey',
+                metadata_value_type: 'Literal',
+            },
+        },
+    },
+    { Op: 'And' },
+];
+export const invalidRestrictionKey = [{ Restriction: { NotARestriction: {} } }];
+export const invalidRestrictionValue = [
+    {
+        Restriction: {
+            FixedInputMetadataValue: {
+                invalid: 0,
+            },
+        },
+    },
+];
+// WHY not to use simple/etc? why not name1 name2?
+export const multiple = (process1Name, process1BumpedV, process2Name, process2BumpedV) => JSON.stringify([
+    {
+        name: process1Name,
+        version: process1BumpedV,
+        program: [
+            {
+                Restriction: {
+                    SenderHasInputRole: {
+                        index: 0,
+                        role_key: 'Supplier',
+                    },
+                },
+            },
+        ],
+    },
+    {
+        name: process2Name,
+        version: process2BumpedV,
+        program: [
+            {
+                Restriction: {
+                    SenderHasInputRole: {
+                        index: 0,
+                        role_key: 'Supplier',
+                    },
+                },
+            },
+        ],
+    },
+]);

package/build/tests/helpers/substrateHelper.d.ts

@@ -0,0 +1,2 @@
+export declare const getVersionHelper: (name: string) => Promise<number>;
+export declare const Helper: (processId: Process.Hex, version: number) => Promise<Process.Payload>;

package/build/tests/helpers/substrateHelper.js

@@ -0,0 +1,25 @@
+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 { createNodeApi } from '../../src/lib/utils/polkadot.js';
+import { getVersion, getProcess } from '../../src/lib/process/api.js';
+import { defaultOptions } from '../../src/lib/process/index.js';
+import { utf8ToHex } from '../../src/lib/process/hex.js';
+export const getVersionHelper = (name) => __awaiter(void 0, void 0, void 0, function* () {
+    const polkadot = yield createNodeApi(defaultOptions);
+    const version = yield getVersion(polkadot, utf8ToHex(name));
+    yield polkadot.api.disconnect();
+    return version;
+});
+export const Helper = (processId, version) => __awaiter(void 0, void 0, void 0, function* () {
+    const polkadot = yield createNodeApi(defaultOptions);
+    const process = yield getProcess(polkadot, processId, version);
+    yield polkadot.api.disconnect();
+    return process;
+});

package/build/tests/integration/command-functions.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,327 @@
+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 { default as chai, expect, assert } from 'chai';
+import chaiAsPromised from 'chai-as-promised';
+chai.use(chaiAsPromised);
+import { createProcess, disableProcess, loadProcesses } from '../../src/lib/process/index.js';
+import { validAllRestrictions, invalidPOSIX, multiple, simple2, simple, invalidRestrictionKey, invalidRestrictionValue, } from '../fixtures/programs.js';
+import { Constants } from '../../src/lib/process/constants.js';
+import { getVersionHelper } from '../helpers/substrateHelper.js';
+import { ZodError } from 'zod';
+import { DisableError, ProgramError, VersionError } from '../../src/lib/types/error.js';
+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 };
+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({
+                    name: 'existing-process-test',
+                    version: 1,
+                    program: simple2,
+                }, false, polkadotOptions);
+                const process2Name = 'process-to-be-created';
+                const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
+                const newProcesses = yield loadProcesses({
+                    options: polkadotOptions,
+                    data: multiple('existing-process-test', 1, process2Name, process2BumpedV),
+                });
+                if (newProcesses.type !== 'ok') {
+                    expect.fail('Expected new process creation to succeed');
+                }
+                expect(newProcesses.result['existing-process-test'].type).to.equal('ok');
+                expect(newProcesses.result['existing-process-test']).to.deep.contain({
+                    message: 'Skipping: process existing-process-test is already created.',
+                    result: {
+                        name: 'existing-process-test',
+                        version: 1,
+                        status: 'Enabled',
+                    },
+                });
+                const process2Result = newProcesses.result[process2Name];
+                if (process2Result.type !== 'ok') {
+                    expect.fail('Expected process create for process2 to succeed');
+                }
+                expect(process2Result.message).to.deep.equal('Transaction for new process process-to-be-created has been successfully submitted');
+                expect(process2Result.result).to.deep.contain({
+                    version: process2BumpedV,
+                    status: 'Enabled',
+                });
+            }));
+            it('creates multiple processes', () => __awaiter(void 0, void 0, void 0, function* () {
+                const process1Name = 'process-1';
+                const process1BumpedV = (yield getVersionHelper(process1Name)) + 1;
+                const process2Name = 'process-2';
+                const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
+                const newProcesses = yield loadProcesses({
+                    options: polkadotOptions,
+                    data: multiple(process1Name, process1BumpedV, process2Name, process2BumpedV),
+                });
+                if (newProcesses.type !== 'ok') {
+                    expect.fail('Expected new process creation to succeed');
+                }
+                expect(newProcesses.result[process1Name].message).to.deep.equal('Transaction for new process process-1 has been successfully submitted');
+                const process1Result = newProcesses.result[process1Name];
+                if (process1Result.type !== 'ok') {
+                    expect.fail('Expected process1 creation to succeed');
+                }
+                expect(process1Result.result).to.deep.contain({
+                    version: process1BumpedV,
+                    status: 'Enabled',
+                });
+                const process2Result = newProcesses.result[process2Name];
+                if (process2Result.type !== 'ok') {
+                    expect.fail('Expected process2 creation to succeed');
+                }
+                expect(process2Result.message).to.deep.equal('Transaction for new process process-2 has been successfully submitted');
+                expect(process2Result.result).to.deep.contain({
+                    version: process2BumpedV,
+                    status: 'Enabled',
+                });
+            }));
+            it('loads and skips multiple processes using number values', () => __awaiter(void 0, void 0, void 0, function* () {
+                yield loadProcesses({ options: polkadotOptions, data: JSON.stringify(processesExample) });
+                const res = yield loadProcesses({ options: polkadotOptions, data: JSON.stringify(processesExample) });
+                if (res.type !== 'ok') {
+                    expect.fail('Expected process create to succeed');
+                }
+                const process1Result = res.result['test-program-create'];
+                const process2Result = res.result['test-program-propose'];
+                const process3Result = res.result['test-program-strings-and-numbers'];
+                if (process1Result.type !== 'ok') {
+                    expect.fail('Expected test-program-create to be already created and succeed');
+                }
+                if (process2Result.type !== 'ok') {
+                    expect.fail('Expected test-program-propose to be already created and succeed');
+                }
+                if (process2Result.type !== 'ok') {
+                    expect.fail('Expected test-program-strings-and-numbers to be already created and succeed');
+                }
+                expect(process1Result.message).to.equal('Skipping: process test-program-create is already created.');
+                expect(process2Result.message).to.equal('Skipping: process test-program-propose is already created.');
+                expect(process3Result.message).to.equal('Skipping: process test-program-strings-and-numbers is already created.');
+            })).timeout(60000);
+        });
+        it('creates then disables a process', () => __awaiter(void 0, void 0, void 0, function* () {
+            const processName = '0';
+            const currentVersion = yield getVersionHelper(processName);
+            const bumpedVersion = currentVersion + 1;
+            const newProcess = yield createProcess({ name: processName, version: bumpedVersion, program: simple }, false, polkadotOptions);
+            if (newProcess.type !== 'ok') {
+                expect.fail('Expected process creation to succeed');
+            }
+            expect(newProcess.result).to.deep.equal({
+                name: processName,
+                version: bumpedVersion,
+                status: 'Enabled',
+            });
+            const disabledProcess = yield disableProcess(processName, bumpedVersion, false, polkadotOptions);
+            if (disabledProcess.type !== 'ok') {
+                expect.fail('Expected process disable to succeed');
+            }
+            expect(disabledProcess.message).to.equal('Process has been disabled');
+            expect(disabledProcess.result).to.deep.equal({
+                name: processName,
+                version: bumpedVersion,
+                status: 'Disabled',
+            });
+        }));
+        it('does not create process if dry run', () => __awaiter(void 0, void 0, void 0, function* () {
+            const processName = '0';
+            const currentVersion = yield getVersionHelper(processName);
+            const bumpedVersion = currentVersion + 1;
+            const newProcess = yield createProcess({ name: processName, version: bumpedVersion, program: validAllRestrictions }, true, polkadotOptions);
+            if (newProcess.type !== 'ok') {
+                expect.fail('Expected process create to succeed');
+            }
+            expect(newProcess.message).to.equal('Dry run: transaction has not been created');
+            expect(newProcess.result).to.deep.equal({
+                name: processName,
+                version: bumpedVersion,
+                status: 'Enabled (dry-run)',
+            });
+        }));
+        it('does not disable process if dry run', () => __awaiter(void 0, void 0, void 0, function* () {
+            const processName = '0';
+            const currentVersion = yield getVersionHelper(processName);
+            const bumpedVersion = currentVersion + 1;
+            const newProcess = yield createProcess({ 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') {
+                expect.fail('Expected disable process to succeed');
+            }
+            expect(disabledProcess.result).to.deep.contain({
+                name: processName,
+                status: 'Disabled (dry-run)',
+            });
+            expect(disabledProcess).to.deep.contain({
+                message: `This will DISABLE the following process ${processName}`,
+            });
+        }));
+        // it('returns a list of raw processes when with --verbose flag', () => {
+        it('returns a list of processes', () => __awaiter(void 0, void 0, void 0, function* () {
+            const res = yield getAll(polkadotOptions);
+            expect(res).to.be.an('array');
+            expect(res[0])
+                .to.be.an('object')
+                .that.has.keys(['name', 'createdAtHash', 'initialU8aLength', 'program', 'status', 'version']);
+        }));
+    });
+    describe('Sad path', () => {
+        const validProcessName = '0';
+        let validVersionNumber;
+        before(() => __awaiter(void 0, void 0, void 0, function* () {
+            const currentVersion = yield getVersionHelper(validProcessName);
+            validVersionNumber = currentVersion + 1;
+        }));
+        describe('If process already exists', () => {
+            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);
+                    const process2Name = 'should-create-1';
+                    const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
+                    const res = yield loadProcesses({
+                        options: polkadotOptions,
+                        data: multiple('existing-length', 1, process2Name, process2BumpedV),
+                    });
+                    if (res.type !== 'ok') {
+                        expect.fail('Expected overall create to succeed');
+                    }
+                    const failResult = res.result['existing-length'];
+                    if (failResult.type !== 'error') {
+                        expect.fail('Expected existing-length creation to fail');
+                    }
+                    expect(failResult.message).to.equal('existing: programs are different lengths');
+                    const process2Res = res.result[process2Name];
+                    if (process2Res.type !== 'ok') {
+                        expect.fail(`Expected ${process2Name} creation to succeed`);
+                    }
+                    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);
+                    const process2Name = 'should-create-2';
+                    const process2BumpedV = (yield getVersionHelper(process2Name)) + 1;
+                    const res = yield loadProcesses({
+                        options: polkadotOptions,
+                        data: multiple('existing-steps', 1, process2Name, process2BumpedV),
+                    });
+                    // TODO: should this fail
+                    if (res.type !== 'ok') {
+                        expect.fail('Expected overall process create to succeed');
+                    }
+                    expect(res.result['existing-steps'].message).to.equal('existing: program steps did not match');
+                    expect(res.result[process2Name].message).to.equal('Transaction for new process should-create-2 has been successfully submitted');
+                }));
+            });
+            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);
+                if (res.type !== 'error') {
+                    expect.fail('Expected program create with different lengths to fail');
+                }
+                expect(res.message).to.equal('existing: programs are different lengths');
+                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);
+                if (res.type !== 'error') {
+                    expect.fail('Expected program create with different lengths to fail');
+                }
+                expect(res.message).to.equal('existing: program steps did not match');
+                expect(res.error).to.instanceOf(ProgramError);
+                const error = res.error;
+                expect(error.process).to.deep.contain({
+                    name: 'existing-steps-single',
+                    version: 1,
+                    status: 'Enabled',
+                });
+            }));
+        });
+        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);
+            if (res.type !== 'error') {
+                expect.fail('Expected process create to fail');
+            }
+            expect(res.error).to.be.instanceOf(ProgramError);
+            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({
+                name: validProcessName,
+                version: validVersionNumber,
+                program: invalidRestrictionKey,
+            }, false, polkadotOptions);
+            if (res.type !== 'error') {
+                expect.fail('Expected process create to fail');
+            }
+            expect(res.error).to.be.instanceOf(ZodError);
+            const zError = res.error;
+            expect(zError.issues[0]).to.deep.contain({
+                code: 'invalid_union',
+                message: 'Invalid input',
+            });
+        }));
+        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);
+            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);
+            if (res.type !== 'error') {
+                expect.fail('Expected process create to fail');
+            }
+            expect(res.error).to.be.instanceOf(ZodError);
+        }));
+        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);
+            if (res.type !== 'error') {
+                expect.fail('Expected process create to fail');
+            }
+            expect(res.message).to.equal(`Process version ${validVersionNumber - 2} is invalid. If you are trying to create a new version of process ${validProcessName} version should be ${validVersionNumber}`);
+            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);
+            if (res.type !== 'error') {
+                expect.fail('Expected process create to fail');
+            }
+            expect(res.message).to.equal(`Process version ${validVersionNumber + 1} is invalid. If you are trying to create a new version of process ${validProcessName} version should be ${validVersionNumber}`);
+            expect(res.error).to.be.instanceOf(VersionError);
+        }));
+        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);
+            if (res.type !== 'error') {
+                expect.fail('Expected process create to fail');
+            }
+            expect(res.error).to.be.instanceOf(ZodError);
+        }));
+        it('fails to disable process that does not exist', () => __awaiter(void 0, void 0, void 0, function* () {
+            return assert.isRejected(disableProcess('incorrectProcessName', 1, false, polkadotOptions), 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);
+            expect(newProcess.type).to.equal('ok');
+            const firstDisable = yield disableProcess(validProcessName, validVersionNumber, false, polkadotOptions);
+            expect(firstDisable.type).to.equal('ok');
+            return assert.isRejected(disableProcess(validProcessName, validVersionNumber, false, polkadotOptions), DisableError);
+        }));
+    });
+});

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@digicatapult/sqnc-process-management",
+  "version": "2.2.0",
+  "description": "SQNC Process Management Flow",
+  "main": "./lib/index.js",
+  "bin": {
+    "process-management": "./build/src/index.js"
+  },
+  "type": "module",
+  "scripts": {
+    "start": "node --loader ts-node/esm src/index.ts",
+    "local": "npm i -g && process-management",
+    "dev": "nodemon --watch 'src/**/*.ts' --exec node --loader ts-node/esm src/index.ts",
+    "lint": "eslint . --ext .ts",
+    "build": "tsc --build",
+    "depcheck": "depcheck",
+    "test": "ts-mocha --config ./tests/mocharc.json -n  loader=ts-node/esm -p tsconfig.json tests/**/*.test.ts --exit",
+    "test:unit": "ts-mocha --config ./tests/mocharc.json -n loader=ts-node/esm -p tsconfig.json src/**/*.test.ts --exit",
+    "prettier": "npx prettier --write ."
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/digicatapult/sqnc-process-management.git"
+  },
+  "files": [
+    "/build"
+  ],
+  "engines": {
+    "node": ">=20.x.x",
+    "npm": ">=10.x.x"
+  },
+  "author": "Digital Catapult",
+  "license": "Apache-2.0",
+  "bugs": {
+    "url": "https://github.com/digicatapult/sqnc-process-management/issues"
+  },
+  "homepage": "https://github.com/digicatapult/sqnc-process-management#readme",
+  "devDependencies": {
+    "@types/chai": "^4.3.11",
+    "@types/chai-as-promised": "^7.1.8",
+    "@types/mocha": "^10.0.6",
+    "@types/node": "^18.19.4",
+    "@typescript-eslint/eslint-plugin": "^6.17.0",
+    "@typescript-eslint/parser": "^6.17.0",
+    "chai": "^4.3.10",
+    "chai-as-promised": "^7.1.1",
+    "depcheck": "^1.4.7",
+    "eslint": "^8.56.0",
+    "eslint-config-prettier": "^9.1.0",
+    "eslint-plugin-prettier": "^5.1.2",
+    "mocha": "^10.2.0",
+    "nodemon": "^3.0.2",
+    "prettier": "^3.1.1",
+    "ts-mocha": "^10.0.0",
+    "ts-node": "^10.9.2"
+  },
+  "dependencies": {
+    "@polkadot/api": "^10.11.2",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "typescript": "^5.3.3",
+    "zod": "^3.22.4"
+  }
+}