@toolproof-core/lib 1.0.13 → 1.0.15

package/src/utils/creation/stepCreation.ts

@@ -0,0 +1,159 @@
+import type {
+    BranchStepIdentityJson,
+    BranchStepJson,
+    CaseJson,
+    ForStepIdentityJson,
+    ForStepJson,
+    JobJson,
+    JobStepIdentityJson,
+    JobStepJson,
+    ResourceRoleIdentityJson,
+    WhileStepIdentityJson,
+    WhileStepJson,
+} from '@toolproof-core/schema';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+
+export type LoopStepBuildIdentities =
+    | {
+        stepKind: typeof CONSTANTS.Enums.StepKind.for;
+        stepIdentity: ForStepIdentityJson;
+        whatIdentity: JobStepIdentityJson;
+        whenIdentity: JobStepIdentityJson;
+    }
+    | {
+        stepKind: typeof CONSTANTS.Enums.StepKind.while;
+        stepIdentity: WhileStepIdentityJson;
+        whatIdentity: JobStepIdentityJson;
+        whenIdentity: JobStepIdentityJson;
+    };
+
+export type BranchCaseBuildIdentities = {
+    whatIdentity: JobStepIdentityJson;
+    whenIdentity: JobStepIdentityJson;
+};
+
+function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
+    if (arr.length === 0) {
+        throw new Error(msg);
+    }
+}
+
+function getRoleBindings(job: JobJson): JobStepJson['roleBindings'] {
+    return {
+        inputBindings: Object.keys(job.roles.inputDict) as ResourceRoleIdentityJson[],
+        outputBindings: Object.keys(job.roles.outputDict) as ResourceRoleIdentityJson[],
+    };
+}
+
+export function buildJobStepFromJob(
+    job: JobJson,
+    identity: JobStepIdentityJson,
+): JobStepJson {
+    return {
+        identity,
+        stepKind: CONSTANTS.Enums.StepKind.job,
+        jobHandle: job.identity,
+        roleBindings: getRoleBindings(job),
+    };
+}
+
+export function buildLoopStepFromJobPair(
+    whatJob: JobJson,
+    whenJob: JobJson,
+    identities: LoopStepBuildIdentities,
+): ForStepJson | WhileStepJson {
+    const what = buildJobStepFromJob(whatJob, identities.whatIdentity);
+    const when = buildJobStepFromJob(whenJob, identities.whenIdentity);
+
+    if (identities.stepKind === CONSTANTS.Enums.StepKind.for) {
+        return {
+            identity: identities.stepIdentity,
+            stepKind: CONSTANTS.Enums.StepKind.for,
+            case: { what, when },
+        };
+    }
+
+    return {
+        identity: identities.stepIdentity,
+        stepKind: CONSTANTS.Enums.StepKind.while,
+        case: { what, when },
+    };
+}
+
+export function buildBranchStepFromJobPairs(
+    cases: Array<{ whatJob: JobJson; whenJob: JobJson }>,
+    branchIdentity: BranchStepIdentityJson,
+    caseIdentities: BranchCaseBuildIdentities[],
+): BranchStepJson {
+    if (cases.length !== caseIdentities.length) {
+        throw new Error('buildBranchStepFromJobPairs requires one identity pair per case');
+    }
+
+    const resolved = cases.map(({ whatJob, whenJob }, index) => {
+        const identities = caseIdentities[index];
+
+        if (!identities) {
+            throw new Error(`Missing case identities for case index ${index}`);
+        }
+
+        const what = buildJobStepFromJob(whatJob, identities.whatIdentity);
+        const when = buildJobStepFromJob(whenJob, identities.whenIdentity);
+        return { what, when } satisfies CaseJson;
+    });
+
+    assertNonEmpty(resolved, 'buildBranchStepFromJobPairs requires at least one case');
+
+    return {
+        identity: branchIdentity,
+        stepKind: CONSTANTS.Enums.StepKind.branch,
+        cases: resolved,
+    };
+}
+
+export function cloneForStepWithIdentities(
+    forStep: ForStepJson,
+    identities: {
+        stepIdentity: ForStepIdentityJson;
+        whatIdentity: JobStepIdentityJson;
+        whenIdentity: JobStepIdentityJson;
+    },
+): ForStepJson {
+    return {
+        identity: identities.stepIdentity,
+        stepKind: CONSTANTS.Enums.StepKind.for,
+        case: {
+            what: {
+                ...forStep.case.what,
+                identity: identities.whatIdentity,
+            },
+            when: {
+                ...forStep.case.when,
+                identity: identities.whenIdentity,
+            },
+        },
+    };
+}
+
+export function cloneWhileStepWithIdentities(
+    whileStep: WhileStepJson,
+    identities: {
+        stepIdentity: WhileStepIdentityJson;
+        whatIdentity: JobStepIdentityJson;
+        whenIdentity: JobStepIdentityJson;
+    },
+): WhileStepJson {
+    return {
+        identity: identities.stepIdentity,
+        stepKind: CONSTANTS.Enums.StepKind.while,
+        case: {
+            what: {
+                ...whileStep.case.what,
+                identity: identities.whatIdentity,
+            },
+            when: {
+                ...whileStep.case.when,
+                identity: identities.whenIdentity,
+            },
+        },
+    };
+}