@toolproof-core/lib 1.0.3 → 1.0.5

package/package.json

@@ -1,47 +1,54 @@
 {
-    "name": "@toolproof-core/lib",
-    "version": "1.0.3",
-    "description": "",
-    "type": "module",
-    "keywords": [],
-    "author": "",
-    "license": "ISC",
-    "packageManager": "pnpm@10.15.0",
-    "scripts": {
-        "test": "echo \"Error: no test specified\" && exit 1",
-        "build": "tsc -b"
+  "name": "@toolproof-core/lib",
+  "version": "1.0.5",
+  "description": "",
+  "type": "module",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "exports": {
+    "./artifacts": {
+      "types": "./dist/artifacts/artifacts.d.ts",
+      "import": "./dist/artifacts/artifacts.js"
     },
-    "exports": {
-        "./artifacts": {
-            "types": "./dist/artifacts/artifacts.d.ts",
-            "import": "./dist/artifacts/artifacts.js"
-        },
-        "./types": {
-            "types": "./dist/types/types.d.ts",
-            "import": "./dist/types/types.js"
-        },
-        "./resource-map-extraction": {
-            "types": "./dist/utils/resourceMapExtraction.d.ts",
-            "import": "./dist/utils/resourceMapExtraction.js"
-        },
-        "./creation": {
-            "types": "./dist/utils/creation.d.ts",
-            "import": "./dist/utils/creation.js"
-        },
-        "./firebase-admin-init": {
-            "types": "./dist/_lib/setup/firebaseAdminInit.d.ts",
-            "import": "./dist/_lib/setup/firebaseAdminInit.js"
-        },
-        "./firebase-admin-helpers": {
-            "types": "./dist/firebase/firebaseAdminHelpers.d.ts",
-            "import": "./dist/firebase/firebaseAdminHelpers.js"
-        }
+    "./types": {
+      "types": "./dist/types/types.d.ts",
+      "import": "./dist/types/types.js"
     },
-    "devDependencies": {
-        "@types/node": "^22.0.0"
+    "./extract-from": {
+      "types": "./dist/utils/extractFrom.d.ts",
+      "import": "./dist/utils/extractFrom.js"
     },
-    "dependencies": {
-        "@toolproof-core/schema": "workspace:*",
-        "firebase-admin": "^13.7.0"
+    "./extract-from-resources-by-resource-type-handle": {
+      "types": "./dist/utils/extractFromResourcesByResourceTypeHandle.d.ts",
+      "import": "./dist/utils/extractFromResourcesByResourceTypeHandle.js"
+    },
+    "./generate-from": {
+      "types": "./dist/utils/generateFrom.d.ts",
+      "import": "./dist/utils/generateFrom.js"
+    },
+    "./firebase-admin-init": {
+      "types": "./dist/_lib/setup/firebaseAdminInit.d.ts",
+      "import": "./dist/_lib/setup/firebaseAdminInit.js"
+    },
+    "./firebase-admin-helpers": {
+      "types": "./dist/firebase/firebaseAdminHelpers.d.ts",
+      "import": "./dist/firebase/firebaseAdminHelpers.js"
+    },
+    "./shared": {
+      "types": "./dist/shared.d.ts",
+      "import": "./dist/shared.js"
     }
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0"
+  },
+  "dependencies": {
+    "@toolproof-core/schema": "^1.0.11",
+    "firebase-admin": "^13.7.0"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc -b"
+  }
 }

package/src/_lib/setup/firebaseAdminInit.ts

@@ -1,38 +1,38 @@
-import { getApp, getApps, initializeApp, applicationDefault, cert } from 'firebase-admin/app';
-import { getFirestore } from 'firebase-admin/firestore';
-import { getStorage } from 'firebase-admin/storage';
-import { existsSync, readFileSync } from 'fs';
-import path from 'path';
-
-// Resolve credentials: prefer GOOGLE_APPLICATION_CREDENTIALS, fallback to local gcp-key.json, else ADC
-function resolveCredential() {
-    const jsonString = process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON;
-    const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
-    const localKeyPath = path.join(process.cwd(), 'gcp-key.json');
-    try {
-        if (jsonString) {
-            const json = JSON.parse(jsonString);
-            return cert(json);
-        }
-        if (envPath && existsSync(envPath)) {
-            const json = JSON.parse(readFileSync(envPath, 'utf8'));
-            return cert(json);
-        }
-        if (existsSync(localKeyPath)) {
-            const json = JSON.parse(readFileSync(localKeyPath, 'utf8'));
-            return cert(json);
-        }
-    } catch {
-        // fall through to ADC
-    }
-    return applicationDefault();
-}
-
-const app = getApps().length ? getApp() : initializeApp({
-    credential: resolveCredential(),
-    projectId: "toolproof-563fe",
-});
-const dbAdmin = getFirestore(app);
-const storageAdmin = getStorage(app);
-
-export { dbAdmin, storageAdmin };
+import { getApp, getApps, initializeApp, applicationDefault, cert } from 'firebase-admin/app';
+import { getFirestore } from 'firebase-admin/firestore';
+import { getStorage } from 'firebase-admin/storage';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+// Resolve credentials: prefer GOOGLE_APPLICATION_CREDENTIALS, fallback to local gcp-key.json, else ADC
+function resolveCredential() {
+    const jsonString = process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON;
+    const envPath = process.env.GOOGLE_APPLICATION_CREDENTIALS;
+    const localKeyPath = path.join(process.cwd(), 'gcp-key.json');
+    try {
+        if (jsonString) {
+            const json = JSON.parse(jsonString);
+            return cert(json);
+        }
+        if (envPath && existsSync(envPath)) {
+            const json = JSON.parse(readFileSync(envPath, 'utf8'));
+            return cert(json);
+        }
+        if (existsSync(localKeyPath)) {
+            const json = JSON.parse(readFileSync(localKeyPath, 'utf8'));
+            return cert(json);
+        }
+    } catch {
+        // fall through to ADC
+    }
+    return applicationDefault();
+}
+
+const app = getApps().length ? getApp() : initializeApp({
+    credential: resolveCredential(),
+    projectId: "toolproof-563fe",
+});
+const dbAdmin = getFirestore(app);
+const storageAdmin = getStorage(app);
+
+export { dbAdmin, storageAdmin };

package/src/artifacts/artifacts.ts

@@ -1,41 +1,41 @@
-import { CONSTANTS as _CONSTANTS, MAPPINGS as _MAPPINGS } from "@toolproof-core/schema";
-
-export const CONSTANTS = {
-    ..._CONSTANTS,
-    Persistence: {
-        Buckets: {
-            tp_resources: 'tp-resources',
-            tp_strategies: 'tp-strategies',
-        },
-        Collections: {
-            resources: 'resources',
-            members: 'members',
-        },
-    },
-    Engine: {
-        Graphs: {
-            GraphRunStrategy: 'GraphRunStrategy',
-            GraphBuildStrategy: 'GraphBuildStrategy',
-        },
-    },
-    Cosmos: {
-        TYPE_Boolean: 'TYPE-Boolean',
-        TYPE_Natural: 'TYPE-Natural',
-        TYPE_ResourceType: 'TYPE-ResourceType',
-        TYPE_Job: 'TYPE-Job',
-        TYPE_Error: 'TYPE-Error',
-        TYPE_RawStrategy: 'TYPE-RawStrategy',
-        TYPE_RunnableStrategy: 'TYPE-RunnableStrategy',
-        TYPE_StrategyRun: 'TYPE-StrategyRun',
-        ROLE_Manual: 'ROLE-Manual',
-        ROLE_ErrorOutput: 'ROLE-ErrorOutput',
-        ROLE_LessThanSource: 'ROLE-LessThanSource',
-        ROLE_LessThanTarget: 'ROLE-LessThanTarget',
-        ROLE_LessThanDecision: 'ROLE-LessThanDecision',
-        JOB_LessThan: 'JOB-LessThan',
-    }
-} as const;
-
-export const MAPPINGS = {
-    ..._MAPPINGS,
+import { CONSTANTS as _CONSTANTS, MAPPINGS as _MAPPINGS } from "@toolproof-core/schema";
+
+export const CONSTANTS = {
+    ..._CONSTANTS,
+    Persistence: {
+        Buckets: {
+            tp_resources: 'tp-resources',
+            tp_strategies: 'tp-strategies',
+        },
+        Collections: {
+            resources: 'resources',
+            members: 'members',
+        },
+    },
+    Engine: {
+        Graphs: {
+            GraphRunStrategy: 'GraphRunStrategy',
+            GraphBuildStrategy: 'GraphBuildStrategy',
+        },
+    },
+    Cosmos: {
+        TYPE_Boolean: 'TYPE-Boolean',
+        TYPE_Natural: 'TYPE-Natural',
+        TYPE_ResourceType: 'TYPE-ResourceType',
+        TYPE_Job: 'TYPE-Job',
+        TYPE_Error: 'TYPE-Error',
+        TYPE_RawStrategy: 'TYPE-RawStrategy',
+        TYPE_RunnableStrategy: 'TYPE-RunnableStrategy',
+        TYPE_StrategyRun: 'TYPE-StrategyRun',
+        ROLE_Manual: 'ROLE-Manual',
+        ROLE_ErrorOutput: 'ROLE-ErrorOutput',
+        ROLE_LessThanSource: 'ROLE-LessThanSource',
+        ROLE_LessThanTarget: 'ROLE-LessThanTarget',
+        ROLE_LessThanDecision: 'ROLE-LessThanDecision',
+        JOB_LessThan: 'JOB-LessThan',
+    }
+} as const;
+
+export const MAPPINGS = {
+    ..._MAPPINGS,
 } as const;

package/src/firebase/firebaseAdminHelpers.ts

@@ -1,157 +1,157 @@
-import type {
-    ResourceJson,
-    ResourceTypeIdentityJson,
-    StepKindJson,
-} from '@toolproof-core/schema';
-import type { IdentityName, IdentityStringByIdentityName, StepIdentityStringByStepKind, ResourceMap } from '../types/types.js';
-import { CONSTANTS } from '../artifacts/artifacts.js';
-import { MAPPINGS } from '../artifacts/artifacts.js';
-import { dbAdmin, storageAdmin } from "../_lib/setup/firebaseAdminInit.js";
-
-
-function capitalizeFirst(value: string): string {
-    if (!value) return value;
-    return value.charAt(0).toUpperCase() + value.slice(1);
-}
-
-export function getNewIdentity<K extends IdentityName>(identityName: K): IdentityStringByIdentityName<K> {
-    const prefix = MAPPINGS.IdentityNameToIdentityPrefix[identityName];
-    const docRef = dbAdmin
-        .collection(CONSTANTS.Persistence.Collections.resources)
-        .doc(identityName)
-        .collection(CONSTANTS.Persistence.Collections.members)
-        .doc();
-    return (prefix + docRef.id) as IdentityStringByIdentityName<K>;
-}
-
-export function getNewStepIdentity<K extends StepKindJson>(stepKind: K): StepIdentityStringByStepKind<K> {
-    const identityName = `${capitalizeFirst(stepKind)}StepIdentity` as IdentityName;
-    if (!(identityName in MAPPINGS.IdentityNameToIdentityPrefix)) {
-        throw new Error(`No IdentityNameToIdentityPrefix entry for derived step identity name: ${identityName}`);
-    }
-    return getNewIdentity(identityName) as StepIdentityStringByStepKind<K>;
-}
-
-export async function listResources(
-    resourceTypeHandles: ResourceTypeIdentityJson[]
-): Promise<ResourceMap> {
-    const bucket_resources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
-    const bucket_strategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
-
-    async function fetchFilesUnder(resourceTypeHandle: ResourceTypeIdentityJson): Promise<Array<{ data: unknown; meta: any; name: string }>> {
-        const bucket = resourceTypeHandle === CONSTANTS.Cosmos.TYPE_RunnableStrategy
-            ? bucket_strategies
-            : bucket_resources;
-        const prefix = `${resourceTypeHandle}/`;
-        const [found] = await bucket.getFiles({ prefix });
-        const files = found.filter(f => {
-            const name = f.name || '';
-            if (!name || name.endsWith('/')) return false;
-            return true;
-        });
-        if (!files.length) return [];
-        const items = await Promise.all(files.map(async (file) => {
-            try {
-                const [buf] = await file.download();
-                const meta = file.metadata || (await file.getMetadata())[0];
-                const data = JSON.parse(buf.toString('utf8')) as unknown;
-                return { data, meta, name: file.name };
-            } catch {
-                return null as unknown as { data: unknown; meta: any; name: string };
-            }
-        }));
-        return items.filter(Boolean) as Array<{ data: unknown; meta: any; name: string }>;
-    }
-
-    const entries = await Promise.all(
-        resourceTypeHandles.map(async (resourceTypeHandle) => {
-            const rows = await fetchFilesUnder(resourceTypeHandle);
-            const items: ResourceJson[] = rows.map(({ data, meta, name }) => {
-                const flat = meta?.metadata ?? {};
-                // Reconstruct nested object from flattened keys (dot and array index notation)
-                const root: any = {};
-                for (const [k, vRaw] of Object.entries(flat)) {
-                    if (typeof vRaw !== 'string') continue; // GCS should store only strings
-                    const vStr = vRaw.trim();
-                    // Attempt JSON parse for non-simple primitives
-                    let value: any = vStr;
-                    if ((vStr.startsWith('{') && vStr.endsWith('}')) || (vStr.startsWith('[') && vStr.endsWith(']'))) {
-                        try { value = JSON.parse(vStr); } catch { value = vStr; }
-                    }
-                    // Split by '.' while preserving array indices
-                    const segments = k.split('.');
-                    let cursor = root;
-                    for (const [i, seg] of segments.entries()) {
-                        const arrIdxMatch = seg.match(/^(.*)\[(\d+)\]$/);
-                        if (arrIdxMatch) {
-                            const base = arrIdxMatch[1];
-                            const idxStr = arrIdxMatch[2];
-                            if (base === undefined || idxStr === undefined) continue;
-                            const idx = parseInt(idxStr, 10);
-                            if (!cursor[base]) cursor[base] = [];
-                            if (!Array.isArray(cursor[base])) cursor[base] = [];
-                            while (cursor[base].length <= idx) cursor[base].push(undefined);
-                            if (i === segments.length - 1) {
-                                cursor[base][idx] = value;
-                            } else {
-                                if (!cursor[base][idx]) cursor[base][idx] = {};
-                                cursor = cursor[base][idx];
-                            }
-                        } else {
-                            if (i === segments.length - 1) {
-                                cursor[seg] = value;
-                            } else {
-                                if (!cursor[seg] || typeof cursor[seg] !== 'object') cursor[seg] = {};
-                                cursor = cursor[seg];
-                            }
-                        }
-                    }
-                }
-                const identity = root.identity;
-                // const resourceTypeHandle = root.resourceTypeHandle; // we already have this
-                const resourceRoleHandle = root.creationContext.resourceRoleHandle;
-                const jobStepHandle = root.creationContext.jobStepHandle;
-                const resourceShellKind = root.resourceShellKind;
-                const versionRaw = root.version;
-                const version = typeof versionRaw === 'number'
-                    ? versionRaw
-                    : parseInt(String(versionRaw ?? ''), 10);
-                const path = root.path;
-                const timestamp = root.timestamp;
-
-                const missing = [
-                    ['identity', identity],
-                    ['resourceRoleHandle', resourceRoleHandle],
-                    ['jobStepHandle', jobStepHandle],
-                    ['resourceShellKind', resourceShellKind],
-                    ['version', Number.isFinite(version) ? String(version) : ''],
-                    ['timestamp', timestamp],
-                    ['path', path],
-                ].filter(([_, v]) => typeof v !== 'string' || (v as string).length === 0) as Array<[string, string | undefined]>;
-
-                if (missing.length) {
-                    const keys = missing.map(([k]) => k).join(', ');
-                    throw new Error(`Missing required metadata keys [${keys}] for resource file: ${name}`);
-                }
-
-                return {
-                    identity,
-                    resourceTypeHandle,
-                    creationContext: {
-                        resourceRoleHandle,
-                        jobStepHandle,
-                    },
-                    resourceShellKind,
-                    version,
-                    timestamp: timestamp as string,
-                    path: path as string,
-                    nucleus: data as any,
-                } as unknown as ResourceJson;
-            });
-            return [resourceTypeHandle, items] as const;
-        })
-    );
-    return Object.fromEntries(entries) as ResourceMap;
-}
-
-
+import type {
+    ResourceJson,
+    ResourceTypeIdentityJson,
+    StepKindJson,
+} from '@toolproof-core/schema';
+import type { IdentityName, IdentityStringByIdentityName, StepIdentityStringByStepKind, ResourcesByResourceTypeHandle } from '../types/types.js';
+import { CONSTANTS } from '../artifacts/artifacts.js';
+import { MAPPINGS } from '../artifacts/artifacts.js';
+import { dbAdmin, storageAdmin } from "../_lib/setup/firebaseAdminInit.js";
+
+
+function capitalizeFirst(value: string): string {
+    if (!value) return value;
+    return value.charAt(0).toUpperCase() + value.slice(1);
+}
+
+export function getNewIdentity<K extends IdentityName>(identityName: K): IdentityStringByIdentityName<K> {
+    const prefix = MAPPINGS.IdentityNameToIdentityPrefix[identityName];
+    const docRef = dbAdmin
+        .collection(CONSTANTS.Persistence.Collections.resources)
+        .doc(identityName)
+        .collection(CONSTANTS.Persistence.Collections.members)
+        .doc();
+    return (prefix + docRef.id) as IdentityStringByIdentityName<K>;
+}
+
+export function getNewStepIdentity<K extends StepKindJson>(stepKind: K): StepIdentityStringByStepKind<K> {
+    const identityName = `${capitalizeFirst(stepKind)}StepIdentity` as IdentityName;
+    if (!(identityName in MAPPINGS.IdentityNameToIdentityPrefix)) {
+        throw new Error(`No IdentityNameToIdentityPrefix entry for derived step identity name: ${identityName}`);
+    }
+    return getNewIdentity(identityName) as StepIdentityStringByStepKind<K>;
+}
+
+export async function listResources(
+    resourceTypeHandles: ResourceTypeIdentityJson[]
+): Promise<ResourcesByResourceTypeHandle> {
+    const bucket_resources = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_resources);
+    const bucket_strategies = storageAdmin.bucket(CONSTANTS.Persistence.Buckets.tp_strategies);
+
+    async function fetchFilesUnder(resourceTypeHandle: ResourceTypeIdentityJson): Promise<Array<{ data: unknown; meta: any; name: string }>> {
+        const bucket = resourceTypeHandle === CONSTANTS.Cosmos.TYPE_RunnableStrategy
+            ? bucket_strategies
+            : bucket_resources;
+        const prefix = `${resourceTypeHandle}/`;
+        const [found] = await bucket.getFiles({ prefix });
+        const files = found.filter(f => {
+            const name = f.name || '';
+            if (!name || name.endsWith('/')) return false;
+            return true;
+        });
+        if (!files.length) return [];
+        const items = await Promise.all(files.map(async (file) => {
+            try {
+                const [buf] = await file.download();
+                const meta = file.metadata || (await file.getMetadata())[0];
+                const data = JSON.parse(buf.toString('utf8')) as unknown;
+                return { data, meta, name: file.name };
+            } catch {
+                return null as unknown as { data: unknown; meta: any; name: string };
+            }
+        }));
+        return items.filter(Boolean) as Array<{ data: unknown; meta: any; name: string }>;
+    }
+
+    const entries = await Promise.all(
+        resourceTypeHandles.map(async (resourceTypeHandle) => {
+            const rows = await fetchFilesUnder(resourceTypeHandle);
+            const items: ResourceJson[] = rows.map(({ data, meta, name }) => {
+                const flat = meta?.metadata ?? {};
+                // Reconstruct nested object from flattened keys (dot and array index notation)
+                const root: any = {};
+                for (const [k, vRaw] of Object.entries(flat)) {
+                    if (typeof vRaw !== 'string') continue; // GCS should store only strings
+                    const vStr = vRaw.trim();
+                    // Attempt JSON parse for non-simple primitives
+                    let value: any = vStr;
+                    if ((vStr.startsWith('{') && vStr.endsWith('}')) || (vStr.startsWith('[') && vStr.endsWith(']'))) {
+                        try { value = JSON.parse(vStr); } catch { value = vStr; }
+                    }
+                    // Split by '.' while preserving array indices
+                    const segments = k.split('.');
+                    let cursor = root;
+                    for (const [i, seg] of segments.entries()) {
+                        const arrIdxMatch = seg.match(/^(.*)\[(\d+)\]$/);
+                        if (arrIdxMatch) {
+                            const base = arrIdxMatch[1];
+                            const idxStr = arrIdxMatch[2];
+                            if (base === undefined || idxStr === undefined) continue;
+                            const idx = parseInt(idxStr, 10);
+                            if (!cursor[base]) cursor[base] = [];
+                            if (!Array.isArray(cursor[base])) cursor[base] = [];
+                            while (cursor[base].length <= idx) cursor[base].push(undefined);
+                            if (i === segments.length - 1) {
+                                cursor[base][idx] = value;
+                            } else {
+                                if (!cursor[base][idx]) cursor[base][idx] = {};
+                                cursor = cursor[base][idx];
+                            }
+                        } else {
+                            if (i === segments.length - 1) {
+                                cursor[seg] = value;
+                            } else {
+                                if (!cursor[seg] || typeof cursor[seg] !== 'object') cursor[seg] = {};
+                                cursor = cursor[seg];
+                            }
+                        }
+                    }
+                }
+                const identity = root.identity;
+                // const resourceTypeHandle = root.resourceTypeHandle; // we already have this
+                const resourceRoleHandle = root.creationContext.resourceRoleHandle;
+                const jobStepHandle = root.creationContext.jobStepHandle;
+                const resourceShellKind = root.resourceShellKind;
+                const versionRaw = root.version;
+                const version = typeof versionRaw === 'number'
+                    ? versionRaw
+                    : parseInt(String(versionRaw ?? ''), 10);
+                const path = root.path;
+                const timestamp = root.timestamp;
+
+                const missing = [
+                    ['identity', identity],
+                    ['resourceRoleHandle', resourceRoleHandle],
+                    ['jobStepHandle', jobStepHandle],
+                    ['resourceShellKind', resourceShellKind],
+                    ['version', Number.isFinite(version) ? String(version) : ''],
+                    ['timestamp', timestamp],
+                    ['path', path],
+                ].filter(([_, v]) => typeof v !== 'string' || (v as string).length === 0) as Array<[string, string | undefined]>;
+
+                if (missing.length) {
+                    const keys = missing.map(([k]) => k).join(', ');
+                    throw new Error(`Missing required metadata keys [${keys}] for resource file: ${name}`);
+                }
+
+                return {
+                    identity,
+                    resourceTypeHandle,
+                    creationContext: {
+                        resourceRoleHandle,
+                        jobStepHandle,
+                    },
+                    resourceShellKind,
+                    version,
+                    timestamp: timestamp as string,
+                    path: path as string,
+                    nucleus: data as any,
+                } as unknown as ResourceJson;
+            });
+            return [resourceTypeHandle, items] as const;
+        })
+    );
+    return Object.fromEntries(entries) as ResourcesByResourceTypeHandle;
+}
+
+