@vibeorm/sql 4.1.0 → 4.3.0

package/dist/key-list.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Key-list membership (`SqlExpr` `keyList`, the public `where: { IN }`):
+ * the postgres element type each member's array binds as.
+ *
+ * Postgres compares `"col" = $n` with the parameter typed as the column's
+ * type WITHOUT its modifier (measured on postgres 18.6: `timestamptz(3) =
+ * '…00.1234'` matches nothing, `numeric(10,2) = '1.234'` matches nothing,
+ * `varchar(3) = 'abcd'` matches nothing). The unnest form must compare the
+ * same way, so every member binds as `$n::<base type>[]`: a `timestamptz(3)[]`
+ * cast would round `.1234` onto the stored `.123` and match a row `=` does not.
+ * The base type also keeps the column's own operator and index: `bpchar` for
+ * `char(n)` (pad-insensitive like `=`), `citext` (case-insensitive like `=`;
+ * a `text[]` member would compare case-sensitively), the native enum's own
+ * type, and text collations resolve to the column's collation, as for `=`.
+ */
+import type { KeyListMember } from "./ast.ts";
+import type { SqlDialect } from "./dialect.ts";
+/**
+ * The postgres element type a key-list member's array binds as, or
+ * `undefined` when the member has none (Json, or a native type this list does
+ * not know). Never throws: a caller deciding whether a key list CAN carry a
+ * member (the automatic OR rewrite) asks here; {@link postgresKeyListElementType}
+ * is the throwing form the renderer uses.
+ */
+export declare function postgresKeyListElementTypeOf(params: {
+    dialect: SqlDialect;
+    member: KeyListMember;
+}): string | undefined;
+/**
+ * The postgres element type a key-list member's array binds as
+ * (`$n::<type>[]`), derived from the column's declared type facts.
+ *
+ * @throws VibeError `VIBE_UNSUPPORTED_CAPABILITY` for a member whose type has
+ *   no equality a key can use (Json) or a native type this list does not know.
+ */
+export declare function postgresKeyListElementType(params: {
+    dialect: SqlDialect;
+    member: KeyListMember;
+}): string;
+/**
+ * Whether a key list must bind its rows as a row-value list of UNTYPED
+ * parameters, `(a, b) IN (($1, $2), …)`, instead of typed arrays on the
+ * `unnest` strategy: some member is a `DateTime` without a declared native
+ * type. Its element type would be `timestamptz`, but such a field may sit on
+ * a zone-less `timestamp(3)` column (a Prisma-created database;
+ * docs/dialect-notes.md "DateTime without time zone on postgres"), where
+ * `timestamp = timestamptz` converts the column through the session TimeZone
+ * and matches other rows than `"col" = $n` (an untyped parameter the server
+ * types from the column). The row-value list keeps that typing; PostgreSQL
+ * plans it like the OR of conjunctions, so its planning grows with the list.
+ * Shared by the renderer and the runtime's render-cache walk.
+ */
+export declare function keyListBindsUntypedRows(params: {
+    members: readonly KeyListMember[];
+}): boolean;
+/**
+ * The cast after a bulk-insert column's array placeholder (`$n::<cast>[]`),
+ * or `undefined` when the column has none and the insert must keep VALUES.
+ * Never throws: the query builder asks here while deciding admission.
+ *
+ * Every type the key list knows binds its BASE type, exactly as above — the
+ * INSERT's assignment then applies the column's modifier (length, precision,
+ * rounding) the way it does for a VALUES parameter. Json is the one addition:
+ * it binds through a text slot, `text::jsonb` (`text::json` for `@db.Json`),
+ * because PostgreSQL has no assignment cast from text to jsonb and bun:sql's
+ * named statements would JSON-encode pre-encoded text bound to a jsonb slot
+ * (the `JsonParamCell` rule, per element).
+ */
+export declare function postgresBulkInsertArrayCastOf(params: {
+    dialect: SqlDialect;
+    member: KeyListMember;
+}): string | undefined;
+/**
+ * The throwing form of {@link postgresBulkInsertArrayCastOf}, for the renderer.
+ *
+ * @throws VibeError `VIBE_UNSUPPORTED_CAPABILITY` for a native type the
+ *   bulk-insert form does not know.
+ */
+export declare function postgresBulkInsertArrayCast(params: {
+    dialect: SqlDialect;
+    member: KeyListMember;
+}): string;
+//# sourceMappingURL=key-list.d.ts.map

package/dist/like.d.ts

@@ -41,4 +41,21 @@ export declare function strictMatchPattern(params: {
     op: "contains" | "startsWith" | "endsWith";
     value: string;
 }): string;
+/**
+ * Does a `strictMatch` render the collation `LIKE` conjunct BEFORE its
+ * byte-exact test? Only the `binary` strategy's (mysql) non-negated
+ * `startsWith`: `(col LIKE ? AND col LIKE CAST(? AS BINARY))`, the same
+ * pattern bound twice. A byte-exact prefix match is always a collation match
+ * (a collation never separates identical characters, and the escaped prefix
+ * plus `%` has no other wildcard), so the AND keeps exactly the binary test's
+ * rows — while the plain conjunct lets a btree index on the column bound the
+ * scan (measured on mysql 26.7: 5.92 → 0.24 ms, 100 002 → 3 rows read). The
+ * ONE decision point for the renderer AND the runtime's render-cache mirror,
+ * which must bind the pattern twice exactly when the renderer does.
+ */
+export declare function strictMatchCollationPrefilter(params: {
+    strategy: "native" | "glob" | "binary";
+    op: "equals" | "contains" | "startsWith" | "endsWith";
+    negate: boolean;
+}): boolean;
 //# sourceMappingURL=like.d.ts.map

package/dist/local-date.d.ts

@@ -0,0 +1,9 @@
+import type { CheckIR } from "@vibeorm/schema";
+import type { SqlDialect } from "./dialect.ts";
+/** The single owned SQLite calendar/domain CHECK; native DATE dialects need no marker. */
+export declare function renderLocalDateCheck({ dialect, table, column }: {
+    readonly dialect: SqlDialect;
+    readonly table: string;
+    readonly column: string;
+}): CheckIR | undefined;
+//# sourceMappingURL=local-date.d.ts.map

package/dist/pg-array.d.ts

@@ -7,6 +7,12 @@ export declare function toPgArrayLiteral(params: {
  * not a literal (defensive — the value then passes through untouched).
  * Unquoted `NULL` is SQL NULL; postgres quotes any element that could be
  * mistaken for it.
+ *
+ * RD-07: elements are SLICED out of the literal (an unquoted element up to the
+ * next comma, a quoted one as the runs between its escapes) instead of built
+ * one character at a time; the output, malformed input included, is the same
+ * as the former char-by-char parser's (differential test
+ * `tests/pg-array-literal-sliced.test.ts`).
  */
 export declare function parsePgArrayLiteral(params: {
     literal: string;

package/dist/predicate.d.ts

@@ -6,6 +6,9 @@
  * `WHERE`. Constitution rule 4 — every SQL-text decision lives in a dialect
  * here, never in migrate, the DSL or a query builder.
  *
+ * Shared scalar rendering also serves expression-index keys. The caller owns
+ * expression-index DDL and its additional database-object qualification.
+ *
  * What it guarantees:
  *
  * - **Logical field names resolve to physical columns.** `@map("qty_total")`
@@ -14,9 +17,8 @@
  * - **Identifiers are quoted through `dialect.quoteIdent`, literals through
  *   `dialect.quoteStringLiteral`.** No value the author writes can escape its
  *   literal and become SQL structure.
- * - **Operand scalars must match the field's.** Compared through
- *   `fieldTypeIdentity`, the same answer foreign-key pairing uses, so a check
- *   and a relation can never disagree about what a column IS.
+ * - **Operand scalars must match the expression result type.** Local dates keep
+ *   their distinct logical identity, shared with foreign-key pairing.
  * - **A dialect that cannot express something refuses here**, at the earliest
  *   knowable moment (generate time), with a `VibeError` carrying a stable
  *   `meta.rule` — never silently different SQL.
@@ -26,13 +28,13 @@
  * an implicit `IS NOT NULL` guard. An author who wants all-or-none writes it
  * with `isNull`/`isNotNull`.
  */
-import type { EnumIR, ModelIR, PredicateIR } from "@vibeorm/schema";
+import type { EnumIR, ModelIR, PredicateBooleanUsage, PredicateExpression, PredicateIR, PredicateResultType } from "@vibeorm/schema";
 import type { SqlDialect } from "./dialect.ts";
 /**
- * Where a predicate is being rendered. The two sites have different database
- * limits, so the renderer has to know which one it is serving.
+ * Where a Boolean predicate is being rendered. Each host has different database
+ * limits; scalar index-expression usage is handled by renderSchemaExpression.
  */
-export type PredicateUsage = "check" | "indexPredicate" | "exclusionPredicate";
+export type PredicateUsage = PredicateBooleanUsage;
 /**
  * The part of a model a predicate reads: its name (for error messages) and its
  * fields (for physical column names and scalar types). Narrow on purpose — a
@@ -50,4 +52,16 @@ export declare function renderPredicate(params: {
     /** Human label naming the declaration, e.g. `CHECK "order_total_nonnegative"`. */
     site: string;
 }): string;
+/** Render a scalar schema expression. Expression-index DDL and host qualification belong to the caller. */
+export declare function renderSchemaExpression({ expression, model, dialect, enums, usage, site }: {
+    expression: PredicateExpression;
+    model: PredicateModel;
+    dialect: SqlDialect;
+    enums?: readonly EnumIR[];
+    usage: "indexExpression";
+    site: string;
+}): {
+    readonly text: string;
+    readonly resultType: PredicateResultType;
+};
 //# sourceMappingURL=predicate.d.ts.map

package/dist/query/index.js

@@ -13,6 +13,11 @@ registerSqlHandleCheck({ check: (value) => expressionStates.has(value) || source
 function columnContract(definition) {
   return JSON.stringify({ scalar: definition.scalar, nullable: definition.nullable === true, list: definition.list === true, enumType: definition.enumType, enumValues: definition.enumValues, nativeType: definition.nativeType, transport: definition.transport });
 }
+function assertWritableColumn({ table, column }) {
+  if (table.columns[column]?.generated === true) {
+    throw new VibeError({ code: "VIBE_VALIDATION", message: `Generated SQL column "${column}" is read-only`, meta: { reason: "generated-column-write", table: table.name, field: column, path: [column] } });
+  }
+}
 function invalid(message) {
   throw new VibeError({ code: "VIBE_VALIDATION", message });
 }
@@ -64,7 +69,8 @@ function checkScope(params) {
 import { assertSqlNamespace } from "@vibeorm/schema";
 
 // packages/sql/src/query/expressions.ts
-import { assertSqlParamBuilding, decode, float32Codec, isSqlBindingCollector, isSqlFragment, isSqlParam, jsonListParameter, nativeEnumArrayParameter, parsePgArrayLiteral, recordSqlBinding, renderSqlFragment, resultScalarContract, snapshotSqlValue, sqlParamContract, timeOfDayCodec, toPgArrayLiteral } from "@vibeorm/sql";
+import { isLocalDateField } from "@vibeorm/schema";
+import { assertSqlParamBuilding, decode, float32Codec, isSqlBindingCollector, isSqlFragment, isSqlParam, jsonListParameter, localDateCodec, nativeEnumArrayParameter, parsePgArrayLiteral, recordSqlBinding, renderSqlFragment, resultScalarContract, snapshotSqlValue, sqlParamContract, timeOfDayCodec, toPgArrayLiteral } from "@vibeorm/sql";
 var nullableFloat = decode.nullable({ decoder: decode.float });
 var countDefinition = Object.freeze({ name: "", scalar: "BigInt", decoder: decode.bigInt });
 var floatDefinition = Object.freeze({ name: "", scalar: "Float", nullable: true, decoder: nullableFloat });
@@ -74,6 +80,8 @@ function nullableDecoder(decoder) {
   if (lifted === undefined) {
     lifted = Object.freeze({ decode: (params) => params.value === null ? null : decoder.decode(params) });
     nullableDecoders.set(decoder, lifted);
+    if (localDateValueDecoders.has(decoder))
+      localDateValueDecoders.add(lifted);
   }
   return lifted;
 }
@@ -87,11 +95,19 @@ function inputDecoder(definition) {
     invalid("A decode-only projection requires a separate inputDecoder for parameters and writes");
   return decoder;
 }
+function isLocalDateColumn({ definition }) {
+  return definition?.scalar === "String" && isLocalDateField({ field: { type: "String", nativeType: definition.nativeType } });
+}
 function nativeColumnDefinition(definition) {
+  const localDate = isLocalDateColumn({ definition });
+  if (localDate && definition.list === true)
+    invalid("Local-date list columns are unsupported");
+  if (localDate && localDateDecoders.has(definition.decoder))
+    return definition;
   const contract = resultScalarContract({ decoder: definition.decoder });
-  if (contract === undefined || contract.scalar !== definition.scalar)
+  if (!localDate && (contract === undefined || contract.scalar !== definition.scalar))
     return definition;
-  const codec = definition.scalar === "DateTime" ? timeOfDayCodec({ nativeType: definition.nativeType }) : definition.scalar === "Float" && /^(real|float4)$/i.test(definition.nativeType ?? "") ? float32Codec : undefined;
+  const codec = localDate ? localDateCodec : definition.scalar === "DateTime" ? timeOfDayCodec({ nativeType: definition.nativeType }) : definition.scalar === "Float" && /^(real|float4)$/i.test(definition.nativeType ?? "") ? float32Codec : undefined;
   if (codec === undefined)
     return definition;
   const original = definition.decoder;
@@ -101,7 +117,7 @@ function nativeColumnDefinition(definition) {
     decoders = new Map;
     nativeDecoders.set(original, decoders);
   }
-  const key = `${definition.nativeType}|${list}`;
+  const key = localDate ? "local-date" : `${definition.nativeType}|${list}`;
   let decoder = decoders.get(key);
   if (decoder === undefined) {
     decoder = Object.freeze({
@@ -112,20 +128,32 @@ function nativeColumnDefinition(definition) {
         const value = raw === null ? null : list && Array.isArray(elements) ? elements.map(convert) : convert(raw);
         return original.decode({ ...params, value });
       },
-      encode: (params) => {
-        const encoded = original.encode(params);
-        const convert = (value) => value === null ? null : codec.encode(value);
-        return list && Array.isArray(encoded) ? encoded.map(convert) : convert(encoded);
-      }
+      ..."encode" in original && typeof original.encode === "function" ? {
+        encode: (params) => {
+          const encoded = original.encode(params);
+          const convert = (value) => value === null ? null : codec.encode(value);
+          return list && Array.isArray(encoded) ? encoded.map(convert) : convert(encoded);
+        }
+      } : {}
     });
     decoders.set(key, decoder);
+    if (localDate) {
+      localDateDecoders.add(decoder);
+      if (contract?.scalar === "String" && !contract.list)
+        localDateValueDecoders.add(decoder);
+    }
   }
   return { ...definition, decoder };
 }
 var nativeDecoders = new WeakMap;
+var localDateDecoders = new WeakSet;
+var localDateValueDecoders = new WeakSet;
+function hasLocalDateValueInput({ definition }) {
+  return isLocalDateColumn({ definition }) && localDateValueDecoders.has(definition.decoder) && (definition.inputDecoder === undefined || localDateValueDecoders.has(definition.inputDecoder));
+}
 function transportProjection(params) {
   const { context, expression, definition } = params;
-  if (definition.transport === "text" || definition.scalar === "Json" || definition.scalar === "BigInt" || definition.list === true && definition.scalar === "Float") {
+  if (context.dialect.name !== "sqlite" && isLocalDateColumn({ definition }) || definition.transport === "text" || definition.scalar === "Json" || definition.scalar === "BigInt" || definition.list === true && definition.scalar === "Float") {
     return `CAST(${expression} AS ${context.dialect.name === "mysql" ? "CHAR" : "TEXT"})`;
   }
   return expression;
@@ -141,7 +169,7 @@ function columnInputContract(definition) {
     enumValues: definition.enumValues,
     enumType: definition.enumType,
     jsonStorage: definition.jsonStorage,
-    ...definition.inputDecoder !== undefined && definition.inputDecoder !== definition.decoder ? { columnIdentity: encoder } : {}
+    ...definition.inputDecoder !== undefined && definition.inputDecoder !== definition.decoder && !hasLocalDateValueInput({ definition }) ? { columnIdentity: encoder } : {}
   };
 }
 function physicalInput(contract) {
@@ -190,6 +218,8 @@ function encodeColumnValue(params) {
       invalid("A non-null SQL column cannot receive SQL NULL from its encoder");
     return null;
   }
+  if (isLocalDateColumn({ definition }))
+    return localDateCodec.encode(encoded);
   if (definition.scalar === "BigInt" && definition.list !== true && dialect.name === "sqlite") {
     const integer = decode.bigInt.decode({ value: encoded, dialect: "sqlite" });
     if (integer < -9223372036854775808n || integer > 9223372036854775807n)
@@ -239,7 +269,7 @@ function bindColumnValue(params) {
 }
 function predicateDefinition(expression) {
   const state = expressionState(expression);
-  if (state.definition?.inputDecoder !== undefined && (!("encode" in state.definition.decoder) || typeof state.definition.decoder.encode !== "function"))
+  if (state.definition?.inputDecoder !== undefined && (!("encode" in state.definition.decoder) || typeof state.definition.decoder.encode !== "function") && !hasLocalDateValueInput({ definition: state.definition }))
     unsupported("Input tokens cannot infer predicates over read-transformed columns");
   if (state.definition !== undefined)
     return state.definition;
@@ -297,7 +327,7 @@ function literal(params) {
 function comparedLiteral(params) {
   const state = expressionState(params.expression);
   const definition = state.definition;
-  if (definition?.inputDecoder !== undefined && (!("encode" in definition.decoder) || typeof definition.decoder.encode !== "function")) {
+  if (definition?.inputDecoder !== undefined && (!("encode" in definition.decoder) || typeof definition.decoder.encode !== "function") && !hasLocalDateValueInput({ definition })) {
     unsupported("Implicit literal predicates are unavailable for read-transformed columns; use an explicit trusted SQL input contract");
   }
   const value = snapshotSqlValue(params.value);
@@ -335,6 +365,9 @@ function comparison(params) {
   const right = typeof params.right === "object" && params.right !== null && expressionStates.has(params.right) ? params.right : comparedLiteral({ expression: params.left, value: params.right });
   const leftState = expressionState(params.left);
   const rightState = expressionState(right);
+  if (leftState.parameter === undefined && rightState.parameter === undefined && leftState.definition !== undefined && rightState.definition !== undefined && isLocalDateColumn({ definition: leftState.definition }) !== isLocalDateColumn({ definition: rightState.definition })) {
+    invalid("Local-date comparisons require matching local-date columns, not plain text or another scalar");
+  }
   const unsafeDecimal = (state) => state.definition?.scalar === "Decimal";
   return makeExpression(childrenState({
     children: [params.left, right],
@@ -342,7 +375,7 @@ function comparison(params) {
     render: (context) => {
       if (context.dialect.name === "sqlite" && (unsafeDecimal(leftState) || unsafeDecimal(rightState)))
         unsupported("SQLite Decimal comparisons are not exact; use an explicit raw numeric contract");
-      const left = leftState.render(context);
+      const left = leftState.parameter !== undefined && isLocalDateColumn({ definition: rightState.definition }) ? bindColumnValue({ context, definition: rightState.definition, encoder: leftState.parameter.decoder, value: leftState.parameter.value }) : leftState.render(context);
       const operand = leftState.parameter === undefined && leftState.definition !== undefined && rightState.parameter !== undefined ? bindColumnValue({ context, definition: leftState.definition, encoder: rightState.parameter.decoder, value: rightState.parameter.value }) : rightState.render(context);
       return `(${left} ${params.operator} ${operand})`;
     }
@@ -363,7 +396,7 @@ function aggregate(params) {
     invalid("Nested aggregate expressions are unsupported");
   if (definition === undefined || definition.list === true || !["String", "Int", "BigInt", "Float", "DateTime"].includes(definition.scalar))
     unsupported("MIN/MAX require a qualified ordered scalar column; use an explicit raw decoder otherwise");
-  if (definition.scalar === "String" && definition.nativeType !== undefined && !/^(text|varchar|char|bpchar|tinytext|mediumtext|longtext)(?:\s*\(.*\))?$/i.test(definition.nativeType))
+  if (definition.scalar === "String" && !isLocalDateColumn({ definition }) && definition.nativeType !== undefined && !/^(text|varchar|char|bpchar|tinytext|mediumtext|longtext)(?:\s*\(.*\))?$/i.test(definition.nativeType))
     unsupported("MIN/MAX do not support this native String type; UUID and other non-text types need explicit SQL");
   return makeExpression({
     ...state,
@@ -375,7 +408,7 @@ function aggregate(params) {
     ungrouped: new Set,
     aggregate: true,
     render: (context) => `${params.fn}(${state.render(context)})`,
-    projection: definition.scalar === "BigInt" ? (context) => `CAST(${params.fn}(${state.render(context)}) AS ${context.dialect.name === "mysql" ? "CHAR" : "TEXT"})` : undefined
+    projection: definition.scalar === "BigInt" || isLocalDateColumn({ definition }) ? (context) => transportProjection({ context, expression: `${params.fn}(${state.render(context)})`, definition }) : undefined
   });
 }
 function floatAggregate(params) {
@@ -488,6 +521,8 @@ function makeTable(params) {
     identifier(key);
     identifier(definition.name);
     assertDecoder(definition.decoder);
+    if (definition.generated !== undefined && definition.generated !== true)
+      invalid("SQL generated-column metadata must be true when present");
     if (definition.inputDecoder !== undefined && typeof definition.inputDecoder.encode !== "function")
       invalid("SQL input decoders must have an encoder");
     if (definition.enumType !== undefined) {
@@ -501,9 +536,11 @@ function makeTable(params) {
   const physical = Object.values(columns).map((column) => column.name);
   if (new Set(physical).size !== physical.length)
     invalid("Physical column names must be unique within a source");
-  const required = [...params.required ?? Object.entries(columns).filter(([, definition]) => definition.nullable !== true && definition.dbDefault !== true).map(([name]) => name)];
+  const required = [...params.required ?? Object.entries(columns).filter(([, definition]) => definition.nullable !== true && definition.dbDefault !== true && definition.generated !== true).map(([name]) => name)];
   if (required.some((key) => !Object.hasOwn(columns, key)))
     invalid("Required insert columns must belong to the table");
+  for (const column of required)
+    assertWritableColumn({ table: { name: params.name, columns, required }, column });
   const source = Object.freeze(Object.create(null));
   sourceStates.set(source, Object.freeze({ name: params.name, namespace: params.namespace, columns: Object.freeze(columns), required: Object.freeze(required), readOnly: params.readOnly === true }));
   return source;
@@ -874,9 +911,11 @@ function cells(params) {
     invalid("SQL write rows must be field objects");
   const table = sourceState(params.binding.source);
   const row = params.value;
-  for (const name of Object.keys(row))
+  for (const name of Object.keys(row)) {
     if (!Object.hasOwn(table.columns, name))
       invalid(`Unknown SQL write field "${name}"`);
+    assertWritableColumn({ table, column: name });
+  }
   return Object.freeze(Object.keys(table.columns).filter((name) => Object.hasOwn(row, name)).map((name) => {
     const value = row[name];
     if (isSqlParam3(value)) {
@@ -1009,6 +1048,7 @@ function input(params) {
     invalid("qb.input requires a writable physical table");
   if (!Object.hasOwn(table.columns, params.column))
     invalid("SQL input column does not belong to its table");
+  assertWritableColumn({ table, column: params.column });
   const definition = table.columns[params.column];
   let descriptor = columnInputs.get(definition);
   if (descriptor === undefined) {
@@ -1077,4 +1117,4 @@ export {
   sum
 };
 
-//# debugId=B60163A02807B75F64756E2164756E21
+//# debugId=3FADE857D3991B3164756E2164756E21