@warlock.js/cascade 4.0.174 → 4.1.1

package/esm/restorer/database-restorer.d.mts

@@ -0,0 +1,135 @@
+import { Model } from "../model/model.mjs";
+import { RestorerContract, RestorerOptions, RestorerResult } from "../contracts/database-restorer.contract.mjs";
+
+//#region ../../@warlock.js/cascade/src/restorer/database-restorer.d.ts
+/**
+ * Database restorer service that orchestrates model restoration.
+ *
+ * Handles the complete restoration pipeline:
+ * 1. Strategy detection (trash vs soft delete)
+ * 2. Record retrieval from trash table or soft-deleted records
+ * 3. ID conflict resolution
+ * 4. Event emission (restoring, restored)
+ * 5. Driver execution (insert back to original table, remove from trash/clear deletedAt)
+ *
+ * @example
+ * ```typescript
+ * const restorer = new DatabaseRestorer(User);
+ * const result = await restorer.restore(123);
+ *
+ * console.log(result.success); // true
+ * console.log(result.strategy); // "trash" | "soft"
+ * ```
+ */
+declare class DatabaseRestorer implements RestorerContract {
+  /** Model constructor reference */
+  private readonly ctor;
+  /** Data source containing driver */
+  private readonly dataSource;
+  /** Database driver for executing queries */
+  private readonly driver;
+  /** Table/collection name */
+  private readonly table;
+  /** Primary key field name */
+  private readonly primaryKey;
+  /**
+   * Create a new restorer instance for a model class.
+   *
+   * @param modelClass - The model class (static context)
+   *
+   * @example
+   * ```typescript
+   * const restorer = new DatabaseRestorer(User);
+   * await restorer.restore(123);
+   * ```
+   */
+  constructor(modelClass: typeof Model);
+  /**
+   * Restore a single deleted record by its ID.
+   *
+   * @param id - The primary key value of the record to restore
+   * @param options - Restorer options
+   * @returns Result containing success status, strategy used, and restored record
+   * @throws {Error} If record not found in trash or soft-deleted records
+   * @throws {Error} If ID conflict and onIdConflict is "fail"
+   */
+  restore(id: string | number, options?: RestorerOptions): Promise<RestorerResult>;
+  /**
+   * Restore all deleted records for the model's table.
+   *
+   * @param options - Restorer options
+   * @returns Result containing success status, strategy used, and aggregate counts
+   */
+  restoreAll(options?: RestorerOptions): Promise<RestorerResult>;
+  /**
+   * Resolve the delete strategy.
+   *
+   * Priority: options → model static → data source default → "permanent"
+   *
+   * @param strategyOption - Optional strategy override from options
+   * @returns The resolved delete strategy
+   * @private
+   */
+  private resolveStrategy;
+  /**
+   * Fetch a record by ID based on the delete strategy.
+   *
+   * @param id - The primary key value
+   * @param strategy - The delete strategy to use
+   * @returns The record data, or null if not found
+   * @private
+   */
+  private fetchRecordByStrategy;
+  /**
+   * Fetch all records based on the delete strategy.
+   *
+   * @param strategy - The delete strategy to use
+   * @returns Array of record data
+   * @private
+   */
+  private fetchAllRecordsByStrategy;
+  /**
+   * Handle ID conflict by checking if ID exists and assigning new one if needed.
+   *
+   * @param recordData - The record data to restore
+   * @param originalId - The original ID value
+   * @param onIdConflict - Conflict resolution strategy
+   * @returns Record data with potentially new ID
+   * @private
+   */
+  private handleIdConflict;
+  /**
+   * Check if an ID already exists in the target table.
+   *
+   * @param id - The ID to check
+   * @returns True if ID exists, false otherwise
+   * @private
+   */
+  private checkIdExists;
+  /**
+   * Assign a new ID to the record data.
+   *
+   * For MongoDB: Generates new ObjectId for `_id`, keeps `id` if it exists
+   * For SQL: Removes `id` to let database auto-increment
+   *
+   * @param recordData - The record data
+   * @returns Record data with new ID assigned
+   * @private
+   */
+  private assignNewId;
+  /**
+   * Resolve the trash table/collection name.
+   *
+   * Priority:
+   * 1. Model.trashTable (if set)
+   * 2. Data source defaultTrashTable (e.g., "RecycleBin" for MongoDB)
+   * 3. Default pattern: `{table}Trash`
+   *
+   * @returns The trash table/collection name
+   * @private
+   */
+  private resolveTrashTable;
+}
+//#endregion
+export { DatabaseRestorer };
+//# sourceMappingURL=database-restorer.d.mts.map

package/esm/restorer/database-restorer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-restorer.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/restorer/database-restorer.ts"],"mappings":";;;;;;AA6BA;;;;;;;;;;;;;;;;;cAAa,gBAAA,YAA4B,gBAAA;EActB;EAAA,iBAZA,IAAA;EAyBqB;EAAA,iBAtBrB,UAAA;EAuCJ;EAAA,iBApCI,MAAA;EAsCN;EAAA,iBAnCM,KAAA;EAoCd;EAAA,iBAjCc,UAAA;EAoHJ;;;;;;;;;;;cAvGM,UAAA,SAAmB,KAAA;EAgcb;AAAA;;;;;;;;EA/aZ,OAAA,CACX,EAAA,mBACA,OAAA,GAAS,eAAA,GACR,OAAA,CAAQ,cAAA;;;;;;;EAmFE,UAAA,CAAW,OAAA,GAAS,eAAA,GAAuB,OAAA,CAAQ,cAAA;;;;;;;;;;UAiKxD,eAAA;;;;;;;;;UAiBM,qBAAA;;;;;;;;UA0CA,yBAAA;;;;;;;;;;UA6CA,gBAAA;;;;;;;;UA4BA,aAAA;;;;;;;;;;;UAoBA,WAAA;;;;;;;;;;;;UAgCN,iBAAA;AAAA"}

package/esm/restorer/database-restorer.mjs

@@ -0,0 +1,316 @@
+//#region ../../@warlock.js/cascade/src/restorer/database-restorer.ts
+/**
+* Database restorer service that orchestrates model restoration.
+*
+* Handles the complete restoration pipeline:
+* 1. Strategy detection (trash vs soft delete)
+* 2. Record retrieval from trash table or soft-deleted records
+* 3. ID conflict resolution
+* 4. Event emission (restoring, restored)
+* 5. Driver execution (insert back to original table, remove from trash/clear deletedAt)
+*
+* @example
+* ```typescript
+* const restorer = new DatabaseRestorer(User);
+* const result = await restorer.restore(123);
+*
+* console.log(result.success); // true
+* console.log(result.strategy); // "trash" | "soft"
+* ```
+*/
+var DatabaseRestorer = class {
+	/** Model constructor reference */
+	ctor;
+	/** Data source containing driver */
+	dataSource;
+	/** Database driver for executing queries */
+	driver;
+	/** Table/collection name */
+	table;
+	/** Primary key field name */
+	primaryKey;
+	/**
+	* Create a new restorer instance for a model class.
+	*
+	* @param modelClass - The model class (static context)
+	*
+	* @example
+	* ```typescript
+	* const restorer = new DatabaseRestorer(User);
+	* await restorer.restore(123);
+	* ```
+	*/
+	constructor(modelClass) {
+		this.ctor = modelClass;
+		this.dataSource = modelClass.getDataSource();
+		this.driver = this.dataSource.driver;
+		this.table = modelClass.table;
+		this.primaryKey = modelClass.primaryKey;
+	}
+	/**
+	* Restore a single deleted record by its ID.
+	*
+	* @param id - The primary key value of the record to restore
+	* @param options - Restorer options
+	* @returns Result containing success status, strategy used, and restored record
+	* @throws {Error} If record not found in trash or soft-deleted records
+	* @throws {Error} If ID conflict and onIdConflict is "fail"
+	*/
+	async restore(id, options = {}) {
+		const onIdConflict = options.onIdConflict ?? "assignNew";
+		const skipEvents = options.skipEvents ?? false;
+		const strategy = this.resolveStrategy(options.strategy);
+		if (strategy === "permanent") throw new Error(`Cannot restore ${this.ctor.name} with ${this.primaryKey} ${id}: permanently deleted records cannot be restored.`);
+		const recordData = await this.fetchRecordByStrategy(id, strategy);
+		if (!recordData) throw new Error(`Cannot restore ${this.ctor.name} with ${this.primaryKey} ${id}: record not found in ${strategy === "trash" ? "trash table" : "soft-deleted records"}.`);
+		const restoredData = { ...recordData };
+		delete restoredData.deletedAt;
+		delete restoredData.originalTable;
+		const finalData = await this.handleIdConflict(restoredData, id, onIdConflict);
+		const model = new this.ctor(finalData);
+		if (!skipEvents) await model.emitEvent("restoring");
+		if (strategy === "trash") {
+			await this.driver.insert(this.table, finalData);
+			model.isNew = false;
+			await this.driver.delete(this.resolveTrashTable(), { [this.primaryKey]: id });
+		} else if (strategy === "soft") {
+			const deletedAtColumn = this.ctor.deletedAtColumn ?? "deletedAt";
+			if (deletedAtColumn) {
+				const filter = { [this.primaryKey]: id };
+				const updateOperations = { $unset: { [deletedAtColumn]: 1 } };
+				await this.driver.update(this.table, filter, updateOperations);
+				model.isNew = false;
+			}
+		}
+		if (!skipEvents) await model.emitEvent("restored");
+		return {
+			success: true,
+			restoredCount: 1,
+			strategy,
+			restoredRecord: model
+		};
+	}
+	/**
+	* Restore all deleted records for the model's table.
+	*
+	* @param options - Restorer options
+	* @returns Result containing success status, strategy used, and aggregate counts
+	*/
+	async restoreAll(options = {}) {
+		const onIdConflict = options.onIdConflict ?? "assignNew";
+		const skipEvents = options.skipEvents ?? false;
+		const strategy = this.resolveStrategy(options.strategy);
+		if (strategy === "permanent") throw new Error(`Cannot restore all ${this.ctor.name} records: permanently deleted records cannot be restored.`);
+		const recordsToRestore = await this.fetchAllRecordsByStrategy(strategy);
+		if (recordsToRestore.length === 0) return {
+			success: true,
+			restoredCount: 0,
+			strategy
+		};
+		let restoredCount = 0;
+		const conflicts = [];
+		const restoredRecords = [];
+		for (const recordData of recordsToRestore) {
+			const id = recordData[this.primaryKey];
+			try {
+				const restoredData = { ...recordData };
+				delete restoredData.deletedAt;
+				delete restoredData.originalTable;
+				if (await this.checkIdExists(id)) {
+					if (onIdConflict === "fail") throw new Error(`Cannot restore ${this.ctor.name} with ${this.primaryKey} ${id}: ID already exists in target table.`);
+					const finalData = await this.assignNewId(restoredData);
+					conflicts.push({
+						id,
+						reason: `ID ${id} already exists, assigned new ID ${finalData[this.primaryKey]}`
+					});
+					const model = new this.ctor(finalData);
+					if (!skipEvents) await model.emitEvent("restoring");
+					if (strategy === "trash") {
+						await this.driver.insert(this.table, finalData);
+						model.isNew = false;
+					} else if (strategy === "soft") {
+						const deletedAtColumn = this.ctor.deletedAtColumn ?? "deletedAt";
+						if (deletedAtColumn) {
+							const filter = { [this.primaryKey]: id };
+							const updateOperations = { $unset: { [deletedAtColumn]: 1 } };
+							await this.driver.update(this.table, filter, updateOperations);
+							model.isNew = false;
+						}
+					}
+					restoredRecords.push(model);
+					if (!skipEvents) await model.emitEvent("restored");
+				} else {
+					const model = new this.ctor(restoredData);
+					if (!skipEvents) await model.emitEvent("restoring");
+					if (strategy === "trash") {
+						await this.driver.insert(this.table, restoredData);
+						model.isNew = false;
+					} else if (strategy === "soft") {
+						const deletedAtColumn = this.ctor.deletedAtColumn ?? "deletedAt";
+						if (deletedAtColumn) {
+							const filter = { [this.primaryKey]: id };
+							const updateOperations = { $unset: { [deletedAtColumn]: 1 } };
+							await this.driver.update(this.table, filter, updateOperations);
+							model.isNew = false;
+						}
+					}
+					restoredRecords.push(model);
+					if (!skipEvents) await model.emitEvent("restored");
+				}
+				if (strategy === "trash") {
+					const trashTable = this.resolveTrashTable();
+					const trashFilter = { [this.primaryKey]: id };
+					await this.driver.delete(trashTable, trashFilter);
+				}
+				restoredCount++;
+			} catch (error) {
+				if (onIdConflict === "fail") throw error;
+				conflicts.push({
+					id,
+					reason: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+		return {
+			success: true,
+			restoredCount,
+			restoredRecords,
+			strategy,
+			conflicts: conflicts.length > 0 ? conflicts : void 0
+		};
+	}
+	/**
+	* Resolve the delete strategy.
+	*
+	* Priority: options → model static → data source default → "permanent"
+	*
+	* @param strategyOption - Optional strategy override from options
+	* @returns The resolved delete strategy
+	* @private
+	*/
+	resolveStrategy(strategyOption) {
+		return strategyOption ?? this.ctor.deleteStrategy ?? this.dataSource.defaultDeleteStrategy ?? "permanent";
+	}
+	/**
+	* Fetch a record by ID based on the delete strategy.
+	*
+	* @param id - The primary key value
+	* @param strategy - The delete strategy to use
+	* @returns The record data, or null if not found
+	* @private
+	*/
+	async fetchRecordByStrategy(id, strategy) {
+		if (strategy === "trash") {
+			const trashTable = this.resolveTrashTable();
+			try {
+				return await this.driver.queryBuilder(trashTable).where(this.primaryKey, id).first();
+			} catch {
+				return null;
+			}
+		} else if (strategy === "soft") {
+			const deletedAtColumn = this.ctor.deletedAtColumn ?? "deletedAt";
+			if (!deletedAtColumn) return null;
+			try {
+				return await this.driver.queryBuilder(this.table).where(this.primaryKey, id).whereNotNull(deletedAtColumn).first();
+			} catch {
+				return null;
+			}
+		}
+		return null;
+	}
+	/**
+	* Fetch all records based on the delete strategy.
+	*
+	* @param strategy - The delete strategy to use
+	* @returns Array of record data
+	* @private
+	*/
+	async fetchAllRecordsByStrategy(strategy) {
+		if (strategy === "trash") {
+			const trashTable = this.resolveTrashTable();
+			try {
+				return await this.driver.queryBuilder(trashTable).where("originalTable", this.table).get();
+			} catch {
+				return [];
+			}
+		} else if (strategy === "soft") {
+			const deletedAtColumn = this.ctor.deletedAtColumn ?? "deletedAt";
+			if (!deletedAtColumn) return [];
+			try {
+				return await this.driver.queryBuilder(this.table).whereNotNull(deletedAtColumn).get();
+			} catch {
+				return [];
+			}
+		}
+		return [];
+	}
+	/**
+	* Handle ID conflict by checking if ID exists and assigning new one if needed.
+	*
+	* @param recordData - The record data to restore
+	* @param originalId - The original ID value
+	* @param onIdConflict - Conflict resolution strategy
+	* @returns Record data with potentially new ID
+	* @private
+	*/
+	async handleIdConflict(recordData, originalId, onIdConflict) {
+		if (await this.checkIdExists(originalId)) {
+			if (onIdConflict === "fail") throw new Error(`Cannot restore ${this.ctor.name} with ${this.primaryKey} ${originalId}: ID already exists in target table.`);
+			return await this.assignNewId(recordData);
+		}
+		return recordData;
+	}
+	/**
+	* Check if an ID already exists in the target table.
+	*
+	* @param id - The ID to check
+	* @returns True if ID exists, false otherwise
+	* @private
+	*/
+	async checkIdExists(id) {
+		try {
+			return await this.driver.queryBuilder(this.table).where(this.primaryKey, id).exists();
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Assign a new ID to the record data.
+	*
+	* For MongoDB: Generates new ObjectId for `_id`, keeps `id` if it exists
+	* For SQL: Removes `id` to let database auto-increment
+	*
+	* @param recordData - The record data
+	* @returns Record data with new ID assigned
+	* @private
+	*/
+	async assignNewId(recordData) {
+		const isMongoDb = this.driver.name === "mongodb";
+		const newData = { ...recordData };
+		if (isMongoDb) {
+			if (this.primaryKey === "_id") delete newData._id;
+			else if (this.primaryKey === "id") delete newData.id;
+		} else delete newData[this.primaryKey];
+		return newData;
+	}
+	/**
+	* Resolve the trash table/collection name.
+	*
+	* Priority:
+	* 1. Model.trashTable (if set)
+	* 2. Data source defaultTrashTable (e.g., "RecycleBin" for MongoDB)
+	* 3. Default pattern: `{table}Trash`
+	*
+	* @returns The trash table/collection name
+	* @private
+	*/
+	resolveTrashTable() {
+		if (this.ctor.trashTable) return this.ctor.trashTable;
+		if (this.dataSource.defaultTrashTable) return this.dataSource.defaultTrashTable;
+		return `${this.table}Trash`;
+	}
+};
+
+//#endregion
+export { DatabaseRestorer };
+//# sourceMappingURL=database-restorer.mjs.map

package/esm/restorer/database-restorer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-restorer.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/restorer/database-restorer.ts"],"sourcesContent":["import type { DriverContract, UpdateOperations } from \"../contracts/database-driver.contract\";\nimport type {\n  RestorerContract,\n  RestorerOptions,\n  RestorerResult,\n} from \"../contracts/database-restorer.contract\";\nimport type { DataSource } from \"../data-source/data-source\";\nimport type { Model } from \"../model/model\";\nimport type { DeleteStrategy } from \"../types\";\n\n/**\n * Database restorer service that orchestrates model restoration.\n *\n * Handles the complete restoration pipeline:\n * 1. Strategy detection (trash vs soft delete)\n * 2. Record retrieval from trash table or soft-deleted records\n * 3. ID conflict resolution\n * 4. Event emission (restoring, restored)\n * 5. Driver execution (insert back to original table, remove from trash/clear deletedAt)\n *\n * @example\n * ```typescript\n * const restorer = new DatabaseRestorer(User);\n * const result = await restorer.restore(123);\n *\n * console.log(result.success); // true\n * console.log(result.strategy); // \"trash\" | \"soft\"\n * ```\n */\nexport class DatabaseRestorer implements RestorerContract {\n  /** Model constructor reference */\n  private readonly ctor: typeof Model;\n\n  /** Data source containing driver */\n  private readonly dataSource: DataSource;\n\n  /** Database driver for executing queries */\n  private readonly driver: DriverContract;\n\n  /** Table/collection name */\n  private readonly table: string;\n\n  /** Primary key field name */\n  private readonly primaryKey: string;\n\n  /**\n   * Create a new restorer instance for a model class.\n   *\n   * @param modelClass - The model class (static context)\n   *\n   * @example\n   * ```typescript\n   * const restorer = new DatabaseRestorer(User);\n   * await restorer.restore(123);\n   * ```\n   */\n  public constructor(modelClass: typeof Model) {\n    this.ctor = modelClass;\n    this.dataSource = modelClass.getDataSource();\n    this.driver = this.dataSource.driver;\n    this.table = modelClass.table;\n    this.primaryKey = modelClass.primaryKey;\n  }\n\n  /**\n   * Restore a single deleted record by its ID.\n   *\n   * @param id - The primary key value of the record to restore\n   * @param options - Restorer options\n   * @returns Result containing success status, strategy used, and restored record\n   * @throws {Error} If record not found in trash or soft-deleted records\n   * @throws {Error} If ID conflict and onIdConflict is \"fail\"\n   */\n  public async restore(\n    id: string | number,\n    options: RestorerOptions = {},\n  ): Promise<RestorerResult> {\n    const onIdConflict = options.onIdConflict ?? \"assignNew\";\n    const skipEvents = options.skipEvents ?? false;\n\n    // 1. Resolve strategy (options → model static → data source default)\n    const strategy = this.resolveStrategy(options.strategy);\n\n    // 2. Validate strategy (cannot restore permanent deletes)\n    if (strategy === \"permanent\") {\n      throw new Error(\n        `Cannot restore ${this.ctor.name} with ${this.primaryKey} ${id}: permanently deleted records cannot be restored.`,\n      );\n    }\n\n    // 3. Fetch record based on strategy\n    const recordData = await this.fetchRecordByStrategy(id, strategy);\n\n    if (!recordData) {\n      throw new Error(\n        `Cannot restore ${this.ctor.name} with ${this.primaryKey} ${id}: record not found in ${strategy === \"trash\" ? \"trash table\" : \"soft-deleted records\"}.`,\n      );\n    }\n\n    // 4. Prepare record data (remove metadata fields)\n    const restoredData = { ...recordData };\n    delete restoredData.deletedAt;\n    delete restoredData.originalTable;\n\n    // 5. Check for ID conflict and handle\n    const finalData = await this.handleIdConflict(restoredData, id, onIdConflict);\n\n    // 6. Create temporary model instance for event emission\n    // Note: Model is abstract, but at runtime this.ctor is a concrete subclass\n    const model = new (this.ctor as any)(finalData) as Model;\n\n    // 7. Emit restoring event (unless skipEvents)\n    if (!skipEvents) {\n      await model.emitEvent(\"restoring\");\n    }\n\n    // 8. Restore based on strategy\n    if (strategy === \"trash\") {\n      // Insert record back into original table (was moved to trash)\n      await this.driver.insert(this.table, finalData);\n      model.isNew = false;\n\n      // Remove from trash table\n      await this.driver.delete(this.resolveTrashTable(), {\n        [this.primaryKey]: id,\n      });\n    } else if (strategy === \"soft\") {\n      // Record still exists, just unset deletedAt (don't insert - would create duplicate!)\n      const deletedAtColumn = this.ctor.deletedAtColumn ?? \"deletedAt\";\n      if (deletedAtColumn) {\n        const filter = { [this.primaryKey]: id };\n        const updateOperations: UpdateOperations = {\n          $unset: { [deletedAtColumn]: 1 },\n        };\n\n        await this.driver.update(this.table, filter, updateOperations);\n        model.isNew = false;\n      }\n    }\n\n    // 10. Emit restored event (unless skipEvents)\n    if (!skipEvents) {\n      await model.emitEvent(\"restored\");\n    }\n\n    return {\n      success: true,\n      restoredCount: 1,\n      strategy,\n      restoredRecord: model,\n    };\n  }\n\n  /**\n   * Restore all deleted records for the model's table.\n   *\n   * @param options - Restorer options\n   * @returns Result containing success status, strategy used, and aggregate counts\n   */\n  public async restoreAll(options: RestorerOptions = {}): Promise<RestorerResult> {\n    const onIdConflict = options.onIdConflict ?? \"assignNew\";\n    const skipEvents = options.skipEvents ?? false;\n\n    // 1. Resolve strategy (options → model static → data source default)\n    const strategy = this.resolveStrategy(options.strategy);\n\n    // 2. Validate strategy (cannot restore permanent deletes)\n    if (strategy === \"permanent\") {\n      throw new Error(\n        `Cannot restore all ${this.ctor.name} records: permanently deleted records cannot be restored.`,\n      );\n    }\n\n    // 3. Fetch all records based on strategy\n    const recordsToRestore = await this.fetchAllRecordsByStrategy(strategy);\n\n    if (recordsToRestore.length === 0) {\n      return {\n        success: true,\n        restoredCount: 0,\n        strategy,\n      };\n    }\n\n    // 4. Restore each record\n    let restoredCount = 0;\n    const conflicts: Array<{ id: string | number; reason: string }> = [];\n\n    const restoredRecords: Model[] = [];\n\n    for (const recordData of recordsToRestore) {\n      const id = recordData[this.primaryKey] as string | number;\n\n      try {\n        // Prepare record data (remove metadata fields)\n        const restoredData = { ...recordData };\n        delete restoredData.deletedAt;\n        delete restoredData.originalTable;\n\n        // Check for ID conflict\n        const idExists = await this.checkIdExists(id);\n        if (idExists) {\n          if (onIdConflict === \"fail\") {\n            throw new Error(\n              `Cannot restore ${this.ctor.name} with ${this.primaryKey} ${id}: ID already exists in target table.`,\n            );\n          }\n\n          // Assign new ID\n          const finalData = await this.assignNewId(restoredData);\n          conflicts.push({\n            id,\n            reason: `ID ${id} already exists, assigned new ID ${finalData[this.primaryKey]}`,\n          });\n\n          // Create temporary model for events\n          const model = new (this.ctor as any)(finalData) as Model;\n\n          // Emit restoring event\n          if (!skipEvents) {\n            await model.emitEvent(\"restoring\");\n          }\n\n          // Restore based on strategy\n          if (strategy === \"trash\") {\n            // Insert with new ID (was moved to trash)\n            await this.driver.insert(this.table, finalData);\n            model.isNew = false;\n          } else if (strategy === \"soft\") {\n            // Record still exists, just unset deletedAt\n            const deletedAtColumn = this.ctor.deletedAtColumn ?? \"deletedAt\";\n            if (deletedAtColumn) {\n              const filter = { [this.primaryKey]: id };\n              const updateOperations: UpdateOperations = {\n                $unset: { [deletedAtColumn]: 1 },\n              };\n              await this.driver.update(this.table, filter, updateOperations);\n              model.isNew = false;\n            }\n          }\n\n          restoredRecords.push(model);\n\n          // Emit restored event\n          if (!skipEvents) {\n            await model.emitEvent(\"restored\");\n          }\n        } else {\n          // No conflict, restore with original ID\n          const model = new (this.ctor as any)(restoredData) as Model;\n\n          // Emit restoring event\n          if (!skipEvents) {\n            await model.emitEvent(\"restoring\");\n          }\n\n          // Restore based on strategy\n          if (strategy === \"trash\") {\n            // Insert with original ID (was moved to trash)\n            await this.driver.insert(this.table, restoredData);\n            model.isNew = false;\n          } else if (strategy === \"soft\") {\n            // Record still exists, just unset deletedAt\n            const deletedAtColumn = this.ctor.deletedAtColumn ?? \"deletedAt\";\n            if (deletedAtColumn) {\n              const filter = { [this.primaryKey]: id };\n              const updateOperations: UpdateOperations = {\n                $unset: { [deletedAtColumn]: 1 },\n              };\n              await this.driver.update(this.table, filter, updateOperations);\n              model.isNew = false;\n            }\n          }\n\n          restoredRecords.push(model);\n\n          // Emit restored event\n          if (!skipEvents) {\n            await model.emitEvent(\"restored\");\n          }\n        }\n\n        // Remove from trash (only for trash strategy)\n        if (strategy === \"trash\") {\n          const trashTable = this.resolveTrashTable();\n          const trashFilter = { [this.primaryKey]: id };\n          await this.driver.delete(trashTable, trashFilter);\n        }\n\n        restoredCount++;\n      } catch (error) {\n        if (onIdConflict === \"fail\") {\n          throw error;\n        }\n        // Continue with next record if assignNew mode\n        conflicts.push({\n          id,\n          reason: error instanceof Error ? error.message : String(error),\n        });\n      }\n    }\n\n    return {\n      success: true,\n      restoredCount,\n      restoredRecords,\n      strategy,\n      conflicts: conflicts.length > 0 ? conflicts : undefined,\n    };\n  }\n\n  /**\n   * Resolve the delete strategy.\n   *\n   * Priority: options → model static → data source default → \"permanent\"\n   *\n   * @param strategyOption - Optional strategy override from options\n   * @returns The resolved delete strategy\n   * @private\n   */\n  private resolveStrategy(strategyOption?: \"trash\" | \"soft\"): DeleteStrategy {\n    return (\n      strategyOption ??\n      this.ctor.deleteStrategy ??\n      this.dataSource.defaultDeleteStrategy ??\n      \"permanent\"\n    );\n  }\n\n  /**\n   * Fetch a record by ID based on the delete strategy.\n   *\n   * @param id - The primary key value\n   * @param strategy - The delete strategy to use\n   * @returns The record data, or null if not found\n   * @private\n   */\n  private async fetchRecordByStrategy(id: string | number, strategy: \"trash\" | \"soft\") {\n    if (strategy === \"trash\") {\n      const trashTable = this.resolveTrashTable();\n      try {\n        const trashQuery = await this.driver\n          .queryBuilder(trashTable)\n          .where(this.primaryKey, id)\n          .first<Record<string, unknown>>();\n\n        return trashQuery;\n      } catch {\n        return null;\n      }\n    } else if (strategy === \"soft\") {\n      const deletedAtColumn = this.ctor.deletedAtColumn ?? \"deletedAt\";\n      if (!deletedAtColumn) {\n        return null;\n      }\n\n      try {\n        const softDeletedQuery = await this.driver\n          .queryBuilder(this.table)\n          .where(this.primaryKey, id)\n          .whereNotNull(deletedAtColumn)\n          .first<Record<string, unknown>>();\n\n        return softDeletedQuery;\n      } catch {\n        return null;\n      }\n    }\n\n    return null;\n  }\n\n  /**\n   * Fetch all records based on the delete strategy.\n   *\n   * @param strategy - The delete strategy to use\n   * @returns Array of record data\n   * @private\n   */\n  private async fetchAllRecordsByStrategy(\n    strategy: \"trash\" | \"soft\",\n  ): Promise<Record<string, unknown>[]> {\n    if (strategy === \"trash\") {\n      const trashTable = this.resolveTrashTable();\n      try {\n        const trashQuery = this.driver\n          .queryBuilder(trashTable)\n          .where(\"originalTable\", this.table)\n          .get();\n\n        return (await trashQuery) as Record<string, unknown>[];\n      } catch {\n        return [];\n      }\n    } else if (strategy === \"soft\") {\n      const deletedAtColumn = this.ctor.deletedAtColumn ?? \"deletedAt\";\n      if (!deletedAtColumn) {\n        return [];\n      }\n\n      try {\n        const softDeletedQuery = this.driver\n          .queryBuilder(this.table)\n          .whereNotNull(deletedAtColumn)\n          .get();\n\n        return (await softDeletedQuery) as Record<string, unknown>[];\n      } catch {\n        return [];\n      }\n    }\n\n    return [];\n  }\n\n  /**\n   * Handle ID conflict by checking if ID exists and assigning new one if needed.\n   *\n   * @param recordData - The record data to restore\n   * @param originalId - The original ID value\n   * @param onIdConflict - Conflict resolution strategy\n   * @returns Record data with potentially new ID\n   * @private\n   */\n  private async handleIdConflict(\n    recordData: Record<string, unknown>,\n    originalId: string | number,\n    onIdConflict: \"fail\" | \"assignNew\",\n  ): Promise<Record<string, unknown>> {\n    const idExists = await this.checkIdExists(originalId);\n\n    if (idExists) {\n      if (onIdConflict === \"fail\") {\n        throw new Error(\n          `Cannot restore ${this.ctor.name} with ${this.primaryKey} ${originalId}: ID already exists in target table.`,\n        );\n      }\n\n      // Assign new ID\n      return await this.assignNewId(recordData);\n    }\n\n    return recordData;\n  }\n\n  /**\n   * Check if an ID already exists in the target table.\n   *\n   * @param id - The ID to check\n   * @returns True if ID exists, false otherwise\n   * @private\n   */\n  private async checkIdExists(id: string | number): Promise<boolean> {\n    try {\n      const query = this.driver.queryBuilder(this.table).where(this.primaryKey, id).exists();\n\n      return await query;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Assign a new ID to the record data.\n   *\n   * For MongoDB: Generates new ObjectId for `_id`, keeps `id` if it exists\n   * For SQL: Removes `id` to let database auto-increment\n   *\n   * @param recordData - The record data\n   * @returns Record data with new ID assigned\n   * @private\n   */\n  private async assignNewId(recordData: Record<string, unknown>): Promise<Record<string, unknown>> {\n    const isMongoDb = this.driver.name === \"mongodb\";\n    const newData = { ...recordData };\n\n    if (isMongoDb) {\n      // MongoDB: Generate new ObjectId for _id\n      if (this.primaryKey === \"_id\") {\n        // Remove _id to let MongoDB generate new one\n        delete newData._id;\n      } else if (this.primaryKey === \"id\") {\n        // Remove id to let ID generator create new one\n        delete newData.id;\n      }\n    } else {\n      // SQL: Remove primary key to let database auto-increment\n      delete newData[this.primaryKey];\n    }\n\n    return newData;\n  }\n\n  /**\n   * Resolve the trash table/collection name.\n   *\n   * Priority:\n   * 1. Model.trashTable (if set)\n   * 2. Data source defaultTrashTable (e.g., \"RecycleBin\" for MongoDB)\n   * 3. Default pattern: `{table}Trash`\n   *\n   * @returns The trash table/collection name\n   * @private\n   */\n  private resolveTrashTable(): string {\n    if (this.ctor.trashTable) {\n      return this.ctor.trashTable;\n    }\n\n    if (this.dataSource.defaultTrashTable) {\n      return this.dataSource.defaultTrashTable;\n    }\n\n    return `${this.table}Trash`;\n  }\n}\n"],"mappings":"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"}

package/esm/sql-database-dirty-tracker.d.mts

@@ -0,0 +1,17 @@
+import { DatabaseDirtyTracker } from "./database-dirty-tracker.mjs";
+
+//#region ../../@warlock.js/cascade/src/sql-database-dirty-tracker.d.ts
+/**
+ * A dirty tracker designed for SQL databases where nested objects shouldn't be flattened.
+ * Since SQL drivers (like Postgres) replace the entire JSON column when updated,
+ * we keep the object intact instead of using dot-notation keys.
+ */
+declare class SqlDatabaseDirtyTracker extends DatabaseDirtyTracker {
+  /**
+   * Overrides the default flattening behavior to keep the raw data structure.
+   */
+  protected flattenData(data: Record<string, unknown>): Record<string, unknown>;
+}
+//#endregion
+export { SqlDatabaseDirtyTracker };
+//# sourceMappingURL=sql-database-dirty-tracker.d.mts.map

package/esm/sql-database-dirty-tracker.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-database-dirty-tracker.d.mts","names":[],"sources":["../../../../../@warlock.js/cascade/src/sql-database-dirty-tracker.ts"],"mappings":";;;;;AAOA;;;cAAa,uBAAA,SAAgC,oBAAA;EAIoB;;;EAAA,UAA5C,WAAA,CAAY,IAAA,EAAM,MAAA,oBAA0B,MAAA;AAAA"}

package/esm/sql-database-dirty-tracker.mjs

@@ -0,0 +1,20 @@
+import { DatabaseDirtyTracker } from "./database-dirty-tracker.mjs";
+
+//#region ../../@warlock.js/cascade/src/sql-database-dirty-tracker.ts
+/**
+* A dirty tracker designed for SQL databases where nested objects shouldn't be flattened.
+* Since SQL drivers (like Postgres) replace the entire JSON column when updated,
+* we keep the object intact instead of using dot-notation keys.
+*/
+var SqlDatabaseDirtyTracker = class extends DatabaseDirtyTracker {
+	/**
+	* Overrides the default flattening behavior to keep the raw data structure.
+	*/
+	flattenData(data) {
+		return { ...data };
+	}
+};
+
+//#endregion
+export { SqlDatabaseDirtyTracker };
+//# sourceMappingURL=sql-database-dirty-tracker.mjs.map

package/esm/sql-database-dirty-tracker.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sql-database-dirty-tracker.mjs","names":[],"sources":["../../../../../@warlock.js/cascade/src/sql-database-dirty-tracker.ts"],"sourcesContent":["import { DatabaseDirtyTracker } from \"./database-dirty-tracker\";\n\n/**\n * A dirty tracker designed for SQL databases where nested objects shouldn't be flattened.\n * Since SQL drivers (like Postgres) replace the entire JSON column when updated,\n * we keep the object intact instead of using dot-notation keys.\n */\nexport class SqlDatabaseDirtyTracker extends DatabaseDirtyTracker {\n  /**\n   * Overrides the default flattening behavior to keep the raw data structure.\n   */\n  protected override flattenData(data: Record<string, unknown>): Record<string, unknown> {\n    // Return a shallow copy of the data without flattening nested objects\n    return { ...data };\n  }\n}\n"],"mappings":";;;;;;;;AAOA,IAAa,0BAAb,cAA6C,qBAAqB;;;;CAIhE,AAAmB,YAAY,MAAwD;EAErF,OAAO,EAAE,GAAG,KAAK;CACnB;AACF"}

package/esm/sync/model-events.mjs

@@ -0,0 +1,46 @@
+//#region ../../@warlock.js/cascade/src/sync/model-events.ts
+/**
+* Event name prefix for all model sync events.
+*/
+const MODEL_EVENT_PREFIX = "model";
+/**
+* Model sync event types.
+*/
+const ModelSyncEventType = {
+	UPDATED: "updated",
+	DELETED: "deleted"
+};
+/**
+* Get the event name for a model update.
+*
+* @param modelClass - The model class
+* @returns Event name string (e.g., "model.Category.updated")
+*
+* @example
+* ```typescript
+* const eventName = getModelUpdatedEvent(Category);
+* // Returns: "model.Category.updated"
+* ```
+*/
+function getModelUpdatedEvent(modelClass) {
+	return `${MODEL_EVENT_PREFIX}.${modelClass.name}.${ModelSyncEventType.UPDATED}`;
+}
+/**
+* Get the event name for a model deletion.
+*
+* @param modelClass - The model class
+* @returns Event name string (e.g., "model.Category.deleted")
+*
+* @example
+* ```typescript
+* const eventName = getModelDeletedEvent(Category);
+* // Returns: "model.Category.deleted"
+* ```
+*/
+function getModelDeletedEvent(modelClass) {
+	return `${MODEL_EVENT_PREFIX}.${modelClass.name}.${ModelSyncEventType.DELETED}`;
+}
+
+//#endregion
+export { getModelDeletedEvent, getModelUpdatedEvent };
+//# sourceMappingURL=model-events.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"model-events.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/sync/model-events.ts"],"sourcesContent":["/**\n * Model sync event name helpers.\n *\n * Provides type-safe event names for model sync operations.\n * Avoids hardcoded string literals throughout the codebase.\n *\n * @module cascade-next/sync/model-events\n */\n\nimport type { ChildModel, Model } from \"../model/model\";\n\n/**\n * Event name prefix for all model sync events.\n */\nexport const MODEL_EVENT_PREFIX = \"model\";\n\n/**\n * Model sync event types.\n */\nexport const ModelSyncEventType = {\n  UPDATED: \"updated\",\n  DELETED: \"deleted\",\n} as const;\n\nexport type ModelSyncEventTypeName = (typeof ModelSyncEventType)[keyof typeof ModelSyncEventType];\n\n/**\n * Get the event name for a model update.\n *\n * @param modelClass - The model class\n * @returns Event name string (e.g., \"model.Category.updated\")\n *\n * @example\n * ```typescript\n * const eventName = getModelUpdatedEvent(Category);\n * // Returns: \"model.Category.updated\"\n * ```\n */\nexport function getModelUpdatedEvent(modelClass: ChildModel<Model>): string {\n  return `${MODEL_EVENT_PREFIX}.${modelClass.name}.${ModelSyncEventType.UPDATED}`;\n}\n\n/**\n * Get the event name for a model deletion.\n *\n * @param modelClass - The model class\n * @returns Event name string (e.g., \"model.Category.deleted\")\n *\n * @example\n * ```typescript\n * const eventName = getModelDeletedEvent(Category);\n * // Returns: \"model.Category.deleted\"\n * ```\n */\nexport function getModelDeletedEvent(modelClass: ChildModel<Model>): string {\n  return `${MODEL_EVENT_PREFIX}.${modelClass.name}.${ModelSyncEventType.DELETED}`;\n}\n\n/**\n * Get the event name for a model by name string.\n *\n * @param modelName - The model class name\n * @param eventType - The event type\n * @returns Event name string\n *\n * @example\n * ```typescript\n * const eventName = getModelEvent(\"Category\", \"updated\");\n * // Returns: \"model.Category.updated\"\n * ```\n */\nexport function getModelEvent(modelName: string, eventType: ModelSyncEventTypeName): string {\n  return `${MODEL_EVENT_PREFIX}.${modelName}.${eventType}`;\n}\n"],"mappings":";;;;AAcA,MAAa,qBAAqB;;;;AAKlC,MAAa,qBAAqB;CAChC,SAAS;CACT,SAAS;AACX;;;;;;;;;;;;;AAgBA,SAAgB,qBAAqB,YAAuC;CAC1E,OAAO,GAAG,mBAAmB,GAAG,WAAW,KAAK,GAAG,mBAAmB;AACxE;;;;;;;;;;;;;AAcA,SAAgB,qBAAqB,YAAuC;CAC1E,OAAO,GAAG,mBAAmB,GAAG,WAAW,KAAK,GAAG,mBAAmB;AACxE"}