@toolproof-core/lib 1.0.14 → 1.0.16

package/src/utils/creation/runnableStrategyCreation.ts

@@ -0,0 +1,46 @@
+import type {
+    RawStrategyJson,
+    RunnableStrategyIdentityJson,
+    RunnableStrategyJson,
+    StepJson,
+    StepsByStrategyThreadJson,
+    StrategyThreadIdentityJson,
+} from '@toolproof-core/schema';
+import { CONSTANTS } from '../../artifacts/artifacts.js';
+import { getIndependentThreads } from '../parallelizeSteps.js';
+
+export function getRunnableStrategyThreadGroups(rawStrategy: RawStrategyJson): StepJson[][] {
+    return getIndependentThreads(rawStrategy.steps, rawStrategy.strategyState);
+}
+
+export function buildRunnableStrategy(
+    rawStrategy: RawStrategyJson,
+    runnableStrategyIdentity: RunnableStrategyIdentityJson,
+    threadStepGroups: StepJson[][],
+    threadIdentities: StrategyThreadIdentityJson[],
+): RunnableStrategyJson {
+    if (threadStepGroups.length !== threadIdentities.length) {
+        throw new Error('buildRunnableStrategy requires one thread identity per thread group');
+    }
+
+    const stepsByStrategyThread: StepsByStrategyThreadJson = {};
+
+    for (const [index, group] of threadStepGroups.entries()) {
+        const threadIdentity = threadIdentities[index];
+
+        if (!threadIdentity) {
+            throw new Error(`Missing thread identity for thread group index ${index}`);
+        }
+
+        stepsByStrategyThread[threadIdentity] = group;
+    }
+
+    return {
+        identity: runnableStrategyIdentity,
+        runnableStrategyContext: {
+            status: CONSTANTS.Enums.RunnableStrategyStatus.pending,
+        },
+        stepsByStrategyThread,
+        strategyState: rawStrategy.strategyState,
+    };
+}

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.inputRoleValuesByIdentity) as ResourceRoleIdentityJson[],
+        outputBindings: Object.keys(job.roles.outputRoleValuesByIdentity) 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,
+            },
+        },
+    };
+}

package/src/utils/extractData.ts

@@ -77,13 +77,13 @@ export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategyJson, jobM
         const job = jobMap.get(jobHandle);
         if (!job) continue;
 
-        for (const [rid, role] of Object.entries(job.roles.inputDict)) {
+        for (const [rid, role] of Object.entries(job.roles.inputRoleValuesByIdentity)) {
             roleMap.set(rid as ResourceRoleIdentityJson, {
                 identity: rid as ResourceRoleIdentityJson,
                 ...role,
             });
         }
-        for (const [rid, role] of Object.entries(job.roles.outputDict)) {
+        for (const [rid, role] of Object.entries(job.roles.outputRoleValuesByIdentity)) {
             roleMap.set(rid as ResourceRoleIdentityJson, {
                 identity: rid as ResourceRoleIdentityJson,
                 ...role,
@@ -96,7 +96,7 @@ export function extractRoleMapFromRawStrategy(rawStrategy: RawStrategyJson, jobM
 
 export function extractSingleNonErrorOutputTypeHandle(job: JobJson): ResourceTypeIdentityJson | null {
     const errorRoleId = CONSTANTS.Cosmos.ROLE_ErrorOutput;
-    const outputEntries = Object.entries(job.roles.outputDict).filter(([roleId]) => roleId !== errorRoleId);
+    const outputEntries = Object.entries(job.roles.outputRoleValuesByIdentity).filter(([roleId]) => roleId !== errorRoleId);
     if (!outputEntries || !outputEntries[0] || outputEntries.length !== 1) {
         throw new Error(`Job ${job.identity} must have exactly one non-error output role to be branchable/loopable`);
     } // ATTENTION_PUREIFY