@memberjunction/core-entities 2.104.0 → 2.106.0

package/dist/artifact-extraction/artifact-extract-rules.d.ts

@@ -0,0 +1,163 @@
+/**
+ * @fileoverview TypeScript types for artifact extract rules system.
+ *
+ * This module defines the structure for extract rules that enable artifact types
+ * to declaratively specify how to extract attributes from artifact content.
+ * Extract rules support hierarchical inheritance through parent artifact types.
+ *
+ * @module @memberjunction/core-entities
+ * @since 2.105.0
+ */
+/**
+ * Standard properties that extracted attributes can map to for UI rendering.
+ * These provide semantic meaning to extracted values beyond custom attributes.
+ */
+export type ArtifactStandardProperty = 'name' | 'description' | 'displayMarkdown' | 'displayHtml';
+/**
+ * Definition of a single extraction rule that defines how to extract an attribute
+ * from artifact content.
+ *
+ * Extract rules are stored as JSON in the ArtifactType.ExtractRules column and
+ * support hierarchical inheritance where child types can override parent rules.
+ *
+ * @example
+ * ```typescript
+ * const emailSubjectRule: ArtifactExtractRule = {
+ *   name: 'subject',
+ *   description: 'Email subject line',
+ *   type: 'string',
+ *   standardProperty: 'name',
+ *   extractor: `
+ *     // content is the artifact content (JSON, text, etc.)
+ *     const parsed = JSON.parse(content);
+ *     return parsed.subject;
+ *   `
+ * };
+ * ```
+ */
+export interface ArtifactExtractRule {
+    /**
+     * Unique name for this extraction rule within the artifact type hierarchy.
+     * Used as the key for overriding parent rules and for storing extracted values.
+     */
+    name: string;
+    /**
+     * Human-readable description of what this rule extracts.
+     */
+    description: string;
+    /**
+     * TypeScript type definition for the extracted value.
+     *
+     * Can be:
+     * - Primitive types: 'string', 'number', 'boolean', 'Date'
+     * - Complex types: 'Array<string>', 'Record<string, any>'
+     * - Custom interfaces: 'Array<{x: number, y: string}>'
+     *
+     * @example 'string'
+     * @example 'number'
+     * @example 'Array<{id: string, name: string}>'
+     */
+    type: string;
+    /**
+     * Optional mapping to a standard property for UI rendering.
+     *
+     * When set, this extracted value can be used by the UI for specific purposes:
+     * - 'name': Display name of the artifact
+     * - 'description': Description/summary of the artifact
+     * - 'displayMarkdown': Markdown-formatted display content
+     * - 'displayHtml': HTML-formatted display content
+     *
+     * If undefined, this is a custom attribute specific to the artifact type.
+     */
+    standardProperty?: ArtifactStandardProperty;
+    /**
+     * JavaScript code that performs the extraction.
+     *
+     * The extractor function receives the artifact content as input and returns
+     * the extracted value. The function body should be valid JavaScript that:
+     *
+     * 1. Receives a 'content' variable (string) containing the artifact content
+     * 2. Performs necessary parsing/extraction logic
+     * 3. Returns a value matching the declared 'type'
+     *
+     * Security Note: This code is executed in a sandboxed environment.
+     * You may not access external resources or do anything that would result in side effects.
+     *
+     * @example
+     * ```javascript
+     * // Extract subject from JSON email
+     * const parsed = JSON.parse(content);
+     * return parsed.subject || 'Untitled';
+     * ```
+     *
+     * @example
+     * ```javascript
+     * // Extract first heading from Markdown
+     * const match = content.match(/^#\s+(.+)$/m);
+     * return match ? match[1] : null;
+     * ```
+     */
+    extractor: string;
+}
+/**
+ * Result of extracting attributes from artifact content using extract rules.
+ * This is the runtime representation of extracted values.
+ */
+export interface ExtractedArtifactAttribute {
+    /** Name of the extracted attribute (from rule.name) */
+    name: string;
+    /** TypeScript type of the value (from rule.type) */
+    type: string;
+    /** The extracted value (JSON-serializable) */
+    value: any;
+    /** Optional mapping to standard property (from rule.standardProperty) */
+    standardProperty?: ArtifactStandardProperty;
+}
+/**
+ * Configuration for running artifact extraction.
+ * Provides context and options for the extraction process.
+ */
+export interface ArtifactExtractionConfig {
+    /**
+     * The artifact content to extract from.
+     * This is typically the Content field from ArtifactVersion.
+     */
+    content: string;
+    /**
+     * Array of extract rules to apply.
+     * These should be the resolved rules after inheritance from parent types.
+     */
+    extractRules: ArtifactExtractRule[];
+    /**
+     * Whether to throw errors on extraction failures or continue with null values.
+     * Default: false (continue on errors)
+     */
+    throwOnError?: boolean;
+    /**
+     * Maximum execution time for each extractor function in milliseconds.
+     * Default: 5000ms (5 seconds)
+     */
+    timeout?: number;
+    /**
+     * Whether to enable verbose logging during extraction.
+     * Default: false
+     */
+    verbose?: boolean;
+}
+/**
+ * Result of running artifact extraction on content.
+ */
+export interface ArtifactExtractionResult {
+    /** Whether the extraction completed successfully */
+    success: boolean;
+    /** Array of successfully extracted attributes */
+    attributes: ExtractedArtifactAttribute[];
+    /** Array of errors that occurred during extraction */
+    errors: Array<{
+        ruleName: string;
+        error: string;
+    }>;
+    /** Total extraction time in milliseconds */
+    executionTimeMs: number;
+}
+//# sourceMappingURL=artifact-extract-rules.d.ts.map

package/dist/artifact-extraction/artifact-extract-rules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-extract-rules.d.ts","sourceRoot":"","sources":["../../src/artifact-extraction/artifact-extract-rules.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH;;;GAGG;AACH,MAAM,MAAM,wBAAwB,GAAG,MAAM,GAAG,aAAa,GAAG,iBAAiB,GAAG,aAAa,CAAC;AAElG;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,WAAW,mBAAmB;IAChC;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;;;;;OAWG;IACH,IAAI,EAAE,MAAM,CAAC;IAEb;;;;;;;;;;OAUG;IACH,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,SAAS,EAAE,MAAM,CAAC;CACrB;AAED;;;GAGG;AACH,MAAM,WAAW,0BAA0B;IACvC,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IAEb,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAC;IAEb,8CAA8C;IAC9C,KAAK,EAAE,GAAG,CAAC;IAEX,yEAAyE;IACzE,gBAAgB,CAAC,EAAE,wBAAwB,CAAC;CAC/C;AAED;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACrC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,YAAY,EAAE,mBAAmB,EAAE,CAAC;IAEpC;;;OAGG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;IAEjB;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACrC,oDAAoD;IACpD,OAAO,EAAE,OAAO,CAAC;IAEjB,iDAAiD;IACjD,UAAU,EAAE,0BAA0B,EAAE,CAAC;IAEzC,sDAAsD;IACtD,MAAM,EAAE,KAAK,CAAC;QACV,QAAQ,EAAE,MAAM,CAAC;QACjB,KAAK,EAAE,MAAM,CAAC;KACjB,CAAC,CAAC;IAEH,4CAA4C;IAC5C,eAAe,EAAE,MAAM,CAAC;CAC3B"}

package/dist/artifact-extraction/artifact-extract-rules.js

@@ -0,0 +1,13 @@
+"use strict";
+/**
+ * @fileoverview TypeScript types for artifact extract rules system.
+ *
+ * This module defines the structure for extract rules that enable artifact types
+ * to declaratively specify how to extract attributes from artifact content.
+ * Extract rules support hierarchical inheritance through parent artifact types.
+ *
+ * @module @memberjunction/core-entities
+ * @since 2.105.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=artifact-extract-rules.js.map

package/dist/artifact-extraction/artifact-extract-rules.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-extract-rules.js","sourceRoot":"","sources":["../../src/artifact-extraction/artifact-extract-rules.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG"}

package/dist/artifact-extraction/artifact-extractor.d.ts

@@ -0,0 +1,157 @@
+/**
+ * @fileoverview Artifact attribute extraction utilities with hierarchical rule inheritance.
+ *
+ * This module provides functionality for extracting attributes from artifact content
+ * based on extract rules defined in artifact types. Supports hierarchical inheritance
+ * where child artifact types can override parent rules.
+ *
+ * @module @memberjunction/core-entities
+ * @since 2.105.0
+ */
+import { ArtifactExtractRule, ExtractedArtifactAttribute, ArtifactExtractionConfig, ArtifactExtractionResult } from './artifact-extract-rules';
+/**
+ * Utility class for managing artifact extract rules and performing extraction.
+ *
+ * Handles:
+ * - Hierarchical rule inheritance from parent artifact types
+ * - Rule override resolution (child rules override parent rules by name)
+ * - Safe execution of extractor JavaScript code
+ * - Error handling and timeout management
+ */
+export declare class ArtifactExtractor {
+    /**
+     * Resolves extract rules with hierarchical inheritance.
+     *
+     * Child artifact types inherit all rules from their parent/grandparent types,
+     * but can override rules with the same name. This method resolves the final
+     * set of rules by walking up the hierarchy and merging rules.
+     *
+     * @param artifactTypeChain - Array of artifact types from most specific (child) to least specific (root parent)
+     *                           Each element should have an ExtractRules JSON string
+     * @returns Resolved array of extract rules with overrides applied
+     *
+     * @example
+     * ```typescript
+     * // Parent type has rules: [{ name: 'title', ... }, { name: 'author', ... }]
+     * // Child type has rules: [{ name: 'title', ... (override) }, { name: 'date', ... (new) }]
+     * const resolved = ArtifactExtractor.ResolveExtractRules([
+     *   childType.ExtractRules,
+     *   parentType.ExtractRules
+     * ]);
+     * // Result: [{ name: 'title' (from child), ... }, { name: 'author' (from parent), ... }, { name: 'date' (from child), ... }]
+     * ```
+     */
+    static ResolveExtractRules(artifactTypeChain: Array<{
+        ExtractRules?: string | null;
+    }>): ArtifactExtractRule[];
+    /**
+     * Extracts attributes from artifact content using the provided extract rules.
+     *
+     * Executes each extractor function in a controlled environment with timeout
+     * and error handling. Failed extractors can either throw or return null values
+     * based on configuration.
+     *
+     * @param config - Extraction configuration including content and rules
+     * @returns Extraction result with attributes, errors, and timing information
+     *
+     * @example
+     * ```typescript
+     * const result = await ArtifactExtractor.ExtractAttributes({
+     *   content: '{"subject": "Hello", "body": "World"}',
+     *   extractRules: [
+     *     {
+     *       name: 'subject',
+     *       type: 'string',
+     *       standardProperty: 'name',
+     *       extractor: 'const parsed = JSON.parse(content); return parsed.subject;'
+     *     }
+     *   ]
+     * });
+     * // result.attributes = [{ name: 'subject', type: 'string', value: 'Hello', standardProperty: 'name' }]
+     * ```
+     */
+    static ExtractAttributes(config: ArtifactExtractionConfig): Promise<ArtifactExtractionResult>;
+    /**
+     * Executes an extractor function with timeout protection.
+     *
+     * Creates a sandboxed environment where the extractor code can run safely
+     * with access to the content but isolated from the global scope.
+     *
+     * @param content - The artifact content to extract from
+     * @param extractorCode - JavaScript code that performs the extraction
+     * @param timeoutMs - Maximum execution time in milliseconds
+     * @returns The extracted value
+     * @throws Error if execution times out or fails
+     *
+     * @private
+     */
+    private static ExecuteExtractor;
+    /**
+     * Serializes extracted attributes for storage in ArtifactVersionAttribute table.
+     *
+     * Converts extracted attribute values to JSON strings suitable for database storage.
+     *
+     * @param attributes - Array of extracted attributes
+     * @returns Array of objects ready for database insertion
+     *
+     * @example
+     * ```typescript
+     * const serialized = ArtifactExtractor.SerializeForStorage(result.attributes);
+     * // Can now insert these into ArtifactVersionAttribute table
+     * for (const attr of serialized) {
+     *   await artifactVersionAttribute.save({
+     *     ArtifactVersionID: versionId,
+     *     Name: attr.name,
+     *     Type: attr.type,
+     *     Value: attr.value,
+     *     StandardProperty: attr.standardProperty
+     *   });
+     * }
+     * ```
+     */
+    static SerializeForStorage(attributes: ExtractedArtifactAttribute[]): Array<{
+        name: string;
+        type: string;
+        value: string;
+        standardProperty?: string;
+    }>;
+    /**
+     * Deserializes stored attributes from ArtifactVersionAttribute records.
+     *
+     * Converts JSON strings back to their original types for use in application.
+     *
+     * @param storedAttributes - Array of attribute records from database
+     * @returns Array of extracted attributes with deserialized values
+     *
+     * @example
+     * ```typescript
+     * const stored = await artifactVersionAttributes.load();
+     * const attributes = ArtifactExtractor.DeserializeFromStorage(stored);
+     * // attributes have parsed JSON values, not strings
+     * ```
+     */
+    static DeserializeFromStorage(storedAttributes: Array<{
+        Name: string;
+        Type: string;
+        Value: string;
+        StandardProperty?: string | null;
+    }>): ExtractedArtifactAttribute[];
+    /**
+     * Finds a specific standard property value from extracted attributes.
+     *
+     * Convenience method for retrieving attributes mapped to standard properties
+     * like 'name', 'description', etc.
+     *
+     * @param attributes - Array of extracted attributes
+     * @param standardProperty - The standard property to find
+     * @returns The value of the attribute, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const name = ArtifactExtractor.GetStandardProperty(attributes, 'name');
+     * const description = ArtifactExtractor.GetStandardProperty(attributes, 'description');
+     * ```
+     */
+    static GetStandardProperty(attributes: ExtractedArtifactAttribute[], standardProperty: 'name' | 'description' | 'displayMarkdown' | 'displayHtml'): any | null;
+}
+//# sourceMappingURL=artifact-extractor.d.ts.map

package/dist/artifact-extraction/artifact-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-extractor.d.ts","sourceRoot":"","sources":["../../src/artifact-extraction/artifact-extractor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EACH,mBAAmB,EACnB,0BAA0B,EAC1B,wBAAwB,EACxB,wBAAwB,EAC3B,MAAM,0BAA0B,CAAC;AAElC;;;;;;;;GAQG;AACH,qBAAa,iBAAiB;IAC1B;;;;;;;;;;;;;;;;;;;;;OAqBG;WACW,mBAAmB,CAAC,iBAAiB,EAAE,KAAK,CAAC;QAAE,YAAY,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;KAAE,CAAC,GAAG,mBAAmB,EAAE;IA4BpH;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;WACiB,iBAAiB,CAAC,MAAM,EAAE,wBAAwB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IA+D1G;;;;;;;;;;;;;OAaG;mBACkB,gBAAgB;IA6BrC;;;;;;;;;;;;;;;;;;;;;;OAsBG;WACW,mBAAmB,CAAC,UAAU,EAAE,0BAA0B,EAAE,GAAG,KAAK,CAAC;QAC/E,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC7B,CAAC;IASF;;;;;;;;;;;;;;OAcG;WACW,sBAAsB,CAAC,gBAAgB,EAAE,KAAK,CAAC;QACzD,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,EAAE,MAAM,CAAC;QACd,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;KACpC,CAAC,GAAG,0BAA0B,EAAE;IASjC;;;;;;;;;;;;;;;OAeG;WACW,mBAAmB,CAC7B,UAAU,EAAE,0BAA0B,EAAE,EACxC,gBAAgB,EAAE,MAAM,GAAG,aAAa,GAAG,iBAAiB,GAAG,aAAa,GAC7E,GAAG,GAAG,IAAI;CAIhB"}

package/dist/artifact-extraction/artifact-extractor.js

@@ -0,0 +1,265 @@
+"use strict";
+/**
+ * @fileoverview Artifact attribute extraction utilities with hierarchical rule inheritance.
+ *
+ * This module provides functionality for extracting attributes from artifact content
+ * based on extract rules defined in artifact types. Supports hierarchical inheritance
+ * where child artifact types can override parent rules.
+ *
+ * @module @memberjunction/core-entities
+ * @since 2.105.0
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArtifactExtractor = void 0;
+/**
+ * Utility class for managing artifact extract rules and performing extraction.
+ *
+ * Handles:
+ * - Hierarchical rule inheritance from parent artifact types
+ * - Rule override resolution (child rules override parent rules by name)
+ * - Safe execution of extractor JavaScript code
+ * - Error handling and timeout management
+ */
+class ArtifactExtractor {
+    /**
+     * Resolves extract rules with hierarchical inheritance.
+     *
+     * Child artifact types inherit all rules from their parent/grandparent types,
+     * but can override rules with the same name. This method resolves the final
+     * set of rules by walking up the hierarchy and merging rules.
+     *
+     * @param artifactTypeChain - Array of artifact types from most specific (child) to least specific (root parent)
+     *                           Each element should have an ExtractRules JSON string
+     * @returns Resolved array of extract rules with overrides applied
+     *
+     * @example
+     * ```typescript
+     * // Parent type has rules: [{ name: 'title', ... }, { name: 'author', ... }]
+     * // Child type has rules: [{ name: 'title', ... (override) }, { name: 'date', ... (new) }]
+     * const resolved = ArtifactExtractor.ResolveExtractRules([
+     *   childType.ExtractRules,
+     *   parentType.ExtractRules
+     * ]);
+     * // Result: [{ name: 'title' (from child), ... }, { name: 'author' (from parent), ... }, { name: 'date' (from child), ... }]
+     * ```
+     */
+    static ResolveExtractRules(artifactTypeChain) {
+        const rulesMap = new Map();
+        // Process from root parent to child (reverse order)
+        // This way child rules naturally override parent rules
+        for (let i = artifactTypeChain.length - 1; i >= 0; i--) {
+            const artifactType = artifactTypeChain[i];
+            if (!artifactType.ExtractRules) {
+                continue;
+            }
+            try {
+                const rules = JSON.parse(artifactType.ExtractRules);
+                if (Array.isArray(rules)) {
+                    for (const rule of rules) {
+                        // Child rules override parent rules by name
+                        rulesMap.set(rule.name, rule);
+                    }
+                }
+            }
+            catch (error) {
+                console.error(`Failed to parse ExtractRules for artifact type at index ${i}:`, error);
+                // Continue processing other levels
+            }
+        }
+        return Array.from(rulesMap.values());
+    }
+    /**
+     * Extracts attributes from artifact content using the provided extract rules.
+     *
+     * Executes each extractor function in a controlled environment with timeout
+     * and error handling. Failed extractors can either throw or return null values
+     * based on configuration.
+     *
+     * @param config - Extraction configuration including content and rules
+     * @returns Extraction result with attributes, errors, and timing information
+     *
+     * @example
+     * ```typescript
+     * const result = await ArtifactExtractor.ExtractAttributes({
+     *   content: '{"subject": "Hello", "body": "World"}',
+     *   extractRules: [
+     *     {
+     *       name: 'subject',
+     *       type: 'string',
+     *       standardProperty: 'name',
+     *       extractor: 'const parsed = JSON.parse(content); return parsed.subject;'
+     *     }
+     *   ]
+     * });
+     * // result.attributes = [{ name: 'subject', type: 'string', value: 'Hello', standardProperty: 'name' }]
+     * ```
+     */
+    static async ExtractAttributes(config) {
+        const startTime = Date.now();
+        const attributes = [];
+        const errors = [];
+        const timeout = config.timeout ?? 5000;
+        const throwOnError = config.throwOnError ?? false;
+        const verbose = config.verbose ?? false;
+        for (const rule of config.extractRules) {
+            try {
+                if (verbose) {
+                    console.log(`Extracting attribute '${rule.name}' using rule:`, rule);
+                }
+                // Execute the extractor function with timeout
+                const value = await this.ExecuteExtractor(config.content, rule.extractor, timeout);
+                attributes.push({
+                    name: rule.name,
+                    type: rule.type,
+                    value,
+                    standardProperty: rule.standardProperty
+                });
+                if (verbose) {
+                    console.log(`Successfully extracted '${rule.name}':`, value);
+                }
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                errors.push({
+                    ruleName: rule.name,
+                    error: errorMessage
+                });
+                if (verbose) {
+                    console.error(`Failed to extract '${rule.name}':`, errorMessage);
+                }
+                if (throwOnError) {
+                    throw new Error(`Extraction failed for rule '${rule.name}': ${errorMessage}`);
+                }
+                // Add null value for failed extraction when not throwing
+                attributes.push({
+                    name: rule.name,
+                    type: rule.type,
+                    value: null,
+                    standardProperty: rule.standardProperty
+                });
+            }
+        }
+        const executionTimeMs = Date.now() - startTime;
+        return {
+            success: errors.length === 0,
+            attributes,
+            errors,
+            executionTimeMs
+        };
+    }
+    /**
+     * Executes an extractor function with timeout protection.
+     *
+     * Creates a sandboxed environment where the extractor code can run safely
+     * with access to the content but isolated from the global scope.
+     *
+     * @param content - The artifact content to extract from
+     * @param extractorCode - JavaScript code that performs the extraction
+     * @param timeoutMs - Maximum execution time in milliseconds
+     * @returns The extracted value
+     * @throws Error if execution times out or fails
+     *
+     * @private
+     */
+    static async ExecuteExtractor(content, extractorCode, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            // Set up timeout
+            const timeoutId = setTimeout(() => {
+                reject(new Error(`Extractor execution timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+            try {
+                // Create a function from the extractor code
+                // The extractor receives 'content' as a parameter
+                const extractorFn = new Function('content', extractorCode);
+                // Execute the extractor
+                let result = extractorFn(content);
+                // Handle the case where extractor returns string "null" instead of null
+                if (typeof result === "string" && result.trim().toLowerCase() === "null") {
+                    result = null;
+                }
+                clearTimeout(timeoutId);
+                resolve(result);
+            }
+            catch (error) {
+                clearTimeout(timeoutId);
+                reject(error);
+            }
+        });
+    }
+    /**
+     * Serializes extracted attributes for storage in ArtifactVersionAttribute table.
+     *
+     * Converts extracted attribute values to JSON strings suitable for database storage.
+     *
+     * @param attributes - Array of extracted attributes
+     * @returns Array of objects ready for database insertion
+     *
+     * @example
+     * ```typescript
+     * const serialized = ArtifactExtractor.SerializeForStorage(result.attributes);
+     * // Can now insert these into ArtifactVersionAttribute table
+     * for (const attr of serialized) {
+     *   await artifactVersionAttribute.save({
+     *     ArtifactVersionID: versionId,
+     *     Name: attr.name,
+     *     Type: attr.type,
+     *     Value: attr.value,
+     *     StandardProperty: attr.standardProperty
+     *   });
+     * }
+     * ```
+     */
+    static SerializeForStorage(attributes) {
+        return attributes.map(attr => ({
+            name: attr.name,
+            type: attr.type,
+            value: JSON.stringify(attr.value),
+            standardProperty: attr.standardProperty
+        }));
+    }
+    /**
+     * Deserializes stored attributes from ArtifactVersionAttribute records.
+     *
+     * Converts JSON strings back to their original types for use in application.
+     *
+     * @param storedAttributes - Array of attribute records from database
+     * @returns Array of extracted attributes with deserialized values
+     *
+     * @example
+     * ```typescript
+     * const stored = await artifactVersionAttributes.load();
+     * const attributes = ArtifactExtractor.DeserializeFromStorage(stored);
+     * // attributes have parsed JSON values, not strings
+     * ```
+     */
+    static DeserializeFromStorage(storedAttributes) {
+        return storedAttributes.map(attr => ({
+            name: attr.Name,
+            type: attr.Type,
+            value: JSON.parse(attr.Value),
+            standardProperty: attr.StandardProperty
+        }));
+    }
+    /**
+     * Finds a specific standard property value from extracted attributes.
+     *
+     * Convenience method for retrieving attributes mapped to standard properties
+     * like 'name', 'description', etc.
+     *
+     * @param attributes - Array of extracted attributes
+     * @param standardProperty - The standard property to find
+     * @returns The value of the attribute, or null if not found
+     *
+     * @example
+     * ```typescript
+     * const name = ArtifactExtractor.GetStandardProperty(attributes, 'name');
+     * const description = ArtifactExtractor.GetStandardProperty(attributes, 'description');
+     * ```
+     */
+    static GetStandardProperty(attributes, standardProperty) {
+        const attr = attributes.find(a => a.standardProperty === standardProperty);
+        return attr?.value ?? null;
+    }
+}
+exports.ArtifactExtractor = ArtifactExtractor;
+//# sourceMappingURL=artifact-extractor.js.map

package/dist/artifact-extraction/artifact-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-extractor.js","sourceRoot":"","sources":["../../src/artifact-extraction/artifact-extractor.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AASH;;;;;;;;GAQG;AACH,MAAa,iBAAiB;IAC1B;;;;;;;;;;;;;;;;;;;;;OAqBG;IACI,MAAM,CAAC,mBAAmB,CAAC,iBAA0D;QACxF,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA+B,CAAC;QAExD,oDAAoD;QACpD,uDAAuD;QACvD,KAAK,IAAI,CAAC,GAAG,iBAAiB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;YACrD,MAAM,YAAY,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAAC;YAC1C,IAAI,CAAC,YAAY,CAAC,YAAY,EAAE,CAAC;gBAC7B,SAAS;YACb,CAAC;YAED,IAAI,CAAC;gBACD,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,YAAY,CAA0B,CAAC;gBAC7E,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;oBACvB,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;wBACvB,4CAA4C;wBAC5C,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;oBAClC,CAAC;gBACL,CAAC;YACL,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACb,OAAO,CAAC,KAAK,CAAC,2DAA2D,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;gBACtF,mCAAmC;YACvC,CAAC;QACL,CAAC;QAED,OAAO,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;IACzC,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;OAyBG;IACI,MAAM,CAAC,KAAK,CAAC,iBAAiB,CAAC,MAAgC;QAClE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC7B,MAAM,UAAU,GAAiC,EAAE,CAAC;QACpD,MAAM,MAAM,GAA+C,EAAE,CAAC;QAE9D,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,IAAI,CAAC;QACvC,MAAM,YAAY,GAAG,MAAM,CAAC,YAAY,IAAI,KAAK,CAAC;QAClD,MAAM,OAAO,GAAG,MAAM,CAAC,OAAO,IAAI,KAAK,CAAC;QAExC,KAAK,MAAM,IAAI,IAAI,MAAM,CAAC,YAAY,EAAE,CAAC;YACrC,IAAI,CAAC;gBACD,IAAI,OAAO,EAAE,CAAC;oBACV,OAAO,CAAC,GAAG,CAAC,yBAAyB,IAAI,CAAC,IAAI,eAAe,EAAE,IAAI,CAAC,CAAC;gBACzE,CAAC;gBAED,8CAA8C;gBAC9C,MAAM,KAAK,GAAG,MAAM,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC;gBAEnF,UAAU,CAAC,IAAI,CAAC;oBACZ,IAAI,EAAE,IAAI,CAAC,IAAI;oBACf,IAAI,EAAE,IAAI,CAAC,IAAI;oBACf,KAAK;oBACL,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;iBAC1C,CAAC,CAAC;gBAEH,IAAI,OAAO,EAAE,CAAC;oBACV,OAAO,CAAC,GAAG,CAAC,2BAA2B,IAAI,CAAC,IAAI,IAAI,EAAE,KAAK,CAAC,CAAC;gBACjE,CAAC;YACL,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACb,MAAM,YAAY,GAAG,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;gBAC5E,MAAM,CAAC,IAAI,CAAC;oBACR,QAAQ,EAAE,IAAI,CAAC,IAAI;oBACnB,KAAK,EAAE,YAAY;iBACtB,CAAC,CAAC;gBAEH,IAAI,OAAO,EAAE,CAAC;oBACV,OAAO,CAAC,KAAK,CAAC,sBAAsB,IAAI,CAAC,IAAI,IAAI,EAAE,YAAY,CAAC,CAAC;gBACrE,CAAC;gBAED,IAAI,YAAY,EAAE,CAAC;oBACf,MAAM,IAAI,KAAK,CAAC,+BAA+B,IAAI,CAAC,IAAI,MAAM,YAAY,EAAE,CAAC,CAAC;gBAClF,CAAC;gBAED,yDAAyD;gBACzD,UAAU,CAAC,IAAI,CAAC;oBACZ,IAAI,EAAE,IAAI,CAAC,IAAI;oBACf,IAAI,EAAE,IAAI,CAAC,IAAI;oBACf,KAAK,EAAE,IAAI;oBACX,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;iBAC1C,CAAC,CAAC;YACP,CAAC;QACL,CAAC;QAED,MAAM,eAAe,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;QAE/C,OAAO;YACH,OAAO,EAAE,MAAM,CAAC,MAAM,KAAK,CAAC;YAC5B,UAAU;YACV,MAAM;YACN,eAAe;SAClB,CAAC;IACN,CAAC;IAED;;;;;;;;;;;;;OAaG;IACK,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAAC,OAAe,EAAE,aAAqB,EAAE,SAAiB;QAC3F,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;YACnC,iBAAiB;YACjB,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE;gBAC9B,MAAM,CAAC,IAAI,KAAK,CAAC,uCAAuC,SAAS,IAAI,CAAC,CAAC,CAAC;YAC5E,CAAC,EAAE,SAAS,CAAC,CAAC;YAEd,IAAI,CAAC;gBACD,4CAA4C;gBAC5C,kDAAkD;gBAClD,MAAM,WAAW,GAAG,IAAI,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;gBAE3D,wBAAwB;gBACxB,IAAI,MAAM,GAAG,WAAW,CAAC,OAAO,CAAC,CAAC;gBAElC,wEAAwE;gBACxE,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,WAAW,EAAE,KAAK,MAAM,EAAE,CAAC;oBACvE,MAAM,GAAG,IAAI,CAAC;gBAClB,CAAC;gBAED,YAAY,CAAC,SAAS,CAAC,CAAC;gBACxB,OAAO,CAAC,MAAM,CAAC,CAAC;YACpB,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACb,YAAY,CAAC,SAAS,CAAC,CAAC;gBACxB,MAAM,CAAC,KAAK,CAAC,CAAC;YAClB,CAAC;QACL,CAAC,CAAC,CAAC;IACP,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACI,MAAM,CAAC,mBAAmB,CAAC,UAAwC;QAMtE,OAAO,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC3B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,KAAK,CAAC;YACjC,gBAAgB,EAAE,IAAI,CAAC,gBAAgB;SAC1C,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;;;;;;;;;;;;;OAcG;IACI,MAAM,CAAC,sBAAsB,CAAC,gBAKnC;QACE,OAAO,gBAAgB,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YACjC,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC;YAC7B,gBAAgB,EAAE,IAAI,CAAC,gBAAuB;SACjD,CAAC,CAAC,CAAC;IACR,CAAC;IAED;;;;;;;;;;;;;;;OAeG;IACI,MAAM,CAAC,mBAAmB,CAC7B,UAAwC,EACxC,gBAA4E;QAE5E,MAAM,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,gBAAgB,KAAK,gBAAgB,CAAC,CAAC;QAC3E,OAAO,IAAI,EAAE,KAAK,IAAI,IAAI,CAAC;IAC/B,CAAC;CACJ;AAhRD,8CAgRC"}

package/dist/custom/TemplateEntityExtended.d.ts

@@ -0,0 +1,59 @@
+import { ValidationResult } from "@memberjunction/core";
+import { TemplateContentEntity, TemplateEntity, TemplateParamEntity } from "../generated/entity_subclasses";
+export declare class TemplateEntityExtended extends TemplateEntity {
+    private _Content;
+    get Content(): TemplateContentEntity[];
+    set Content(value: TemplateContentEntity[]);
+    private _Params;
+    get Params(): TemplateParamEntity[];
+    set Params(value: TemplateParamEntity[]);
+    /**
+     * Returns all content for a given type for the template
+     * @param type
+     * @returns
+     */
+    GetContentByType(type: string): TemplateContentEntity[];
+    /**
+     * Returns the highest priority content for the template
+     * @param type If provided, returns the highest priority content of the specified type
+     * @returns
+     */
+    GetHighestPriorityContent(type?: string): TemplateContentEntity;
+    /**
+     * Returns all parameters that apply to a specific template content.
+     * This includes both global parameters (where TemplateContentID is NULL)
+     * and content-specific parameters for the given contentId.
+     *
+     * @param contentId - The ID of the template content. If not provided, returns only global parameters.
+     * @returns Array of TemplateParamEntity objects that apply to the specified content
+     *
+     * @example
+     * // Get all parameters for a specific content
+     * const params = template.GetParametersForContent('content-uuid');
+     *
+     * @example
+     * // Get only global parameters (that apply to all contents)
+     * const globalParams = template.GetParametersForContent();
+     */
+    GetParametersForContent(contentId?: string): TemplateParamEntity[];
+    /**
+     * This method is different from the Validate() method which validates the state of the Template itself.
+     * This method validates the data object provided meets the requirements for the template's parameter definitions.
+     *
+     * @param data - the data object to validate against the template's parameter definitions
+     * @param contentId - Optional: The ID of the template content to validate against.
+     *                    If provided, validates against parameters specific to that content.
+     *                    If not provided, validates against all parameters.
+     * @returns ValidationResult with success status and any validation errors
+     *
+     * @example
+     * // Validate against all parameters
+     * const result = template.ValidateTemplateInput(inputData);
+     *
+     * @example
+     * // Validate against parameters for a specific content
+     * const result = template.ValidateTemplateInput(inputData, 'content-uuid');
+     */
+    ValidateTemplateInput(data: any, contentId?: string): ValidationResult;
+}
+//# sourceMappingURL=TemplateEntityExtended.d.ts.map