@warlock.js/cascade 4.0.174 → 4.1.1

package/esm/relations/types.d.mts

@@ -0,0 +1,317 @@
+import { ChildModel } from "../model/model.types.mjs";
+import { Model } from "../model/model.mjs";
+import { QueryBuilderContract } from "../contracts/query-builder.contract.mjs";
+import { Lazy } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/cascade/src/relations/types.d.ts
+/**
+ * The type of relationship between models.
+ *
+ * - `hasOne`: One-to-one relationship where the foreign key is on the related model
+ * - `hasMany`: One-to-many relationship where the foreign key is on the related model
+ * - `belongsTo`: Inverse of hasOne/hasMany where the foreign key is on this model
+ * - `belongsToMany`: Many-to-many relationship through a pivot table
+ *
+ * @example
+ * ```typescript
+ * // User hasOne Profile (profile.userId references user.id)
+ * // User hasMany Posts (post.userId references user.id)
+ * // Post belongsTo User (post.userId references user.id)
+ * // Post belongsToMany Tags (through post_tags pivot table)
+ * ```
+ */
+type RelationType = "hasOne" | "hasMany" | "belongsTo" | "belongsToMany";
+/**
+ * Complete definition of a model relationship.
+ *
+ * This interface describes how two models are connected, including
+ * the type of relationship and the keys used for joining.
+ *
+ * @example
+ * ```typescript
+ * const postsRelation: RelationDefinition = {
+ *   type: "hasMany",
+ *   model: "Post",
+ *   foreignKey: "userId",
+ *   localKey: "id",
+ * };
+ * ```
+ */
+type RelationDefinition = {
+  /**
+   * The type of relationship.
+   */
+  readonly type: RelationType;
+  /**
+   * The related model — accepts three forms:
+   *  - **String** registered via `@RegisterModel()` — indirect lookup,
+   *    cycle-safe because resolution is dynamic. Required for cross-package
+   *    refs that can't import the class.
+   *  - **Direct class reference** — idiomatic and type-safe. Cleanest
+   *    choice when no import cycle exists between the two model files.
+   *  - **`lazy(() => SomeModel)`** — type-safe AND cycle-safe. The
+   *    closure defers reading the binding until query time, sidestepping
+   *    the ESM partial-load gotcha that breaks direct refs in cycles.
+   *
+   * The framework resolves all three via `resolveModelClass()` from
+   * `model/register-model.ts`. Direct class and lazy refs carry the class
+   * directly, so their target does NOT need to be registered.
+   */
+  readonly model: string | ChildModel<Model> | Lazy<unknown>;
+  /**
+   * The foreign key field on the related model (for hasOne/hasMany)
+   * or on this model (for belongsTo).
+   *
+   * For belongsToMany, this is the key on the related model.
+   */
+  readonly foreignKey?: string;
+  /**
+   * The local key field on this model that the foreign key references.
+   *
+   * @default "id"
+   */
+  readonly localKey?: string;
+  /**
+   * The pivot table name (only for belongsToMany relationships).
+   */
+  readonly pivot?: string;
+  /**
+   * The column in the pivot table that references this model's primary key.
+   * Only applicable for belongsToMany relationships.
+   */
+  readonly pivotLocalKey?: string;
+  /**
+   * The column in the pivot table that references the related model's primary key.
+   * Only applicable for belongsToMany relationships.
+   */
+  readonly pivotForeignKey?: string;
+  /**
+   * List of specific columns to select.
+   *
+   * If not provided, defaults to all columns.
+   */
+  readonly select?: string[];
+};
+/**
+ * Configuration options for a hasMany relationship.
+ *
+ * @example
+ * ```typescript
+ * // User has many Posts via post.userId
+ * static relations = {
+ *   posts: hasMany("Post", { foreignKey: "userId" }),
+ * };
+ * ```
+ */
+type HasManyOptions = {
+  /**
+   * The foreign key field on the related model.
+   *
+   * If not provided, defaults to `{thisModelName}Id` (e.g., `userId` for User model).
+   */
+  readonly foreignKey?: string;
+  /**
+   * The local key field on this model that the foreign key references.
+   *
+   * @default "id"
+   */
+  readonly localKey?: string;
+  /**
+   * List of specific columns to select.
+   *
+   * If not provided, defaults to all columns.
+   */
+  readonly select?: string[];
+};
+/**
+ * Configuration options for a hasOne relationship.
+ *
+ * @example
+ * ```typescript
+ * // User has one Profile via profile.userId
+ * static relations = {
+ *   profile: hasOne("Profile", { foreignKey: "userId" }),
+ * };
+ * ```
+ */
+type HasOneOptions = {
+  /**
+   * The foreign key field on the related model.
+   *
+   * If not provided, defaults to `{thisModelName}Id` (e.g., `userId` for User model).
+   */
+  readonly foreignKey?: string;
+  /**
+   * The local key field on this model that the foreign key references.
+   *
+   * @default "id"
+   */
+  readonly localKey?: string;
+  /**
+   * List of specific columns to select.
+   *
+   * If not provided, defaults to all columns.
+   */
+  readonly select?: string[];
+};
+/**
+ * Configuration options for a belongsTo relationship.
+ *
+ * @example
+ * ```typescript
+ * // Post belongs to User via post.userId
+ * static relations = {
+ *   author: belongsTo("User", { foreignKey: "userId" }),
+ * };
+ * ```
+ */
+type BelongsToOptions = {
+  /**
+   * The foreign key field on this model that references the related model.
+   *
+   * If not provided, defaults to `{relationName}Id` (e.g., `authorId` for author relation).
+   */
+  readonly foreignKey?: string;
+  /**
+   * The primary key field on the related model.
+   *
+   * @default "id"
+   */
+  readonly ownerKey?: string;
+  /**
+   * List of specific columns to select from the related model.
+   */
+  readonly select?: string[];
+};
+/**
+ * Configuration options for a belongsToMany relationship.
+ *
+ * @example
+ * ```typescript
+ * // Post belongs to many Tags via post_tags pivot table
+ * static relations = {
+ *   tags: belongsToMany("Tag", {
+ *     pivot: "post_tags",
+ *     localKey: "postId",
+ *     foreignKey: "tagId",
+ *   }),
+ * };
+ * ```
+ */
+type BelongsToManyOptions = {
+  /**
+   * The pivot table name that connects the two models.
+   *
+   * If omitted, defaults to the alphabetical snake-case join of the two
+   * model names (e.g. `post_tag` for `Post` ↔ `Tag`).
+   */
+  readonly pivot?: string;
+  /**
+   * The column in the pivot table that references this model's primary key.
+   *
+   * If not provided, defaults to `{thisModelName}Id`.
+   */
+  readonly localKey?: string;
+  /**
+   * The column in the pivot table that references the related model's primary key.
+   *
+   * If not provided, defaults to `{relatedModelName}Id`.
+   */
+  readonly foreignKey?: string;
+  /**
+   * The primary key of this model that the pivot table references.
+   *
+   * @default "id"
+   */
+  readonly pivotLocalKey?: string;
+  /**
+   * The primary key of the related model that the pivot table references.
+   *
+   * @default "id"
+   */
+  readonly pivotForeignKey?: string;
+  /**
+   * List of specific columns to select from the related model.
+   */
+  readonly select?: string[];
+};
+/**
+ * Callback function to apply constraints when loading a relation.
+ *
+ * @example
+ * ```typescript
+ * User.query().with("posts", (query) => {
+ *   query.where("isPublished", true).orderBy("createdAt", "desc");
+ * });
+ * ```
+ */
+type RelationConstraintCallback = (query: QueryBuilderContract) => void;
+/**
+ * Constraints to apply when loading relations.
+ *
+ * Can be:
+ * - A single constraint callback for a relation
+ * - An object mapping relation names to constraint callbacks or boolean values
+ *
+ * @example
+ * ```typescript
+ * // Object form
+ * await User.loadRelations(users, {
+ *   posts: (query) => query.where("isPublished", true),
+ *   organization: true,
+ * });
+ * ```
+ */
+type RelationConstraints = Record<string, boolean | RelationConstraintCallback>;
+/**
+ * Type for the result of loading a relation.
+ *
+ * - For hasOne/belongsTo: A single model instance or null
+ * - For hasMany/belongsToMany: An array of model instances
+ */
+type LoadedRelationResult = Model | Model[] | null;
+/**
+ * Map that stores loaded relation data on a model instance.
+ *
+ * @example
+ * ```typescript
+ * // After user.load("posts", "profile")
+ * user.loadedRelations.get("posts"); // Post[]
+ * user.loadedRelations.get("profile"); // Profile | null
+ * ```
+ */
+type LoadedRelationsMap = Map<string, LoadedRelationResult>;
+/**
+ * A map of relation names to their definitions.
+ *
+ * This is the type for the static `relations` property on models.
+ *
+ * @example
+ * ```typescript
+ * class User extends Model {
+ *   static relations: RelationDefinitions = {
+ *     posts: hasMany("Post"),
+ *     profile: hasOne("Profile"),
+ *     organization: belongsTo("Organization"),
+ *   };
+ * }
+ * ```
+ */
+type RelationDefinitions = Record<string, RelationDefinition>;
+/**
+ * Additional data to store in the pivot table for many-to-many relationships.
+ *
+ * @example
+ * ```typescript
+ * await post.attach("tags", [1, 2, 3], { addedBy: userId, addedAt: new Date() });
+ * ```
+ */
+type PivotData = Record<string, unknown>;
+/**
+ * IDs that can be used for pivot operations.
+ * Supports both numeric and string IDs.
+ */
+type PivotIds = (number | string)[];
+//#endregion
+export { BelongsToManyOptions, BelongsToOptions, HasManyOptions, HasOneOptions, LoadedRelationResult, LoadedRelationsMap, PivotData, PivotIds, RelationConstraintCallback, RelationConstraints, RelationDefinition, RelationDefinitions, RelationType };
+//# sourceMappingURL=types.d.mts.map

package/esm/relations/types.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/relations/types.ts"],"mappings":";;;;;;AAiCwB;AAsBxB;;;;;;;;;;;;;;;AAtBwB,KAAZ,YAAA;;;;;;;AAkFK;AAkBjB;;;;;;;;AAoBiB;KAlGL,kBAAA;EAgHa;;;EAAA,SA5Gd,IAAA,EAAM,YAAA;EAyHN;;;AAOM;AAcjB;;;;;;;;AAkBiB;AAkBjB;;EAzDW,SAxGA,KAAA,WAAgB,UAAA,CAAW,KAAA,IAAS,IAAA;EAiKf;;;;;;EAAA,SAzJrB,UAAA;EAiMM;AAAA;AAiBjB;;;EAjBiB,SA1LN,QAAA;EA2M0D;AAkBrE;;EAlBqE,SAtM1D,KAAA;EAwNuB;AAAmD;AAYrF;;EAZkC,SAlNvB,aAAA;EA8NwB;AAAa;AAYhD;;EAZmC,SAxNxB,eAAA;EAoOsB;AAAgC;AAsBjE;;;EAtBiC,SA7NtB,MAAA;AAAA;AAiQX;;;;AAA8B;AAM9B;;;;AAAoB;;AANpB,KA/OY,cAAA;;;;;;WAMD,UAAA;;;;;;WAOA,QAAA;;;;;;WAOA,MAAA;AAAA;;;;;;;;;;;;KAcC,aAAA;;;;;;WAMD,UAAA;;;;;;WAOA,QAAA;;;;;;WAOA,MAAA;AAAA;;;;;;;;;;;;KAcC,gBAAA;;;;;;WAMD,UAAA;;;;;;WAOA,QAAA;;;;WAKA,MAAA;AAAA;;;;;;;;;;;;;;;;KAkBC,oBAAA;;;;;;;WAOD,KAAA;;;;;;WAOA,QAAA;;;;;;WAOA,UAAA;;;;;;WAOA,aAAA;;;;;;WAOA,eAAA;;;;WAKA,MAAA;AAAA;;;;;;;;;;;KAiBC,0BAAA,IAA8B,KAA2B,EAApB,oBAAoB;;;;;;;;;;;;;;;;;KAkBzD,mBAAA,GAAsB,MAAM,mBAAmB,0BAAA;;;;;;;KAY/C,oBAAA,GAAuB,KAAA,GAAQ,KAAK;;;;;;;;;;;KAYpC,kBAAA,GAAqB,GAAG,SAAS,oBAAA;;;;;;;;;;;;;;;;;KAsBjC,mBAAA,GAAsB,MAAM,SAAS,kBAAA;;;;;;;;;KAcrC,SAAA,GAAY,MAAM;;;;;KAMlB,QAAA"}

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

@@ -0,0 +1,104 @@
+import { Model } from "../model/model.mjs";
+import { RemoverContract, RemoverOptions, RemoverResult } from "../contracts/database-remover.contract.mjs";
+
+//#region ../../@warlock.js/cascade/src/remover/database-remover.d.ts
+/**
+ * Database remover service that orchestrates model deletion.
+ *
+ * Handles the complete deletion pipeline:
+ * 1. Strategy resolution (options → model static → data source default)
+ * 2. Validation (check if model is new, has primary key)
+ * 3. Event emission (deleting, deleted)
+ * 4. Driver execution (based on strategy: trash, permanent, or soft)
+ * 5. Post-deletion cleanup (mark as new, reset state)
+ *
+ * @example
+ * ```typescript
+ * const user = await User.find(1);
+ * const remover = new DatabaseRemover(user);
+ * const result = await remover.destroy();
+ *
+ * console.log(result.success); // true
+ * console.log(result.strategy); // "trash" | "permanent" | "soft"
+ * ```
+ */
+declare class DatabaseRemover implements RemoverContract {
+  /** The model instance being deleted */
+  private readonly model;
+  /** 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 remover instance for a model.
+   *
+   * @param model - The model instance to delete
+   *
+   * @example
+   * ```typescript
+   * const user = await User.find(1);
+   * const remover = new DatabaseRemover(user);
+   * await remover.destroy();
+   * ```
+   */
+  constructor(model: Model);
+  /**
+   * Destroy (delete) the model instance from the database.
+   *
+   * @param options - Remover options
+   * @returns Result containing success status, strategy used, and metadata
+   * @throws {Error} If model is new (not saved) or if deletion fails
+   */
+  destroy(options?: RemoverOptions): Promise<RemoverResult>;
+  /**
+   * Prepare the trash record by preserving all original fields and adding deletion metadata.
+   *
+   * Keeps all original fields intact for easy restoration and adds:
+   * - `deletedAt`: Timestamp when the record was deleted
+   * - `originalTable`: The table/collection the record came from (for filtering in restoreAll)
+   *
+   * **ID Handling:**
+   * - MongoDB with `_id`: Keeps `_id` as-is (unique across database)
+   * - MongoDB with auto-increment `id`: Keeps `id` as a regular field (not primary key)
+   * - SQL: Keeps original `id` as a regular field (trash table uses its own auto-increment primary key)
+   *
+   * The trash table should use its own primary key structure:
+   * - MongoDB: Uses `_id` (ObjectId) as primary key, original `id` is just a field
+   * - SQL: Uses auto-increment `trashId` as primary key, original `id` is just a field
+   *
+   * @param documentData - The original document data
+   * @returns Prepared trash record data with all original fields + deletedAt + originalTable
+   * @private
+   */
+  private prepareTrashRecord;
+  /**
+   * 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;
+  /**
+   * Trigger sync operations after successful deletion.
+   *
+   * Emits a model.deleted event that ModelSyncOperation listens to.
+   * The sync is handled by registered sync operations, not directly here.
+   *
+   * @private
+   */
+  private triggerSync;
+}
+//#endregion
+export { DatabaseRemover };
+//# sourceMappingURL=database-remover.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"database-remover.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/remover/database-remover.ts"],"mappings":";;;;;;AAgCA;;;;;;;;;;;;;;;;;;cAAa,eAAA,YAA2B,eAAA;EA+BnB;EAAA,iBA7BF,KAAA;EA6Ca;EAAA,iBA1Cb,IAAA;EA0CmC;EAAA,iBAvCnC,UAAA;EAqLT;EAAA,iBAlLS,MAAA;EA0NH;EAAA,iBAvNG,KAAA;EAuNQ;EAAA,iBApNR,UAAA;;;;;;;;;;;;;cAcE,KAAA,EAAO,KAAA;;;;;;;;EAgBb,OAAA,CAAQ,OAAA,GAAS,cAAA,GAAsB,OAAA,CAAQ,aAAA;;;;;;;;;;;;;;;;;;;;;UA8IpD,kBAAA;;;;;;;;;;;;UAoBA,iBAAA;;;;;;;;;UAoBM,WAAA;AAAA"}

package/esm/remover/database-remover.mjs

@@ -0,0 +1,174 @@
+import { getModelDeletedEvent } from "../sync/model-events.mjs";
+import events from "@mongez/events";
+
+//#region ../../@warlock.js/cascade/src/remover/database-remover.ts
+/**
+* Database remover service that orchestrates model deletion.
+*
+* Handles the complete deletion pipeline:
+* 1. Strategy resolution (options → model static → data source default)
+* 2. Validation (check if model is new, has primary key)
+* 3. Event emission (deleting, deleted)
+* 4. Driver execution (based on strategy: trash, permanent, or soft)
+* 5. Post-deletion cleanup (mark as new, reset state)
+*
+* @example
+* ```typescript
+* const user = await User.find(1);
+* const remover = new DatabaseRemover(user);
+* const result = await remover.destroy();
+*
+* console.log(result.success); // true
+* console.log(result.strategy); // "trash" | "permanent" | "soft"
+* ```
+*/
+var DatabaseRemover = class {
+	/** The model instance being deleted */
+	model;
+	/** 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 remover instance for a model.
+	*
+	* @param model - The model instance to delete
+	*
+	* @example
+	* ```typescript
+	* const user = await User.find(1);
+	* const remover = new DatabaseRemover(user);
+	* await remover.destroy();
+	* ```
+	*/
+	constructor(model) {
+		this.model = model;
+		this.ctor = model.constructor;
+		this.dataSource = this.ctor.getDataSource();
+		this.driver = this.dataSource.driver;
+		this.table = this.ctor.table;
+		this.primaryKey = this.ctor.primaryKey;
+	}
+	/**
+	* Destroy (delete) the model instance from the database.
+	*
+	* @param options - Remover options
+	* @returns Result containing success status, strategy used, and metadata
+	* @throws {Error} If model is new (not saved) or if deletion fails
+	*/
+	async destroy(options = {}) {
+		const strategy = options.strategy ?? this.ctor.deleteStrategy ?? this.dataSource.defaultDeleteStrategy ?? "permanent";
+		if (this.model.isNew) throw new Error(`Cannot destroy ${this.ctor.name} instance that hasn't been saved to the database.`);
+		const primaryKeyValue = this.model.get(this.primaryKey);
+		if (!primaryKeyValue) throw new Error(`Cannot destroy ${this.ctor.name} instance: primary key (${this.primaryKey}) is missing.`);
+		if (!options.skipEvents) await this.model.emitEvent("deleting", {
+			strategy,
+			primaryKeyValue,
+			primaryKey: this.primaryKey
+		});
+		let deletedCount = 0;
+		let trashRecord;
+		const filter = { [this.primaryKey]: primaryKeyValue };
+		const context = {
+			strategy,
+			primaryKeyValue,
+			primaryKey: this.primaryKey
+		};
+		switch (strategy) {
+			case "trash": {
+				const trashTable = this.resolveTrashTable();
+				const documentData = { ...this.model.data };
+				const trashData = this.prepareTrashRecord(documentData);
+				trashRecord = (await this.driver.insert(trashTable, trashData)).document;
+				context.trashRecord = trashRecord;
+				deletedCount = await this.driver.delete(this.table, filter) > 0 ? 1 : 0;
+				break;
+			}
+			case "permanent":
+				deletedCount = await this.driver.delete(this.table, filter) > 0 ? 1 : 0;
+				break;
+			case "soft": {
+				const deletedAtColumn = this.ctor.deletedAtColumn;
+				if (deletedAtColumn === false || deletedAtColumn === void 0) throw new Error(`Cannot perform soft delete on ${this.ctor.name}: deletedAtColumn is not configured. Set a column name or use a different delete strategy.`);
+				const updateOperations = { $set: { [deletedAtColumn]: /* @__PURE__ */ new Date() } };
+				deletedCount = (await this.driver.update(this.table, filter, updateOperations)).modifiedCount > 0 ? 1 : 0;
+				break;
+			}
+		}
+		if (deletedCount === 0) throw new Error(`Failed to destroy ${this.ctor.name} instance: record not found.`);
+		context.deletedCount = deletedCount;
+		if (strategy !== "soft") this.model.isNew = true;
+		if (!options.skipEvents) await this.model.emitEvent("deleted", context);
+		if (!options.skipSync) this.triggerSync();
+		return {
+			success: true,
+			deletedCount,
+			strategy,
+			trashRecord
+		};
+	}
+	/**
+	* Prepare the trash record by preserving all original fields and adding deletion metadata.
+	*
+	* Keeps all original fields intact for easy restoration and adds:
+	* - `deletedAt`: Timestamp when the record was deleted
+	* - `originalTable`: The table/collection the record came from (for filtering in restoreAll)
+	*
+	* **ID Handling:**
+	* - MongoDB with `_id`: Keeps `_id` as-is (unique across database)
+	* - MongoDB with auto-increment `id`: Keeps `id` as a regular field (not primary key)
+	* - SQL: Keeps original `id` as a regular field (trash table uses its own auto-increment primary key)
+	*
+	* The trash table should use its own primary key structure:
+	* - MongoDB: Uses `_id` (ObjectId) as primary key, original `id` is just a field
+	* - SQL: Uses auto-increment `trashId` as primary key, original `id` is just a field
+	*
+	* @param documentData - The original document data
+	* @returns Prepared trash record data with all original fields + deletedAt + originalTable
+	* @private
+	*/
+	prepareTrashRecord(documentData) {
+		return {
+			...documentData,
+			deletedAt: /* @__PURE__ */ new Date(),
+			originalTable: this.table
+		};
+	}
+	/**
+	* 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`;
+	}
+	/**
+	* Trigger sync operations after successful deletion.
+	*
+	* Emits a model.deleted event that ModelSyncOperation listens to.
+	* The sync is handled by registered sync operations, not directly here.
+	*
+	* @private
+	*/
+	async triggerSync() {
+		await events.triggerAll(getModelDeletedEvent(this.ctor), this.model);
+	}
+};
+
+//#endregion
+export { DatabaseRemover };
+//# sourceMappingURL=database-remover.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"database-remover.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/remover/database-remover.ts"],"sourcesContent":["import events from \"@mongez/events\";\nimport type { DriverContract, UpdateOperations } from \"../contracts/database-driver.contract\";\nimport type {\n  RemoverContract,\n  RemoverOptions,\n  RemoverResult,\n} from \"../contracts/database-remover.contract\";\nimport type { OnDeletedEventContext } from \"../events/model-events\";\nimport type { ChildModel, Model } from \"../model/model\";\nimport { getModelDeletedEvent } from \"../sync/model-events\";\nimport type { DataSource } from \"./../data-source/data-source\";\n\n/**\n * Database remover service that orchestrates model deletion.\n *\n * Handles the complete deletion pipeline:\n * 1. Strategy resolution (options → model static → data source default)\n * 2. Validation (check if model is new, has primary key)\n * 3. Event emission (deleting, deleted)\n * 4. Driver execution (based on strategy: trash, permanent, or soft)\n * 5. Post-deletion cleanup (mark as new, reset state)\n *\n * @example\n * ```typescript\n * const user = await User.find(1);\n * const remover = new DatabaseRemover(user);\n * const result = await remover.destroy();\n *\n * console.log(result.success); // true\n * console.log(result.strategy); // \"trash\" | \"permanent\" | \"soft\"\n * ```\n */\nexport class DatabaseRemover implements RemoverContract {\n  /** The model instance being deleted */\n  private readonly model: Model;\n\n  /** Model constructor reference */\n  private readonly ctor: ChildModel<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 remover instance for a model.\n   *\n   * @param model - The model instance to delete\n   *\n   * @example\n   * ```typescript\n   * const user = await User.find(1);\n   * const remover = new DatabaseRemover(user);\n   * await remover.destroy();\n   * ```\n   */\n  public constructor(model: Model) {\n    this.model = model;\n    this.ctor = model.constructor as ChildModel<Model>;\n    this.dataSource = this.ctor.getDataSource();\n    this.driver = this.dataSource.driver;\n    this.table = this.ctor.table;\n    this.primaryKey = this.ctor.primaryKey;\n  }\n\n  /**\n   * Destroy (delete) the model instance from the database.\n   *\n   * @param options - Remover options\n   * @returns Result containing success status, strategy used, and metadata\n   * @throws {Error} If model is new (not saved) or if deletion fails\n   */\n  public async destroy(options: RemoverOptions = {}): Promise<RemoverResult> {\n    // 1. Resolve strategy (options → model static → data source default → permanent)\n    const strategy =\n      options.strategy ??\n      this.ctor.deleteStrategy ??\n      this.dataSource.defaultDeleteStrategy ??\n      \"permanent\";\n\n    // 2. Validate model is not new and has primary key\n    if (this.model.isNew) {\n      throw new Error(\n        `Cannot destroy ${this.ctor.name} instance that hasn't been saved to the database.`,\n      );\n    }\n\n    const primaryKeyValue = this.model.get(this.primaryKey);\n    if (!primaryKeyValue) {\n      throw new Error(\n        `Cannot destroy ${this.ctor.name} instance: primary key (${this.primaryKey}) is missing.`,\n      );\n    }\n\n    // 3. Emit deleting event (unless skipEvents)\n    if (!options.skipEvents) {\n      await this.model.emitEvent(\"deleting\", {\n        strategy,\n        primaryKeyValue,\n        primaryKey: this.primaryKey,\n      });\n    }\n\n    // 4. Execute deletion based on strategy\n    let deletedCount = 0;\n    let trashRecord: Record<string, unknown> | undefined;\n\n    const filter = { [this.primaryKey]: primaryKeyValue };\n\n    const context: Partial<OnDeletedEventContext> = {\n      strategy,\n      primaryKeyValue,\n      primaryKey: this.primaryKey,\n    };\n\n    switch (strategy) {\n      case \"trash\": {\n        // Move to trash table, then delete\n        const trashTable = this.resolveTrashTable();\n        const documentData = { ...this.model.data };\n\n        // Prepare trash record with metadata and handle ID conflicts\n        const trashData = this.prepareTrashRecord(documentData);\n\n        // Insert into trash table\n        const insertResult = await this.driver.insert(trashTable, trashData);\n        trashRecord = insertResult.document as Record<string, unknown>;\n\n        context.trashRecord = trashRecord;\n\n        // Delete original\n        const result = await this.driver.delete(this.table, filter);\n        deletedCount = result > 0 ? 1 : 0;\n        break;\n      }\n\n      case \"permanent\": {\n        // Direct deletion\n        const result = await this.driver.delete(this.table, filter);\n        deletedCount = result > 0 ? 1 : 0;\n        break;\n      }\n\n      case \"soft\": {\n        // Set deletedAt timestamp (using resolved column name)\n        const deletedAtColumn = this.ctor.deletedAtColumn;\n        \n        // Only proceed if deletedAtColumn is configured (not false or undefined)\n        if (deletedAtColumn === false || deletedAtColumn === undefined) {\n          throw new Error(\n            `Cannot perform soft delete on ${this.ctor.name}: deletedAtColumn is not configured. ` +\n            `Set a column name or use a different delete strategy.`,\n          );\n        }\n        \n        const updateOperations: UpdateOperations = {\n          $set: { [deletedAtColumn]: new Date() },\n        };\n        const updateResult = await this.driver.update(this.table, filter, updateOperations);\n        deletedCount = updateResult.modifiedCount > 0 ? 1 : 0;\n        break;\n      }\n    }\n\n    if (deletedCount === 0) {\n      throw new Error(`Failed to destroy ${this.ctor.name} instance: record not found.`);\n    }\n\n    context.deletedCount = deletedCount;\n\n    // 5. Post-deletion cleanup\n    // Only mark as new for permanent and trash (soft delete keeps the record)\n    if (strategy !== \"soft\") {\n      this.model.isNew = true;\n    }\n\n    // 6. Emit deleted event (unless skipEvents)\n    if (!options.skipEvents) {\n      await this.model.emitEvent(\"deleted\", context);\n    }\n\n    // 7. Trigger sync operations (fire-and-forget, non-blocking)\n    if (!options.skipSync) {\n      void this.triggerSync();\n    }\n\n    return {\n      success: true,\n      deletedCount,\n      strategy,\n      trashRecord,\n    };\n  }\n\n  /**\n   * Prepare the trash record by preserving all original fields and adding deletion metadata.\n   *\n   * Keeps all original fields intact for easy restoration and adds:\n   * - `deletedAt`: Timestamp when the record was deleted\n   * - `originalTable`: The table/collection the record came from (for filtering in restoreAll)\n   *\n   * **ID Handling:**\n   * - MongoDB with `_id`: Keeps `_id` as-is (unique across database)\n   * - MongoDB with auto-increment `id`: Keeps `id` as a regular field (not primary key)\n   * - SQL: Keeps original `id` as a regular field (trash table uses its own auto-increment primary key)\n   *\n   * The trash table should use its own primary key structure:\n   * - MongoDB: Uses `_id` (ObjectId) as primary key, original `id` is just a field\n   * - SQL: Uses auto-increment `trashId` as primary key, original `id` is just a field\n   *\n   * @param documentData - The original document data\n   * @returns Prepared trash record data with all original fields + deletedAt + originalTable\n   * @private\n   */\n  private prepareTrashRecord(documentData: Record<string, unknown>): Record<string, unknown> {\n    // Preserve all original fields and add deletion metadata\n    return {\n      ...documentData,\n      deletedAt: new Date(),\n      originalTable: this.table,\n    };\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  /**\n   * Trigger sync operations after successful deletion.\n   *\n   * Emits a model.deleted event that ModelSyncOperation listens to.\n   * The sync is handled by registered sync operations, not directly here.\n   *\n   * @private\n   */\n  private async triggerSync(): Promise<void> {\n    // Emit model.deleted event - ModelSyncOperation listens to these\n    await events.triggerAll(getModelDeletedEvent(this.ctor), this.model);\n  }\n}\n"],"mappings":"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"}