@toolproof-core/lib 1.0.3 → 1.0.5

package/src/utils/roleResourceBinding.ts

@@ -0,0 +1,109 @@
+import type {
+    ResourceJson,
+    ResourceMissingJson,
+    ResourceInputPotentialJson,
+    ResourceOutputPotentialJson,
+    CreationContextJson,
+    StrategyStateJson,
+} from '@toolproof-core/schema';
+import { resolveResourceChain } from './resourceChain.js';
+
+export function bindInputResInStrategyState(
+    strategyState: StrategyStateJson,
+    target: CreationContextJson,
+    resource: ResourceJson
+): StrategyStateJson {
+    const bucket = strategyState[target.jobStepHandle] ?? {};
+    return {
+        ...strategyState,
+        [target.jobStepHandle]: {
+            ...bucket,
+            [target.resourceRoleHandle]: resource,
+        },
+    };
+}
+
+export function bindInputRefInStrategyState(
+    strategyState: StrategyStateJson,
+    target: CreationContextJson,
+    source: CreationContextJson
+): StrategyStateJson {
+    const sourceEntry = strategyState?.[source.jobStepHandle]?.[source.resourceRoleHandle] as (
+        | ResourceJson
+        | ResourceMissingJson
+        | ResourceInputPotentialJson
+        | ResourceOutputPotentialJson
+        | undefined
+    );
+    if (!sourceEntry) {
+        throw new Error(`resourceEntry not found for source (${source.jobStepHandle}, ${source.resourceRoleHandle})`);
+    }
+
+    const result = resolveResourceChain(strategyState, source);
+    const bucket = strategyState[target.jobStepHandle] ?? {};
+
+    if (result.status === 'materialized') {
+        return {
+            ...strategyState,
+            [target.jobStepHandle]: {
+                ...bucket,
+                [target.resourceRoleHandle]: result.entry,
+            },
+        };
+    }
+
+    if (result.status === 'missing') {
+        const missing = result.entry;
+        const reusedMissing: ResourceMissingJson = {
+            identity: missing.identity,
+            resourceTypeHandle: missing.resourceTypeHandle,
+            resourceShellKind: 'missing',
+        };
+
+        return {
+            ...strategyState,
+            [target.jobStepHandle]: {
+                ...bucket,
+                [target.resourceRoleHandle]: reusedMissing,
+            },
+        };
+    }
+
+    if (result.status === 'outputPotential') {
+        const potentialInput: ResourceInputPotentialJson = {
+            identity: sourceEntry.identity,
+            resourceTypeHandle: sourceEntry.resourceTypeHandle,
+            creationContext: {
+                jobStepHandle: source.jobStepHandle,
+                resourceRoleHandle: source.resourceRoleHandle,
+            },
+            resourceShellKind: 'inputPotential',
+        };
+
+        return {
+            ...strategyState,
+            [target.jobStepHandle]: {
+                ...bucket,
+                [target.resourceRoleHandle]: potentialInput,
+            },
+        };
+    }
+
+    throw new Error(`Failed to resolve resource chain: ${result.reason}`);
+}
+
+export function clearInputBindingInStrategyState(
+    strategyState: StrategyStateJson,
+    target: CreationContextJson
+): StrategyStateJson {
+    const bucket = strategyState?.[target.jobStepHandle];
+    if (!bucket?.[target.resourceRoleHandle]) return strategyState;
+
+    const nextBucket = { ...bucket } as Record<string, unknown>;
+    delete nextBucket[target.resourceRoleHandle];
+
+    return {
+        ...strategyState,
+        [target.jobStepHandle]: nextBucket as any,
+    };
+}

package/src/utils/runnableStrategyCreation.ts

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,112 @@
+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'),
+            },
+        },
+    };
+}

package/tsconfig.json

@@ -1,15 +1,15 @@
-{
-    "extends": "../../tsconfig.base.json",
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "types": ["node"]
-    },
-    "include": [
-        "src"
-    ],
-    "exclude": [
-        "dist",
-        "node_modules"
-    ]
+{
+    "extends": "../../tsconfig.base.json",
+    "compilerOptions": {
+        "rootDir": "./src",
+        "outDir": "./dist",
+        "types": ["node"]
+    },
+    "include": [
+        "src"
+    ],
+    "exclude": [
+        "dist",
+        "node_modules"
+    ]
 }

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/_lib/setup/firebaseAdminInit.ts","./src/artifacts/artifacts.ts","./src/firebase/firebaseAdminHelpers.ts","./src/types/types.ts","./src/utils/creation.ts","./src/utils/resourceMapExtraction.ts"],"version":"5.9.3"}
+{"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"}

package/src/utils/resourceMapExtraction.ts

@@ -1,47 +0,0 @@
-import type {
-    ResourceIdentityJson,
-    ResourceTypeIdentityJson,
-    ResourceJson,
-} from '@toolproof-core/schema';
-import type { ResourceMap } from '../types/types.js';
-
-
-export function extractResourcesByType<TResource extends ResourceJson = ResourceJson>(
-    resourceMap: ResourceMap,
-    resourceTypeHandle: ResourceTypeIdentityJson
-): Record<ResourceIdentityJson, TResource> {
-    const resources = (resourceMap[resourceTypeHandle] ?? []) as TResource[];
-    const result: Record<ResourceIdentityJson, TResource> = {} as Record<ResourceIdentityJson, TResource>;
-
-    for (const resource of resources) {
-        result[resource.identity] = resource;
-    }
-
-    return result;
-}
-
-/**
- 
- */
-export function extractNucleusMap<
-    TKey extends string = string,
-    TNucleus extends { identity: string | number | boolean } = { identity: string | number | boolean },
-    TResource extends ResourceJson = ResourceJson
->(
-    resourceMap: ResourceMap,
-    resourceTypeHandle: ResourceTypeIdentityJson,
-): Map<TKey, TNucleus> {
-    const resources = extractResourcesByType<TResource>(resourceMap, resourceTypeHandle);
-    const out = new Map<TKey, TNucleus>();
-
-    for (const resource of Object.values(resources)) {
-        const data = (resource as any).nucleus as unknown;
-
-        const value = data as TNucleus;
-        const key = String(value.identity) as TKey;
-
-        out.set(key, value);
-    }
-
-    return out;
-}