@warlock.js/cascade 4.0.171 → 4.1.1

package/esm/migration/types.d.mts

@@ -0,0 +1,136 @@
+import { Migration } from "./migration.mjs";
+
+//#region ../../@warlock.js/cascade/src/migration/types.d.ts
+/**
+ * Result of a single migration execution.
+ */
+interface MigrationResult {
+  /** Migration name/identifier */
+  readonly name: string;
+  /** Table/collection affected */
+  readonly table: string;
+  /** Direction executed */
+  readonly direction: "up" | "down";
+  /** Whether execution was successful */
+  readonly success: boolean;
+  /** Error message if failed */
+  readonly error?: string;
+  /** Execution duration in milliseconds */
+  readonly durationMs: number;
+  /** Timestamp of execution */
+  readonly executedAt: Date;
+}
+/**
+ * Status of a migration file.
+ */
+interface MigrationStatus {
+  /** Migration name/identifier */
+  readonly name: string;
+  /** Table/collection affected */
+  readonly table: string;
+  /** Whether migration has been run */
+  readonly executed: boolean;
+  /** Batch number (null if not executed) */
+  readonly batch: number | null;
+  /** Timestamp when executed (null if not executed) */
+  readonly executedAt: Date | null;
+  /** File path of the migration */
+  readonly filePath: string;
+}
+/**
+ * Pending migration ready to be executed.
+ */
+interface PendingMigration {
+  /** Migration name/identifier */
+  readonly name: string;
+  /** Table/collection affected */
+  readonly table: string;
+  /** Migration instance */
+  readonly migration: Migration;
+  /** File path of the migration */
+  readonly filePath: string;
+  /** Parsed createdAt timestamp */
+  readonly createdAt: Date;
+}
+/**
+ * Record stored in the migrations table.
+ */
+interface MigrationRecord {
+  /** Migration name/identifier */
+  name: string;
+  /** Batch number */
+  batch: number;
+  /** Migration when executed */
+  executedAt: Date;
+  /** Migration file creation time */
+  createdAt: Date;
+}
+/**
+ * Options for the migration runner.
+ */
+interface MigrationRunnerOptions {
+  /**
+   * Glob pattern for finding migration files.
+   *
+   * @default "**\/*.migration.ts"
+   */
+  readonly pattern?: string;
+  /**
+   * Base directory to search for migrations.
+   */
+  readonly directory: string;
+  /**
+   * Table/collection name to store migration history.
+   *
+   * @default "_migrations"
+   */
+  readonly migrationsTable?: string;
+  /**
+   * Whether to run in dry-run mode (no actual changes).
+   *
+   * @default false
+   */
+  readonly dryRun?: boolean;
+  /**
+   * Whether to log operations.
+   *
+   * @default true
+   */
+  readonly verbose?: boolean;
+}
+/**
+ * Options for running migrations.
+ */
+interface RunMigrationsOptions {
+  /**
+   * Specific migrations to run (by name).
+   * If not provided, runs all pending migrations.
+   */
+  readonly only?: string[];
+  /**
+   * Run in dry-run mode (no actual changes).
+   */
+  readonly dryRun?: boolean;
+}
+/**
+ * Options for rolling back migrations.
+ */
+interface RollbackOptions {
+  /**
+   * Number of batches to rollback.
+   *
+   * @default 1
+   */
+  readonly batches?: number;
+  /**
+   * Specific migrations to rollback (by name).
+   */
+  readonly only?: string[];
+  /**
+   * Run in dry-run mode (no actual changes).
+   */
+  readonly dryRun?: boolean;
+}
+//#endregion
+export { MigrationRecord, MigrationResult, MigrationRunnerOptions, MigrationStatus, PendingMigration, RollbackOptions, RunMigrationsOptions };
+//# sourceMappingURL=types.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../@warlock.js/cascade/src/migration/types.ts"],"mappings":";;;;;AAKA;UAAiB,eAAA;;WAEN,IAAA;EAAA;EAAA,SAEA,KAAA;EAEA;EAAA,SAAA,SAAA;EAIA;EAAA,SAFA,OAAA;EAMA;EAAA,SAJA,KAAA;EAIgB;EAAA,SAFhB,UAAA;EAQM;EAAA,SANN,UAAA,EAAY,IAAI;AAAA;;;;UAMV,eAAA;EAQN;EAAA,SANA,IAAA;EAQY;EAAA,SANZ,KAAA;EAQQ;EAAA,SANR,QAAA;EAYM;EAAA,SAVN,KAAA;;WAEA,UAAA,EAAY,IAAI;EAUhB;EAAA,SARA,QAAA;AAAA;;;;UAMM,gBAAA;EAUS;EAAA,SARf,IAAA;EAcM;EAAA,SAZN,KAAA;;WAEA,SAAA,EAAW,SAAA;EAYpB;EAAA,SAVS,QAAA;EAcT;EAAA,SAZS,SAAA,EAAW,IAAI;AAAA;;;AAcT;UARA,eAAA;EAcsB;EAZrC,IAAA;EAYqC;EAVrC,KAAA;EAqBS;EAnBT,UAAA,EAAY,IAAA;EAiCH;EA/BT,SAAA,EAAW,IAAI;AAAA;AAsCC;AAMlB;;AANkB,UAhCD,sBAAA;EA2CN;AAKM;AAMjB;;;EAXW,SArCA,OAAA;EAsDA;;;EAAA,SAjDA,SAAA;EA2DM;;;;;EAAA,SApDN,eAAA;;;;;;WAOA,MAAA;;;;;;WAOA,OAAA;AAAA;;;;UAMM,oBAAA;;;;;WAKN,IAAA;;;;WAKA,MAAM;AAAA;;;;UAMA,eAAA;;;;;;WAMN,OAAA;;;;WAKA,IAAA;;;;WAKA,MAAA;AAAA"}

package/esm/model/methods/accessor-methods.mjs

@@ -0,0 +1,54 @@
+import { get, merge, only, set, unset } from "@mongez/reinforcements";
+
+//#region ../../@warlock.js/cascade/src/model/methods/accessor-methods.ts
+/**
+* Sentinel symbol to distinguish a genuinely missing field from a field
+* whose value is `undefined`. Encapsulated here — callers use `hasField()`.
+*/
+const MISSING_VALUE = Symbol("missing");
+function getFieldValue(model, field, defaultValue) {
+	return get(model.data, field, defaultValue);
+}
+function setFieldValue(model, field, value) {
+	const path = String(field);
+	set(model.data, path, value);
+	const partial = {};
+	set(partial, path, value);
+	model.dirtyTracker.mergeChanges(partial);
+	return model;
+}
+function hasField(model, field) {
+	return get(model.data, field, MISSING_VALUE) !== MISSING_VALUE;
+}
+function incrementField(model, field, amount) {
+	return setFieldValue(model, field, getFieldValue(model, field, 0) + (amount ?? 1));
+}
+function decrementField(model, field, amount) {
+	return setFieldValue(model, field, getFieldValue(model, field, 0) - (amount ?? 1));
+}
+function unsetFields(model, ...fields) {
+	model.data = unset(model.data, fields);
+	model.dirtyTracker.unset(fields);
+	return model;
+}
+function mergeFields(model, values) {
+	model.data = merge(model.data, values);
+	model.dirtyTracker.mergeChanges(values);
+	return model;
+}
+function getOnlyFields(model, fields) {
+	return only(model.data, fields);
+}
+function getStringField(model, key, defaultValue) {
+	return getFieldValue(model, key, defaultValue);
+}
+function getNumberField(model, key, defaultValue) {
+	return getFieldValue(model, key, defaultValue);
+}
+function getBooleanField(model, key, defaultValue) {
+	return getFieldValue(model, key, defaultValue);
+}
+
+//#endregion
+export { decrementField, getBooleanField, getFieldValue, getNumberField, getOnlyFields, getStringField, hasField, incrementField, mergeFields, setFieldValue, unsetFields };
+//# sourceMappingURL=accessor-methods.mjs.map

package/esm/model/methods/accessor-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"accessor-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/accessor-methods.ts"],"sourcesContent":["import { get, merge, only, set, unset } from \"@mongez/reinforcements\";\nimport type { Model } from \"../model\";\n\n/**\n * Sentinel symbol to distinguish a genuinely missing field from a field\n * whose value is `undefined`. Encapsulated here — callers use `hasField()`.\n */\nconst MISSING_VALUE = Symbol(\"missing\");\n\nexport function getFieldValue(model: Model, field: string, defaultValue?: unknown): any {\n  return get(model.data, field, defaultValue);\n}\n\nexport function setFieldValue(model: Model, field: string, value: unknown): Model {\n  const path = String(field);\n  set(model.data, path, value);\n\n  const partial: Record<string, unknown> = {};\n  set(partial, path, value);\n  model.dirtyTracker.mergeChanges(partial);\n\n  return model;\n}\n\nexport function hasField(model: Model, field: string): boolean {\n  return get(model.data, field, MISSING_VALUE as any) !== MISSING_VALUE;\n}\n\nexport function incrementField(model: Model, field: string, amount?: number): Model {\n  const value = getFieldValue(model, field, 0) as number;\n  const incrementedValue = value + (amount ?? 1);\n  return setFieldValue(model, field, incrementedValue);\n}\n\nexport function decrementField(model: Model, field: string, amount?: number): Model {\n  const value = getFieldValue(model, field, 0) as number;\n  const decrementedValue = value - (amount ?? 1);\n  return setFieldValue(model, field, decrementedValue);\n}\n\nexport function unsetFields(model: Model, ...fields: string[]): Model {\n  model.data = unset(model.data, fields);\n  model.dirtyTracker.unset(fields);\n\n  return model;\n}\n\nexport function mergeFields(model: Model, values: Record<string, unknown>): Model {\n  model.data = merge(model.data, values) as any;\n  model.dirtyTracker.mergeChanges(values);\n  return model;\n}\n\nexport function getOnlyFields(model: Model, fields: string[]): Record<string, unknown> {\n  return only(model.data, fields);\n}\n\nexport function getStringField(model: Model, key: string, defaultValue?: string): string | undefined {\n  return getFieldValue(model, key, defaultValue) as string | undefined;\n}\n\nexport function getNumberField(model: Model, key: string, defaultValue?: number): number | undefined {\n  return getFieldValue(model, key, defaultValue) as number | undefined;\n}\n\nexport function getBooleanField(model: Model, key: string, defaultValue?: boolean): boolean | undefined {\n  return getFieldValue(model, key, defaultValue) as boolean | undefined;\n}\n"],"mappings":";;;;;;;AAOA,MAAM,gBAAgB,OAAO,SAAS;AAEtC,SAAgB,cAAc,OAAc,OAAe,cAA6B;CACtF,OAAO,IAAI,MAAM,MAAM,OAAO,YAAY;AAC5C;AAEA,SAAgB,cAAc,OAAc,OAAe,OAAuB;CAChF,MAAM,OAAO,OAAO,KAAK;CACzB,IAAI,MAAM,MAAM,MAAM,KAAK;CAE3B,MAAM,UAAmC,CAAC;CAC1C,IAAI,SAAS,MAAM,KAAK;CACxB,MAAM,aAAa,aAAa,OAAO;CAEvC,OAAO;AACT;AAEA,SAAgB,SAAS,OAAc,OAAwB;CAC7D,OAAO,IAAI,MAAM,MAAM,OAAO,aAAoB,MAAM;AAC1D;AAEA,SAAgB,eAAe,OAAc,OAAe,QAAwB;CAGlF,OAAO,cAAc,OAAO,OAFd,cAAc,OAAO,OAAO,CACb,KAAK,UAAU,EACO;AACrD;AAEA,SAAgB,eAAe,OAAc,OAAe,QAAwB;CAGlF,OAAO,cAAc,OAAO,OAFd,cAAc,OAAO,OAAO,CACb,KAAK,UAAU,EACO;AACrD;AAEA,SAAgB,YAAY,OAAc,GAAG,QAAyB;CACpE,MAAM,OAAO,MAAM,MAAM,MAAM,MAAM;CACrC,MAAM,aAAa,MAAM,MAAM;CAE/B,OAAO;AACT;AAEA,SAAgB,YAAY,OAAc,QAAwC;CAChF,MAAM,OAAO,MAAM,MAAM,MAAM,MAAM;CACrC,MAAM,aAAa,aAAa,MAAM;CACtC,OAAO;AACT;AAEA,SAAgB,cAAc,OAAc,QAA2C;CACrF,OAAO,KAAK,MAAM,MAAM,MAAM;AAChC;AAEA,SAAgB,eAAe,OAAc,KAAa,cAA2C;CACnG,OAAO,cAAc,OAAO,KAAK,YAAY;AAC/C;AAEA,SAAgB,eAAe,OAAc,KAAa,cAA2C;CACnG,OAAO,cAAc,OAAO,KAAK,YAAY;AAC/C;AAEA,SAAgB,gBAAgB,OAAc,KAAa,cAA6C;CACtG,OAAO,cAAc,OAAO,KAAK,YAAY;AAC/C"}

package/esm/model/methods/delete-methods.mjs

@@ -0,0 +1,16 @@
+import { DatabaseRemover } from "../../remover/database-remover.mjs";
+
+//#region ../../@warlock.js/cascade/src/model/methods/delete-methods.ts
+async function destroyModel(model, options) {
+	return new DatabaseRemover(model).destroy(options);
+}
+async function deleteRecords(ModelClass, filter) {
+	return ModelClass.getDriver().deleteMany(ModelClass.table, filter);
+}
+async function deleteOneRecord(ModelClass, filter) {
+	return ModelClass.getDriver().delete(ModelClass.table, filter);
+}
+
+//#endregion
+export { deleteOneRecord, deleteRecords, destroyModel };
+//# sourceMappingURL=delete-methods.mjs.map

package/esm/model/methods/delete-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"delete-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/delete-methods.ts"],"sourcesContent":["import { DatabaseRemover } from \"../../remover/database-remover\";\nimport type { DeleteStrategy } from \"../../types\";\nimport type { RemoverResult } from \"../../contracts\";\nimport type { ChildModel, Model } from \"../model\";\n\nexport async function destroyModel(\n  model: Model,\n  options?: { strategy?: DeleteStrategy; skipEvents?: boolean },\n): Promise<RemoverResult> {\n  const remover = new DatabaseRemover(model);\n  return remover.destroy(options);\n}\n\nexport async function deleteRecords(\n  ModelClass: ChildModel<any>,\n  filter?: Record<string, unknown>,\n): Promise<number> {\n  return ModelClass.getDriver().deleteMany(ModelClass.table, filter);\n}\n\nexport async function deleteOneRecord(\n  ModelClass: ChildModel<any>,\n  filter?: Record<string, unknown>,\n): Promise<number> {\n  return ModelClass.getDriver().delete(ModelClass.table, filter);\n}\n"],"mappings":";;;AAKA,eAAsB,aACpB,OACA,SACwB;CAExB,OAAO,IADa,gBAAgB,KACvB,EAAE,QAAQ,OAAO;AAChC;AAEA,eAAsB,cACpB,YACA,QACiB;CACjB,OAAO,WAAW,UAAU,EAAE,WAAW,WAAW,OAAO,MAAM;AACnE;AAEA,eAAsB,gBACpB,YACA,QACiB;CACjB,OAAO,WAAW,UAAU,EAAE,OAAO,WAAW,OAAO,MAAM;AAC/D"}

package/esm/model/methods/dirty-methods.mjs

@@ -0,0 +1,20 @@
+//#region ../../@warlock.js/cascade/src/model/methods/dirty-methods.ts
+function checkHasChanges(model) {
+	return model.dirtyTracker.hasChanges();
+}
+function checkIsDirty(model, column) {
+	return model.dirtyTracker.isDirty(column);
+}
+function getDirtyColumnsWithValues(model) {
+	return model.dirtyTracker.getDirtyColumnsWithValues();
+}
+function getRemovedColumns(model) {
+	return model.dirtyTracker.getRemovedColumns();
+}
+function getDirtyColumns(model) {
+	return model.dirtyTracker.getDirtyColumns();
+}
+
+//#endregion
+export { checkHasChanges, checkIsDirty, getDirtyColumns, getDirtyColumnsWithValues, getRemovedColumns };
+//# sourceMappingURL=dirty-methods.mjs.map

package/esm/model/methods/dirty-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"dirty-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/dirty-methods.ts"],"sourcesContent":["import type { Model } from \"../model\";\n\nexport function checkHasChanges(model: Model): boolean {\n  return model.dirtyTracker.hasChanges();\n}\n\nexport function checkIsDirty(model: Model, column: string): boolean {\n  return model.dirtyTracker.isDirty(column);\n}\n\nexport function getDirtyColumnsWithValues(model: Model): Record<string, { oldValue: unknown; newValue: unknown }> {\n  return model.dirtyTracker.getDirtyColumnsWithValues();\n}\n\nexport function getRemovedColumns(model: Model): string[] {\n  return model.dirtyTracker.getRemovedColumns();\n}\n\nexport function getDirtyColumns(model: Model): string[] {\n  return model.dirtyTracker.getDirtyColumns();\n}\n"],"mappings":";AAEA,SAAgB,gBAAgB,OAAuB;CACrD,OAAO,MAAM,aAAa,WAAW;AACvC;AAEA,SAAgB,aAAa,OAAc,QAAyB;CAClE,OAAO,MAAM,aAAa,QAAQ,MAAM;AAC1C;AAEA,SAAgB,0BAA0B,OAAwE;CAChH,OAAO,MAAM,aAAa,0BAA0B;AACtD;AAEA,SAAgB,kBAAkB,OAAwB;CACxD,OAAO,MAAM,aAAa,kBAAkB;AAC9C;AAEA,SAAgB,gBAAgB,OAAwB;CACtD,OAAO,MAAM,aAAa,gBAAgB;AAC5C"}

package/esm/model/methods/hydration-methods.mjs

@@ -0,0 +1,51 @@
+import { RelationHydrator } from "../../relations/relation-hydrator.mjs";
+
+//#region ../../@warlock.js/cascade/src/model/methods/hydration-methods.ts
+function hydrateModel(ModelClass, data) {
+	const model = new ModelClass(ModelClass.getDriver().deserialize(data));
+	model.isNew = false;
+	return model;
+}
+function modelFromSnapshot(ModelClass, snapshot) {
+	const model = ModelClass.hydrate(snapshot.data);
+	RelationHydrator.hydrate(model, ModelClass.relations, snapshot.relations);
+	return model;
+}
+function modelToSnapshot(model) {
+	const driver = model.constructor.getDataSource().driver;
+	const relations = {};
+	for (const [name, related] of model.loadedRelations) if (related === null) relations[name] = null;
+	else if (Array.isArray(related)) relations[name] = related.map((m) => m instanceof Object && typeof m.toSnapshot === "function" ? m.toSnapshot() : m);
+	else if (related instanceof Object && typeof related.toSnapshot === "function") relations[name] = related.toSnapshot();
+	return {
+		data: driver.serialize({ ...model.data }),
+		relations
+	};
+}
+function serializeModel(model) {
+	return model.constructor.getDataSource().driver.serialize(model.data);
+}
+function cloneModel(model) {
+	const clonedData = JSON.parse(JSON.stringify(model.data));
+	const clonedModel = new (model.self())(clonedData);
+	clonedModel.isNew = model.isNew;
+	deepFreezeObject(clonedModel.data);
+	clonedModel.dirtyTracker.reset();
+	return clonedModel;
+}
+function deepFreezeObject(obj) {
+	Object.freeze(obj);
+	Object.getOwnPropertyNames(obj).forEach((prop) => {
+		const value = obj[prop];
+		if (value !== null && (typeof value === "object" || typeof value === "function") && !Object.isFrozen(value)) deepFreezeObject(value);
+	});
+	return obj;
+}
+function replaceModelData(model, data) {
+	model.data = data;
+	model.dirtyTracker.replaceCurrentData(data);
+}
+
+//#endregion
+export { cloneModel, deepFreezeObject, hydrateModel, modelFromSnapshot, modelToSnapshot, replaceModelData, serializeModel };
+//# sourceMappingURL=hydration-methods.mjs.map

package/esm/model/methods/hydration-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydration-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/hydration-methods.ts"],"sourcesContent":["import { RelationHydrator, type ModelSnapshot, type SerializedRelation } from \"../../relations/relation-hydrator\";\nimport type { ChildModel, Model } from \"../model\";\n\nexport function hydrateModel<TModel extends Model = Model>(\n  ModelClass: ChildModel<TModel>,\n  data: Record<string, unknown>,\n): TModel {\n  const model = new ModelClass(ModelClass.getDriver().deserialize(data));\n  model.isNew = false;\n  return model;\n}\n\nexport function modelFromSnapshot<TModel extends Model>(\n  ModelClass: ChildModel<TModel>,\n  snapshot: ModelSnapshot,\n): TModel {\n  const model = ModelClass.hydrate(snapshot.data) as TModel;\n  RelationHydrator.hydrate(model, ModelClass.relations, snapshot.relations);\n  return model;\n}\n\nexport function modelToSnapshot(model: Model): ModelSnapshot {\n  const driver = (model.constructor as typeof Model).getDataSource().driver;\n  const relations: Record<string, SerializedRelation> = {};\n\n  for (const [name, related] of model.loadedRelations) {\n    if (related === null) {\n      relations[name] = null;\n    } else if (Array.isArray(related)) {\n      relations[name] = related.map((m) => (m instanceof Object && typeof m.toSnapshot === \"function\" ? m.toSnapshot() : m));\n    } else if (related instanceof Object && typeof related.toSnapshot === \"function\") {\n      relations[name] = related.toSnapshot();\n    }\n  }\n\n  return {\n    data: driver.serialize({ ...model.data }) as Record<string, unknown>,\n    relations,\n  };\n}\n\nexport function serializeModel(model: Model) {\n  return (model.constructor as typeof Model).getDataSource().driver.serialize(model.data);\n}\n\nexport function cloneModel<TModel extends Model>(model: TModel): TModel {\n  const clonedData = JSON.parse(JSON.stringify(model.data));\n  const ModelClass = model.self();\n  const clonedModel = new ModelClass(clonedData) as TModel;\n\n  clonedModel.isNew = model.isNew;\n  deepFreezeObject(clonedModel.data);\n  clonedModel.dirtyTracker.reset();\n\n  return clonedModel;\n}\n\nexport function deepFreezeObject<T>(obj: T): T {\n  Object.freeze(obj);\n\n  Object.getOwnPropertyNames(obj).forEach((prop) => {\n    const value = (obj as any)[prop];\n    if (\n      value !== null &&\n      (typeof value === \"object\" || typeof value === \"function\") &&\n      !Object.isFrozen(value)\n    ) {\n      deepFreezeObject(value);\n    }\n  });\n\n  return obj;\n}\n\nexport function replaceModelData<TModel extends Model>(\n  model: TModel,\n  data: Record<string, unknown>,\n): void {\n  model.data = data as any;\n  model.dirtyTracker.replaceCurrentData(data);\n}\n"],"mappings":";;;AAGA,SAAgB,aACd,YACA,MACQ;CACR,MAAM,QAAQ,IAAI,WAAW,WAAW,UAAU,EAAE,YAAY,IAAI,CAAC;CACrE,MAAM,QAAQ;CACd,OAAO;AACT;AAEA,SAAgB,kBACd,YACA,UACQ;CACR,MAAM,QAAQ,WAAW,QAAQ,SAAS,IAAI;CAC9C,iBAAiB,QAAQ,OAAO,WAAW,WAAW,SAAS,SAAS;CACxE,OAAO;AACT;AAEA,SAAgB,gBAAgB,OAA6B;CAC3D,MAAM,SAAU,MAAM,YAA6B,cAAc,EAAE;CACnE,MAAM,YAAgD,CAAC;CAEvD,KAAK,MAAM,CAAC,MAAM,YAAY,MAAM,iBAClC,IAAI,YAAY,MACd,UAAU,QAAQ;MACb,IAAI,MAAM,QAAQ,OAAO,GAC9B,UAAU,QAAQ,QAAQ,KAAK,MAAO,aAAa,UAAU,OAAO,EAAE,eAAe,aAAa,EAAE,WAAW,IAAI,CAAE;MAChH,IAAI,mBAAmB,UAAU,OAAO,QAAQ,eAAe,YACpE,UAAU,QAAQ,QAAQ,WAAW;CAIzC,OAAO;EACL,MAAM,OAAO,UAAU,EAAE,GAAG,MAAM,KAAK,CAAC;EACxC;CACF;AACF;AAEA,SAAgB,eAAe,OAAc;CAC3C,OAAQ,MAAM,YAA6B,cAAc,EAAE,OAAO,UAAU,MAAM,IAAI;AACxF;AAEA,SAAgB,WAAiC,OAAuB;CACtE,MAAM,aAAa,KAAK,MAAM,KAAK,UAAU,MAAM,IAAI,CAAC;CAExD,MAAM,cAAc,KADD,MAAM,KACQ,GAAE,UAAU;CAE7C,YAAY,QAAQ,MAAM;CAC1B,iBAAiB,YAAY,IAAI;CACjC,YAAY,aAAa,MAAM;CAE/B,OAAO;AACT;AAEA,SAAgB,iBAAoB,KAAW;CAC7C,OAAO,OAAO,GAAG;CAEjB,OAAO,oBAAoB,GAAG,EAAE,SAAS,SAAS;EAChD,MAAM,QAAS,IAAY;EAC3B,IACE,UAAU,SACT,OAAO,UAAU,YAAY,OAAO,UAAU,eAC/C,CAAC,OAAO,SAAS,KAAK,GAEtB,iBAAiB,KAAK;CAE1B,CAAC;CAED,OAAO;AACT;AAEA,SAAgB,iBACd,OACA,MACM;CACN,MAAM,OAAO;CACb,MAAM,aAAa,mBAAmB,IAAI;AAC5C"}

package/esm/model/methods/instance-event-methods.mjs

@@ -0,0 +1,22 @@
+import { globalModelEvents } from "../../events/model-events.mjs";
+
+//#region ../../@warlock.js/cascade/src/model/methods/instance-event-methods.ts
+async function emitModelEvent(model, event, context) {
+	const ctor = model.constructor;
+	await model.events.emit(event, model, context);
+	await ctor.events().emit(event, model, context);
+	await globalModelEvents.emit(event, model, context);
+}
+function onModelEvent(model, event, listener) {
+	return model.events.on(event, listener);
+}
+function onceModelEvent(model, event, listener) {
+	return model.events.once(event, listener);
+}
+function offModelEvent(model, event, listener) {
+	model.events.off(event, listener);
+}
+
+//#endregion
+export { emitModelEvent, offModelEvent, onModelEvent, onceModelEvent };
+//# sourceMappingURL=instance-event-methods.mjs.map

package/esm/model/methods/instance-event-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"instance-event-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/instance-event-methods.ts"],"sourcesContent":["import {\n  globalModelEvents,\n  type ModelEventListener,\n  type ModelEventName,\n} from \"../../events/model-events\";\nimport type { Model } from \"../model\";\n\nexport async function emitModelEvent<TContext = unknown>(\n  model: Model,\n  event: ModelEventName,\n  context?: TContext,\n): Promise<void> {\n  const ctor = model.constructor as any;\n  await model.events.emit(event, model, context as TContext);\n  await ctor.events().emit(event, model, context as TContext);\n  await globalModelEvents.emit(event, model, context as TContext);\n}\n\nexport function onModelEvent<TContext = unknown>(\n  model: Model,\n  event: ModelEventName,\n  listener: ModelEventListener<any, TContext>,\n): () => void {\n  return model.events.on(event, listener);\n}\n\nexport function onceModelEvent<TContext = unknown>(\n  model: Model,\n  event: ModelEventName,\n  listener: ModelEventListener<any, TContext>,\n): () => void {\n  return model.events.once(event, listener);\n}\n\nexport function offModelEvent<TContext = unknown>(\n  model: Model,\n  event: ModelEventName,\n  listener: ModelEventListener<any, TContext>,\n): void {\n  model.events.off(event, listener);\n}\n"],"mappings":";;;AAOA,eAAsB,eACpB,OACA,OACA,SACe;CACf,MAAM,OAAO,MAAM;CACnB,MAAM,MAAM,OAAO,KAAK,OAAO,OAAO,OAAmB;CACzD,MAAM,KAAK,OAAO,EAAE,KAAK,OAAO,OAAO,OAAmB;CAC1D,MAAM,kBAAkB,KAAK,OAAO,OAAO,OAAmB;AAChE;AAEA,SAAgB,aACd,OACA,OACA,UACY;CACZ,OAAO,MAAM,OAAO,GAAG,OAAO,QAAQ;AACxC;AAEA,SAAgB,eACd,OACA,OACA,UACY;CACZ,OAAO,MAAM,OAAO,KAAK,OAAO,QAAQ;AAC1C;AAEA,SAAgB,cACd,OACA,OACA,UACM;CACN,MAAM,OAAO,IAAI,OAAO,QAAQ;AAClC"}

package/esm/model/methods/meta-methods.mjs

@@ -0,0 +1,36 @@
+import { DatabaseWriter } from "../../writer/database-writer.mjs";
+
+//#region ../../@warlock.js/cascade/src/model/methods/meta-methods.ts
+function applyDefaultsToModel(ModelClass, defaults) {
+	if (defaults.autoGenerateId !== void 0 && ModelClass.autoGenerateId === void 0) ModelClass.autoGenerateId = defaults.autoGenerateId;
+	if (defaults.initialId !== void 0 && ModelClass.initialId === void 0) ModelClass.initialId = defaults.initialId;
+	if (defaults.randomInitialId !== void 0 && ModelClass.randomInitialId === void 0) ModelClass.randomInitialId = defaults.randomInitialId;
+	if (defaults.incrementIdBy !== void 0 && ModelClass.incrementIdBy === void 0) ModelClass.incrementIdBy = defaults.incrementIdBy;
+	if (defaults.randomIncrement !== void 0 && ModelClass.randomIncrement === void 0) ModelClass.randomIncrement = defaults.randomIncrement;
+	if (defaults.createdAtColumn !== void 0 && ModelClass.createdAtColumn === void 0) ModelClass.createdAtColumn = defaults.createdAtColumn;
+	if (defaults.updatedAtColumn !== void 0 && ModelClass.updatedAtColumn === void 0) ModelClass.updatedAtColumn = defaults.updatedAtColumn;
+	if (defaults.deleteStrategy !== void 0 && ModelClass.deleteStrategy === void 0) ModelClass.deleteStrategy = defaults.deleteStrategy;
+	if (defaults.deletedAtColumn !== void 0 && ModelClass.deletedAtColumn === void 0) ModelClass.deletedAtColumn = defaults.deletedAtColumn;
+	if (defaults.trashTable !== void 0 && ModelClass.trashTable === void 0) if (typeof defaults.trashTable === "function") ModelClass.trashTable = defaults.trashTable(ModelClass.table);
+	else ModelClass.trashTable = defaults.trashTable;
+	if (defaults.strictMode !== void 0 && ModelClass.strictMode === void 0) ModelClass.strictMode = defaults.strictMode;
+}
+async function generateModelNextId(model) {
+	await new DatabaseWriter(model).generateNextId();
+	return model.id;
+}
+async function performAtomicUpdate(model, operations) {
+	return model.self().atomic({ id: model.id }, operations);
+}
+async function performAtomicIncrement(model, field, amount = 1) {
+	model.increment(field, amount);
+	return performAtomicUpdate(model, { $inc: { [field]: amount } });
+}
+async function performAtomicDecrement(model, field, amount = 1) {
+	model.decrement(field, amount);
+	return performAtomicUpdate(model, { $inc: { [field]: -amount } });
+}
+
+//#endregion
+export { applyDefaultsToModel, generateModelNextId, performAtomicDecrement, performAtomicIncrement, performAtomicUpdate };
+//# sourceMappingURL=meta-methods.mjs.map

package/esm/model/methods/meta-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"meta-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/meta-methods.ts"],"sourcesContent":["import { DatabaseWriter } from \"../../writer/database-writer\";\nimport type { Model } from \"../model\";\n\nexport function applyDefaultsToModel(ModelClass: any, defaults: any): void {\n  // Only apply defaults if model doesn't have its own value\n\n  // ============================================================================\n  // ID Generation\n  // ============================================================================\n  if (defaults.autoGenerateId !== undefined && ModelClass.autoGenerateId === undefined) {\n    ModelClass.autoGenerateId = defaults.autoGenerateId;\n  }\n  if (defaults.initialId !== undefined && ModelClass.initialId === undefined) {\n    ModelClass.initialId = defaults.initialId;\n  }\n  if (defaults.randomInitialId !== undefined && ModelClass.randomInitialId === undefined) {\n    ModelClass.randomInitialId = defaults.randomInitialId;\n  }\n  if (defaults.incrementIdBy !== undefined && ModelClass.incrementIdBy === undefined) {\n    ModelClass.incrementIdBy = defaults.incrementIdBy;\n  }\n  if (defaults.randomIncrement !== undefined && ModelClass.randomIncrement === undefined) {\n    ModelClass.randomIncrement = defaults.randomIncrement;\n  }\n\n  // ============================================================================\n  // Timestamps\n  // ============================================================================\n  if (defaults.createdAtColumn !== undefined && ModelClass.createdAtColumn === undefined) {\n    ModelClass.createdAtColumn = defaults.createdAtColumn;\n  }\n\n  if (defaults.updatedAtColumn !== undefined && ModelClass.updatedAtColumn === undefined) {\n    ModelClass.updatedAtColumn = defaults.updatedAtColumn;\n  }\n\n  // ============================================================================\n  // Deletion\n  // ============================================================================\n  if (defaults.deleteStrategy !== undefined && ModelClass.deleteStrategy === undefined) {\n    ModelClass.deleteStrategy = defaults.deleteStrategy;\n  }\n  if (defaults.deletedAtColumn !== undefined && ModelClass.deletedAtColumn === undefined) {\n    ModelClass.deletedAtColumn = defaults.deletedAtColumn;\n  }\n  if (defaults.trashTable !== undefined && ModelClass.trashTable === undefined) {\n    // Handle function-based trash table\n    if (typeof defaults.trashTable === \"function\") {\n      ModelClass.trashTable = defaults.trashTable(ModelClass.table);\n    } else {\n      ModelClass.trashTable = defaults.trashTable;\n    }\n  }\n\n  // ============================================================================\n  // Validation\n  // ============================================================================\n  if (defaults.strictMode !== undefined && ModelClass.strictMode === undefined) {\n    ModelClass.strictMode = defaults.strictMode;\n  }\n}\n\nexport async function generateModelNextId(model: Model): Promise<number | string> {\n  const writer = new DatabaseWriter(model);\n  await writer.generateNextId();\n  return model.id!;\n}\n\nexport async function performAtomicUpdate(\n  model: Model,\n  operations: Record<string, unknown>,\n): Promise<number> {\n  return model.self().atomic({ id: model.id! }, operations);\n}\n\nexport async function performAtomicIncrement<T extends string>(\n  model: Model,\n  field: T,\n  amount = 1,\n): Promise<number> {\n  model.increment(field, amount);\n  return performAtomicUpdate(model, {\n    $inc: {\n      [field]: amount,\n    },\n  });\n}\n\nexport async function performAtomicDecrement<T extends string>(\n  model: Model,\n  field: T,\n  amount = 1,\n): Promise<number> {\n  model.decrement(field, amount);\n  return performAtomicUpdate(model, {\n    $inc: {\n      [field]: -amount,\n    },\n  });\n}\n"],"mappings":";;;AAGA,SAAgB,qBAAqB,YAAiB,UAAqB;CAMzE,IAAI,SAAS,mBAAmB,UAAa,WAAW,mBAAmB,QACzE,WAAW,iBAAiB,SAAS;CAEvC,IAAI,SAAS,cAAc,UAAa,WAAW,cAAc,QAC/D,WAAW,YAAY,SAAS;CAElC,IAAI,SAAS,oBAAoB,UAAa,WAAW,oBAAoB,QAC3E,WAAW,kBAAkB,SAAS;CAExC,IAAI,SAAS,kBAAkB,UAAa,WAAW,kBAAkB,QACvE,WAAW,gBAAgB,SAAS;CAEtC,IAAI,SAAS,oBAAoB,UAAa,WAAW,oBAAoB,QAC3E,WAAW,kBAAkB,SAAS;CAMxC,IAAI,SAAS,oBAAoB,UAAa,WAAW,oBAAoB,QAC3E,WAAW,kBAAkB,SAAS;CAGxC,IAAI,SAAS,oBAAoB,UAAa,WAAW,oBAAoB,QAC3E,WAAW,kBAAkB,SAAS;CAMxC,IAAI,SAAS,mBAAmB,UAAa,WAAW,mBAAmB,QACzE,WAAW,iBAAiB,SAAS;CAEvC,IAAI,SAAS,oBAAoB,UAAa,WAAW,oBAAoB,QAC3E,WAAW,kBAAkB,SAAS;CAExC,IAAI,SAAS,eAAe,UAAa,WAAW,eAAe,QAEjE,IAAI,OAAO,SAAS,eAAe,YACjC,WAAW,aAAa,SAAS,WAAW,WAAW,KAAK;MAE5D,WAAW,aAAa,SAAS;CAOrC,IAAI,SAAS,eAAe,UAAa,WAAW,eAAe,QACjE,WAAW,aAAa,SAAS;AAErC;AAEA,eAAsB,oBAAoB,OAAwC;CAEhF,MAAM,IADa,eAAe,KACvB,EAAE,eAAe;CAC5B,OAAO,MAAM;AACf;AAEA,eAAsB,oBACpB,OACA,YACiB;CACjB,OAAO,MAAM,KAAK,EAAE,OAAO,EAAE,IAAI,MAAM,GAAI,GAAG,UAAU;AAC1D;AAEA,eAAsB,uBACpB,OACA,OACA,SAAS,GACQ;CACjB,MAAM,UAAU,OAAO,MAAM;CAC7B,OAAO,oBAAoB,OAAO,EAChC,MAAM,GACH,QAAQ,OACX,EACF,CAAC;AACH;AAEA,eAAsB,uBACpB,OACA,OACA,SAAS,GACQ;CACjB,MAAM,UAAU,OAAO,MAAM;CAC7B,OAAO,oBAAoB,OAAO,EAChC,MAAM,GACH,QAAQ,CAAC,OACZ,EACF,CAAC;AACH"}

package/esm/model/methods/pivot-methods.mjs

@@ -0,0 +1,48 @@
+import { createPivotOperations } from "../../relations/pivot-operations.mjs";
+
+//#region ../../@warlock.js/cascade/src/model/methods/pivot-methods.ts
+/**
+* Get the pivot-operations handle for a `belongsToMany` relation.
+*
+* Returns the `PivotOperations` object exposing `attach` / `detach` /
+* `sync` / `toggle` for the named relation's pivot table.
+*
+* @throws Error if the relation is not a belongsToMany relation.
+*
+* @example
+* await post.pivot("tags").attach([1, 2, 3]);
+* await post.pivot("tags").sync([1, 3, 5]);
+* await post.pivot("tags").toggle([1, 7]);
+*/
+function pivotRelation(model, relation) {
+	return createPivotOperations(model, relation);
+}
+/**
+* Attach one or more related records to a belongsToMany pivot table.
+*
+* @throws Error if the relation is not a belongsToMany relation.
+*
+* @example
+* await post.attach("tags", [1, 2, 3]);
+* await post.attach("tags", [4], { addedBy: currentUserId });
+*/
+async function attachPivotRelation(model, relation, ids, pivotData) {
+	return createPivotOperations(model, relation).attach(ids, pivotData);
+}
+/**
+* Detach related records from a belongsToMany pivot table. Omit `ids` to
+* detach every row for this side of the relation.
+*
+* @throws Error if the relation is not a belongsToMany relation.
+*
+* @example
+* await post.detach("tags", [2]);
+* await post.detach("tags"); // detach all
+*/
+async function detachPivotRelation(model, relation, ids) {
+	return createPivotOperations(model, relation).detach(ids);
+}
+
+//#endregion
+export { attachPivotRelation, detachPivotRelation, pivotRelation };
+//# sourceMappingURL=pivot-methods.mjs.map

package/esm/model/methods/pivot-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"pivot-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/pivot-methods.ts"],"sourcesContent":["import { createPivotOperations, type PivotOperations } from \"../../relations/pivot-operations\";\nimport type { PivotData, PivotIds } from \"../../relations/types\";\nimport type { Model } from \"../model\";\n\n/**\n * Get the pivot-operations handle for a `belongsToMany` relation.\n *\n * Returns the `PivotOperations` object exposing `attach` / `detach` /\n * `sync` / `toggle` for the named relation's pivot table.\n *\n * @throws Error if the relation is not a belongsToMany relation.\n *\n * @example\n * await post.pivot(\"tags\").attach([1, 2, 3]);\n * await post.pivot(\"tags\").sync([1, 3, 5]);\n * await post.pivot(\"tags\").toggle([1, 7]);\n */\nexport function pivotRelation(model: Model, relation: string): PivotOperations {\n  return createPivotOperations(model, relation);\n}\n\n/**\n * Attach one or more related records to a belongsToMany pivot table.\n *\n * @throws Error if the relation is not a belongsToMany relation.\n *\n * @example\n * await post.attach(\"tags\", [1, 2, 3]);\n * await post.attach(\"tags\", [4], { addedBy: currentUserId });\n */\nexport async function attachPivotRelation(\n  model: Model,\n  relation: string,\n  ids: PivotIds,\n  pivotData?: PivotData,\n): Promise<void> {\n  return createPivotOperations(model, relation).attach(ids, pivotData);\n}\n\n/**\n * Detach related records from a belongsToMany pivot table. Omit `ids` to\n * detach every row for this side of the relation.\n *\n * @throws Error if the relation is not a belongsToMany relation.\n *\n * @example\n * await post.detach(\"tags\", [2]);\n * await post.detach(\"tags\"); // detach all\n */\nexport async function detachPivotRelation(\n  model: Model,\n  relation: string,\n  ids?: PivotIds,\n): Promise<void> {\n  return createPivotOperations(model, relation).detach(ids);\n}\n"],"mappings":";;;;;;;;;;;;;;;;AAiBA,SAAgB,cAAc,OAAc,UAAmC;CAC7E,OAAO,sBAAsB,OAAO,QAAQ;AAC9C;;;;;;;;;;AAWA,eAAsB,oBACpB,OACA,UACA,KACA,WACe;CACf,OAAO,sBAAsB,OAAO,QAAQ,EAAE,OAAO,KAAK,SAAS;AACrE;;;;;;;;;;;AAYA,eAAsB,oBACpB,OACA,UACA,KACe;CACf,OAAO,sBAAsB,OAAO,QAAQ,EAAE,OAAO,GAAG;AAC1D"}

package/esm/model/methods/query-methods.mjs

@@ -0,0 +1,121 @@
+import { dataSourceRegistry } from "../../data-source/data-source-registry.mjs";
+
+//#region ../../@warlock.js/cascade/src/model/methods/query-methods.ts
+function buildQuery(ModelClass, BaseModel) {
+	const queryBuilder = ModelClass.newQueryBuilder();
+	queryBuilder.pendingGlobalScopes = new Map([...BaseModel.globalScopes, ...ModelClass.globalScopes]);
+	queryBuilder.availableLocalScopes = ModelClass.localScopes;
+	queryBuilder.disabledGlobalScopes = /* @__PURE__ */ new Set();
+	queryBuilder.relationDefinitions = ModelClass.relations;
+	queryBuilder.modelClass = ModelClass;
+	ModelClass.events().emitFetching(queryBuilder, {
+		table: ModelClass.table,
+		modelClass: ModelClass
+	});
+	queryBuilder.hydrate((data) => {
+		return ModelClass.hydrate(data);
+	});
+	queryBuilder.onFetched(async (models) => {
+		await ModelClass.events().emit("fetched", models, {});
+	});
+	return queryBuilder;
+}
+function buildNewQueryBuilder(ModelClass) {
+	const dataSource = ModelClass.getDataSource();
+	if (ModelClass.builder) {
+		const BuilderClass = ModelClass.builder;
+		return new BuilderClass(ModelClass.table, dataSource);
+	}
+	return dataSource.driver.queryBuilder(ModelClass.table);
+}
+async function findFirst(ModelClass, filter) {
+	const query = ModelClass.query();
+	if (filter) query.where(filter);
+	return query.first();
+}
+async function findLast(ModelClass, filter) {
+	const query = ModelClass.query();
+	if (filter) query.where(filter);
+	return query.last();
+}
+async function findAll(ModelClass, filter) {
+	const query = ModelClass.query();
+	if (filter) query.where(filter);
+	return query.get();
+}
+function countRecords(ModelClass, filter) {
+	const query = ModelClass.query();
+	if (filter) query.where(filter);
+	return query.count();
+}
+async function findById(ModelClass, id) {
+	return ModelClass.query().where(ModelClass.primaryKey, id).first();
+}
+async function paginateRecords(ModelClass, options = {}) {
+	const query = ModelClass.query();
+	if (options.filter) query.where(options.filter);
+	return query.paginate({
+		limit: options.limit,
+		page: options.page
+	});
+}
+async function findLatest(ModelClass, filter) {
+	const query = ModelClass.query();
+	if (filter) query.where(filter);
+	return await query.latest();
+}
+function increaseField(ModelClass, filter, field, amount) {
+	return ModelClass.query().where(filter).increment(field, amount);
+}
+function decreaseField(ModelClass, filter, field, amount) {
+	return ModelClass.query().where(filter).decrement(field, amount);
+}
+async function performAtomic(ModelClass, filter, operations) {
+	return (await ModelClass.getDriver().atomic(ModelClass.table, filter, operations)).modifiedCount;
+}
+async function updateById(ModelClass, id, data) {
+	return (await ModelClass.getDriver().update(ModelClass.table, { [ModelClass.primaryKey]: id }, { $set: data })).modifiedCount;
+}
+async function findAndUpdateRecords(ModelClass, filter, update) {
+	await performAtomic(ModelClass, filter, update);
+	return await ModelClass.query().where(filter).get();
+}
+async function findOneAndUpdateRecord(ModelClass, filter, update) {
+	const result = await ModelClass.getDriver().findOneAndUpdate(ModelClass.table, filter, update);
+	if (!result) return null;
+	return new ModelClass(result);
+}
+async function findAndReplaceRecord(ModelClass, filter, document) {
+	const result = await ModelClass.getDriver().replace(ModelClass.table, filter, document);
+	if (!result) return null;
+	return new ModelClass(result);
+}
+async function findOneAndDeleteRecord(ModelClass, filter, options) {
+	const result = await ModelClass.getDriver().findOneAndDelete(ModelClass.table, filter, options);
+	if (!result) return null;
+	const model = ModelClass.hydrate(result);
+	model.dirtyTracker.reset();
+	return model;
+}
+function resolveDataSource(ModelClass) {
+	const ref = ModelClass.dataSource;
+	let dataSource;
+	if (typeof ref === "string") dataSource = dataSourceRegistry.get(ref);
+	else if (ref) dataSource = ref;
+	else dataSource = dataSourceRegistry.get();
+	if (!ModelClass.hasOwnProperty("_defaultsApplied")) {
+		const driverDefaults = dataSource.driver.modelDefaults || {};
+		const dataSourceDefaults = dataSource.modelDefaults || {};
+		const mergedDefaults = {
+			...driverDefaults,
+			...dataSourceDefaults
+		};
+		if (Object.keys(mergedDefaults).length > 0) ModelClass.applyModelDefaults(mergedDefaults);
+		ModelClass._defaultsApplied = true;
+	}
+	return dataSource;
+}
+
+//#endregion
+export { buildNewQueryBuilder, buildQuery, countRecords, decreaseField, findAll, findAndReplaceRecord, findAndUpdateRecords, findById, findFirst, findLast, findLatest, findOneAndDeleteRecord, findOneAndUpdateRecord, increaseField, paginateRecords, performAtomic, resolveDataSource, updateById };
+//# sourceMappingURL=query-methods.mjs.map

package/esm/model/methods/query-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-methods.mjs","names":["ctor"],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/query-methods.ts"],"sourcesContent":["import type {\r\n  PaginationOptions,\r\n  PaginationResult,\r\n  QueryBuilderContract,\r\n  UpdateOperations,\r\n} from \"../../contracts\";\r\nimport type { DataSource } from \"../../data-source/data-source\";\r\nimport { dataSourceRegistry } from \"../../data-source/data-source-registry\";\r\nimport type { ChildModel, GlobalScopeDefinition, Model } from \"../model\";\r\n\r\nexport function buildQuery<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  BaseModel: typeof Model,\r\n): QueryBuilderContract<TModel> {\r\n  const queryBuilder = ModelClass.newQueryBuilder<TModel>();\r\n  const qb = queryBuilder;\r\n\r\n  // Collect global scopes from base Model and child model\r\n  const allGlobalScopes = new Map<string, GlobalScopeDefinition>([\r\n    ...BaseModel.globalScopes,\r\n    ...ModelClass.globalScopes,\r\n  ]);\r\n\r\n  queryBuilder.pendingGlobalScopes = allGlobalScopes;\r\n  queryBuilder.availableLocalScopes = ModelClass.localScopes;\r\n  queryBuilder.disabledGlobalScopes = new Set();\r\n  queryBuilder.relationDefinitions = ModelClass.relations;\r\n  queryBuilder.modelClass = ModelClass;\r\n\r\n  ModelClass.events().emitFetching(queryBuilder, {\r\n    table: ModelClass.table,\r\n    modelClass: ModelClass,\r\n  });\r\n\r\n  queryBuilder.hydrate((data: any) => {\r\n    return ModelClass.hydrate(data);\r\n  });\r\n\r\n  // Eager-loading runs inside the driver's `get()` so it works for any\r\n  // builder construction path (Model.query, Model.newQueryBuilder, custom\r\n  // subclassed builders). This hook only handles the model-level `fetched`\r\n  // event emission.\r\n  queryBuilder.onFetched(async (models: any[]) => {\r\n    await ModelClass.events().emit(\"fetched\", models as any, {});\r\n  });\r\n\r\n  return queryBuilder;\r\n}\r\n\r\nexport function buildNewQueryBuilder<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n): QueryBuilderContract<TModel> {\r\n  const dataSource = ModelClass.getDataSource();\r\n\r\n  if (ModelClass.builder) {\r\n    const BuilderClass = ModelClass.builder;\r\n    return new BuilderClass(ModelClass.table, dataSource) as QueryBuilderContract<TModel>;\r\n  }\r\n\r\n  const queryBuilder = dataSource.driver.queryBuilder<TModel>(ModelClass.table);\r\n  return queryBuilder;\r\n}\r\n\r\nexport async function findFirst<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter?: Record<string, unknown>,\r\n): Promise<TModel | null> {\r\n  const query = ModelClass.query();\r\n  if (filter) {\r\n    query.where(filter);\r\n  }\r\n  return query.first();\r\n}\r\n\r\nexport async function findLast<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter?: Record<string, unknown>,\r\n): Promise<TModel | null> {\r\n  const query = ModelClass.query();\r\n  if (filter) {\r\n    query.where(filter);\r\n  }\r\n\r\n  return query.last();\r\n}\r\n\r\nexport async function findAll<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter?: Record<string, unknown>,\r\n): Promise<TModel[]> {\r\n  const query = ModelClass.query();\r\n  if (filter) {\r\n    query.where(filter);\r\n  }\r\n  return query.get();\r\n}\r\n\r\nexport function countRecords<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter?: Record<string, unknown>,\r\n): Promise<number> {\r\n  const query = ModelClass.query();\r\n  if (filter) {\r\n    query.where(filter);\r\n  }\r\n  return query.count();\r\n}\r\n\r\nexport async function findById<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  id: string | number,\r\n): Promise<TModel | null> {\r\n  const query = ModelClass.query();\r\n  return query.where(ModelClass.primaryKey, id).first();\r\n}\r\n\r\nexport async function paginateRecords<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  options: PaginationOptions & { filter?: Record<string, unknown> } = {},\r\n): Promise<PaginationResult<TModel>> {\r\n  const query = ModelClass.query();\r\n  if (options.filter) {\r\n    query.where(options.filter);\r\n  }\r\n\r\n  return query.paginate({\r\n    limit: options.limit,\r\n    page: options.page,\r\n  });\r\n}\r\n\r\nexport async function findLatest<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter?: Record<string, unknown>,\r\n): Promise<TModel[]> {\r\n  const query = ModelClass.query();\r\n  if (filter) {\r\n    query.where(filter);\r\n  }\r\n  return (await query.latest()) as unknown as TModel[];\r\n}\r\n\r\nexport function increaseField<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter: Record<string, unknown>,\r\n  field: string,\r\n  amount: number,\r\n): Promise<number> {\r\n  const query = ModelClass.query().where(filter);\r\n  return query.increment(field, amount);\r\n}\r\n\r\nexport function decreaseField<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter: Record<string, unknown>,\r\n  field: string,\r\n  amount: number,\r\n): Promise<number> {\r\n  const query = ModelClass.query().where(filter);\r\n  return query.decrement(field, amount);\r\n}\r\n\r\nexport async function performAtomic<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter: Record<string, unknown>,\r\n  operations: UpdateOperations,\r\n): Promise<number> {\r\n  const result = await ModelClass.getDriver().atomic(ModelClass.table, filter, operations);\r\n  return result.modifiedCount;\r\n}\r\n\r\nexport async function updateById<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  id: string | number,\r\n  data: Record<string, unknown>,\r\n): Promise<number> {\r\n  const result = await ModelClass.getDriver().update(ModelClass.table, { [ModelClass.primaryKey]: id }, { $set: data });\r\n  return result.modifiedCount;\r\n}\r\n\r\nexport async function findAndUpdateRecords<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter: Record<string, unknown>,\r\n  update: UpdateOperations,\r\n): Promise<TModel[]> {\r\n  await performAtomic(ModelClass, filter, update);\r\n  return await ModelClass.query().where(filter).get();\r\n}\r\n\r\nexport async function findOneAndUpdateRecord<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter: Record<string, unknown>,\r\n  update: UpdateOperations,\r\n): Promise<TModel | null> {\r\n  const result = await ModelClass.getDriver().findOneAndUpdate(ModelClass.table, filter, update);\r\n  if (!result) return null;\r\n  const ctor = ModelClass as any;\r\n  return new ctor(result);\r\n}\r\n\r\nexport async function findAndReplaceRecord<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter: Record<string, unknown>,\r\n  document: Record<string, unknown>,\r\n): Promise<TModel | null> {\r\n  const result = await ModelClass.getDriver().replace(ModelClass.table, filter, document);\r\n  if (!result) return null;\r\n  const ctor = ModelClass as any;\r\n  return new ctor(result);\r\n}\r\n\r\nexport async function findOneAndDeleteRecord<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n  filter: Record<string, unknown>,\r\n  options?: Record<string, unknown>,\r\n): Promise<TModel | null> {\r\n  const driver = ModelClass.getDriver();\r\n  const result = await driver.findOneAndDelete(ModelClass.table, filter, options);\r\n\r\n  if (!result) {\r\n    return null;\r\n  }\r\n\r\n  const model = ModelClass.hydrate(result as Record<string, unknown>);\r\n  model.dirtyTracker.reset();\r\n  return model;\r\n}\r\n\r\nexport function resolveDataSource<TModel extends Model>(\r\n  ModelClass: ChildModel<TModel>,\r\n): DataSource {\r\n  const ref = ModelClass.dataSource;\r\n  let dataSource: DataSource;\r\n\r\n  if (typeof ref === \"string\") {\r\n    dataSource = dataSourceRegistry.get(ref);\r\n  } else if (ref) {\r\n    dataSource = ref;\r\n  } else {\r\n    dataSource = dataSourceRegistry.get();\r\n  }\r\n\r\n  if (!ModelClass.hasOwnProperty(\"_defaultsApplied\")) {\r\n    const driverDefaults = dataSource.driver.modelDefaults || {};\r\n    const dataSourceDefaults = dataSource.modelDefaults || {};\r\n\r\n    const mergedDefaults = {\r\n      ...driverDefaults,\r\n      ...dataSourceDefaults,\r\n    };\r\n\r\n    if (Object.keys(mergedDefaults).length > 0) {\r\n      (ModelClass as any).applyModelDefaults(mergedDefaults);\r\n    }\r\n\r\n    (ModelClass as any)._defaultsApplied = true;\r\n  }\r\n\r\n  return dataSource;\r\n}\r\n"],"mappings":"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"}

package/esm/model/methods/restore-methods.mjs

@@ -0,0 +1,16 @@
+import { DatabaseRestorer } from "../../restorer/database-restorer.mjs";
+
+//#region ../../@warlock.js/cascade/src/model/methods/restore-methods.ts
+async function restoreRecord(ModelClass, id, options) {
+	const result = await new DatabaseRestorer(ModelClass).restore(id, options);
+	if (!result.restoredRecord) throw new Error(`Failed to restore ${ModelClass.name} with ${ModelClass.primaryKey} ${id}: no record returned.`);
+	return result.restoredRecord;
+}
+async function restoreAllRecords(ModelClass, options) {
+	const result = await new DatabaseRestorer(ModelClass).restoreAll(options);
+	return result.restoredCount === 0 ? [] : result.restoredRecords;
+}
+
+//#endregion
+export { restoreAllRecords, restoreRecord };
+//# sourceMappingURL=restore-methods.mjs.map

package/esm/model/methods/restore-methods.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"restore-methods.mjs","names":[],"sources":["../../../../../../../@warlock.js/cascade/src/model/methods/restore-methods.ts"],"sourcesContent":["import { DatabaseRestorer } from \"../../restorer/database-restorer\";\nimport type { ChildModel, Model } from \"../model\";\n\nexport async function restoreRecord<TModel extends Model>(\n  ModelClass: ChildModel<TModel>,\n  id: string | number,\n  options?: { onIdConflict?: \"fail\" | \"assignNew\"; skipEvents?: boolean },\n): Promise<TModel> {\n  const restorer = new DatabaseRestorer(ModelClass as unknown as typeof Model);\n  const result = await restorer.restore(id, options);\n\n  if (!result.restoredRecord) {\n    throw new Error(\n      `Failed to restore ${ModelClass.name} with ${ModelClass.primaryKey} ${id}: no record returned.`,\n    );\n  }\n\n  return result.restoredRecord as TModel;\n}\n\nexport async function restoreAllRecords<TModel extends Model>(\n  ModelClass: ChildModel<TModel>,\n  options?: { onIdConflict?: \"fail\" | \"assignNew\"; skipEvents?: boolean },\n): Promise<TModel[]> {\n  const restorer = new DatabaseRestorer(ModelClass as unknown as typeof Model);\n  const result = await restorer.restoreAll(options);\n\n  return result.restoredCount === 0 ? [] : (result.restoredRecords as TModel[]);\n}\n"],"mappings":";;;AAGA,eAAsB,cACpB,YACA,IACA,SACiB;CAEjB,MAAM,SAAS,MAAM,IADA,iBAAiB,UACV,EAAE,QAAQ,IAAI,OAAO;CAEjD,IAAI,CAAC,OAAO,gBACV,MAAM,IAAI,MACR,qBAAqB,WAAW,KAAK,QAAQ,WAAW,WAAW,GAAG,GAAG,sBAC3E;CAGF,OAAO,OAAO;AAChB;AAEA,eAAsB,kBACpB,YACA,SACmB;CAEnB,MAAM,SAAS,MAAM,IADA,iBAAiB,UACV,EAAE,WAAW,OAAO;CAEhD,OAAO,OAAO,kBAAkB,IAAI,CAAC,IAAK,OAAO;AACnD"}

package/esm/model/methods/scope-methods.mjs

@@ -0,0 +1,20 @@
+//#region ../../@warlock.js/cascade/src/model/methods/scope-methods.ts
+function addGlobalModelScope(ModelClass, name, callback, options = {}) {
+	ModelClass.globalScopes.set(name, {
+		callback,
+		timing: options.timing || "before"
+	});
+}
+function removeGlobalModelScope(ModelClass, name) {
+	ModelClass.globalScopes.delete(name);
+}
+function addLocalModelScope(ModelClass, name, callback) {
+	ModelClass.localScopes.set(name, callback);
+}
+function removeLocalModelScope(ModelClass, name) {
+	ModelClass.localScopes.delete(name);
+}
+
+//#endregion
+export { addGlobalModelScope, addLocalModelScope, removeGlobalModelScope, removeLocalModelScope };
+//# sourceMappingURL=scope-methods.mjs.map