@warlock.js/cascade 4.0.174 → 4.1.1

package/esm/sync/model-sync.mjs

@@ -0,0 +1,157 @@
+import { ModelSyncOperation } from "./model-sync-operation.mjs";
+
+//#region ../../@warlock.js/cascade/src/sync/model-sync.ts
+/**
+* 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");
+* });
+* ```
+*/
+var ModelSyncFacade = class {
+	/**
+	* All active sync operations.
+	*/
+	operations = [];
+	/**
+	* Stack for tracking operations during register() callbacks.
+	* Each element is an array of operations created in that scope.
+	*/
+	registrationStack = [];
+	/**
+	* 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(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(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) {
+		const scopedOperations = [];
+		this.registrationStack.push(scopedOperations);
+		try {
+			callback();
+		} finally {
+			this.registrationStack.pop();
+		}
+		return () => {
+			for (const operation of scopedOperations) {
+				operation.unsubscribe();
+				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;
+	}
+	/**
+	* Track a new operation in global list and current registration scope.
+	*/
+	trackOperation(operation) {
+		this.operations.push(operation);
+		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();
+
+//#endregion
+export { modelSync };
+//# sourceMappingURL=model-sync.mjs.map

package/esm/sync/model-sync.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"model-sync.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/sync/model-sync.ts"],"sourcesContent":["/**\n * ModelSync facade for registering sync operations.\n *\n * Provides a clean API for defining sync relationships between models\n * with automatic cleanup support for HMR (Hot Module Replacement).\n *\n * @module cascade-next/sync/model-sync\n */\n\nimport type { ChildModel, Model } from \"../model/model\";\nimport { ModelSyncOperation } from \"./model-sync-operation\";\nimport type { ModelSyncContract, ModelSyncOperationContract } from \"./types\";\n\n/**\n * ModelSync facade implementation.\n *\n * Manages sync operation registration with scoped cleanup support.\n * Uses a registration stack to track operations created during\n * a `register()` callback for proper HMR cleanup.\n *\n * @example\n * ```typescript\n * // In events file\n * export const cleanup = modelSync.register(() => {\n *   Category.sync(Product, \"category\");\n *   Tag.syncMany(Post, \"tags\").identifyBy(\"id\");\n * });\n * ```\n */\nclass ModelSyncFacade implements ModelSyncContract {\n  /**\n   * All active sync operations.\n   */\n  private readonly operations: ModelSyncOperation[] = [];\n\n  /**\n   * Stack for tracking operations during register() callbacks.\n   * Each element is an array of operations created in that scope.\n   */\n  private readonly registrationStack: ModelSyncOperation[][] = [];\n\n  // ============================================================================\n  // PUBLIC API\n  // ============================================================================\n\n  /**\n   * Create a sync operation for a single embedded document.\n   *\n   * When the source model is updated, the target model's field\n   * will be updated with the embedded data.\n   *\n   * @param source - Source model class that triggers sync\n   * @param target - Target model class that receives data\n   * @param field - Field path in target model\n   * @returns Sync operation for chaining configuration\n   *\n   * @example\n   * ```typescript\n   * // When Category updates, update Product.category\n   * modelSync.sync(Category, Product, \"category\");\n   *\n   * // With configuration\n   * modelSync.sync(Category, Product, \"category\")\n   *   .embed(\"embedMinimal\")\n   *   .watchFields([\"name\", \"slug\"]);\n   * ```\n   */\n  public sync(\n    source: ChildModel<Model>,\n    target: ChildModel<Model>,\n    field: string,\n  ): ModelSyncOperationContract {\n    const operation = new ModelSyncOperation(source, target, field, false);\n    this.trackOperation(operation);\n    return operation;\n  }\n\n  /**\n   * Create a sync operation for an array of embedded documents.\n   *\n   * When the source model is updated, the corresponding element\n   * in the target model's array field will be updated.\n   *\n   * @param source - Source model class that triggers sync\n   * @param target - Target model class that receives data\n   * @param field - Array field path in target model\n   * @returns Sync operation for chaining configuration\n   *\n   * @example\n   * ```typescript\n   * // When Tag updates, update Post.tags[i] where tags[i].id matches\n   * modelSync.syncMany(Tag, Post, \"tags\").identifyBy(\"id\");\n   * ```\n   */\n  public syncMany(\n    source: ChildModel<Model>,\n    target: ChildModel<Model>,\n    field: string,\n  ): ModelSyncOperationContract {\n    const operation = new ModelSyncOperation(source, target, field, true);\n    this.trackOperation(operation);\n    return operation;\n  }\n\n  /**\n   * Register sync operations with automatic cleanup.\n   *\n   * Executes the callback function which should contain sync registrations.\n   * Returns a cleanup function that unsubscribes all operations created\n   * during the callback - perfect for HMR module cleanup.\n   *\n   * @param callback - Function that registers sync operations\n   * @returns Cleanup function that unsubscribes all registered operations\n   *\n   * @example\n   * ```typescript\n   * // In src/app/blog/events/sync.ts\n   * export const cleanup = modelSync.register(() => {\n   *   Category.sync(Product, \"category\");\n   *   Tag.syncMany(Post, \"tags\").identifyBy(\"id\");\n   *   Author.sync(Article, \"author\").unsetOnDelete();\n   * });\n   * ```\n   */\n  public register(callback: () => void): () => void {\n    // Create a new scope for tracking operations\n    const scopedOperations: ModelSyncOperation[] = [];\n    this.registrationStack.push(scopedOperations);\n\n    try {\n      // Execute callback - operations are tracked via trackOperation()\n      callback();\n    } finally {\n      // Remove the scope from stack\n      this.registrationStack.pop();\n    }\n\n    // Return cleanup function for just these scoped operations\n    return () => {\n      for (const operation of scopedOperations) {\n        operation.unsubscribe();\n\n        // Remove from global operations array\n        const index = this.operations.indexOf(operation);\n        if (index !== -1) {\n          this.operations.splice(index, 1);\n        }\n      }\n    };\n  }\n\n  /**\n   * Clear all registered sync operations.\n   * Useful for testing or complete reset.\n   */\n  public clear(): void {\n    for (const operation of this.operations) {\n      operation.unsubscribe();\n    }\n    this.operations.length = 0;\n  }\n\n  /**\n   * Get count of active sync operations.\n   * Useful for debugging and testing.\n   */\n  public get count(): number {\n    return this.operations.length;\n  }\n\n  // ============================================================================\n  // PRIVATE HELPERS\n  // ============================================================================\n\n  /**\n   * Track a new operation in global list and current registration scope.\n   */\n  private trackOperation(operation: ModelSyncOperation): void {\n    // Always add to global operations\n    this.operations.push(operation);\n\n    // If inside a register() callback, also track in the current scope\n    const currentScope = this.registrationStack[this.registrationStack.length - 1];\n    if (currentScope) {\n      currentScope.push(operation);\n    }\n  }\n}\n\n/**\n * Global modelSync facade instance.\n *\n * Use this to register sync operations between models.\n *\n * @example\n * ```typescript\n * import { modelSync } from \"@warlock.js/cascade\";\n *\n * export const cleanup = modelSync.register(() => {\n *   Category.sync(Product, \"category\");\n * });\n * ```\n */\nexport const modelSync = new ModelSyncFacade();\n"],"mappings":";;;;;;;;;;;;;;;;;;;AA6BA,IAAM,kBAAN,MAAmD;;;;CAIjD,AAAiB,aAAmC,CAAC;;;;;CAMrD,AAAiB,oBAA4C,CAAC;;;;;;;;;;;;;;;;;;;;;;;CA4B9D,AAAO,KACL,QACA,QACA,OAC4B;EAC5B,MAAM,YAAY,IAAI,mBAAmB,QAAQ,QAAQ,OAAO,KAAK;EACrE,KAAK,eAAe,SAAS;EAC7B,OAAO;CACT;;;;;;;;;;;;;;;;;;CAmBA,AAAO,SACL,QACA,QACA,OAC4B;EAC5B,MAAM,YAAY,IAAI,mBAAmB,QAAQ,QAAQ,OAAO,IAAI;EACpE,KAAK,eAAe,SAAS;EAC7B,OAAO;CACT;;;;;;;;;;;;;;;;;;;;;CAsBA,AAAO,SAAS,UAAkC;EAEhD,MAAM,mBAAyC,CAAC;EAChD,KAAK,kBAAkB,KAAK,gBAAgB;EAE5C,IAAI;GAEF,SAAS;EACX,UAAU;GAER,KAAK,kBAAkB,IAAI;EAC7B;EAGA,aAAa;GACX,KAAK,MAAM,aAAa,kBAAkB;IACxC,UAAU,YAAY;IAGtB,MAAM,QAAQ,KAAK,WAAW,QAAQ,SAAS;IAC/C,IAAI,UAAU,IACZ,KAAK,WAAW,OAAO,OAAO,CAAC;GAEnC;EACF;CACF;;;;;CAMA,AAAO,QAAc;EACnB,KAAK,MAAM,aAAa,KAAK,YAC3B,UAAU,YAAY;EAExB,KAAK,WAAW,SAAS;CAC3B;;;;;CAMA,IAAW,QAAgB;EACzB,OAAO,KAAK,WAAW;CACzB;;;;CASA,AAAQ,eAAe,WAAqC;EAE1D,KAAK,WAAW,KAAK,SAAS;EAG9B,MAAM,eAAe,KAAK,kBAAkB,KAAK,kBAAkB,SAAS;EAC5E,IAAI,cACF,aAAa,KAAK,SAAS;CAE/B;AACF;;;;;;;;;;;;;;;AAgBA,MAAa,YAAY,IAAI,gBAAgB"}

package/esm/sync/sync-context.d.mts

@@ -0,0 +1,69 @@
+import { SyncContext, SyncInstruction } from "./types.mjs";
+
+//#region ../../@warlock.js/cascade/src/sync/sync-context.d.ts
+/**
+ * Default maximum sync depth.
+ * Prevents infinite sync chains.
+ */
+declare const DEFAULT_MAX_SYNC_DEPTH = 3;
+/**
+ * Manages sync context and provides validation utilities.
+ */
+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;
+}
+//#endregion
+export { DEFAULT_MAX_SYNC_DEPTH, SyncContextManager };
+//# sourceMappingURL=sync-context.d.mts.map

package/esm/sync/sync-context.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-context.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/sync/sync-context.ts"],"mappings":";;;;AAYmC;AAKnC;;cALa,sBAAA;;;;cAKA,kBAAA;EAUT;;;;;;;EAAA,OAFY,aAAA,CACZ,WAAA,EAAa,eAAA,EACb,aAAA,WACC,WAAW;EA8BT;;;;;;;;;;EAAA,OANS,QAAA,CACZ,KAAA,UACA,KAAA,YACA,WAAA,UACA,QAAA,UACA,eAAA;IACG,KAAA;IAAgB,KAAA;EAAA;EA6DH;;;;;;;EAAA,OAlCJ,QAAA,CAAS,KAAA,YAAiB,WAAA;;;;;;;;SAW1B,WAAA,CAAY,KAAA,YAAiB,SAAA;;;;;;;SAU7B,WAAA,CAAY,KAAA;;;;;;;;SAWZ,aAAA,CACZ,YAAA,UACA,QAAA;AAAA"}

package/esm/sync/sync-context.mjs

@@ -0,0 +1,95 @@
+//#region ../../@warlock.js/cascade/src/sync/sync-context.ts
+/**
+* Default maximum sync depth.
+* Prevents infinite sync chains.
+*/
+const DEFAULT_MAX_SYNC_DEPTH = 3;
+/**
+* Manages sync context and provides validation utilities.
+*/
+var SyncContextManager = class {
+	/**
+	* 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: /* @__PURE__ */ 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) {
+		if (depth > maxDepth) return {
+			valid: false,
+			error: `Sync depth limit exceeded: ${depth} > ${maxDepth}. Chain: ${chain.join(" → ")}`
+		};
+		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;
+	}
+};
+
+//#endregion
+export { DEFAULT_MAX_SYNC_DEPTH, SyncContextManager };
+//# sourceMappingURL=sync-context.mjs.map

package/esm/sync/sync-context.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-context.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/sync/sync-context.ts"],"sourcesContent":["/**\n * Sync context management and validation.\n *\n * @module cascade-next/sync/sync-context\n */\n\nimport type { SyncContext, SyncInstruction } from \"./types\";\n\n/**\n * Default maximum sync depth.\n * Prevents infinite sync chains.\n */\nexport const DEFAULT_MAX_SYNC_DEPTH = 3;\n\n/**\n * Manages sync context and provides validation utilities.\n */\nexport class SyncContextManager {\n  /**\n   * Creates a new sync context from a sync instruction.\n   *\n   * @param instruction - The sync instruction to create context from\n   * @param affectedCount - Number of documents affected\n   * @returns A new sync context\n   */\n  public static createContext(\n    instruction: SyncInstruction,\n    affectedCount: number,\n  ): SyncContext {\n    return {\n      sourceModel: instruction.sourceModel,\n      sourceId: instruction.sourceId,\n      currentDepth: instruction.depth,\n      syncChain: [...instruction.chain],\n      targetModel: instruction.targetModel,\n      filter: { ...instruction.filter },\n      update: { ...instruction.update },\n      affectedCount,\n      timestamp: new Date(),\n    };\n  }\n\n  /**\n   * Validates if a sync operation can proceed based on depth and cycle detection.\n   *\n   * @param depth - Current sync depth\n   * @param chain - Current sync chain\n   * @param targetModel - Target model name\n   * @param maxDepth - Maximum allowed depth\n   * @param preventCircular - Whether to prevent circular references\n   * @returns Validation result with success flag and optional error message\n   */\n  public static validate(\n    depth: number,\n    chain: string[],\n    targetModel: string,\n    maxDepth: number,\n    preventCircular: boolean,\n  ): { valid: boolean; error?: string } {\n    // Check depth limit\n    if (depth > maxDepth) {\n      return {\n        valid: false,\n        error: `Sync depth limit exceeded: ${depth} > ${maxDepth}. Chain: ${chain.join(\" → \")}`,\n      };\n    }\n\n    // Check for circular references\n    if (preventCircular && this.hasCycle(chain, targetModel)) {\n      return {\n        valid: false,\n        error: `Circular sync detected: ${targetModel} already exists in chain [${chain.join(\" → \")}]`,\n      };\n    }\n\n    return { valid: true };\n  }\n\n  /**\n   * Checks if adding a target model would create a cycle in the sync chain.\n   *\n   * @param chain - Current sync chain\n   * @param targetModel - Model to be added to the chain\n   * @returns True if adding the model would create a cycle\n   */\n  public static hasCycle(chain: string[], targetModel: string): boolean {\n    return chain.includes(targetModel);\n  }\n\n  /**\n   * Creates a new sync chain by appending a model name.\n   *\n   * @param chain - Current sync chain\n   * @param modelName - Model name to append\n   * @returns New sync chain array\n   */\n  public static extendChain(chain: string[], modelName: string): string[] {\n    return [...chain, modelName];\n  }\n\n  /**\n   * Formats a sync chain for display.\n   *\n   * @param chain - Sync chain to format\n   * @returns Formatted string (e.g., \"Category → Product → Module\")\n   */\n  public static formatChain(chain: string[]): string {\n    return chain.join(\" → \");\n  }\n\n  /**\n   * Checks if the current depth allows for further syncing.\n   *\n   * @param currentDepth - Current depth in the chain\n   * @param maxDepth - Maximum allowed depth\n   * @returns True if more syncing is allowed\n   */\n  public static canSyncDeeper(\n    currentDepth: number,\n    maxDepth: number,\n  ): boolean {\n    return currentDepth < maxDepth;\n  }\n}\n\n"],"mappings":";;;;;AAYA,MAAa,yBAAyB;;;;AAKtC,IAAa,qBAAb,MAAgC;;;;;;;;CAQ9B,OAAc,cACZ,aACA,eACa;EACb,OAAO;GACL,aAAa,YAAY;GACzB,UAAU,YAAY;GACtB,cAAc,YAAY;GAC1B,WAAW,CAAC,GAAG,YAAY,KAAK;GAChC,aAAa,YAAY;GACzB,QAAQ,EAAE,GAAG,YAAY,OAAO;GAChC,QAAQ,EAAE,GAAG,YAAY,OAAO;GAChC;GACA,2BAAW,IAAI,KAAK;EACtB;CACF;;;;;;;;;;;CAYA,OAAc,SACZ,OACA,OACA,aACA,UACA,iBACoC;EAEpC,IAAI,QAAQ,UACV,OAAO;GACL,OAAO;GACP,OAAO,8BAA8B,MAAM,KAAK,SAAS,WAAW,MAAM,KAAK,KAAK;EACtF;EAIF,IAAI,mBAAmB,KAAK,SAAS,OAAO,WAAW,GACrD,OAAO;GACL,OAAO;GACP,OAAO,2BAA2B,YAAY,4BAA4B,MAAM,KAAK,KAAK,EAAE;EAC9F;EAGF,OAAO,EAAE,OAAO,KAAK;CACvB;;;;;;;;CASA,OAAc,SAAS,OAAiB,aAA8B;EACpE,OAAO,MAAM,SAAS,WAAW;CACnC;;;;;;;;CASA,OAAc,YAAY,OAAiB,WAA6B;EACtE,OAAO,CAAC,GAAG,OAAO,SAAS;CAC7B;;;;;;;CAQA,OAAc,YAAY,OAAyB;EACjD,OAAO,MAAM,KAAK,KAAK;CACzB;;;;;;;;CASA,OAAc,cACZ,cACA,UACS;EACT,OAAO,eAAe;CACxB;AACF"}

package/esm/sync/sync-manager.d.mts

@@ -0,0 +1,213 @@
+import { ChildModel } from "../model/model.types.mjs";
+import { SyncConfig, SyncResult } from "./types.mjs";
+import { Model } from "../model/model.mjs";
+import { DriverContract } from "../contracts/database-driver.contract.mjs";
+
+//#region ../../@warlock.js/cascade/src/sync/sync-manager.d.ts
+/**
+ * Manages sync operations across models with multi-level support.
+ */
+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;
+}
+//#endregion
+export { SyncManager };
+//# sourceMappingURL=sync-manager.d.mts.map

package/esm/sync/sync-manager.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync-manager.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/sync/sync-manager.ts"],"mappings":";;;;;;;;;cAqBa,WAAA;EAAA,iBACM,WAAA;EAAA,iBACA,MAAA;EAyBN;;;;;;cAjBQ,WAAA,EAAa,UAAA,CAAW,KAAA,GAAQ,MAAA,EAAQ,cAAA;EAkJjD;;;;;;;;EArIG,UAAA,CACX,QAAA,mBACA,WAAA,EAAa,MAAA,oBAA0B,KAAA,EACvC,aAAA,aACC,OAAA,CAAQ,UAAA;;;;;;;;;;;EAgEE,oBAAA,CACX,QAAA,mBACA,WAAA,EAAa,MAAA,oBAA0B,KAAA,EACvC,aAAA,YACA,MAAA,EAAQ,UAAA,GACP,OAAA,CAAQ,UAAA;EAtET;;;;;;;;EAgIW,oBAAA,CACX,QAAA,mBACA,MAAA,EAAQ,UAAA,GACP,OAAA,CAAQ,UAAA;EA9DD;;;;;;EAoHG,UAAA,CAAW,QAAA,oBAA4B,OAAA,CAAQ,UAAA;EAvD1D;;;;;;EAAA,QA6GY,mBAAA;EAAA;;;;;;;;EAAA,QA6DA,yBAAA;EAyQA;;;;;;;;;;EAAA,QA9NA,4BAAA;EAgdW;AAAA;;;;;;;;EAAA,QAtajB,sBAAA;;;;;;;;;UAwCA,sBAAA;;;;;;;;UA4BA,WAAA;;;;;;;;UAiBA,WAAA;;;;;;;;UAoBM,mBAAA;;;;;;;UAgDA,YAAA;;;;;;;;UA2BA,iBAAA;;;;;;;;UAuDN,eAAA;;;;;;;UAmBA,YAAA;;;;;;;UAqBA,YAAA;;;;;;;;UAqBA,UAAA;;;;;;;;UAeM,YAAA;;;;;;UA8BN,cAAA;;;;;;;UAkBA,sBAAA;;;;;;UAiBM,gBAAA;;;;;;UAuBA,eAAA;;;;;;UAuBN,iBAAA;AAAA"}