@nosana/node 1.0.0-rc

package/dist/output-formatter/__tests__/OutputFormatterFactory.spec.js

@@ -0,0 +1,26 @@
+import '../__mocks__/outputFormatter.mock.js';
+import { JsonOutputFormatter } from '../json/JsonOutputFormatter.js';
+import { OutputFormatter } from '../OutputFormatter.js';
+import { OutputFormatterFactory } from '../OutputFormatterFactory.js';
+import { TextOutputFormatter } from '../text/TextOutputFormatter.js';
+beforeEach(() => {
+    vi.clearAllMocks();
+    vi.resetModules();
+});
+describe('OutputFormatterFactory', () => {
+    it('should create a JSON formatter', () => {
+        const formatter = OutputFormatterFactory.createFormatter('json');
+        expect(formatter).toBeInstanceOf(OutputFormatter);
+        expect(JsonOutputFormatter).toHaveBeenCalled();
+    });
+    it('should create a Text formatter by default', () => {
+        const formatter = OutputFormatterFactory.createFormatter('text');
+        expect(formatter).toBeInstanceOf(OutputFormatter);
+        expect(TextOutputFormatter).toHaveBeenCalled();
+    });
+    it('should create a Text formatter for unknown format', () => {
+        const formatter = OutputFormatterFactory.createFormatter('unknown');
+        expect(formatter).toBeInstanceOf(OutputFormatter);
+        expect(TextOutputFormatter).toHaveBeenCalled();
+    });
+});

package/dist/output-formatter/__tests__/outputFormatSelector.spec.d.ts

@@ -0,0 +1 @@
+import '../__mocks__/outputFormatter.mock.js';

package/dist/output-formatter/__tests__/outputFormatSelector.spec.js

@@ -0,0 +1,21 @@
+import '../__mocks__/outputFormatter.mock.js';
+import { JsonOutputFormatter } from '../json/JsonOutputFormatter.js';
+import { outputFormatSelector } from '../outputFormatSelector.js';
+describe('outputFormatSelector', () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.resetModules();
+        outputFormatSelector.instance = null;
+    });
+    it('should return the same instance for multiple calls with JSON format', () => {
+        const formatter1 = outputFormatSelector('json');
+        const formatter2 = outputFormatSelector('json');
+        expect(formatter1).toBe(formatter2);
+        expect(JsonOutputFormatter).toHaveBeenCalledTimes(1);
+    });
+    it('should not create a new instance if called again with a different format', () => {
+        const formatter1 = outputFormatSelector('json');
+        const formatter2 = outputFormatSelector('text');
+        expect(formatter1).toBe(formatter2);
+    });
+});

package/dist/output-formatter/json/JsonOutputEventHandlers.d.ts

@@ -0,0 +1,8 @@
+import { OutputEventParams } from '../outputEvents.js';
+import { JsonResponseType } from './JsonOutputFormatter.js';
+type EventHandler<T extends keyof OutputEventParams> = (response: JsonResponseType, param: OutputEventParams[T]) => void;
+type OutputEventHandlers = {
+    [K in keyof OutputEventParams]: EventHandler<K>;
+};
+export declare const jsonOutputEventHandlers: OutputEventHandlers;
+export {};

package/dist/output-formatter/json/JsonOutputEventHandlers.js

@@ -0,0 +1,191 @@
+import { OUTPUT_EVENTS, } from '../outputEvents.js';
+export const jsonOutputEventHandlers = {
+    [OUTPUT_EVENTS.READ_KEYFILE]: (response, param) => {
+        response.keypair_path = param.keyfile;
+    },
+    [OUTPUT_EVENTS.EMPTY_KEYFILE]: (response, param) => {
+        response.keypair_path = param.keyfile;
+    },
+    [OUTPUT_EVENTS.CREATE_KEYFILE]: (response, param) => {
+        response.keypair_path = param.keyfile;
+    },
+    [OUTPUT_EVENTS.OUTPUT_BALANCES]: (response, param) => {
+        response.balances = {
+            SOL: `${param.sol} SOL`,
+            NOS: `${param.nos} NOS`,
+        };
+    },
+    [OUTPUT_EVENTS.OUTPUT_NETWORK]: (response, param) => {
+        response.network = param.network;
+    },
+    [OUTPUT_EVENTS.OUTPUT_WALLET]: (response, param) => {
+        response.wallet = param.publicKey;
+    },
+    [OUTPUT_EVENTS.OUTPUT_IPFS_UPLOADED]: (response, param) => {
+        response.ipfs_uploaded = param.ipfsHash;
+    },
+    [OUTPUT_EVENTS.OUTPUT_SERVICE_URL]: (response, param) => {
+        response.service_url = param.url.split(',');
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_SERVICE_URL]: (response, param) => {
+        response.service_url = param.url.split(',');
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_INVALID]: (response) => {
+        response.isError = true;
+        response.msg = 'Invalid Job';
+        response.errors = ['Invalid Job Entered'];
+        response.service_url = undefined;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_EXPIRED]: (response, param) => {
+        response.isError = true;
+        response.msg = 'Job expired';
+        response.errors = [
+            `Job exposed URL is expired since Job has been ${param.state}`,
+        ];
+        response.service_url = undefined;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_NOT_READY]: (response) => {
+        response.isError = true;
+        response.msg = 'Job exposed URL is not ready yet';
+        response.errors = [`Job exposed URL is not ready yet`];
+        response.service_url = undefined;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = `Failed to fetch exposed URL ${param.error.message}`;
+        response.errors = [param.error];
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_PRIVATE_URL_MESSAGE]: (response, param) => {
+        response.service_url = undefined;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL]: (response, param) => {
+        response.job_url = param.job_url;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_URL]: (response, param) => {
+        response.json_flow_url = param.json_flow_url;
+    },
+    [OUTPUT_EVENTS.OUTPUT_MARKET_URL]: (response, param) => {
+        response.market_url = param.market_url;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_PRICE]: (response, param) => {
+        response.price = `${param.price} NOS/s`;
+    },
+    [OUTPUT_EVENTS.OUTPUT_TOTAL_COST]: (response, param) => {
+        response.total_cost = `${param.cost} NOS/s`;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_STATUS]: (response, param) => {
+        response.status = param.status;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTER_AUTH_TOKEN]: (response, param) => {
+        response.authorization = param;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTING]: (response, param) => {
+        response.job_posting = {
+            market_id: param.market_address,
+            price_per_second: `${param.price} NOS/s`,
+            total_cost: `${param.total} NOS`,
+        };
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_TX]: (response, param) => {
+        response.job_posting = {
+            transaction_id: param.tx,
+            ...response.job_posting,
+        };
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_VALIDATION_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = 'Job Definition validation failed';
+        response.errors = param.error;
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = 'Failed to fetch market';
+        response.errors = [param.error];
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = "Couldn't post job";
+        response.errors = [param.error];
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_SOL_BALANCE_LOW_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = `Minimum of '0.005' SOL needed: SOL available ${param.sol}`;
+        response.errors = [
+            `Minimum of '0.005' SOL needed: SOL available ${param.sol}`,
+        ];
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_NOS_BALANCE_LOW_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = `Not enough NOS: NOS available ${param.nosBalance}, NOS needed: ${param.nosNeeded}`;
+        response.errors = [
+            `Not enough NOS: NOS available ${param.nosBalance}, NOS needed: ${param.nosNeeded}`,
+        ];
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_AIRDROP_REQUEST_FAILED_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = 'Couldnt airdrop tokens to your address';
+        response.errors = ['Couldnt airdrop tokens to your address'];
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JOB_NOT_FOUND]: (response, param) => {
+        response.isError = true;
+        response.msg = 'Could not retrieve job';
+        response.errors = [param.error];
+    },
+    [OUTPUT_EVENTS.OUTPUT_CANNOT_LOG_RESULT]: (response) => {
+        response.isError = true;
+        response.msg = 'Cannot log results';
+        response.errors = ['Cannot log results'];
+    },
+    [OUTPUT_EVENTS.OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = 'artifact support coming soon!';
+        response.errors = ['artifact support coming soon!'];
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR]: (response, param) => {
+        response.isError = true;
+        response.msg = `type ${param.type} not supported yet`;
+        response.errors = [`type ${param.type} not supported yet`];
+        throw response;
+    },
+    [OUTPUT_EVENTS.OUTPUT_NODE_URL]: (response, param) => {
+        response.node_url = param.url;
+    },
+    [OUTPUT_EVENTS.OUTPUT_DURATION]: (response, param) => {
+        response.duration = param.duration;
+    },
+    [OUTPUT_EVENTS.OUTPUT_START_TIME]: (response, param) => {
+        response.start_time = param.date;
+    },
+    [OUTPUT_EVENTS.OUTPUT_RESULT_URL]: (response, param) => {
+        response.result_url = param.url;
+    },
+    [OUTPUT_EVENTS.OUTPUT_RETRIVE_JOB_COMMAND]: (response, param) => { },
+    [OUTPUT_EVENTS.OUTPUT_HEADER_LOGO]: (response, param) => { },
+    [OUTPUT_EVENTS.OUTPUT_JOB_EXECUTION]: (response, param) => {
+        let execution = {};
+        execution.logs = [];
+        for (const log of param.opState.logs) {
+            const sanitizedLog = log.log ?? '';
+            execution.logs.push(sanitizedLog);
+        }
+        execution.operationId = param.opState.operationId;
+        execution.duration =
+            (param.opState.endTime - param.opState.startTime) / 1000;
+        if (param.opState.status) {
+            execution.exitCode = param.opState.exitCode;
+            execution.status = param.opState.status;
+        }
+        if (!response.executions) {
+            response.executions = [];
+        }
+        response.executions.push(execution);
+    },
+};

package/dist/output-formatter/json/JsonOutputFormatter.d.ts

@@ -0,0 +1,47 @@
+import { IValidation } from 'typia';
+import { OutputEvent, OutputEventParams } from '../outputEvents.js';
+import { OutputFormatterAdapter } from '../OutputFormatter.js';
+export declare class JsonOutputFormatter implements OutputFormatterAdapter {
+    private response;
+    finalize(): void;
+    output<T extends OutputEvent>(event: T, param: OutputEventParams[T]): void;
+}
+export interface JsonResponseType {
+    isError?: boolean;
+    msg?: string;
+    keypair_path?: string;
+    balances?: {
+        SOL: string;
+        NOS: string;
+    };
+    network?: string;
+    wallet?: string;
+    ipfs_uploaded?: string;
+    service_url?: string[];
+    job_url?: string;
+    json_flow_url?: string;
+    market_url?: string;
+    price?: string;
+    total_cost?: string;
+    status?: string;
+    job_posting?: {
+        transaction_id?: string;
+        market_id?: string;
+        price_per_second?: string;
+        total_cost?: string;
+    };
+    transaction_id?: string;
+    errors?: string[] | Error[] | IValidation.IError[];
+    node_url?: string;
+    duration?: number;
+    start_time?: Date;
+    result_url?: string;
+    executions?: Array<{
+        operationId: string | null;
+        duration: number;
+        logs: string[];
+        exitCode?: number | null;
+        status?: string;
+    }>;
+    authorization?: string;
+}

package/dist/output-formatter/json/JsonOutputFormatter.js

@@ -0,0 +1,12 @@
+import { jsonOutputEventHandlers } from './JsonOutputEventHandlers.js';
+export class JsonOutputFormatter {
+    constructor() {
+        this.response = {};
+    }
+    finalize() {
+        console.log(`${JSON.stringify(this.response)}`);
+    }
+    output(event, param) {
+        jsonOutputEventHandlers[event](this.response, param);
+    }
+}

package/dist/output-formatter/json/__tests__/JsonOutputFormatter.spec.d.ts

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

package/dist/output-formatter/json/__tests__/JsonOutputFormatter.spec.js

@@ -0,0 +1,36 @@
+import outputEventsMock from '../../__mocks__/outputEvents.mock.js';
+import { JsonOutputFormatter } from '../JsonOutputFormatter.js';
+import { OUTPUT_EVENTS } from '../../outputEvents.js';
+import { jsonOutputEventHandlers } from '../JsonOutputEventHandlers.js';
+vi.mock('../JsonOutputEventHandlers', () => {
+    return {
+        jsonOutputEventHandlers: outputEventsMock,
+    };
+});
+describe('JsonOutputFormatter', () => {
+    let formatter;
+    beforeEach(() => {
+        formatter = new JsonOutputFormatter();
+        vi.clearAllMocks();
+    });
+    it('should handle events and call the appropriate event handlers', () => {
+        const param = { keyfile: 'test-keyfile' };
+        const event = OUTPUT_EVENTS.READ_KEYFILE;
+        formatter.output(event, param);
+        expect(jsonOutputEventHandlers.READ_KEYFILE).toHaveBeenCalledWith(formatter['response'], param);
+    });
+    it('should set isError to undefined initially', () => {
+        const param = { keyfile: 'test-keyfile' };
+        const event = OUTPUT_EVENTS.READ_KEYFILE;
+        formatter.output(event, param);
+        expect(formatter['response'].isError).toBe(undefined);
+    });
+    it('should finalize and print JSON response', () => {
+        console.log = vi.fn();
+        const param = { keyfile: 'test-keyfile' };
+        const event = OUTPUT_EVENTS.READ_KEYFILE;
+        formatter.output(event, param);
+        formatter.finalize();
+        expect(console.log).toHaveBeenCalledWith(JSON.stringify(formatter['response'], null, 2));
+    });
+});

package/dist/output-formatter/outputEvents.d.ts

@@ -0,0 +1,213 @@
+import { IValidation } from 'typia';
+import { OpState } from '@nosana/sdk';
+/**
+ * Adding a new Output/Throw Event
+ *
+ * Step 1: Add the new event name under OUTPUT_EVENTS
+ * Example:
+ * OUTPUT_NEW_EVENT: 'OUTPUT_NEW_EVENT',
+ *
+ * Step 2: Define parameter types for the new event
+ * Example:
+ * export type NewEventParam = { data: string };
+ *
+ * Step 3: Add the new event to OutputEventParams
+ * Example:
+ * [OUTPUT_EVENTS.OUTPUT_NEW_EVENT]: NewEventParam;
+ *
+ * Step 4: Make implementation for this new event on all OutputFormatterAdapter Handlers, Failure to do this will cause errors
+ * Example:
+ * [OUTPUT_EVENTS.OUTPUT_NEW_EVENT]: (param: OutputEventParams) => {},
+ *
+ * Step 5: also add the event to __mock__ so the tests can pass
+ */
+export declare const OUTPUT_EVENTS: {
+    readonly READ_KEYFILE: "READ_KEYFILE";
+    readonly CREATE_KEYFILE: "CREATE_KEYFILE";
+    readonly EMPTY_KEYFILE: "EMPTY_KEYFILE";
+    readonly OUTPUT_JOB_URL: "OUTPUT_JOB_URL";
+    readonly OUTPUT_JSON_FLOW_URL: "OUTPUT_JSON_FLOW_URL";
+    readonly OUTPUT_MARKET_URL: "OUTPUT_MARKET_URL";
+    readonly OUTPUT_JOB_PRICE: "OUTPUT_JOB_PRICE";
+    readonly OUTPUT_JOB_STATUS: "OUTPUT_JOB_STATUS";
+    readonly OUTPUT_JOB_POSTED_ERROR: "OUTPUT_JOB_POSTED_ERROR";
+    readonly OUTPUT_JOB_POSTING: "OUTPUT_JOB_POSTING";
+    readonly OUTPUT_NETWORK: "OUTPUT_NETWORK";
+    readonly OUTPUT_BALANCES: "OUTPUT_BALANCES";
+    readonly OUTPUT_WALLET: "OUTPUT_WALLET";
+    readonly OUTPUT_IPFS_UPLOADED: "OUTPUT_IPFS_UPLOADED";
+    readonly OUTPUT_SERVICE_URL: "OUTPUT_SERVICE_URL";
+    readonly OUTPUT_PRIVATE_URL_MESSAGE: "OUTPUT_PRIVATE_URL_MESSAGE";
+    readonly OUTPUT_JOB_NOT_FOUND: "OUTPUT_JOB_NOT_FOUND";
+    readonly OUTPUT_CANNOT_LOG_RESULT: "OUTPUT_CANNOT_LOG_RESULT";
+    readonly OUTPUT_JOB_VALIDATION_ERROR: "OUTPUT_JOB_VALIDATION_ERROR";
+    readonly OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR: "OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR";
+    readonly OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR: "OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR";
+    readonly OUTPUT_SOL_BALANCE_LOW_ERROR: "OUTPUT_SOL_BALANCE_LOW_ERROR";
+    readonly OUTPUT_NOS_BALANCE_LOW_ERROR: "OUTPUT_NOS_BALANCE_LOW_ERROR";
+    readonly OUTPUT_AIRDROP_REQUEST_FAILED_ERROR: "OUTPUT_AIRDROP_REQUEST_FAILED_ERROR";
+    readonly OUTPUT_JOB_POSTED_TX: "OUTPUT_JOB_POSTED_TX";
+    readonly OUTPUT_NODE_URL: "OUTPUT_NODE_URL";
+    readonly OUTPUT_DURATION: "OUTPUT_DURATION";
+    readonly OUTPUT_START_TIME: "OUTPUT_START_TIME";
+    readonly OUTPUT_RESULT_URL: "OUTPUT_RESULT_URL";
+    readonly OUTPUT_JOB_EXECUTION: "OUTPUT_JOB_EXECUTION";
+    readonly OUTPUT_TOTAL_COST: "OUTPUT_TOTAL_COST";
+    readonly OUTPUT_RETRIVE_JOB_COMMAND: "OUTPUT_RETRIVE_JOB_COMMAND";
+    readonly OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR: "OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR";
+    readonly OUTPUT_HEADER_LOGO: "OUTPUT_HEADER_LOGO";
+    readonly OUTPUT_JOB_URL_ERROR: "OUTPUT_JOB_URL_ERROR";
+    readonly OUTPUT_JOB_URL_EXPIRED: "OUTPUT_JOB_URL_EXPIRED";
+    readonly OUTPUT_JOB_URL_NOT_READY: "OUTPUT_JOB_URL_NOT_READY";
+    readonly OUTPUT_JOB_INVALID: "OUTPUT_JOB_INVALID";
+    readonly OUTPUT_JOB_SERVICE_URL: "OUTPUT_JOB_SERVICE_URL";
+    readonly OUTPUT_JOB_POSTER_AUTH_TOKEN: "OUTPUT_JOB_POSTER_AUTH_TOKEN";
+};
+export type OutputEvent = (typeof OUTPUT_EVENTS)[keyof typeof OUTPUT_EVENTS];
+export type JobServiceUrlErrorParam = {
+    error: Error;
+};
+export type JobServiceUrlExpiredParam = {
+    state: string;
+};
+export type JobServiceUrlNotReadyParam = {};
+export type JobServiceUrlInvalidParam = {};
+export type JobServiceUrlParam = {
+    url: string;
+};
+export type KeyfileParam = {
+    keyfile: string;
+};
+export type BalanceParam = {
+    sol: number;
+    nos: string;
+};
+export type NetworkParam = {
+    network: string;
+};
+export type WalletParam = {
+    publicKey: string;
+};
+export type IpfsParam = {
+    ipfsHash: string;
+};
+export type ServiceUrlParam = {
+    url: string;
+};
+export type CommandParam = {
+    command: string;
+};
+export type JobUrlParam = {
+    job_url: string;
+};
+export type JsonFlowUrlParam = {
+    json_flow_url: string;
+};
+export type MarketUrlParam = {
+    market_url: string;
+};
+export type JobPriceParam = {
+    price: string;
+};
+export type JobStatusParam = {
+    status: string;
+};
+export type JobPostingParam = {
+    market_address: string;
+    price: number;
+    total: string;
+};
+export type JobPosterAuthToken = string;
+export type TotalCostParam = {
+    cost: number;
+};
+export type TxParam = {
+    tx: string;
+};
+export type ValidationErrorParam = {
+    error: IValidation.IError[];
+};
+export type ErrorParam = {
+    error: Error;
+};
+export type BalanceLowParam = {
+    sol: string;
+};
+export type NosBalanceLowParam = {
+    nosBalance: string;
+    nosNeeded: string;
+};
+export type JobPostedErrorParam = {
+    error: Error;
+};
+export type JsonFlowTypeErrorParam = {
+    type: string;
+};
+export type JobNotFoundErrorParam = {
+    error: Error;
+};
+export type CannotLogResultParam = {};
+export type OutputHeaderLogoParam = {
+    text: string;
+};
+export type NodeUrlParam = {
+    url: string;
+};
+export type DurationParam = {
+    duration: number;
+};
+export type StartTimeParam = {
+    date: Date;
+};
+export type ResultUrlParam = {
+    url: string;
+};
+export type RetriveJobCommandParam = {
+    job: string;
+    network: string;
+};
+export type JobExecutionParam = {
+    opState: OpState;
+};
+export type OutputEventParams = {
+    [OUTPUT_EVENTS.READ_KEYFILE]: KeyfileParam;
+    [OUTPUT_EVENTS.EMPTY_KEYFILE]: KeyfileParam;
+    [OUTPUT_EVENTS.CREATE_KEYFILE]: KeyfileParam;
+    [OUTPUT_EVENTS.OUTPUT_BALANCES]: BalanceParam;
+    [OUTPUT_EVENTS.OUTPUT_NETWORK]: NetworkParam;
+    [OUTPUT_EVENTS.OUTPUT_WALLET]: WalletParam;
+    [OUTPUT_EVENTS.OUTPUT_IPFS_UPLOADED]: IpfsParam;
+    [OUTPUT_EVENTS.OUTPUT_SERVICE_URL]: ServiceUrlParam;
+    [OUTPUT_EVENTS.OUTPUT_PRIVATE_URL_MESSAGE]: CommandParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL]: JobUrlParam;
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_URL]: JsonFlowUrlParam;
+    [OUTPUT_EVENTS.OUTPUT_MARKET_URL]: MarketUrlParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_PRICE]: JobPriceParam;
+    [OUTPUT_EVENTS.OUTPUT_TOTAL_COST]: TotalCostParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_STATUS]: JobStatusParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTING]: JobPostingParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_TX]: TxParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_VALIDATION_ERROR]: ValidationErrorParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTED_ERROR]: JobPostedErrorParam;
+    [OUTPUT_EVENTS.OUTPUT_SOL_BALANCE_LOW_ERROR]: BalanceLowParam;
+    [OUTPUT_EVENTS.OUTPUT_NOS_BALANCE_LOW_ERROR]: NosBalanceLowParam;
+    [OUTPUT_EVENTS.OUTPUT_AIRDROP_REQUEST_FAILED_ERROR]: ErrorParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_NOT_FOUND]: JobNotFoundErrorParam;
+    [OUTPUT_EVENTS.OUTPUT_CANNOT_LOG_RESULT]: CannotLogResultParam | null;
+    [OUTPUT_EVENTS.OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR]: ErrorParam;
+    [OUTPUT_EVENTS.OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR]: JsonFlowTypeErrorParam;
+    [OUTPUT_EVENTS.OUTPUT_NODE_URL]: NodeUrlParam;
+    [OUTPUT_EVENTS.OUTPUT_DURATION]: DurationParam;
+    [OUTPUT_EVENTS.OUTPUT_START_TIME]: StartTimeParam;
+    [OUTPUT_EVENTS.OUTPUT_RESULT_URL]: ResultUrlParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_EXECUTION]: JobExecutionParam;
+    [OUTPUT_EVENTS.OUTPUT_RETRIVE_JOB_COMMAND]: RetriveJobCommandParam;
+    [OUTPUT_EVENTS.OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR]: ErrorParam;
+    [OUTPUT_EVENTS.OUTPUT_HEADER_LOGO]: OutputHeaderLogoParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_ERROR]: JobServiceUrlErrorParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_EXPIRED]: JobServiceUrlExpiredParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_URL_NOT_READY]: JobServiceUrlNotReadyParam | null;
+    [OUTPUT_EVENTS.OUTPUT_JOB_INVALID]: JobServiceUrlInvalidParam | null;
+    [OUTPUT_EVENTS.OUTPUT_JOB_SERVICE_URL]: JobServiceUrlParam;
+    [OUTPUT_EVENTS.OUTPUT_JOB_POSTER_AUTH_TOKEN]: JobPosterAuthToken;
+};

package/dist/output-formatter/outputEvents.js

@@ -0,0 +1,63 @@
+/**
+ * Adding a new Output/Throw Event
+ *
+ * Step 1: Add the new event name under OUTPUT_EVENTS
+ * Example:
+ * OUTPUT_NEW_EVENT: 'OUTPUT_NEW_EVENT',
+ *
+ * Step 2: Define parameter types for the new event
+ * Example:
+ * export type NewEventParam = { data: string };
+ *
+ * Step 3: Add the new event to OutputEventParams
+ * Example:
+ * [OUTPUT_EVENTS.OUTPUT_NEW_EVENT]: NewEventParam;
+ *
+ * Step 4: Make implementation for this new event on all OutputFormatterAdapter Handlers, Failure to do this will cause errors
+ * Example:
+ * [OUTPUT_EVENTS.OUTPUT_NEW_EVENT]: (param: OutputEventParams) => {},
+ *
+ * Step 5: also add the event to __mock__ so the tests can pass
+ */
+export const OUTPUT_EVENTS = {
+    READ_KEYFILE: 'READ_KEYFILE',
+    CREATE_KEYFILE: 'CREATE_KEYFILE',
+    EMPTY_KEYFILE: 'EMPTY_KEYFILE',
+    OUTPUT_JOB_URL: 'OUTPUT_JOB_URL',
+    OUTPUT_JSON_FLOW_URL: 'OUTPUT_JSON_FLOW_URL',
+    OUTPUT_MARKET_URL: 'OUTPUT_MARKET_URL',
+    OUTPUT_JOB_PRICE: 'OUTPUT_JOB_PRICE',
+    OUTPUT_JOB_STATUS: 'OUTPUT_JOB_STATUS',
+    OUTPUT_JOB_POSTED_ERROR: 'OUTPUT_JOB_POSTED_ERROR',
+    OUTPUT_JOB_POSTING: 'OUTPUT_JOB_POSTING',
+    OUTPUT_NETWORK: 'OUTPUT_NETWORK',
+    OUTPUT_BALANCES: 'OUTPUT_BALANCES',
+    OUTPUT_WALLET: 'OUTPUT_WALLET',
+    OUTPUT_IPFS_UPLOADED: 'OUTPUT_IPFS_UPLOADED',
+    OUTPUT_SERVICE_URL: 'OUTPUT_SERVICE_URL',
+    OUTPUT_PRIVATE_URL_MESSAGE: 'OUTPUT_PRIVATE_URL_MESSAGE',
+    OUTPUT_JOB_NOT_FOUND: 'OUTPUT_JOB_NOT_FOUND',
+    OUTPUT_CANNOT_LOG_RESULT: 'OUTPUT_CANNOT_LOG_RESULT',
+    OUTPUT_JOB_VALIDATION_ERROR: 'OUTPUT_JOB_VALIDATION_ERROR',
+    OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR: 'OUTPUT_ARTIFACT_SUPPORT_INCOMING_ERROR',
+    OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR: 'OUTPUT_JSON_FLOW_TYPE_NOT_SUPPORTED_ERROR',
+    OUTPUT_SOL_BALANCE_LOW_ERROR: 'OUTPUT_SOL_BALANCE_LOW_ERROR',
+    OUTPUT_NOS_BALANCE_LOW_ERROR: 'OUTPUT_NOS_BALANCE_LOW_ERROR',
+    OUTPUT_AIRDROP_REQUEST_FAILED_ERROR: 'OUTPUT_AIRDROP_REQUEST_FAILED_ERROR',
+    OUTPUT_JOB_POSTED_TX: 'OUTPUT_JOB_POSTED_TX',
+    OUTPUT_NODE_URL: 'OUTPUT_NODE_URL',
+    OUTPUT_DURATION: 'OUTPUT_DURATION',
+    OUTPUT_START_TIME: 'OUTPUT_START_TIME',
+    OUTPUT_RESULT_URL: 'OUTPUT_RESULT_URL',
+    OUTPUT_JOB_EXECUTION: 'OUTPUT_JOB_EXECUTION',
+    OUTPUT_TOTAL_COST: 'OUTPUT_TOTAL_COST',
+    OUTPUT_RETRIVE_JOB_COMMAND: 'OUTPUT_RETRIVE_JOB_COMMAND',
+    OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR: 'OUTPUT_FAILED_TO_FETCH_MARKETS_ERROR',
+    OUTPUT_HEADER_LOGO: 'OUTPUT_HEADER_LOGO',
+    OUTPUT_JOB_URL_ERROR: 'OUTPUT_JOB_URL_ERROR',
+    OUTPUT_JOB_URL_EXPIRED: 'OUTPUT_JOB_URL_EXPIRED',
+    OUTPUT_JOB_URL_NOT_READY: 'OUTPUT_JOB_URL_NOT_READY',
+    OUTPUT_JOB_INVALID: 'OUTPUT_JOB_INVALID',
+    OUTPUT_JOB_SERVICE_URL: 'OUTPUT_JOB_SERVICE_URL',
+    OUTPUT_JOB_POSTER_AUTH_TOKEN: 'OUTPUT_JOB_POSTER_AUTH_TOKEN',
+};

package/dist/output-formatter/outputFormatArgumentParser.d.ts

@@ -0,0 +1 @@
+export declare const outputFormatArgumentParser: (args: string[]) => string;

package/dist/output-formatter/outputFormatArgumentParser.js

@@ -0,0 +1,10 @@
+export const outputFormatArgumentParser = (args) => {
+    if (args.includes('--verbose')) {
+        return 'verbose:text';
+    }
+    const formatIndex = args.indexOf('--format');
+    if (formatIndex !== -1 && formatIndex + 1 < args.length) {
+        return args[formatIndex + 1];
+    }
+    return 'text';
+};

package/dist/output-formatter/outputFormatSelector.d.ts

@@ -0,0 +1,15 @@
+import { OutputFormatter } from './OutputFormatter.js';
+/**
+ * Singleton pattern to ensure a single instance of OutputFormatter.
+ * This function selects the appropriate formatter (JSON or Text) based on the input.
+ * @param {string} format - Options indicating whether to use JSON formatting. If text, uses Text formatting.
+ * @returns {OutputFormatter} - The singleton instance of OutputFormatter.
+ *
+ * Usage:
+ *
+ * ```typescript
+ * // To get a Text formatter
+ * const textFormatter = outputFormatSelector();
+ * ```
+ */
+export declare const outputFormatSelector: (format: string) => OutputFormatter;