@warlock.js/cascade 4.0.174 → 4.1.2

package/esm/utils/once-connected.mjs

@@ -0,0 +1,203 @@
+import { dataSourceRegistry } from "../data-source/data-source-registry.mjs";
+
+//#region ../../@warlock.js/cascade/src/utils/once-connected.ts
+/**
+* Execute a callback once the driver is connected.
+*
+* If the driver is already connected, the callback is executed immediately.
+* Otherwise, it waits for the "connected" event.
+*
+* **Use Case:**
+* Useful for ensuring database-dependent operations only run after connection
+* is established, especially in small to medium projects with a single data source.
+*
+* @param dataSourceOrNameOrCallback - Data source instance, name, or callback function
+* @param callback - Function to execute once connected (optional if first param is callback)
+*
+* @example
+* ```typescript
+* // With default data source (just callback)
+* await connectToDatabase({ database: "myapp" });
+*
+* onceConnected((ds) => {
+*   console.log("Database is ready!");
+*   console.log("Connected to:", ds.name);
+* });
+* ```
+*
+* @example
+* ```typescript
+* // With data source name
+* onceConnected("primary", (ds) => {
+*   console.log("Primary database is ready!");
+* });
+* ```
+*
+* @example
+* ```typescript
+* // With data source instance
+* const dataSource = await connectToDatabase({ database: "myapp" });
+*
+* onceConnected(dataSource, (ds) => {
+*   console.log("Database is ready!");
+* });
+* ```
+*
+* @example
+* ```typescript
+* // With driver instance
+* const driver = new MongoDbDriver(config);
+* const dataSource = new DataSource({ name: "primary", driver });
+*
+* onceConnected(dataSource, () => {
+*   // Start application server
+*   app.listen(3000);
+* });
+*
+* // Connect after setting up the callback
+* await driver.connect();
+* ```
+*
+* @example
+* ```typescript
+* // Chaining operations
+* onceConnected(async (ds) => {
+*   // Seed database
+*   await seedDatabase();
+*
+*   // Run migrations
+*   await runMigrations();
+*
+*   console.log("Database ready!");
+* });
+* ```
+*/
+function onceConnected(dataSourceOrNameOrCallback, callback) {
+	let targetDataSource;
+	let actualCallback;
+	if (typeof dataSourceOrNameOrCallback === "function") {
+		actualCallback = dataSourceOrNameOrCallback;
+		targetDataSource = "default";
+	} else {
+		if (!callback) throw new Error("Callback is required when providing a data source name or instance.");
+		actualCallback = callback;
+		targetDataSource = dataSourceOrNameOrCallback;
+	}
+	let resolvedDataSource;
+	if (typeof targetDataSource === "string") try {
+		resolvedDataSource = targetDataSource === "default" ? dataSourceRegistry.get() : dataSourceRegistry.get(targetDataSource);
+	} catch {}
+	else resolvedDataSource = targetDataSource;
+	if (resolvedDataSource && resolvedDataSource.driver.isConnected) {
+		actualCallback(resolvedDataSource);
+		return;
+	}
+	const listener = (ds) => {
+		if (typeof targetDataSource === "string" ? targetDataSource === "default" ? ds.isDefault : ds.name === targetDataSource : ds === targetDataSource) {
+			dataSourceRegistry.off("connected", listener);
+			actualCallback(ds);
+		}
+	};
+	dataSourceRegistry.on("connected", listener);
+}
+/**
+* Execute a callback once the driver is disconnected.
+*
+* If the driver is already disconnected, the callback is executed immediately.
+* Otherwise, it waits for the "disconnected" event.
+*
+* **Use Case:**
+* Useful for cleanup operations, graceful shutdown, or reconnection logic.
+*
+* @param dataSourceOrNameOrCallback - Data source instance, name, or callback function
+* @param callback - Function to execute once disconnected (optional if first param is callback)
+*
+* @example
+* ```typescript
+* // With default data source (just callback)
+* await connectToDatabase({ database: "myapp" });
+*
+* onceDisconnected((ds) => {
+*   console.log("Database disconnected!");
+*   console.log("Attempting reconnection...");
+* });
+* ```
+*
+* @example
+* ```typescript
+* // With data source name
+* onceDisconnected("primary", (ds) => {
+*   console.log("Primary database disconnected!");
+* });
+* ```
+*
+* @example
+* ```typescript
+* // With data source instance
+* const dataSource = await connectToDatabase({ database: "myapp" });
+*
+* onceDisconnected(dataSource, (ds) => {
+*   console.log("Database disconnected!");
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Graceful shutdown with default data source
+* process.on("SIGTERM", async () => {
+*   console.log("Shutting down...");
+*
+*   onceDisconnected(() => {
+*     console.log("Database closed, exiting process");
+*     process.exit(0);
+*   });
+*
+*   const dataSource = DataSourceRegistry.getDefault();
+*   await dataSource?.driver.disconnect();
+* });
+* ```
+*
+* @example
+* ```typescript
+* // Cleanup resources on disconnect
+* onceDisconnected(async (ds) => {
+*   // Close file handles
+*   await closeFileHandles();
+*
+*   // Clear caches
+*   clearCaches();
+*
+*   console.log("Cleanup complete");
+* });
+* ```
+*/
+function onceDisconnected(dataSourceOrNameOrCallback, callback) {
+	let targetDataSource;
+	let actualCallback;
+	if (typeof dataSourceOrNameOrCallback === "function") {
+		actualCallback = dataSourceOrNameOrCallback;
+		targetDataSource = "default";
+	} else {
+		if (!callback) throw new Error("Callback is required when providing a data source name or instance.");
+		actualCallback = callback;
+		targetDataSource = dataSourceOrNameOrCallback;
+	}
+	let resolvedDataSource;
+	if (typeof targetDataSource === "string") try {
+		resolvedDataSource = targetDataSource === "default" ? dataSourceRegistry.get() : dataSourceRegistry.get(targetDataSource);
+	} catch {}
+	else resolvedDataSource = targetDataSource;
+	if (resolvedDataSource && !resolvedDataSource.driver.isConnected) {
+		actualCallback(resolvedDataSource);
+		return;
+	}
+	const listener = (ds) => {
+		if (typeof targetDataSource === "string" ? targetDataSource === "default" ? ds.isDefault : ds.name === targetDataSource : ds === targetDataSource) actualCallback(ds);
+		else dataSourceRegistry.once("disconnected", listener);
+	};
+	dataSourceRegistry.once("disconnected", listener);
+}
+
+//#endregion
+export { onceConnected, onceDisconnected };
+//# sourceMappingURL=once-connected.mjs.map

package/esm/utils/once-connected.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"once-connected.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/utils/once-connected.ts"],"sourcesContent":["import type { DataSource } from \"../data-source/data-source\";\nimport { dataSourceRegistry } from \"../data-source/data-source-registry\";\n\n/**\n * Execute a callback once the driver is connected.\n *\n * If the driver is already connected, the callback is executed immediately.\n * Otherwise, it waits for the \"connected\" event.\n *\n * **Use Case:**\n * Useful for ensuring database-dependent operations only run after connection\n * is established, especially in small to medium projects with a single data source.\n *\n * @param dataSourceOrNameOrCallback - Data source instance, name, or callback function\n * @param callback - Function to execute once connected (optional if first param is callback)\n *\n * @example\n * ```typescript\n * // With default data source (just callback)\n * await connectToDatabase({ database: \"myapp\" });\n *\n * onceConnected((ds) => {\n *   console.log(\"Database is ready!\");\n *   console.log(\"Connected to:\", ds.name);\n * });\n * ```\n *\n * @example\n * ```typescript\n * // With data source name\n * onceConnected(\"primary\", (ds) => {\n *   console.log(\"Primary database is ready!\");\n * });\n * ```\n *\n * @example\n * ```typescript\n * // With data source instance\n * const dataSource = await connectToDatabase({ database: \"myapp\" });\n *\n * onceConnected(dataSource, (ds) => {\n *   console.log(\"Database is ready!\");\n * });\n * ```\n *\n * @example\n * ```typescript\n * // With driver instance\n * const driver = new MongoDbDriver(config);\n * const dataSource = new DataSource({ name: \"primary\", driver });\n *\n * onceConnected(dataSource, () => {\n *   // Start application server\n *   app.listen(3000);\n * });\n *\n * // Connect after setting up the callback\n * await driver.connect();\n * ```\n *\n * @example\n * ```typescript\n * // Chaining operations\n * onceConnected(async (ds) => {\n *   // Seed database\n *   await seedDatabase();\n *\n *   // Run migrations\n *   await runMigrations();\n *\n *   console.log(\"Database ready!\");\n * });\n * ```\n */\nexport function onceConnected(\n  dataSourceOrNameOrCallback: DataSource | string | ((dataSource: DataSource) => void),\n  callback?: (dataSource: DataSource) => void,\n): void {\n  // Determine if first parameter is a callback\n  let targetDataSource: DataSource | string;\n  let actualCallback: (dataSource: DataSource) => void;\n\n  if (typeof dataSourceOrNameOrCallback === \"function\") {\n    // First param is callback, use default data source\n    actualCallback = dataSourceOrNameOrCallback;\n    targetDataSource = \"default\";\n  } else {\n    // First param is data source name or instance\n    if (!callback) {\n      throw new Error(\"Callback is required when providing a data source name or instance.\");\n    }\n    actualCallback = callback;\n    targetDataSource = dataSourceOrNameOrCallback;\n  }\n\n  // Try to get the data source if it's a string\n  let resolvedDataSource: DataSource | undefined;\n  if (typeof targetDataSource === \"string\") {\n    try {\n      resolvedDataSource =\n        targetDataSource === \"default\"\n          ? dataSourceRegistry.get()\n          : dataSourceRegistry.get(targetDataSource);\n    } catch {\n      // Data source not registered yet, will wait for event\n    }\n  } else {\n    resolvedDataSource = targetDataSource;\n  }\n\n  // If data source is resolved and already connected, fire immediately\n  if (resolvedDataSource && resolvedDataSource.driver.isConnected) {\n    actualCallback(resolvedDataSource);\n    return;\n  }\n\n  // Otherwise, wait for the connected event\n  const listener = (ds: DataSource) => {\n    const matches =\n      typeof targetDataSource === \"string\"\n        ? targetDataSource === \"default\"\n          ? ds.isDefault\n          : ds.name === targetDataSource\n        : ds === targetDataSource;\n\n    if (matches) {\n      // Remove the listener once our condition is met\n      dataSourceRegistry.off(\"connected\", listener);\n      actualCallback(ds);\n    }\n    // If it doesn't match, we do nothing and just wait for the next \"connected\" event targeting our DB\n  };\n\n  dataSourceRegistry.on(\"connected\", listener);\n}\n\n/**\n * Execute a callback once the driver is disconnected.\n *\n * If the driver is already disconnected, the callback is executed immediately.\n * Otherwise, it waits for the \"disconnected\" event.\n *\n * **Use Case:**\n * Useful for cleanup operations, graceful shutdown, or reconnection logic.\n *\n * @param dataSourceOrNameOrCallback - Data source instance, name, or callback function\n * @param callback - Function to execute once disconnected (optional if first param is callback)\n *\n * @example\n * ```typescript\n * // With default data source (just callback)\n * await connectToDatabase({ database: \"myapp\" });\n *\n * onceDisconnected((ds) => {\n *   console.log(\"Database disconnected!\");\n *   console.log(\"Attempting reconnection...\");\n * });\n * ```\n *\n * @example\n * ```typescript\n * // With data source name\n * onceDisconnected(\"primary\", (ds) => {\n *   console.log(\"Primary database disconnected!\");\n * });\n * ```\n *\n * @example\n * ```typescript\n * // With data source instance\n * const dataSource = await connectToDatabase({ database: \"myapp\" });\n *\n * onceDisconnected(dataSource, (ds) => {\n *   console.log(\"Database disconnected!\");\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Graceful shutdown with default data source\n * process.on(\"SIGTERM\", async () => {\n *   console.log(\"Shutting down...\");\n *\n *   onceDisconnected(() => {\n *     console.log(\"Database closed, exiting process\");\n *     process.exit(0);\n *   });\n *\n *   const dataSource = DataSourceRegistry.getDefault();\n *   await dataSource?.driver.disconnect();\n * });\n * ```\n *\n * @example\n * ```typescript\n * // Cleanup resources on disconnect\n * onceDisconnected(async (ds) => {\n *   // Close file handles\n *   await closeFileHandles();\n *\n *   // Clear caches\n *   clearCaches();\n *\n *   console.log(\"Cleanup complete\");\n * });\n * ```\n */\nexport function onceDisconnected(\n  dataSourceOrNameOrCallback: DataSource | string | ((dataSource: DataSource) => void),\n  callback?: (dataSource: DataSource) => void,\n): void {\n  // Determine if first parameter is a callback\n  let targetDataSource: DataSource | string;\n  let actualCallback: (dataSource: DataSource) => void;\n\n  if (typeof dataSourceOrNameOrCallback === \"function\") {\n    // First param is callback, use default data source\n    actualCallback = dataSourceOrNameOrCallback;\n    targetDataSource = \"default\";\n  } else {\n    // First param is data source name or instance\n    if (!callback) {\n      throw new Error(\"Callback is required when providing a data source name or instance.\");\n    }\n    actualCallback = callback;\n    targetDataSource = dataSourceOrNameOrCallback;\n  }\n\n  // Try to get the data source if it's a string\n  let resolvedDataSource: DataSource | undefined;\n  if (typeof targetDataSource === \"string\") {\n    try {\n      resolvedDataSource =\n        targetDataSource === \"default\"\n          ? dataSourceRegistry.get()\n          : dataSourceRegistry.get(targetDataSource);\n    } catch {\n      // Data source not registered yet, will wait for event\n    }\n  } else {\n    resolvedDataSource = targetDataSource;\n  }\n\n  // If data source is resolved and already disconnected, fire immediately\n  if (resolvedDataSource && !resolvedDataSource.driver.isConnected) {\n    actualCallback(resolvedDataSource);\n    return;\n  }\n\n  // Otherwise, wait for the disconnected event\n  const listener = (ds: DataSource) => {\n    const matches =\n      typeof targetDataSource === \"string\"\n        ? targetDataSource === \"default\"\n          ? ds.isDefault\n          : ds.name === targetDataSource\n        : ds === targetDataSource;\n\n    if (matches) {\n      actualCallback(ds);\n    } else {\n      // Not the one we're looking for, keep listening\n      dataSourceRegistry.once(\"disconnected\", listener);\n    }\n  };\n\n  dataSourceRegistry.once(\"disconnected\", listener);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0EA,SAAgB,cACd,4BACA,UACM;CAEN,IAAI;CACJ,IAAI;CAEJ,IAAI,OAAO,+BAA+B,YAAY;EAEpD,iBAAiB;EACjB,mBAAmB;CACrB,OAAO;EAEL,IAAI,CAAC,UACH,MAAM,IAAI,MAAM,qEAAqE;EAEvF,iBAAiB;EACjB,mBAAmB;CACrB;CAGA,IAAI;CACJ,IAAI,OAAO,qBAAqB,UAC9B,IAAI;EACF,qBACE,qBAAqB,YACjB,mBAAmB,IAAI,IACvB,mBAAmB,IAAI,gBAAgB;CAC/C,QAAQ,CAER;MAEA,qBAAqB;CAIvB,IAAI,sBAAsB,mBAAmB,OAAO,aAAa;EAC/D,eAAe,kBAAkB;EACjC;CACF;CAGA,MAAM,YAAY,OAAmB;EAQnC,IANE,OAAO,qBAAqB,WACxB,qBAAqB,YACnB,GAAG,YACH,GAAG,SAAS,mBACd,OAAO,kBAEA;GAEX,mBAAmB,IAAI,aAAa,QAAQ;GAC5C,eAAe,EAAE;EACnB;CAEF;CAEA,mBAAmB,GAAG,aAAa,QAAQ;AAC7C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyEA,SAAgB,iBACd,4BACA,UACM;CAEN,IAAI;CACJ,IAAI;CAEJ,IAAI,OAAO,+BAA+B,YAAY;EAEpD,iBAAiB;EACjB,mBAAmB;CACrB,OAAO;EAEL,IAAI,CAAC,UACH,MAAM,IAAI,MAAM,qEAAqE;EAEvF,iBAAiB;EACjB,mBAAmB;CACrB;CAGA,IAAI;CACJ,IAAI,OAAO,qBAAqB,UAC9B,IAAI;EACF,qBACE,qBAAqB,YACjB,mBAAmB,IAAI,IACvB,mBAAmB,IAAI,gBAAgB;CAC/C,QAAQ,CAER;MAEA,qBAAqB;CAIvB,IAAI,sBAAsB,CAAC,mBAAmB,OAAO,aAAa;EAChE,eAAe,kBAAkB;EACjC;CACF;CAGA,MAAM,YAAY,OAAmB;EAQnC,IANE,OAAO,qBAAqB,WACxB,qBAAqB,YACnB,GAAG,YACH,GAAG,SAAS,mBACd,OAAO,kBAGX,eAAe,EAAE;OAGjB,mBAAmB,KAAK,gBAAgB,QAAQ;CAEpD;CAEA,mBAAmB,KAAK,gBAAgB,QAAQ;AAClD"}

package/esm/validation/database-seal-plugins.d.mts

@@ -0,0 +1 @@
+export { };

package/esm/validation/database-seal-plugins.mjs

@@ -0,0 +1,11 @@
+import { databaseRulesPlugin } from "./plugins/database-rules-plugin.mjs";
+import { embedValidator } from "./plugins/embed-validator-plugin.mjs";
+import { registerPlugin } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/database-seal-plugins.ts
+registerPlugin(embedValidator);
+registerPlugin(databaseRulesPlugin);
+
+//#endregion
+export {  };
+//# sourceMappingURL=database-seal-plugins.mjs.map

package/esm/validation/database-seal-plugins.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-seal-plugins.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/validation/database-seal-plugins.ts"],"sourcesContent":["import { registerPlugin } from \"@warlock.js/seal\";\nimport { databaseRulesPlugin } from \"./plugins/database-rules-plugin\";\nimport { embedValidator } from \"./plugins/embed-validator-plugin\";\n\nregisterPlugin(embedValidator);\nregisterPlugin(databaseRulesPlugin);\n\n/**\n * This file registers database seal plugins as a side effect.\n * Import this file to ensure the plugins are registered.\n *\n * @example\n * ```ts\n * import \"./validation/database-seal-plugins\";\n * ```\n */\nexport type DatabaseSealPlugins = typeof embedValidator | typeof databaseRulesPlugin;\n"],"mappings":";;;;;AAIA,eAAe,cAAc;AAC7B,eAAe,mBAAmB"}

package/esm/validation/database-writer-validation-error.d.mts

@@ -0,0 +1,101 @@
+import { ValidationResult } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/database-writer-validation-error.d.ts
+/**
+ * Error thrown when model validation fails during database write operations.
+ *
+ * Contains detailed information about all validation errors,
+ * including field paths, error messages, and validation rules that failed.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const user = new User({ name: "", age: -5 });
+ *   await user.save();
+ * } catch (error) {
+ *   if (error instanceof DatabaseWriterValidationError) {
+ *     console.log(error.message); // "Validation failed"
+ *     console.log(error.errors);
+ *     // [
+ *     //   { path: "name", error: "name is required", rule: "required" },
+ *     //   { path: "age", error: "age must be at least 0", rule: "min" }
+ *     // ]
+ *   }
+ * }
+ * ```
+ */
+declare class DatabaseWriterValidationError extends Error {
+  /**
+   * Array of validation errors from @warlock.js/seal.
+   *
+   * Each error contains:
+   * - `path`: Dot-notation path to the field (e.g., "address.city")
+   * - `error`: Human-readable error message
+   * - `rule`: The validation rule that failed (e.g., "required", "email")
+   * - Additional context depending on the rule
+   */
+  readonly errors: ValidationResult["errors"];
+  /**
+   * Create a new DatabaseWriterValidationError.
+   *
+   * @param message - Error message (typically "Validation failed")
+   * @param errors - Array of validation errors from seal
+   *
+   * @example
+   * ```typescript
+   * const error = new DatabaseWriterValidationError("Validation failed", [
+   *   { path: "email", error: "email must be valid", rule: "email" }
+   * ]);
+   * ```
+   */
+  constructor(message: string, errors: ValidationResult["errors"]);
+  /**
+   * Get a formatted string representation of all validation errors.
+   *
+   * Provides beautiful, colored terminal output with clear field-by-field breakdown.
+   *
+   * @returns Multi-line string with all errors, formatted for terminal
+   *
+   * @example
+   * ```typescript
+   * console.log(error.toString());
+   * // ❌ Validation Error: UserModel
+   * //
+   * //   Field: email
+   * //   Error: Email already exists
+   * //   Value: "john@example.com"
+   * ```
+   */
+  toString(): string;
+  /**
+   * Get validation errors for a specific field.
+   *
+   * @param fieldPath - Dot-notation path to the field
+   * @returns Array of errors for that field
+   *
+   * @example
+   * ```typescript
+   * const emailErrors = error.getFieldErrors("email");
+   * console.log(emailErrors);
+   * // [{ path: "email", error: "email must be valid", rule: "email" }]
+   * ```
+   */
+  getFieldErrors(fieldPath: string): ValidationResult["errors"];
+  /**
+   * Check if a specific field has validation errors.
+   *
+   * @param fieldPath - Dot-notation path to the field
+   * @returns True if the field has errors
+   *
+   * @example
+   * ```typescript
+   * if (error.hasFieldError("email")) {
+   *   console.log("Email is invalid");
+   * }
+   * ```
+   */
+  hasFieldError(fieldPath: string): boolean;
+}
+//#endregion
+export { DatabaseWriterValidationError };
+//# sourceMappingURL=database-writer-validation-error.d.mts.map

package/esm/validation/database-writer-validation-error.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-writer-validation-error.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/validation/database-writer-validation-error.ts"],"mappings":";;;;;AA0BA;;;;;;;;;;;;;;;;;;;;;cAAa,6BAAA,SAAsC,KAAA;EAsJX;AAAA;;;;;;;;EAAA,SA5ItB,MAAA,EAAQ,gBAAA;;;;;;;;;;;;;;cAeL,OAAA,UAAiB,MAAA,EAAQ,gBAAA;;;;;;;;;;;;;;;;;;EA0CrC,QAAA,CAAA;;;;;;;;;;;;;;EAkEA,cAAA,CAAe,SAAA,WAAoB,gBAAA;;;;;;;;;;;;;;EAiBnC,aAAA,CAAc,SAAA;AAAA"}

package/esm/validation/database-writer-validation-error.mjs

@@ -0,0 +1,153 @@
+import { colors } from "@mongez/copper";
+
+//#region ../../@warlock.js/cascade/src/validation/database-writer-validation-error.ts
+/**
+* Error thrown when model validation fails during database write operations.
+*
+* Contains detailed information about all validation errors,
+* including field paths, error messages, and validation rules that failed.
+*
+* @example
+* ```typescript
+* try {
+*   const user = new User({ name: "", age: -5 });
+*   await user.save();
+* } catch (error) {
+*   if (error instanceof DatabaseWriterValidationError) {
+*     console.log(error.message); // "Validation failed"
+*     console.log(error.errors);
+*     // [
+*     //   { path: "name", error: "name is required", rule: "required" },
+*     //   { path: "age", error: "age must be at least 0", rule: "min" }
+*     // ]
+*   }
+* }
+* ```
+*/
+var DatabaseWriterValidationError = class DatabaseWriterValidationError extends Error {
+	/**
+	* Array of validation errors from @warlock.js/seal.
+	*
+	* Each error contains:
+	* - `path`: Dot-notation path to the field (e.g., "address.city")
+	* - `error`: Human-readable error message
+	* - `rule`: The validation rule that failed (e.g., "required", "email")
+	* - Additional context depending on the rule
+	*/
+	errors;
+	/**
+	* Create a new DatabaseWriterValidationError.
+	*
+	* @param message - Error message (typically "Validation failed")
+	* @param errors - Array of validation errors from seal
+	*
+	* @example
+	* ```typescript
+	* const error = new DatabaseWriterValidationError("Validation failed", [
+	*   { path: "email", error: "email must be valid", rule: "email" }
+	* ]);
+	* ```
+	*/
+	constructor(message, errors) {
+		super(message);
+		this.name = "DatabaseWriterValidationError";
+		this.errors = errors;
+		if (Error.captureStackTrace) Error.captureStackTrace(this, DatabaseWriterValidationError);
+		Object.defineProperty(this, "inspect", {
+			value: () => this.toString(),
+			enumerable: false
+		});
+	}
+	/**
+	* Custom inspect method for Node.js console output.
+	* This makes console.log and error logging use our beautiful format.
+	*/
+	[Symbol.for("nodejs.util.inspect.custom")]() {
+		return this.toString();
+	}
+	/**
+	* Get a formatted string representation of all validation errors.
+	*
+	* Provides beautiful, colored terminal output with clear field-by-field breakdown.
+	*
+	* @returns Multi-line string with all errors, formatted for terminal
+	*
+	* @example
+	* ```typescript
+	* console.log(error.toString());
+	* // ❌ Validation Error: UserModel
+	* //
+	* //   Field: email
+	* //   Error: Email already exists
+	* //   Value: "john@example.com"
+	* ```
+	*/
+	toString() {
+		const modelMatch = this.message.match(/\[(\w+)\s+Model\]/);
+		const modelName = modelMatch ? modelMatch[1] : "Model";
+		const operation = this.message.includes("Insert") ? "Insert" : "Update";
+		const lines = [];
+		lines.push("");
+		lines.push(colors.red(`❌ Validation Error: ${modelName} (${operation})`));
+		lines.push("");
+		const errorsByField = /* @__PURE__ */ new Map();
+		for (const err of this.errors) {
+			const fieldName = err.input || "unknown";
+			if (!errorsByField.has(fieldName)) errorsByField.set(fieldName, []);
+			errorsByField.get(fieldName).push({
+				error: err.error,
+				type: err.type,
+				value: err.value
+			});
+		}
+		for (const [fieldName, fieldErrors] of errorsByField) {
+			lines.push(colors.yellow(`  Field: ${fieldName}`));
+			for (const fieldError of fieldErrors) {
+				lines.push(colors.white(`  Error: ${fieldError.error}`));
+				if (fieldError.value !== void 0) {
+					const valueStr = typeof fieldError.value === "string" ? `"${fieldError.value}"` : JSON.stringify(fieldError.value);
+					lines.push(colors.gray(`  Value: ${valueStr}`));
+				}
+				if (fieldError.type) lines.push(colors.cyan(`  Type:  ${fieldError.type}`));
+			}
+			lines.push("");
+		}
+		return lines.join("\n");
+	}
+	/**
+	* Get validation errors for a specific field.
+	*
+	* @param fieldPath - Dot-notation path to the field
+	* @returns Array of errors for that field
+	*
+	* @example
+	* ```typescript
+	* const emailErrors = error.getFieldErrors("email");
+	* console.log(emailErrors);
+	* // [{ path: "email", error: "email must be valid", rule: "email" }]
+	* ```
+	*/
+	getFieldErrors(fieldPath) {
+		return this.errors.filter((err) => err.input === fieldPath);
+	}
+	/**
+	* Check if a specific field has validation errors.
+	*
+	* @param fieldPath - Dot-notation path to the field
+	* @returns True if the field has errors
+	*
+	* @example
+	* ```typescript
+	* if (error.hasFieldError("email")) {
+	*   console.log("Email is invalid");
+	* }
+	* ```
+	*/
+	hasFieldError(fieldPath) {
+		return this.errors.some((err) => err.input === fieldPath);
+	}
+};
+
+//#endregion
+export { DatabaseWriterValidationError };
+//# sourceMappingURL=database-writer-validation-error.mjs.map

package/esm/validation/database-writer-validation-error.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-writer-validation-error.mjs","names":[],"sources":["../../../../../../@warlock.js/cascade/src/validation/database-writer-validation-error.ts"],"sourcesContent":["import { colors } from \"@mongez/copper\";\nimport type { ValidationResult } from \"@warlock.js/seal\";\n\n/**\n * Error thrown when model validation fails during database write operations.\n *\n * Contains detailed information about all validation errors,\n * including field paths, error messages, and validation rules that failed.\n *\n * @example\n * ```typescript\n * try {\n *   const user = new User({ name: \"\", age: -5 });\n *   await user.save();\n * } catch (error) {\n *   if (error instanceof DatabaseWriterValidationError) {\n *     console.log(error.message); // \"Validation failed\"\n *     console.log(error.errors);\n *     // [\n *     //   { path: \"name\", error: \"name is required\", rule: \"required\" },\n *     //   { path: \"age\", error: \"age must be at least 0\", rule: \"min\" }\n *     // ]\n *   }\n * }\n * ```\n */\nexport class DatabaseWriterValidationError extends Error {\n  /**\n   * Array of validation errors from @warlock.js/seal.\n   *\n   * Each error contains:\n   * - `path`: Dot-notation path to the field (e.g., \"address.city\")\n   * - `error`: Human-readable error message\n   * - `rule`: The validation rule that failed (e.g., \"required\", \"email\")\n   * - Additional context depending on the rule\n   */\n  public readonly errors: ValidationResult[\"errors\"];\n\n  /**\n   * Create a new DatabaseWriterValidationError.\n   *\n   * @param message - Error message (typically \"Validation failed\")\n   * @param errors - Array of validation errors from seal\n   *\n   * @example\n   * ```typescript\n   * const error = new DatabaseWriterValidationError(\"Validation failed\", [\n   *   { path: \"email\", error: \"email must be valid\", rule: \"email\" }\n   * ]);\n   * ```\n   */\n  public constructor(message: string, errors: ValidationResult[\"errors\"]) {\n    super(message);\n    this.name = \"DatabaseWriterValidationError\";\n    this.errors = errors;\n\n    // Maintain proper stack trace for where error was thrown (V8 only)\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, DatabaseWriterValidationError);\n    }\n\n    // Override Node.js inspect to use our formatted output\n    Object.defineProperty(this, \"inspect\", {\n      value: () => this.toString(),\n      enumerable: false,\n    });\n  }\n\n  /**\n   * Custom inspect method for Node.js console output.\n   * This makes console.log and error logging use our beautiful format.\n   */\n  [Symbol.for(\"nodejs.util.inspect.custom\")](): string {\n    return this.toString();\n  }\n\n  /**\n   * Get a formatted string representation of all validation errors.\n   *\n   * Provides beautiful, colored terminal output with clear field-by-field breakdown.\n   *\n   * @returns Multi-line string with all errors, formatted for terminal\n   *\n   * @example\n   * ```typescript\n   * console.log(error.toString());\n   * // ❌ Validation Error: UserModel\n   * //\n   * //   Field: email\n   * //   Error: Email already exists\n   * //   Value: \"john@example.com\"\n   * ```\n   */\n  public toString(): string {\n    // Extract model name from message (e.g., \"[UserModel Model]\")\n    const modelMatch = this.message.match(/\\[(\\w+)\\s+Model\\]/);\n    const modelName = modelMatch ? modelMatch[1] : \"Model\";\n    const operation = this.message.includes(\"Insert\") ? \"Insert\" : \"Update\";\n\n    // Build header\n    const lines: string[] = [];\n    lines.push(\"\");\n    lines.push(colors.red(`❌ Validation Error: ${modelName} (${operation})`));\n    lines.push(\"\");\n\n    // Group errors by field for better readability\n    const errorsByField = new Map<string, Array<{ error: string; type?: string; value?: any }>>();\n\n    for (const err of this.errors) {\n      const fieldName = err.input || \"unknown\";\n      if (!errorsByField.has(fieldName)) {\n        errorsByField.set(fieldName, []);\n      }\n      errorsByField.get(fieldName)!.push({\n        error: err.error,\n        type: err.type,\n        value: (err as any).value,\n      });\n    }\n\n    // Format each field's errors\n    for (const [fieldName, fieldErrors] of errorsByField) {\n      lines.push(colors.yellow(`  Field: ${fieldName}`));\n\n      for (const fieldError of fieldErrors) {\n        lines.push(colors.white(`  Error: ${fieldError.error}`));\n\n        if (fieldError.value !== undefined) {\n          const valueStr =\n            typeof fieldError.value === \"string\"\n              ? `\"${fieldError.value}\"`\n              : JSON.stringify(fieldError.value);\n          lines.push(colors.gray(`  Value: ${valueStr}`));\n        }\n\n        if (fieldError.type) {\n          lines.push(colors.cyan(`  Type:  ${fieldError.type}`));\n        }\n      }\n\n      lines.push(\"\"); // Blank line between fields\n    }\n\n    return lines.join(\"\\n\");\n  }\n\n  /**\n   * Get validation errors for a specific field.\n   *\n   * @param fieldPath - Dot-notation path to the field\n   * @returns Array of errors for that field\n   *\n   * @example\n   * ```typescript\n   * const emailErrors = error.getFieldErrors(\"email\");\n   * console.log(emailErrors);\n   * // [{ path: \"email\", error: \"email must be valid\", rule: \"email\" }]\n   * ```\n   */\n  public getFieldErrors(fieldPath: string): ValidationResult[\"errors\"] {\n    return this.errors.filter((err) => err.input === fieldPath);\n  }\n\n  /**\n   * Check if a specific field has validation errors.\n   *\n   * @param fieldPath - Dot-notation path to the field\n   * @returns True if the field has errors\n   *\n   * @example\n   * ```typescript\n   * if (error.hasFieldError(\"email\")) {\n   *   console.log(\"Email is invalid\");\n   * }\n   * ```\n   */\n  public hasFieldError(fieldPath: string): boolean {\n    return this.errors.some((err) => err.input === fieldPath);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;AA0BA,IAAa,gCAAb,MAAa,sCAAsC,MAAM;;;;;;;;;;CAUvD,AAAgB;;;;;;;;;;;;;;CAehB,AAAO,YAAY,SAAiB,QAAoC;EACtE,MAAM,OAAO;EACb,KAAK,OAAO;EACZ,KAAK,SAAS;EAGd,IAAI,MAAM,mBACR,MAAM,kBAAkB,MAAM,6BAA6B;EAI7D,OAAO,eAAe,MAAM,WAAW;GACrC,aAAa,KAAK,SAAS;GAC3B,YAAY;EACd,CAAC;CACH;;;;;CAMA,CAAC,OAAO,IAAI,4BAA4B,KAAa;EACnD,OAAO,KAAK,SAAS;CACvB;;;;;;;;;;;;;;;;;;CAmBA,AAAO,WAAmB;EAExB,MAAM,aAAa,KAAK,QAAQ,MAAM,mBAAmB;EACzD,MAAM,YAAY,aAAa,WAAW,KAAK;EAC/C,MAAM,YAAY,KAAK,QAAQ,SAAS,QAAQ,IAAI,WAAW;EAG/D,MAAM,QAAkB,CAAC;EACzB,MAAM,KAAK,EAAE;EACb,MAAM,KAAK,OAAO,IAAI,uBAAuB,UAAU,IAAI,UAAU,EAAE,CAAC;EACxE,MAAM,KAAK,EAAE;EAGb,MAAM,gCAAgB,IAAI,IAAkE;EAE5F,KAAK,MAAM,OAAO,KAAK,QAAQ;GAC7B,MAAM,YAAY,IAAI,SAAS;GAC/B,IAAI,CAAC,cAAc,IAAI,SAAS,GAC9B,cAAc,IAAI,WAAW,CAAC,CAAC;GAEjC,cAAc,IAAI,SAAS,EAAG,KAAK;IACjC,OAAO,IAAI;IACX,MAAM,IAAI;IACV,OAAQ,IAAY;GACtB,CAAC;EACH;EAGA,KAAK,MAAM,CAAC,WAAW,gBAAgB,eAAe;GACpD,MAAM,KAAK,OAAO,OAAO,YAAY,WAAW,CAAC;GAEjD,KAAK,MAAM,cAAc,aAAa;IACpC,MAAM,KAAK,OAAO,MAAM,YAAY,WAAW,OAAO,CAAC;IAEvD,IAAI,WAAW,UAAU,QAAW;KAClC,MAAM,WACJ,OAAO,WAAW,UAAU,WACxB,IAAI,WAAW,MAAM,KACrB,KAAK,UAAU,WAAW,KAAK;KACrC,MAAM,KAAK,OAAO,KAAK,YAAY,UAAU,CAAC;IAChD;IAEA,IAAI,WAAW,MACb,MAAM,KAAK,OAAO,KAAK,YAAY,WAAW,MAAM,CAAC;GAEzD;GAEA,MAAM,KAAK,EAAE;EACf;EAEA,OAAO,MAAM,KAAK,IAAI;CACxB;;;;;;;;;;;;;;CAeA,AAAO,eAAe,WAA+C;EACnE,OAAO,KAAK,OAAO,QAAQ,QAAQ,IAAI,UAAU,SAAS;CAC5D;;;;;;;;;;;;;;CAeA,AAAO,cAAc,WAA4B;EAC/C,OAAO,KAAK,OAAO,MAAM,QAAQ,IAAI,UAAU,SAAS;CAC1D;AACF"}

package/esm/validation/index.d.mts

@@ -0,0 +1,2 @@
+import { DatabaseWriterValidationError } from "./database-writer-validation-error.mjs";
+import { BaseQueryRuleOptions, BaseUniqueRuleOptions, ExistsRuleOptions, UniqueRuleOptions } from "./types.mjs";

package/esm/validation/index.mjs

@@ -0,0 +1,4 @@
+import { DatabaseWriterValidationError } from "./database-writer-validation-error.mjs";
+import "./database-seal-plugins.mjs";
+
+export {  };

package/esm/validation/mutators/embed-mutator.mjs

@@ -0,0 +1,26 @@
+import { getModelFromRegistry } from "../../model/register-model.mjs";
+import { Model } from "../../model/model.mjs";
+
+//#region ../../@warlock.js/cascade/src/validation/mutators/embed-mutator.ts
+const databaseModelMutator = async (value, context) => {
+	let { model: ModelClass } = context?.options || {};
+	if (typeof ModelClass === "string") ModelClass = getModelFromRegistry(ModelClass);
+	if (!ModelClass) throw new Error(`Model ${ModelClass} not found in registry`);
+	if (value instanceof Model) return value;
+	if (typeof value === "object" && value?.id) value = Number(value.id);
+	if (typeof value !== "number") return value;
+	return await ModelClass.find(value);
+};
+const databaseModelsMutator = async (value, context) => {
+	if (!Array.isArray(value)) return value;
+	let { model: ModelClass } = context?.options || {};
+	if (typeof ModelClass === "string") ModelClass = getModelFromRegistry(ModelClass);
+	if (!ModelClass) throw new Error(`Model ${ModelClass} not found in registry`);
+	if (value.every((item) => item instanceof Model)) return value;
+	const ids = value.map((item) => item?.id || item).filter((item) => item !== void 0);
+	return await ModelClass.query().whereIn("id", ids).get();
+};
+
+//#endregion
+export { databaseModelMutator, databaseModelsMutator };
+//# sourceMappingURL=embed-mutator.mjs.map

package/esm/validation/mutators/embed-mutator.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed-mutator.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/validation/mutators/embed-mutator.ts"],"sourcesContent":["import type { Mutator } from \"@warlock.js/seal\";\nimport { ChildModel, Model } from \"../../model/model\";\nimport { getModelFromRegistry } from \"../../model/register-model\";\n\ntype DatabaseModelMutatorOptions = {\n  model: ChildModel<any> | string;\n};\n\nexport const databaseModelMutator: Mutator<DatabaseModelMutatorOptions> = async (\n  value,\n  context,\n) => {\n  let { model: ModelClass } = context?.options || {};\n\n  if (typeof ModelClass === \"string\") {\n    ModelClass = getModelFromRegistry(ModelClass)!;\n  }\n\n  if (!ModelClass) {\n    throw new Error(`Model ${ModelClass} not found in registry`);\n  }\n\n  if (value instanceof Model) return value;\n\n  if (typeof value === \"object\" && value?.id) {\n    value = Number(value.id);\n  }\n\n  if (typeof value !== \"number\") return value;\n\n  return await ModelClass.find(value);\n};\n\nexport const databaseModelsMutator: Mutator<DatabaseModelMutatorOptions> = async (\n  value,\n  context,\n) => {\n  if (!Array.isArray(value)) return value;\n\n  let { model: ModelClass } = context?.options || {};\n\n  if (typeof ModelClass === \"string\") {\n    ModelClass = getModelFromRegistry(ModelClass)!;\n  }\n\n  if (!ModelClass) {\n    throw new Error(`Model ${ModelClass} not found in registry`);\n  }\n\n  // first, if all values are list of models, then return them.\n  if (value.every((item) => item instanceof Model)) return value;\n\n  const ids = value.map((item) => item?.id || item).filter((item) => item !== undefined);\n\n  return await ModelClass.query().whereIn(\"id\", ids).get();\n};\n"],"mappings":";;;;AAQA,MAAa,uBAA6D,OACxE,OACA,YACG;CACH,IAAI,EAAE,OAAO,eAAe,SAAS,WAAW,CAAC;CAEjD,IAAI,OAAO,eAAe,UACxB,aAAa,qBAAqB,UAAU;CAG9C,IAAI,CAAC,YACH,MAAM,IAAI,MAAM,SAAS,WAAW,uBAAuB;CAG7D,IAAI,iBAAiB,OAAO,OAAO;CAEnC,IAAI,OAAO,UAAU,YAAY,OAAO,IACtC,QAAQ,OAAO,MAAM,EAAE;CAGzB,IAAI,OAAO,UAAU,UAAU,OAAO;CAEtC,OAAO,MAAM,WAAW,KAAK,KAAK;AACpC;AAEA,MAAa,wBAA8D,OACzE,OACA,YACG;CACH,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;CAElC,IAAI,EAAE,OAAO,eAAe,SAAS,WAAW,CAAC;CAEjD,IAAI,OAAO,eAAe,UACxB,aAAa,qBAAqB,UAAU;CAG9C,IAAI,CAAC,YACH,MAAM,IAAI,MAAM,SAAS,WAAW,uBAAuB;CAI7D,IAAI,MAAM,OAAO,SAAS,gBAAgB,KAAK,GAAG,OAAO;CAEzD,MAAM,MAAM,MAAM,KAAK,SAAS,MAAM,MAAM,IAAI,EAAE,QAAQ,SAAS,SAAS,MAAS;CAErF,OAAO,MAAM,WAAW,MAAM,EAAE,QAAQ,MAAM,GAAG,EAAE,IAAI;AACzD"}

package/esm/validation/plugins/database-rules-plugin.d.mts

@@ -0,0 +1,28 @@
+import { ChildModel } from "../../model/model.types.mjs";
+import { Model } from "../../model/model.mjs";
+import { ExistsRuleOptions, UniqueRuleOptions } from "../types.mjs";
+//#region ../../@warlock.js/cascade/src/validation/plugins/database-rules-plugin.d.ts
+declare module "@warlock.js/seal" {
+  interface ScalarValidator {
+    /** Value must be unique in database */
+    unique(model: ChildModel<Model> | string, optionsList?: Partial<UniqueRuleOptions> & {
+      errorMessage?: string;
+    }): this;
+    /** Value must exist in database */
+    exists(model: ChildModel<Model> | string, optionsList?: Partial<ExistsRuleOptions> & {
+      errorMessage?: string;
+    }): this;
+  }
+  interface StringValidator {
+    unique: ScalarValidator["unique"];
+    exists: ScalarValidator["exists"];
+  }
+  interface NumberValidator {
+    unique: ScalarValidator["unique"];
+    exists: ScalarValidator["exists"];
+  }
+}
+/**
+ * Cascade's database-rules plugin for Seal.
+ */
+//# sourceMappingURL=database-rules-plugin.d.mts.map

package/esm/validation/plugins/database-rules-plugin.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-rules-plugin.d.mts","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/validation/plugins/database-rules-plugin.ts"],"mappings":";;;;;YAmBY,eAAA;IAYgB;IAVxB,MAAA,CACE,KAAA,EAAO,UAAA,CAAW,KAAA,YAClB,WAAA,GAAc,OAAA,CAAQ,iBAAA;MACpB,YAAA;IAAA;IAmBI;IAdR,MAAA,CACE,KAAA,EAAO,UAAA,CAAW,KAAA,YAClB,WAAA,GAAc,OAAA,CAAQ,iBAAA;MACpB,YAAA;IAAA;EAAA;EAAA,UAKI,eAAA;IACR,MAAA,EAAQ,eAAA;IACR,MAAA,EAAQ,eAAA;EAAA;EAAA,UAGA,eAAA;IACR,MAAA,EAAQ,eAAA;IACR,MAAA,EAAQ,eAAA;EAAA;AAAA"}

package/esm/validation/plugins/database-rules-plugin.mjs

@@ -0,0 +1,43 @@
+import { existsRule } from "../rules/exists-rule.mjs";
+import { uniqueRule } from "../rules/unique-rule.mjs";
+import { NumberValidator, ScalarValidator, StringValidator } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/plugins/database-rules-plugin.ts
+/**
+* Cascade's database-rules plugin for Seal.
+*/
+const databaseRulesPlugin = {
+	name: "cascade-database-rules",
+	version: "1.0.0",
+	description: "Adds unique() and exists() database validation methods to Seal scalar validators",
+	install() {
+		Object.assign(ScalarValidator.prototype, {
+			unique(model, optionsList) {
+				const { errorMessage, ...options } = optionsList || {};
+				return this.addRule(uniqueRule, errorMessage, {
+					Model: model,
+					...options
+				});
+			},
+			exists(model, optionsList) {
+				const { errorMessage, ...options } = optionsList || {};
+				return this.addRule(existsRule, errorMessage, {
+					Model: model,
+					...options
+				});
+			}
+		});
+		Object.assign(StringValidator.prototype, {
+			unique: ScalarValidator.prototype.unique,
+			exists: ScalarValidator.prototype.exists
+		});
+		Object.assign(NumberValidator.prototype, {
+			unique: ScalarValidator.prototype.unique,
+			exists: ScalarValidator.prototype.exists
+		});
+	}
+};
+
+//#endregion
+export { databaseRulesPlugin };
+//# sourceMappingURL=database-rules-plugin.mjs.map

package/esm/validation/plugins/database-rules-plugin.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"database-rules-plugin.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/validation/plugins/database-rules-plugin.ts"],"sourcesContent":["/**\n * Database Rules Plugin\n *\n * Injects the `.unique()` and `.exists()` method-chain entries onto Seal's\n * scalar validators. These are the Cascade-owned, DB-aware validation rules.\n *\n * Request-aware variants (`uniqueExceptCurrentUser`, etc.) live in\n * `@warlock.js/core` because they depend on the HTTP request store, which\n * Cascade has no business knowing about.\n */\n\nimport type { SealPlugin } from \"@warlock.js/seal\";\nimport { NumberValidator, ScalarValidator, StringValidator } from \"@warlock.js/seal\";\nimport type { ChildModel, Model } from \"../../model/model\";\nimport { existsRule } from \"../rules/exists-rule\";\nimport { uniqueRule } from \"../rules/unique-rule\";\nimport type { ExistsRuleOptions, UniqueRuleOptions } from \"../types\";\n\ndeclare module \"@warlock.js/seal\" {\n  interface ScalarValidator {\n    /** Value must be unique in database */\n    unique(\n      model: ChildModel<Model> | string,\n      optionsList?: Partial<UniqueRuleOptions> & {\n        errorMessage?: string;\n      },\n    ): this;\n\n    /** Value must exist in database */\n    exists(\n      model: ChildModel<Model> | string,\n      optionsList?: Partial<ExistsRuleOptions> & {\n        errorMessage?: string;\n      },\n    ): this;\n  }\n\n  interface StringValidator {\n    unique: ScalarValidator[\"unique\"];\n    exists: ScalarValidator[\"exists\"];\n  }\n\n  interface NumberValidator {\n    unique: ScalarValidator[\"unique\"];\n    exists: ScalarValidator[\"exists\"];\n  }\n}\n\n/**\n * Cascade's database-rules plugin for Seal.\n */\nexport const databaseRulesPlugin: SealPlugin = {\n  name: \"cascade-database-rules\",\n  version: \"1.0.0\",\n  description: \"Adds unique() and exists() database validation methods to Seal scalar validators\",\n\n  install() {\n    Object.assign(ScalarValidator.prototype, {\n      unique(\n        this: ScalarValidator,\n        model: ChildModel<Model> | string,\n        optionsList?: Partial<UniqueRuleOptions> & {\n          errorMessage?: string;\n        },\n      ) {\n        const { errorMessage, ...options } = optionsList || {};\n\n        return this.addRule(uniqueRule, errorMessage, {\n          Model: model,\n          ...options,\n        });\n      },\n\n      exists(\n        this: ScalarValidator,\n        model: ChildModel<Model> | string,\n        optionsList?: Partial<ExistsRuleOptions> & {\n          errorMessage?: string;\n        },\n      ) {\n        const { errorMessage, ...options } = optionsList || {};\n\n        return this.addRule(existsRule, errorMessage, {\n          Model: model,\n          ...options,\n        });\n      },\n    });\n\n    Object.assign(StringValidator.prototype, {\n      unique: ScalarValidator.prototype.unique,\n      exists: ScalarValidator.prototype.exists,\n    });\n\n    Object.assign(NumberValidator.prototype, {\n      unique: ScalarValidator.prototype.unique,\n      exists: ScalarValidator.prototype.exists,\n    });\n  },\n};\n"],"mappings":";;;;;;;;AAmDA,MAAa,sBAAkC;CAC7C,MAAM;CACN,SAAS;CACT,aAAa;CAEb,UAAU;EACR,OAAO,OAAO,gBAAgB,WAAW;GACvC,OAEE,OACA,aAGA;IACA,MAAM,EAAE,cAAc,GAAG,YAAY,eAAe,CAAC;IAErD,OAAO,KAAK,QAAQ,YAAY,cAAc;KAC5C,OAAO;KACP,GAAG;IACL,CAAC;GACH;GAEA,OAEE,OACA,aAGA;IACA,MAAM,EAAE,cAAc,GAAG,YAAY,eAAe,CAAC;IAErD,OAAO,KAAK,QAAQ,YAAY,cAAc;KAC5C,OAAO;KACP,GAAG;IACL,CAAC;GACH;EACF,CAAC;EAED,OAAO,OAAO,gBAAgB,WAAW;GACvC,QAAQ,gBAAgB,UAAU;GAClC,QAAQ,gBAAgB,UAAU;EACpC,CAAC;EAED,OAAO,OAAO,gBAAgB,WAAW;GACvC,QAAQ,gBAAgB,UAAU;GAClC,QAAQ,gBAAgB,UAAU;EACpC,CAAC;CACH;AACF"}