@toolproof-npm/shared 0.1.78 → 0.1.79

package/dist/_lib/utils/resourceCreation.d.ts

@@ -12,70 +12,35 @@ export declare function generateContentHash(content: string): string;
  * @returns The path in format: {resourceTypeRef}/{contentHash}
  */
 export declare function generateContentAddressedPath(resourceTypeRef: ResourceTypeIdentityJson, content: string): string;
-/**
- * Options for creating a materialized resource from a potential-output
- * Provide either 'path' OR 'content' (which generates a hash-based path)
- */
-export type CreateMaterializedResourceOptions = Pick<ResourceJson, 'extractedData'> & {
-    /** Explicit path (if provided, content is ignored) */
-    path?: string;
-    /** Content to hash for generating path (used if path not provided) */
-    content?: string;
-    /** Optional timestamp (defaults to current ISO timestamp) */
-    timestamp?: string;
-};
 /**
  * Options for creating a materialized resource from scratch
- * Provide either 'path' OR 'content' (which generates a hash-based path)
- * Omits 'kind' (always set to 'materialized') and makes 'timestamp' optional
+ * Omits 'kind' (always set to 'materialized'), 'path' (auto-generated), and makes 'timestamp' optional
  */
 export type CreateMaterializedResourceFromScratchOptions = Omit<ResourceJson, 'kind' | 'timestamp' | 'path'> & {
-    /** Explicit path (if provided, content is ignored) */
-    path?: string;
-    /** Content to hash for generating path (used if path not provided) */
-    content?: string;
-    /** Optional timestamp (defaults to current ISO timestamp) */
+    /** Optional timestamp (for replacing existing resources with same timestamp) */
     timestamp?: string;
 };
 /**
  * Creates a materialized resource from a potential-output resource.
- * Handles timestamp generation, extractedData normalization, path generation, and structural conversion.
+ * Converts the potential output to a materialized resource by generating a content-addressed path,
+ * assigning the content as extractedData, and creating a timestamp.
  *
  * @param potentialOutput The potential-output resource to materialize
- * @param options Configuration for the materialized resource
+ * @param content The actual content produced by the job (assigned directly to extractedData)
  * @returns A fully materialized ResourceJson
  *
  * @example
  * ```typescript
- * // With explicit path
- * const materialized = createMaterializedResource(potentialOutput, {
- *   path: 'TYPE-Natural/abc123...',
- *   extractedData: { identity: 42 },
- *   timestamp: '2025-01-03T12:00:00.000Z'
- * });
- *
- * // With content (generates hash-based path)
- * const materialized = createMaterializedResource(potentialOutput, {
- *   content: '{"identity": 42}',
- *   extractedData: { identity: 42 }
- * });
+ * const materialized = createMaterializedResourceFromPotentialOutput(
+ *   potentialOutput,
+ *   { identity: 42, someData: "result" }
+ * );
  * ```
  */
-export declare function createMaterializedResource(potentialOutput: ResourcePotentialOutputJson, options: CreateMaterializedResourceOptions): ResourceJson;
-/**
- * Normalizes extractedData to ensure consistent structure with an identity field.
- * Handles various input formats:
- * - Primitives (numbers, strings): wrapped in { identity: value }
- * - Objects with identity: preserved
- * - Objects without identity: identity extracted from first suitable field
- *
- * @param data The raw extracted data
- * @returns Normalized extractedData with identity field
- */
-export declare function normalizeExtractedData(data: JsonDataJson): JsonDataJson;
+export declare function createMaterializedResourceFromPotentialOutput(potentialOutput: ResourcePotentialOutputJson, content: JsonDataJson): ResourceJson;
 /**
  * Creates a materialized resource from scratch (for manual resource creation).
- * Handles timestamp generation, extractedData normalization, path generation, and structural validation.
+ * Generates a content-addressed path from the extractedData and creates a timestamp.
  * Use this when creating resources manually without a potential-output template.
  *
  * @param options All required fields for creating a materialized resource
@@ -83,7 +48,6 @@ export declare function normalizeExtractedData(data: JsonDataJson): JsonDataJson
  *
  * @example
  * ```typescript
- * // With explicit path
  * const materialized = createMaterializedResourceFromScratch({
  *   identity: 'RESOURCE-abc123',
  *   resourceTypeRef: 'TYPE-Natural',
@@ -91,21 +55,8 @@ export declare function normalizeExtractedData(data: JsonDataJson): JsonDataJson
  *     resourceRoleRef: 'ROLE-Manual',
  *     executionRef: 'EXECUTION-Genesis'
  *   },
- *   path: 'TYPE-Natural/def456...',
  *   extractedData: { identity: 42 },
- *   timestamp: '2025-01-03T12:00:00.000Z'
- * });
- *
- * // With content (generates hash-based path)
- * const materialized = createMaterializedResourceFromScratch({
- *   identity: 'RESOURCE-abc123',
- *   resourceTypeRef: 'TYPE-Natural',
- *   creationContext: {
- *     resourceRoleRef: 'ROLE-Manual',
- *     executionRef: 'EXECUTION-Genesis'
- *   },
- *   content: '{"identity": 42}',
- *   extractedData: { identity: 42 }
+ *   timestamp: '2025-01-03T12:00:00.000Z' // optional
  * });
  * ```
  */

package/dist/_lib/utils/resourceCreation.js

@@ -19,79 +19,38 @@ export function generateContentAddressedPath(resourceTypeRef, content) {
 }
 /**
  * Creates a materialized resource from a potential-output resource.
- * Handles timestamp generation, extractedData normalization, path generation, and structural conversion.
+ * Converts the potential output to a materialized resource by generating a content-addressed path,
+ * assigning the content as extractedData, and creating a timestamp.
  *
  * @param potentialOutput The potential-output resource to materialize
- * @param options Configuration for the materialized resource
+ * @param content The actual content produced by the job (assigned directly to extractedData)
  * @returns A fully materialized ResourceJson
  *
  * @example
  * ```typescript
- * // With explicit path
- * const materialized = createMaterializedResource(potentialOutput, {
- *   path: 'TYPE-Natural/abc123...',
- *   extractedData: { identity: 42 },
- *   timestamp: '2025-01-03T12:00:00.000Z'
- * });
- *
- * // With content (generates hash-based path)
- * const materialized = createMaterializedResource(potentialOutput, {
- *   content: '{"identity": 42}',
- *   extractedData: { identity: 42 }
- * });
+ * const materialized = createMaterializedResourceFromPotentialOutput(
+ *   potentialOutput,
+ *   { identity: 42, someData: "result" }
+ * );
  * ```
  */
-export function createMaterializedResource(potentialOutput, options) {
-    const { path, content, extractedData, timestamp } = options;
-    // Determine path: use explicit path or generate from content
-    const finalPath = path ?? (content ? generateContentAddressedPath(potentialOutput.resourceTypeRef, content) : '');
-    if (!finalPath) {
-        throw new Error('Either path or content must be provided');
-    }
-    // Normalize extractedData to ensure it has an identity field
-    const normalizedExtractedData = normalizeExtractedData(extractedData);
+export function createMaterializedResourceFromPotentialOutput(potentialOutput, content) {
+    // Generate content-addressed path from the content
+    const contentString = JSON.stringify(content);
+    const path = generateContentAddressedPath(potentialOutput.resourceTypeRef, contentString);
     return {
         identity: potentialOutput.identity,
         resourceTypeRef: potentialOutput.resourceTypeRef,
         creationContext: potentialOutput.creationContext,
         kind: 'materialized',
-        path: finalPath,
-        timestamp: timestamp ?? new Date().toISOString(),
-        extractedData: normalizedExtractedData,
-    };
-}
-/**
- * Normalizes extractedData to ensure consistent structure with an identity field.
- * Handles various input formats:
- * - Primitives (numbers, strings): wrapped in { identity: value }
- * - Objects with identity: preserved
- * - Objects without identity: identity extracted from first suitable field
- *
- * @param data The raw extracted data
- * @returns Normalized extractedData with identity field
- */
-export function normalizeExtractedData(data) {
-    // If data is a primitive, wrap it
-    if (typeof data !== 'object' || data === null) {
-        return { identity: data };
-    }
-    // If data is an object
-    const dataObj = data;
-    // If it already has an identity field, preserve everything
-    if ('identity' in dataObj) {
-        return data;
-    }
-    // Otherwise, try to extract an identity value from common patterns
-    // This handles cases where the data might have a value field or similar
-    const identityValue = dataObj.value ?? dataObj.id ?? dataObj.result ?? 0;
-    return {
-        identity: identityValue,
-        ...dataObj,
+        path,
+        timestamp: new Date().toISOString(),
+        extractedData: content,
     };
 }
 /**
  * Creates a materialized resource from scratch (for manual resource creation).
- * Handles timestamp generation, extractedData normalization, path generation, and structural validation.
+ * Generates a content-addressed path from the extractedData and creates a timestamp.
  * Use this when creating resources manually without a potential-output template.
  *
  * @param options All required fields for creating a materialized resource
@@ -99,7 +58,6 @@ export function normalizeExtractedData(data) {
  *
  * @example
  * ```typescript
- * // With explicit path
  * const materialized = createMaterializedResourceFromScratch({
  *   identity: 'RESOURCE-abc123',
  *   resourceTypeRef: 'TYPE-Natural',
@@ -107,40 +65,23 @@ export function normalizeExtractedData(data) {
  *     resourceRoleRef: 'ROLE-Manual',
  *     executionRef: 'EXECUTION-Genesis'
  *   },
- *   path: 'TYPE-Natural/def456...',
  *   extractedData: { identity: 42 },
- *   timestamp: '2025-01-03T12:00:00.000Z'
- * });
- *
- * // With content (generates hash-based path)
- * const materialized = createMaterializedResourceFromScratch({
- *   identity: 'RESOURCE-abc123',
- *   resourceTypeRef: 'TYPE-Natural',
- *   creationContext: {
- *     resourceRoleRef: 'ROLE-Manual',
- *     executionRef: 'EXECUTION-Genesis'
- *   },
- *   content: '{"identity": 42}',
- *   extractedData: { identity: 42 }
+ *   timestamp: '2025-01-03T12:00:00.000Z' // optional
  * });
  * ```
  */
 export function createMaterializedResourceFromScratch(options) {
-    const { identity, resourceTypeRef, creationContext, path, content, extractedData, timestamp } = options;
-    // Determine path: use explicit path or generate from content
-    const finalPath = path ?? (content ? generateContentAddressedPath(resourceTypeRef, content) : '');
-    if (!finalPath) {
-        throw new Error('Either path or content must be provided');
-    }
-    // Normalize extractedData to ensure it has an identity field
-    const normalizedExtractedData = normalizeExtractedData(extractedData);
+    const { identity, resourceTypeRef, creationContext, extractedData, timestamp } = options;
+    // Generate content-addressed path from the extractedData
+    const contentString = JSON.stringify(extractedData);
+    const path = generateContentAddressedPath(resourceTypeRef, contentString);
     return {
         identity,
         resourceTypeRef,
         creationContext,
         kind: 'materialized',
-        path: finalPath,
+        path,
         timestamp: timestamp ?? new Date().toISOString(),
-        extractedData: normalizedExtractedData,
+        extractedData,
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolproof-npm/shared",
-  "version": "0.1.78",
+  "version": "0.1.79",
   "description": "Core library utilities for ToolProof",
   "keywords": [
     "toolproof",