@toolproof-npm/shared 0.1.98 → 0.1.100

package/dist/_lib/utils/stepCreation.d.ts

@@ -0,0 +1,8 @@
+import type { WorkStepJson, BranchStepJson, WhileStepJson, ForStepJson, JobJson } from '@toolproof-npm/schema';
+export declare const createWorkStepFromJob: (job: JobJson) => Promise<WorkStepJson>;
+export declare const createLoopStepFromJob: (whatJob: JobJson, whenJob: JobJson, kind: "for" | "while") => Promise<ForStepJson | WhileStepJson>;
+export declare const createBranchStepFromJobPairs: (cases: {
+    whatJob: JobJson;
+    whenJob: JobJson;
+}[]) => Promise<BranchStepJson>;
+export declare const cloneForStep: (forStep: ForStepJson) => Promise<ForStepJson>;

package/dist/_lib/utils/stepCreation.js

@@ -0,0 +1,126 @@
+import { CONSTANTS } from '@toolproof-npm/shared/constants';
+import { getNewIdentity } from '@toolproof-npm/shared/server';
+// DOC: Helper function to construct an Execution object from a job
+const createExecutionFromJob = async (job, executionRef) => {
+    const execIdentity = executionRef ?? await getNewIdentity(CONSTANTS.TERMINALS.execution);
+    const inputBindingMap = {};
+    const inputs = job.roles.inputMap;
+    await Promise.all(Object.keys(inputs).map(async (resourceRoleRef) => {
+        const resourceId = await getNewIdentity(CONSTANTS.TERMINALS.resource);
+        inputBindingMap[resourceRoleRef] = resourceId;
+    }));
+    const outputBindingMap = {};
+    const outputs = job.roles.outputMap;
+    await Promise.all(Object.keys(outputs).map(async (resourceRoleRef) => {
+        const resourceId = await getNewIdentity(CONSTANTS.TERMINALS.resource);
+        outputBindingMap[resourceRoleRef] = resourceId;
+    }));
+    return {
+        identity: execIdentity,
+        jobRef: job.identity,
+        roleBindings: {
+            inputBindingMap,
+            outputBindingMap
+        }
+    };
+};
+// DOC: Helper function to construct a WorkStep object from an jobMetaJson (does not append to statelessStrategy.steps)
+export const createWorkStepFromJob = async (job) => {
+    const workStepIdentity = await getNewIdentity(CONSTANTS.STEPS.work);
+    const executionRef = workStepIdentity.replace(CONSTANTS.STEPS.work.toUpperCase(), 'execution'.toUpperCase()); // ATTENTION: use function
+    const execution = await createExecutionFromJob(job, executionRef);
+    const newWorkStep = {
+        identity: workStepIdentity,
+        kind: CONSTANTS.STEPS.work,
+        execution
+    };
+    return newWorkStep;
+};
+// DOC: Helper function to construct a ForStep or WhileStep from a job
+export const createLoopStepFromJob = async (whatJob, whenJob, kind) => {
+    // Create the "what" WorkStep from the provided job
+    const whatWorkStep = await createWorkStepFromJob(whatJob);
+    // Create the "when" WorkStep from the LessThan job
+    const whenWorkStep = await createWorkStepFromJob(whenJob);
+    // Generate loop step identity based on kind
+    const stepIdentity = (kind === 'for'
+        ? await getNewIdentity(CONSTANTS.STEPS.for)
+        : await getNewIdentity(CONSTANTS.STEPS.while));
+    // Assemble the loop step
+    return {
+        identity: stepIdentity,
+        kind,
+        case: {
+            what: whatWorkStep,
+            when: whenWorkStep
+        }
+    };
+};
+// DOC: Helper function to construct a BranchStep from an array of job pairs
+export const createBranchStepFromJobPairs = async (cases) => {
+    // Generate branch step identity
+    const branchStepIdentity = await getNewIdentity(CONSTANTS.STEPS.branch);
+    // Create WorkSteps for each case (what and when pair)
+    const casesWithWorkSteps = await Promise.all(cases.map(async ({ whatJob, whenJob }) => {
+        const whatWorkStep = await createWorkStepFromJob(whatJob);
+        const whenWorkStep = await createWorkStepFromJob(whenJob);
+        return {
+            what: whatWorkStep,
+            when: whenWorkStep
+        };
+    }));
+    // Assemble the branch step
+    return {
+        identity: branchStepIdentity,
+        kind: CONSTANTS.STEPS.branch,
+        cases: casesWithWorkSteps
+    };
+};
+// DOC: Helper function to clone a ForStep with new identities for steps and executions, preserving job references and bindings
+export const cloneForStep = async (forStep) => {
+    // Generate new ForStep identity
+    const newForStepIdentity = await getNewIdentity(CONSTANTS.STEPS.for);
+    // Clone the "what" WorkStep
+    const originalWhatWorkStep = forStep.case.what;
+    const newWhatWorkStepIdentity = await getNewIdentity(CONSTANTS.STEPS.work);
+    const newWhatExecutionIdentity = newWhatWorkStepIdentity.replace(CONSTANTS.STEPS.work.toUpperCase(), 'execution'.toUpperCase());
+    const newWhatExecution = {
+        identity: newWhatExecutionIdentity,
+        jobRef: originalWhatWorkStep.execution.jobRef,
+        roleBindings: {
+            inputBindingMap: { ...originalWhatWorkStep.execution.roleBindings.inputBindingMap },
+            outputBindingMap: { ...originalWhatWorkStep.execution.roleBindings.outputBindingMap }
+        }
+    };
+    const newWhatWorkStep = {
+        identity: newWhatWorkStepIdentity,
+        kind: CONSTANTS.STEPS.work,
+        execution: newWhatExecution
+    };
+    // Clone the "when" WorkStep
+    const originalWhenWorkStep = forStep.case.when;
+    const newWhenWorkStepIdentity = await getNewIdentity(CONSTANTS.STEPS.work);
+    const newWhenExecutionIdentity = newWhenWorkStepIdentity.replace(CONSTANTS.STEPS.work.toUpperCase(), 'execution'.toUpperCase());
+    const newWhenExecution = {
+        identity: newWhenExecutionIdentity,
+        jobRef: originalWhenWorkStep.execution.jobRef,
+        roleBindings: {
+            inputBindingMap: { ...originalWhenWorkStep.execution.roleBindings.inputBindingMap },
+            outputBindingMap: { ...originalWhenWorkStep.execution.roleBindings.outputBindingMap }
+        }
+    };
+    const newWhenWorkStep = {
+        identity: newWhenWorkStepIdentity,
+        kind: CONSTANTS.STEPS.work,
+        execution: newWhenExecution
+    };
+    // Assemble the cloned ForStep
+    return {
+        identity: newForStepIdentity,
+        kind: CONSTANTS.STEPS.for,
+        case: {
+            what: newWhatWorkStep,
+            when: newWhenWorkStep
+        }
+    };
+};

package/dist/index.d.ts

@@ -2,6 +2,6 @@ export * as CONSTANTS from './constants.js';
 export * as TYPES from './_lib/types.js';
 export * as UTILS from './_lib/utils/utils.js';
 export * as RESOURCE_CREATION from './_lib/utils/resourceCreation.js';
-export * as MAKE_HELPERS from './_lib/utils/makeHelpers.js';
+export * as STEP_CREATION from './_lib/utils/stepCreation.js';
 export * from './firebaseAdminHelpers.js';
 export * from './firebaseAdminInit.js';

package/dist/index.js

@@ -2,6 +2,6 @@ export * as CONSTANTS from './constants.js';
 export * as TYPES from './_lib/types.js';
 export * as UTILS from './_lib/utils/utils.js';
 export * as RESOURCE_CREATION from './_lib/utils/resourceCreation.js';
-export * as MAKE_HELPERS from './_lib/utils/makeHelpers.js';
+export * as STEP_CREATION from './_lib/utils/stepCreation.js';
 export * from './firebaseAdminHelpers.js';
 export * from './firebaseAdminInit.js';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@toolproof-npm/shared",
-    "version": "0.1.98",
+    "version": "0.1.100",
     "description": "Core library utilities for ToolProof",
     "keywords": [
         "toolproof",

package/dist/_lib/utils/makeHelpers.d.ts

@@ -1,7 +0,0 @@
-import type { WorkStepJson, BranchStepJson, WhileStepJson, ForStepJson, JobJson } from '@toolproof-npm/schema';
-export declare const makeWorkStepFromJob: (job: JobJson) => Promise<WorkStepJson>;
-export declare const makeLoopStepFromJob: (whatJob: JobJson, whenJob: JobJson, kind: "for" | "while") => Promise<ForStepJson | WhileStepJson>;
-export declare const makeBranchStepFromJobPairs: (cases: {
-    whatJob: JobJson;
-    whenJob: JobJson;
-}[]) => Promise<BranchStepJson>;

package/dist/_lib/utils/makeHelpers.js

@@ -1,78 +0,0 @@
-import { CONSTANTS } from '@toolproof-npm/shared/constants';
-import { getNewIdentity } from '@toolproof-npm/shared/server';
-// DOC: Helper function to construct an Execution object from a job
-const makeExecutionFromJob = async (job, executionRef) => {
-    const execIdentity = executionRef ?? await getNewIdentity(CONSTANTS.TERMINALS.execution);
-    const inputBindingMap = {};
-    const inputs = job.roles.inputMap;
-    await Promise.all(Object.keys(inputs).map(async (resourceRoleRef) => {
-        const resourceId = await getNewIdentity(CONSTANTS.TERMINALS.resource);
-        inputBindingMap[resourceRoleRef] = resourceId;
-    }));
-    const outputBindingMap = {};
-    const outputs = job.roles.outputMap;
-    await Promise.all(Object.keys(outputs).map(async (resourceRoleRef) => {
-        const resourceId = await getNewIdentity(CONSTANTS.TERMINALS.resource);
-        outputBindingMap[resourceRoleRef] = resourceId;
-    }));
-    return {
-        identity: execIdentity,
-        jobRef: job.identity,
-        roleBindings: {
-            inputBindingMap,
-            outputBindingMap
-        }
-    };
-};
-// DOC: Helper function to construct a WorkStep object from an jobMetaJson (does not append to statelessStrategy.steps)
-export const makeWorkStepFromJob = async (job) => {
-    const workStepIdentity = await getNewIdentity(CONSTANTS.STEPS.work);
-    const executionRef = workStepIdentity.replace(CONSTANTS.STEPS.work.toUpperCase(), 'execution'.toUpperCase()); // ATTENTION: use function
-    const execution = await makeExecutionFromJob(job, executionRef);
-    const newWorkStep = {
-        identity: workStepIdentity,
-        kind: CONSTANTS.STEPS.work,
-        execution
-    };
-    return newWorkStep;
-};
-// DOC: Helper function to construct a ForStep or WhileStep from a job
-export const makeLoopStepFromJob = async (whatJob, whenJob, kind) => {
-    // Create the "what" WorkStep from the provided job
-    const whatWorkStep = await makeWorkStepFromJob(whatJob);
-    // Create the "when" WorkStep from the LessThan job
-    const whenWorkStep = await makeWorkStepFromJob(whenJob);
-    // Generate loop step identity based on kind
-    const stepIdentity = (kind === 'for'
-        ? await getNewIdentity(CONSTANTS.STEPS.for)
-        : await getNewIdentity(CONSTANTS.STEPS.while));
-    // Assemble the loop step
-    return {
-        identity: stepIdentity,
-        kind,
-        case: {
-            what: whatWorkStep,
-            when: whenWorkStep
-        }
-    };
-};
-// DOC: Helper function to construct a BranchStep from an array of job pairs
-export const makeBranchStepFromJobPairs = async (cases) => {
-    // Generate branch step identity
-    const branchStepIdentity = await getNewIdentity(CONSTANTS.STEPS.branch);
-    // Create WorkSteps for each case (what and when pair)
-    const casesWithWorkSteps = await Promise.all(cases.map(async ({ whatJob, whenJob }) => {
-        const whatWorkStep = await makeWorkStepFromJob(whatJob);
-        const whenWorkStep = await makeWorkStepFromJob(whenJob);
-        return {
-            what: whatWorkStep,
-            when: whenWorkStep
-        };
-    }));
-    // Assemble the branch step
-    return {
-        identity: branchStepIdentity,
-        kind: CONSTANTS.STEPS.branch,
-        cases: casesWithWorkSteps
-    };
-};