@warlock.js/cascade 4.0.48 → 4.0.58

package/cjs/sync/model-sync.js

@@ -0,0 +1,178 @@
+'use strict';var modelSyncOperation=require('./model-sync-operation.js');/**
+ * ModelSync facade for registering sync operations.
+ *
+ * Provides a clean API for defining sync relationships between models
+ * with automatic cleanup support for HMR (Hot Module Replacement).
+ *
+ * @module cascade-next/sync/model-sync
+ */
+/**
+ * ModelSync facade implementation.
+ *
+ * Manages sync operation registration with scoped cleanup support.
+ * Uses a registration stack to track operations created during
+ * a `register()` callback for proper HMR cleanup.
+ *
+ * @example
+ * ```typescript
+ * // In events file
+ * export const cleanup = modelSync.register(() => {
+ *   Category.sync(Product, "category");
+ *   Tag.syncMany(Post, "tags").identifyBy("id");
+ * });
+ * ```
+ */
+class ModelSyncFacade {
+    /**
+     * All active sync operations.
+     */
+    operations = [];
+    /**
+     * Stack for tracking operations during register() callbacks.
+     * Each element is an array of operations created in that scope.
+     */
+    registrationStack = [];
+    // ============================================================================
+    // PUBLIC API
+    // ============================================================================
+    /**
+     * Create a sync operation for a single embedded document.
+     *
+     * When the source model is updated, the target model's field
+     * will be updated with the embedded data.
+     *
+     * @param source - Source model class that triggers sync
+     * @param target - Target model class that receives data
+     * @param field - Field path in target model
+     * @returns Sync operation for chaining configuration
+     *
+     * @example
+     * ```typescript
+     * // When Category updates, update Product.category
+     * modelSync.sync(Category, Product, "category");
+     *
+     * // With configuration
+     * modelSync.sync(Category, Product, "category")
+     *   .embed("embedMinimal")
+     *   .watchFields(["name", "slug"]);
+     * ```
+     */
+    sync(source, target, field) {
+        const operation = new modelSyncOperation.ModelSyncOperation(source, target, field, false);
+        this.trackOperation(operation);
+        return operation;
+    }
+    /**
+     * Create a sync operation for an array of embedded documents.
+     *
+     * When the source model is updated, the corresponding element
+     * in the target model's array field will be updated.
+     *
+     * @param source - Source model class that triggers sync
+     * @param target - Target model class that receives data
+     * @param field - Array field path in target model
+     * @returns Sync operation for chaining configuration
+     *
+     * @example
+     * ```typescript
+     * // When Tag updates, update Post.tags[i] where tags[i].id matches
+     * modelSync.syncMany(Tag, Post, "tags").identifyBy("id");
+     * ```
+     */
+    syncMany(source, target, field) {
+        const operation = new modelSyncOperation.ModelSyncOperation(source, target, field, true);
+        this.trackOperation(operation);
+        return operation;
+    }
+    /**
+     * Register sync operations with automatic cleanup.
+     *
+     * Executes the callback function which should contain sync registrations.
+     * Returns a cleanup function that unsubscribes all operations created
+     * during the callback - perfect for HMR module cleanup.
+     *
+     * @param callback - Function that registers sync operations
+     * @returns Cleanup function that unsubscribes all registered operations
+     *
+     * @example
+     * ```typescript
+     * // In src/app/blog/events/sync.ts
+     * export const cleanup = modelSync.register(() => {
+     *   Category.sync(Product, "category");
+     *   Tag.syncMany(Post, "tags").identifyBy("id");
+     *   Author.sync(Article, "author").unsetOnDelete();
+     * });
+     * ```
+     */
+    register(callback) {
+        // Create a new scope for tracking operations
+        const scopedOperations = [];
+        this.registrationStack.push(scopedOperations);
+        try {
+            // Execute callback - operations are tracked via trackOperation()
+            callback();
+        }
+        finally {
+            // Remove the scope from stack
+            this.registrationStack.pop();
+        }
+        // Return cleanup function for just these scoped operations
+        return () => {
+            for (const operation of scopedOperations) {
+                operation.unsubscribe();
+                // Remove from global operations array
+                const index = this.operations.indexOf(operation);
+                if (index !== -1) {
+                    this.operations.splice(index, 1);
+                }
+            }
+        };
+    }
+    /**
+     * Clear all registered sync operations.
+     * Useful for testing or complete reset.
+     */
+    clear() {
+        for (const operation of this.operations) {
+            operation.unsubscribe();
+        }
+        this.operations.length = 0;
+    }
+    /**
+     * Get count of active sync operations.
+     * Useful for debugging and testing.
+     */
+    get count() {
+        return this.operations.length;
+    }
+    // ============================================================================
+    // PRIVATE HELPERS
+    // ============================================================================
+    /**
+     * Track a new operation in global list and current registration scope.
+     */
+    trackOperation(operation) {
+        // Always add to global operations
+        this.operations.push(operation);
+        // If inside a register() callback, also track in the current scope
+        const currentScope = this.registrationStack[this.registrationStack.length - 1];
+        if (currentScope) {
+            currentScope.push(operation);
+        }
+    }
+}
+/**
+ * Global modelSync facade instance.
+ *
+ * Use this to register sync operations between models.
+ *
+ * @example
+ * ```typescript
+ * import { modelSync } from "@warlock.js/cascade";
+ *
+ * export const cleanup = modelSync.register(() => {
+ *   Category.sync(Product, "category");
+ * });
+ * ```
+ */
+const modelSync = new ModelSyncFacade();exports.modelSync=modelSync;//# sourceMappingURL=model-sync.js.map

package/cjs/sync/model-sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-sync.js","sources":["../../src/sync/model-sync.ts"],"sourcesContent":[null],"names":["ModelSyncOperation"],"mappings":"yEAAA;;;;;;;AAOG;AAMH;;;;;;;;;;;;;;;AAeG;AACH,MAAM,eAAe,CAAA;AACnB;;AAEG;IACc,UAAU,GAAyB,EAAE,CAAC;AAEvD;;;AAGG;IACc,iBAAiB,GAA2B,EAAE,CAAC;;;;AAMhE;;;;;;;;;;;;;;;;;;;;;AAqBG;AACI,IAAA,IAAI,CACT,MAAyB,EACzB,MAAyB,EACzB,KAAa,EAAA;AAEb,QAAA,MAAM,SAAS,GAAG,IAAIA,qCAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;AACvE,QAAA,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;AAC/B,QAAA,OAAO,SAAS,CAAC;KAClB;AAED;;;;;;;;;;;;;;;;AAgBG;AACI,IAAA,QAAQ,CACb,MAAyB,EACzB,MAAyB,EACzB,KAAa,EAAA;AAEb,QAAA,MAAM,SAAS,GAAG,IAAIA,qCAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,CAAC,CAAC;AACtE,QAAA,IAAI,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;AAC/B,QAAA,OAAO,SAAS,CAAC;KAClB;AAED;;;;;;;;;;;;;;;;;;;AAmBG;AACI,IAAA,QAAQ,CAAC,QAAoB,EAAA;;QAElC,MAAM,gBAAgB,GAAyB,EAAE,CAAC;AAClD,QAAA,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,gBAAgB,CAAC,CAAC;QAE9C,IAAI;;AAEF,YAAA,QAAQ,EAAE,CAAC;AACZ,SAAA;AAAS,gBAAA;;AAER,YAAA,IAAI,CAAC,iBAAiB,CAAC,GAAG,EAAE,CAAC;AAC9B,SAAA;;AAGD,QAAA,OAAO,MAAK;AACV,YAAA,KAAK,MAAM,SAAS,IAAI,gBAAgB,EAAE;gBACxC,SAAS,CAAC,WAAW,EAAE,CAAC;;gBAGxB,MAAM,KAAK,GAAG,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;AACjD,gBAAA,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE;oBAChB,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AAClC,iBAAA;AACF,aAAA;AACH,SAAC,CAAC;KACH;AAED;;;AAGG;IACI,KAAK,GAAA;AACV,QAAA,KAAK,MAAM,SAAS,IAAI,IAAI,CAAC,UAAU,EAAE;YACvC,SAAS,CAAC,WAAW,EAAE,CAAC;AACzB,SAAA;AACD,QAAA,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC;KAC5B;AAED;;;AAGG;AACH,IAAA,IAAW,KAAK,GAAA;AACd,QAAA,OAAO,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC;KAC/B;;;;AAMD;;AAEG;AACK,IAAA,cAAc,CAAC,SAA6B,EAAA;;AAElD,QAAA,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;;AAGhC,QAAA,MAAM,YAAY,GAAG,IAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,iBAAiB,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;AAC/E,QAAA,IAAI,YAAY,EAAE;AAChB,YAAA,YAAY,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAC9B,SAAA;KACF;AACF,CAAA;AAED;;;;;;;;;;;;;AAaG;AACU,MAAA,SAAS,GAAG,IAAI,eAAe"}

package/cjs/sync/sync-context.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Sync context management and validation.
+ *
+ * @module cascade-next/sync/sync-context
+ */
+import type { SyncContext, SyncInstruction } from "./types";
+/**
+ * Default maximum sync depth.
+ * Prevents infinite sync chains.
+ */
+export declare const DEFAULT_MAX_SYNC_DEPTH = 3;
+/**
+ * Manages sync context and provides validation utilities.
+ */
+export declare class SyncContextManager {
+    /**
+     * Creates a new sync context from a sync instruction.
+     *
+     * @param instruction - The sync instruction to create context from
+     * @param affectedCount - Number of documents affected
+     * @returns A new sync context
+     */
+    static createContext(instruction: SyncInstruction, affectedCount: number): SyncContext;
+    /**
+     * Validates if a sync operation can proceed based on depth and cycle detection.
+     *
+     * @param depth - Current sync depth
+     * @param chain - Current sync chain
+     * @param targetModel - Target model name
+     * @param maxDepth - Maximum allowed depth
+     * @param preventCircular - Whether to prevent circular references
+     * @returns Validation result with success flag and optional error message
+     */
+    static validate(depth: number, chain: string[], targetModel: string, maxDepth: number, preventCircular: boolean): {
+        valid: boolean;
+        error?: string;
+    };
+    /**
+     * Checks if adding a target model would create a cycle in the sync chain.
+     *
+     * @param chain - Current sync chain
+     * @param targetModel - Model to be added to the chain
+     * @returns True if adding the model would create a cycle
+     */
+    static hasCycle(chain: string[], targetModel: string): boolean;
+    /**
+     * Creates a new sync chain by appending a model name.
+     *
+     * @param chain - Current sync chain
+     * @param modelName - Model name to append
+     * @returns New sync chain array
+     */
+    static extendChain(chain: string[], modelName: string): string[];
+    /**
+     * Formats a sync chain for display.
+     *
+     * @param chain - Sync chain to format
+     * @returns Formatted string (e.g., "Category → Product → Module")
+     */
+    static formatChain(chain: string[]): string;
+    /**
+     * Checks if the current depth allows for further syncing.
+     *
+     * @param currentDepth - Current depth in the chain
+     * @param maxDepth - Maximum allowed depth
+     * @returns True if more syncing is allowed
+     */
+    static canSyncDeeper(currentDepth: number, maxDepth: number): boolean;
+}
+//# sourceMappingURL=sync-context.d.ts.map

package/cjs/sync/sync-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-context.d.ts","sourceRoot":"","sources":["../../src/sync/sync-context.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE5D;;;GAGG;AACH,eAAO,MAAM,sBAAsB,IAAI,CAAC;AAExC;;GAEG;AACH,qBAAa,kBAAkB;IAC7B;;;;;;OAMG;WACW,aAAa,CACzB,WAAW,EAAE,eAAe,EAC5B,aAAa,EAAE,MAAM,GACpB,WAAW;IAcd;;;;;;;;;OASG;WACW,QAAQ,CACpB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EAAE,EACf,WAAW,EAAE,MAAM,EACnB,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,OAAO,GACvB;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE;IAoBrC;;;;;;OAMG;WACW,QAAQ,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO;IAIrE;;;;;;OAMG;WACW,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,EAAE;IAIvE;;;;;OAKG;WACW,WAAW,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM;IAIlD;;;;;;OAMG;WACW,aAAa,CACzB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,GACf,OAAO;CAGX"}

package/cjs/sync/sync-context.js

@@ -0,0 +1,101 @@
+'use strict';/**
+ * Sync context management and validation.
+ *
+ * @module cascade-next/sync/sync-context
+ */
+/**
+ * Default maximum sync depth.
+ * Prevents infinite sync chains.
+ */
+const DEFAULT_MAX_SYNC_DEPTH = 3;
+/**
+ * Manages sync context and provides validation utilities.
+ */
+class SyncContextManager {
+    /**
+     * Creates a new sync context from a sync instruction.
+     *
+     * @param instruction - The sync instruction to create context from
+     * @param affectedCount - Number of documents affected
+     * @returns A new sync context
+     */
+    static createContext(instruction, affectedCount) {
+        return {
+            sourceModel: instruction.sourceModel,
+            sourceId: instruction.sourceId,
+            currentDepth: instruction.depth,
+            syncChain: [...instruction.chain],
+            targetModel: instruction.targetModel,
+            filter: { ...instruction.filter },
+            update: { ...instruction.update },
+            affectedCount,
+            timestamp: new Date(),
+        };
+    }
+    /**
+     * Validates if a sync operation can proceed based on depth and cycle detection.
+     *
+     * @param depth - Current sync depth
+     * @param chain - Current sync chain
+     * @param targetModel - Target model name
+     * @param maxDepth - Maximum allowed depth
+     * @param preventCircular - Whether to prevent circular references
+     * @returns Validation result with success flag and optional error message
+     */
+    static validate(depth, chain, targetModel, maxDepth, preventCircular) {
+        // Check depth limit
+        if (depth > maxDepth) {
+            return {
+                valid: false,
+                error: `Sync depth limit exceeded: ${depth} > ${maxDepth}. Chain: ${chain.join(" → ")}`,
+            };
+        }
+        // Check for circular references
+        if (preventCircular && this.hasCycle(chain, targetModel)) {
+            return {
+                valid: false,
+                error: `Circular sync detected: ${targetModel} already exists in chain [${chain.join(" → ")}]`,
+            };
+        }
+        return { valid: true };
+    }
+    /**
+     * Checks if adding a target model would create a cycle in the sync chain.
+     *
+     * @param chain - Current sync chain
+     * @param targetModel - Model to be added to the chain
+     * @returns True if adding the model would create a cycle
+     */
+    static hasCycle(chain, targetModel) {
+        return chain.includes(targetModel);
+    }
+    /**
+     * Creates a new sync chain by appending a model name.
+     *
+     * @param chain - Current sync chain
+     * @param modelName - Model name to append
+     * @returns New sync chain array
+     */
+    static extendChain(chain, modelName) {
+        return [...chain, modelName];
+    }
+    /**
+     * Formats a sync chain for display.
+     *
+     * @param chain - Sync chain to format
+     * @returns Formatted string (e.g., "Category → Product → Module")
+     */
+    static formatChain(chain) {
+        return chain.join(" → ");
+    }
+    /**
+     * Checks if the current depth allows for further syncing.
+     *
+     * @param currentDepth - Current depth in the chain
+     * @param maxDepth - Maximum allowed depth
+     * @returns True if more syncing is allowed
+     */
+    static canSyncDeeper(currentDepth, maxDepth) {
+        return currentDepth < maxDepth;
+    }
+}exports.DEFAULT_MAX_SYNC_DEPTH=DEFAULT_MAX_SYNC_DEPTH;exports.SyncContextManager=SyncContextManager;//# sourceMappingURL=sync-context.js.map

package/cjs/sync/sync-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-context.js","sources":["../../src/sync/sync-context.ts"],"sourcesContent":[null],"names":[],"mappings":"aAAA;;;;AAIG;AAIH;;;AAGG;AACI,MAAM,sBAAsB,GAAG,EAAE;AAExC;;AAEG;MACU,kBAAkB,CAAA;AAC7B;;;;;;AAMG;AACI,IAAA,OAAO,aAAa,CACzB,WAA4B,EAC5B,aAAqB,EAAA;QAErB,OAAO;YACL,WAAW,EAAE,WAAW,CAAC,WAAW;YACpC,QAAQ,EAAE,WAAW,CAAC,QAAQ;YAC9B,YAAY,EAAE,WAAW,CAAC,KAAK;AAC/B,YAAA,SAAS,EAAE,CAAC,GAAG,WAAW,CAAC,KAAK,CAAC;YACjC,WAAW,EAAE,WAAW,CAAC,WAAW;AACpC,YAAA,MAAM,EAAE,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE;AACjC,YAAA,MAAM,EAAE,EAAE,GAAG,WAAW,CAAC,MAAM,EAAE;YACjC,aAAa;YACb,SAAS,EAAE,IAAI,IAAI,EAAE;SACtB,CAAC;KACH;AAED;;;;;;;;;AASG;IACI,OAAO,QAAQ,CACpB,KAAa,EACb,KAAe,EACf,WAAmB,EACnB,QAAgB,EAChB,eAAwB,EAAA;;QAGxB,IAAI,KAAK,GAAG,QAAQ,EAAE;YACpB,OAAO;AACL,gBAAA,KAAK,EAAE,KAAK;AACZ,gBAAA,KAAK,EAAE,CAAA,2BAAA,EAA8B,KAAK,CAAA,GAAA,EAAM,QAAQ,CAAA,SAAA,EAAY,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAE,CAAA;aACxF,CAAC;AACH,SAAA;;QAGD,IAAI,eAAe,IAAI,IAAI,CAAC,QAAQ,CAAC,KAAK,EAAE,WAAW,CAAC,EAAE;YACxD,OAAO;AACL,gBAAA,KAAK,EAAE,KAAK;gBACZ,KAAK,EAAE,CAA2B,wBAAA,EAAA,WAAW,CAA6B,0BAAA,EAAA,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAG,CAAA,CAAA;aAC/F,CAAC;AACH,SAAA;AAED,QAAA,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;KACxB;AAED;;;;;;AAMG;AACI,IAAA,OAAO,QAAQ,CAAC,KAAe,EAAE,WAAmB,EAAA;AACzD,QAAA,OAAO,KAAK,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;KACpC;AAED;;;;;;AAMG;AACI,IAAA,OAAO,WAAW,CAAC,KAAe,EAAE,SAAiB,EAAA;AAC1D,QAAA,OAAO,CAAC,GAAG,KAAK,EAAE,SAAS,CAAC,CAAC;KAC9B;AAED;;;;;AAKG;IACI,OAAO,WAAW,CAAC,KAAe,EAAA;AACvC,QAAA,OAAO,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;KAC1B;AAED;;;;;;AAMG;AACI,IAAA,OAAO,aAAa,CACzB,YAAoB,EACpB,QAAgB,EAAA;QAEhB,OAAO,YAAY,GAAG,QAAQ,CAAC;KAChC;AACF"}

package/cjs/sync/sync-manager.d.ts

@@ -0,0 +1,213 @@
+/**
+ * Sync manager service for handling multi-level sync operations.
+ *
+ * @module cascade-next/sync/sync-manager
+ */
+import type { DriverContract } from "../contracts/database-driver.contract";
+import { ChildModel, Model } from "../model/model";
+import type { SyncConfig, SyncResult } from "./types";
+/**
+ * Manages sync operations across models with multi-level support.
+ */
+export declare class SyncManager {
+    private readonly sourceModel;
+    private readonly driver;
+    /**
+     * Creates a new sync manager.
+     *
+     * @param sourceModel - The source model class
+     * @param driver - The database driver
+     */
+    constructor(sourceModel: ChildModel<Model>, driver: DriverContract);
+    /**
+     * Executes sync operations for a model update.
+     *
+     * @param sourceId - The source model ID
+     * @param updatedData - The updated data to sync (Model instance or plain data)
+     * @param changedFields - Fields that were changed (for filtering)
+     * @returns Sync result with success status and details
+     */
+    syncUpdate(sourceId: string | number, updatedData: Record<string, unknown> | Model, changedFields: string[]): Promise<SyncResult>;
+    /**
+     * Executes sync operations for a model update with a specific config.
+     * Used by ModelSyncOperation for event-based sync.
+     *
+     * @param sourceId - The source model ID
+     * @param updatedData - The updated data to sync
+     * @param changedFields - Fields that were changed
+     * @param config - The sync configuration to use
+     * @returns Sync result with success status and details
+     */
+    syncUpdateWithConfig(sourceId: string | number, updatedData: Record<string, unknown> | Model, changedFields: string[], config: SyncConfig): Promise<SyncResult>;
+    /**
+     * Executes sync delete operations with a specific config.
+     * Used by ModelSyncOperation for event-based sync.
+     *
+     * @param sourceId - The source model ID
+     * @param config - The sync configuration to use
+     * @returns Sync result with success status and details
+     */
+    syncDeleteWithConfig(sourceId: string | number, config: SyncConfig): Promise<SyncResult>;
+    /**
+     * Executes sync operations for a model deletion.
+     *
+     * @param sourceId - The source model ID
+     * @returns Sync result with success status and details
+     */
+    syncDelete(sourceId: string | number): Promise<SyncResult>;
+    /**
+     * Collects sync instructions recursively with depth limiting.
+     *
+     * @param payload - Data payload
+     * @returns Array of sync instructions
+     */
+    private collectInstructions;
+    /**
+     * Collects delete sync instructions.
+     *
+     * @param sourceId - Source model ID
+     * @param syncConfigs - Sync configurations
+     * @param options - Instruction options
+     * @returns Array of sync instructions
+     */
+    private collectDeleteInstructions;
+    /**
+     * Collects instructions for the next level in the sync chain.
+     *
+     * @param parentInstruction - The parent instruction
+     * @param embedData - Embedded data from parent
+     * @param changedFields - Changed fields
+     * @param parentConfig - Parent sync config
+     * @param parentOptions - Parent instruction options
+     * @returns Array of next-level sync instructions
+     */
+    private collectNextLevelInstructions;
+    /**
+     * Builds an update sync instruction.
+     *
+     * @param sourceId - Source model ID
+     * @param config - Sync configuration
+     * @param embedData - Embedded data to sync
+     * @param options - Instruction options
+     * @returns Sync instruction
+     */
+    private buildUpdateInstruction;
+    /**
+     * Builds a delete sync instruction.
+     *
+     * @param sourceId - Source model ID
+     * @param config - Sync configuration
+     * @param options - Instruction options
+     * @returns Sync instruction
+     */
+    private buildDeleteInstruction;
+    /**
+     * Builds a filter for identifying target documents.
+     *
+     * @param sourceId - Source model ID
+     * @param config - Sync configuration
+     * @returns Filter object
+     */
+    private buildFilter;
+    /**
+     * Builds an update operation for syncing data.
+     *
+     * @param embedData - Embedded data to sync
+     * @param config - Sync configuration
+     * @returns Update operation object
+     */
+    private buildUpdate;
+    /**
+     * Executes sync instructions with batch optimization.
+     * Groups by depth and target table for optimal batching.
+     *
+     * @param instructions - Array of sync instructions
+     * @returns Sync result
+     */
+    private executeInstructions;
+    /**
+     * Executes instructions in batch.
+     *
+     * @param instructions - Instructions to execute
+     * @param result - Result object to update
+     */
+    private executeBatch;
+    /**
+     * Executes instructions individually (fallback).
+     * Provides detailed error reporting for each failed instruction.
+     *
+     * @param instructions - Instructions to execute
+     * @param result - Result object to update
+     */
+    private executeIndividual;
+    /**
+     * Formats a sync error with detailed context.
+     *
+     * @param instruction - The failed instruction
+     * @param error - The error that occurred
+     * @returns Formatted error message
+     */
+    private formatSyncError;
+    /**
+     * Groups instructions by depth for batch processing.
+     *
+     * @param instructions - Instructions to group
+     * @returns Map of depth to instructions (sorted ascending)
+     */
+    private groupByDepth;
+    /**
+     * Groups instructions by target table for batch optimization.
+     *
+     * @param instructions - Instructions to group
+     * @returns Map of table name to instructions
+     */
+    private groupByTable;
+    /**
+     * Checks if sync should proceed based on watched fields.
+     *
+     * @param config - Sync configuration
+     * @param changedFields - Fields that changed
+     * @returns True if sync should proceed
+     */
+    private shouldSync;
+    /**
+     * Gets embedded data from the source model.
+     *
+     * @param data - Source model data or Model instance
+     * @param config - Sync configuration
+     * @returns Embedded data
+     */
+    private getEmbedData;
+    /**
+     * Gets sync configurations from the source model.
+     *
+     * @returns Array of sync configurations
+     */
+    private getSyncConfigs;
+    /**
+     * Gets sync configurations for a specific model.
+     *
+     * @param modelClass - The model class
+     * @returns Array of sync configurations
+     */
+    private getSyncConfigsForModel;
+    /**
+     * Emits a syncing event.
+     *
+     * @param instruction - The sync instruction
+     */
+    private emitSyncingEvent;
+    /**
+     * Emits a synced event.
+     *
+     * @param context - The sync context
+     */
+    private emitSyncedEvent;
+    /**
+     * Creates an empty sync result.
+     *
+     * @returns Empty sync result
+     */
+    private createEmptyResult;
+}
+//# sourceMappingURL=sync-manager.d.ts.map

package/cjs/sync/sync-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-manager.d.ts","sourceRoot":"","sources":["../../src/sync/sync-manager.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uCAAuC,CAAC;AAC5E,OAAO,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAEnD,OAAO,KAAK,EAEV,UAAU,EAIV,UAAU,EACX,MAAM,SAAS,CAAC;AAEjB;;GAEG;AACH,qBAAa,WAAW;IACtB,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAoB;IAChD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiB;IAExC;;;;;OAKG;gBACgB,WAAW,EAAE,UAAU,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,cAAc;IAKzE;;;;;;;OAOG;IACU,UAAU,CACrB,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,EAC5C,aAAa,EAAE,MAAM,EAAE,GACtB,OAAO,CAAC,UAAU,CAAC;IAsDtB;;;;;;;;;OASG;IACU,oBAAoB,CAC/B,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,EAC5C,aAAa,EAAE,MAAM,EAAE,EACvB,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,UAAU,CAAC;IAkDtB;;;;;;;OAOG;IACU,oBAAoB,CAC/B,QAAQ,EAAE,MAAM,GAAG,MAAM,EACzB,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC,UAAU,CAAC;IAgDtB;;;;;OAKG;IACU,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC;IAgDvE;;;;;OAKG;YACW,mBAAmB;IAqDjC;;;;;;;OAOG;YACW,yBAAyB;IAiCvC;;;;;;;;;OASG;YACW,4BAA4B;IAiC1C;;;;;;;;OAQG;IACH,OAAO,CAAC,sBAAsB;IAgC9B;;;;;;;OAOG;IACH,OAAO,CAAC,sBAAsB;IAqB9B;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAUnB;;;;;;OAMG;IACH,OAAO,CAAC,WAAW;IAanB;;;;;;OAMG;YACW,mBAAmB;IA0CjC;;;;;OAKG;YACW,YAAY;IAoB1B;;;;;;OAMG;YACW,iBAAiB;IAgD/B;;;;;;OAMG;IACH,OAAO,CAAC,eAAe;IAavB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAepB;;;;;OAKG;IACH,OAAO,CAAC,YAAY;IAcpB;;;;;;OAMG;IACH,OAAO,CAAC,UAAU;IAQlB;;;;;;OAMG;YACW,YAAY;IAyB1B;;;;OAIG;IACH,OAAO,CAAC,cAAc;IAYtB;;;;;OAKG;IACH,OAAO,CAAC,sBAAsB;IAY9B;;;;OAIG;YACW,gBAAgB;IAkB9B;;;;OAIG;YACW,eAAe;IAkB7B;;;;OAIG;IACH,OAAO,CAAC,iBAAiB;CAW1B"}