npm - @warlock.js/cascade - Versions diffs - 5.28.0 → 5.30.0 - Mend

@warlock.js/cascade 5.28.0 → 5.30.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (393) hide show

package/esm/utils/database-writer.utils.d.mts CHANGED Viewed

@@ -1,7 +1,7 @@
 import { Model } from "../model/model.mjs";
 import { TransformerCallback } from "@warlock.js/seal";
-//#region ../cascade/src/utils/database-writer.utils.d.ts
+//#region ../../packages/cascade/src/utils/database-writer.utils.d.ts
 type transformCallbackOptions = {
   model: Model;
   column: string;

package/esm/utils/database-writer.utils.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"database-writer.utils.d.mts","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/database-writer.utils.ts"],"mappings":";;;;KAGK,wBAAA;EACH,KAAA,EAAO,KAAK;EACZ,MAAA;EACA,KAAA;EACA,SAAA;EACA,KAAA;AAAA;AAAA,KAGU,sBAAA,IAA0B,OAAA,EAAS,wBAAA,eAAuC,OAAO;;;;iBAK7E,mBAAA,CAAoB,QAAA,EAAU,sBAAA,GAAsB,mBAAA"}
1	+ {"version":3,"file":"database-writer.utils.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/database-writer.utils.ts"],"mappings":";;;;KAGK,wBAAA;EACH,KAAA,EAAO,KAAK;EACZ,MAAA;EACA,KAAA;EACA,SAAA;EACA,KAAA;AAAA;AAAA,KAGU,sBAAA,IAA0B,OAAA,EAAS,wBAAA,eAAuC,OAAO;;;;iBAK7E,mBAAA,CAAoB,QAAA,EAAU,sBAAA,GAAsB,mBAAA"}

package/esm/utils/database-writer.utils.mjs CHANGED Viewed

@@ -1,4 +1,4 @@
-//#region ../cascade/src/utils/database-writer.utils.ts
+//#region ../../packages/cascade/src/utils/database-writer.utils.ts
 /**
 * Transfer value before saving it into the database
 */

package/esm/utils/database-writer.utils.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"database-writer.utils.mjs","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/database-writer.utils.ts"],"sourcesContent":["import { type TransformerCallback } from \"@warlock.js/seal\";\nimport { type Model } from \"../model/model\";\n\ntype transformCallbackOptions = {\n model: Model;\n column: string;\n value: any;\n isChanged: boolean;\n isNew: boolean;\n};\n\nexport type ModelTransformCallback = (options: transformCallbackOptions) => unknown \| Promise<unknown>;\n\n/*\n Transfer value before saving it into the database\n */\nexport function useModelTransformer(callback: ModelTransformCallback) {\n const transformCallback: TransformerCallback = (data, { context }) => {\n const model = context.rootContext?.model as Model \| undefined;\n\n // No model (e.g. the schema is reused to validate a request body): nothing to transform\n if (!model) return data;\n\n const column = context.key;\n const value = data;\n const isChanged = model.isDirty(column);\n const isNew = model.isNew;\n return callback({ model, column, value, isChanged, isNew });\n };\n\n return transformCallback;\n}\n"],"mappings":";;;;AAgBA,SAAgB,oBAAoB,UAAkC;CACpE,MAAM,qBAA0C,MAAM,EAAE,cAAc;EACpE,MAAM,QAAQ,QAAQ,aAAa;EAGnC,IAAI,CAAC,OAAO,OAAO;EAEnB,MAAM,SAAS,QAAQ;EACvB,MAAM,QAAQ;EACd,MAAM,YAAY,MAAM,QAAQ,MAAM;EACtC,MAAM,QAAQ,MAAM;EACpB,OAAO,SAAS;GAAE;GAAO;GAAQ;GAAO;GAAW;EAAM,CAAC;CAC5D;CAEA,OAAO;AACT"}
1	+ {"version":3,"file":"database-writer.utils.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/database-writer.utils.ts"],"sourcesContent":["import { type TransformerCallback } from \"@warlock.js/seal\";\nimport { type Model } from \"../model/model\";\n\ntype transformCallbackOptions = {\n model: Model;\n column: string;\n value: any;\n isChanged: boolean;\n isNew: boolean;\n};\n\nexport type ModelTransformCallback = (options: transformCallbackOptions) => unknown \| Promise<unknown>;\n\n/*\n Transfer value before saving it into the database\n */\nexport function useModelTransformer(callback: ModelTransformCallback) {\n const transformCallback: TransformerCallback = (data, { context }) => {\n const model = context.rootContext?.model as Model \| undefined;\n\n // No model (e.g. the schema is reused to validate a request body): nothing to transform\n if (!model) return data;\n\n const column = context.key;\n const value = data;\n const isChanged = model.isDirty(column);\n const isNew = model.isNew;\n return callback({ model, column, value, isChanged, isNew });\n };\n\n return transformCallback;\n}\n"],"mappings":";;;;AAgBA,SAAgB,oBAAoB,UAAkC;CACpE,MAAM,qBAA0C,MAAM,EAAE,cAAc;EACpE,MAAM,QAAQ,QAAQ,aAAa;EAGnC,IAAI,CAAC,OAAO,OAAO;EAEnB,MAAM,SAAS,QAAQ;EACvB,MAAM,QAAQ;EACd,MAAM,YAAY,MAAM,QAAQ,MAAM;EACtC,MAAM,QAAQ,MAAM;EACpB,OAAO,SAAS;GAAE;GAAO;GAAQ;GAAO;GAAW;EAAM,CAAC;CAC5D;CAEA,OAAO;AACT"}

package/esm/utils/define-model.d.mts CHANGED Viewed

@@ -3,7 +3,7 @@ import { ModelSchema } from "../model/model.types.mjs";
 import { Model } from "../model/model.mjs";
 import { Infer, ObjectValidator } from "@warlock.js/seal";
-//#region ../cascade/src/utils/define-model.d.ts
+//#region ../../packages/cascade/src/utils/define-model.d.ts
 /**
  * Configuration options for defining a model.
  */

package/esm/utils/define-model.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"define-model.d.mts","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/define-model.ts"],"mappings":";;;;;;;;AASA;KAAY,kBAAA,iBAAmC,WAAA;EAAjB;;;EAI5B,KAAA;EAiCa;;;;EA3Bb,IAAA;EA2FU;;;;EArFV,MAAA,EAAQ,eAAA;EAZR;;;;;;;;;;EAwBA,cAAA,GAAiB,cAAA;EAuDjB;;;;;;;EA9CA,UAAA,GAAa,UAAA;EAgEG;AA2DlB;;;;;EAnHE,cAAA;EAsHoB;;;;;EA/GpB,eAAA;EAoH8B;;;;;EA7G9B,SAAA;EA8G4B;;;;;;;;;;;;;;;;;;;;;;EAtF5B,UAAA,GAAa,QAAA,CAAS,KAAA,CAAM,OAAA,KAAY,MAAA;EAiFvB;;;;;;;;;;;;;;;;EA/DjB,OAAA,GAAU,MAAA;AAAA;;;;;;;;;;;;;;;;;AA8IwE;AAwBpF;;;;;;;;;;;;;;;;;;;;AAIO;;;;;;;;;;;;;;;;;;;iBA/GS,WAAA,iBACE,WAAA,2BACS,eAAA,GAAkB,eAAA,sBACvB,MAAA,qCACH,MAAA,oBAEjB,OAAA,EAAS,kBAAA,CAAmB,OAAA;EAC1B,MAAA,EAAQ,gBAAA;EACR,UAAA,GAAa,QAAA,CAAS,KAAA,CAAM,KAAA,CAAM,MAAA,CAAO,gBAAA,MAAsB,WAAA;EAC/D,OAAA,GAAU,QAAA,QAAgB,KAAA,CAAM,KAAA,CAAM,MAAA,CAAO,gBAAA,MAAsB,QAAA;AAAA,UACpE,WAAA,GAyEoB,OAAA,CAAO,KAAA,CAAA,MAAA,CAAA,gBAAA,OAAmB,KAAA,CAAK,KAAA,CAAA,MAAA,CAAA,gBAAA,KAAmB,WAAA,IAAW,IAAA,QAAA,KAAA,WAAA,QAAA;;;;;;;;;;;;;;;;;;KAwBxE,SAAA,WAAoB,UAAA,QAAkB,WAAA,KAAgB,CAAA,kBAC7D,IAAA,uBAED,CAAA,SAAU,KAAA,YACR,CAAA"}
1	+ {"version":3,"file":"define-model.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/define-model.ts"],"mappings":";;;;;;;;AASA;KAAY,kBAAA,iBAAmC,WAAA;EAAjB;;;EAI5B,KAAA;EAiCa;;;;EA3Bb,IAAA;EA2FU;;;;EArFV,MAAA,EAAQ,eAAA;EAZR;;;;;;;;;;EAwBA,cAAA,GAAiB,cAAA;EAuDjB;;;;;;;EA9CA,UAAA,GAAa,UAAA;EAgEG;AA2DlB;;;;;EAnHE,cAAA;EAsHoB;;;;;EA/GpB,eAAA;EAoH8B;;;;;EA7G9B,SAAA;EA8G4B;;;;;;;;;;;;;;;;;;;;;;EAtF5B,UAAA,GAAa,QAAA,CAAS,KAAA,CAAM,OAAA,KAAY,MAAA;EAiFvB;;;;;;;;;;;;;;;;EA/DjB,OAAA,GAAU,MAAA;AAAA;;;;;;;;;;;;;;;;;AA8IwE;AAwBpF;;;;;;;;;;;;;;;;;;;;AAIO;;;;;;;;;;;;;;;;;;;iBA/GS,WAAA,iBACE,WAAA,2BACS,eAAA,GAAkB,eAAA,sBACvB,MAAA,qCACH,MAAA,oBAEjB,OAAA,EAAS,kBAAA,CAAmB,OAAA;EAC1B,MAAA,EAAQ,gBAAA;EACR,UAAA,GAAa,QAAA,CAAS,KAAA,CAAM,KAAA,CAAM,MAAA,CAAO,gBAAA,MAAsB,WAAA;EAC/D,OAAA,GAAU,QAAA,QAAgB,KAAA,CAAM,KAAA,CAAM,MAAA,CAAO,gBAAA,MAAsB,QAAA;AAAA,UACpE,WAAA,GAyEoB,OAAA,CAAO,KAAA,CAAA,MAAA,CAAA,gBAAA,OAAmB,KAAA,CAAK,KAAA,CAAA,MAAA,CAAA,gBAAA,KAAmB,WAAA,IAAW,IAAA,QAAA,KAAA,WAAA,QAAA;;;;;;;;;;;;;;;;;;KAwBxE,SAAA,WAAoB,UAAA,QAAkB,WAAA,KAAgB,CAAA,kBAC7D,IAAA,uBAED,CAAA,SAAU,KAAA,YACR,CAAA"}

package/esm/utils/define-model.mjs CHANGED Viewed

@@ -1,7 +1,7 @@
 import { registerModelInRegistry } from "../model/register-model.mjs";
 import { Model } from "../model/model.mjs";
-//#region ../cascade/src/utils/define-model.ts
+//#region ../../packages/cascade/src/utils/define-model.ts
 /**
 * Define a model with a clean, concise API.
 *

package/esm/utils/define-model.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"define-model.mjs","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/define-model.ts"],"sourcesContent":["import type { Infer, ObjectValidator } from \"@warlock.js/seal\";\nimport type { ModelSchema } from \"../model/model\";\nimport { Model } from \"../model/model\";\nimport { registerModelInRegistry } from \"../model/register-model\";\nimport type { DeleteStrategy, StrictMode } from \"../types\";\n\n/*\n Configuration options for defining a model.\n /\nexport type DefineModelOptions<TSchema extends ModelSchema> = {\n /\n The database table/collection name.\n /\n table: string;\n\n /\n Model name\n * If provided, it will be registered in the models registery\n /\n name?: string;\n\n /\n The validation schema for the model.\n * Use `v.object()` from @warlock.js/seal to define the schema.\n /\n schema: ObjectValidator;\n\n /\n Delete strategy for this model. Controls how `destroy()` handles records.\n \n - `\"trash\"` — Moves the record to a trash table/collection, then deletes from the source.\n * - `\"permanent\"` — Hard delete. The record is removed from the database.\n * - `\"soft\"` — Sets a `deletedAt` timestamp; the row stays in place.\n \n When omitted, the runtime resolves the strategy in this priority order:\n * `destroy()` call options → this model's static → data source `defaultDeleteStrategy` → `\"permanent\"`.\n /\n deleteStrategy?: DeleteStrategy;\n\n /\n Behavior when the model is asked to write a field that is not declared in `schema`.\n \n - `\"strip\"` — Drop unknown fields silently (default).\n * - `\"fail\"` — Throw a validation error on unknown fields.\n * - `\"allow\"` — Pass unknown fields through to the database as-is.\n /\n strictMode?: StrictMode;\n\n /\n Auto-generate a sequential `id` field on insert (NoSQL only).\n \n SQL drivers use native AUTO_INCREMENT and ignore this. When omitted, the\n * MongoDB driver defaults to `true`; the PostgreSQL driver defaults to `false`.\n /\n autoGenerateId?: boolean;\n\n /\n Use a random increment (1–10) instead of a fixed step when auto-generating IDs.\n \n When omitted, falls through to the driver/data-source default.\n /\n randomIncrement?: boolean;\n\n /\n Initial ID value for the first record when auto-generating IDs.\n \n When omitted, falls through to the driver/data-source default (typically `1`).\n /\n initialId?: number;\n\n /\n Optional: Custom instance properties (getters/setters/methods).\n * Define computed properties, custom getters, or instance methods.\n \n The `this` context will be the Model instance, giving you access to\n * all Model methods like `get()`, `set()`, `save()`, etc.\n \n @example\n * ```typescript\n * properties: {\n * get fullName(this: Model<UserSchema>) {\n * return `${this.get(\"firstName\")} ${this.get(\"lastName\")}`;\n * },\n * get isActive(this: Model<UserSchema>) {\n * return this.get(\"status\") === \"active\";\n * },\n * async sendEmail(this: Model<UserSchema>, subject: string) {\n * // this.get(), this.save(), etc. all work!\n * },\n * }\n * ```\n /\n properties?: ThisType<Model<TSchema>> & Record<string, any>;\n\n /\n Optional: Custom static methods.\n * Define class-level methods like custom finders or utilities.\n \n @example\n * ```typescript\n * statics: {\n * async findByEmail(email: string) {\n * return this.first({ email });\n * },\n * async findActive() {\n * return this.query().where(\"status\", \"active\").get();\n * },\n * }\n * ```\n /\n statics?: Record<string, any>;\n};\n\n/\n Define a model with a clean, concise API.\n \n This utility function creates a Model class with the specified configuration,\n * reducing boilerplate and providing a more declarative way to define models.\n \n @param options - Model configuration options\n * @returns A Model class with the specified configuration\n \n @example\n * ```typescript\n * import { defineModel } from \"@warlock.js/cascade\";\n * import { v } from \"@warlock.js/seal\";\n \n export const User = defineModel({\n * table: \"users\",\n * schema: v.object({\n * name: v.string().required().trim(),\n * email: v.string().email().required().lowercase(),\n * password: v.string().required().min(6),\n * role: v.string().default(\"user\"),\n * }),\n * deleteStrategy: \"soft\",\n * });\n \n // Usage\n * const user = await User.create({\n * name: \"John Doe\",\n * email: \"john@example.com\",\n * password: \"secret123\",\n * });\n * ```\n \n @example\n * ```typescript\n * // With type inference\n * export const Post = defineModel({\n * table: \"posts\",\n * schema: v.object({\n * title: v.string().required(),\n * content: v.string().required(),\n * authorId: v.number().required(),\n * published: v.boolean().default(false),\n * }),\n * });\n \n // TypeScript knows the exact type!\n * const post = await Post.create({\n * title: \"Hello World\",\n * content: \"My first post\",\n * authorId: 1,\n * });\n \n console.log(post.title); // ✅ Type-safe!\n * ```\n /\nexport function defineModel<\n TSchema extends ModelSchema,\n TSchemaValidator extends ObjectValidator = ObjectValidator,\n TProperties extends Record<string, any> = {},\n TStatics extends Record<string, any> = {},\n>(\n options: DefineModelOptions<TSchema> & {\n schema: TSchemaValidator;\n properties?: ThisType<Model<Infer.Output<TSchemaValidator>>> & TProperties;\n statics?: ThisType<typeof Model<Infer.Output<TSchemaValidator>>> & TStatics;\n },\n) {\n type InferredSchema = Infer.Output<TSchemaValidator>;\n\n class DefinedModel extends Model<InferredSchema> {\n /\n Table/collection name\n /\n public static table = options.table;\n\n /\n Validation schema\n /\n public static schema = options.schema;\n\n /\n Delete strategy. When undefined, the runtime resolves via call options →\n * data source `defaultDeleteStrategy` → `\"permanent\"`.\n /\n public static deleteStrategy: DeleteStrategy \| undefined = options.deleteStrategy;\n\n /\n Random increment for auto-generated IDs. When undefined, falls through\n * to the data-source default.\n /\n public static randomIncrement: boolean \| undefined = options.randomIncrement;\n\n /\n Initial ID value for the first record when auto-generating IDs. When\n * undefined, falls through to the data-source default.\n /\n public static initialId: number \| undefined = options.initialId;\n }\n\n // Only set when provided: the base Model owns the framework fallback,\n // and an own `undefined` would shadow it and block data-source defaults.\n if (options.strictMode !== undefined) {\n DefinedModel.strictMode = options.strictMode;\n }\n\n if (options.autoGenerateId !== undefined) {\n DefinedModel.autoGenerateId = options.autoGenerateId;\n }\n\n // Apply custom instance properties (getters/setters/methods)\n if (options.properties) {\n Object.defineProperties(\n DefinedModel.prototype,\n Object.getOwnPropertyDescriptors(options.properties),\n );\n }\n\n if (options.name) {\n registerModelInRegistry(options.name, DefinedModel);\n }\n\n // Apply custom static methods\n if (options.statics) {\n Object.defineProperties(DefinedModel, Object.getOwnPropertyDescriptors(options.statics));\n }\n\n // Return with proper type inference.\n //\n // The constructed type references the EXPORTED `Model` (instance + statics)\n // rather than the local `DefinedModel` class. `DefinedModel` is declared\n // inside this function, so emitting it into the public `.d.ts` would force the\n // declaration emitter to inline it as an anonymous class type — which fails\n // with TS4094 (\"anonymous class type may not be private or protected\", from\n // Model's `protected isActiveColumn`) and crashes the dts bundler on Model's\n // getters. `DefinedModel` adds no instance members over `Model<InferredSchema>`\n // and no statics beyond those already declared on `Model`, so this is a\n // faithful, emittable equivalent of the previously-inferred return type.\n type DefinedModelClass = {\n new (initialData?: Partial<InferredSchema>): Model<InferredSchema> & TProperties;\n } & Omit<typeof Model, \"new\"> &\n TStatics;\n\n return DefinedModel as unknown as DefinedModelClass;\n}\n\n/\n Type helper to infer the schema type from a defined model.\n \n @example\n * ```typescript\n * const User = defineModel({\n * table: \"users\",\n * schema: v.object({\n * name: v.string(),\n * email: v.string(),\n * }),\n * });\n \n type UserType = ModelType<typeof User>;\n * // { name: string; email: string; }\n * ```\n */\nexport type ModelType<T extends ReturnType<typeof defineModel>> = T extends new (\n ...args: any[]\n) => infer R\n ? R extends Model<infer S>\n ? S\n : never\n : never;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyKA,SAAgB,YAMd,SAKA;CAGA,MAAM,qBAAqB,MAAsB;;;;EAI/C,OAAc,QAAQ,QAAQ;;;;EAK9B,OAAc,SAAS,QAAQ;;;;;EAM/B,OAAc,iBAA6C,QAAQ;;;;;EAMnE,OAAc,kBAAuC,QAAQ;;;;;EAM7D,OAAc,YAAgC,QAAQ;CACxD;CAIA,IAAI,QAAQ,eAAe,QACzB,aAAa,aAAa,QAAQ;CAGpC,IAAI,QAAQ,mBAAmB,QAC7B,aAAa,iBAAiB,QAAQ;CAIxC,IAAI,QAAQ,YACV,OAAO,iBACL,aAAa,WACb,OAAO,0BAA0B,QAAQ,UAAU,CACrD;CAGF,IAAI,QAAQ,MACV,wBAAwB,QAAQ,MAAM,YAAY;CAIpD,IAAI,QAAQ,SACV,OAAO,iBAAiB,cAAc,OAAO,0BAA0B,QAAQ,OAAO,CAAC;CAmBzF,OAAO;AACT"}
1	+ {"version":3,"file":"define-model.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/define-model.ts"],"sourcesContent":["import type { Infer, ObjectValidator } from \"@warlock.js/seal\";\nimport type { ModelSchema } from \"../model/model\";\nimport { Model } from \"../model/model\";\nimport { registerModelInRegistry } from \"../model/register-model\";\nimport type { DeleteStrategy, StrictMode } from \"../types\";\n\n/*\n Configuration options for defining a model.\n /\nexport type DefineModelOptions<TSchema extends ModelSchema> = {\n /\n The database table/collection name.\n /\n table: string;\n\n /\n Model name\n * If provided, it will be registered in the models registery\n /\n name?: string;\n\n /\n The validation schema for the model.\n * Use `v.object()` from @warlock.js/seal to define the schema.\n /\n schema: ObjectValidator;\n\n /\n Delete strategy for this model. Controls how `destroy()` handles records.\n \n - `\"trash\"` — Moves the record to a trash table/collection, then deletes from the source.\n * - `\"permanent\"` — Hard delete. The record is removed from the database.\n * - `\"soft\"` — Sets a `deletedAt` timestamp; the row stays in place.\n \n When omitted, the runtime resolves the strategy in this priority order:\n * `destroy()` call options → this model's static → data source `defaultDeleteStrategy` → `\"permanent\"`.\n /\n deleteStrategy?: DeleteStrategy;\n\n /\n Behavior when the model is asked to write a field that is not declared in `schema`.\n \n - `\"strip\"` — Drop unknown fields silently (default).\n * - `\"fail\"` — Throw a validation error on unknown fields.\n * - `\"allow\"` — Pass unknown fields through to the database as-is.\n /\n strictMode?: StrictMode;\n\n /\n Auto-generate a sequential `id` field on insert (NoSQL only).\n \n SQL drivers use native AUTO_INCREMENT and ignore this. When omitted, the\n * MongoDB driver defaults to `true`; the PostgreSQL driver defaults to `false`.\n /\n autoGenerateId?: boolean;\n\n /\n Use a random increment (1–10) instead of a fixed step when auto-generating IDs.\n \n When omitted, falls through to the driver/data-source default.\n /\n randomIncrement?: boolean;\n\n /\n Initial ID value for the first record when auto-generating IDs.\n \n When omitted, falls through to the driver/data-source default (typically `1`).\n /\n initialId?: number;\n\n /\n Optional: Custom instance properties (getters/setters/methods).\n * Define computed properties, custom getters, or instance methods.\n \n The `this` context will be the Model instance, giving you access to\n * all Model methods like `get()`, `set()`, `save()`, etc.\n \n @example\n * ```typescript\n * properties: {\n * get fullName(this: Model<UserSchema>) {\n * return `${this.get(\"firstName\")} ${this.get(\"lastName\")}`;\n * },\n * get isActive(this: Model<UserSchema>) {\n * return this.get(\"status\") === \"active\";\n * },\n * async sendEmail(this: Model<UserSchema>, subject: string) {\n * // this.get(), this.save(), etc. all work!\n * },\n * }\n * ```\n /\n properties?: ThisType<Model<TSchema>> & Record<string, any>;\n\n /\n Optional: Custom static methods.\n * Define class-level methods like custom finders or utilities.\n \n @example\n * ```typescript\n * statics: {\n * async findByEmail(email: string) {\n * return this.first({ email });\n * },\n * async findActive() {\n * return this.query().where(\"status\", \"active\").get();\n * },\n * }\n * ```\n /\n statics?: Record<string, any>;\n};\n\n/\n Define a model with a clean, concise API.\n \n This utility function creates a Model class with the specified configuration,\n * reducing boilerplate and providing a more declarative way to define models.\n \n @param options - Model configuration options\n * @returns A Model class with the specified configuration\n \n @example\n * ```typescript\n * import { defineModel } from \"@warlock.js/cascade\";\n * import { v } from \"@warlock.js/seal\";\n \n export const User = defineModel({\n * table: \"users\",\n * schema: v.object({\n * name: v.string().required().trim(),\n * email: v.string().email().required().lowercase(),\n * password: v.string().required().min(6),\n * role: v.string().default(\"user\"),\n * }),\n * deleteStrategy: \"soft\",\n * });\n \n // Usage\n * const user = await User.create({\n * name: \"John Doe\",\n * email: \"john@example.com\",\n * password: \"secret123\",\n * });\n * ```\n \n @example\n * ```typescript\n * // With type inference\n * export const Post = defineModel({\n * table: \"posts\",\n * schema: v.object({\n * title: v.string().required(),\n * content: v.string().required(),\n * authorId: v.number().required(),\n * published: v.boolean().default(false),\n * }),\n * });\n \n // TypeScript knows the exact type!\n * const post = await Post.create({\n * title: \"Hello World\",\n * content: \"My first post\",\n * authorId: 1,\n * });\n \n console.log(post.title); // ✅ Type-safe!\n * ```\n /\nexport function defineModel<\n TSchema extends ModelSchema,\n TSchemaValidator extends ObjectValidator = ObjectValidator,\n TProperties extends Record<string, any> = {},\n TStatics extends Record<string, any> = {},\n>(\n options: DefineModelOptions<TSchema> & {\n schema: TSchemaValidator;\n properties?: ThisType<Model<Infer.Output<TSchemaValidator>>> & TProperties;\n statics?: ThisType<typeof Model<Infer.Output<TSchemaValidator>>> & TStatics;\n },\n) {\n type InferredSchema = Infer.Output<TSchemaValidator>;\n\n class DefinedModel extends Model<InferredSchema> {\n /\n Table/collection name\n /\n public static table = options.table;\n\n /\n Validation schema\n /\n public static schema = options.schema;\n\n /\n Delete strategy. When undefined, the runtime resolves via call options →\n * data source `defaultDeleteStrategy` → `\"permanent\"`.\n /\n public static deleteStrategy: DeleteStrategy \| undefined = options.deleteStrategy;\n\n /\n Random increment for auto-generated IDs. When undefined, falls through\n * to the data-source default.\n /\n public static randomIncrement: boolean \| undefined = options.randomIncrement;\n\n /\n Initial ID value for the first record when auto-generating IDs. When\n * undefined, falls through to the data-source default.\n /\n public static initialId: number \| undefined = options.initialId;\n }\n\n // Only set when provided: the base Model owns the framework fallback,\n // and an own `undefined` would shadow it and block data-source defaults.\n if (options.strictMode !== undefined) {\n DefinedModel.strictMode = options.strictMode;\n }\n\n if (options.autoGenerateId !== undefined) {\n DefinedModel.autoGenerateId = options.autoGenerateId;\n }\n\n // Apply custom instance properties (getters/setters/methods)\n if (options.properties) {\n Object.defineProperties(\n DefinedModel.prototype,\n Object.getOwnPropertyDescriptors(options.properties),\n );\n }\n\n if (options.name) {\n registerModelInRegistry(options.name, DefinedModel);\n }\n\n // Apply custom static methods\n if (options.statics) {\n Object.defineProperties(DefinedModel, Object.getOwnPropertyDescriptors(options.statics));\n }\n\n // Return with proper type inference.\n //\n // The constructed type references the EXPORTED `Model` (instance + statics)\n // rather than the local `DefinedModel` class. `DefinedModel` is declared\n // inside this function, so emitting it into the public `.d.ts` would force the\n // declaration emitter to inline it as an anonymous class type — which fails\n // with TS4094 (\"anonymous class type may not be private or protected\", from\n // Model's `protected isActiveColumn`) and crashes the dts bundler on Model's\n // getters. `DefinedModel` adds no instance members over `Model<InferredSchema>`\n // and no statics beyond those already declared on `Model`, so this is a\n // faithful, emittable equivalent of the previously-inferred return type.\n type DefinedModelClass = {\n new (initialData?: Partial<InferredSchema>): Model<InferredSchema> & TProperties;\n } & Omit<typeof Model, \"new\"> &\n TStatics;\n\n return DefinedModel as unknown as DefinedModelClass;\n}\n\n/\n Type helper to infer the schema type from a defined model.\n \n @example\n * ```typescript\n * const User = defineModel({\n * table: \"users\",\n * schema: v.object({\n * name: v.string(),\n * email: v.string(),\n * }),\n * });\n \n type UserType = ModelType<typeof User>;\n * // { name: string; email: string; }\n * ```\n */\nexport type ModelType<T extends ReturnType<typeof defineModel>> = T extends new (\n ...args: any[]\n) => infer R\n ? R extends Model<infer S>\n ? S\n : never\n : never;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyKA,SAAgB,YAMd,SAKA;CAGA,MAAM,qBAAqB,MAAsB;;;;EAI/C,OAAc,QAAQ,QAAQ;;;;EAK9B,OAAc,SAAS,QAAQ;;;;;EAM/B,OAAc,iBAA6C,QAAQ;;;;;EAMnE,OAAc,kBAAuC,QAAQ;;;;;EAM7D,OAAc,YAAgC,QAAQ;CACxD;CAIA,IAAI,QAAQ,eAAe,QACzB,aAAa,aAAa,QAAQ;CAGpC,IAAI,QAAQ,mBAAmB,QAC7B,aAAa,iBAAiB,QAAQ;CAIxC,IAAI,QAAQ,YACV,OAAO,iBACL,aAAa,WACb,OAAO,0BAA0B,QAAQ,UAAU,CACrD;CAGF,IAAI,QAAQ,MACV,wBAAwB,QAAQ,MAAM,YAAY;CAIpD,IAAI,QAAQ,SACV,OAAO,iBAAiB,cAAc,OAAO,0BAA0B,QAAQ,OAAO,CAAC;CAmBzF,OAAO;AACT"}

package/esm/utils/escape-regex.d.mts CHANGED Viewed

@@ -1,4 +1,4 @@
-//#region ../cascade/src/utils/escape-regex.d.ts
+//#region ../../packages/cascade/src/utils/escape-regex.d.ts
 /**
  * Regex escaping for pattern-matching helpers.
  *

package/esm/utils/escape-regex.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"escape-regex.d.mts","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/escape-regex.ts"],"mappings":";;AAiCA;;;;AAAyC;AA0BzC;;;;AAAwD;AAaxD;;;;AAA2D;;;;;;;;;;;;;;iBAvC3C,WAAA,CAAY,KAAa;;;;;;;;;;;;;;;;;;;;;;;iBA0BzB,wBAAA,CAAyB,OAAe;;;;;;;;;;iBAaxC,kBAAA,CAAmB,OAAwB,EAAf,MAAM"}
1	+ {"version":3,"file":"escape-regex.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/escape-regex.ts"],"mappings":";;AAiCA;;;;AAAyC;AA0BzC;;;;AAAwD;AAaxD;;;;AAA2D;;;;;;;;;;;;;;iBAvC3C,WAAA,CAAY,KAAa;;;;;;;;;;;;;;;;;;;;;;;iBA0BzB,wBAAA,CAAyB,OAAe;;;;;;;;;;iBAaxC,kBAAA,CAAmB,OAAwB,EAAf,MAAM"}

package/esm/utils/escape-regex.mjs CHANGED Viewed

@@ -1,4 +1,4 @@
-//#region ../cascade/src/utils/escape-regex.ts
+//#region ../../packages/cascade/src/utils/escape-regex.ts
 /**
 * Regex escaping for pattern-matching helpers.
 *

package/esm/utils/escape-regex.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"escape-regex.mjs","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/escape-regex.ts"],"sourcesContent":["/*\n Regex escaping for pattern-matching helpers.\n \n `whereLike` / `whereNotLike` / `whereStartsWith` / `whereEndsWith` /\n * `whereSearch` compile their argument into a MongoDB `$regex`. The argument is\n * exactly what a search box hands over (`whereSearch(\"name\", req.query.q)`), so\n * passing it through unescaped gave the caller control of the regex itself:\n \n - injection — `.` / `\|` / `^` change the intended match semantics, and a\n boolean-oracle probe (`^a`, `^b`, …) reads values back one character at a\n * time from a field the endpoint never meant to expose;\n * - ReDoS — nested quantifiers (`(a+)+`) backtrack catastrophically inside\n * `mongod`, against every document the query scans.\n \n A string value is therefore treated as a LITERAL. Only an explicit `RegExp`\n * argument — which cannot come from JSON, so it is developer-authored — reaches\n * the regex engine as a pattern.\n /\n\n/* Characters that carry meaning to the regex engine and must be neutralized. /\nconst REGEX_METACHARACTERS = /[.+?^${}()\|[\\]\\\\]/g;\n\n/*\n Escape every regex metacharacter in a string so it matches itself.\n \n @param value - The literal text to match\n * @returns Regex source matching `value` verbatim\n \n @example\n * ```typescript\n * escapeRegex(\"(a+)+$\"); // \"\\\$a\\\\+\\\$\\\\+\\\\$\"\n * ```\n /\nexport function escapeRegex(value: string): string {\n return value.replace(REGEX_METACHARACTERS, \"\\\\$&\");\n}\n\n/\n Compile a `whereLike` pattern into regex source.\n \n The pattern is escaped first, so nothing the caller typed can act as a regex\n * operator; the SQL `LIKE` wildcard `%` is then translated to `.` — the one\n wildcard the API documents (`whereLike(\"email\", \"%@gmail.com\")`). Runs of `%`\n * collapse into a single `.`, since `%%%%…` compiles to nothing but extra\n backtracking work.\n \n The result stays unanchored: MongoDB's `whereLike` matches a substring\n * (`whereLike(\"name\", \"ar\")` finds \"Carol\"), which is the documented behavior of\n * this driver and is unchanged by the escaping.\n \n @param pattern - The user-supplied LIKE pattern\n * @returns Regex source matching the pattern literally, `%` aside\n \n @example\n * ```typescript\n * likePatternToRegexSource(\"%o'brien%\"); // \".o'brien.\"\n * likePatternToRegexSource(\"a.b\"); // \"a\\\\.b\" (a literal dot)\n * ```\n /\nexport function likePatternToRegexSource(pattern: string): string {\n return escapeRegex(pattern).replace(/%+/g, \".\");\n}\n\n/*\n Resolve a `whereLike`-style argument to regex source.\n \n An explicit `RegExp` is developer-authored and passes through as-is; a string\n * is user-shaped input and is treated as a literal LIKE pattern.\n \n @param pattern - A `RegExp` (trusted, used verbatim) or a string (escaped)\n * @returns Regex source ready for `$regex`\n */\nexport function resolveLikePattern(pattern: RegExp \| string): string {\n return pattern instanceof RegExp ? pattern.source : likePatternToRegexSource(pattern);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,MAAM,uBAAuB;;;;;;;;;;;;AAa7B,SAAgB,YAAY,OAAuB;CACjD,OAAO,MAAM,QAAQ,sBAAsB,MAAM;AACnD;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,yBAAyB,SAAyB;CAChE,OAAO,YAAY,OAAO,CAAC,CAAC,QAAQ,OAAO,IAAI;AACjD;;;;;;;;;;AAWA,SAAgB,mBAAmB,SAAkC;CACnE,OAAO,mBAAmB,SAAS,QAAQ,SAAS,yBAAyB,OAAO;AACtF"}
1	+ {"version":3,"file":"escape-regex.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/escape-regex.ts"],"sourcesContent":["/*\n Regex escaping for pattern-matching helpers.\n \n `whereLike` / `whereNotLike` / `whereStartsWith` / `whereEndsWith` /\n * `whereSearch` compile their argument into a MongoDB `$regex`. The argument is\n * exactly what a search box hands over (`whereSearch(\"name\", req.query.q)`), so\n * passing it through unescaped gave the caller control of the regex itself:\n \n - injection — `.` / `\|` / `^` change the intended match semantics, and a\n boolean-oracle probe (`^a`, `^b`, …) reads values back one character at a\n * time from a field the endpoint never meant to expose;\n * - ReDoS — nested quantifiers (`(a+)+`) backtrack catastrophically inside\n * `mongod`, against every document the query scans.\n \n A string value is therefore treated as a LITERAL. Only an explicit `RegExp`\n * argument — which cannot come from JSON, so it is developer-authored — reaches\n * the regex engine as a pattern.\n /\n\n/* Characters that carry meaning to the regex engine and must be neutralized. /\nconst REGEX_METACHARACTERS = /[.+?^${}()\|[\\]\\\\]/g;\n\n/*\n Escape every regex metacharacter in a string so it matches itself.\n \n @param value - The literal text to match\n * @returns Regex source matching `value` verbatim\n \n @example\n * ```typescript\n * escapeRegex(\"(a+)+$\"); // \"\\\$a\\\\+\\\$\\\\+\\\\$\"\n * ```\n /\nexport function escapeRegex(value: string): string {\n return value.replace(REGEX_METACHARACTERS, \"\\\\$&\");\n}\n\n/\n Compile a `whereLike` pattern into regex source.\n \n The pattern is escaped first, so nothing the caller typed can act as a regex\n * operator; the SQL `LIKE` wildcard `%` is then translated to `.` — the one\n wildcard the API documents (`whereLike(\"email\", \"%@gmail.com\")`). Runs of `%`\n * collapse into a single `.`, since `%%%%…` compiles to nothing but extra\n backtracking work.\n \n The result stays unanchored: MongoDB's `whereLike` matches a substring\n * (`whereLike(\"name\", \"ar\")` finds \"Carol\"), which is the documented behavior of\n * this driver and is unchanged by the escaping.\n \n @param pattern - The user-supplied LIKE pattern\n * @returns Regex source matching the pattern literally, `%` aside\n \n @example\n * ```typescript\n * likePatternToRegexSource(\"%o'brien%\"); // \".o'brien.\"\n * likePatternToRegexSource(\"a.b\"); // \"a\\\\.b\" (a literal dot)\n * ```\n /\nexport function likePatternToRegexSource(pattern: string): string {\n return escapeRegex(pattern).replace(/%+/g, \".\");\n}\n\n/*\n Resolve a `whereLike`-style argument to regex source.\n \n An explicit `RegExp` is developer-authored and passes through as-is; a string\n * is user-shaped input and is treated as a literal LIKE pattern.\n \n @param pattern - A `RegExp` (trusted, used verbatim) or a string (escaped)\n * @returns Regex source ready for `$regex`\n */\nexport function resolveLikePattern(pattern: RegExp \| string): string {\n return pattern instanceof RegExp ? pattern.source : likePatternToRegexSource(pattern);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAoBA,MAAM,uBAAuB;;;;;;;;;;;;AAa7B,SAAgB,YAAY,OAAuB;CACjD,OAAO,MAAM,QAAQ,sBAAsB,MAAM;AACnD;;;;;;;;;;;;;;;;;;;;;;;AAwBA,SAAgB,yBAAyB,SAAyB;CAChE,OAAO,YAAY,OAAO,CAAC,CAAC,QAAQ,OAAO,IAAI;AACjD;;;;;;;;;;AAWA,SAAgB,mBAAmB,SAAkC;CACnE,OAAO,mBAAmB,SAAS,QAAQ,SAAS,yBAAyB,OAAO;AACtF"}

package/esm/utils/is-valid-date-value.mjs CHANGED Viewed

@@ -1,4 +1,4 @@
-//#region ../cascade/src/utils/is-valid-date-value.ts
+//#region ../../packages/cascade/src/utils/is-valid-date-value.ts
 const isoRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{1,6})?(Z|[+-]\d{2}:?\d{2})$/;
 /**
 * Check if the given value is a valid date value

package/esm/utils/is-valid-date-value.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"is-valid-date-value.mjs","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/is-valid-date-value.ts"],"sourcesContent":["// Strings must carry a time part AND a timezone (Z or ±hh:mm), so plain text such as\n// \"2024-01-15\" or a zone-less local datetime is never turned into a Date.\nconst isoRegex = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,6})?(Z\|[+-]\\d{2}:?\\d{2})$/;\n\n/*\n Check if the given value is a valid date value\n */\nexport function isValidDateValue(value: unknown): boolean {\n // ✅ Handle timestamps\n if (typeof value === \"number\") {\n if (!Number.isFinite(value)) return false;\n\n const date = new Date(value);\n return !Number.isNaN(date.getTime());\n }\n\n // ❌ Only allow strict ISO strings\n if (typeof value !== \"string\") return false;\n\n if (!isoRegex.test(value)) return false;\n\n const date = new Date(value);\n if (Number.isNaN(date.getTime())) return false;\n\n // 🔥 Critical step: prevent JS auto-correction\n // Example: \"2023-02-31\" → March 3 (WRONG but \"valid\")\n // Checked on the written date part itself, so a timezone offset can't shift it.\n const datePart = value.split(\"T\")[0];\n if (datePart === undefined) return false;\n\n const [y, m, d] = datePart.split(\"-\").map(Number);\n if (y === undefined \|\| m === undefined \|\| d === undefined) return false;\n\n const written = new Date(Date.UTC(y, m - 1, d));\n\n return written.getUTCFullYear() === y && written.getUTCMonth() + 1 === m && written.getUTCDate() === d;\n}\n"],"mappings":";AAEA,MAAM,WAAW;;;;AAKjB,SAAgB,iBAAiB,OAAyB;CAExD,IAAI,OAAO,UAAU,UAAU;EAC7B,IAAI,CAAC,OAAO,SAAS,KAAK,GAAG,OAAO;EAEpC,MAAM,OAAO,IAAI,KAAK,KAAK;EAC3B,OAAO,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC;CACrC;CAGA,IAAI,OAAO,UAAU,UAAU,OAAO;CAEtC,IAAI,CAAC,SAAS,KAAK,KAAK,GAAG,OAAO;CAElC,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,GAAG,OAAO;CAKzC,MAAM,WAAW,MAAM,MAAM,GAAG,CAAC,CAAC;CAClC,IAAI,aAAa,QAAW,OAAO;CAEnC,MAAM,CAAC,GAAG,GAAG,KAAK,SAAS,MAAM,GAAG,CAAC,CAAC,IAAI,MAAM;CAChD,IAAI,MAAM,UAAa,MAAM,UAAa,MAAM,QAAW,OAAO;CAElE,MAAM,UAAU,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC;CAE9C,OAAO,QAAQ,eAAe,MAAM,KAAK,QAAQ,YAAY,IAAI,MAAM,KAAK,QAAQ,WAAW,MAAM;AACvG"}
1	+ {"version":3,"file":"is-valid-date-value.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/is-valid-date-value.ts"],"sourcesContent":["// Strings must carry a time part AND a timezone (Z or ±hh:mm), so plain text such as\n// \"2024-01-15\" or a zone-less local datetime is never turned into a Date.\nconst isoRegex = /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,6})?(Z\|[+-]\\d{2}:?\\d{2})$/;\n\n/*\n Check if the given value is a valid date value\n */\nexport function isValidDateValue(value: unknown): boolean {\n // ✅ Handle timestamps\n if (typeof value === \"number\") {\n if (!Number.isFinite(value)) return false;\n\n const date = new Date(value);\n return !Number.isNaN(date.getTime());\n }\n\n // ❌ Only allow strict ISO strings\n if (typeof value !== \"string\") return false;\n\n if (!isoRegex.test(value)) return false;\n\n const date = new Date(value);\n if (Number.isNaN(date.getTime())) return false;\n\n // 🔥 Critical step: prevent JS auto-correction\n // Example: \"2023-02-31\" → March 3 (WRONG but \"valid\")\n // Checked on the written date part itself, so a timezone offset can't shift it.\n const datePart = value.split(\"T\")[0];\n if (datePart === undefined) return false;\n\n const [y, m, d] = datePart.split(\"-\").map(Number);\n if (y === undefined \|\| m === undefined \|\| d === undefined) return false;\n\n const written = new Date(Date.UTC(y, m - 1, d));\n\n return written.getUTCFullYear() === y && written.getUTCMonth() + 1 === m && written.getUTCDate() === d;\n}\n"],"mappings":";AAEA,MAAM,WAAW;;;;AAKjB,SAAgB,iBAAiB,OAAyB;CAExD,IAAI,OAAO,UAAU,UAAU;EAC7B,IAAI,CAAC,OAAO,SAAS,KAAK,GAAG,OAAO;EAEpC,MAAM,OAAO,IAAI,KAAK,KAAK;EAC3B,OAAO,CAAC,OAAO,MAAM,KAAK,QAAQ,CAAC;CACrC;CAGA,IAAI,OAAO,UAAU,UAAU,OAAO;CAEtC,IAAI,CAAC,SAAS,KAAK,KAAK,GAAG,OAAO;CAElC,MAAM,OAAO,IAAI,KAAK,KAAK;CAC3B,IAAI,OAAO,MAAM,KAAK,QAAQ,CAAC,GAAG,OAAO;CAKzC,MAAM,WAAW,MAAM,MAAM,GAAG,CAAC,CAAC;CAClC,IAAI,aAAa,QAAW,OAAO;CAEnC,MAAM,CAAC,GAAG,GAAG,KAAK,SAAS,MAAM,GAAG,CAAC,CAAC,IAAI,MAAM;CAChD,IAAI,MAAM,UAAa,MAAM,UAAa,MAAM,QAAW,OAAO;CAElE,MAAM,UAAU,IAAI,KAAK,KAAK,IAAI,GAAG,IAAI,GAAG,CAAC,CAAC;CAE9C,OAAO,QAAQ,eAAe,MAAM,KAAK,QAAQ,YAAY,IAAI,MAAM,KAAK,QAAQ,WAAW,MAAM;AACvG"}

package/esm/utils/once-connected.d.mts CHANGED Viewed

@@ -1,6 +1,6 @@
 import { DataSource } from "../data-source/data-source.mjs";
-//#region ../cascade/src/utils/once-connected.d.ts
+//#region ../../packages/cascade/src/utils/once-connected.d.ts
 /**
  * Execute a callback once the driver is connected.
  *

package/esm/utils/once-connected.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"once-connected.d.mts","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/once-connected.ts"],"mappings":";;;;;AAqFA;;;;;;;;;;;;;;;;AAE6C;AAmI7C;;;;;;;;;;;;;;;;AAE6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAvI7B,aAAA,CACd,0BAAA,EAA4B,UAAA,cAAwB,UAAA,EAAY,UAAA,YAChE,QAAA,IAAY,UAAA,EAAY,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmIV,gBAAA,CACd,0BAAA,EAA4B,UAAA,cAAwB,UAAA,EAAY,UAAA,YAChE,QAAA,IAAY,UAAA,EAAY,UAAA"}
1	+ {"version":3,"file":"once-connected.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/once-connected.ts"],"mappings":";;;;;AAqFA;;;;;;;;;;;;;;;;AAE6C;AAmI7C;;;;;;;;;;;;;;;;AAE6C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAvI7B,aAAA,CACd,0BAAA,EAA4B,UAAA,cAAwB,UAAA,EAAY,UAAA,YAChE,QAAA,IAAY,UAAA,EAAY,UAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmIV,gBAAA,CACd,0BAAA,EAA4B,UAAA,cAAwB,UAAA,EAAY,UAAA,YAChE,QAAA,IAAY,UAAA,EAAY,UAAA"}

package/esm/utils/once-connected.mjs CHANGED Viewed

@@ -1,6 +1,6 @@
 import { dataSourceRegistry } from "../data-source/data-source-registry.mjs";
-//#region ../cascade/src/utils/once-connected.ts
+//#region ../../packages/cascade/src/utils/once-connected.ts
 /**
 * Whether the given source is the registry's actual default (not just the `isDefault` option flag).
 */

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

	@@ -1 +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 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"}
1	+ {"version":3,"file":"once-connected.mjs","names":[],"sources":["../../../../../../../../packages/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/utils/prune-empty-parents.mjs CHANGED Viewed

@@ -1,6 +1,6 @@
 import { isPlainObject } from "@mongez/supportive-is";
-//#region ../cascade/src/utils/prune-empty-parents.ts
+//#region ../../packages/cascade/src/utils/prune-empty-parents.ts
 /**
 * Remove the ancestors of `path` that became empty plain objects, walking from
 * the leaf's parent up to (and including) the top-level field.

package/esm/utils/prune-empty-parents.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"prune-empty-parents.mjs","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/prune-empty-parents.ts"],"sourcesContent":["import { isPlainObject } from \"@mongez/supportive-is\";\n\n/*\n Remove the ancestors of `path` that became empty plain objects, walking from\n * the leaf's parent up to (and including) the top-level field.\n \n Call it right AFTER removing the leaf at `path`, and only when that leaf\n * actually existed. Gating on \"the leaf existed\" is what keeps an object the\n * user deliberately stored as `{}` untouched: unsetting a key that is not there\n * removes nothing, so nothing becomes empty because of the unset and nothing is\n * pruned. An ancestor is only ever pruned because THIS unset emptied it.\n \n Only plain objects are pruned, and only while their own container is a plain\n * object (or the root): arrays are never pruned and stop the walk, because\n * deleting an index would shift its siblings.\n \n @param root - The data object the path is relative to (mutated in place)\n * @param path - Dot-notation path of the leaf that was just removed\n */\nexport function pruneEmptyParents(root: Record<string, unknown>, path: string): void {\n const segments = path.split(\".\");\n\n // Walk upward: the ancestor at `segments.slice(0, depth)` is the candidate.\n for (let depth = segments.length - 1; depth >= 1; depth -= 1) {\n let container: unknown = root;\n\n for (let index = 0; index < depth - 1; index += 1) {\n container = (container as Record<string, unknown> \| undefined)?.[segments[index] as string];\n\n if (!isPlainObject(container)) {\n return;\n }\n }\n\n const key = segments[depth - 1] as string;\n const candidate = (container as Record<string, unknown>)[key];\n\n if (!isPlainObject(candidate) \|\| Object.keys(candidate as object).length > 0) {\n return;\n }\n\n delete (container as Record<string, unknown>)[key];\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,kBAAkB,MAA+B,MAAoB;CACnF,MAAM,WAAW,KAAK,MAAM,GAAG;CAG/B,KAAK,IAAI,QAAQ,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG;EAC5D,IAAI,YAAqB;EAEzB,KAAK,IAAI,QAAQ,GAAG,QAAQ,QAAQ,GAAG,SAAS,GAAG;GACjD,YAAa,YAAoD,SAAS;GAE1E,IAAI,CAAC,cAAc,SAAS,GAC1B;EAEJ;EAEA,MAAM,MAAM,SAAS,QAAQ;EAC7B,MAAM,YAAa,UAAsC;EAEzD,IAAI,CAAC,cAAc,SAAS,KAAK,OAAO,KAAK,SAAmB,CAAC,CAAC,SAAS,GACzE;EAGF,OAAQ,UAAsC;CAChD;AACF"}
1	+ {"version":3,"file":"prune-empty-parents.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/prune-empty-parents.ts"],"sourcesContent":["import { isPlainObject } from \"@mongez/supportive-is\";\n\n/*\n Remove the ancestors of `path` that became empty plain objects, walking from\n * the leaf's parent up to (and including) the top-level field.\n \n Call it right AFTER removing the leaf at `path`, and only when that leaf\n * actually existed. Gating on \"the leaf existed\" is what keeps an object the\n * user deliberately stored as `{}` untouched: unsetting a key that is not there\n * removes nothing, so nothing becomes empty because of the unset and nothing is\n * pruned. An ancestor is only ever pruned because THIS unset emptied it.\n \n Only plain objects are pruned, and only while their own container is a plain\n * object (or the root): arrays are never pruned and stop the walk, because\n * deleting an index would shift its siblings.\n \n @param root - The data object the path is relative to (mutated in place)\n * @param path - Dot-notation path of the leaf that was just removed\n */\nexport function pruneEmptyParents(root: Record<string, unknown>, path: string): void {\n const segments = path.split(\".\");\n\n // Walk upward: the ancestor at `segments.slice(0, depth)` is the candidate.\n for (let depth = segments.length - 1; depth >= 1; depth -= 1) {\n let container: unknown = root;\n\n for (let index = 0; index < depth - 1; index += 1) {\n container = (container as Record<string, unknown> \| undefined)?.[segments[index] as string];\n\n if (!isPlainObject(container)) {\n return;\n }\n }\n\n const key = segments[depth - 1] as string;\n const candidate = (container as Record<string, unknown>)[key];\n\n if (!isPlainObject(candidate) \|\| Object.keys(candidate as object).length > 0) {\n return;\n }\n\n delete (container as Record<string, unknown>)[key];\n }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAmBA,SAAgB,kBAAkB,MAA+B,MAAoB;CACnF,MAAM,WAAW,KAAK,MAAM,GAAG;CAG/B,KAAK,IAAI,QAAQ,SAAS,SAAS,GAAG,SAAS,GAAG,SAAS,GAAG;EAC5D,IAAI,YAAqB;EAEzB,KAAK,IAAI,QAAQ,GAAG,QAAQ,QAAQ,GAAG,SAAS,GAAG;GACjD,YAAa,YAAoD,SAAS;GAE1E,IAAI,CAAC,cAAc,SAAS,GAC1B;EAEJ;EAEA,MAAM,MAAM,SAAS,QAAQ;EAC7B,MAAM,YAAa,UAAsC;EAEzD,IAAI,CAAC,cAAc,SAAS,KAAK,OAAO,KAAK,SAAmB,CAAC,CAAC,SAAS,GACzE;EAGF,OAAQ,UAAsC;CAChD;AACF"}

package/esm/utils/sanitize-filter.d.mts CHANGED Viewed

@@ -1,4 +1,4 @@
-//#region ../cascade/src/utils/sanitize-filter.d.ts
+//#region ../../packages/cascade/src/utils/sanitize-filter.d.ts
 /**
  * Reject a bound `undefined` value in an equality position. `undefined`
  * silently becomes `= NULL` (SQL) / "field missing" (MongoDB) — a query that

package/esm/utils/sanitize-filter.d.mts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"sanitize-filter.d.mts","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/sanitize-filter.ts"],"mappings":";;AAmEA;;;;AAA2D;AAkB3D;;;;cAlBa,aAAA,GAAiB,KAAA,WAAgB,KAAa;;;;;;AAkBO;AAkBlE;;;;;;iBAlBgB,mBAAA,IAAuB,KAAA,EAAO,CAAA,EAAG,KAAA,WAAgB,CAAC;;;;;;;;AAkBa;;;;;iBAA/D,cAAA,WAAyB,MAAA,mBAAyB,MAAA,EAAQ,CAAA,GAAI,CAAA"}
1	+ {"version":3,"file":"sanitize-filter.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/sanitize-filter.ts"],"mappings":";;AAmEA;;;;AAA2D;AAkB3D;;;;cAlBa,aAAA,GAAiB,KAAA,WAAgB,KAAa;;;;;;AAkBO;AAkBlE;;;;;;iBAlBgB,mBAAA,IAAuB,KAAA,EAAO,CAAA,EAAG,KAAA,WAAgB,CAAC;;;;;;;;AAkBa;;;;;iBAA/D,cAAA,WAAyB,MAAA,mBAAyB,MAAA,EAAQ,CAAA,GAAI,CAAA"}

package/esm/utils/sanitize-filter.mjs CHANGED Viewed

@@ -1,7 +1,7 @@
 import { UndefinedWhereValueError } from "../errors/undefined-where-value.error.mjs";
 import { UnsafeFilterError } from "../errors/unsafe-filter.error.mjs";
-//#region ../cascade/src/utils/sanitize-filter.ts
+//#region ../../packages/cascade/src/utils/sanitize-filter.ts
 /**
 * Filter sanitization for equality-position values.
 *

package/esm/utils/sanitize-filter.mjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"sanitize-filter.mjs","names":[],"sources":["~~../../../../../../../~~cascade/src/utils/sanitize-filter.ts"],"sourcesContent":["import { UndefinedWhereValueError } from \"../errors/undefined-where-value.error\";\nimport { UnsafeFilterError } from \"../errors/unsafe-filter.error\";\n\n/*\n Filter sanitization for equality-position values.\n \n `where({ field: value })`, `where(field, value)` and the filter-accepting\n * model statics (`first`, `findAll`, `deleteMany`, …) express equality\n * matches. If a request-controlled value such as `{ $ne: null }` is passed\n * through verbatim, MongoDB reinterprets it as an operator query — the classic\n * NoSQL operator-injection / auth-bypass primitive. These helpers reject any\n * `$`-prefixed key found in an equality position instead of forwarding it.\n \n Explicit operator APIs (`where(field, operator, value)`, `whereIn`,\n * `whereNull`, object-form `whereRaw({ ... })`, …) are intentionally NOT\n * routed through this check.\n /\n\n/\n Returns true for plain objects only (`{}` / `Object.create(null)`).\n * BSON values such as `Date`, `RegExp`, `ObjectId` or `Buffer` are class\n * instances whose keys are not Mongo operators, so they are never traversed.\n /\nconst isPlainObject = (value: unknown): value is Record<string, unknown> => {\n if (value === null \|\| typeof value !== \"object\") return false;\n const prototype = Object.getPrototypeOf(value);\n return prototype === Object.prototype \|\| prototype === null;\n};\n\nconst rejectOperatorKey = (field: string, key: string): never => {\n throw new UnsafeFilterError(\n `Unsafe filter: value for field \"${field}\" contains the reserved MongoDB operator key \"${key}\". ` +\n `Equality filters must not carry \"$\"-prefixed keys. ` +\n `Use the explicit operator API instead — e.g. where(field, operator, value), whereIn(), whereNull(), or the object form of whereRaw().`,\n field,\n key,\n );\n};\n\nconst assertNoOperatorKeys = (value: unknown, field: string): void => {\n if (Array.isArray(value)) {\n for (const item of value) {\n assertNoOperatorKeys(item, field);\n }\n return;\n }\n\n if (!isPlainObject(value)) return;\n\n for (const [key, nested] of Object.entries(value)) {\n if (key.startsWith(\"$\")) {\n rejectOperatorKey(field, key);\n }\n assertNoOperatorKeys(nested, field);\n }\n};\n\n/\n Reject a bound `undefined` value in an equality position. `undefined`\n * silently becomes `= NULL` (SQL) / \"field missing\" (MongoDB) — a query that\n * never matches what the caller meant, instead of failing loudly. `null` is\n * the explicit, intentional way to match NULL and is never rejected here.\n \n @param value - The equality value to check\n * @param field - The field name, used for the error message\n * @throws UndefinedWhereValueError when `value` is `undefined`\n /\nexport const assertDefined = (value: unknown, field: string): void => {\n if (value === undefined) {\n throw new UndefinedWhereValueError(field);\n }\n};\n\n/\n Assert a single equality-position value carries no `$`-prefixed keys and\n * is not `undefined`. Scalars, `Date`s and other non-plain objects pass\n * through untouched; plain objects/arrays are checked recursively for\n * operator keys.\n \n @param value - The equality value to check\n * @param field - The field name, used for the error message\n * @returns The value, unchanged\n * @throws UnsafeFilterError when a `$`-prefixed key is found\n * @throws UndefinedWhereValueError when `value` is `undefined`\n /\nexport function sanitizeFilterValue<T>(value: T, field: string): T {\n assertDefined(value, field);\n assertNoOperatorKeys(value, field);\n return value;\n}\n\n/\n Assert a `{ field: value }` equality filter carries no `$`-prefixed keys —\n * neither as top-level field names (`{ $where: … }`) nor inside any value\n * (`{ password: { $ne: null } }`) — and that no field's value is `undefined`.\n * Dotted field paths (\"profile.name\") and plain nested documents remain\n * valid.\n \n @param filter - The filter object to check\n * @returns The filter, unchanged\n * @throws UnsafeFilterError when a `$`-prefixed key is found\n * @throws UndefinedWhereValueError when a field's value is `undefined`\n */\nexport function sanitizeFilter<T extends Record<string, unknown>>(filter: T): T {\n for (const [field, value] of Object.entries(filter)) {\n if (field.startsWith(\"$\")) {\n rejectOperatorKey(field, field);\n }\n assertDefined(value, field);\n assertNoOperatorKeys(value, field);\n }\n return filter;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,iBAAiB,UAAqD;CAC1E,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO;CACxD,MAAM,YAAY,OAAO,eAAe,KAAK;CAC7C,OAAO,cAAc,OAAO,aAAa,cAAc;AACzD;AAEA,MAAM,qBAAqB,OAAe,QAAuB;CAC/D,MAAM,IAAI,kBACR,mCAAmC,MAAM,gDAAgD,IAAI,8LAG7F,OACA,GACF;AACF;AAEA,MAAM,wBAAwB,OAAgB,UAAwB;CACpE,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,KAAK,MAAM,QAAQ,OACjB,qBAAqB,MAAM,KAAK;EAElC;CACF;CAEA,IAAI,CAAC,cAAc,KAAK,GAAG;CAE3B,KAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG;EACjD,IAAI,IAAI,WAAW,GAAG,GACpB,kBAAkB,OAAO,GAAG;EAE9B,qBAAqB,QAAQ,KAAK;CACpC;AACF;;;;;;;;;;;AAYA,MAAa,iBAAiB,OAAgB,UAAwB;CACpE,IAAI,UAAU,QACZ,MAAM,IAAI,yBAAyB,KAAK;AAE5C;;;;;;;;;;;;;AAcA,SAAgB,oBAAuB,OAAU,OAAkB;CACjE,cAAc,OAAO,KAAK;CAC1B,qBAAqB,OAAO,KAAK;CACjC,OAAO;AACT;;;;;;;;;;;;;AAcA,SAAgB,eAAkD,QAAc;CAC9E,KAAK,MAAM,CAAC,OAAO,UAAU,OAAO,QAAQ,MAAM,GAAG;EACnD,IAAI,MAAM,WAAW,GAAG,GACtB,kBAAkB,OAAO,KAAK;EAEhC,cAAc,OAAO,KAAK;EAC1B,qBAAqB,OAAO,KAAK;CACnC;CACA,OAAO;AACT"}
1	+ {"version":3,"file":"sanitize-filter.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/sanitize-filter.ts"],"sourcesContent":["import { UndefinedWhereValueError } from \"../errors/undefined-where-value.error\";\nimport { UnsafeFilterError } from \"../errors/unsafe-filter.error\";\n\n/*\n Filter sanitization for equality-position values.\n \n `where({ field: value })`, `where(field, value)` and the filter-accepting\n * model statics (`first`, `findAll`, `deleteMany`, …) express equality\n * matches. If a request-controlled value such as `{ $ne: null }` is passed\n * through verbatim, MongoDB reinterprets it as an operator query — the classic\n * NoSQL operator-injection / auth-bypass primitive. These helpers reject any\n * `$`-prefixed key found in an equality position instead of forwarding it.\n \n Explicit operator APIs (`where(field, operator, value)`, `whereIn`,\n * `whereNull`, object-form `whereRaw({ ... })`, …) are intentionally NOT\n * routed through this check.\n /\n\n/\n Returns true for plain objects only (`{}` / `Object.create(null)`).\n * BSON values such as `Date`, `RegExp`, `ObjectId` or `Buffer` are class\n * instances whose keys are not Mongo operators, so they are never traversed.\n /\nconst isPlainObject = (value: unknown): value is Record<string, unknown> => {\n if (value === null \|\| typeof value !== \"object\") return false;\n const prototype = Object.getPrototypeOf(value);\n return prototype === Object.prototype \|\| prototype === null;\n};\n\nconst rejectOperatorKey = (field: string, key: string): never => {\n throw new UnsafeFilterError(\n `Unsafe filter: value for field \"${field}\" contains the reserved MongoDB operator key \"${key}\". ` +\n `Equality filters must not carry \"$\"-prefixed keys. ` +\n `Use the explicit operator API instead — e.g. where(field, operator, value), whereIn(), whereNull(), or the object form of whereRaw().`,\n field,\n key,\n );\n};\n\nconst assertNoOperatorKeys = (value: unknown, field: string): void => {\n if (Array.isArray(value)) {\n for (const item of value) {\n assertNoOperatorKeys(item, field);\n }\n return;\n }\n\n if (!isPlainObject(value)) return;\n\n for (const [key, nested] of Object.entries(value)) {\n if (key.startsWith(\"$\")) {\n rejectOperatorKey(field, key);\n }\n assertNoOperatorKeys(nested, field);\n }\n};\n\n/\n Reject a bound `undefined` value in an equality position. `undefined`\n * silently becomes `= NULL` (SQL) / \"field missing\" (MongoDB) — a query that\n * never matches what the caller meant, instead of failing loudly. `null` is\n * the explicit, intentional way to match NULL and is never rejected here.\n \n @param value - The equality value to check\n * @param field - The field name, used for the error message\n * @throws UndefinedWhereValueError when `value` is `undefined`\n /\nexport const assertDefined = (value: unknown, field: string): void => {\n if (value === undefined) {\n throw new UndefinedWhereValueError(field);\n }\n};\n\n/\n Assert a single equality-position value carries no `$`-prefixed keys and\n * is not `undefined`. Scalars, `Date`s and other non-plain objects pass\n * through untouched; plain objects/arrays are checked recursively for\n * operator keys.\n \n @param value - The equality value to check\n * @param field - The field name, used for the error message\n * @returns The value, unchanged\n * @throws UnsafeFilterError when a `$`-prefixed key is found\n * @throws UndefinedWhereValueError when `value` is `undefined`\n /\nexport function sanitizeFilterValue<T>(value: T, field: string): T {\n assertDefined(value, field);\n assertNoOperatorKeys(value, field);\n return value;\n}\n\n/\n Assert a `{ field: value }` equality filter carries no `$`-prefixed keys —\n * neither as top-level field names (`{ $where: … }`) nor inside any value\n * (`{ password: { $ne: null } }`) — and that no field's value is `undefined`.\n * Dotted field paths (\"profile.name\") and plain nested documents remain\n * valid.\n \n @param filter - The filter object to check\n * @returns The filter, unchanged\n * @throws UnsafeFilterError when a `$`-prefixed key is found\n * @throws UndefinedWhereValueError when a field's value is `undefined`\n */\nexport function sanitizeFilter<T extends Record<string, unknown>>(filter: T): T {\n for (const [field, value] of Object.entries(filter)) {\n if (field.startsWith(\"$\")) {\n rejectOperatorKey(field, field);\n }\n assertDefined(value, field);\n assertNoOperatorKeys(value, field);\n }\n return filter;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AAuBA,MAAM,iBAAiB,UAAqD;CAC1E,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO;CACxD,MAAM,YAAY,OAAO,eAAe,KAAK;CAC7C,OAAO,cAAc,OAAO,aAAa,cAAc;AACzD;AAEA,MAAM,qBAAqB,OAAe,QAAuB;CAC/D,MAAM,IAAI,kBACR,mCAAmC,MAAM,gDAAgD,IAAI,8LAG7F,OACA,GACF;AACF;AAEA,MAAM,wBAAwB,OAAgB,UAAwB;CACpE,IAAI,MAAM,QAAQ,KAAK,GAAG;EACxB,KAAK,MAAM,QAAQ,OACjB,qBAAqB,MAAM,KAAK;EAElC;CACF;CAEA,IAAI,CAAC,cAAc,KAAK,GAAG;CAE3B,KAAK,MAAM,CAAC,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG;EACjD,IAAI,IAAI,WAAW,GAAG,GACpB,kBAAkB,OAAO,GAAG;EAE9B,qBAAqB,QAAQ,KAAK;CACpC;AACF;;;;;;;;;;;AAYA,MAAa,iBAAiB,OAAgB,UAAwB;CACpE,IAAI,UAAU,QACZ,MAAM,IAAI,yBAAyB,KAAK;AAE5C;;;;;;;;;;;;;AAcA,SAAgB,oBAAuB,OAAU,OAAkB;CACjE,cAAc,OAAO,KAAK;CAC1B,qBAAqB,OAAO,KAAK;CACjC,OAAO;AACT;;;;;;;;;;;;;AAcA,SAAgB,eAAkD,QAAc;CAC9E,KAAK,MAAM,CAAC,OAAO,UAAU,OAAO,QAAQ,MAAM,GAAG;EACnD,IAAI,MAAM,WAAW,GAAG,GACtB,kBAAkB,OAAO,KAAK;EAEhC,cAAc,OAAO,KAAK;EAC1B,qBAAqB,OAAO,KAAK;CACnC;CACA,OAAO;AACT"}

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

@@ -2,7 +2,7 @@ import { databaseRulesPlugin } from "./plugins/database-rules-plugin.mjs";
 import { embedValidator } from "./plugins/embed-validator-plugin.mjs";
 import { registerPlugin } from "@warlock.js/seal";
-//#region ../cascade/src/validation/database-seal-plugins.ts
+//#region ../../packages/cascade/src/validation/database-seal-plugins.ts
 registerPlugin(embedValidator);
 registerPlugin(databaseRulesPlugin);

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

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

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

@@ -1,6 +1,6 @@
 import { ValidationResult } from "@warlock.js/seal";
-//#region ../cascade/src/validation/database-writer-validation-error.d.ts
+//#region ../../packages/cascade/src/validation/database-writer-validation-error.d.ts
 /**
  * Error thrown when model validation fails during database write operations.
  *

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

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

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

@@ -1,6 +1,6 @@
 import { colors } from "@mongez/copper";
-//#region ../cascade/src/validation/database-writer-validation-error.ts
+//#region ../../packages/cascade/src/validation/database-writer-validation-error.ts
 /**
 * Error thrown when model validation fails during database write operations.
 *

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

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

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

@@ -1,7 +1,7 @@
 import { requireModelClass } from "../../model/register-model.mjs";
 import { Model } from "../../model/model.mjs";
-//#region ../cascade/src/validation/mutators/embed-mutator.ts
+//#region ../../packages/cascade/src/validation/mutators/embed-mutator.ts
 const databaseModelMutator = async (value, context) => {
 	const { model } = context?.options || {};
 	if (!model) throw new Error("Model option is required");

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

	@@ -1 +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 { 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"}
1	+ {"version":3,"file":"embed-mutator.mjs","names":[],"sources":["../../../../../../../../../packages/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/database-rules-plugin.d.mts CHANGED Viewed

@@ -1,7 +1,7 @@
 import { ChildModel } from "../../model/model.types.mjs";
 import { Model } from "../../model/model.mjs";
 import { ExistsRuleOptions, UniqueRuleOptions } from "../types.mjs";
-//#region ../cascade/src/validation/plugins/database-rules-plugin.d.ts
+//#region ../../packages/cascade/src/validation/plugins/database-rules-plugin.d.ts
 declare module "@warlock.js/seal" {
   interface ScalarValidator {
     /** Value must be unique in database */

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

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

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

@@ -2,7 +2,7 @@ import { existsRule } from "../rules/exists-rule.mjs";
 import { uniqueRule } from "../rules/unique-rule.mjs";
 import { NumberValidator, ScalarValidator, StringValidator } from "@warlock.js/seal";
-//#region ../cascade/src/validation/plugins/database-rules-plugin.ts
+//#region ../../packages/cascade/src/validation/plugins/database-rules-plugin.ts
 /**
 * Cascade's database-rules plugin for Seal.
 */

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

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

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

@@ -1,6 +1,6 @@
 import { ChildModel } from "../../model/model.types.mjs";
 import { EmbedModelValidator } from "../validators/embed-validator.mjs";
-//#region ../cascade/src/validation/plugins/embed-validator-plugin.d.ts
+//#region ../../packages/cascade/src/validation/plugins/embed-validator-plugin.d.ts
 type EmbedOptions = {
   errorMessage?: string;
   embed?: string | string[];

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

	@@ -1 +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,GAAQ,UAAA,gBAA0B,OAAA,GAAU,YAAA,GAAe,mBAAA;IACjE,SAAA,CAAU,KAAA,GAAQ,UAAA,gBAA0B,OAAA,GAAU,YAAA,GAAe,mBAAA;EAAA;AAAA"}
1	+ {"version":3,"file":"embed-validator-plugin.d.mts","names":[],"sources":["../../../../../../../../../packages/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 CHANGED Viewed

@@ -1,7 +1,7 @@
 import { EmbedModelValidator } from "../validators/embed-validator.mjs";
 import { v } from "@warlock.js/seal";
-//#region ../cascade/src/validation/plugins/embed-validator-plugin.ts
+//#region ../../packages/cascade/src/validation/plugins/embed-validator-plugin.ts
 /**
 * File validation plugin for Seal
 */

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

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

@@ -2,7 +2,7 @@ import { requireModelClass } from "../../model/register-model.mjs";
 import { Model } from "../../model/model.mjs";
 import { VALID_RULE, invalidRule } from "@warlock.js/seal";
-//#region ../cascade/src/validation/rules/database-model-rule.ts
+//#region ../../packages/cascade/src/validation/rules/database-model-rule.ts
 const databaseModelRule = {
 	name: "databaseModel",
 	defaultErrorMessage: "The :input must be a valid :model model",

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

	@@ -1 +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\";\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"}
1	+ {"version":3,"file":"database-model-rule.mjs","names":[],"sources":["../../../../../../../../../packages/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 CHANGED Viewed

@@ -1,7 +1,7 @@
 import { requireModelClass } from "../../model/register-model.mjs";
 import { VALID_RULE, invalidRule } from "@warlock.js/seal";
-//#region ../cascade/src/validation/rules/exists-rule.ts
+//#region ../../packages/cascade/src/validation/rules/exists-rule.ts
 /**
 * Validates that a record exists in the database for the given column/value.
 *