@memberjunction/metadata-sync 2.84.0 → 2.86.0

package/dist/lib/sync-engine.d.ts

@@ -34,7 +34,6 @@ export interface RecordData {
  * @example
  * ```typescript
  * const syncEngine = new SyncEngine(systemUser);
- * await syncEngine.initialize();
  *
  * // Process a field value with special references
  * const value = await syncEngine.processFieldValue('@lookup:Users.Email=admin@example.com', '/path/to/base');
@@ -52,7 +51,7 @@ export declare class SyncEngine {
      * Initializes the sync engine by refreshing metadata cache
      * @returns Promise that resolves when initialization is complete
      */
-    initialize(forceRefresh?: boolean): Promise<void>;
+    initialize(): Promise<void>;
     /**
      * Process special references in field values and handle complex objects
      *
@@ -88,7 +87,7 @@ export declare class SyncEngine {
      * // Returns: '{\n  "items": [\n    {\n      "id": 1\n    },\n    {\n      "id": 2\n    }\n  ]\n}'
      * ```
      */
-    processFieldValue(value: any, baseDir: string, parentRecord?: BaseEntity | null, rootRecord?: BaseEntity | null, depth?: number): Promise<any>;
+    processFieldValue(value: any, baseDir: string, parentRecord?: BaseEntity | null, rootRecord?: BaseEntity | null, depth?: number, batchContext?: Map<string, BaseEntity>): Promise<any>;
     /**
      * Resolve a lookup reference to an ID, optionally creating the record if it doesn't exist
      *
@@ -115,7 +114,7 @@ export declare class SyncEngine {
     resolveLookup(entityName: string, lookupFields: Array<{
         fieldName: string;
         fieldValue: string;
-    }>, autoCreate?: boolean, createFields?: Record<string, any>): Promise<string>;
+    }>, autoCreate?: boolean, createFields?: Record<string, any>, batchContext?: Map<string, BaseEntity>): Promise<string>;
     /**
      * Build cascading defaults for a file path and process field values
      *
@@ -244,49 +243,6 @@ export declare class SyncEngine {
      * ```
      */
     loadEntity(entityName: string, primaryKey: Record<string, any>): Promise<BaseEntity | null>;
-    /**
-     * Process JSON object with template references
-     *
-     * Recursively processes JSON data structures to resolve `@template` references.
-     * Templates can be defined at any level and support:
-     * - Single template references: `"@template:path/to/template.json"`
-     * - Object with @template field: `{ "@template": "file.json", "override": "value" }`
-     * - Array of templates for merging: `{ "@template": ["base.json", "overrides.json"] }`
-     * - Nested template references within templates
-     *
-     * @param data - JSON data structure to process
-     * @param baseDir - Base directory for resolving relative template paths
-     * @returns Promise resolving to the processed data with all templates resolved
-     * @throws Error if template file is not found or contains invalid JSON
-     *
-     * @example
-     * ```typescript
-     * // Input data with template reference
-     * const data = {
-     *   "@template": "defaults/ai-prompt.json",
-     *   "Name": "Custom Prompt",
-     *   "Prompt": "Override the template prompt"
-     * };
-     *
-     * // Resolves template and merges with overrides
-     * const result = await syncEngine.processTemplates(data, '/path/to/dir');
-     * ```
-     */
-    processTemplates(data: any, baseDir: string): Promise<any>;
-    /**
-     * Load and process a template file
-     *
-     * Loads a JSON template file from the filesystem and recursively processes any
-     * nested template references within it. Template paths are resolved relative to
-     * the template file's directory, enabling template composition.
-     *
-     * @param templatePath - Path to the template file (relative or absolute)
-     * @param baseDir - Base directory for resolving relative paths
-     * @returns Promise resolving to the processed template content
-     * @throws Error if template file not found or contains invalid JSON
-     * @private
-     */
-    private loadAndProcessTemplate;
     /**
      * Process file content with {@include} references
      *
@@ -297,8 +253,8 @@ export declare class SyncEngine {
      * - Circular reference detection to prevent infinite loops
      * - Seamless content substitution maintaining surrounding text
      *
-     * @param filePath - Path to the file being processed
      * @param content - The file content to process
+     * @param filePath - Path to the file being processed
      * @param visitedPaths - Set of already visited file paths for circular reference detection
      * @returns Promise resolving to the content with all includes resolved
      * @throws Error if circular reference detected or included file not found
@@ -314,33 +270,4 @@ export declare class SyncEngine {
      * ```
      */
     private processFileContentWithIncludes;
-    /**
-     * Deep merge two objects with target taking precedence
-     *
-     * Recursively merges two objects, with values from the target object overriding
-     * values from the source object. Arrays and primitive values are not merged but
-     * replaced entirely by the target value. Undefined values in target are skipped.
-     *
-     * @param source - Base object to merge from
-     * @param target - Object with values that override source
-     * @returns New object with merged values
-     * @private
-     *
-     * @example
-     * ```typescript
-     * const source = {
-     *   a: 1,
-     *   b: { x: 10, y: 20 },
-     *   c: [1, 2, 3]
-     * };
-     * const target = {
-     *   a: 2,
-     *   b: { y: 30, z: 40 },
-     *   d: 'new'
-     * };
-     * const result = deepMerge(source, target);
-     * // Result: { a: 2, b: { x: 10, y: 30, z: 40 }, c: [1, 2, 3], d: 'new' }
-     * ```
-     */
-    private deepMerge;
 }

package/dist/lib/sync-engine.js

@@ -25,7 +25,6 @@ const core_1 = require("@memberjunction/core");
  * @example
  * ```typescript
  * const syncEngine = new SyncEngine(systemUser);
- * await syncEngine.initialize();
  *
  * // Process a field value with special references
  * const value = await syncEngine.processFieldValue('@lookup:Users.Email=admin@example.com', '/path/to/base');
@@ -46,10 +45,9 @@ class SyncEngine {
      * Initializes the sync engine by refreshing metadata cache
      * @returns Promise that resolves when initialization is complete
      */
-    async initialize(forceRefresh = false) {
-        if (forceRefresh) {
-            await this.metadata.Refresh();
-        }
+    async initialize() {
+        // Currently no initialization needed as metadata is managed globally
+        // Keeping this method for backward compatibility and future use
     }
     /**
      * Process special references in field values and handle complex objects
@@ -86,7 +84,7 @@ class SyncEngine {
      * // Returns: '{\n  "items": [\n    {\n      "id": 1\n    },\n    {\n      "id": 2\n    }\n  ]\n}'
      * ```
      */
-    async processFieldValue(value, baseDir, parentRecord, rootRecord, depth = 0) {
+    async processFieldValue(value, baseDir, parentRecord, rootRecord, depth = 0, batchContext) {
         // Check recursion depth limit
         const MAX_RECURSION_DEPTH = 50;
         if (depth > MAX_RECURSION_DEPTH) {
@@ -127,7 +125,7 @@ class SyncEngine {
             if (await fs_extra_1.default.pathExists(fullPath)) {
                 const fileContent = await fs_extra_1.default.readFile(fullPath, 'utf-8');
                 // Process the file content for {@include} references
-                return await this.processFileContentWithIncludes(fullPath, fileContent);
+                return await this.processFileContentWithIncludes(fileContent, fullPath);
             }
             else {
                 throw new Error(`File not found: ${fullPath}`);
@@ -168,7 +166,7 @@ class SyncEngine {
                 }
                 const [, fieldName, fieldValue] = fieldMatch;
                 // Recursively process the field value to resolve any nested @ commands
-                const processedValue = await this.processFieldValue(fieldValue.trim(), baseDir, parentRecord, rootRecord, depth + 1);
+                const processedValue = await this.processFieldValue(fieldValue.trim(), baseDir, parentRecord, rootRecord, depth + 1, batchContext);
                 lookupFields.push({ fieldName: fieldName.trim(), fieldValue: processedValue });
             }
             if (lookupFields.length === 0) {
@@ -184,11 +182,11 @@ class SyncEngine {
                     if (key && val) {
                         const decodedVal = decodeURIComponent(val);
                         // Recursively process the field value to resolve any nested @ commands
-                        createFields[key] = await this.processFieldValue(decodedVal, baseDir, parentRecord, rootRecord, depth + 1);
+                        createFields[key] = await this.processFieldValue(decodedVal, baseDir, parentRecord, rootRecord, depth + 1, batchContext);
                     }
                 }
             }
-            return await this.resolveLookup(entityName, lookupFields, hasCreate, createFields);
+            return await this.resolveLookup(entityName, lookupFields, hasCreate, createFields, batchContext);
         }
         // Check for @env: reference
         if (value.startsWith('@env:')) {
@@ -224,8 +222,36 @@ class SyncEngine {
      * });
      * ```
      */
-    async resolveLookup(entityName, lookupFields, autoCreate = false, createFields = {}) {
-        // Debug logging handled by caller if needed
+    async resolveLookup(entityName, lookupFields, autoCreate = false, createFields = {}, batchContext) {
+        // First check batch context for in-memory entities
+        if (batchContext) {
+            // Try to find the entity in batch context
+            for (const [, entity] of batchContext) {
+                // Check if this is the right entity type
+                if (entity.EntityInfo?.Name === entityName) {
+                    // Check if all lookup fields match
+                    let allMatch = true;
+                    for (const { fieldName, fieldValue } of lookupFields) {
+                        const entityValue = entity.Get(fieldName);
+                        const normalizedEntityValue = entityValue?.toString() || '';
+                        const normalizedLookupValue = fieldValue?.toString() || '';
+                        if (normalizedEntityValue !== normalizedLookupValue) {
+                            allMatch = false;
+                            break;
+                        }
+                    }
+                    if (allMatch) {
+                        // Found in batch context, return primary key
+                        const entityInfo = this.metadata.EntityByName(entityName);
+                        if (entityInfo && entityInfo.PrimaryKeys.length > 0) {
+                            const pkeyField = entityInfo.PrimaryKeys[0].Name;
+                            return entity.Get(pkeyField);
+                        }
+                    }
+                }
+            }
+        }
+        // Not found in batch context, check database
         const rv = new core_1.RunView();
         const entityInfo = this.metadata.EntityByName(entityName);
         if (!entityInfo) {
@@ -565,103 +591,6 @@ class SyncEngine {
         const loaded = await entity.InnerLoad(compositeKey);
         return loaded ? entity : null;
     }
-    /**
-     * Process JSON object with template references
-     *
-     * Recursively processes JSON data structures to resolve `@template` references.
-     * Templates can be defined at any level and support:
-     * - Single template references: `"@template:path/to/template.json"`
-     * - Object with @template field: `{ "@template": "file.json", "override": "value" }`
-     * - Array of templates for merging: `{ "@template": ["base.json", "overrides.json"] }`
-     * - Nested template references within templates
-     *
-     * @param data - JSON data structure to process
-     * @param baseDir - Base directory for resolving relative template paths
-     * @returns Promise resolving to the processed data with all templates resolved
-     * @throws Error if template file is not found or contains invalid JSON
-     *
-     * @example
-     * ```typescript
-     * // Input data with template reference
-     * const data = {
-     *   "@template": "defaults/ai-prompt.json",
-     *   "Name": "Custom Prompt",
-     *   "Prompt": "Override the template prompt"
-     * };
-     *
-     * // Resolves template and merges with overrides
-     * const result = await syncEngine.processTemplates(data, '/path/to/dir');
-     * ```
-     */
-    async processTemplates(data, baseDir) {
-        // Handle arrays
-        if (Array.isArray(data)) {
-            const processedArray = [];
-            for (const item of data) {
-                processedArray.push(await this.processTemplates(item, baseDir));
-            }
-            return processedArray;
-        }
-        // Handle objects
-        if (data && typeof data === 'object') {
-            // Check for @template reference
-            if (typeof data === 'string' && data.startsWith('@template:')) {
-                const templatePath = data.substring(10);
-                return await this.loadAndProcessTemplate(templatePath, baseDir);
-            }
-            // Process object with possible @template field
-            const processed = {};
-            let templateData = {};
-            // First, check if there's a @template field to process
-            if (data['@template']) {
-                const templates = Array.isArray(data['@template']) ? data['@template'] : [data['@template']];
-                // Process templates in order, merging them
-                for (const templateRef of templates) {
-                    const templateContent = await this.loadAndProcessTemplate(templateRef, baseDir);
-                    templateData = this.deepMerge(templateData, templateContent);
-                }
-            }
-            // Process all other fields
-            for (const [key, value] of Object.entries(data)) {
-                if (key === '@template')
-                    continue; // Skip the template field itself
-                // Process the value recursively
-                processed[key] = await this.processTemplates(value, baseDir);
-            }
-            // Merge template data with processed data (processed data takes precedence)
-            return this.deepMerge(templateData, processed);
-        }
-        // Return primitive values as-is
-        return data;
-    }
-    /**
-     * Load and process a template file
-     *
-     * Loads a JSON template file from the filesystem and recursively processes any
-     * nested template references within it. Template paths are resolved relative to
-     * the template file's directory, enabling template composition.
-     *
-     * @param templatePath - Path to the template file (relative or absolute)
-     * @param baseDir - Base directory for resolving relative paths
-     * @returns Promise resolving to the processed template content
-     * @throws Error if template file not found or contains invalid JSON
-     * @private
-     */
-    async loadAndProcessTemplate(templatePath, baseDir) {
-        const fullPath = path_1.default.resolve(baseDir, templatePath);
-        if (!await fs_extra_1.default.pathExists(fullPath)) {
-            throw new Error(`Template file not found: ${fullPath}`);
-        }
-        try {
-            const templateContent = await fs_extra_1.default.readJson(fullPath);
-            // Recursively process any nested templates
-            const templateDir = path_1.default.dirname(fullPath);
-            return await this.processTemplates(templateContent, templateDir);
-        }
-        catch (error) {
-            throw new Error(`Failed to load template ${fullPath}: ${error}`);
-        }
-    }
     /**
      * Process file content with {@include} references
      *
@@ -672,8 +601,8 @@ class SyncEngine {
      * - Circular reference detection to prevent infinite loops
      * - Seamless content substitution maintaining surrounding text
      *
-     * @param filePath - Path to the file being processed
      * @param content - The file content to process
+     * @param filePath - Path to the file being processed
      * @param visitedPaths - Set of already visited file paths for circular reference detection
      * @returns Promise resolving to the content with all includes resolved
      * @throws Error if circular reference detected or included file not found
@@ -688,7 +617,7 @@ class SyncEngine {
      * // 'This is a [contents of header.md] example'
      * ```
      */
-    async processFileContentWithIncludes(filePath, content, visitedPaths = new Set()) {
+    async processFileContentWithIncludes(content, filePath, visitedPaths = new Set()) {
         // Add current file to visited set
         const absolutePath = path_1.default.resolve(filePath);
         if (visitedPaths.has(absolutePath)) {
@@ -715,7 +644,7 @@ class SyncEngine {
                 // Read the included file
                 const includedContent = await fs_extra_1.default.readFile(resolvedPath, 'utf-8');
                 // Recursively process the included content for nested includes
-                const processedInclude = await this.processFileContentWithIncludes(resolvedPath, includedContent, new Set(visitedPaths) // Pass a copy to allow the same file in different branches
+                const processedInclude = await this.processFileContentWithIncludes(includedContent, resolvedPath, new Set(visitedPaths) // Pass a copy to allow the same file in different branches
                 );
                 // Replace the {@include} reference with the processed content
                 processedContent = processedContent.replace(fullMatch, processedInclude);
@@ -727,65 +656,6 @@ class SyncEngine {
         }
         return processedContent;
     }
-    /**
-     * Deep merge two objects with target taking precedence
-     *
-     * Recursively merges two objects, with values from the target object overriding
-     * values from the source object. Arrays and primitive values are not merged but
-     * replaced entirely by the target value. Undefined values in target are skipped.
-     *
-     * @param source - Base object to merge from
-     * @param target - Object with values that override source
-     * @returns New object with merged values
-     * @private
-     *
-     * @example
-     * ```typescript
-     * const source = {
-     *   a: 1,
-     *   b: { x: 10, y: 20 },
-     *   c: [1, 2, 3]
-     * };
-     * const target = {
-     *   a: 2,
-     *   b: { y: 30, z: 40 },
-     *   d: 'new'
-     * };
-     * const result = deepMerge(source, target);
-     * // Result: { a: 2, b: { x: 10, y: 30, z: 40 }, c: [1, 2, 3], d: 'new' }
-     * ```
-     */
-    deepMerge(source, target) {
-        if (!source)
-            return target;
-        if (!target)
-            return source;
-        // If target is not an object, it completely overrides source
-        if (typeof target !== 'object' || target === null || Array.isArray(target)) {
-            return target;
-        }
-        // If source is not an object, target wins
-        if (typeof source !== 'object' || source === null || Array.isArray(source)) {
-            return target;
-        }
-        // Both are objects, merge them
-        const result = { ...source };
-        for (const [key, value] of Object.entries(target)) {
-            if (value === undefined) {
-                continue; // Skip undefined values
-            }
-            if (typeof value === 'object' && value !== null && !Array.isArray(value) &&
-                typeof result[key] === 'object' && result[key] !== null && !Array.isArray(result[key])) {
-                // Both are objects, merge recursively
-                result[key] = this.deepMerge(result[key], value);
-            }
-            else {
-                // Otherwise, target value wins
-                result[key] = value;
-            }
-        }
-        return result;
-    }
 }
 exports.SyncEngine = SyncEngine;
 //# sourceMappingURL=sync-engine.js.map