@toolproof-core/lib 1.0.3 → 1.0.4

package/src/utils/extractFrom.ts

@@ -0,0 +1,93 @@
+import type {
+    RawStrategyJson,
+    JobIdentityJson,
+    JobJson,
+    JobStepIdentityJson,
+    JobStepJson,
+    StepJson,
+    ResourceRoleIdentityJson,
+    ResourceRoleJson,
+    ErrorJson
+} from '@toolproof-core/schema';
+import { CONSTANTS } from '../artifacts/artifacts.js';
+
+
+export function extractJobHandlesFromRawStrategy(rawStrategy: RawStrategyJson): JobIdentityJson[] {
+    const jobSteps = extractJobStepsFromRawStrategy(rawStrategy);
+    const ids = new Set<JobIdentityJson>();
+    for (const jStep of jobSteps) {
+        ids.add(jStep.jobHandle);
+    }
+    return Array.from(ids);
+}
+
+export function extractJobStepsFromRawStrategy(rawStrategy: RawStrategyJson): JobStepJson[] {
+    const jobSteps: JobStepJson[] = [];
+    const seen = new Set<JobStepIdentityJson>();
+
+    const addJobStep = (jobStep: JobStepJson) => {
+        if (seen.has(jobStep.identity)) {
+            throw new Error(`Duplicate job step identity encountered: ${jobStep.identity}`);
+        }
+        seen.add(jobStep.identity);
+        jobSteps.push(jobStep);
+    };
+
+    const visitStep = (step: StepJson) => {
+        switch (step.stepKind) {
+            case CONSTANTS.Enums.StepKind.job: {
+                addJobStep(step);
+                return;
+            }
+            case CONSTANTS.Enums.StepKind.branch: {
+                for (const conditional of step.cases) {
+                    addJobStep(conditional.when);
+                    addJobStep(conditional.what);
+                }
+                return;
+            }
+            case CONSTANTS.Enums.StepKind.while:
+            case CONSTANTS.Enums.StepKind.for: {
+                addJobStep(step.case.when);
+                addJobStep(step.case.what);
+                return;
+            }
+            default: {
+                const _exhaustive: never = step;
+                return _exhaustive;
+            }
+        }
+    };
+
+    for (const step of rawStrategy.steps) {
+        visitStep(step);
+    }
+
+    return jobSteps;
+}
+
+
+export function extractResourceRolesFromRawStrategy(rawStrategy: RawStrategyJson, jobMap: Map<JobIdentityJson, JobJson>): ResourceRoleJson[] {
+    const map = new Map<ResourceRoleIdentityJson, ResourceRoleJson>();
+    const jobHandles = extractJobHandlesFromRawStrategy(rawStrategy);
+
+    for (const jobHandle of jobHandles) {
+        const job = jobMap.get(jobHandle);
+        if (!job) continue;
+
+        for (const [rid, role] of Object.entries(job.roles.inputDict)) {
+            map.set(rid as ResourceRoleIdentityJson, {
+                identity: rid as ResourceRoleIdentityJson,
+                ...role,
+            });
+        }
+        for (const [rid, role] of Object.entries(job.roles.outputDict)) {
+            map.set(rid as ResourceRoleIdentityJson, {
+                identity: rid as ResourceRoleIdentityJson,
+                ...role,
+            });
+        }
+    }
+
+    return Array.from(map.values());
+}

package/src/utils/extractFromResourcesByResourceTypeHandle.ts

@@ -0,0 +1,55 @@
+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/{creation.ts → generateFrom.ts}

@@ -1,27 +1,27 @@
-import type { ResourceIdentityJson, ResourceTypeIdentityJson, ResourceJson, ResourceOutputPotentialJson } from '@toolproof-core/schema';
-
-
-export function generatePath(resourceTypeHandle: ResourceTypeIdentityJson, identity: ResourceIdentityJson): string {
-    return `${resourceTypeHandle}/${identity}.json`;
-}
-
-export function fromOutputPotentialToMaterialized(
-    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,
-    };
+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/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/_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"],"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;
-}