@toolproof-core/lib 1.0.5 → 1.0.8

package/src/utils/{parallelization.ts → parallelizeSteps.ts}

@@ -8,6 +8,7 @@ import type {
     StrategyStateJson,
     WhileStepJson,
 } from '@toolproof-core/schema';
+import { CONSTANTS } from '../artifacts/artifacts.js';
 
 
 export function getIndependentThreads(steps: StepJson[], strategyState: StrategyStateJson): StepJson[][] {
@@ -41,26 +42,26 @@ export function getIndependentThreads(steps: StepJson[], strategyState: Strategy
     };
 
     steps.forEach((step, ownerIndex) => {
-        if (step.stepKind === 'job') {
+        if (step.stepKind === CONSTANTS.Enums.StepKind.job) {
             addJobStep(step as JobStepJson, ownerIndex);
             return;
         }
 
-        if (step.stepKind === 'for') {
+        if (step.stepKind === CONSTANTS.Enums.StepKind.for) {
             const loop = step as ForStepJson;
             addJobStep(loop.case?.what, ownerIndex);
             addJobStep(loop.case?.when, ownerIndex);
             return;
         }
 
-        if (step.stepKind === 'while') {
+        if (step.stepKind === CONSTANTS.Enums.StepKind.while) {
             const loop = step as WhileStepJson;
             addJobStep(loop.case?.what, ownerIndex);
             addJobStep(loop.case?.when, ownerIndex);
             return;
         }
 
-        if (step.stepKind === 'branch') {
+        if (step.stepKind === CONSTANTS.Enums.StepKind.branch) {
             const branch = step as BranchStepJson;
             for (const caseItem of branch.cases ?? []) {
                 addJobStep(caseItem?.what, ownerIndex);

package/src/utils/{resourceChain.ts → resolveResourceChain.ts}

@@ -6,11 +6,12 @@ import type {
     ResourceOutputPotentialJson,
     StrategyStateJson,
 } from '@toolproof-core/schema';
+import { CONSTANTS } from '../artifacts/artifacts.js';
 
 export type ResolveResult =
-    | { status: 'materialized'; entry: ResourceJson; path: CreationContextJson[] }
-    | { status: 'missing'; entry: ResourceMissingJson; path: CreationContextJson[] }
-    | { status: 'outputPotential'; entry: ResourceOutputPotentialJson; path: CreationContextJson[] }
+    | { status: typeof CONSTANTS.Enums.ResourceShellKind.materialized; entry: ResourceJson; path: CreationContextJson[] }
+    | { status: typeof CONSTANTS.Enums.ResourceShellKind.missing; entry: ResourceMissingJson; path: CreationContextJson[] }
+    | { status: typeof CONSTANTS.Enums.ResourceShellKind.outputPotential; entry: ResourceOutputPotentialJson; path: CreationContextJson[] }
     | { status: 'unresolved'; reason: 'not-found' | 'cycle' | 'depth-exceeded'; path: CreationContextJson[] };
 
 export function resolveResourceChain(
@@ -42,18 +43,18 @@ export function resolveResourceChain(
         );
         if (!entry) return { status: 'unresolved', reason: 'not-found', path };
 
-        if (entry.resourceShellKind === 'materialized') {
-            return { status: 'materialized', entry: entry as ResourceJson, path };
+        if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.materialized) {
+            return { status: CONSTANTS.Enums.ResourceShellKind.materialized, entry: entry as ResourceJson, path };
         }
-        if (entry.resourceShellKind === 'missing') {
-            return { status: 'missing', entry: entry as ResourceMissingJson, path };
+        if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.missing) {
+            return { status: CONSTANTS.Enums.ResourceShellKind.missing, entry: entry as ResourceMissingJson, path };
         }
-        if (entry.resourceShellKind === 'outputPotential') {
-            return { status: 'outputPotential', entry: entry as ResourceOutputPotentialJson, path };
+        if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.outputPotential) {
+            return { status: CONSTANTS.Enums.ResourceShellKind.outputPotential, entry: entry as ResourceOutputPotentialJson, path };
         }
 
         // inputPotential: follow ref backwards
-        if (entry.resourceShellKind === 'inputPotential') {
+        if (entry.resourceShellKind === CONSTANTS.Enums.ResourceShellKind.inputPotential) {
             current = (entry as ResourceInputPotentialJson).creationContext;
             continue;
         }

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/shared.ts","./src/_lib/setup/firebaseadmininit.ts","./src/artifacts/artifacts.ts","./src/firebase/firebaseadminhelpers.ts","./src/types/types.ts","./src/utils/extractfrom.ts","./src/utils/extractfromresourcesbyresourcetypehandle.ts","./src/utils/generatefrom.ts","./src/utils/parallelization.ts","./src/utils/resourcechain.ts","./src/utils/roleresourcebinding.ts","./src/utils/runnablestrategycreation.ts","./src/utils/stepcreation.ts"],"version":"5.9.3"}
+{"root":["./src/_lib/setup/firebaseadmininit.ts","./src/artifacts/artifacts.ts","./src/firebase/firebaseadminhelpers.ts","./src/types/types.ts","./src/utils/bindinputroletoresource.ts","./src/utils/createresource.ts","./src/utils/createrunnablestrategy.ts","./src/utils/createstep.ts","./src/utils/extractdata.ts","./src/utils/parallelizesteps.ts","./src/utils/resolveresourcechain.ts"],"version":"5.9.3"}

package/src/shared.ts

@@ -1,126 +0,0 @@
-import type {
-    CreationContextJson,
-    JsonDataJson,
-    ResourceIdentityJson,
-    ResourceInputPotentialJson,
-    ResourceJson,
-    ResourceMissingJson,
-    ResourceOutputPotentialJson,
-    ResourceTypeIdentityJson,
-} from '@toolproof-core/schema';
-
-import { resolveResourceChain } from './utils/resourceChain.js';
-import {
-    bindInputRefInStrategyState,
-    bindInputResInStrategyState,
-    clearInputBindingInStrategyState,
-} from './utils/roleResourceBinding.js';
-import { createRunnableStrategy } from './utils/runnableStrategyCreation.js';
-import {
-    cloneForStep,
-    cloneWhileStep,
-    createBranchStepFromJobPairs,
-    createJobStepFromJob,
-    createLoopStepFromJobs,
-} from './utils/stepCreation.js';
-
-
-export const RESOURCE_CHAIN = {
-    resolveResourceChain,
-} as const;
-
-
-export const ROLE_RESOURCE_BINDINGS = {
-    bindInputResInStrategyState,
-    bindInputRefInStrategyState,
-    clearInputBindingInStrategyState,
-} as const;
-
-
-export const RUNNABLE_STRATEGY_CREATION = {
-    createRunnableStrategy,
-} as const;
-
-
-export const STEP_CREATION = {
-    createJobStepFromJob,
-    createLoopStepFromJobs,
-    createBranchStepFromJobPairs,
-    cloneForStep,
-    cloneWhileStep,
-} as const;
-
-
-function asMaterializedResource(
-    base: {
-        identity: ResourceIdentityJson;
-        resourceTypeHandle: ResourceTypeIdentityJson;
-        creationContext: CreationContextJson;
-    },
-    nucleus: JsonDataJson,
-    opts?: { path?: string; timestamp?: string }
-): ResourceJson {
-    return {
-        identity: base.identity,
-        resourceTypeHandle: base.resourceTypeHandle,
-        creationContext: base.creationContext,
-        resourceShellKind: 'materialized',
-        version: 1,
-        timestamp: opts?.timestamp ?? new Date().toISOString(),
-        path: opts?.path ?? '',
-        nucleus,
-    } as unknown as ResourceJson;
-}
-
-
-export const RESOURCE_CREATION = {
-    createMissingResource(identity: ResourceIdentityJson, resourceTypeHandle: ResourceTypeIdentityJson): ResourceMissingJson {
-        return {
-            identity,
-            resourceTypeHandle,
-            resourceShellKind: 'missing',
-        };
-    },
-
-    createOutputPotentialResource(
-        identity: ResourceIdentityJson,
-        resourceTypeHandle: ResourceTypeIdentityJson,
-        creationContext: CreationContextJson
-    ): ResourceOutputPotentialJson {
-        return {
-            identity,
-            resourceTypeHandle,
-            creationContext,
-            resourceShellKind: 'outputPotential',
-        };
-    },
-
-    createInputPotentialResource(
-        identity: ResourceIdentityJson,
-        resourceTypeHandle: ResourceTypeIdentityJson,
-        creationContext: CreationContextJson
-    ): ResourceInputPotentialJson {
-        return {
-            identity,
-            resourceTypeHandle,
-            creationContext,
-            resourceShellKind: 'inputPotential',
-        };
-    },
-
-    createMaterializedResourceFromPotential(
-        potential: ResourceOutputPotentialJson | ResourceInputPotentialJson,
-        nucleus: JsonDataJson,
-        opts?: { path?: string; timestamp?: string }
-    ): ResourceJson {
-        return asMaterializedResource(
-            {
-                identity: potential.identity,
-                resourceTypeHandle: potential.resourceTypeHandle,
-                creationContext: potential.creationContext,
-            },
-            nucleus,
-            opts
-        );
-    },
-} as const;

package/src/utils/extractFromResourcesByResourceTypeHandle.ts

@@ -1,55 +0,0 @@
-import type {
-    ResourceIdentityJson,
-    ResourceTypeIdentityJson,
-    ResourceJson,
-} from '@toolproof-core/schema';
-
-
-export function extractResourceMapForResourceType<TResource extends ResourceJson = ResourceJson>(
-    resourcesByResourceTypeHandle: Partial<Record<ResourceTypeIdentityJson, TResource[]>>,
-    resourceTypeHandle: ResourceTypeIdentityJson
-): Map<ResourceIdentityJson, TResource> {
-    const resources = resourcesByResourceTypeHandle[resourceTypeHandle] ?? [];
-    const map = new Map<ResourceIdentityJson, TResource>();
-
-    for (const resource of resources) {
-        map.set(resource.identity, resource);
-    }
-
-    return map;
-}
-
-// ATTENTION: should only need standalone type as type parameter, then we could extract the nuclueus type and identity type
-export function extractNucleusMapForResourceType<
-    TKey extends string = string,
-    TNucleus extends { identity: string | number | boolean } = { identity: string | number | boolean },
-    TResource extends ResourceJson = ResourceJson
->(
-    resourcesByResourceTypeHandle: Partial<Record<ResourceTypeIdentityJson, TResource[]>>,
-    resourceTypeHandle: ResourceTypeIdentityJson,
-): Map<TKey, TNucleus> {
-    const resourceMap = extractResourceMapForResourceType<TResource>(resourcesByResourceTypeHandle, resourceTypeHandle);
-    const out = new Map<TKey, TNucleus>();
-
-    for (const resource of resourceMap.values()) {
-        const data = (resource as any).nucleus as unknown;
-        if (data === null || data === undefined) {
-            continue;
-        }
-        if (typeof data !== 'object') {
-            continue;
-        }
-
-        const maybeIdentity = (data as any).identity as unknown;
-        if (maybeIdentity === null || maybeIdentity === undefined) {
-            continue;
-        }
-
-        const value = data as TNucleus;
-        const key = String(maybeIdentity) as TKey;
-
-        out.set(key, value);
-    }
-
-    return out;
-}

package/src/utils/generateFrom.ts

@@ -1,27 +0,0 @@
-import type { ResourceIdentityJson, ResourceTypeIdentityJson, ResourceJson, ResourceOutputPotentialJson } from '@toolproof-core/schema';
-
-
-export function generatePath(resourceTypeHandle: ResourceTypeIdentityJson, identity: ResourceIdentityJson): string {
-    return `${resourceTypeHandle}/${identity}.json`;
-}
-
-export function generateMaterializedFromOutputPotential(
-    outputPotential: ResourceOutputPotentialJson,
-    nucleus: unknown,
-    timestamp?: string
-): ResourceJson {
-    const { identity, resourceTypeHandle, creationContext } = outputPotential;
-
-    const path = generatePath(resourceTypeHandle, identity);
-
-    return {
-        identity,
-        resourceTypeHandle,
-        creationContext,
-        resourceShellKind: 'materialized',
-        version: 1,
-        timestamp: timestamp ?? new Date().toISOString(), // Preserve original timestamp when copying
-        path,
-        nucleus,
-    };
-}

package/src/utils/runnableStrategyCreation.ts

@@ -1,47 +0,0 @@
-import type {
-    RawStrategyJson,
-    RunnableStrategyIdentityJson,
-    RunnableStrategyJson,
-    RunnableStrategyStatusJson,
-    StepJson,
-    StrategyThreadIdentityJson,
-} from '@toolproof-core/schema';
-import type { IdentityName } from '../types/types.js';
-import { getIndependentThreads } from './parallelization.js';
-
-
-export type GetNewIdentity = (identityName: IdentityName) => string | Promise<string>;
-
-
-export async function createRunnableStrategy(
-    rawStrategy: RawStrategyJson,
-    opts: {
-        getNewIdentity: GetNewIdentity;
-        status?: RunnableStrategyStatusJson;
-    }
-): Promise<RunnableStrategyJson> {
-    if (!opts?.getNewIdentity) {
-        throw new Error('createRunnableStrategy: opts.getNewIdentity is required');
-    }
-
-    const runnableStrategyIdentity = (await opts.getNewIdentity('RunnableStrategyIdentity')) as RunnableStrategyIdentityJson;
-    const steps = (rawStrategy.steps ?? []) as StepJson[];
-    const strategyState = (rawStrategy.strategyState ?? {}) as RunnableStrategyJson['strategyState'];
-
-    const threadStepGroups = getIndependentThreads(steps, strategyState);
-    const strategyThreadDict: Record<StrategyThreadIdentityJson, StepJson[]> = {} as any;
-
-    for (const group of threadStepGroups) {
-        const threadIdentity = (await opts.getNewIdentity('StrategyThreadIdentity')) as StrategyThreadIdentityJson;
-        strategyThreadDict[threadIdentity] = group;
-    }
-
-    return {
-        identity: runnableStrategyIdentity,
-        runnableStrategyContext: {
-            status: opts.status ?? 'running',
-        },
-        strategyThreadDict,
-        strategyState,
-    } as RunnableStrategyJson;
-}

package/src/utils/stepCreation.ts

@@ -1,112 +0,0 @@
-import type {
-    BranchStepJson,
-    ConditionalJson,
-    ForStepJson,
-    JobJson,
-    JobStepJson,
-    ResourceRoleIdentityJson,
-    WhileStepJson,
-} from '@toolproof-core/schema';
-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 async function createJobStepFromJob(job: JobJson): Promise<JobStepJson> {
-    const inputBindings = Object.keys(job.roles.inputDict ?? {}) as ResourceRoleIdentityJson[];
-    const outputBindings = Object.keys(job.roles.outputDict ?? {}) as ResourceRoleIdentityJson[];
-
-    return {
-        identity: getNewStepIdentity('job'),
-        stepKind: 'job',
-        jobHandle: job.identity,
-        roleBindings: {
-            inputBindings,
-            outputBindings,
-        },
-    };
-}
-
-
-export async function createLoopStepFromJobs(
-    whatJob: JobJson,
-    whenJob: JobJson,
-    stepKind: 'for' | 'while'
-): Promise<ForStepJson | WhileStepJson> {
-    const what = await createJobStepFromJob(whatJob);
-    const when = await createJobStepFromJob(whenJob);
-
-    if (stepKind === 'for') {
-        return {
-            identity: getNewStepIdentity('for'),
-            stepKind: 'for',
-            case: { what, when },
-        };
-    }
-
-    return {
-        identity: getNewStepIdentity('while'),
-        stepKind: 'while',
-        case: { what, when },
-    };
-}
-
-
-export async function createBranchStepFromJobPairs(
-    cases: Array<{ whatJob: JobJson; whenJob: JobJson }>
-): Promise<BranchStepJson> {
-    const resolved = await Promise.all(
-        cases.map(async ({ whatJob, whenJob }) => {
-            const what = await createJobStepFromJob(whatJob);
-            const when = await createJobStepFromJob(whenJob);
-            return { what, when } satisfies ConditionalJson;
-        })
-    );
-
-    assertNonEmpty(resolved, 'createBranchStepFromJobPairs requires at least one case');
-
-    return {
-        identity: getNewStepIdentity('branch'),
-        stepKind: 'branch',
-        cases: resolved,
-    };
-}
-
-
-export function cloneForStep(forStep: ForStepJson): ForStepJson {
-    return {
-        identity: getNewStepIdentity('for'),
-        stepKind: 'for',
-        case: {
-            what: {
-                ...forStep.case.what,
-                identity: getNewStepIdentity('job'),
-            },
-            when: {
-                ...forStep.case.when,
-                identity: getNewStepIdentity('job'),
-            },
-        },
-    };
-}
-
-
-export function cloneWhileStep(whileStep: WhileStepJson): WhileStepJson {
-    return {
-        identity: getNewStepIdentity('while'),
-        stepKind: 'while',
-        case: {
-            what: {
-                ...whileStep.case.what,
-                identity: getNewStepIdentity('job'),
-            },
-            when: {
-                ...whileStep.case.when,
-                identity: getNewStepIdentity('job'),
-            },
-        },
-    };
-}