@toolproof-core/lib 1.0.14 → 1.0.16

package/src/utils/createRunnableStrategy.ts

@@ -1,31 +0,0 @@
-import type {
-    RawStrategyJson,
-    RunnableStrategyJson,
-    StrategyThreadDictJson
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { getNewIdentity } from '../firebase/firebaseAdminHelpers.js';
-import { getIndependentThreads } from './parallelizeSteps.js';
-
-export function createRunnableStrategy(rawStrategy: RawStrategyJson): RunnableStrategyJson {
-    const runnableStrategyIdentity = getNewIdentity(CONSTANTS.Names.RunnableStrategyIdentity);
-    const steps = rawStrategy.steps;
-    const strategyState = rawStrategy.strategyState;
-
-    const threadStepGroups = getIndependentThreads(steps, strategyState);
-    const strategyThreadDict: StrategyThreadDictJson = {};
-
-    for (const group of threadStepGroups) {
-        const threadIdentity = getNewIdentity(CONSTANTS.Names.StrategyThreadIdentity);
-        strategyThreadDict[threadIdentity] = group;
-    }
-
-    return {
-        identity: runnableStrategyIdentity,
-        runnableStrategyContext: {
-            status: CONSTANTS.Enums.RunnableStrategyStatus.pending,
-        },
-        strategyThreadDict,
-        strategyState,
-    };
-}

package/src/utils/createStep.ts

@@ -1,111 +0,0 @@
-import type {
-    BranchStepJson,
-    CaseJson,
-    ForStepJson,
-    JobJson,
-    JobStepJson,
-    ResourceRoleIdentityJson,
-    WhileStepJson,
-} from '@toolproof-core/schema';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { getNewStepIdentity } from '../firebase/firebaseAdminHelpers.js';
-
-
-function assertNonEmpty<T>(arr: T[], msg: string): asserts arr is [T, ...T[]] {
-    if (arr.length === 0) throw new Error(msg);
-}
-
-
-export function createJobStepFromJob(job: JobJson): JobStepJson {
-    const inputBindings = Object.keys(job.roles.inputDict) as ResourceRoleIdentityJson[];
-    const outputBindings = Object.keys(job.roles.outputDict) as ResourceRoleIdentityJson[];
-
-    return {
-        identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
-        stepKind: CONSTANTS.Enums.StepKind.job,
-        jobHandle: job.identity,
-        roleBindings: {
-            inputBindings,
-            outputBindings,
-        },
-    };
-}
-
-
-export function createLoopStepFromJobPair(
-    whatJob: JobJson,
-    whenJob: JobJson,
-    stepKind: typeof CONSTANTS.Enums.StepKind.for | typeof CONSTANTS.Enums.StepKind.while
-): ForStepJson | WhileStepJson {
-    const what = createJobStepFromJob(whatJob);
-    const when = createJobStepFromJob(whenJob);
-
-    if (stepKind === CONSTANTS.Enums.StepKind.for) {
-        return {
-            identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.for),
-            stepKind: CONSTANTS.Enums.StepKind.for,
-            case: { what, when },
-        };
-    }
-
-    return {
-        identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.while),
-        stepKind: CONSTANTS.Enums.StepKind.while,
-        case: { what, when },
-    };
-}
-
-
-export function createBranchStepFromJobPairs(
-    cases: Array<{ whatJob: JobJson; whenJob: JobJson }>
-): BranchStepJson {
-    const resolved = cases.map(({ whatJob, whenJob }) => {
-        const what = createJobStepFromJob(whatJob);
-        const when = createJobStepFromJob(whenJob);
-        return { what, when } satisfies CaseJson;
-    });
-
-    assertNonEmpty(resolved, 'createBranchStepFromJobPairs requires at least one case'); // ATTENTION_IMPURE
-
-    return {
-        identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.branch),
-        stepKind: CONSTANTS.Enums.StepKind.branch,
-        cases: resolved,
-    };
-}
-
-
-export function cloneForStep(forStep: ForStepJson): ForStepJson {
-    return {
-        identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.for),
-        stepKind: CONSTANTS.Enums.StepKind.for,
-        case: {
-            what: {
-                ...forStep.case.what,
-                identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
-            },
-            when: {
-                ...forStep.case.when,
-                identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
-            },
-        },
-    };
-}
-
-
-export function cloneWhileStep(whileStep: WhileStepJson): WhileStepJson {
-    return {
-        identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.while),
-        stepKind: CONSTANTS.Enums.StepKind.while,
-        case: {
-            what: {
-                ...whileStep.case.what,
-                identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
-            },
-            when: {
-                ...whileStep.case.when,
-                identity: getNewStepIdentity(CONSTANTS.Enums.StepKind.job),
-            },
-        },
-    };
-}