@warlock.js/cascade 5.19.1 → 5.21.0

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

@@ -1 +1 @@
-{"version":3,"file":"once-connected.mjs","names":[],"sources":["../../../../../../../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"}
+{"version":3,"file":"once-connected.mjs","names":[],"sources":["../../../../../../../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 * Whether the given source is the registry's actual default (not just the `isDefault` option flag).\n */\nfunction isRegistryDefault(ds: DataSource): boolean {\n  try {\n    return dataSourceRegistry.get() === ds;\n  } catch {\n    return false;\n  }\n}\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          ? isRegistryDefault(ds)\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          ? isRegistryDefault(ds)\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":";;;;;;AAMA,SAAS,kBAAkB,IAAyB;CAClD,IAAI;EACF,OAAO,mBAAmB,IAAI,MAAM;CACtC,QAAQ;EACN,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyEA,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,kBAAkB,EAAE,IACpB,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,kBAAkB,EAAE,IACpB,GAAG,SAAS,mBACd,OAAO,kBAGX,eAAe,EAAE;OAGjB,mBAAmB,KAAK,gBAAgB,QAAQ;CAEpD;CAEA,mBAAmB,KAAK,gBAAgB,QAAQ;AAClD"}

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

@@ -1,24 +1,32 @@
-import { getModelFromRegistry } from "../../model/register-model.mjs";
+import { requireModelClass } from "../../model/register-model.mjs";
 import { Model } from "../../model/model.mjs";
 
 //#region ../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`);
+	const { model } = context?.options || {};
+	if (!model) throw new Error("Model option is required");
+	const ModelClass = requireModelClass(model);
 	if (value instanceof Model) return value;
-	if (typeof value === "object" && value?.id) value = Number(value.id);
-	if (typeof value !== "number") return value;
+	if (value && typeof value === "object") {
+		const key = ModelClass.primaryKey || "id";
+		value = value[key] ?? value.id;
+	}
+	if (typeof value !== "number" && typeof value !== "string") return value;
+	if (value === "") 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`);
+	const { model } = context?.options || {};
+	if (!model) throw new Error("Model option is required");
+	const ModelClass = requireModelClass(model);
 	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();
+	const key = ModelClass.primaryKey || "id";
+	const ids = value.map((item) => item && typeof item === "object" ? item[key] ?? item.id : item).filter((item) => item !== void 0 && item !== null);
+	const uniqueIds = [...new Set(ids)];
+	const found = await ModelClass.query().whereIn(key, uniqueIds).get();
+	if (found.length !== uniqueIds.length) return value;
+	return found;
 };
 
 //#endregion

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

@@ -1 +1 @@
-{"version":3,"file":"embed-mutator.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/mutators/embed-mutator.ts"],"sourcesContent":["import type { Mutator } from \"@warlock.js/seal\";\nimport { type 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,CAAC,CAAC,QAAQ,SAAS,SAAS,MAAS;CAErF,OAAO,MAAM,WAAW,MAAM,CAAC,CAAC,QAAQ,MAAM,GAAG,CAAC,CAAC,IAAI;AACzD"}
+{"version":3,"file":"embed-mutator.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/mutators/embed-mutator.ts"],"sourcesContent":["import type { Mutator } from \"@warlock.js/seal\";\nimport { type ChildModel, Model } from \"../../model/model\";\nimport { requireModelClass } 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  const { model } = context?.options || {};\n\n  if (!model) {\n    throw new Error(\"Model option is required\");\n  }\n\n  const ModelClass = requireModelClass(model);\n\n  if (value instanceof Model) return value;\n\n  if (value && typeof value === \"object\") {\n    const key = ModelClass.primaryKey || \"id\";\n    value = value[key] ?? value.id;\n  }\n\n  if (typeof value !== \"number\" && typeof value !== \"string\") return value;\n\n  if (value === \"\") 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  const { model } = context?.options || {};\n\n  if (!model) {\n    throw new Error(\"Model option is required\");\n  }\n\n  const ModelClass = requireModelClass(model);\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 key = ModelClass.primaryKey || \"id\";\n\n  const ids = value\n    .map((item) => (item && typeof item === \"object\" ? (item[key] ?? item.id) : item))\n    .filter((item) => item !== undefined && item !== null);\n\n  const uniqueIds = [...new Set(ids)];\n\n  const found = await ModelClass.query().whereIn(key, uniqueIds).get();\n\n  // a missing id must fail validation instead of being silently dropped;\n  // returning the raw value makes the models rule reject it\n  if (found.length !== uniqueIds.length) return value;\n\n  return found;\n};\n"],"mappings":";;;;AAQA,MAAa,uBAA6D,OACxE,OACA,YACG;CACH,MAAM,EAAE,UAAU,SAAS,WAAW,CAAC;CAEvC,IAAI,CAAC,OACH,MAAM,IAAI,MAAM,0BAA0B;CAG5C,MAAM,aAAa,kBAAkB,KAAK;CAE1C,IAAI,iBAAiB,OAAO,OAAO;CAEnC,IAAI,SAAS,OAAO,UAAU,UAAU;EACtC,MAAM,MAAM,WAAW,cAAc;EACrC,QAAQ,MAAM,QAAQ,MAAM;CAC9B;CAEA,IAAI,OAAO,UAAU,YAAY,OAAO,UAAU,UAAU,OAAO;CAEnE,IAAI,UAAU,IAAI,OAAO;CAEzB,OAAO,MAAM,WAAW,KAAK,KAAK;AACpC;AAEA,MAAa,wBAA8D,OACzE,OACA,YACG;CACH,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO;CAElC,MAAM,EAAE,UAAU,SAAS,WAAW,CAAC;CAEvC,IAAI,CAAC,OACH,MAAM,IAAI,MAAM,0BAA0B;CAG5C,MAAM,aAAa,kBAAkB,KAAK;CAG1C,IAAI,MAAM,OAAO,SAAS,gBAAgB,KAAK,GAAG,OAAO;CAEzD,MAAM,MAAM,WAAW,cAAc;CAErC,MAAM,MAAM,MACT,KAAK,SAAU,QAAQ,OAAO,SAAS,WAAY,KAAK,QAAQ,KAAK,KAAM,IAAK,CAAC,CACjF,QAAQ,SAAS,SAAS,UAAa,SAAS,IAAI;CAEvD,MAAM,YAAY,CAAC,GAAG,IAAI,IAAI,GAAG,CAAC;CAElC,MAAM,QAAQ,MAAM,WAAW,MAAM,CAAC,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,IAAI;CAInE,IAAI,MAAM,WAAW,UAAU,QAAQ,OAAO;CAE9C,OAAO;AACT"}

package/esm/validation/plugins/embed-validator-plugin.d.mts

@@ -7,8 +7,8 @@ type EmbedOptions = {
 };
 declare module "@warlock.js/seal" {
   interface ValidatorV {
-    embed(model: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;
-    embedMany(model: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;
+    embed(model?: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;
+    embedMany(model?: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;
   }
 }
 /**

package/esm/validation/plugins/embed-validator-plugin.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"embed-validator-plugin.d.mts","names":[],"sources":["../../../../../../../../cascade/src/validation/plugins/embed-validator-plugin.ts"],"mappings":";;;KAWK,YAAA;EACH,YAAA;EACA,KAAK;AAAA;AAAA;EAAA,UAIK,UAAA;IACR,KAAA,CAAM,KAAA,EAAO,UAAA,gBAA0B,OAAA,GAAU,YAAA,GAAe,mBAAA;IAChE,SAAA,CAAU,KAAA,EAAO,UAAA,gBAA0B,OAAA,GAAU,YAAA,GAAe,mBAAA;EAAA;AAAA"}
+{"version":3,"file":"embed-validator-plugin.d.mts","names":[],"sources":["../../../../../../../../cascade/src/validation/plugins/embed-validator-plugin.ts"],"mappings":";;;KAWK,YAAA;EACH,YAAA;EACA,KAAK;AAAA;AAAA;EAAA,UAIK,UAAA;IACR,KAAA,CAAM,KAAA,GAAQ,UAAA,gBAA0B,OAAA,GAAU,YAAA,GAAe,mBAAA;IACjE,SAAA,CAAU,KAAA,GAAQ,UAAA,gBAA0B,OAAA,GAAU,YAAA,GAAe,mBAAA;EAAA;AAAA"}

package/esm/validation/plugins/embed-validator-plugin.mjs

@@ -10,8 +10,14 @@ const embedValidator = {
 	version: "1.0.0",
 	description: "Adds embed validation (v.embed())",
 	install() {
-		v.embed = (model, options) => new EmbedModelValidator().model(model).embed(options?.embed);
-		v.embedMany = (model, options) => new EmbedModelValidator().models(model).embed(options?.embed);
+		v.embed = (model, options) => {
+			const validator = new EmbedModelValidator();
+			return (model ? validator.model(model, options?.errorMessage) : validator).embed(options?.embed);
+		};
+		v.embedMany = (model, options) => {
+			const validator = new EmbedModelValidator();
+			return (model ? validator.models(model, options?.errorMessage) : validator).embed(options?.embed);
+		};
 	}
 };
 

package/esm/validation/plugins/embed-validator-plugin.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"embed-validator-plugin.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/plugins/embed-validator-plugin.ts"],"sourcesContent":["/**\n * Embed Validator Plugin\n *\n * Adds embed validation to Seal v factory\n */\n\nimport type { SealPlugin } from \"@warlock.js/seal\";\nimport { v } from \"@warlock.js/seal\";\nimport type { ChildModel } from \"../../model/model\";\nimport { EmbedModelValidator } from \"../validators/embed-validator\";\n\ntype EmbedOptions = {\n  errorMessage?: string;\n  embed?: string | string[];\n};\n\ndeclare module \"@warlock.js/seal\" {\n  interface ValidatorV {\n    embed(model: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;\n    embedMany(model: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;\n  }\n}\n\n/**\n * File validation plugin for Seal\n */\nexport const embedValidator: SealPlugin = {\n  name: \"embed\",\n  version: \"1.0.0\",\n  description: \"Adds embed validation (v.embed())\",\n\n  install() {\n    // Inject embed() method into v factory\n    v.embed = (model: ChildModel<any> | string, options?: EmbedOptions) =>\n      new EmbedModelValidator().model(model).embed(options?.embed);\n    v.embedMany = (model: ChildModel<any> | string, options?: EmbedOptions) =>\n      new EmbedModelValidator().models(model).embed(options?.embed);\n  },\n};\n"],"mappings":";;;;;;;AA0BA,MAAa,iBAA6B;CACxC,MAAM;CACN,SAAS;CACT,aAAa;CAEb,UAAU;EAER,EAAE,SAAS,OAAiC,YAC1C,IAAI,oBAAoB,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,SAAS,KAAK;EAC7D,EAAE,aAAa,OAAiC,YAC9C,IAAI,oBAAoB,CAAC,CAAC,OAAO,KAAK,CAAC,CAAC,MAAM,SAAS,KAAK;CAChE;AACF"}
+{"version":3,"file":"embed-validator-plugin.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/plugins/embed-validator-plugin.ts"],"sourcesContent":["/**\n * Embed Validator Plugin\n *\n * Adds embed validation to Seal v factory\n */\n\nimport type { SealPlugin } from \"@warlock.js/seal\";\nimport { v } from \"@warlock.js/seal\";\nimport type { ChildModel } from \"../../model/model\";\nimport { EmbedModelValidator } from \"../validators/embed-validator\";\n\ntype EmbedOptions = {\n  errorMessage?: string;\n  embed?: string | string[];\n};\n\ndeclare module \"@warlock.js/seal\" {\n  interface ValidatorV {\n    embed(model?: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;\n    embedMany(model?: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;\n  }\n}\n\n/**\n * File validation plugin for Seal\n */\nexport const embedValidator: SealPlugin = {\n  name: \"embed\",\n  version: \"1.0.0\",\n  description: \"Adds embed validation (v.embed())\",\n\n  install() {\n    // Inject embed() method into v factory\n    // without a model, a bare validator is returned (call .model()/.models() later)\n    v.embed = (model?: ChildModel<any> | string, options?: EmbedOptions) => {\n      const validator = new EmbedModelValidator();\n\n      return (model ? validator.model(model, options?.errorMessage) : validator).embed(\n        options?.embed,\n      );\n    };\n    v.embedMany = (model?: ChildModel<any> | string, options?: EmbedOptions) => {\n      const validator = new EmbedModelValidator();\n\n      return (model ? validator.models(model, options?.errorMessage) : validator).embed(\n        options?.embed,\n      );\n    };\n  },\n};\n"],"mappings":";;;;;;;AA0BA,MAAa,iBAA6B;CACxC,MAAM;CACN,SAAS;CACT,aAAa;CAEb,UAAU;EAGR,EAAE,SAAS,OAAkC,YAA2B;GACtE,MAAM,YAAY,IAAI,oBAAoB;GAE1C,QAAQ,QAAQ,UAAU,MAAM,OAAO,SAAS,YAAY,IAAI,UAAS,CAAE,MACzE,SAAS,KACX;EACF;EACA,EAAE,aAAa,OAAkC,YAA2B;GAC1E,MAAM,YAAY,IAAI,oBAAoB;GAE1C,QAAQ,QAAQ,UAAU,OAAO,OAAO,SAAS,YAAY,IAAI,UAAS,CAAE,MAC1E,SAAS,KACX;EACF;CACF;AACF"}

package/esm/validation/rules/database-model-rule.mjs

@@ -1,4 +1,4 @@
-import { getModelFromRegistry } from "../../model/register-model.mjs";
+import { requireModelClass } from "../../model/register-model.mjs";
 import { Model } from "../../model/model.mjs";
 import { VALID_RULE, invalidRule } from "@warlock.js/seal";
 
@@ -8,7 +8,8 @@ const databaseModelRule = {
 	defaultErrorMessage: "The :input must be a valid :model model",
 	async validate(value, context) {
 		if (value instanceof Model === false) {
-			this.context.attributesList.model = this.context.options.model?.name;
+			const { model } = this.context.options;
+			this.context.attributesList.model = typeof model === "string" ? model : model?.name;
 			return invalidRule(this, context);
 		}
 		return VALID_RULE;
@@ -18,9 +19,9 @@ const databaseModelsRule = {
 	name: "databaseModels",
 	defaultErrorMessage: "The :input must be a list of valid :model",
 	async validate(value, context) {
-		let { model } = this.context.options;
-		if (typeof model === "string") model = getModelFromRegistry(model);
-		this.context.attributesList.model = model.name;
+		const { model } = this.context.options;
+		const ModelClass = requireModelClass(model);
+		this.context.attributesList.model = typeof model === "string" ? model : ModelClass.name;
 		if (!Array.isArray(value)) return invalidRule(this, context);
 		if (value.every((item) => item instanceof Model)) return VALID_RULE;
 		return invalidRule(this, context);

package/esm/validation/rules/database-model-rule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"database-model-rule.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/rules/database-model-rule.ts"],"sourcesContent":["import { invalidRule, VALID_RULE, type SchemaRule } from \"@warlock.js/seal\";\r\nimport { type ChildModel, Model } from \"./../../model/model\";\r\nimport { getModelFromRegistry } from \"./../../model/register-model\";\r\n\r\nexport const databaseModelRule: SchemaRule = {\r\n  name: \"databaseModel\",\r\n  defaultErrorMessage: \"The :input must be a valid :model model\",\r\n  async validate(value, context) {\r\n    if (value instanceof Model === false) {\r\n      this.context.attributesList.model = this.context.options.model?.name;\r\n      return invalidRule(this, context);\r\n    }\r\n\r\n    return VALID_RULE;\r\n  },\r\n};\r\n\r\nexport const databaseModelsRule: SchemaRule<{ model: ChildModel<any> | string }> = {\r\n  name: \"databaseModels\",\r\n  defaultErrorMessage: \"The :input must be a list of valid :model\",\r\n  async validate(value, context) {\r\n    let { model } = this.context.options;\r\n    if (typeof model === \"string\") {\r\n      model = getModelFromRegistry(model)!;\r\n    }\r\n\r\n    this.context.attributesList.model = model.name;\r\n\r\n    if (!Array.isArray(value)) return invalidRule(this, context);\r\n\r\n    if (value.every((item) => item instanceof Model)) return VALID_RULE;\r\n\r\n    return invalidRule(this, context);\r\n  },\r\n};\r\n"],"mappings":";;;;;AAIA,MAAa,oBAAgC;CAC3C,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,iBAAiB,UAAU,OAAO;GACpC,KAAK,QAAQ,eAAe,QAAQ,KAAK,QAAQ,QAAQ,OAAO;GAChE,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;AAEA,MAAa,qBAAsE;CACjF,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,EAAE,UAAU,KAAK,QAAQ;EAC7B,IAAI,OAAO,UAAU,UACnB,QAAQ,qBAAqB,KAAK;EAGpC,KAAK,QAAQ,eAAe,QAAQ,MAAM;EAE1C,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO,YAAY,MAAM,OAAO;EAE3D,IAAI,MAAM,OAAO,SAAS,gBAAgB,KAAK,GAAG,OAAO;EAEzD,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}
+{"version":3,"file":"database-model-rule.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/rules/database-model-rule.ts"],"sourcesContent":["import { invalidRule, VALID_RULE, type SchemaRule } from \"@warlock.js/seal\";\nimport { type ChildModel, Model } from \"./../../model/model\";\nimport { requireModelClass } from \"./../../model/register-model\";\n\nexport const databaseModelRule: SchemaRule = {\n  name: \"databaseModel\",\n  defaultErrorMessage: \"The :input must be a valid :model model\",\n  async validate(value, context) {\n    if (value instanceof Model === false) {\n      const { model } = this.context.options;\n\n      this.context.attributesList.model = typeof model === \"string\" ? model : model?.name;\n      return invalidRule(this, context);\n    }\n\n    return VALID_RULE;\n  },\n};\n\nexport const databaseModelsRule: SchemaRule<{ model: ChildModel<any> | string }> = {\n  name: \"databaseModels\",\n  defaultErrorMessage: \"The :input must be a list of valid :model\",\n  async validate(value, context) {\n    const { model } = this.context.options;\n\n    // keep the original name for messages; throws when a string ref is unregistered\n    const ModelClass = requireModelClass(model);\n\n    this.context.attributesList.model = typeof model === \"string\" ? model : ModelClass.name;\n\n    if (!Array.isArray(value)) return invalidRule(this, context);\n\n    if (value.every((item) => item instanceof Model)) return VALID_RULE;\n\n    return invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;AAIA,MAAa,oBAAgC;CAC3C,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,IAAI,iBAAiB,UAAU,OAAO;GACpC,MAAM,EAAE,UAAU,KAAK,QAAQ;GAE/B,KAAK,QAAQ,eAAe,QAAQ,OAAO,UAAU,WAAW,QAAQ,OAAO;GAC/E,OAAO,YAAY,MAAM,OAAO;EAClC;EAEA,OAAO;CACT;AACF;AAEA,MAAa,qBAAsE;CACjF,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAO,SAAS;EAC7B,MAAM,EAAE,UAAU,KAAK,QAAQ;EAG/B,MAAM,aAAa,kBAAkB,KAAK;EAE1C,KAAK,QAAQ,eAAe,QAAQ,OAAO,UAAU,WAAW,QAAQ,WAAW;EAEnF,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,OAAO,YAAY,MAAM,OAAO;EAE3D,IAAI,MAAM,OAAO,SAAS,gBAAgB,KAAK,GAAG,OAAO;EAEzD,OAAO,YAAY,MAAM,OAAO;CAClC;AACF"}

package/esm/validation/rules/exists-rule.mjs

@@ -1,4 +1,4 @@
-import { resolveModelClass } from "../../model/register-model.mjs";
+import { requireModelClass } from "../../model/register-model.mjs";
 import { VALID_RULE, invalidRule } from "@warlock.js/seal";
 
 //#region ../cascade/src/validation/rules/exists-rule.ts
@@ -12,9 +12,11 @@ const existsRule = {
 	name: "exists",
 	defaultErrorMessage: "The :input must exist",
 	async validate(value, context) {
-		const { Model, query, column = context.key } = this.context.options;
-		const dbQuery = resolveModelClass(Model).query();
-		dbQuery.where(column, value);
+		const { Model, query, column } = this.context.options;
+		const ResolvedModelClass = requireModelClass(Model);
+		const lookupColumn = column ?? ResolvedModelClass.primaryKey;
+		const dbQuery = ResolvedModelClass.query();
+		dbQuery.where(lookupColumn, value);
 		if (query) await query({
 			query: dbQuery,
 			value,

package/esm/validation/rules/exists-rule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"exists-rule.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/rules/exists-rule.ts"],"sourcesContent":["import { invalidRule, VALID_RULE, type SchemaRule } from \"@warlock.js/seal\";\nimport { resolveModelClass } from \"../../model/register-model\";\nimport type { ExistsRuleOptions } from \"../types\";\n\n/**\n * Validates that a record exists in the database for the given column/value.\n *\n * @example\n * v.string().exists(Organization, { column: \"id\" });\n */\nexport const existsRule: SchemaRule<ExistsRuleOptions> = {\n  name: \"exists\",\n  defaultErrorMessage: \"The :input must exist\",\n  async validate(value: any, context) {\n    const { Model, query, column = context.key } = this.context.options;\n\n    const ResolvedModelClass = resolveModelClass(Model);\n\n    const dbQuery = ResolvedModelClass.query();\n\n    dbQuery.where(column, value);\n\n    if (query) {\n      await query({\n        query: dbQuery,\n        value,\n        allValues: context.allValues,\n      });\n    }\n\n    const document = await dbQuery.first();\n\n    return document ? VALID_RULE : invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;;AAUA,MAAa,aAA4C;CACvD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,OAAO,OAAO,SAAS,QAAQ,QAAQ,KAAK,QAAQ;EAI5D,MAAM,UAFqB,kBAAkB,KAEZ,CAAC,CAAC,MAAM;EAEzC,QAAQ,MAAM,QAAQ,KAAK;EAE3B,IAAI,OACF,MAAM,MAAM;GACV,OAAO;GACP;GACA,WAAW,QAAQ;EACrB,CAAC;EAKH,OAAO,MAFgB,QAAQ,MAAM,IAEnB,aAAa,YAAY,MAAM,OAAO;CAC1D;AACF"}
+{"version":3,"file":"exists-rule.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/rules/exists-rule.ts"],"sourcesContent":["import { invalidRule, VALID_RULE, type SchemaRule } from \"@warlock.js/seal\";\nimport { requireModelClass } from \"../../model/register-model\";\nimport type { ExistsRuleOptions } from \"../types\";\n\n/**\n * Validates that a record exists in the database for the given column/value.\n *\n * @example\n * v.string().exists(Organization, { column: \"id\" });\n */\nexport const existsRule: SchemaRule<ExistsRuleOptions> = {\n  name: \"exists\",\n  defaultErrorMessage: \"The :input must exist\",\n  async validate(value: any, context) {\n    const { Model, query, column } = this.context.options;\n\n    const ResolvedModelClass = requireModelClass(Model);\n\n    // Explicit column wins, otherwise look up by the related model's primary key\n    const lookupColumn = column ?? ResolvedModelClass.primaryKey;\n\n    const dbQuery = ResolvedModelClass.query();\n\n    dbQuery.where(lookupColumn, value);\n\n    if (query) {\n      await query({\n        query: dbQuery,\n        value,\n        allValues: context.allValues,\n      });\n    }\n\n    const document = await dbQuery.first();\n\n    return document ? VALID_RULE : invalidRule(this, context);\n  },\n};\n"],"mappings":";;;;;;;;;;AAUA,MAAa,aAA4C;CACvD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EAAE,OAAO,OAAO,WAAW,KAAK,QAAQ;EAE9C,MAAM,qBAAqB,kBAAkB,KAAK;EAGlD,MAAM,eAAe,UAAU,mBAAmB;EAElD,MAAM,UAAU,mBAAmB,MAAM;EAEzC,QAAQ,MAAM,cAAc,KAAK;EAEjC,IAAI,OACF,MAAM,MAAM;GACV,OAAO;GACP;GACA,WAAW,QAAQ;EACrB,CAAC;EAKH,OAAO,MAFgB,QAAQ,MAAM,IAEnB,aAAa,YAAY,MAAM,OAAO;CAC1D;AACF"}

package/esm/validation/rules/unique-rule.mjs

@@ -1,4 +1,4 @@
-import { resolveModelClass } from "../../model/register-model.mjs";
+import { requireModelClass } from "../../model/register-model.mjs";
 import { get } from "@mongez/reinforcements";
 import { VALID_RULE, invalidRule } from "@warlock.js/seal";
 
@@ -22,12 +22,15 @@ const uniqueRule = {
 	defaultErrorMessage: "The :input must be unique",
 	async validate(value, context) {
 		const { Model, except, column = context.key, exceptColumnName, exceptValue, query } = this.context.options;
-		const dbQuery = resolveModelClass(Model).query();
+		const ResolvedModelClass = requireModelClass(Model);
+		const dbQuery = ResolvedModelClass.query();
 		dbQuery.where(column, value);
 		if (except) {
 			const exceptVal = get(context.allValues, except);
 			if (exceptVal !== void 0) dbQuery.where(except, "!=", exceptVal);
 		}
+		const currentModel = context.rootContext?.model;
+		if (currentModel && currentModel.isNew === false && currentModel.constructor === ResolvedModelClass && currentModel.trustedPrimaryKey !== void 0) dbQuery.where(ResolvedModelClass.primaryKey || "id", "!=", currentModel.trustedPrimaryKey);
 		if (exceptColumnName !== void 0) dbQuery.where(exceptColumnName, "!=", exceptValue);
 		if (query) await query({
 			query: dbQuery,

package/esm/validation/rules/unique-rule.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"unique-rule.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/rules/unique-rule.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\nimport { invalidRule, VALID_RULE, type SchemaRule } from \"@warlock.js/seal\";\nimport { resolveModelClass } from \"../../model/register-model\";\nimport type { UniqueRuleOptions } from \"../types\";\n\n/**\n * Validates that a value is unique against a database column.\n *\n * Supports three exclusion modes:\n * - `except`: read a sibling input's value and exclude rows where that\n *   column equals the sibling's value\n * - `exceptColumnName` + `exceptValue`: exclude rows where the named\n *   column equals the supplied value (used by request-aware wrappers)\n * - Custom `query` callback for anything more involved\n *\n * @example\n * v.email().unique(\"User\");\n * v.string().unique(\"User\", { except: \"id\" });\n */\nexport const uniqueRule: SchemaRule<UniqueRuleOptions> = {\n  name: \"unique\",\n  defaultErrorMessage: \"The :input must be unique\",\n  async validate(value: any, context) {\n    const {\n      Model,\n      except,\n      column = context.key,\n      exceptColumnName,\n      exceptValue,\n      query,\n    } = this.context.options;\n\n    const ResolvedModelClass = resolveModelClass(Model);\n\n    const dbQuery = ResolvedModelClass.query();\n\n    dbQuery.where(column, value);\n\n    if (except) {\n      const exceptVal = get(context.allValues, except);\n\n      if (exceptVal !== undefined) {\n        dbQuery.where(except, \"!=\", exceptVal);\n      }\n    }\n\n    if (exceptColumnName !== undefined) {\n      dbQuery.where(exceptColumnName, \"!=\", exceptValue);\n    }\n\n    if (query) {\n      await query({\n        query: dbQuery,\n        value,\n        allValues: context.allValues,\n      });\n    }\n\n    const document = await dbQuery.first();\n\n    return document ? invalidRule(this, context) : VALID_RULE;\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,MAAa,aAA4C;CACvD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EACJ,OACA,QACA,SAAS,QAAQ,KACjB,kBACA,aACA,UACE,KAAK,QAAQ;EAIjB,MAAM,UAFqB,kBAAkB,KAEZ,CAAC,CAAC,MAAM;EAEzC,QAAQ,MAAM,QAAQ,KAAK;EAE3B,IAAI,QAAQ;GACV,MAAM,YAAY,IAAI,QAAQ,WAAW,MAAM;GAE/C,IAAI,cAAc,QAChB,QAAQ,MAAM,QAAQ,MAAM,SAAS;EAEzC;EAEA,IAAI,qBAAqB,QACvB,QAAQ,MAAM,kBAAkB,MAAM,WAAW;EAGnD,IAAI,OACF,MAAM,MAAM;GACV,OAAO;GACP;GACA,WAAW,QAAQ;EACrB,CAAC;EAKH,OAAO,MAFgB,QAAQ,MAAM,IAEnB,YAAY,MAAM,OAAO,IAAI;CACjD;AACF"}
+{"version":3,"file":"unique-rule.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/rules/unique-rule.ts"],"sourcesContent":["import { get } from \"@mongez/reinforcements\";\nimport { invalidRule, VALID_RULE, type SchemaRule } from \"@warlock.js/seal\";\nimport { requireModelClass } from \"../../model/register-model\";\nimport type { UniqueRuleOptions } from \"../types\";\n\n/**\n * Validates that a value is unique against a database column.\n *\n * Supports three exclusion modes:\n * - `except`: read a sibling input's value and exclude rows where that\n *   column equals the sibling's value\n * - `exceptColumnName` + `exceptValue`: exclude rows where the named\n *   column equals the supplied value (used by request-aware wrappers)\n * - Custom `query` callback for anything more involved\n *\n * @example\n * v.email().unique(\"User\");\n * v.string().unique(\"User\", { except: \"id\" });\n */\nexport const uniqueRule: SchemaRule<UniqueRuleOptions> = {\n  name: \"unique\",\n  defaultErrorMessage: \"The :input must be unique\",\n  async validate(value: any, context) {\n    const {\n      Model,\n      except,\n      column = context.key,\n      exceptColumnName,\n      exceptValue,\n      query,\n    } = this.context.options;\n\n    const ResolvedModelClass = requireModelClass(Model);\n\n    const dbQuery = ResolvedModelClass.query();\n\n    dbQuery.where(column, value);\n\n    if (except) {\n      const exceptVal = get(context.allValues, except);\n\n      if (exceptVal !== undefined) {\n        dbQuery.where(except, \"!=\", exceptVal);\n      }\n    }\n\n    // A persisted model never collides with its own row on update.\n    const currentModel = context.rootContext?.model;\n\n    if (\n      currentModel &&\n      currentModel.isNew === false &&\n      currentModel.constructor === ResolvedModelClass &&\n      currentModel.trustedPrimaryKey !== undefined\n    ) {\n      dbQuery.where(\n        (ResolvedModelClass as any).primaryKey || \"id\",\n        \"!=\",\n        currentModel.trustedPrimaryKey,\n      );\n    }\n\n    if (exceptColumnName !== undefined) {\n      dbQuery.where(exceptColumnName, \"!=\", exceptValue);\n    }\n\n    if (query) {\n      await query({\n        query: dbQuery,\n        value,\n        allValues: context.allValues,\n      });\n    }\n\n    const document = await dbQuery.first();\n\n    return document ? invalidRule(this, context) : VALID_RULE;\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAmBA,MAAa,aAA4C;CACvD,MAAM;CACN,qBAAqB;CACrB,MAAM,SAAS,OAAY,SAAS;EAClC,MAAM,EACJ,OACA,QACA,SAAS,QAAQ,KACjB,kBACA,aACA,UACE,KAAK,QAAQ;EAEjB,MAAM,qBAAqB,kBAAkB,KAAK;EAElD,MAAM,UAAU,mBAAmB,MAAM;EAEzC,QAAQ,MAAM,QAAQ,KAAK;EAE3B,IAAI,QAAQ;GACV,MAAM,YAAY,IAAI,QAAQ,WAAW,MAAM;GAE/C,IAAI,cAAc,QAChB,QAAQ,MAAM,QAAQ,MAAM,SAAS;EAEzC;EAGA,MAAM,eAAe,QAAQ,aAAa;EAE1C,IACE,gBACA,aAAa,UAAU,SACvB,aAAa,gBAAgB,sBAC7B,aAAa,sBAAsB,QAEnC,QAAQ,MACL,mBAA2B,cAAc,MAC1C,MACA,aAAa,iBACf;EAGF,IAAI,qBAAqB,QACvB,QAAQ,MAAM,kBAAkB,MAAM,WAAW;EAGnD,IAAI,OACF,MAAM,MAAM;GACV,OAAO;GACP;GACA,WAAW,QAAQ;EACrB,CAAC;EAKH,OAAO,MAFgB,QAAQ,MAAM,IAEnB,YAAY,MAAM,OAAO,IAAI;CACjD;AACF"}

package/esm/validation/validators/embed-validator.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"embed-validator.d.mts","names":[],"sources":["../../../../../../../../cascade/src/validation/validators/embed-validator.ts"],"mappings":";;;;cAMa,mBAAA,SAA4B,aAAA;;;AAAzC;EAIS,WAAA,CAAY,KAAA;;;;EAWZ,KAAA,CAAM,KAAA,EAAO,UAAA,gBAA0B,YAAA,YAAwB,mBAAA;EAaC;;;EAAhE,MAAA,CAAO,KAAA,EAAO,UAAA,gBAA0B,YAAA,YAAwB,mBAAA;EA5BnB;;;EA6C7C,KAAA,CAAM,KAAA,uBAA4B,mBAAA;AAAA"}
+{"version":3,"file":"embed-validator.d.mts","names":[],"sources":["../../../../../../../../cascade/src/validation/validators/embed-validator.ts"],"mappings":";;;;cAMa,mBAAA,SAA4B,aAAA;;;AAAzC;EAIS,WAAA,CAAY,KAAA;;;;EAYZ,KAAA,CAAM,KAAA,EAAO,UAAA,gBAA0B,YAAA,YAAwB,mBAAA;EAaC;;;EAAhE,MAAA,CAAO,KAAA,EAAO,UAAA,gBAA0B,YAAA,YAAwB,mBAAA;EA7BnB;;;EA8C7C,KAAA,CAAM,KAAA,uBAA4B,mBAAA;AAAA"}

package/esm/validation/validators/embed-validator.mjs

@@ -10,7 +10,7 @@ var EmbedModelValidator = class extends BaseValidator {
 	* Check if value is a string type
 	*/
 	matchesType(value) {
-		return value instanceof Model || typeof value === "number" || Array.isArray(value) && value.every((item) => item instanceof Model);
+		return value instanceof Model || typeof value === "number" || typeof value === "string" || Array.isArray(value) && value.every((item) => item instanceof Model);
 	}
 	/**
 	* Mutate the value to be a model, also fail if the mutated value is not a valid model

package/esm/validation/validators/embed-validator.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"embed-validator.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/validators/embed-validator.ts"],"sourcesContent":["import { arrayRule, BaseValidator } from \"@warlock.js/seal\";\nimport { Model, type ChildModel } from \"../../model/model\";\nimport { databaseModelMutator, databaseModelsMutator } from \"../mutators/embed-mutator\";\nimport { databaseModelRule, databaseModelsRule } from \"../rules/database-model-rule\";\nimport { databaseModelTransformer } from \"../transformers/embed-model-transformer\";\n\nexport class EmbedModelValidator extends BaseValidator {\n  /**\n   * Check if value is a string type\n   */\n  public matchesType(value: any): boolean {\n    return (\n      value instanceof Model ||\n      typeof value === \"number\" ||\n      (Array.isArray(value) && value.every((item) => item instanceof Model))\n    );\n  }\n\n  /**\n   * Mutate the value to be a model, also fail if the mutated value is not a valid model\n   */\n  public model(model: ChildModel<any> | string, errorMessage?: string): EmbedModelValidator {\n    this.addMutator(databaseModelMutator, {\n      model,\n    });\n\n    return this.addRule(databaseModelRule, errorMessage, {\n      model,\n    });\n  }\n\n  /**\n   * Validate the value is a list of models\n   */\n  public models(model: ChildModel<any> | string, errorMessage?: string): EmbedModelValidator {\n    const instance = this.instance;\n    instance.addMutator(databaseModelsMutator, {\n      model,\n    });\n\n    instance.addMutableRule(arrayRule);\n    instance.addMutableRule(databaseModelsRule, errorMessage, {\n      model,\n    });\n\n    return instance;\n  }\n\n  /**\n   * Determine how the data will be stored as an embedded document\n   */\n  public embed(embed?: string | string[]): EmbedModelValidator {\n    return this.addTransformer(databaseModelTransformer, {\n      embed,\n    });\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,sBAAb,cAAyC,cAAc;;;;CAIrD,AAAO,YAAY,OAAqB;EACtC,OACE,iBAAiB,SACjB,OAAO,UAAU,YAChB,MAAM,QAAQ,KAAK,KAAK,MAAM,OAAO,SAAS,gBAAgB,KAAK;CAExE;;;;CAKA,AAAO,MAAM,OAAiC,cAA4C;EACxF,KAAK,WAAW,sBAAsB,EACpC,MACF,CAAC;EAED,OAAO,KAAK,QAAQ,mBAAmB,cAAc,EACnD,MACF,CAAC;CACH;;;;CAKA,AAAO,OAAO,OAAiC,cAA4C;EACzF,MAAM,WAAW,KAAK;EACtB,SAAS,WAAW,uBAAuB,EACzC,MACF,CAAC;EAED,SAAS,eAAe,SAAS;EACjC,SAAS,eAAe,oBAAoB,cAAc,EACxD,MACF,CAAC;EAED,OAAO;CACT;;;;CAKA,AAAO,MAAM,OAAgD;EAC3D,OAAO,KAAK,eAAe,0BAA0B,EACnD,MACF,CAAC;CACH;AACF"}
+{"version":3,"file":"embed-validator.mjs","names":[],"sources":["../../../../../../../../cascade/src/validation/validators/embed-validator.ts"],"sourcesContent":["import { arrayRule, BaseValidator } from \"@warlock.js/seal\";\nimport { Model, type ChildModel } from \"../../model/model\";\nimport { databaseModelMutator, databaseModelsMutator } from \"../mutators/embed-mutator\";\nimport { databaseModelRule, databaseModelsRule } from \"../rules/database-model-rule\";\nimport { databaseModelTransformer } from \"../transformers/embed-model-transformer\";\n\nexport class EmbedModelValidator extends BaseValidator {\n  /**\n   * Check if value is a string type\n   */\n  public matchesType(value: any): boolean {\n    return (\n      value instanceof Model ||\n      typeof value === \"number\" ||\n      typeof value === \"string\" ||\n      (Array.isArray(value) && value.every((item) => item instanceof Model))\n    );\n  }\n\n  /**\n   * Mutate the value to be a model, also fail if the mutated value is not a valid model\n   */\n  public model(model: ChildModel<any> | string, errorMessage?: string): EmbedModelValidator {\n    this.addMutator(databaseModelMutator, {\n      model,\n    });\n\n    return this.addRule(databaseModelRule, errorMessage, {\n      model,\n    });\n  }\n\n  /**\n   * Validate the value is a list of models\n   */\n  public models(model: ChildModel<any> | string, errorMessage?: string): EmbedModelValidator {\n    const instance = this.instance;\n    instance.addMutator(databaseModelsMutator, {\n      model,\n    });\n\n    instance.addMutableRule(arrayRule);\n    instance.addMutableRule(databaseModelsRule, errorMessage, {\n      model,\n    });\n\n    return instance;\n  }\n\n  /**\n   * Determine how the data will be stored as an embedded document\n   */\n  public embed(embed?: string | string[]): EmbedModelValidator {\n    return this.addTransformer(databaseModelTransformer, {\n      embed,\n    });\n  }\n}\n"],"mappings":";;;;;;;AAMA,IAAa,sBAAb,cAAyC,cAAc;;;;CAIrD,AAAO,YAAY,OAAqB;EACtC,OACE,iBAAiB,SACjB,OAAO,UAAU,YACjB,OAAO,UAAU,YAChB,MAAM,QAAQ,KAAK,KAAK,MAAM,OAAO,SAAS,gBAAgB,KAAK;CAExE;;;;CAKA,AAAO,MAAM,OAAiC,cAA4C;EACxF,KAAK,WAAW,sBAAsB,EACpC,MACF,CAAC;EAED,OAAO,KAAK,QAAQ,mBAAmB,cAAc,EACnD,MACF,CAAC;CACH;;;;CAKA,AAAO,OAAO,OAAiC,cAA4C;EACzF,MAAM,WAAW,KAAK;EACtB,SAAS,WAAW,uBAAuB,EACzC,MACF,CAAC;EAED,SAAS,eAAe,SAAS;EACjC,SAAS,eAAe,oBAAoB,cAAc,EACxD,MACF,CAAC;EAED,OAAO;CACT;;;;CAKA,AAAO,MAAM,OAAgD;EAC3D,OAAO,KAAK,eAAe,0BAA0B,EACnD,MACF,CAAC;CACH;AACF"}

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

@@ -39,6 +39,8 @@ import { WriterContract, WriterOptions, WriterResult } from "../contracts/databa
 declare class DatabaseWriter implements WriterContract {
   /** The model instance being persisted */
   private readonly model;
+  /** Dirty columns an update validation dropped (strip mode); never written. */
+  private readonly unvalidatedColumns;
   /** Model constructor reference */
   private readonly ctor;
   /** Data source containing driver and ID generator */
@@ -85,6 +87,13 @@ declare class DatabaseWriter implements WriterContract {
    * @private
    */
   private validateAndCast;
+  /**
+   * Validate, cast and id-generate a not-yet-persisted model for `upsert()`.
+   *
+   * Runs the insert-mode pipeline (schema, casts, strictMode, Mongo `id`) but
+   * does not write; the caller sends the resulting data through the driver.
+   */
+  prepareForUpsert(): Promise<void>;
   /**
    * Perform an insert operation.
    *
@@ -93,6 +102,18 @@ declare class DatabaseWriter implements WriterContract {
    * @private
    */
   private performInsert;
+  /**
+   * Run the insert pipeline (validation, casting, id generation, timestamps,
+   * `validating`/`validated`/`creating` hooks) WITHOUT writing.
+   *
+   * `save()` uses this for its insert path, so bulk inserts and single inserts
+   * cannot drift. The caller is responsible for sending the returned document
+   * to the driver.
+   *
+   * @param options - Save options (e.g. `skipEvents`, `skipValidation`)
+   * @returns The prepared document to insert
+   */
+  prepareForInsert(options?: WriterOptions): Promise<Record<string, unknown>>;
   /**
    * Perform an update operation.
    *
@@ -101,6 +122,12 @@ declare class DatabaseWriter implements WriterContract {
    * @private
    */
   private performUpdate;
+  /**
+   * Map a driver unique-constraint violation (Postgres 23505, MongoDB 11000)
+   * to a field validation error, so a lost `unique` race never surfaces as a
+   * 500. Any other error is returned untouched.
+   */
+  private mapUniqueViolation;
   /**
    * Build the filter that pins a write to the row this model was loaded from.
    *

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

@@ -1 +1 @@
-{"version":3,"file":"database-writer.d.mts","names":[],"sources":["../../../../../../../cascade/src/writer/database-writer.ts"],"mappings":";;;;;;AAuDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,YAA0B,cAAA;EA+UN;EAAA,iBA7Ud,KAAA;EA6aT;EAAA,iBA1aS,IAAA;EAydT;EAAA,iBAtdS,UAAA;EAmeQ;EAAA,iBAheR,MAAA;;mBAGA,KAAA;;mBAGA,UAAA;;mBAGA,MAAA;;mBAGA,UAAA;;;;;;;;;;;;;cAcE,KAAA,EAAO,KAAA;;;;;;;;EAkBb,IAAA,CAAK,OAAA,GAAS,aAAA,GAAqB,OAAA,CAAQ,YAAA;;;;;;;;;;;UAsE1C,eAAA;;;;;;;;UA8FA,aAAA;;;;;;;;UAqDA,aAAA;;;;;;;;;;;;UAsDN,qBAAA;;;;;;EASK,cAAA,IAAkB,OAAA;;;;;;;;;;;;;;;;;;;;;;UA6CvB,qBAAA;;;;;;;;;;;;UAmDA,gBAAA;;;;;;;;;;;;UAyBA,kBAAA;;;;;;;;;UAsBA,SAAA;;;;;;;;;;UAaM,WAAA;AAAA"}
+{"version":3,"file":"database-writer.d.mts","names":[],"sources":["../../../../../../../cascade/src/writer/database-writer.ts"],"mappings":";;;;;;AAwDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,YAA0B,cAAA;EA+HvB;EAAA,iBA7HG,KAAA;EAkPgB;EAAA,iBA/OhB,kBAAA;EA8RJ;EAAA,iBA3RI,IAAA;EA2Ra;EAAA,iBAxRb,UAAA;EAwRmD;EAAA,iBArRnD,MAAA;EAqXT;EAAA,iBAlXS,KAAA;EA8aJ;EAAA,iBA3aI,UAAA;EAwdT;EAAA,iBArdS,MAAA;EAiiBT;EAAA,iBA9hBS,UAAA;EAikBH;;AAAW;;;;;;;;;;cAnjBN,KAAA,EAAO,KAAA;;;;;;;;EAkBb,IAAA,CAAK,OAAA,GAAS,aAAA,GAAqB,OAAA,CAAQ,YAAA;;;;;;;;;;;UAqE1C,eAAA;;;;;;;EAqHD,gBAAA,IAAoB,OAAA;;;;;;;;UAYnB,aAAA;;;;;;;;;;;;EAmCD,gBAAA,CAAiB,OAAA,GAAS,aAAA,GAAqB,OAAA,CAAQ,MAAA;;;;;;;;UA4CtD,aAAA;;;;;;UAoDN,kBAAA;;;;;;;;;;;;UAmDA,qBAAA;;;;;;EASK,cAAA,IAAkB,OAAA;;;;;;;;;;;;;;;;;;;;;;UA6CvB,qBAAA;;;;;;;;;;;;UAmDA,gBAAA;;;;;;;;;;;;UAyBA,kBAAA;;;;;;;;;UAsBA,SAAA;;;;;;;;;;UAaM,WAAA;AAAA"}

package/esm/writer/database-writer.mjs

@@ -1,9 +1,10 @@
-import { getModelUpdatedEvent } from "../sync/model-events.mjs";
+import { afterCommit } from "../transactions/after-commit.mjs";
+import { triggerModelEvent } from "../sync/model-events.mjs";
 import { mergeDriverFields } from "../model/methods/accessor-methods.mjs";
 import { DatabaseWriterValidationError } from "../validation/database-writer-validation-error.mjs";
 import "../validation/index.mjs";
+import { log } from "@warlock.js/logger";
 import { when } from "@mongez/reinforcements";
-import events from "@mongez/events";
 import { getSealConfig, v } from "@warlock.js/seal";
 
 //#region ../cascade/src/writer/database-writer.ts
@@ -44,6 +45,8 @@ import { getSealConfig, v } from "@warlock.js/seal";
 var DatabaseWriter = class {
 	/** The model instance being persisted */
 	model;
+	/** Dirty columns an update validation dropped (strip mode); never written. */
+	unvalidatedColumns = /* @__PURE__ */ new Set();
 	/** Model constructor reference */
 	ctor;
 	/** Data source containing driver and ID generator */
@@ -100,10 +103,12 @@ var DatabaseWriter = class {
 			options,
 			mode: isInsert ? "insert" : "update"
 		});
-		await this.validateAndCast(isInsert, options);
 		let result;
 		if (isInsert) result = await this.performInsert(options);
-		else result = await this.performUpdate(options);
+		else {
+			await this.validateAndCast(false, options);
+			result = await this.performUpdate(options);
+		}
 		const changedFields = isInsert ? [] : this.model.getDirtyColumns();
 		this.model.dirtyTracker.reset();
 		this.model.isNew = false;
@@ -111,7 +116,7 @@ var DatabaseWriter = class {
 			await this.model.emitEvent("saved");
 			await this.model.emitEvent(isInsert ? "created" : "updated");
 		}
-		if (!options.skipSync && !isInsert) this.triggerSync(changedFields);
+		if (!options.skipSync && !isInsert) afterCommit(() => this.triggerSync(changedFields));
 		return {
 			success: true,
 			document: this.model.data,
@@ -143,16 +148,16 @@ var DatabaseWriter = class {
 			...when(this.ctor.updatedAtColumn, () => ({ [this.ctor.updatedAtColumn]: v.date().optional() })),
 			...when(this.ctor.deletedAtColumn, () => ({ [this.ctor.deletedAtColumn]: v.date().optional() }))
 		};
-		const validationSchema = isInsert ? this.schema.clone().extend(systemColumns) : this.schema.clone(Object.keys(this.model.data)).extend(systemColumns);
+		const dataToValidate = isInsert ? this.model.data : Object.fromEntries(this.model.getDirtyColumns().filter((column) => column in this.model.data).map((column) => [column, this.model.data[column]]));
+		const validationSchema = isInsert ? this.schema.clone().extend(systemColumns) : this.schema.clone(Object.keys(dataToValidate)).extend(systemColumns);
 		if (this.strictMode === "strip") validationSchema.stripUnknown();
 		else if (this.strictMode === "fail") validationSchema.allowUnknown(false);
 		else if (this.strictMode === "allow") validationSchema.allowUnknown(true);
-		const result = await v.validate(validationSchema, this.model.data, {
+		const result = await v.validate(validationSchema, dataToValidate, {
 			context: { model: this.model },
 			...getSealConfig()
 		});
 		if (!result.isValid) {
-			console.trace(result.errors);
 			const error = new DatabaseWriterValidationError(`[${this.model.constructor.name} Model] ${isInsert ? "Insert" : "Update"} Validation failed`, result.errors);
 			if (!options.skipEvents) await this.model.emitEvent("validated", {
 				result,
@@ -160,10 +165,25 @@ var DatabaseWriter = class {
 			});
 			throw error;
 		}
-		this.model.replaceData(result.data);
+		if (isInsert) this.model.replaceData(result.data);
+		else {
+			const validated = result.data;
+			for (const column of Object.keys(dataToValidate)) if (column in validated) this.model.set(column, validated[column]);
+			else this.unvalidatedColumns.add(column);
+		}
 		if (!options.skipEvents) await this.model.emitEvent("validated", { result });
 	}
 	/**
+	* Validate, cast and id-generate a not-yet-persisted model for `upsert()`.
+	*
+	* Runs the insert-mode pipeline (schema, casts, strictMode, Mongo `id`) but
+	* does not write; the caller sends the resulting data through the driver.
+	*/
+	async prepareForUpsert() {
+		await this.validateAndCast(true, {});
+		await this.generateNextId();
+	}
+	/**
 	* Perform an insert operation.
 	*
 	* @param options - Save options
@@ -171,6 +191,30 @@ var DatabaseWriter = class {
 	* @private
 	*/
 	async performInsert(options) {
+		const dataToInsert = await this.prepareForInsert(options);
+		let result;
+		try {
+			result = await this.driver.insert(this.table, dataToInsert);
+		} catch (error) {
+			throw this.mapUniqueViolation(error, true);
+		}
+		mergeDriverFields(this.model, result.document);
+		this.model.dirtyTracker.reset();
+		return result;
+	}
+	/**
+	* Run the insert pipeline (validation, casting, id generation, timestamps,
+	* `validating`/`validated`/`creating` hooks) WITHOUT writing.
+	*
+	* `save()` uses this for its insert path, so bulk inserts and single inserts
+	* cannot drift. The caller is responsible for sending the returned document
+	* to the driver.
+	*
+	* @param options - Save options (e.g. `skipEvents`, `skipValidation`)
+	* @returns The prepared document to insert
+	*/
+	async prepareForInsert(options = {}) {
+		await this.validateAndCast(true, options);
 		await this.generateNextId();
 		const dataToInsert = this.model.data;
 		const createdAtColumn = this.ctor.createdAtColumn;
@@ -178,10 +222,7 @@ var DatabaseWriter = class {
 		const updatedAtColumn = this.ctor.updatedAtColumn;
 		if (updatedAtColumn) dataToInsert[updatedAtColumn] = /* @__PURE__ */ new Date();
 		if (!options.skipEvents) await this.model.emitEvent("creating");
-		const result = await this.driver.insert(this.table, dataToInsert);
-		mergeDriverFields(this.model, result.document);
-		this.model.dirtyTracker.reset();
-		return result;
+		return dataToInsert;
 	}
 	/**
 	* Perform an update operation.
@@ -201,7 +242,29 @@ var DatabaseWriter = class {
 		}
 		const operations = this.buildUpdateOperations();
 		if (Object.keys(operations).length === 0) return { modifiedCount: 0 };
-		return await this.driver.update(this.table, this.buildPrimaryKeyFilter(), operations);
+		try {
+			return await this.driver.update(this.table, this.buildPrimaryKeyFilter(), operations);
+		} catch (error) {
+			throw this.mapUniqueViolation(error, false);
+		}
+	}
+	/**
+	* Map a driver unique-constraint violation (Postgres 23505, MongoDB 11000)
+	* to a field validation error, so a lost `unique` race never surfaces as a
+	* 500. Any other error is returned untouched.
+	*/
+	mapUniqueViolation(error, isInsert) {
+		const err = error;
+		if (err?.code !== "23505" && err?.code !== 11e3 && err?.code !== "11000") return error;
+		let field;
+		if (err.keyPattern) field = Object.keys(err.keyPattern)[0];
+		else field = /Key \(([^)]+)\)=/.exec(err.detail ?? "")?.[1]?.split(",")[0]?.trim();
+		if (!field) field = /index: (\S+?)_-?1\b/.exec(err.message ?? "")?.[1];
+		return new DatabaseWriterValidationError(`[${this.model.constructor.name} Model] ${isInsert ? "Insert" : "Update"} Validation failed`, [{
+			type: "unique",
+			error: `The ${field ?? "value"} must be unique`,
+			input: field ?? "id"
+		}]);
 	}
 	/**
 	* Build the filter that pins a write to the row this model was loaded from.
@@ -263,7 +326,7 @@ var DatabaseWriter = class {
 			"id",
 			"_id"
 		]);
-		const dirtyColumns = this.model.getDirtyColumns().filter((column) => !identityColumns.has(column));
+		const dirtyColumns = this.model.getDirtyColumns().filter((column) => !identityColumns.has(column) && !this.unvalidatedColumns.has(column));
 		if (dirtyColumns.length > 0) {
 			operations.$set = {};
 			for (const column of dirtyColumns) {
@@ -306,8 +369,8 @@ var DatabaseWriter = class {
 	* @private
 	*/
 	resolveIncrementBy() {
-		if (this.ctor.incrementIdBy) return this.ctor.incrementIdBy;
 		if (this.ctor.randomIncrement) return typeof this.ctor.randomIncrement === "function" ? this.ctor.randomIncrement() : this.randomInt(1, 10);
+		if (this.ctor.incrementIdBy) return this.ctor.incrementIdBy;
 		return 1;
 	}
 	/**
@@ -331,7 +394,11 @@ var DatabaseWriter = class {
 	* @private
 	*/
 	async triggerSync(changedFields) {
-		await events.triggerAll(getModelUpdatedEvent(this.ctor), this.model, changedFields);
+		try {
+			await triggerModelEvent(this.ctor, "updated", this.model, changedFields);
+		} catch (error) {
+			log.error("database", "sync.failed", `[cascade] sync failed for ${this.ctor.name}: ${error}`);
+		}
 	}
 };