@warlock.js/cascade 5.30.0 → 5.32.0

package/esm/sync/types.d.mts

@@ -1,94 +1,142 @@
 import { ChildModel } from "../model/model.types.mjs";
 import { Model } from "../model/model.mjs";
-
 //#region ../../packages/cascade/src/sync/types.d.ts
 /**
  * Context information for a sync operation.
  * Tracks the source, target, chain, and results of a sync operation.
  */
-type SyncContext = {
-  /** Source model name (e.g., "Category") */sourceModel: string; /** Source model primary key value */
-  sourceId: string | number; /** Current depth in the sync chain (1, 2, 3...) */
-  currentDepth: number; /** Chain of model names in the sync path (e.g., ["Category", "Product"]) */
-  syncChain: string[]; /** Target model name being synced to */
-  targetModel: string; /** Filter to identify documents to update in target */
-  filter: Record<string, unknown>; /** Update operations to apply to matched documents */
-  update: Record<string, unknown>; /** Number of documents affected by this sync operation */
-  affectedCount: number; /** Timestamp when the sync operation was executed */
+export type SyncContext = {
+  /** Source model name (e.g., "Category") */
+  sourceModel: string;
+  /** Source model primary key value */
+  sourceId: string | number;
+  /** Current depth in the sync chain (1, 2, 3...) */
+  currentDepth: number;
+  /** Chain of model names in the sync path (e.g., ["Category", "Product"]) */
+  syncChain: string[];
+  /** Target model name being synced to */
+  targetModel: string;
+  /** Filter to identify documents to update in target */
+  filter: Record<string, unknown>;
+  /** Update operations to apply to matched documents */
+  update: Record<string, unknown>;
+  /** Number of documents affected by this sync operation */
+  affectedCount: number;
+  /** Timestamp when the sync operation was executed */
   timestamp: Date;
 };
 /**
  * Result of a sync operation.
  * Contains success status, counts, and error details.
  */
-type SyncResult = {
-  /** Whether the overall sync operation succeeded */success: boolean; /** Total number of sync instructions attempted */
-  attempted: number; /** Number of sync instructions that succeeded */
-  succeeded: number; /** Number of sync instructions that failed */
-  failed: number; /** Detailed error information for failed operations */
+export type SyncResult = {
+  /** Whether the overall sync operation succeeded */
+  success: boolean;
+  /** Total number of sync instructions attempted */
+  attempted: number;
+  /** Number of sync instructions that succeeded */
+  succeeded: number;
+  /** Number of sync instructions that failed */
+  failed: number;
+  /** Detailed error information for failed operations */
   errors: Array<{
     instruction: SyncInstruction;
     error: Error;
-  }>; /** Maximum depth reached in the sync chain */
-  depthReached: number; /** All sync contexts created during the operation */
+  }>;
+  /** Maximum depth reached in the sync chain */
+  depthReached: number;
+  /** All sync contexts created during the operation */
   contexts: SyncContext[];
 };
 /**
  * A single sync instruction to be executed.
  * Contains all information needed to perform a sync update.
  */
-type SyncInstruction = {
-  /** Target table/collection name */targetTable: string; /** Target model name */
-  targetModel: string; /** Filter to identify documents to update */
-  filter: Record<string, unknown>; /** Update operations to apply */
-  update: Record<string, unknown>; /** Current depth in the sync chain */
-  depth: number; /** Chain of model names leading to this instruction */
-  chain: string[]; /** Source model name */
-  sourceModel: string; /** Source model ID */
-  sourceId: string | number; /** Whether this is an array update (requires positional operator) */
-  isArrayUpdate?: boolean; /** Array field path for positional updates */
-  arrayField?: string; /** Identifier field for array matching */
-  identifierField?: string; /** Identifier value for array matching */
+export type SyncInstruction = {
+  /** Target table/collection name */
+  targetTable: string;
+  /** Target model name */
+  targetModel: string;
+  /** Filter to identify documents to update */
+  filter: Record<string, unknown>;
+  /** Update operations to apply */
+  update: Record<string, unknown>;
+  /** Current depth in the sync chain */
+  depth: number;
+  /** Chain of model names leading to this instruction */
+  chain: string[];
+  /** Source model name */
+  sourceModel: string;
+  /** Source model ID */
+  sourceId: string | number;
+  /** Whether this is an array update (requires positional operator) */
+  isArrayUpdate?: boolean;
+  /** Array field path for positional updates */
+  arrayField?: string;
+  /** Identifier field for array matching */
+  identifierField?: string;
+  /** Identifier value for array matching */
   identifierValue?: string | number;
 };
 /**
  * Configuration for a single sync relationship.
  */
-type SyncConfig = {
-  /** Target field path in the target model (e.g., "category" or "products") */targetField: string; /** Whether this is a many relationship (array of embedded documents) */
-  isMany: boolean; /** Method name to call on source model to get embedded data */
-  embedKey: string; /** Field name to use as identifier in array matching (for isMany) */
-  identifierField: string; /** Maximum sync depth allowed from this relationship */
-  maxSyncDepth: number; /** Whether to prevent circular sync chains */
-  preventCircularSync: boolean; /** Fields to watch for changes (empty = all fields) */
-  watchFields: string[]; /** Whether to unset the field when source is deleted */
-  unsetOnDelete: boolean; /** Target model class (for chaining) */
+export type SyncConfig = {
+  /** Target field path in the target model (e.g., "category" or "products") */
+  targetField: string;
+  /** Whether this is a many relationship (array of embedded documents) */
+  isMany: boolean;
+  /** Method name to call on source model to get embedded data */
+  embedKey: string;
+  /** Field name to use as identifier in array matching (for isMany) */
+  identifierField: string;
+  /** Maximum sync depth allowed from this relationship */
+  maxSyncDepth: number;
+  /** Whether to prevent circular sync chains */
+  preventCircularSync: boolean;
+  /** Fields to watch for changes (empty = all fields) */
+  watchFields: string[];
+  /** Whether to unset the field when source is deleted */
+  unsetOnDelete: boolean;
+  /** Target model class (for chaining) */
   targetModelClass: ChildModel<Model>;
 };
 /**
  * Options for building sync instructions.
  */
-type SyncInstructionOptions = {
-  /** Current depth in the sync chain */currentDepth: number; /** Chain of model names leading to this point */
-  syncChain: string[]; /** Maximum allowed depth for this sync operation */
-  maxDepth: number; /** Whether to prevent circular references */
+export type SyncInstructionOptions = {
+  /** Current depth in the sync chain */
+  currentDepth: number;
+  /** Chain of model names leading to this point */
+  syncChain: string[];
+  /** Maximum allowed depth for this sync operation */
+  maxDepth: number;
+  /** Whether to prevent circular references */
   preventCircular: boolean;
 };
 /**
  * Standard embed proeprties names.
  */
-type EmbedKey = "embedData" | "embedParent" | "embedMinimal";
+export type EmbedKey = "embedData" | "embedParent" | "embedMinimal";
 /**
  * Event payload for sync events.
  */
-type SyncEventPayload = {
-  /** Source model name */sourceModel: string; /** Source model ID */
-  sourceId: string | number; /** Target model name */
-  targetModel: string; /** Filter used to identify target documents */
-  filter: Record<string, unknown>; /** Update operations applied */
-  update: Record<string, unknown>; /** Number of documents affected */
-  affectedCount: number; /** Current depth in sync chain */
-  depth: number; /** Sync chain path */
+export type SyncEventPayload = {
+  /** Source model name */
+  sourceModel: string;
+  /** Source model ID */
+  sourceId: string | number;
+  /** Target model name */
+  targetModel: string;
+  /** Filter used to identify target documents */
+  filter: Record<string, unknown>;
+  /** Update operations applied */
+  update: Record<string, unknown>;
+  /** Number of documents affected */
+  affectedCount: number;
+  /** Current depth in sync chain */
+  depth: number;
+  /** Sync chain path */
   chain: string[];
 };
 /**
@@ -96,16 +144,26 @@ type SyncEventPayload = {
  *
  * Holds all settings for how a source model syncs to a target model.
  */
-type ModelSyncConfig = {
-  /** Source model class that triggers sync on changes */readonly sourceModel: ChildModel<Model>; /** Target model class that receives synced data */
-  readonly targetModel: ChildModel<Model>; /** Field path in target model where data is embedded */
-  readonly targetField: string; /** Whether this syncs to an array field (true) or single field (false) */
-  readonly isMany: boolean; /** Method name on source model to get embedded data */
-  embedKey: string | string[]; /** Field name used as identifier when syncing to arrays */
-  identifierField: string; /** Maximum depth for chained sync operations */
-  maxSyncDepth: number; /** Fields to watch - sync only triggers when these change (empty = all) */
-  watchFields: string[]; /** Whether to unset the target field when source is deleted */
-  unsetOnDelete: boolean; /** Whether to delete target documents when source is deleted */
+export type ModelSyncConfig = {
+  /** Source model class that triggers sync on changes */
+  readonly sourceModel: ChildModel<Model>;
+  /** Target model class that receives synced data */
+  readonly targetModel: ChildModel<Model>;
+  /** Field path in target model where data is embedded */
+  readonly targetField: string;
+  /** Whether this syncs to an array field (true) or single field (false) */
+  readonly isMany: boolean;
+  /** Method name on source model to get embedded data */
+  embedKey: string | string[];
+  /** Field name used as identifier when syncing to arrays */
+  identifierField: string;
+  /** Maximum depth for chained sync operations */
+  maxSyncDepth: number;
+  /** Fields to watch - sync only triggers when these change (empty = all) */
+  watchFields: string[];
+  /** Whether to unset the target field when source is deleted */
+  unsetOnDelete: boolean;
+  /** Whether to delete target documents when source is deleted */
   removeOnDelete: boolean;
 };
 /**
@@ -121,7 +179,7 @@ type ModelSyncConfig = {
  *   .unsetOnDelete();
  * ```
  */
-interface ModelSyncOperationContract {
+export interface ModelSyncOperationContract {
   /**
    * Set the embed method to call on source model.
    *
@@ -183,7 +241,7 @@ interface ModelSyncOperationContract {
  * });
  * ```
  */
-interface ModelSyncContract {
+export interface ModelSyncContract {
   /**
    * Create a sync operation for a single embedded document.
    *
@@ -211,5 +269,4 @@ interface ModelSyncContract {
   register(callback: () => void): () => void;
 }
 //#endregion
-export { EmbedKey, ModelSyncConfig, ModelSyncContract, ModelSyncOperationContract, SyncConfig, SyncContext, SyncEventPayload, SyncInstruction, SyncInstructionOptions, SyncResult };
 //# sourceMappingURL=types.d.mts.map

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

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/sync/types.ts"],"mappings":";;;;;;;;KAYY,WAAA;EA0BK,2CAxBf,WAAA,UAGA;EAAA,QAAA,mBAMA;EAHA,YAAA,UASA;EANA,SAAA,YASA;EANA,WAAA,UASA;EANA,MAAA,EAAQ,MAAA,mBASG;EANX,MAAA,EAAQ,MAAA,mBAMO;EAHf,aAAA,UAUoB;EAPpB,SAAA,EAAW,IAAA;AAAA;;;;;KAOD,UAAA;EAEV,mDAAA,OAAA,WAMA;EAHA,SAAA,UASA;EANA,SAAA,UAMgB;EAHhB,MAAA,UAG8C;EAA9C,MAAA,EAAQ,KAAA;IAAQ,WAAA,EAAa,eAAA;IAAiB,KAAA,EAAO,KAAA;EAAA,IAMhC;EAHrB,YAAA,UAUU;EAPV,QAAA,EAAU,WAAA;AAAA;;;;;KAOA,eAAA;EAWV,mCATA,WAAA,UAYA;EATA,WAAA,UAeA;EAZA,MAAA,EAAQ,MAAA,mBAkBR;EAfA,MAAA,EAAQ,MAAM,mBAqBd;EAlBA,KAAA,UAqBe;EAlBf,KAAA,YAwBU;EArBV,WAAA;EAGA,QAAA,mBAoBA;EAjBA,aAAA,YAuBA;EApBA,UAAA,WA0BA;EAvBA,eAAA,WA6BA;EA1BA,eAAA;AAAA;;;;KAMU,UAAA;EAgCA,6EA9BV,WAAA;EAGA,MAAA,WA6BA;EA1BA,QAAA,UAgCA;EA7BA,eAAA,UAgCe;EA7Bf,YAAA,UAuDU;EApDV,mBAAA;EAGA,WAAA,YAiDkB;EA9ClB,aAAA,WAmD0B;EAhD1B,gBAAA,EAAkB,UAAU,CAAC,KAAA;AAAA;;;;KAMnB,sBAAA;EAqDF,sCAnDR,YAAA,UAsDQ;EAnDR,SAAA,YAyDA;EAtDA,QAAA,UAyDK;EAtDL,eAAA;AAAA;;;;KA0BU,QAAA;;;;KAKA,gBAAA;EAgEI,wBA9Dd,WAAA,UA8EyC;EA3EzC,QAAA,mBA2EyC;EAxEzC,WAAA,UA+EM;EA5EN,MAAA,EAAQ,MAAA,mBAqFG;EAlFX,MAAA,EAAQ,MAAM,mBA0FL;EAvFT,aAAA,UAgGY;EA7FZ,KAAA,UA2GA;EAxGA,KAAA;AAAA;AA8GW;AAgBb;;;;AAhBa,KAlGD,eAAA;EA6HW,gEA3HZ,WAAA,EAAa,UAAA,CAAW,KAAA,GA6H9B;EAAA,SA1HM,WAAA,EAAa,UAAA,CAAW,KAAA,GAqIvB;EAAA,SAlID,WAAA,UAmIC;EAAA,SAhID,MAAA,WAkIoB;EA/H7B,QAAA,qBA6GA;EA1GA,eAAA,UA2GqB;EAxGrB,YAAA,UAyGU;EAtGV,WAAA,YAsGE;EAnGF,aAAA,WAqGG;EAlGH,cAAA;AAAA;;;;;;;;;;;AAwH6B;;;UAxGd,0BAAA;;;;;;;EAOf,KAAA,CAAM,MAAA;;;;;;;;EASN,UAAA,CAAW,KAAA;;;;;;;EAQX,QAAA,CAAS,KAAA;;;;;;;;EAST,WAAA,CAAY,MAAA;;;;;;EAOZ,aAAA;;;;;;EAOA,cAAA;;;;;EAMA,WAAA;AAAA;;;;;;;;;;;;;;UAgBe,iBAAA;;;;;;;;;EASf,IAAA,CACE,MAAA,EAAQ,UAAA,CAAW,KAAA,GACnB,MAAA,EAAQ,UAAA,CAAW,KAAA,GACnB,KAAA,WACC,0BAAA;;;;;;;;;EAUH,QAAA,CACE,MAAA,EAAQ,UAAA,CAAW,KAAA,GACnB,MAAA,EAAQ,UAAA,CAAW,KAAA,GACnB,KAAA,WACC,0BAAA;;;;;;;EAQH,QAAA,CAAS,QAAA;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/sync/types.ts"],"mappings":";;;;;;;YAYY;;EAEV;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,QAAQ;;EAGR,QAAQ;;EAGR;;EAGA,WAAW;;;;;;YAOD;;EAEV;;EAGA;;EAGA;;EAGA;;EAGA,QAAQ;IAAQ,aAAa;IAAiB,OAAO;;;EAGrD;;EAGA,UAAU;;;;;;YAOA;;EAEV;;EAGA;;EAGA,QAAQ;;EAGR,QAAQ;;EAGR;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;;;;YAMU;;EAEV;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA,kBAAkB,WAAW;;;;;YAMnB;;EAEV;;EAGA;;EAGA;;EAGA;;;;;YA0BU;;;;YAKA;;EAEV;;EAGA;;EAGA;;EAGA,QAAQ;;EAGR,QAAQ;;EAGR;;EAGA;;EAGA;;;;;;;YAYU;;WAED,aAAa,WAAW;;WAGxB,aAAa,WAAW;;WAGxB;;WAGA;;EAGT;;EAGA;;EAGA;;EAGA;;EAGA;;EAGA;;;;;;;;;;;;;;;iBAgBe;;;;;;;EAOf,MAAM;;;;;;;;EASN,WAAW;;;;;;;EAQX,SAAS;;;;;;;;EAST,YAAY;;;;;;EAOZ;;;;;;EAOA;;;;;EAMA;;;;;;;;;;;;;;;iBAgBe;;;;;;;;;EASf,KACE,QAAQ,WAAW,QACnB,QAAQ,WAAW,QACnB,gBACC;;;;;;;;;EAUH,SACE,QAAQ,WAAW,QACnB,QAAQ,WAAW,QACnB,gBACC;;;;;;;EAQH,SAAS"}

package/esm/transactions/after-commit.d.mts

@@ -18,7 +18,7 @@ type AfterCommitCallback = () => void | Promise<void>;
  * @example
  * Product.events().onSaved(() => afterCommit(() => regenerateSitemap()));
  */
-declare function afterCommit(fn: AfterCommitCallback): void;
+export declare function afterCommit(fn: AfterCommitCallback): void;
 //#endregion
-export { afterCommit };
+export {};
 //# sourceMappingURL=after-commit.d.mts.map

package/esm/transactions/after-commit.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"after-commit.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/transactions/after-commit.ts"],"mappings":";KAGK,mBAAA,gBAAmC,OAAO;;;;;AAAA;AAwB/C;;;;AAAmD;;;;;;;;;iBAAnC,WAAA,CAAY,EAAuB,EAAnB,mBAAmB"}
+{"version":3,"file":"after-commit.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/transactions/after-commit.ts"],"mappings":";KAGK,mCAAmC;;;;;;;;;;;;;;;;;;;wBAwBxB,YAAY,IAAI"}

package/esm/types.d.mts

@@ -17,7 +17,7 @@
  * }
  * ```
  */
-type StrictMode = "strip" | "fail" | "allow";
+export type StrictMode = "strip" | "fail" | "allow";
 /**
  * Delete strategy for model destruction.
  *
@@ -42,7 +42,7 @@ type StrictMode = "strip" | "fail" | "allow";
  * await user.destroy({ strategy: "permanent" });
  * ```
  */
-type DeleteStrategy = "trash" | "permanent" | "soft";
+export type DeleteStrategy = "trash" | "permanent" | "soft";
 /**
  * Naming convention for database column names.
  *
@@ -63,7 +63,7 @@ type DeleteStrategy = "trash" | "permanent" | "soft";
  * // Results in: createdAt, updatedAt, deletedAt
  * ```
  */
-type NamingConvention = "camelCase" | "snake_case";
+export type NamingConvention = "camelCase" | "snake_case";
 /**
  * Unified model default configuration.
  *
@@ -103,7 +103,7 @@ type NamingConvention = "camelCase" | "snake_case";
  * }
  * ```
  */
-type ModelDefaults = {
+export type ModelDefaults = {
   /**
    * Auto-generate incremental `id` field on insert (NoSQL only).
    *
@@ -302,7 +302,7 @@ type ModelDefaults = {
  * }
  * ```
  */
-type UuidStrategy = "v4" | "v7";
+export type UuidStrategy = "v4" | "v7";
 /**
  * Migration-level defaults configurable per data source.
  *
@@ -327,7 +327,7 @@ type UuidStrategy = "v4" | "v7";
  * }
  * ```
  */
-type MigrationDefaults = {
+export type MigrationDefaults = {
   /**
    * UUID generation strategy for `primaryUuid()` migration shortcut.
    * Each driver maps this to its native SQL/expression.
@@ -389,7 +389,7 @@ type MigrationDefaults = {
  * }
  * ```
  */
-type RelationDefaults = {
+export type RelationDefaults = {
   /**
    * Suffix appended to the inferred relation name to form the foreign-key
    * column name.
@@ -419,5 +419,4 @@ type RelationDefaults = {
   pivotTableNamingOrder?: "alphabetical" | "owner_first";
 };
 //#endregion
-export { DeleteStrategy, MigrationDefaults, ModelDefaults, NamingConvention, RelationDefaults, StrictMode, UuidStrategy };
 //# sourceMappingURL=types.d.mts.map

package/esm/types.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../packages/cascade/src/types.ts"],"mappings":";;AAkBA;;;;AAAsB;AA0BtB;;;;AAA0B;AAsB1B;;;;AAA4B;AAyC5B;;KAzFY,UAAA;;;;;;;;;;;;;;;;;;;;;;;;AA+SyB;KArRzB,cAAA;;;;AA2SY;AA0BxB;;;;;;;;;AA0CY;AAuBZ;;;;AA4BuB;;KA5YX,gBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAyCA,aAAA;;;;;;;;;;;EAeV,cAAA;;;;;;;;;;;EAYA,SAAA;;;;;;;;;;;;;;;;;EAkBA,eAAA;;;;;;;;;;;EAYA,aAAA;;;;;;;;;;;;;;;;;EAkBA,eAAA;;;;;;;;;EAcA,UAAA;;;;;;;;;;;;;;EAeA,eAAA;;;;;;;;;;;;;;EAeA,eAAA;;;;;;;;;;;;;;;;EAqBA,cAAA,GAAiB,cAAA;;;;;;;;;;;;;;EAejB,eAAA;;;;;;;;;;;;;;;;;;;EAoBA,UAAA,cAAwB,SAAA;;;;;;;;;;;;;;;EAoBxB,UAAA,GAAa,UAAA;;;;;;;;;;;;;;EAmBb,gBAAA,GAAmB,gBAAA;AAAA;;;;;;;;;;;;;;;;KAsBT,YAAA;;;;;;;;;;;;;;;;;;;;;;;;;KA0BA,iBAAA;;;;;;;EAOV,YAAA,GAAe,YAAY;;;;;;;;;;EAW3B,cAAA;;;;;;;;;;;;;;;;;;;;;;;EAwBA,UAAA;AAAA;;;;;;;;;;;;;;;;;;;;;KAuBU,gBAAA;;;;;;;;;;;EAWV,gBAAA;;;;;;;;;;;;;;;;EAiBA,qBAAqB;AAAA"}
+{"version":3,"file":"types.d.mts","names":[],"sources":["../../../../../../../packages/cascade/src/types.ts"],"mappings":";;;;;;;;;;;;;;;;;;;YAkBY;;;;;;;;;;;;;;;;;;;;;;;;;YA0BA;;;;;;;;;;;;;;;;;;;;;YAsBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAyCA;;;;;;;;;;;EAeV;;;;;;;;;;;EAYA;;;;;;;;;;;;;;;;;EAkBA;;;;;;;;;;;EAYA;;;;;;;;;;;;;;;;;EAkBA;;;;;;;;;EAcA;;;;;;;;;;;;;;EAeA;;;;;;;;;;;;;;EAeA;;;;;;;;;;;;;;;;EAqBA,iBAAiB;;;;;;;;;;;;;;EAejB;;;;;;;;;;;;;;;;;;;EAoBA,wBAAwB;;;;;;;;;;;;;;;EAoBxB,aAAa;;;;;;;;;;;;;;EAmBb,mBAAmB;;;;;;;;;;;;;;;;;YAsBT;;;;;;;;;;;;;;;;;;;;;;;;;YA0BA;;;;;;;EAOV,eAAe;;;;;;;;;;EAWf;;;;;;;;;;;;;;;;;;;;;;;EAwBA;;;;;;;;;;;;;;;;;;;;;;YAuBU;;;;;;;;;;;EAWV;;;;;;;;;;;;;;;;EAiBA"}

package/esm/utils/connect-to-database.d.mts

@@ -1,12 +1,12 @@
 import { DeleteStrategy, MigrationDefaults, ModelDefaults, RelationDefaults } from "../types.mjs";
 import { DriverContract, TransactionContext } from "../contracts/database-driver.contract.mjs";
+import "../contracts/index.mjs";
 import { DataSource } from "../data-source/data-source.mjs";
-
 //#region ../../packages/cascade/src/utils/connect-to-database.d.ts
 /**
  * Supported database driver types.
  */
-type DatabaseDriver = "mongodb" | "postgres" | "mysql";
+export type DatabaseDriver = "mongodb" | "postgres" | "mysql";
 /**
  * Default model configuration options.
  *
@@ -24,7 +24,7 @@ type DatabaseDriver = "mongodb" | "postgres" | "mysql";
  *
  * @see ModelDefaults for complete type definition and documentation
  */
-type ModelDefaultConfig = Partial<ModelDefaults>;
+export type ModelDefaultConfig = Partial<ModelDefaults>;
 /**
  * Connection options for establishing a database connection.
  *
@@ -63,7 +63,7 @@ type ModelDefaultConfig = Partial<ModelDefaults>;
  * };
  * ```
  */
-type ConnectionOptions<TDriverOptions = any, TClientOptions = any> = {
+export type ConnectionOptions<TDriverOptions = any, TClientOptions = any> = {
   /**
    * Database driver to use.
    * @default "mongodb"
@@ -305,7 +305,7 @@ type ConnectionOptions<TDriverOptions = any, TClientOptions = any> = {
  * });
  * ```
  */
-declare function connectToDatabase<TDriverOptions = any, TClientOptions = any>(options: ConnectionOptions<TDriverOptions, TClientOptions>): Promise<DataSource>;
+export declare function connectToDatabase<TDriverOptions = any, TClientOptions = any>(options: ConnectionOptions<TDriverOptions, TClientOptions>): Promise<DataSource>;
 /**
  * Get current driver instance.
  *
@@ -317,12 +317,11 @@ declare function connectToDatabase<TDriverOptions = any, TClientOptions = any>(o
  * const pgDriver = getDatabaseDriver<PostgresDriver>();
  * ```
  */
-declare function getDatabaseDriver<T extends DriverContract = any>(): T;
+export declare function getDatabaseDriver<T extends DriverContract = any>(): T;
 /**
  * Perform database transaction(s)
  * Shorthand to `dataSourceRegister.get().driver.transaction
  */
-declare function transaction<T = any>(fn: (ctx: TransactionContext) => Promise<T>, options?: Record<string, unknown>): Promise<T>;
+export declare function transaction<T = any>(fn: (ctx: TransactionContext) => Promise<T>, options?: Record<string, unknown>): Promise<T>;
 //#endregion
-export { ConnectionOptions, DatabaseDriver, ModelDefaultConfig, connectToDatabase, getDatabaseDriver, transaction };
 //# sourceMappingURL=connect-to-database.d.mts.map

package/esm/utils/connect-to-database.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"connect-to-database.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/connect-to-database.ts"],"mappings":";;;;;;;;KAUY,cAAA;;;;AAAc;AAmB1B;;;;AAAsD;AAwCtD;;;;;;;;KAxCY,kBAAA,GAAqB,OAAO,CAAC,aAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0RhC;AAgDT;;;KAlSY,iBAAA;EAmSiC;;;;EA1R3C,MAAA,GAAS,cAAA;EA2RD;;;;;EApRR,IAAA;EAmRA;;;;EA7QA,SAAA;EAiXc;;;EA5Wd,QAAA;EA4WgC;;;;AAAoC;AAUtE;EA9WE,OAAA;EA8W+B;;;;;;;EAjW/B,GAAA;EAoWQ;;;;EA9VR,IAAA;EA4VyC;;;;EAtVzC,IAAA;EAwVS;;AAAC;EAnVV,QAAA;;;;EAKA,QAAA;;;;;EAMA,UAAA;;;;;;;EAYA,aAAA,GAAgB,cAAA;;;;;;;EAYhB,aAAA,GAAgB,cAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDhB,YAAA,GAAe,kBAAA;;;;;;;;;;;;;;;;EAiBf,gBAAA,GAAmB,iBAAA;;;;;;;;;;;;;;;;;EAkBnB,eAAA,GAAkB,gBAAA;;;;;;;;;;;EAgBlB,qBAAA,GAAwB,cAAA;;;;;;;;;;;EAYxB,iBAAA;;;;EASA,UAAA;;;;;;;;;;;;IAYE,aAAA;;;;;;IAOA,KAAA;EAAA;AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAgDkB,iBAAA,6CACpB,OAAA,EAAS,iBAAA,CAAkB,cAAA,EAAgB,cAAA,IAC1C,OAAA,CAAQ,UAAA;;;;;;;;;;;;iBAmGK,iBAAA,WAA4B,cAAA,WAAyB,CAAC;;;;;iBAUhD,WAAA,UACpB,EAAA,GAAK,GAAA,EAAK,kBAAA,KAAuB,OAAA,CAAQ,CAAA,GACzC,OAAA,GAAU,MAAA,oBACT,OAAA,CAAQ,CAAA"}
+{"version":3,"file":"connect-to-database.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/connect-to-database.ts"],"mappings":";;;;;;;;YAUY;;;;;;;;;;;;;;;;;;YAmBA,qBAAqB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAwC7B,kBAAkB,sBAAsB;;;;;EASlD,SAAS;;;;;;EAOT;;;;;EAMA;;;;EAKA;;;;;;;EAQA;;;;;;;;EAaA;;;;;EAMA;;;;;EAMA;;;;EAKA;;;;EAKA;;;;;EAMA;;;;;;;EAYA,gBAAgB;;;;;;;EAYhB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDhB,eAAe;;;;;;;;;;;;;;;;EAiBf,mBAAmB;;;;;;;;;;;;;;;;;EAkBnB,kBAAkB;;;;;;;;;;;EAgBlB,wBAAwB;;;;;;;;;;;EAYxB;;;;EASA;;;;;;;;;;;;IAYE;;;;;;IAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAgDkB,kBAAkB,sBAAsB,sBAC5D,SAAS,kBAAkB,gBAAgB,kBAC1C,QAAQ;;;;;;;;;;;;wBAmGK,kBAAkB,UAAU,yBAAyB;;;;;wBAU/C,YAAY,SAChC,KAAK,KAAK,uBAAuB,QAAQ,IACzC,UAAU,0BACT,QAAQ"}

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

@@ -1,6 +1,5 @@
 import { Model } from "../model/model.mjs";
 import { TransformerCallback } from "@warlock.js/seal";
-
 //#region ../../packages/cascade/src/utils/database-writer.utils.d.ts
 type transformCallbackOptions = {
   model: Model;
@@ -9,11 +8,11 @@ type transformCallbackOptions = {
   isChanged: boolean;
   isNew: boolean;
 };
-type ModelTransformCallback = (options: transformCallbackOptions) => unknown | Promise<unknown>;
+export type ModelTransformCallback = (options: transformCallbackOptions) => unknown | Promise<unknown>;
 /**
  * Transfer value before saving it into the database
  */
-declare function useModelTransformer(callback: ModelTransformCallback): TransformerCallback;
+export declare function useModelTransformer(callback: ModelTransformCallback): TransformerCallback;
 //#endregion
-export { ModelTransformCallback, useModelTransformer };
+export {};
 //# sourceMappingURL=database-writer.utils.d.mts.map

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

@@ -1 +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"}
+{"version":3,"file":"database-writer.utils.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/database-writer.utils.ts"],"mappings":";;;KAGK;EACH,OAAO;EACP;EACA;EACA;EACA;;YAGU,0BACV,SAAS,uCACI;;;;wBAKC,oBAAoB,UAAU,yBAAsB"}

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

@@ -1 +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"}
+{"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 = (\n  options: transformCallbackOptions,\n) => 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":";;;;AAkBA,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

@@ -2,12 +2,11 @@ import { DeleteStrategy, StrictMode } from "../types.mjs";
 import { ModelSchema } from "../model/model.types.mjs";
 import { Model } from "../model/model.mjs";
 import { Infer, ObjectValidator } from "@warlock.js/seal";
-
 //#region ../../packages/cascade/src/utils/define-model.d.ts
 /**
  * Configuration options for defining a model.
  */
-type DefineModelOptions<TSchema extends ModelSchema> = {
+export type DefineModelOptions<TSchema extends ModelSchema> = {
   /**
    * The database table/collection name.
    */
@@ -157,7 +156,7 @@ type DefineModelOptions<TSchema extends ModelSchema> = {
  * console.log(post.title); // ✅ Type-safe!
  * ```
  */
-declare function defineModel<TSchema extends ModelSchema, TSchemaValidator extends ObjectValidator = ObjectValidator, TProperties extends Record<string, any> = {}, TStatics extends Record<string, any> = {}>(options: DefineModelOptions<TSchema> & {
+export declare function defineModel<TSchema extends ModelSchema, TSchemaValidator extends ObjectValidator = ObjectValidator, TProperties extends Record<string, any> = {}, TStatics extends Record<string, any> = {}>(options: DefineModelOptions<TSchema> & {
   schema: TSchemaValidator;
   properties?: ThisType<Model<Infer.Output<TSchemaValidator>>> & TProperties;
   statics?: ThisType<typeof Model<Infer.Output<TSchemaValidator>>> & TStatics;
@@ -179,7 +178,6 @@ declare function defineModel<TSchema extends ModelSchema, TSchemaValidator exten
  * // { name: string; email: string; }
  * ```
  */
-type ModelType<T extends ReturnType<typeof defineModel>> = T extends (new (...args: any[]) => infer R) ? R extends Model<infer S> ? S : never : never;
+export type ModelType<T extends ReturnType<typeof defineModel>> = T extends (new (...args: any[]) => infer R) ? R extends Model<infer S> ? S : never : never;
 //#endregion
-export { DefineModelOptions, ModelType, defineModel };
 //# sourceMappingURL=define-model.d.mts.map

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

@@ -1 +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"}
+{"version":3,"file":"define-model.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/define-model.ts"],"mappings":";;;;;;;;YASY,mBAAmB,gBAAgB;;;;EAI7C;;;;;EAMA;;;;;EAMA,QAAQ;;;;;;;;;;;EAYR,iBAAiB;;;;;;;;EASjB,aAAa;;;;;;;EAQb;;;;;;EAOA;;;;;;EAOA;;;;;;;;;;;;;;;;;;;;;;;EAwBA,aAAa,SAAS,MAAM,YAAY;;;;;;;;;;;;;;;;;EAkBxC,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA2DI,YACd,gBAAgB,aAChB,yBAAyB,kBAAkB,iBAC3C,oBAAoB,0BACpB,iBAAiB,0BAEjB,SAAS,mBAAmB;EAC1B,QAAQ;EACR,aAAa,SAAS,MAAM,MAAM,OAAO,sBAAsB;EAC/D,UAAU,gBAAgB,MAAM,MAAM,OAAO,sBAAsB;UACpE,cAyEoB,QAAO,MAAA,OAAA,uBAAmB,MAAK,MAAA,OAAA,qBAAmB,eAAW,YAAA,gBAAA;;;;;;;;;;;;;;;;;;YAwBxE,UAAU,UAAU,kBAAkB,gBAAgB,mBAC7D,sBACM,KACP,UAAU,YAAY,KACpB"}

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

@@ -28,7 +28,7 @@
  * escapeRegex("(a+)+$"); // "\\(a\\+\\)\\+\\$"
  * ```
  */
-declare function escapeRegex(value: string): string;
+export declare function escapeRegex(value: string): string;
 /**
  * Compile a `whereLike` pattern into regex source.
  *
@@ -51,7 +51,7 @@ declare function escapeRegex(value: string): string;
  * likePatternToRegexSource("a.b");       // "a\\.b"  (a literal dot)
  * ```
  */
-declare function likePatternToRegexSource(pattern: string): string;
+export declare function likePatternToRegexSource(pattern: string): string;
 /**
  * Resolve a `whereLike`-style argument to regex source.
  *
@@ -61,7 +61,6 @@ declare function likePatternToRegexSource(pattern: string): string;
  * @param pattern - A `RegExp` (trusted, used verbatim) or a string (escaped)
  * @returns Regex source ready for `$regex`
  */
-declare function resolveLikePattern(pattern: RegExp | string): string;
+export declare function resolveLikePattern(pattern: RegExp | string): string;
 //#endregion
-export { escapeRegex, likePatternToRegexSource, resolveLikePattern };
 //# sourceMappingURL=escape-regex.d.mts.map

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

@@ -1 +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"}
+{"version":3,"file":"escape-regex.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/escape-regex.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAiCgB,YAAY;;;;;;;;;;;;;;;;;;;;;;;wBA0BZ,yBAAyB;;;;;;;;;;wBAazB,mBAAmB,SAAS"}

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

@@ -1 +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"}
+{"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 (\n    written.getUTCFullYear() === y && written.getUTCMonth() + 1 === m && written.getUTCDate() === d\n  );\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,OACE,QAAQ,eAAe,MAAM,KAAK,QAAQ,YAAY,IAAI,MAAM,KAAK,QAAQ,WAAW,MAAM;AAElG"}

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

@@ -1,5 +1,4 @@
 import { DataSource } from "../data-source/data-source.mjs";
-
 //#region ../../packages/cascade/src/utils/once-connected.d.ts
 /**
  * Execute a callback once the driver is connected.
@@ -72,7 +71,7 @@ import { DataSource } from "../data-source/data-source.mjs";
  * });
  * ```
  */
-declare function onceConnected(dataSourceOrNameOrCallback: DataSource | string | ((dataSource: DataSource) => void), callback?: (dataSource: DataSource) => void): void;
+export declare function onceConnected(dataSourceOrNameOrCallback: DataSource | string | ((dataSource: DataSource) => void), callback?: (dataSource: DataSource) => void): void;
 /**
  * Execute a callback once the driver is disconnected.
  *
@@ -144,7 +143,6 @@ declare function onceConnected(dataSourceOrNameOrCallback: DataSource | string |
  * });
  * ```
  */
-declare function onceDisconnected(dataSourceOrNameOrCallback: DataSource | string | ((dataSource: DataSource) => void), callback?: (dataSource: DataSource) => void): void;
+export declare function onceDisconnected(dataSourceOrNameOrCallback: DataSource | string | ((dataSource: DataSource) => void), callback?: (dataSource: DataSource) => void): void;
 //#endregion
-export { onceConnected, onceDisconnected };
 //# sourceMappingURL=once-connected.d.mts.map

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

@@ -1 +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"}
+{"version":3,"file":"once-connected.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/once-connected.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAqFgB,cACd,4BAA4B,wBAAwB,YAAY,sBAChE,YAAY,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAmIV,iBACd,4BAA4B,wBAAwB,YAAY,sBAChE,YAAY,YAAY"}

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

@@ -9,7 +9,7 @@
  * @param field - The field name, used for the error message
  * @throws UndefinedWhereValueError when `value` is `undefined`
  */
-declare const assertDefined: (value: unknown, field: string) => void;
+export declare const assertDefined: (value: unknown, field: string) => void;
 /**
  * Assert a single equality-position value carries no `$`-prefixed keys and
  * is not `undefined`. Scalars, `Date`s and other non-plain objects pass
@@ -22,7 +22,7 @@ declare const assertDefined: (value: unknown, field: string) => void;
  * @throws UnsafeFilterError when a `$`-prefixed key is found
  * @throws UndefinedWhereValueError when `value` is `undefined`
  */
-declare function sanitizeFilterValue<T>(value: T, field: string): T;
+export declare function sanitizeFilterValue<T>(value: T, field: string): T;
 /**
  * Assert a `{ field: value }` equality filter carries no `$`-prefixed keys —
  * neither as top-level field names (`{ $where: … }`) nor inside any value
@@ -35,7 +35,6 @@ declare function sanitizeFilterValue<T>(value: T, field: string): T;
  * @throws UnsafeFilterError when a `$`-prefixed key is found
  * @throws UndefinedWhereValueError when a field's value is `undefined`
  */
-declare function sanitizeFilter<T extends Record<string, unknown>>(filter: T): T;
+export declare function sanitizeFilter<T extends Record<string, unknown>>(filter: T): T;
 //#endregion
-export { assertDefined, sanitizeFilter, sanitizeFilterValue };
 //# sourceMappingURL=sanitize-filter.d.mts.map

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

@@ -1 +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"}
+{"version":3,"file":"sanitize-filter.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/utils/sanitize-filter.ts"],"mappings":";;;;;;;;;;;qBAmEa,gBAAa,gBAAkB;;;;;;;;;;;;;wBAkB5B,oBAAoB,GAAG,OAAO,GAAG,gBAAgB;;;;;;;;;;;;;wBAkBjD,eAAe,UAAU,yBAAyB,QAAQ,IAAI"}

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

@@ -1 +1,2 @@
-export { };
+import "./plugins/database-rules-plugin.mjs";
+import "./plugins/embed-validator-plugin.mjs";