@warlock.js/cascade 5.30.0 → 5.32.0

package/esm/expressions/column-expressions.d.mts

@@ -39,17 +39,17 @@
  * ```
  */
 /** Discriminator tag identifying a node in the column-expression tree. */
-type ColumnExpressionType = "column" | "literal" | "add" | "subtract" | "multiply" | "divide" | "raw";
+export type ColumnExpressionType = "column" | "literal" | "add" | "subtract" | "multiply" | "divide" | "raw";
 /**
  * A reference to a column/field. The driver is responsible for quoting the
  * name (SQL) or prefixing it with `$` (Mongo) — it is never interpolated raw.
  */
-type ColumnRefExpression = {
+export type ColumnRefExpression = {
   readonly __expr: "column";
   readonly column: string;
 };
 /** A scalar literal value embedded directly in the expression. */
-type LiteralExpression = {
+export type LiteralExpression = {
   readonly __expr: "literal";
   readonly value: number | boolean;
 };
@@ -59,7 +59,7 @@ type LiteralExpression = {
  * `add` / `multiply` are variadic; `subtract` / `divide` take exactly two
  * operands (left, right) since they are not associative.
  */
-type ArithmeticExpression = {
+export type ArithmeticExpression = {
   readonly __expr: "add" | "subtract" | "multiply" | "divide";
   readonly operands: ColumnExpression[];
 };
@@ -68,7 +68,7 @@ type ArithmeticExpression = {
  * generated SQL — callers MUST NOT build it from untrusted input. This is the
  * documented boundary for anything the typed nodes above don't cover.
  */
-type RawColumnExpression = {
+export type RawColumnExpression = {
   readonly __expr: "raw";
   readonly expression: string;
 };
@@ -77,16 +77,16 @@ type RawColumnExpression = {
  * valid expression input wherever this type is accepted — it is interpreted as
  * a column reference.
  */
-type ColumnExpression = ColumnRefExpression | LiteralExpression | ArithmeticExpression | RawColumnExpression;
+export type ColumnExpression = ColumnRefExpression | LiteralExpression | ArithmeticExpression | RawColumnExpression;
 /** Input accepted by expression-aware helpers: a typed node or a column-name string. */
-type ColumnExpressionInput = ColumnExpression | string;
+export type ColumnExpressionInput = ColumnExpression | string;
 /**
  * Type guard: is `value` one of the typed column-expression nodes?
  *
  * @param value - The value to test
  * @returns `true` when `value` is a `ColumnExpression` node
  */
-declare function isColumnExpression(value: unknown): value is ColumnExpression;
+export declare function isColumnExpression(value: unknown): value is ColumnExpression;
 /**
  * Reference a column/field by name.
  *
@@ -151,7 +151,7 @@ declare function raw(expression: string): RawColumnExpression;
  * @param input - A typed expression node or a bare column-name string
  * @returns The corresponding `ColumnExpression` node
  */
-declare function toColumnExpression(input: ColumnExpressionInput): ColumnExpression;
+export declare function toColumnExpression(input: ColumnExpressionInput): ColumnExpression;
 /**
  * Typed, database-agnostic column-expression builders.
  *
@@ -179,7 +179,7 @@ declare function toColumnExpression(input: ColumnExpressionInput): ColumnExpress
  * $agg.sum($expr.raw("price * quantity * (1 - discount)"));
  * ```
  */
-declare const $expr: {
+export declare const $expr: {
   col: typeof col;
   lit: typeof lit;
   mul: typeof mul;
@@ -189,5 +189,5 @@ declare const $expr: {
   raw: typeof raw;
 };
 //#endregion
-export { $expr, ArithmeticExpression, ColumnExpression, ColumnExpressionInput, ColumnExpressionType, ColumnRefExpression, LiteralExpression, RawColumnExpression, isColumnExpression, toColumnExpression };
+export {};
 //# sourceMappingURL=column-expressions.d.mts.map

package/esm/expressions/column-expressions.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"column-expressions.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/expressions/column-expressions.ts"],"mappings":";;AAyCA;;;;AAAgC;AAahC;;;;AAEiB;AAIjB;;;;AAEgB;AAShB;;;;;;;;AAEqC;AAQrC;;;;AAEqB;AAQrB;;;;;;;;;;KAlDY,oBAAA;;;;AAsDW;KAzCX,mBAAA;EAAA,SACD,MAAA;EAAA,SACA,MAAM;AAAA;AA0CmC;AAAA,KAtCxC,iBAAA;EAAA,SACD,MAAA;EAAA,SACA,KAAK;AAAA;;;;;AA4C6D;AAM5E;KAzCW,oBAAA;EAAA,SACD,MAAA;EAAA,SACA,QAAA,EAAU,gBAAgB;AAAA;AA+CY;;;;AAUO;AAVP,KAvCrC,mBAAA;EAAA,SACD,MAAA;EAAA,SACA,UAAU;AAAA;;;;;AAyDmD;KAjD5D,gBAAA,GACR,mBAAA,GACA,iBAAA,GACA,oBAAA,GACA,mBAAA;;KAGQ,qBAAA,GAAwB,gBAAgB;;;;;;AAoDoB;iBA5CxD,kBAAA,CAAmB,KAAA,YAAiB,KAAA,IAAS,gBAAgB;;;;;;;iBAcpE,GAAA,CAAI,MAAA,WAAiB,mBAAmB;;;;;;;iBAUxC,GAAA,CAAI,KAAA,qBAA0B,iBAAiB;AAkCjC;;;;;;AAAA,iBAxBd,GAAA,IAAO,QAAA,EAAU,qBAAA,KAA0B,oBAAoB;;;;;;;iBAU/D,GAAA,IAAO,QAAA,EAAU,qBAAA,KAA0B,oBAAoB;AA+BjD;AAAA;;;;AAkB8B;AAYrD;AA9BuB,iBApBd,GAAA,CACP,IAAA,EAAM,qBAAA,EACN,KAAA,EAAO,qBAAA,GACN,oBAAA;;;;;;;AA+C+E;iBAjCzE,GAAA,CACP,IAAA,EAAM,qBAAA,EACN,KAAA,EAAO,qBAAA,GACN,oBAAA;;;;;;;;;;;;iBAkBM,GAAA,CAAI,UAAA,WAAqB,mBAAmB;;;;;;;;;iBAYrC,kBAAA,CAAmB,KAAA,EAAO,qBAAA,GAAwB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA+BrE,KAAA"}
+{"version":3,"file":"column-expressions.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/expressions/column-expressions.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAyCY;;;;;YAaA;WACD;WACA;;;YAIC;WACD;WACA;;;;;;;;YASC;WACD;WACA,UAAU;;;;;;;YAQT;WACD;WACA;;;;;;;YAQC,mBACR,sBACA,oBACA,uBACA;;YAGQ,wBAAwB;;;;;;;wBAQpB,mBAAmB,iBAAiB,SAAS;;;;;;;iBAcpD,IAAI,iBAAiB;;;;;;;iBAUrB,IAAI,0BAA0B;;;;;;;iBAU9B,OAAO,UAAU,0BAA0B;;;;;;;iBAU3C,OAAO,UAAU,0BAA0B;;;;;;;;iBAW3C,IAAI,MAAM,uBAAuB,OAAO,wBAAwB;;;;;;;;iBAchE,IAAI,MAAM,uBAAuB,OAAO,wBAAwB;;;;;;;;;;;;iBAkBhE,IAAI,qBAAqB;;;;;;;;;wBAYlB,mBAAmB,OAAO,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;qBA+BrD"}

package/esm/expressions/column-expressions.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"column-expressions.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/expressions/column-expressions.ts"],"sourcesContent":["/**\n * Database-agnostic, **typed** column expressions for aggregate inputs.\n *\n * These let `$agg.sum(...)` (and any future expression-accepting aggregate)\n * operate on a composed arithmetic expression — e.g. `price * quantity` — not\n * just a bare column, while staying portable across drivers.\n *\n * The builders are grouped under a single `$expr` object (mirroring `$agg`),\n * so the package root exposes exactly two expression namespaces — `$agg` for\n * aggregates and `$expr` for the scalar arithmetic that feeds them — rather\n * than a handful of collision-prone bare verbs (`mul`, `add`, `col`, …).\n *\n * The expression tree is a small, closed union of safe nodes:\n *\n * - `$expr.col(\"price\")` — a column reference (driver quotes/escapes it)\n * - `$expr.lit(2)` — a numeric/boolean literal\n * - `$expr.mul(a, b, …)` / `$expr.add(…)` / `$expr.sub(a, b)` / `$expr.div(a, b)` — arithmetic\n * - `$expr.raw(\"price * 1.2\")` — an explicit escape hatch for a raw SQL fragment\n *\n * Only `$expr.raw` ever embeds an uninterpreted string, and it is opt-in by\n * name. Everything else is composed from typed nodes, so user-supplied column\n * names flow through the driver's identifier-quoting path rather than being\n * string-interpolated into SQL. This is the boundary the S2 task calls out: a\n * tiny typed DSL for the common safe ops, plus a clearly-named raw escape\n * hatch for everything beyond it.\n *\n * Bare strings are still accepted everywhere a `ColumnExpression` is — a plain\n * string is treated as a column reference (`\"price\"` === `$expr.col(\"price\")`),\n * so the existing `$agg.sum(\"amount\")` call site keeps working unchanged.\n *\n * @example\n * ```typescript\n * import { $agg, $expr } from \"@warlock.js/cascade\";\n *\n * query.groupByDate(\"created_at\", \"month\", {\n *   revenue: $agg.sum($expr.mul(\"price\", \"quantity\")),\n * });\n * ```\n */\n\n/** Discriminator tag identifying a node in the column-expression tree. */\nexport type ColumnExpressionType =\n  | \"column\"\n  | \"literal\"\n  | \"add\"\n  | \"subtract\"\n  | \"multiply\"\n  | \"divide\"\n  | \"raw\";\n\n/**\n * A reference to a column/field. The driver is responsible for quoting the\n * name (SQL) or prefixing it with `$` (Mongo) — it is never interpolated raw.\n */\nexport type ColumnRefExpression = {\n  readonly __expr: \"column\";\n  readonly column: string;\n};\n\n/** A scalar literal value embedded directly in the expression. */\nexport type LiteralExpression = {\n  readonly __expr: \"literal\";\n  readonly value: number | boolean;\n};\n\n/**\n * An arithmetic operation over one or more operands.\n *\n * `add` / `multiply` are variadic; `subtract` / `divide` take exactly two\n * operands (left, right) since they are not associative.\n */\nexport type ArithmeticExpression = {\n  readonly __expr: \"add\" | \"subtract\" | \"multiply\" | \"divide\";\n  readonly operands: ColumnExpression[];\n};\n\n/**\n * A raw expression escape hatch. The string is emitted verbatim into the\n * generated SQL — callers MUST NOT build it from untrusted input. This is the\n * documented boundary for anything the typed nodes above don't cover.\n */\nexport type RawColumnExpression = {\n  readonly __expr: \"raw\";\n  readonly expression: string;\n};\n\n/**\n * Any node in the typed column-expression tree. A bare `string` is also a\n * valid expression input wherever this type is accepted — it is interpreted as\n * a column reference.\n */\nexport type ColumnExpression =\n  | ColumnRefExpression\n  | LiteralExpression\n  | ArithmeticExpression\n  | RawColumnExpression;\n\n/** Input accepted by expression-aware helpers: a typed node or a column-name string. */\nexport type ColumnExpressionInput = ColumnExpression | string;\n\n/**\n * Type guard: is `value` one of the typed column-expression nodes?\n *\n * @param value - The value to test\n * @returns `true` when `value` is a `ColumnExpression` node\n */\nexport function isColumnExpression(value: unknown): value is ColumnExpression {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as ColumnExpression).__expr === \"string\"\n  );\n}\n\n/**\n * Reference a column/field by name.\n *\n * @param column - The column/field name\n * @returns A column-reference expression node\n */\nfunction col(column: string): ColumnRefExpression {\n  return { __expr: \"column\", column };\n}\n\n/**\n * A scalar literal (number or boolean) operand.\n *\n * @param value - The literal value\n * @returns A literal expression node\n */\nfunction lit(value: number | boolean): LiteralExpression {\n  return { __expr: \"literal\", value };\n}\n\n/**\n * Multiply two or more operands.\n *\n * @param operands - Column names, literals, or nested expression nodes\n * @returns A multiply expression node\n */\nfunction mul(...operands: ColumnExpressionInput[]): ArithmeticExpression {\n  return { __expr: \"multiply\", operands: operands.map(toColumnExpression) };\n}\n\n/**\n * Add two or more operands.\n *\n * @param operands - Column names, literals, or nested expression nodes\n * @returns An add expression node\n */\nfunction add(...operands: ColumnExpressionInput[]): ArithmeticExpression {\n  return { __expr: \"add\", operands: operands.map(toColumnExpression) };\n}\n\n/**\n * Subtract `right` from `left`.\n *\n * @param left - The minuend\n * @param right - The subtrahend\n * @returns A subtract expression node\n */\nfunction sub(\n  left: ColumnExpressionInput,\n  right: ColumnExpressionInput,\n): ArithmeticExpression {\n  return {\n    __expr: \"subtract\",\n    operands: [toColumnExpression(left), toColumnExpression(right)],\n  };\n}\n\n/**\n * Divide `left` by `right`.\n *\n * @param left - The dividend\n * @param right - The divisor\n * @returns A divide expression node\n */\nfunction div(\n  left: ColumnExpressionInput,\n  right: ColumnExpressionInput,\n): ArithmeticExpression {\n  return {\n    __expr: \"divide\",\n    operands: [toColumnExpression(left), toColumnExpression(right)],\n  };\n}\n\n/**\n * Wrap a raw expression string as an escape hatch.\n *\n * The string is emitted verbatim — never build it from untrusted input. Use\n * this only when the typed `$expr.mul` / `$expr.add` / `$expr.sub` /\n * `$expr.div` / `$expr.col` / `$expr.lit` combinators can't express what you\n * need.\n *\n * @param expression - A raw, driver-native expression fragment\n * @returns A raw expression node\n */\nfunction raw(expression: string): RawColumnExpression {\n  return { __expr: \"raw\", expression };\n}\n\n/**\n * Normalize an expression input to a `ColumnExpression` node. A bare string\n * becomes a `$expr.col(...)` reference; an existing node passes through\n * unchanged.\n *\n * @param input - A typed expression node or a bare column-name string\n * @returns The corresponding `ColumnExpression` node\n */\nexport function toColumnExpression(input: ColumnExpressionInput): ColumnExpression {\n  return typeof input === \"string\" ? col(input) : input;\n}\n\n/**\n * Typed, database-agnostic column-expression builders.\n *\n * Grouped under one object (like `$agg`) so the scalar arithmetic that feeds\n * an aggregate reads as a single, discoverable namespace: `$agg.sum($expr.mul(\n * \"price\", \"quantity\"))`. Each builder returns a plain, closed `ColumnExpression`\n * node — the driver translates it to native SQL / a Mongo pipeline.\n *\n * @example\n * ```typescript\n * import { $agg, $expr } from \"@warlock.js/cascade\";\n *\n * // SUM(price * quantity)\n * query.groupBy(\"product_id\", { revenue: $agg.sum($expr.mul(\"price\", \"quantity\")) });\n *\n * // SUM((1 - discount) * price)\n * query.groupBy(\"product_id\", {\n *   net: $agg.sum($expr.mul($expr.sub($expr.lit(1), \"discount\"), \"price\")),\n * });\n *\n * // price * 1.2 (e.g. tax)\n * $agg.sum($expr.mul(\"price\", $expr.lit(1.2)));\n *\n * // escape hatch (Postgres-only, emitted verbatim — never from user input)\n * $agg.sum($expr.raw(\"price * quantity * (1 - discount)\"));\n * ```\n */\nexport const $expr = {\n  col,\n  lit,\n  mul,\n  add,\n  sub,\n  div,\n  raw,\n};\n"],"mappings":";;;;;;;AA0GA,SAAgB,mBAAmB,OAA2C;CAC5E,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAA2B,WAAW;AAElD;;;;;;;AAQA,SAAS,IAAI,QAAqC;CAChD,OAAO;EAAE,QAAQ;EAAU;CAAO;AACpC;;;;;;;AAQA,SAAS,IAAI,OAA4C;CACvD,OAAO;EAAE,QAAQ;EAAW;CAAM;AACpC;;;;;;;AAQA,SAAS,IAAI,GAAG,UAAyD;CACvE,OAAO;EAAE,QAAQ;EAAY,UAAU,SAAS,IAAI,kBAAkB;CAAE;AAC1E;;;;;;;AAQA,SAAS,IAAI,GAAG,UAAyD;CACvE,OAAO;EAAE,QAAQ;EAAO,UAAU,SAAS,IAAI,kBAAkB;CAAE;AACrE;;;;;;;;AASA,SAAS,IACP,MACA,OACsB;CACtB,OAAO;EACL,QAAQ;EACR,UAAU,CAAC,mBAAmB,IAAI,GAAG,mBAAmB,KAAK,CAAC;CAChE;AACF;;;;;;;;AASA,SAAS,IACP,MACA,OACsB;CACtB,OAAO;EACL,QAAQ;EACR,UAAU,CAAC,mBAAmB,IAAI,GAAG,mBAAmB,KAAK,CAAC;CAChE;AACF;;;;;;;;;;;;AAaA,SAAS,IAAI,YAAyC;CACpD,OAAO;EAAE,QAAQ;EAAO;CAAW;AACrC;;;;;;;;;AAUA,SAAgB,mBAAmB,OAAgD;CACjF,OAAO,OAAO,UAAU,WAAW,IAAI,KAAK,IAAI;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,QAAQ;CACnB;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}
+{"version":3,"file":"column-expressions.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/expressions/column-expressions.ts"],"sourcesContent":["/**\n * Database-agnostic, **typed** column expressions for aggregate inputs.\n *\n * These let `$agg.sum(...)` (and any future expression-accepting aggregate)\n * operate on a composed arithmetic expression — e.g. `price * quantity` — not\n * just a bare column, while staying portable across drivers.\n *\n * The builders are grouped under a single `$expr` object (mirroring `$agg`),\n * so the package root exposes exactly two expression namespaces — `$agg` for\n * aggregates and `$expr` for the scalar arithmetic that feeds them — rather\n * than a handful of collision-prone bare verbs (`mul`, `add`, `col`, …).\n *\n * The expression tree is a small, closed union of safe nodes:\n *\n * - `$expr.col(\"price\")` — a column reference (driver quotes/escapes it)\n * - `$expr.lit(2)` — a numeric/boolean literal\n * - `$expr.mul(a, b, …)` / `$expr.add(…)` / `$expr.sub(a, b)` / `$expr.div(a, b)` — arithmetic\n * - `$expr.raw(\"price * 1.2\")` — an explicit escape hatch for a raw SQL fragment\n *\n * Only `$expr.raw` ever embeds an uninterpreted string, and it is opt-in by\n * name. Everything else is composed from typed nodes, so user-supplied column\n * names flow through the driver's identifier-quoting path rather than being\n * string-interpolated into SQL. This is the boundary the S2 task calls out: a\n * tiny typed DSL for the common safe ops, plus a clearly-named raw escape\n * hatch for everything beyond it.\n *\n * Bare strings are still accepted everywhere a `ColumnExpression` is — a plain\n * string is treated as a column reference (`\"price\"` === `$expr.col(\"price\")`),\n * so the existing `$agg.sum(\"amount\")` call site keeps working unchanged.\n *\n * @example\n * ```typescript\n * import { $agg, $expr } from \"@warlock.js/cascade\";\n *\n * query.groupByDate(\"created_at\", \"month\", {\n *   revenue: $agg.sum($expr.mul(\"price\", \"quantity\")),\n * });\n * ```\n */\n\n/** Discriminator tag identifying a node in the column-expression tree. */\nexport type ColumnExpressionType =\n  | \"column\"\n  | \"literal\"\n  | \"add\"\n  | \"subtract\"\n  | \"multiply\"\n  | \"divide\"\n  | \"raw\";\n\n/**\n * A reference to a column/field. The driver is responsible for quoting the\n * name (SQL) or prefixing it with `$` (Mongo) — it is never interpolated raw.\n */\nexport type ColumnRefExpression = {\n  readonly __expr: \"column\";\n  readonly column: string;\n};\n\n/** A scalar literal value embedded directly in the expression. */\nexport type LiteralExpression = {\n  readonly __expr: \"literal\";\n  readonly value: number | boolean;\n};\n\n/**\n * An arithmetic operation over one or more operands.\n *\n * `add` / `multiply` are variadic; `subtract` / `divide` take exactly two\n * operands (left, right) since they are not associative.\n */\nexport type ArithmeticExpression = {\n  readonly __expr: \"add\" | \"subtract\" | \"multiply\" | \"divide\";\n  readonly operands: ColumnExpression[];\n};\n\n/**\n * A raw expression escape hatch. The string is emitted verbatim into the\n * generated SQL — callers MUST NOT build it from untrusted input. This is the\n * documented boundary for anything the typed nodes above don't cover.\n */\nexport type RawColumnExpression = {\n  readonly __expr: \"raw\";\n  readonly expression: string;\n};\n\n/**\n * Any node in the typed column-expression tree. A bare `string` is also a\n * valid expression input wherever this type is accepted — it is interpreted as\n * a column reference.\n */\nexport type ColumnExpression =\n  | ColumnRefExpression\n  | LiteralExpression\n  | ArithmeticExpression\n  | RawColumnExpression;\n\n/** Input accepted by expression-aware helpers: a typed node or a column-name string. */\nexport type ColumnExpressionInput = ColumnExpression | string;\n\n/**\n * Type guard: is `value` one of the typed column-expression nodes?\n *\n * @param value - The value to test\n * @returns `true` when `value` is a `ColumnExpression` node\n */\nexport function isColumnExpression(value: unknown): value is ColumnExpression {\n  return (\n    typeof value === \"object\" &&\n    value !== null &&\n    typeof (value as ColumnExpression).__expr === \"string\"\n  );\n}\n\n/**\n * Reference a column/field by name.\n *\n * @param column - The column/field name\n * @returns A column-reference expression node\n */\nfunction col(column: string): ColumnRefExpression {\n  return { __expr: \"column\", column };\n}\n\n/**\n * A scalar literal (number or boolean) operand.\n *\n * @param value - The literal value\n * @returns A literal expression node\n */\nfunction lit(value: number | boolean): LiteralExpression {\n  return { __expr: \"literal\", value };\n}\n\n/**\n * Multiply two or more operands.\n *\n * @param operands - Column names, literals, or nested expression nodes\n * @returns A multiply expression node\n */\nfunction mul(...operands: ColumnExpressionInput[]): ArithmeticExpression {\n  return { __expr: \"multiply\", operands: operands.map(toColumnExpression) };\n}\n\n/**\n * Add two or more operands.\n *\n * @param operands - Column names, literals, or nested expression nodes\n * @returns An add expression node\n */\nfunction add(...operands: ColumnExpressionInput[]): ArithmeticExpression {\n  return { __expr: \"add\", operands: operands.map(toColumnExpression) };\n}\n\n/**\n * Subtract `right` from `left`.\n *\n * @param left - The minuend\n * @param right - The subtrahend\n * @returns A subtract expression node\n */\nfunction sub(left: ColumnExpressionInput, right: ColumnExpressionInput): ArithmeticExpression {\n  return {\n    __expr: \"subtract\",\n    operands: [toColumnExpression(left), toColumnExpression(right)],\n  };\n}\n\n/**\n * Divide `left` by `right`.\n *\n * @param left - The dividend\n * @param right - The divisor\n * @returns A divide expression node\n */\nfunction div(left: ColumnExpressionInput, right: ColumnExpressionInput): ArithmeticExpression {\n  return {\n    __expr: \"divide\",\n    operands: [toColumnExpression(left), toColumnExpression(right)],\n  };\n}\n\n/**\n * Wrap a raw expression string as an escape hatch.\n *\n * The string is emitted verbatim — never build it from untrusted input. Use\n * this only when the typed `$expr.mul` / `$expr.add` / `$expr.sub` /\n * `$expr.div` / `$expr.col` / `$expr.lit` combinators can't express what you\n * need.\n *\n * @param expression - A raw, driver-native expression fragment\n * @returns A raw expression node\n */\nfunction raw(expression: string): RawColumnExpression {\n  return { __expr: \"raw\", expression };\n}\n\n/**\n * Normalize an expression input to a `ColumnExpression` node. A bare string\n * becomes a `$expr.col(...)` reference; an existing node passes through\n * unchanged.\n *\n * @param input - A typed expression node or a bare column-name string\n * @returns The corresponding `ColumnExpression` node\n */\nexport function toColumnExpression(input: ColumnExpressionInput): ColumnExpression {\n  return typeof input === \"string\" ? col(input) : input;\n}\n\n/**\n * Typed, database-agnostic column-expression builders.\n *\n * Grouped under one object (like `$agg`) so the scalar arithmetic that feeds\n * an aggregate reads as a single, discoverable namespace: `$agg.sum($expr.mul(\n * \"price\", \"quantity\"))`. Each builder returns a plain, closed `ColumnExpression`\n * node — the driver translates it to native SQL / a Mongo pipeline.\n *\n * @example\n * ```typescript\n * import { $agg, $expr } from \"@warlock.js/cascade\";\n *\n * // SUM(price * quantity)\n * query.groupBy(\"product_id\", { revenue: $agg.sum($expr.mul(\"price\", \"quantity\")) });\n *\n * // SUM((1 - discount) * price)\n * query.groupBy(\"product_id\", {\n *   net: $agg.sum($expr.mul($expr.sub($expr.lit(1), \"discount\"), \"price\")),\n * });\n *\n * // price * 1.2 (e.g. tax)\n * $agg.sum($expr.mul(\"price\", $expr.lit(1.2)));\n *\n * // escape hatch (Postgres-only, emitted verbatim — never from user input)\n * $agg.sum($expr.raw(\"price * quantity * (1 - discount)\"));\n * ```\n */\nexport const $expr = {\n  col,\n  lit,\n  mul,\n  add,\n  sub,\n  div,\n  raw,\n};\n"],"mappings":";;;;;;;AA0GA,SAAgB,mBAAmB,OAA2C;CAC5E,OACE,OAAO,UAAU,YACjB,UAAU,QACV,OAAQ,MAA2B,WAAW;AAElD;;;;;;;AAQA,SAAS,IAAI,QAAqC;CAChD,OAAO;EAAE,QAAQ;EAAU;CAAO;AACpC;;;;;;;AAQA,SAAS,IAAI,OAA4C;CACvD,OAAO;EAAE,QAAQ;EAAW;CAAM;AACpC;;;;;;;AAQA,SAAS,IAAI,GAAG,UAAyD;CACvE,OAAO;EAAE,QAAQ;EAAY,UAAU,SAAS,IAAI,kBAAkB;CAAE;AAC1E;;;;;;;AAQA,SAAS,IAAI,GAAG,UAAyD;CACvE,OAAO;EAAE,QAAQ;EAAO,UAAU,SAAS,IAAI,kBAAkB;CAAE;AACrE;;;;;;;;AASA,SAAS,IAAI,MAA6B,OAAoD;CAC5F,OAAO;EACL,QAAQ;EACR,UAAU,CAAC,mBAAmB,IAAI,GAAG,mBAAmB,KAAK,CAAC;CAChE;AACF;;;;;;;;AASA,SAAS,IAAI,MAA6B,OAAoD;CAC5F,OAAO;EACL,QAAQ;EACR,UAAU,CAAC,mBAAmB,IAAI,GAAG,mBAAmB,KAAK,CAAC;CAChE;AACF;;;;;;;;;;;;AAaA,SAAS,IAAI,YAAyC;CACpD,OAAO;EAAE,QAAQ;EAAO;CAAW;AACrC;;;;;;;;;AAUA,SAAgB,mBAAmB,OAAgD;CACjF,OAAO,OAAO,UAAU,WAAW,IAAI,KAAK,IAAI;AAClD;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6BA,MAAa,QAAQ;CACnB;CACA;CACA;CACA;CACA;CACA;CACA;AACF"}

package/esm/index.d.mts

@@ -2,14 +2,14 @@ import { DeleteStrategy, MigrationDefaults, ModelDefaults, NamingConvention, Rel
 import { TableIndexInformation } from "./contracts/driver-blueprint.contract.mjs";
 import { ColumnDefinition, ColumnType, ForeignKeyDefinition, FullTextIndexOptions, GeoIndexOptions, IndexDefinition, MigrationDriverContract, MigrationDriverFactory, VectorIndexOptions } from "./contracts/migration-driver.contract.mjs";
 import { ColumnBuilder } from "./migration/column-builder.mjs";
-import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./migration/column-helpers.mjs";
+import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, bool as boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./migration/column-helpers.mjs";
 import { DatabaseDirtyTracker } from "./database-dirty-tracker.mjs";
-import { ChildModel, GlobalScopeDefinition, GlobalScopeOptions, LocalScopeCallback, ModelSchema, ScopeTiming } from "./model/model.types.mjs";
 import { ModelEventListener, ModelEventName, ModelEvents, OnDeletedEventContext, globalModelEvents } from "./events/model-events.mjs";
 import { BelongsToManyOptions, BelongsToOptions, HasManyOptions, HasOneOptions, LoadedRelationResult, LoadedRelationsMap, PivotData, PivotIds, RelationConstraintCallback, RelationConstraints, RelationDefinition, RelationDefinitions, RelationType } from "./relations/types.mjs";
 import { PivotOperations, createPivotOperations } from "./relations/pivot-operations.mjs";
 import { ModelSnapshot, RelationHydrator, SerializedRelation } from "./relations/relation-hydrator.mjs";
 import { EmbedKey, ModelSyncConfig, ModelSyncContract, ModelSyncOperationContract, SyncConfig, SyncContext, SyncEventPayload, SyncInstruction, SyncInstructionOptions, SyncResult } from "./sync/types.mjs";
+import { ChildModel, GlobalScopeDefinition, GlobalScopeOptions, LocalScopeCallback, ModelSchema, ScopeTiming } from "./model/model.types.mjs";
 import { Model } from "./model/model.mjs";
 import { ConnectionOptions, DatabaseDriver, ModelDefaultConfig, connectToDatabase, getDatabaseDriver, transaction } from "./utils/connect-to-database.mjs";
 import { ForeignKeyBuilder } from "./migration/foreign-key-builder.mjs";
@@ -41,8 +41,10 @@ import { DatabaseRemover } from "./remover/database-remover.mjs";
 import { DatabaseRestorer } from "./restorer/database-restorer.mjs";
 import { DatabaseWriterValidationError } from "./validation/database-writer-validation-error.mjs";
 import { BaseQueryRuleOptions, BaseUniqueRuleOptions, ExistsRuleOptions, UniqueRuleOptions } from "./validation/types.mjs";
+import "./validation/index.mjs";
 import { DatabaseWriter } from "./writer/database-writer.mjs";
 import { RelationLoader } from "./relations/relation-loader.mjs";
+import "./relations/index.mjs";
 import { $expr, ArithmeticExpression, ColumnExpression, ColumnExpressionInput, ColumnExpressionType, ColumnRefExpression, LiteralExpression, RawColumnExpression, isColumnExpression, toColumnExpression } from "./expressions/column-expressions.mjs";
 import { $agg, AggregateExpression, AggregateFunction, isAggregateExpression } from "./expressions/aggregate-expressions.mjs";
 import { MongoDriverOptions, Operation, PipelineStage } from "./drivers/mongodb/types.mjs";
@@ -61,8 +63,10 @@ import { DefineModelOptions, ModelType, defineModel } from "./utils/define-model
 import { onceConnected, onceDisconnected } from "./utils/once-connected.mjs";
 import { MigrationRecord, MigrationResult, MigrationRunnerOptions, MigrationStatus, RollbackOptions, RunMigrationsOptions } from "./migration/types.mjs";
 import { MigrationRunner, inferMigrationName, migrationRunner } from "./migration/migration-runner.mjs";
+import "./migration/index.mjs";
 import { CreateDatabaseResult, DropAllTablesResult, createDatabase, dropAllTables } from "./operations/database.mjs";
 import { ExportMigrationsSQLOptions, PendingMigration, RollbackMigrationsOptions, exportMigrationsSQL, freshMigrate, listExecutedMigrations, listPendingMigrations, rollbackMigrations, runMigrations } from "./operations/migrations.mjs";
+import "./operations/index.mjs";
 import { MongoMigrationDriver } from "./drivers/mongodb/mongodb-migration-driver.mjs";
 import { SqlDialectContract } from "./drivers/sql/sql-dialect.contract.mjs";
 import { SqlAggregateFunction, SqlDeleteOperation, SqlGroupClause, SqlHavingClause, SqlInsertOperation, SqlJoinClause, SqlJoinType, SqlOrderClause, SqlQueryConfig, SqlQueryResult, SqlSelectClause, SqlUpdateOperation, SqlWhereOperation, SqlWhereType } from "./drivers/sql/sql-types.mjs";
@@ -73,6 +77,7 @@ import { PostgresBlueprint } from "./drivers/postgres/postgres-blueprint.mjs";
 import { PostgresMigrationDriver } from "./drivers/postgres/postgres-migration-driver.mjs";
 import { PostgresQueryBuilder } from "./drivers/postgres/postgres-query-builder.mjs";
 import { PostgresOperationType, PostgresParserOperation, PostgresParserOptions, PostgresQueryParser } from "./drivers/postgres/postgres-query-parser.mjs";
+import "./drivers/postgres/index.mjs";
 import { MongoClientOptions, TransactionOptions } from "mongodb";
 export { $agg, $expr, AggregateExpression, AggregateFunction, AlterSchema, ArithmeticExpression, AtomicUpdate, AtomicUpdateOptions, type BaseQueryRuleOptions, type BaseUniqueRuleOptions, BelongsTo, BelongsToMany, type BelongsToManyOptions, type BelongsToOptions, BuildUpdateOperationsResult, type ChildModel, ChunkCallback, ColumnBuilder, ColumnDefinition, ColumnExpression, ColumnExpressionInput, ColumnExpressionType, ColumnMap, ColumnRefExpression, ColumnType, ConnectionOptions, CreateDatabaseOptions, CreateDatabaseResult, CursorPaginationOptions, CursorPaginationResult, DEFAULT_MAX_SYNC_DEPTH, DataSource, DataSourceOptions, DataSourceRegistryEvent, DataSourceRegistryListener, DatabaseDirtyTracker, DatabaseDriver, DatabaseRemover, DatabaseRestorer, DatabaseWriter, DatabaseWriterValidationError, DefineModelOptions, DeleteStrategy, DetachedColumnBuilder, DriverAtomicUpdateOptions, DriverContract, DriverEvent, DriverEventListener, DriverQuery, DriverTransactionContract, DropAllTablesResult, DropDatabaseOptions, type EmbedKey, type ExistsRuleOptions, ExportMigrationsSQLOptions, FindOneAndUpdateOptions, ForeignKeyBuilder, ForeignKeyDefinition, FullTextIndexOptions, GenerateIdOptions, GeoIndexOptions, type GlobalScopeDefinition, type GlobalScopeOptions, GroupByInput, HasMany, type HasManyOptions, HasOne, type HasOneOptions, HavingInput, IdGeneratorContract, IndexDefinition, IndexEntry, InsertResult, JoinOptions, LeanDocument, LiteralExpression, type LoadedRelationResult, type LoadedRelationsMap, type LocalScopeCallback, LockForUpdateOptions, Migration, MigrationAlterOptions, MigrationConstructor, MigrationContract, MigrationCreateOptions, MigrationDefaults, MigrationDriverContract, MigrationDriverFactory, MigrationOrigin, type MigrationRecord, type MigrationResult, MigrationRunner, type MigrationRunnerOptions, type MigrationStatus, MigrationStep, MissingDataSourceError, Model, ModelDefaultConfig, ModelDefaults, ModelEventListener, ModelEventName, ModelEvents, ModelRef, type ModelSchema, type ModelSnapshot, type ModelSyncConfig, type ModelSyncContract, ModelSyncOperation, type ModelSyncOperationContract, ModelTransformCallback, ModelType, type MongoClientOptions, MongoDbDriver, MongoDriverOptions, MongoIdGenerator, MongoMigrationDriver, MongoQueryBuilder, MongoSyncAdapter, NamingConvention, OnDeletedEventContext, Operation, OperationType, OrderDirection, PaginationOptions, PaginationResult, PendingMigration, PendingOperation, PipelineStage, type PivotData, type PivotIds, PivotOperations, PostgresBlueprint, PostgresConnectionConfig, PostgresCopyOptions, PostgresDialect, PostgresDialectOptions, PostgresDriver, PostgresIsolationLevel, PostgresMigrationDriver, PostgresNaming, PostgresNotification, PostgresOperation, PostgresOperationType, PostgresParserOperation, PostgresParserOptions, PostgresPoolConfig, PostgresQueryBuilder, PostgresQueryParser, PostgresQueryResult, PostgresTransactionOptions, PostgresWhereClause, QueryBuilderContract, QueryEvent, RELATION_METADATA_KEY, RawColumnExpression, RawExpression, RawQueryResult, RegisterModel, RegisterModelOptions, type RelationConstraintCallback, type RelationConstraints, RelationDefaults, type RelationDefinition, type RelationDefinitions, RelationHydrator, RelationLoader, type RelationType, RemoverContract, RemoverOptions, RemoverResult, RestorerContract, RestorerOptions, RestorerResult, RollbackMigrationsOptions, type RollbackOptions, type RunMigrationsOptions, type ScopeTiming, type SerializedRelation, SqlAggregateFunction, SqlDeleteOperation, SqlDialectContract, SqlGroupClause, SqlHavingClause, SqlInsertOperation, SqlJoinClause, SqlJoinType, SqlOrderClause, SqlQueryConfig, SqlQueryResult, SqlSelectClause, SqlUpdateOperation, SqlWhereOperation, SqlWhereType, StrictMode, SyncAdapterContract, type SyncConfig, type SyncContext, SyncContextManager, type SyncEventPayload, SyncInstruction, type SyncInstructionOptions, SyncManager, type SyncResult, type TableIndexInformation, TransactionContext, type TransactionOptions, TransactionRollbackError, UndefinedWhereValueError, UniqueEntry, type UniqueRuleOptions, UnsafeFilterError, UnsafeRawExpressionError, UnsupportedLeanOperationError, UnsupportedLockForUpdateError, UnsupportedQueryOperationError, UnsupportedUpdateOperationError, UnwindOptions, UpdateOperations, UpdatePipeline, UpdateResult, UuidStrategy, VectorIndexOptions, WhereCallback, WhereObject, WhereOperator, WriterContract, WriterOptions, WriterResult, afterCommit, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, assertDefined, bigInt, bigInteger, binary, blobCol, boolCol as bool, boolCol, buildPostgresPoolConfig, char, cleanupModelsRegistery, connectToDatabase, createDatabase, createPivotOperations, dataSourceRegistry, databaseDataSourceContext, databaseTransactionContext, date, dateTime, decimal, defineModel, double, dropAllTables, enumCol, escapeRegex, escapeSqlLiteral, exportMigrationsSQL, float, freshMigrate, geometry, getAllModelsFromRegistry, getDatabaseDriver, getModelFromRegistry, globalModelEvents, inferMigrationName, int, integer, ipAddress, isAggregateExpression, isColumnExpression, isMongoDBDriverLoaded, json, likePatternToRegexSource, lineString, listExecutedMigrations, listPendingMigrations, longText, macAddress, mediumText, migrate, migrationRunner, modelSync, objectCol, onceConnected, onceDisconnected, parsePostgresInt8, point, polygon, registerModelInRegistry, removeModelFromRegistery, requireModelClass, resolveLikePattern, resolveModelClass, resolveModelName, rollbackMigrations, runMigrations, sanitizeFilter, sanitizeFilterValue, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, toColumnExpression, transaction, tryResolveModelClass, ulid, useModelTransformer, uuid, vector, verifyRegisteredRelations, year };
 import "./validation/plugins/database-rules-plugin.mjs";

package/esm/index.mjs

@@ -52,7 +52,7 @@ import { defineModel } from "./utils/define-model.mjs";
 import { onceConnected, onceDisconnected } from "./utils/once-connected.mjs";
 import { ColumnBuilder } from "./migration/column-builder.mjs";
 import { ForeignKeyBuilder } from "./migration/foreign-key-builder.mjs";
-import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./migration/column-helpers.mjs";
+import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, bool as boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./migration/column-helpers.mjs";
 import { Migration, migrate } from "./migration/migration.mjs";
 import { MigrationRunner, inferMigrationName, migrationRunner } from "./migration/migration-runner.mjs";
 import "./migration/index.mjs";

package/esm/migration/column-builder.d.mts

@@ -1,5 +1,4 @@
 import { ColumnDefinition, ColumnType, ForeignKeyDefinition, VectorIndexOptions } from "../contracts/migration-driver.contract.mjs";
-
 //#region ../../packages/cascade/src/migration/column-builder.d.ts
 /**
  * Reference to the Migration type to avoid circular imports.
@@ -35,7 +34,7 @@ type MigrationLike = {
  *   .comment("User's age in years");
  * ```
  */
-declare class ColumnBuilder {
+export declare class ColumnBuilder {
   private readonly migration;
   /** Mutable column definition being accumulated */
   private readonly definition;
@@ -416,5 +415,5 @@ declare class ColumnBuilder {
   getDefinition(): ColumnDefinition;
 }
 //#endregion
-export { ColumnBuilder };
+export {};
 //# sourceMappingURL=column-builder.d.mts.map

package/esm/migration/column-builder.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"column-builder.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/migration/column-builder.ts"],"mappings":";;;;;AAKgD;;KAM3C,aAAA;EACH,eAAA,CAAgB,KAAA;IAAS,OAAA;IAAmB,MAAA;EAAA;EAC5C,sBAAA,CAAuB,EAAA,EAAI,oBAAA;EAC3B,qBAAA,EAAuB,MAAA,UAAgB,OAAA,EAAS,IAAA,CAAK,kBAAA;AAAA;;;;;;;;;;;;AAA6B;AAqCpF;;;;;;;;;;cAAa,aAAA;EAAA,iBAmBQ,SAAA;EAslBK;EAAA,iBAvmBP,UAAA;EAumBuB;EAAA,QApmBhC,YAAA;EAHS;EAAA,QAMT,mBAAA;EAAA;;;;;;;;cAWW,SAAA,EAAW,aAAA,EAC5B,IAAA,UACA,IAAA,EAAM,UAAA,EACN,OAAA,GAAS,OAAA,CACP,IAAA,CAAK,gBAAA;EAAA;;;;;;;;;;EAyBF,QAAA;EAuIA;;;;;;;EA3HA,WAAA;EAoOA;;;;;;;;;;;;;;;;;EA1MA,OAAA,CAAQ,KAAA;EA0WC;;;;;;;;;;;AAyKwB;;;;EA9fjC,aAAA,CAAc,KAAA;;;;;;;;;;;;;EAkBd,UAAA;;;;;;;;;;;;;EAiBA,kBAAA;;;;;;;;;;;;;EAqBA,MAAA;;;;;;;;;;;;;EAoBA,KAAA;;;;;;;;;;;;;;EAoBA,WAAA,CAAY,OAAA,GAAS,IAAA,CAAK,kBAAA;;;;;;;;;;;EAwB1B,OAAA;;;;;;;;;;;;;;EAkBA,aAAA;;;;;;;;;;;;;EAqBA,QAAA;;;;;;;;;;;;;;EAsBA,OAAA,CAAQ,IAAA;;;;;;;;EAgBR,KAAA,CAAM,UAAA,UAAoB,IAAA;;;;;;;;;;;;;;EAyB1B,KAAA,CAAM,UAAA;;;;;;;;;;;;;EAiBN,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCA,UAAA,CAAW,YAAA;IAAyB,KAAA;EAAA;;;;;;;;;;;;;;EA2BpC,EAAA,CAAG,MAAA;;;;;;;;;;;;;;EAoBH,QAAA,CAAS,MAAA,EAAQ,oBAAA;;;;;;;;;;;;;;EAoBjB,QAAA,CAAS,MAAA,EAAQ,oBAAA;;;;;;;;;;;;;EAmBjB,UAAA;;;;;;;;;;;;;;;;;;;;;EAgCA,MAAA;;;;EAsCA,MAAA;;;;;;;;;;;;;;;;;;;;;;;EA8BA,WAAA,CAAY,UAAA;;;;;;;;EAYZ,MAAA;;;;;;;;EAiBA,OAAA;;;;;;;;EAqBA,aAAA,IAAiB,gBAAA;AAAA"}
+{"version":3,"file":"column-builder.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/migration/column-builder.ts"],"mappings":";;;;;;KAWK;EACH,gBAAgB;IAAS;IAAmB;;EAC5C,uBAAuB,IAAI;EAC3B,uBAAuB,gBAAgB,SAAS,KAAK;;;;;;;;;;;;;;;;;;;;;;;;qBAqC1C;mBAmBQ;;mBAjBF;;UAGT;;UAGA;;;;;;;;;EAUR,YACmB,WAAW,eAC5B,cACA,MAAM,YACN,UAAS,QACP,KAAK;;;;;;;;;;;EAyBF;;;;;;;;EAYA;;;;;;;;;;;;;;;;;;EA0BA,QAAQ;;;;;;;;;;;;;;;;EAqBR,cAAc;;;;;;;;;;;;;EAkBd;;;;;;;;;;;;;EAiBA;;;;;;;;;;;;;EAqBA;;;;;;;;;;;;;EAoBA;;;;;;;;;;;;;;EAoBA,YAAY,UAAS,KAAK;;;;;;;;;;;EAwB1B;;;;;;;;;;;;;;EAkBA;;;;;;;;;;;;;EAqBA;;;;;;;;;;;;;;EAsBA,QAAQ;;;;;;;;EAgBR,MAAM,oBAAoB;;;;;;;;;;;;;;EAyB1B,MAAM;;;;;;;;;;;;;EAiBN;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmCA,WAAW;IAAyB;;;;;;;;;;;;;;;EA2BpC,GAAG;;;;;;;;;;;;;;EAoBH,SAAS,QAAQ;;;;;;;;;;;;;;EAoBjB,SAAS,QAAQ;;;;;;;;;;;;;EAmBjB;;;;;;;;;;;;;;;;;;;;;EAgCA;;;;EAsCA;;;;;;;;;;;;;;;;;;;;;;;EA8BA,YAAY;;;;;;;;EAYZ;;;;;;;;EAiBA;;;;;;;;EAqBA,iBAAiB"}

package/esm/migration/column-helpers.d.mts

@@ -1,6 +1,5 @@
 import { VectorIndexOptions } from "../contracts/migration-driver.contract.mjs";
 import { ColumnBuilder } from "./column-builder.mjs";
-
 //#region ../../packages/cascade/src/migration/column-helpers.d.ts
 /**
  * A no-op migration sink used by standalone column helpers.
@@ -37,7 +36,7 @@ declare class DetachedMigrationSink {
  * A `ColumnBuilder` that carries its own detached sink so it can be
  * constructed outside of a migration class and later merged in.
  */
-declare class DetachedColumnBuilder extends ColumnBuilder {
+export declare class DetachedColumnBuilder extends ColumnBuilder {
   readonly sink: DetachedMigrationSink;
   constructor(type: ConstructorParameters<typeof ColumnBuilder>[2], name: string, options?: ConstructorParameters<typeof ColumnBuilder>[3]);
 }
@@ -53,7 +52,7 @@ declare class DetachedColumnBuilder extends ColumnBuilder {
  * });
  * ```
  */
-declare function string(length?: number): DetachedColumnBuilder;
+export declare function string(length?: number): DetachedColumnBuilder;
 /**
  * Standalone column helper: fixed-length CHAR.
  *
@@ -62,7 +61,7 @@ declare function string(length?: number): DetachedColumnBuilder;
  * code: char(3) // CHAR(3)
  * ```
  */
-declare function char(length: number): DetachedColumnBuilder;
+export declare function char(length: number): DetachedColumnBuilder;
 /**
  * Standalone column helper: TEXT (unlimited length).
  *
@@ -75,15 +74,15 @@ declare function char(length: number): DetachedColumnBuilder;
  * });
  * ```
  */
-declare function text(): DetachedColumnBuilder;
+export declare function text(): DetachedColumnBuilder;
 /**
  * Standalone column helper: MEDIUMTEXT.
  */
-declare function mediumText(): DetachedColumnBuilder;
+export declare function mediumText(): DetachedColumnBuilder;
 /**
  * Standalone column helper: LONGTEXT.
  */
-declare function longText(): DetachedColumnBuilder;
+export declare function longText(): DetachedColumnBuilder;
 /**
  * Standalone column helper: INTEGER.
  *
@@ -92,35 +91,35 @@ declare function longText(): DetachedColumnBuilder;
  * age: integer().unsigned()
  * ```
  */
-declare function integer(): DetachedColumnBuilder;
+export declare function integer(): DetachedColumnBuilder;
 /** Alias for `integer()`. */
-declare const int: typeof integer;
+export declare const int: typeof integer;
 /**
  * Standalone column helper: SMALLINT.
  */
-declare function smallInteger(): DetachedColumnBuilder;
+export declare function smallInteger(): DetachedColumnBuilder;
 /** Alias for `smallInteger()`. */
-declare const smallInt: typeof smallInteger;
+export declare const smallInt: typeof smallInteger;
 /**
  * Standalone column helper: TINYINT.
  */
-declare function tinyInteger(): DetachedColumnBuilder;
+export declare function tinyInteger(): DetachedColumnBuilder;
 /** Alias for `tinyInteger()`. */
-declare const tinyInt: typeof tinyInteger;
+export declare const tinyInt: typeof tinyInteger;
 /**
  * Standalone column helper: BIGINT.
  */
-declare function bigInteger(): DetachedColumnBuilder;
+export declare function bigInteger(): DetachedColumnBuilder;
 /** Alias for `bigInteger()`. */
-declare const bigInt: typeof bigInteger;
+export declare const bigInt: typeof bigInteger;
 /**
  * Standalone column helper: FLOAT.
  */
-declare function float(): DetachedColumnBuilder;
+export declare function float(): DetachedColumnBuilder;
 /**
  * Standalone column helper: DOUBLE.
  */
-declare function double(): DetachedColumnBuilder;
+export declare function double(): DetachedColumnBuilder;
 /**
  * Standalone column helper: DECIMAL.
  *
@@ -129,7 +128,7 @@ declare function double(): DetachedColumnBuilder;
  * price: decimal(10, 2) // DECIMAL(10,2)
  * ```
  */
-declare function decimal(precision?: number, scale?: number): DetachedColumnBuilder;
+export declare function decimal(precision?: number, scale?: number): DetachedColumnBuilder;
 /**
  * Standalone column helper: BOOLEAN.
  *
@@ -140,15 +139,15 @@ declare function decimal(precision?: number, scale?: number): DetachedColumnBuil
  * is_active: boolCol().default(true)
  * ```
  */
-declare function boolCol(): DetachedColumnBuilder;
+export declare function boolCol(): DetachedColumnBuilder;
 /**
  * Standalone column helper: DATE.
  */
-declare function date(): DetachedColumnBuilder;
+export declare function date(): DetachedColumnBuilder;
 /**
  * Standalone column helper: DATETIME.
  */
-declare function dateTime(): DetachedColumnBuilder;
+export declare function dateTime(): DetachedColumnBuilder;
 /**
  * Standalone column helper: TIMESTAMP.
  *
@@ -157,15 +156,15 @@ declare function dateTime(): DetachedColumnBuilder;
  * started_at: timestamp().default("NOW()")
  * ```
  */
-declare function timestamp(): DetachedColumnBuilder;
+export declare function timestamp(): DetachedColumnBuilder;
 /**
  * Standalone column helper: TIME.
  */
-declare function time(): DetachedColumnBuilder;
+export declare function time(): DetachedColumnBuilder;
 /**
  * Standalone column helper: YEAR.
  */
-declare function year(): DetachedColumnBuilder;
+export declare function year(): DetachedColumnBuilder;
 /**
  * Standalone column helper: JSON.
  *
@@ -177,19 +176,19 @@ declare function year(): DetachedColumnBuilder;
  * metadata: json().nullable()
  * ```
  */
-declare function json(): DetachedColumnBuilder;
+export declare function json(): DetachedColumnBuilder;
 /**
  * Alias for `json()`. Named `objectCol` to avoid collision with TS `object` type.
  */
-declare function objectCol(): DetachedColumnBuilder;
+export declare function objectCol(): DetachedColumnBuilder;
 /**
  * Standalone column helper: BINARY / BLOB.
  */
-declare function binary(): DetachedColumnBuilder;
+export declare function binary(): DetachedColumnBuilder;
 /**
  * Alias for `binary()`. Named `blobCol` to avoid collision with the Web `Blob` API.
  */
-declare function blobCol(): DetachedColumnBuilder;
+export declare function blobCol(): DetachedColumnBuilder;
 /**
  * Standalone column helper: UUID.
  *
@@ -202,35 +201,35 @@ declare function blobCol(): DetachedColumnBuilder;
  * });
  * ```
  */
-declare function uuid(): DetachedColumnBuilder;
+export declare function uuid(): DetachedColumnBuilder;
 /**
  * Standalone column helper: ULID.
  */
-declare function ulid(): DetachedColumnBuilder;
+export declare function ulid(): DetachedColumnBuilder;
 /**
  * Standalone column helper: IP address.
  */
-declare function ipAddress(): DetachedColumnBuilder;
+export declare function ipAddress(): DetachedColumnBuilder;
 /**
  * Standalone column helper: MAC address.
  */
-declare function macAddress(): DetachedColumnBuilder;
+export declare function macAddress(): DetachedColumnBuilder;
 /**
  * Standalone column helper: geo point.
  */
-declare function point(): DetachedColumnBuilder;
+export declare function point(): DetachedColumnBuilder;
 /**
  * Standalone column helper: polygon.
  */
-declare function polygon(): DetachedColumnBuilder;
+export declare function polygon(): DetachedColumnBuilder;
 /**
  * Standalone column helper: line string.
  */
-declare function lineString(): DetachedColumnBuilder;
+export declare function lineString(): DetachedColumnBuilder;
 /**
  * Standalone column helper: generic geometry.
  */
-declare function geometry(): DetachedColumnBuilder;
+export declare function geometry(): DetachedColumnBuilder;
 /**
  * Standalone column helper: vector (for AI embeddings).
  *
@@ -241,7 +240,7 @@ declare function geometry(): DetachedColumnBuilder;
  * embedding: vector(1536)
  * ```
  */
-declare function vector(dimensions: number): DetachedColumnBuilder;
+export declare function vector(dimensions: number): DetachedColumnBuilder;
 /**
  * Standalone column helper: ENUM.
  *
@@ -250,31 +249,31 @@ declare function vector(dimensions: number): DetachedColumnBuilder;
  * status: enumCol(["active", "inactive", "pending"])
  * ```
  */
-declare function enumCol(values: string[]): DetachedColumnBuilder;
+export declare function enumCol(values: string[]): DetachedColumnBuilder;
 /**
  * Standalone column helper: SET (multiple values).
  */
-declare function setCol(values: string[]): DetachedColumnBuilder;
+export declare function setCol(values: string[]): DetachedColumnBuilder;
 /** Standalone helper: INTEGER[] */
-declare function arrayInt(): DetachedColumnBuilder;
+export declare function arrayInt(): DetachedColumnBuilder;
 /** Standalone helper: BIGINT[] */
-declare function arrayBigInt(): DetachedColumnBuilder;
+export declare function arrayBigInt(): DetachedColumnBuilder;
 /** Standalone helper: REAL[] */
-declare function arrayFloat(): DetachedColumnBuilder;
+export declare function arrayFloat(): DetachedColumnBuilder;
 /** Standalone helper: DECIMAL[] */
-declare function arrayDecimal(precision?: number, scale?: number): DetachedColumnBuilder;
+export declare function arrayDecimal(precision?: number, scale?: number): DetachedColumnBuilder;
 /** Standalone helper: BOOLEAN[] */
-declare function arrayBoolean(): DetachedColumnBuilder;
+export declare function arrayBoolean(): DetachedColumnBuilder;
 /** Standalone helper: TEXT[] */
-declare function arrayText(): DetachedColumnBuilder;
+export declare function arrayText(): DetachedColumnBuilder;
 /** Standalone helper: DATE[] */
-declare function arrayDate(): DetachedColumnBuilder;
+export declare function arrayDate(): DetachedColumnBuilder;
 /** Standalone helper: TIMESTAMPTZ[] */
-declare function arrayTimestamp(): DetachedColumnBuilder;
+export declare function arrayTimestamp(): DetachedColumnBuilder;
 /** Standalone helper: UUID[] */
-declare function arrayUuid(): DetachedColumnBuilder;
+export declare function arrayUuid(): DetachedColumnBuilder;
 /** Standalone helper: JSONB[] */
-declare function arrayJson(): DetachedColumnBuilder;
+export declare function arrayJson(): DetachedColumnBuilder;
 //#endregion
-export { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year };
+export { boolCol as bool };
 //# sourceMappingURL=column-helpers.d.mts.map

package/esm/migration/column-helpers.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"column-helpers.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/migration/column-helpers.ts"],"mappings":";;;;;;;AAAiD;;;;;;;;cAa3C,qBAAA;EAE8B;EAAA,SAAlB,cAAA;IAAkB,OAAA;IAAmB,MAAA;EAAA;EAQnD;EAAA,SALc,kBAAA;EAQT;EAAA,SALS,oBAAA;IACd,MAAA;IACA,OAAA,EAVuB,kBAAA;EAAA;EAalB,eAAA,CAAgB,KAAA;IAAS,OAAA;IAAmB,MAAA;EAAA;EAI5C,sBAAA,CAAuB,EAAA;EAIvB,qBAAA,CACL,MAAA,UACA,OAAA,EAAS,IAAA,CAbmE,kBAAA;AAAA;AAagB;AAUhG;;;AAVgG,cAUnF,qBAAA,SAA8B,aAAA;EAAA,SACzB,IAAA,EAAM,qBAAA;cAGpB,IAAA,EAAM,qBAAA,QAA6B,aAAA,MACnC,IAAA,UACA,OAAA,GAAS,qBAAA,QAA6B,aAAA;AAAA;;;;;;;;;;;;;iBAwB1B,MAAA,CAAO,MAAA,YAAe,qBAAqB;;;;AAxBK;AAwBhE;;;;iBAYgB,IAAA,CAAK,MAAA,WAAiB,qBAAqB;AAA3D;;;;AAA2D;AAgB3D;;;;AAA6C;AAO7C;;AAvBA,iBAgBgB,IAAA,IAAQ,qBAAqB;;AAOM;AAOnD;iBAPgB,UAAA,IAAc,qBAAqB;;;AAOF;iBAAjC,QAAA,IAAY,qBAAqB;;;;AAgBD;AAKhD;;;;iBALgB,OAAA,IAAW,qBAAqB;AAUhD;AAAA,cALa,GAAA,SAAG,OAAU;;;AAK2B;iBAArC,YAAA,IAAgB,qBAAqB;;cAKxC,QAAA,SAAQ,YAAe;;AAAA;AAKpC;iBAAgB,WAAA,IAAe,qBAAqB;;cAKvC,OAAA,SAAO,WAAc;AALkB;AAKpD;;AALoD,iBAUpC,UAAA,IAAc,qBAAqB;;cAKtC,MAAA,SAAM,UAAa;AALhC;;;AAAA,iBAUgB,KAAA,IAAS,qBAAqB;AAVK;AAKnD;;AALmD,iBAiBnC,MAAA,IAAU,qBAAqB;;AAZf;AAKhC;;;;AAA8C;AAO9C;iBAYgB,OAAA,CAAQ,SAAA,WAAe,KAAA,YAAY,qBAAqB;;;AAZzB;AAY/C;;;;;;;iBAkBgB,OAAA,IAAW,qBAAqB;;;;iBAchC,IAAA,IAAQ,qBAAqB;AAA7C;;;AAAA,iBAOgB,QAAA,IAAY,qBAAqB;AAPJ;AAO7C;;;;AAAiD;AAYjD;;AAnB6C,iBAmB7B,SAAA,IAAa,qBAAqB;;AAAA;AAOlD;iBAAgB,IAAA,IAAQ,qBAAqB;;;AAAA;iBAO7B,IAAA,IAAQ,qBAAqB;;;;AAAA;AAmB7C;;;;AAA6C;AAO7C;;iBAPgB,IAAA,IAAQ,qBAAqB;;AAOK;AAOlD;iBAPgB,SAAA,IAAa,qBAAqB;;;AAOH;iBAA/B,MAAA,IAAU,qBAAqB;;;;iBAO/B,OAAA,IAAW,qBAAqB;AAoBhD;;;;AAA6C;AAO7C;;;;AAA6C;AAW7C;;AAlBA,iBAAgB,IAAA,IAAQ,qBAAqB;;AAkBK;AAOlD;iBAlBgB,IAAA,IAAQ,qBAAqB;;;AAkBM;iBAPnC,SAAA,IAAa,qBAAqB;;;;iBAOlC,UAAA,IAAc,qBAAqB;AAkBnD;;;AAAA,iBAPgB,KAAA,IAAS,qBAAqB;AAOE;AAOhD;;AAPgD,iBAAhC,OAAA,IAAW,qBAAqB;;AAOG;AAOnD;iBAPgB,UAAA,IAAc,qBAAqB;;;AAOF;iBAAjC,QAAA,IAAY,qBAAqB;;;;AAkBgB;AAgBjE;;;;AAAgE;AAOhE;iBAvBgB,MAAA,CAAO,UAAA,WAAqB,qBAAqB;;;AAuBF;AAS/D;;;;AAAiD;iBAhBjC,OAAA,CAAQ,MAAA,aAAmB,qBAAqB;;;;iBAOhD,MAAA,CAAO,MAAA,aAAmB,qBAAqB;AAmB/D;AAAA,iBAVgB,QAAA,IAAY,qBAAqB;;iBAKjC,WAAA,IAAe,qBAAqB;AAKD;AAAA,iBAAnC,UAAA,IAAc,qBAAqB;;iBAKnC,YAAA,CAAa,SAAA,WAAoB,KAAA,YAAiB,qBAAqB;;iBAKvE,YAAA,IAAgB,qBAAqB;;iBAKrC,SAAA,IAAa,qBAAqB;;iBAKlC,SAAA,IAAa,qBAAqB;AAVlD;AAAA,iBAegB,cAAA,IAAkB,qBAAqB;;iBAKvC,SAAA,IAAa,qBAAqB;AApBG;AAAA,iBAyBrC,SAAA,IAAa,qBAAqB"}
+{"version":3,"file":"column-helpers.d.mts","names":["_$___contracts_migration_driver_contract0.VectorIndexOptions"],"sources":["../../../../../../../../packages/cascade/src/migration/column-helpers.ts"],"mappings":";;;;;;;;;;;;;;cAaM;;WAEY;IAAkB;IAAmB;;;WAGrC;;WAGA;IACd;IACA,SAVEA;;EAaG,gBAAgB;IAAS;IAAmB;;EAI5C,uBAAuB;EAIvB,sBACL,gBACA,SAAS,KAbiDA;;;;;;qBAuBjD,8BAA8B;WACzB,MAAM;EAEtB,YACE,MAAM,6BAA6B,mBACnC,cACA,UAAS,6BAA6B;;;;;;;;;;;;;;wBAwB1B,OAAO,kBAAe;;;;;;;;;wBAYtB,KAAK,iBAAiB;;;;;;;;;;;;;wBAgBtB,QAAQ;;;;wBAOR,cAAc;;;;wBAOd,YAAY;;;;;;;;;wBAgBZ,WAAW;;qBAKd,YAAG;;;;wBAKA,gBAAgB;;qBAKnB,iBAAQ;;;;wBAKL,eAAe;;qBAKlB,gBAAO;;;;wBAKJ,cAAc;;qBAKjB,eAAM;;;;wBAKH,SAAS;;;;wBAOT,UAAU;;;;;;;;;wBAYV,QAAQ,oBAAe,iBAAY;;;;;;;;;;;wBAkBnC,WAAW;;;;wBAcX,QAAQ;;;;wBAOR,YAAY;;;;;;;;;wBAYZ,aAAa;;;;wBAOb,QAAQ;;;;wBAOR,QAAQ;;;;;;;;;;;;wBAmBR,QAAQ;;;;wBAOR,aAAa;;;;wBAOb,UAAU;;;;wBAOV,WAAW;;;;;;;;;;;;;wBAoBX,QAAQ;;;;wBAOR,QAAQ;;;;wBAWR,aAAa;;;;wBAOb,cAAc;;;;wBAWd,SAAS;;;;wBAOT,WAAW;;;;wBAOX,cAAc;;;;wBAOd,YAAY;;;;;;;;;;;wBAkBZ,OAAO,qBAAqB;;;;;;;;;wBAgB5B,QAAQ,mBAAmB;;;;wBAO3B,OAAO,mBAAmB;;wBAS1B,YAAY;;wBAKZ,eAAe;;wBAKf,cAAc;;wBAKd,aAAa,oBAAoB,iBAAiB;;wBAKlD,gBAAgB;;wBAKhB,aAAa;;wBAKb,aAAa;;wBAKb,kBAAkB;;wBAKlB,aAAa;;wBAKb,aAAa"}

package/esm/migration/column-helpers.mjs

@@ -372,5 +372,5 @@ function arrayJson() {
 }
 
 //#endregion
-export { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year };
+export { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol as bool, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year };
 //# sourceMappingURL=column-helpers.mjs.map

package/esm/migration/foreign-key-builder.d.mts

@@ -1,5 +1,4 @@
 import { ForeignKeyDefinition } from "../contracts/migration-driver.contract.mjs";
-
 //#region ../../packages/cascade/src/migration/foreign-key-builder.d.ts
 /**
  * Reference to the Migration type to avoid circular imports.
@@ -25,7 +24,7 @@ type MigrationLike = {
  *   .onUpdate("cascade");
  * ```
  */
-declare class ForeignKeyBuilder {
+export declare class ForeignKeyBuilder {
   private readonly migration;
   /** Mutable foreign key definition being accumulated */
   private readonly definition;
@@ -102,5 +101,5 @@ declare class ForeignKeyBuilder {
   cascadeAll(): this;
 }
 //#endregion
-export { ForeignKeyBuilder };
+export {};
 //# sourceMappingURL=foreign-key-builder.d.mts.map

package/esm/migration/foreign-key-builder.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"foreign-key-builder.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/migration/foreign-key-builder.ts"],"mappings":";;;;;AAAmF;KAK9E,aAAA;EACH,sBAAA,CAAuB,EAAA,EAAI,oBAAoB;AAAA;;;;;AAAA;AAiCjD;;;;;;;;;;;;;cAAa,iBAAA;EAAA,iBAWQ,SAAA;EAkBP;EAAA,iBA3BK,UAAA;EAiDC;;;;;;cAxCC,SAAA,EAAW,aAAA,EAC5B,MAAA;EA6Ec;;;AAeC;;;EA3EV,IAAA,CAAK,IAAA;;;;;;;;;;;;;;;;;;EAsBL,UAAA,CAAW,KAAA,UAAe,MAAA;;;;;;;;;;;;;;EAoB1B,QAAA,CAAS,MAAA,EAAQ,oBAAA;;;;;;;;;;;;;;EAkBjB,QAAA,CAAS,MAAA,EAAQ,oBAAA;;;;;;;;;;;EAejB,UAAA;AAAA"}
+{"version":3,"file":"foreign-key-builder.d.mts","names":[],"sources":["../../../../../../../../packages/cascade/src/migration/foreign-key-builder.ts"],"mappings":";;;;;KAKK;EACH,uBAAuB,IAAI;;;;;;;;;;;;;;;;;;;;qBAiChB;mBAWQ;;mBATF;;;;;;;EAQjB,YACmB,WAAW,eAC5B;;;;;;;EAiBK,KAAK;;;;;;;;;;;;;;;;;;EAsBL,WAAW,eAAe;;;;;;;;;;;;;;EAoB1B,SAAS,QAAQ;;;;;;;;;;;;;;EAkBjB,SAAS,QAAQ;;;;;;;;;;;EAejB"}

package/esm/migration/foreign-key-builder.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"foreign-key-builder.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/migration/foreign-key-builder.ts"],"sourcesContent":["import type { ForeignKeyDefinition } from \"../contracts/migration-driver.contract\";\n\n/**\n * Reference to the Migration type to avoid circular imports.\n */\ntype MigrationLike = {\n  addForeignKeyOperation(fk: ForeignKeyDefinition): void;\n};\n\n/**\n * Mutable foreign key definition being built.\n */\ninterface MutableForeignKeyDefinition {\n  name?: string;\n  column: string;\n  referencesTable: string;\n  referencesColumn: string;\n  onDelete: ForeignKeyDefinition[\"onDelete\"];\n  onUpdate: ForeignKeyDefinition[\"onUpdate\"];\n}\n\n/**\n * Fluent builder for foreign key constraints.\n *\n * Allows building foreign key definitions with a chainable API.\n * SQL-only feature; NoSQL drivers ignore foreign keys.\n *\n * The operation is pushed when `.references()` is called using a mutable\n * reference — subsequent `.onDelete()` / `.onUpdate()` calls mutate the\n * same definition already queued in pendingOperations.\n *\n * @example\n * ```typescript\n * this.foreign(\"user_id\")\n *   .references(\"users\", \"id\")\n *   .onDelete(\"cascade\")\n *   .onUpdate(\"cascade\");\n * ```\n */\nexport class ForeignKeyBuilder {\n  /** Mutable foreign key definition being accumulated */\n  private readonly definition: MutableForeignKeyDefinition;\n\n  /**\n   * Create a new foreign key builder.\n   *\n   * @param migration - Parent migration instance\n   * @param column - Local column name that will reference another table\n   */\n  public constructor(\n    private readonly migration: MigrationLike,\n    column: string,\n  ) {\n    this.definition = {\n      column,\n      referencesTable: \"\",\n      referencesColumn: \"id\",\n      onDelete: \"restrict\",\n      onUpdate: \"restrict\",\n    };\n  }\n\n  /**\n   * Set the constraint name.\n   *\n   * @param name - Constraint name (auto-generated if not provided)\n   * @returns This builder for chaining\n   */\n  public name(name: string): this {\n    this.definition.name = name;\n    return this;\n  }\n\n  /**\n   * Set the referenced table and column, and register the foreign key operation.\n   *\n   * Pushes the operation immediately using a mutable reference — any\n   * `.onDelete()` / `.onUpdate()` calls after this will mutate the same\n   * definition already queued in pendingOperations.\n   *\n   * @param table - Referenced table name\n   * @param column - Referenced column name (default: \"id\")\n   * @returns This builder for chaining\n   *\n   * @example\n   * ```typescript\n   * this.foreign(\"user_id\").references(\"users\", \"id\");\n   * this.foreign(\"category_id\").references(\"categories\"); // defaults to \"id\"\n   * ```\n   */\n  public references(table: string, column = \"id\"): this {\n    this.definition.referencesTable = table;\n    this.definition.referencesColumn = column;\n    this.migration.addForeignKeyOperation(this.definition as ForeignKeyDefinition);\n    return this;\n  }\n\n  /**\n   * Set the ON DELETE action.\n   *\n   * @param action - Action to take when referenced row is deleted\n   * @returns This builder for chaining\n   *\n   * @example\n   * ```typescript\n   * this.foreign(\"user_id\")\n   *   .references(\"users\")\n   *   .onDelete(\"cascade\"); // Delete child when parent is deleted\n   * ```\n   */\n  public onDelete(action: ForeignKeyDefinition[\"onDelete\"]): this {\n    this.definition.onDelete = action;\n    return this;\n  }\n\n  /**\n   * Set the ON UPDATE action.\n   *\n   * @param action - Action to take when referenced row's key is updated\n   * @returns This builder for chaining\n   *\n   * @example\n   * ```typescript\n   * this.foreign(\"user_id\")\n   *   .references(\"users\")\n   *   .onUpdate(\"cascade\"); // Update child when parent key changes\n   * ```\n   */\n  public onUpdate(action: ForeignKeyDefinition[\"onUpdate\"]): this {\n    this.definition.onUpdate = action;\n    return this;\n  }\n\n  /**\n   * Shorthand for `.onDelete(\"cascade\").onUpdate(\"cascade\")`.\n   *\n   * @returns This builder for chaining\n   *\n   * @example\n   * ```typescript\n   * this.foreign(\"user_id\").references(\"users\").cascadeAll();\n   * ```\n   */\n  public cascadeAll(): this {\n    this.definition.onDelete = \"cascade\";\n    this.definition.onUpdate = \"cascade\";\n    return this;\n  }\n\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuCA,IAAa,oBAAb,MAA+B;CAWV;;CATnB,AAAiB;;;;;;;CAQjB,AAAO,YACL,AAAiB,WACjB,QACA;EAFiB;EAGjB,KAAK,aAAa;GAChB;GACA,iBAAiB;GACjB,kBAAkB;GAClB,UAAU;GACV,UAAU;EACZ;CACF;;;;;;;CAQA,AAAO,KAAK,MAAoB;EAC9B,KAAK,WAAW,OAAO;EACvB,OAAO;CACT;;;;;;;;;;;;;;;;;;CAmBA,AAAO,WAAW,OAAe,SAAS,MAAY;EACpD,KAAK,WAAW,kBAAkB;EAClC,KAAK,WAAW,mBAAmB;EACnC,KAAK,UAAU,uBAAuB,KAAK,UAAkC;EAC7E,OAAO;CACT;;;;;;;;;;;;;;CAeA,AAAO,SAAS,QAAgD;EAC9D,KAAK,WAAW,WAAW;EAC3B,OAAO;CACT;;;;;;;;;;;;;;CAeA,AAAO,SAAS,QAAgD;EAC9D,KAAK,WAAW,WAAW;EAC3B,OAAO;CACT;;;;;;;;;;;CAYA,AAAO,aAAmB;EACxB,KAAK,WAAW,WAAW;EAC3B,KAAK,WAAW,WAAW;EAC3B,OAAO;CACT;AAEF"}
+{"version":3,"file":"foreign-key-builder.mjs","names":[],"sources":["../../../../../../../../packages/cascade/src/migration/foreign-key-builder.ts"],"sourcesContent":["import type { ForeignKeyDefinition } from \"../contracts/migration-driver.contract\";\n\n/**\n * Reference to the Migration type to avoid circular imports.\n */\ntype MigrationLike = {\n  addForeignKeyOperation(fk: ForeignKeyDefinition): void;\n};\n\n/**\n * Mutable foreign key definition being built.\n */\ninterface MutableForeignKeyDefinition {\n  name?: string;\n  column: string;\n  referencesTable: string;\n  referencesColumn: string;\n  onDelete: ForeignKeyDefinition[\"onDelete\"];\n  onUpdate: ForeignKeyDefinition[\"onUpdate\"];\n}\n\n/**\n * Fluent builder for foreign key constraints.\n *\n * Allows building foreign key definitions with a chainable API.\n * SQL-only feature; NoSQL drivers ignore foreign keys.\n *\n * The operation is pushed when `.references()` is called using a mutable\n * reference — subsequent `.onDelete()` / `.onUpdate()` calls mutate the\n * same definition already queued in pendingOperations.\n *\n * @example\n * ```typescript\n * this.foreign(\"user_id\")\n *   .references(\"users\", \"id\")\n *   .onDelete(\"cascade\")\n *   .onUpdate(\"cascade\");\n * ```\n */\nexport class ForeignKeyBuilder {\n  /** Mutable foreign key definition being accumulated */\n  private readonly definition: MutableForeignKeyDefinition;\n\n  /**\n   * Create a new foreign key builder.\n   *\n   * @param migration - Parent migration instance\n   * @param column - Local column name that will reference another table\n   */\n  public constructor(\n    private readonly migration: MigrationLike,\n    column: string,\n  ) {\n    this.definition = {\n      column,\n      referencesTable: \"\",\n      referencesColumn: \"id\",\n      onDelete: \"restrict\",\n      onUpdate: \"restrict\",\n    };\n  }\n\n  /**\n   * Set the constraint name.\n   *\n   * @param name - Constraint name (auto-generated if not provided)\n   * @returns This builder for chaining\n   */\n  public name(name: string): this {\n    this.definition.name = name;\n    return this;\n  }\n\n  /**\n   * Set the referenced table and column, and register the foreign key operation.\n   *\n   * Pushes the operation immediately using a mutable reference — any\n   * `.onDelete()` / `.onUpdate()` calls after this will mutate the same\n   * definition already queued in pendingOperations.\n   *\n   * @param table - Referenced table name\n   * @param column - Referenced column name (default: \"id\")\n   * @returns This builder for chaining\n   *\n   * @example\n   * ```typescript\n   * this.foreign(\"user_id\").references(\"users\", \"id\");\n   * this.foreign(\"category_id\").references(\"categories\"); // defaults to \"id\"\n   * ```\n   */\n  public references(table: string, column = \"id\"): this {\n    this.definition.referencesTable = table;\n    this.definition.referencesColumn = column;\n    this.migration.addForeignKeyOperation(this.definition as ForeignKeyDefinition);\n    return this;\n  }\n\n  /**\n   * Set the ON DELETE action.\n   *\n   * @param action - Action to take when referenced row is deleted\n   * @returns This builder for chaining\n   *\n   * @example\n   * ```typescript\n   * this.foreign(\"user_id\")\n   *   .references(\"users\")\n   *   .onDelete(\"cascade\"); // Delete child when parent is deleted\n   * ```\n   */\n  public onDelete(action: ForeignKeyDefinition[\"onDelete\"]): this {\n    this.definition.onDelete = action;\n    return this;\n  }\n\n  /**\n   * Set the ON UPDATE action.\n   *\n   * @param action - Action to take when referenced row's key is updated\n   * @returns This builder for chaining\n   *\n   * @example\n   * ```typescript\n   * this.foreign(\"user_id\")\n   *   .references(\"users\")\n   *   .onUpdate(\"cascade\"); // Update child when parent key changes\n   * ```\n   */\n  public onUpdate(action: ForeignKeyDefinition[\"onUpdate\"]): this {\n    this.definition.onUpdate = action;\n    return this;\n  }\n\n  /**\n   * Shorthand for `.onDelete(\"cascade\").onUpdate(\"cascade\")`.\n   *\n   * @returns This builder for chaining\n   *\n   * @example\n   * ```typescript\n   * this.foreign(\"user_id\").references(\"users\").cascadeAll();\n   * ```\n   */\n  public cascadeAll(): this {\n    this.definition.onDelete = \"cascade\";\n    this.definition.onUpdate = \"cascade\";\n    return this;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;AAuCA,IAAa,oBAAb,MAA+B;CAWV;;CATnB,AAAiB;;;;;;;CAQjB,AAAO,YACL,AAAiB,WACjB,QACA;EAFiB;EAGjB,KAAK,aAAa;GAChB;GACA,iBAAiB;GACjB,kBAAkB;GAClB,UAAU;GACV,UAAU;EACZ;CACF;;;;;;;CAQA,AAAO,KAAK,MAAoB;EAC9B,KAAK,WAAW,OAAO;EACvB,OAAO;CACT;;;;;;;;;;;;;;;;;;CAmBA,AAAO,WAAW,OAAe,SAAS,MAAY;EACpD,KAAK,WAAW,kBAAkB;EAClC,KAAK,WAAW,mBAAmB;EACnC,KAAK,UAAU,uBAAuB,KAAK,UAAkC;EAC7E,OAAO;CACT;;;;;;;;;;;;;;CAeA,AAAO,SAAS,QAAgD;EAC9D,KAAK,WAAW,WAAW;EAC3B,OAAO;CACT;;;;;;;;;;;;;;CAeA,AAAO,SAAS,QAAgD;EAC9D,KAAK,WAAW,WAAW;EAC3B,OAAO;CACT;;;;;;;;;;;CAYA,AAAO,aAAmB;EACxB,KAAK,WAAW,WAAW;EAC3B,KAAK,WAAW,WAAW;EAC3B,OAAO;CACT;AACF"}

package/esm/migration/index.d.mts

@@ -1,6 +1,7 @@
 import { ColumnBuilder } from "./column-builder.mjs";
-import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./column-helpers.mjs";
+import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, bool as boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./column-helpers.mjs";
 import { ForeignKeyBuilder } from "./foreign-key-builder.mjs";
 import { AlterSchema, ColumnMap, IndexEntry, Migration, MigrationAlterOptions, MigrationConstructor, MigrationContract, MigrationCreateOptions, MigrationOrigin, MigrationStep, OperationType, PendingOperation, UniqueEntry, migrate } from "./migration.mjs";
 import { MigrationRecord, MigrationResult, MigrationRunnerOptions, MigrationStatus, RollbackOptions, RunMigrationsOptions } from "./types.mjs";
-import { MigrationRunner, inferMigrationName, migrationRunner } from "./migration-runner.mjs";
+import { MigrationRunner, inferMigrationName, migrationRunner } from "./migration-runner.mjs";
+export { AlterSchema, ColumnBuilder, ColumnMap, DetachedColumnBuilder, ForeignKeyBuilder, IndexEntry, Migration, MigrationAlterOptions, MigrationConstructor, MigrationContract, MigrationCreateOptions, MigrationOrigin, type MigrationRecord, type MigrationResult, MigrationRunner, type MigrationRunnerOptions, type MigrationStatus, MigrationStep, OperationType, PendingOperation, type RollbackOptions, type RunMigrationsOptions, UniqueEntry, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol as bool, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, inferMigrationName, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, migrate, migrationRunner, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year };

package/esm/migration/index.mjs

@@ -1,7 +1,7 @@
 import { ColumnBuilder } from "./column-builder.mjs";
 import { ForeignKeyBuilder } from "./foreign-key-builder.mjs";
-import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./column-helpers.mjs";
+import { DetachedColumnBuilder, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, bool as boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year } from "./column-helpers.mjs";
 import { Migration, migrate } from "./migration.mjs";
 import { MigrationRunner, inferMigrationName, migrationRunner } from "./migration-runner.mjs";
 
-export {  };
+export { ColumnBuilder, DetachedColumnBuilder, ForeignKeyBuilder, Migration, MigrationRunner, arrayBigInt, arrayBoolean, arrayDate, arrayDecimal, arrayFloat, arrayInt, arrayJson, arrayText, arrayTimestamp, arrayUuid, bigInt, bigInteger, binary, blobCol, boolCol as bool, boolCol, char, date, dateTime, decimal, double, enumCol, float, geometry, inferMigrationName, int, integer, ipAddress, json, lineString, longText, macAddress, mediumText, migrate, migrationRunner, objectCol, point, polygon, setCol, smallInt, smallInteger, string, text, time, timestamp, tinyInt, tinyInteger, ulid, uuid, vector, year };