@warlock.js/cascade 4.0.174 → 4.1.2

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

@@ -0,0 +1,17 @@
+import { ChildModel } from "../../model/model.types.mjs";
+import { EmbedModelValidator } from "../validators/embed-validator.mjs";
+//#region ../../@warlock.js/cascade/src/validation/plugins/embed-validator-plugin.d.ts
+type EmbedOptions = {
+  errorMessage?: string;
+  embed?: string | string[];
+};
+declare module "@warlock.js/seal" {
+  interface ValidatorV {
+    embed(model: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;
+    embedMany(model: ChildModel<any> | string, options?: EmbedOptions): EmbedModelValidator;
+  }
+}
+/**
+ * File validation plugin for Seal
+ */
+//# sourceMappingURL=embed-validator-plugin.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embed-validator-plugin.d.mts","names":[],"sources":["../../../../../../../@warlock.js/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"}

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

@@ -0,0 +1,20 @@
+import { EmbedModelValidator } from "../validators/embed-validator.mjs";
+import { v } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/plugins/embed-validator-plugin.ts
+/**
+* File validation plugin for Seal
+*/
+const embedValidator = {
+	name: "embed",
+	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);
+	}
+};
+
+//#endregion
+export { embedValidator };
+//# sourceMappingURL=embed-validator-plugin.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embed-validator-plugin.mjs","names":[],"sources":["../../../../../../../@warlock.js/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,EAAE,MAAM,KAAK,EAAE,MAAM,SAAS,KAAK;EAC7D,EAAE,aAAa,OAAiC,YAC9C,IAAI,oBAAoB,EAAE,OAAO,KAAK,EAAE,MAAM,SAAS,KAAK;CAChE;AACF"}

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

@@ -0,0 +1,32 @@
+import { getModelFromRegistry } from "../../model/register-model.mjs";
+import { Model } from "../../model/model.mjs";
+import { VALID_RULE, invalidRule } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/rules/database-model-rule.ts
+const databaseModelRule = {
+	name: "databaseModel",
+	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;
+			return invalidRule(this, context);
+		}
+		return VALID_RULE;
+	}
+};
+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;
+		if (!Array.isArray(value)) return invalidRule(this, context);
+		if (value.every((item) => item instanceof Model)) return VALID_RULE;
+		return invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { databaseModelRule, databaseModelsRule };
+//# sourceMappingURL=database-model-rule.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"database-model-rule.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/validation/rules/database-model-rule.ts"],"sourcesContent":["import { invalidRule, VALID_RULE, type SchemaRule } from \"@warlock.js/seal\";\r\nimport { 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"}

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

@@ -0,0 +1,29 @@
+import { resolveModelClass } from "../../model/register-model.mjs";
+import { VALID_RULE, invalidRule } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/rules/exists-rule.ts
+/**
+* Validates that a record exists in the database for the given column/value.
+*
+* @example
+* v.string().exists(Organization, { column: "id" });
+*/
+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);
+		if (query) await query({
+			query: dbQuery,
+			value,
+			allValues: context.allValues
+		});
+		return await dbQuery.first() ? VALID_RULE : invalidRule(this, context);
+	}
+};
+
+//#endregion
+export { existsRule };
+//# sourceMappingURL=exists-rule.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"exists-rule.mjs","names":[],"sources":["../../../../../../../@warlock.js/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,EAAE,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"}

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

@@ -0,0 +1,43 @@
+import { resolveModelClass } from "../../model/register-model.mjs";
+import { get } from "@mongez/reinforcements";
+import { VALID_RULE, invalidRule } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/rules/unique-rule.ts
+/**
+* Validates that a value is unique against a database column.
+*
+* Supports three exclusion modes:
+* - `except`: read a sibling input's value and exclude rows where that
+*   column equals the sibling's value
+* - `exceptColumnName` + `exceptValue`: exclude rows where the named
+*   column equals the supplied value (used by request-aware wrappers)
+* - Custom `query` callback for anything more involved
+*
+* @example
+* v.email().unique("User");
+* v.string().unique("User", { except: "id" });
+*/
+const uniqueRule = {
+	name: "unique",
+	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();
+		dbQuery.where(column, value);
+		if (except) {
+			const exceptVal = get(context.allValues, except);
+			if (exceptVal !== void 0) dbQuery.where(except, "!=", exceptVal);
+		}
+		if (exceptColumnName !== void 0) dbQuery.where(exceptColumnName, "!=", exceptValue);
+		if (query) await query({
+			query: dbQuery,
+			value,
+			allValues: context.allValues
+		});
+		return await dbQuery.first() ? invalidRule(this, context) : VALID_RULE;
+	}
+};
+
+//#endregion
+export { uniqueRule };
+//# sourceMappingURL=unique-rule.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unique-rule.mjs","names":[],"sources":["../../../../../../../@warlock.js/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,EAAE,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"}

package/esm/validation/transformers/embed-model-transformer.mjs

@@ -0,0 +1,17 @@
+import { Model } from "../../model/model.mjs";
+
+//#region ../../@warlock.js/cascade/src/validation/transformers/embed-model-transformer.ts
+const databaseModelTransformer = (value, context) => {
+	const embed = context.options.embed ?? "embedData";
+	if (value instanceof Model === false && !Array.isArray(value)) return value;
+	if (Array.isArray(value)) return value.map((item) => {
+		if (typeof embed === "string") return item[embed];
+		return item.only(embed);
+	});
+	if (typeof embed === "string") return value[embed];
+	return value.only(embed);
+};
+
+//#endregion
+export { databaseModelTransformer };
+//# sourceMappingURL=embed-model-transformer.mjs.map

package/esm/validation/transformers/embed-model-transformer.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"embed-model-transformer.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/validation/transformers/embed-model-transformer.ts"],"sourcesContent":["import { type TransformerCallback } from \"@warlock.js/seal\";\nimport { Model } from \"../../model/model\";\n\nexport const databaseModelTransformer: TransformerCallback = (value, context) => {\n  const embed = context.options.embed ?? \"embedData\";\n\n  if (value instanceof Model === false && !Array.isArray(value)) {\n    return value;\n  }\n\n  if (Array.isArray(value)) {\n    return value.map((item) => {\n      if (typeof embed === \"string\") {\n        return item[embed];\n      }\n\n      return item.only(embed);\n    });\n  }\n\n  if (typeof embed === \"string\") {\n    return (value as any)[embed];\n  }\n\n  return value.only(embed);\n};\n"],"mappings":";;;AAGA,MAAa,4BAAiD,OAAO,YAAY;CAC/E,MAAM,QAAQ,QAAQ,QAAQ,SAAS;CAEvC,IAAI,iBAAiB,UAAU,SAAS,CAAC,MAAM,QAAQ,KAAK,GAC1D,OAAO;CAGT,IAAI,MAAM,QAAQ,KAAK,GACrB,OAAO,MAAM,KAAK,SAAS;EACzB,IAAI,OAAO,UAAU,UACnB,OAAO,KAAK;EAGd,OAAO,KAAK,KAAK,KAAK;CACxB,CAAC;CAGH,IAAI,OAAO,UAAU,UACnB,OAAQ,MAAc;CAGxB,OAAO,MAAM,KAAK,KAAK;AACzB"}

package/esm/validation/types.d.mts

@@ -0,0 +1,43 @@
+import { ChildModel } from "../model/model.types.mjs";
+import { Model } from "../model/model.mjs";
+import { QueryBuilderContract } from "../contracts/query-builder.contract.mjs";
+
+//#region ../../@warlock.js/cascade/src/validation/types.d.ts
+/**
+ * Base options shared by all database-backed validation rules.
+ *
+ * Identifies the model to query, the column to filter on, and an optional
+ * hook to customise the query before the existence/uniqueness check runs.
+ */
+type BaseQueryRuleOptions = {
+  /** The Model to query against */Model: ChildModel<Model> | string; /** Callback to customise the query before it executes */
+  query?: (options: {
+    query: QueryBuilderContract;
+    value: any;
+    allValues: any;
+  }) => void | Promise<void>; /** The column to filter by (defaults to the validated key) */
+  column?: string;
+};
+/**
+ * Base options for uniqueness validation rules.
+ */
+type BaseUniqueRuleOptions = BaseQueryRuleOptions;
+/**
+ * Options for the `unique` validation rule.
+ *
+ * Accepts an optional `except` sibling-key for "unique except this other
+ * input's value", or an explicit `exceptColumnName` / `exceptValue` pair
+ * used by request-aware wrappers (e.g. core's `uniqueExceptCurrentUser`).
+ */
+type UniqueRuleOptions = BaseUniqueRuleOptions & {
+  /** Sibling input key to exclude from the uniqueness check */except?: string; /** Column name to exclude (paired with `exceptValue`) */
+  exceptColumnName?: string; /** Value to exclude under `exceptColumnName` */
+  exceptValue?: any;
+};
+/**
+ * Options for the `exists` validation rule.
+ */
+type ExistsRuleOptions = BaseQueryRuleOptions;
+//#endregion
+export { BaseQueryRuleOptions, BaseUniqueRuleOptions, ExistsRuleOptions, UniqueRuleOptions };
+//# sourceMappingURL=types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/validation/types.ts"],"mappings":";;;;;;;;AASA;;;KAAY,oBAAA;EAEH,iCAAP,KAAA,EAAO,UAAA,CAAW,KAAA,YAML;EAJb,KAAA,IAAS,OAAA;IACP,KAAA,EAAO,oBAAA;IACP,KAAA;IACA,SAAA;EAAA,aACW,OAAA,QAJb;EAMA,MAAA;AAAA;;;;KAMU,qBAAA,GAAwB,oBAAoB;;;AANhD;AAMR;;;;KASY,iBAAA,GAAoB,qBAAqB;EAAzC,6DAEV,MAAA;EAEA,gBAAA,WAJ8B;EAM9B,WAAA;AAAA;;;AAAW;KAMD,iBAAA,GAAoB,oBAAoB"}

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

@@ -0,0 +1,25 @@
+import { ChildModel } from "../../model/model.types.mjs";
+import { BaseValidator } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/validators/embed-validator.d.ts
+declare class EmbedModelValidator extends BaseValidator {
+  /**
+   * Check if value is a string type
+   */
+  matchesType(value: any): boolean;
+  /**
+   * Mutate the value to be a model, also fail if the mutated value is not a valid model
+   */
+  model(model: ChildModel<any> | string, errorMessage?: string): EmbedModelValidator;
+  /**
+   * Validate the value is a list of models
+   */
+  models(model: ChildModel<any> | string, errorMessage?: string): EmbedModelValidator;
+  /**
+   * Determine how the data will be stored as an embedded document
+   */
+  embed(embed?: string | string[]): EmbedModelValidator;
+}
+//#endregion
+export { EmbedModelValidator };
+//# sourceMappingURL=embed-validator.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embed-validator.d.mts","names":[],"sources":["../../../../../../../@warlock.js/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"}

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

@@ -0,0 +1,42 @@
+import { databaseModelMutator, databaseModelsMutator } from "../mutators/embed-mutator.mjs";
+import { databaseModelRule, databaseModelsRule } from "../rules/database-model-rule.mjs";
+import { databaseModelTransformer } from "../transformers/embed-model-transformer.mjs";
+import { Model } from "../../model/model.mjs";
+import { BaseValidator, arrayRule } from "@warlock.js/seal";
+
+//#region ../../@warlock.js/cascade/src/validation/validators/embed-validator.ts
+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);
+	}
+	/**
+	* Mutate the value to be a model, also fail if the mutated value is not a valid model
+	*/
+	model(model, errorMessage) {
+		this.addMutator(databaseModelMutator, { model });
+		return this.addRule(databaseModelRule, errorMessage, { model });
+	}
+	/**
+	* Validate the value is a list of models
+	*/
+	models(model, errorMessage) {
+		const instance = this.instance;
+		instance.addMutator(databaseModelsMutator, { model });
+		instance.addMutableRule(arrayRule);
+		instance.addMutableRule(databaseModelsRule, errorMessage, { model });
+		return instance;
+	}
+	/**
+	* Determine how the data will be stored as an embedded document
+	*/
+	embed(embed) {
+		return this.addTransformer(databaseModelTransformer, { embed });
+	}
+};
+
+//#endregion
+export { EmbedModelValidator };
+//# sourceMappingURL=embed-validator.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"embed-validator.mjs","names":[],"sources":["../../../../../../../@warlock.js/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"}

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

@@ -0,0 +1,178 @@
+import { Model } from "../model/model.mjs";
+import { WriterContract, WriterOptions, WriterResult } from "../contracts/database-writer.contract.mjs";
+
+//#region ../../@warlock.js/cascade/src/writer/database-writer.d.ts
+/**
+ * Database writer service that orchestrates model persistence.
+ *
+ * Handles the complete save pipeline:
+ * 1. Check for changes (skip if no changes and not new)
+ * 2. Emit `saving` event (for data enrichment)
+ * 3. Emit `validating` event
+ * 4. Validate and cast data via @warlock.js/seal schema
+ * 5. Emit `validated` event
+ * 6. Generate ID (for new NoSQL records)
+ * 7. Emit `creating`/`updating` events
+ * 8. Execute insert or update via driver
+ * 9. Merge returned data into model
+ * 10. Reset dirty tracker and update `isNew` flag
+ * 11. Emit `saved` and `created`/`updated` events
+ *
+ * @example
+ * ```typescript
+ * const user = new User({ name: "Alice", email: "alice@example.com" });
+ * const writer = new DatabaseWriter(user);
+ * await writer.save();
+ *
+ * console.log(user.get("id")); // 1 (auto-generated)
+ * console.log(user.get("_id")); // ObjectId("...")
+ *
+ * // Update existing record
+ * user.set("name", "Alice Smith");
+ * await writer.save();
+ * // Only updates the "name" field (partial update)
+ *
+ * // Silent save (no events)
+ * await writer.save({ skipEvents: true });
+ * ```
+ */
+declare class DatabaseWriter implements WriterContract {
+  /** The model instance being persisted */
+  private readonly model;
+  /** Model constructor reference */
+  private readonly ctor;
+  /** Data source containing driver and ID generator */
+  private readonly dataSource;
+  /** Database driver for executing queries */
+  private readonly driver;
+  /** Table/collection name */
+  private readonly table;
+  /** Primary key field name */
+  private readonly primaryKey;
+  /** Validation schema (if defined) */
+  private readonly schema?;
+  /** Strict mode configuration */
+  private readonly strictMode;
+  /**
+   * Create a new writer instance for a model.
+   *
+   * @param model - The model instance to persist
+   *
+   * @example
+   * ```typescript
+   * const user = new User({ name: "Alice" });
+   * const writer = new DatabaseWriter(user);
+   * await writer.save();
+   * ```
+   */
+  constructor(model: Model);
+  /**
+   * Save the model instance to the database.
+   *
+   * @param options - Save options
+   * @returns Result with success status, document, and metadata
+   * @throws {ValidationError} If validation fails
+   */
+  save(options?: WriterOptions): Promise<WriterResult>;
+  /**
+   * Validate and cast model data using the schema.
+   *
+   * Updates the model's data in-place with validated/casted values.
+   *
+   * @param isInsert - Whether this is an insert operation
+   * @param options - Save options
+   * @throws {ValidationError} If validation fails
+   * @private
+   */
+  private validateAndCast;
+  /**
+   * Perform an insert operation.
+   *
+   * @param options - Save options
+   * @returns Insert result
+   * @private
+   */
+  private performInsert;
+  /**
+   * Perform an update operation.
+   *
+   * @param options - Save options
+   * @returns Update result
+   * @private
+   */
+  private performUpdate;
+  /**
+   * Generate ID for the model if auto-generation is enabled.
+   *
+   * @private
+   */
+  generateNextId(): Promise<void>;
+  /**
+   * Build update operations from the model's dirty tracker.
+   *
+   * Handles both modified fields ($set) and removed fields ($unset).
+   *
+   * @returns Update operations for the driver
+   * @private
+   *
+   * @example
+   * ```typescript
+   * // Model with changes
+   * user.set("name", "Alice");
+   * user.unset("tempField");
+   *
+   * const operations = this.buildUpdateOperations();
+   * // {
+   * //   $set: { name: "Alice" },
+   * //   $unset: { tempField: 1 }
+   * // }
+   * ```
+   */
+  private buildUpdateOperations;
+  /**
+   * Resolve the initial ID from model configuration.
+   *
+   * Priority:
+   * 1. Model.initialId (explicit value)
+   * 2. Model.randomInitialId (random or function)
+   * 3. Default: 1
+   *
+   * @returns The initial ID value
+   * @private
+   */
+  private resolveInitialId;
+  /**
+   * Resolve the increment value from model configuration.
+   *
+   * Priority:
+   * 1. Model.incrementIdBy (explicit value)
+   * 2. Model.randomIncrement (random or function)
+   * 3. Default: 1
+   *
+   * @returns The increment value
+   * @private
+   */
+  private resolveIncrementBy;
+  /**
+   * Generate a random integer between min and max (inclusive).
+   *
+   * @param min - Minimum value
+   * @param max - Maximum value
+   * @returns Random integer
+   * @private
+   */
+  private randomInt;
+  /**
+   * Trigger sync operations after successful save.
+   *
+   * Emits a model.updated event that ModelSyncOperation listens to.
+   * The sync is handled by registered sync operations, not directly here.
+   *
+   * @param changedFields - Fields that were changed (for filtering)
+   * @private
+   */
+  private triggerSync;
+}
+//#endregion
+export { DatabaseWriter };
+//# sourceMappingURL=database-writer.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"database-writer.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/writer/database-writer.ts"],"mappings":";;;;;;AAqDA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAAa,cAAA,YAA0B,cAAA;EA0U7B;EAAA,iBAxUS,KAAA;EAwYT;EAAA,iBArYS,IAAA;EAwaH;EAAA,iBAraG,UAAA;EAqaQ;EAAA,iBAlaR,MAAA;;mBAGA,KAAA;;mBAGA,UAAA;;mBAGA,MAAA;;mBAGA,UAAA;;;;;;;;;;;;;cAcE,KAAA,EAAO,KAAA;;;;;;;;EAkBb,IAAA,CAAK,OAAA,GAAS,aAAA,GAAqB,OAAA,CAAQ,YAAA;;;;;;;;;;;UAoE1C,eAAA;;;;;;;;UAuEA,aAAA;;;;;;;;UAgDA,aAAA;;;;;;EA2CD,cAAA,CAAA,GAAkB,OAAA;;;;;;;;;;;;;;;;;;;;;;UA6CvB,qBAAA;;;;;;;;;;;;UAuCA,gBAAA;;;;;;;;;;;;UAyBA,kBAAA;;;;;;;;;UAsBA,SAAA;;;;;;;;;;UAaM,WAAA;AAAA"}