@toolproof-npm/shared 0.1.52 → 0.1.53

package/dist/constants.d.ts

@@ -1,46 +1,35 @@
 export declare const CONSTANTS: {
     readonly SCHEMA: {
-        readonly ResourceFormatData: "ResourceFormatData";
-        readonly ResourceTypeData: "ResourceTypeData";
+        readonly ResourceFormat: "ResourceFormat";
+        readonly ResourceType: "ResourceType";
         readonly Execution: "Execution";
-        readonly ResourceMap: "ResourceMap";
+        readonly StrategyState: "StrategyState";
     };
     readonly STORAGE: {
         readonly BUCKETS: {
-            readonly tp_shapes: "tp-shapes";
             readonly tp_resources: "tp-resources";
         };
         readonly COLLECTIONS: {
-            readonly shapes: "shapes";
             readonly resources: "resources";
-        };
-        readonly FILTER: {
             readonly members: "members";
-            readonly specials: "specials";
         };
     };
-    readonly SHAPES: {
-        readonly formats: "formats";
-        readonly types: "types";
-    };
-    readonly ROLES: {
-        readonly roles: "roles";
-    };
-    readonly RESOURCES: {
-        readonly resources: "resources";
-        readonly jobs: "jobs";
-    };
-    readonly STEP: {
+    readonly TERMINALS: {
+        readonly format: "format";
+        readonly type: "type";
+        readonly role: "role";
+        readonly job: "job";
+        readonly execution: "executions";
+        readonly resource: "resource";
+        readonly stateless_strategy: "stateless_strategy";
+        readonly stateful_strategy: "stateful_strategy";
+    };
+    readonly STEPS: {
         readonly work: "work";
         readonly branch: "branch";
         readonly while: "while";
         readonly for: "for";
     };
-    readonly WORKFLOW: {
-        readonly execution: "execution";
-        readonly workflow: "workflow";
-        readonly workflowSpec: "workflowSpec";
-    };
     readonly ENGINE: {
         readonly GraphRunStrategy: "GraphRunStrategy";
     };

package/dist/constants.js

@@ -1,46 +1,35 @@
 export const CONSTANTS = {
     SCHEMA: {
-        ResourceFormatData: 'ResourceFormatData',
-        ResourceTypeData: 'ResourceTypeData',
+        ResourceFormat: 'ResourceFormat',
+        ResourceType: 'ResourceType',
         Execution: 'Execution',
-        ResourceMap: 'ResourceMap',
+        StrategyState: 'StrategyState',
     },
     STORAGE: {
         BUCKETS: {
-            tp_shapes: 'tp-shapes',
             tp_resources: 'tp-resources',
         },
         COLLECTIONS: {
-            shapes: 'shapes',
             resources: 'resources',
-        },
-        FILTER: {
             members: 'members',
-            specials: 'specials',
-        }
-    },
-    SHAPES: {
-        formats: 'formats',
-        types: 'types',
-    },
-    ROLES: {
-        roles: 'roles',
-    },
-    RESOURCES: {
-        resources: 'resources',
-        jobs: 'jobs',
+        },
     },
-    STEP: {
+    TERMINALS: {
+        format: 'format',
+        type: 'type',
+        role: 'role',
+        job: 'job',
+        execution: 'executions',
+        resource: 'resource',
+        stateless_strategy: 'stateless_strategy',
+        stateful_strategy: 'stateful_strategy',
+    },
+    STEPS: {
         work: 'work',
         branch: 'branch',
         while: 'while',
         for: 'for',
     },
-    WORKFLOW: {
-        execution: 'execution',
-        workflow: 'workflow',
-        workflowSpec: 'workflowSpec',
-    },
     ENGINE: {
         GraphRunStrategy: 'GraphRunStrategy',
     },

package/dist/firebaseAdminHelpers.d.ts

@@ -1,5 +1,5 @@
-import type { ResourceTypeIdJson } from '@toolproof-npm/schema';
-import type { ResourceShapeConst, ResourceRoleConst, StepConst, ResourceMap, ResourceConst } from './types.d.ts';
-export declare function getNewId(identifiable: ResourceShapeConst | ResourceRoleConst | ResourceConst | 'jobs' | 'executions' | StepConst | 'STATELESS_STRATEGY' | 'STATEFUL_STRATEGY'): string;
+import type { ResourceTypeIdentityJson } from '@toolproof-npm/schema';
+import type { StepConst, ResourceMap, TerminalConst } from './types.d.ts';
+export declare function getNewIdentity(identifiable: TerminalConst | StepConst): string;
 export declare function listResources(// ATTENTION: must clean up
-resourceTypeIds: ResourceTypeIdJson[]): Promise<ResourceMap>;
+resourceTypeRefs: ResourceTypeIdentityJson[]): Promise<ResourceMap>;

package/dist/firebaseAdminHelpers.js

@@ -1,17 +1,17 @@
 import { CONSTANTS } from './constants.js';
 import { dbAdmin, storageAdmin } from "./firebaseAdminInit.js";
-export function getNewId(identifiable) {
+export function getNewIdentity(identifiable) {
     const base = identifiable.toUpperCase();
     const normalized = base.endsWith('S') ? base.slice(0, -1) : base;
     const prefix = normalized + '-';
-    const docRef = dbAdmin.collection(CONSTANTS.STORAGE.COLLECTIONS.shapes).doc(identifiable).collection(CONSTANTS.STORAGE.FILTER.members).doc();
+    const docRef = dbAdmin.collection(CONSTANTS.STORAGE.COLLECTIONS.resources).doc(identifiable).collection(CONSTANTS.STORAGE.COLLECTIONS.members).doc();
     return prefix + docRef.id;
 }
 export async function listResources(// ATTENTION: must clean up
-resourceTypeIds) {
+resourceTypeRefs) {
     const bucket = storageAdmin.bucket(CONSTANTS.STORAGE.BUCKETS.tp_resources);
-    async function fetchFilesUnder(resourceTypeId) {
-        const prefix = `${resourceTypeId}/`;
+    async function fetchFilesUnder(resourceTypeRef) {
+        const prefix = `${resourceTypeRef}/`;
         const [found] = await bucket.getFiles({ prefix });
         const files = found.filter(f => {
             const name = f.name || '';
@@ -34,8 +34,8 @@ resourceTypeIds) {
         }));
         return items.filter(Boolean);
     }
-    const entries = await Promise.all(resourceTypeIds.map(async (resourceTypeId) => {
-        const rows = await fetchFilesUnder(resourceTypeId);
+    const entries = await Promise.all(resourceTypeRefs.map(async (resourceTypeRef) => {
+        const rows = await fetchFilesUnder(resourceTypeRef);
         const items = rows.map(({ data, meta, name }) => {
             const flat = meta?.metadata ?? {};
             // Reconstruct nested object from flattened keys (dot and array index notation)
@@ -91,18 +91,16 @@ resourceTypeIds) {
                 }
             }
             const identity = root.identity;
-            const resourceTypeIdMeta = root.resourceTypeId;
-            // creationContext may be flattened as creationContext.resourceRoleId or direct resourceRoleId
-            const resourceRoleId = (root.creationContext?.resourceRoleId ?? root.resourceRoleId);
-            const executionId = (root.creationContext?.executionId ?? root.executionId);
+            // const resourceTypeRef = root.resourceTypeRef; // we already have this
+            const resourceRoleRef = root.creationContext.resourceRoleRef;
+            const executionRef = root.creationContext.executionRef;
             const kind = root.kind;
             const path = root.path;
             const timestamp = root.timestamp;
             const missing = [
                 ['identity', identity],
-                ['resourceTypeId', resourceTypeIdMeta],
-                ['resourceRoleId', resourceRoleId],
-                ['executionId', executionId],
+                ['resourceRoleRef', resourceRoleRef],
+                ['executionRef', executionRef],
                 ['kind', kind],
                 ['timestamp', timestamp],
                 ['path', path],
@@ -113,10 +111,10 @@ resourceTypeIds) {
             }
             return {
                 identity,
-                resourceTypeId,
+                resourceTypeRef,
                 creationContext: {
-                    resourceRoleId,
-                    executionId,
+                    resourceRoleRef,
+                    executionRef,
                 },
                 kind: kind,
                 path: path,
@@ -124,7 +122,7 @@ resourceTypeIds) {
                 extractedData: data,
             };
         });
-        return [resourceTypeId, items];
+        return [resourceTypeRef, items];
     }));
     return Object.fromEntries(entries);
 }

package/dist/types.d.ts

@@ -1,22 +1,18 @@
-import type { ResourceIdJson, ExecutionIdJson, ResourceRoleIdJson, ResourceRoleValueJson, ResourceTypeIdJson, ResourceJson } from '@toolproof-npm/schema';
+import type { ExecutionIdentityJson, ResourceIdentityJson, ResourceJson, ResourceRoleIdentityJson, ResourceRoleValueJson, ResourceTypeIdentityJson } from '@toolproof-npm/schema';
 import { CONSTANTS } from './constants.js';
-export type BucketConst = typeof CONSTANTS.STORAGE.BUCKETS.tp_shapes | typeof CONSTANTS.STORAGE.BUCKETS.tp_resources;
-export type CollectionConst = typeof CONSTANTS.STORAGE.COLLECTIONS.shapes | typeof CONSTANTS.STORAGE.COLLECTIONS.resources;
-export type FilterConst = typeof CONSTANTS.STORAGE.FILTER.members | typeof CONSTANTS.STORAGE.FILTER.specials;
-export type ResourceShapeConst = typeof CONSTANTS.SHAPES.formats | typeof CONSTANTS.SHAPES.types;
-export type ResourceRoleConst = typeof CONSTANTS.ROLES.roles;
-export type ResourceConst = typeof CONSTANTS.RESOURCES.resources;
-export type StepConst = typeof CONSTANTS.STEP.work | typeof CONSTANTS.STEP.branch | typeof CONSTANTS.STEP.while | typeof CONSTANTS.STEP.for;
-export type WorkflowConst = typeof CONSTANTS.WORKFLOW.workflow | typeof CONSTANTS.WORKFLOW.workflowSpec | typeof CONSTANTS.WORKFLOW.execution;
+export type BucketConst = typeof CONSTANTS.STORAGE.BUCKETS.tp_resources;
+export type CollectionConst = typeof CONSTANTS.STORAGE.COLLECTIONS.resources | typeof CONSTANTS.STORAGE.COLLECTIONS.members;
+export type TerminalConst = typeof CONSTANTS.TERMINALS.format | typeof CONSTANTS.TERMINALS.type | typeof CONSTANTS.TERMINALS.role | typeof CONSTANTS.TERMINALS.job | typeof CONSTANTS.TERMINALS.execution | typeof CONSTANTS.TERMINALS.resource | typeof CONSTANTS.TERMINALS.stateless_strategy | typeof CONSTANTS.TERMINALS.stateful_strategy;
+export type StepConst = typeof CONSTANTS.STEPS.work | typeof CONSTANTS.STEPS.branch | typeof CONSTANTS.STEPS.while | typeof CONSTANTS.STEPS.for;
 export type Role = {
-    id: ResourceRoleIdJson;
+    identity: ResourceRoleIdentityJson;
 } & ResourceRoleValueJson;
-export type ResourceMap = Record<ResourceTypeIdJson, ResourceJson[]>;
+export type ResourceMap = Record<ResourceTypeIdentityJson, ResourceJson[]>;
 export type PartialResourceMeta = {
-    identity: ResourceIdJson;
-    resourceTypeId: ResourceTypeIdJson;
+    identity: ResourceIdentityJson;
+    resourceTypeRef: ResourceTypeIdentityJson;
     creationContext: {
-        resourceRoleId: ResourceRoleIdJson;
-        executionId: ExecutionIdJson;
+        resourceRoleRef: ResourceRoleIdentityJson;
+        executionRef: ExecutionIdentityJson;
     };
 };

package/dist/utils.d.ts

@@ -1,24 +1,24 @@
-import type { ResourceIdJson, ResourceTypeIdJson, ResourceJson, ResourceMissingJson, JobJson, ResourcePotentialOutputJson, StrategyStateValueJson, CreationContextValueJson } from '@toolproof-npm/schema';
+import type { ResourceIdentityJson, ResourceTypeIdentityJson, ResourceJson, ResourceMissingJson, JobJson, ResourcePotentialOutputJson, StrategyStateJson, CreationContextJson } from '@toolproof-npm/schema';
 import type { ResourceMap } from './types.js';
-export declare function extractResourcesByType(resourceMap: ResourceMap, resourceTypeId: ResourceTypeIdJson): Record<ResourceIdJson, ResourceJson>;
-export declare function extractJobMap(resourceMap: ResourceMap): Map<string, JobJson>;
+export declare function extractResourcesByType(resourceMap: ResourceMap, resourceTypeRef: ResourceTypeIdentityJson): Record<ResourceIdentityJson, ResourceJson>;
+export declare function extractJobMap(resourceMap: ResourceMap): Map<`JOB-${string}`, JobJson>;
 export type ResolveResult = {
     status: 'materialized';
     entry: ResourceJson;
-    path: CreationContextValueJson[];
+    path: CreationContextJson[];
 } | {
     status: 'missing';
     entry: ResourceMissingJson;
-    path: CreationContextValueJson[];
+    path: CreationContextJson[];
 } | {
     status: 'blocked-output';
     entry: ResourcePotentialOutputJson;
-    path: CreationContextValueJson[];
+    path: CreationContextJson[];
 } | {
     status: 'unresolved';
     reason: 'missing-entry' | 'cycle' | 'depth-exceeded';
-    path: CreationContextValueJson[];
+    path: CreationContextJson[];
 };
-export declare function resolveResourceChain(strategyState: StrategyStateValueJson, start: CreationContextValueJson, opts?: {
+export declare function resolveResourceChain(strategyState: StrategyStateJson, start: CreationContextJson, opts?: {
     maxDepth?: number;
 }): ResolveResult;

package/dist/utils.js

@@ -1,5 +1,5 @@
-export function extractResourcesByType(resourceMap, resourceTypeId) {
-    const resources = resourceMap[resourceTypeId] ?? [];
+export function extractResourcesByType(resourceMap, resourceTypeRef) {
+    const resources = resourceMap[resourceTypeRef] ?? [];
     const result = {};
     for (const resource of resources) {
         result[resource.identity] = resource;
@@ -11,7 +11,7 @@ export function extractJobMap(resourceMap) {
     const jobMap = new Map();
     Object.values(resourceJobMap).forEach((resource) => {
         if (resource.extractedData?.identity) {
-            jobMap.set(resource.extractedData.identity, resource.extractedData);
+            jobMap.set(resource.extractedData.identity, resource.extractedData); // ATTENTION: why do we need type assertion here?
         }
     });
     return jobMap;
@@ -23,15 +23,15 @@ export function resolveResourceChain(strategyState, start, opts) {
     let current = start;
     for (let depth = 0; depth <= maxDepth; depth++) {
         path.push(current);
-        const visitKey = `${current.executionId}::${current.resourceRoleId}`;
+        const visitKey = `${current.executionRef}::${current.resourceRoleRef}`;
         if (visited.has(visitKey)) {
             return { status: 'unresolved', reason: 'cycle', path };
         }
         visited.add(visitKey);
-        const bucket = strategyState[current.executionId];
+        const bucket = strategyState[current.executionRef];
         if (!bucket)
             return { status: 'unresolved', reason: 'missing-entry', path };
-        const entry = bucket[current.resourceRoleId];
+        const entry = bucket[current.resourceRoleRef];
         if (!entry)
             return { status: 'unresolved', reason: 'missing-entry', path };
         if (entry.kind === 'materialized') {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/shared",
-  "version": "0.1.52",
+  "version": "0.1.53",
   "description": "Core library utilities for ToolProof",
   "keywords": [
     "toolproof",
@@ -56,7 +56,7 @@
     "typescript": "^5.9.3"
   },
   "dependencies": {
-    "@toolproof-npm/schema": "^0.1.44",
+    "@toolproof-npm/schema": "^0.1.45",
     "firebase-admin": "^13.6.0"
   },
   "scripts": {