@vibeorm/sql 5.8.0 → 5.10.0

package/dist/json-patch.d.ts

@@ -0,0 +1,82 @@
+/**
+ * JSON key-level update: an ordered list of `set` / `remove` steps applied to
+ * ONE Json column in ONE assignment, without reading the document first.
+ *
+ * Semantics (identical on every dialect):
+ * - `set` replaces or adds the member at its path and creates missing
+ *   intermediate objects; a SQL NULL column starts from `{}`.
+ * - `remove` deletes the member; an absent member (or an absent container on
+ *   the way) is a no-op, and a SQL NULL column stays NULL.
+ * - Every container a step passes through must be an object or absent. An
+ *   array, a scalar or JSON `null` there refuses the write.
+ *
+ * The steps are folded at build time into one write tree, so the SQL reads
+ * only the ORIGINAL column, never an earlier step's result: its text grows
+ * linearly with the steps. A container whose value an earlier `set` wrote is
+ * known here and checked in JavaScript ({@link planJsonPatch} reports the
+ * conflict before any SQL); every other container is checked in the statement
+ * against the original document, and a failed check fails the statement on
+ * purpose with a marker the client maps back to a typed error:
+ * `__vibe_veto:json_patch:<nonce>:<check index>:<found type>`.
+ */
+/** One step of a JSON patch; `value` is the JSON text the Json codec wrote. */
+export type JsonPatchStep = {
+    readonly set: readonly string[];
+    readonly value: string;
+} | {
+    readonly remove: readonly string[];
+};
+/**
+ * An UPDATE set value that patches a Json column in place. Recognised
+ * structurally inside `UpdateStatement.set` and conflict updates, with the
+ * same discipline as the other set markers: the Json codec stringifies JSON
+ * payloads before they reach the AST, so a document is never mistaken for it.
+ */
+export type JsonPatchOperation = {
+    readonly __jsonPatch: true;
+    readonly steps: readonly JsonPatchStep[];
+    /** Per-call value bound into the refusal marker; the client maps only the markers it issued. */
+    readonly nonce: string;
+    /** `json` for a postgres `json` column (`Json @db.Json`): patched through jsonb, stored as json. */
+    readonly storage?: "json";
+};
+/** Narrow an UPDATE set value to a {@link JsonPatchOperation}. */
+export declare function isJsonPatchOperation(value: unknown): value is JsonPatchOperation;
+/** JSON types a container can hold instead of an object. */
+export type JsonPatchFoundType = "array" | "string" | "number" | "boolean" | "null";
+/** A container of the ORIGINAL document that must be an object or absent; `step` is the first step that passes through it. */
+export type JsonPatchCheck = {
+    readonly path: readonly string[];
+    readonly step: number;
+};
+/** A step that passes through a non-object value an earlier `set` of the same patch wrote. */
+export type JsonPatchConflict = {
+    readonly step: number;
+    readonly path: readonly string[];
+    readonly found: JsonPatchFoundType;
+};
+/** {@link planJsonPatch}: the in-statement checks in render order, or the conflict known before any SQL. */
+export type JsonPatchPlan = {
+    readonly checks: readonly JsonPatchCheck[];
+} | {
+    readonly conflict: JsonPatchConflict;
+};
+/**
+ * Fold a patch's steps: the checks the statement runs on the original
+ * document (index = the check index its refusal marker carries), or the
+ * conflict an earlier `set` of the same patch makes certain.
+ */
+export declare function planJsonPatch(params: {
+    steps: readonly JsonPatchStep[];
+}): JsonPatchPlan;
+/** A refusal marker found in a database error message: the nonce, the check index, and the container's type as the database spelled it. */
+export type JsonPatchVeto = {
+    readonly nonce: string;
+    readonly check: number;
+    readonly found: string;
+};
+/** The JSON patch refusal a database error message quotes, or `undefined`. */
+export declare function jsonPatchVetoOf(params: {
+    message: string;
+}): JsonPatchVeto | undefined;
+//# sourceMappingURL=json-patch.d.ts.map

package/dist/json-path.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=json-path.d.ts.map

package/dist/key-list.d.ts

@@ -26,17 +26,6 @@ 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
@@ -70,14 +59,4 @@ 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/native-types.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Column types per dialect: the type migrate creates for a scalar field, in
+ * the spelling it compares types by. ONE rule, read by migrate's differ and by
+ * the runtime's `describeSchema`, so two fields that describe the same type
+ * are two columns migrate would never ALTER into each other.
+ *
+ * A field without a native type gets its scalar's column type
+ * (dialect-matrix §2). A declared `@db.*` type replaces it on PostgreSQL and
+ * MySQL unless it IS that type spelled another way. SQLite stores every column
+ * by its scalar's storage class and ignores native types.
+ */
+import type { Dialect, ScalarType } from "@vibeorm/schema";
+/** IR scalar → the PostgreSQL column type migrate creates. */
+export declare const POSTGRES_SCALAR_COLUMN_TYPES: Readonly<Record<ScalarType, string>>;
+/** IR scalar → the MySQL column type migrate creates (information_schema spelling). */
+export declare const MYSQL_SCALAR_COLUMN_TYPES: Readonly<Record<ScalarType, string>>;
+/** IR scalar → the SQLite storage class migrate declares. */
+export declare const SQLITE_SCALAR_STORAGE_CLASSES: Readonly<Record<ScalarType, string>>;
+/**
+ * Alias map applied to the base name of a native type (everything before the
+ * parenthesized modifier) so that schema-declared `@db.*` spellings and
+ * catalog-reported names compare equal.
+ */
+export declare const POSTGRES_NATIVE_ALIASES: Readonly<Record<string, string>>;
+/**
+ * Normalize a PostgreSQL type string for comparison: lowercase, whitespace
+ * stripped, base name de-aliased. `"VarChar(191)"` and `"character
+ * varying(191)"` both become `"varchar(191)"`.
+ */
+export declare function normalizePostgresNativeType(params: {
+    readonly raw: string;
+}): string;
+/**
+ * Native spellings an explicit declaration compares EQUAL to its scalar's
+ * column type without being it: `@db.Timestamptz(6)` is bare `timestamptz`
+ * spelled out. Nothing grandfathered: `timestamptz(3)` stays its own type.
+ */
+export declare const POSTGRES_EXACT_EQUIVALENTS: Readonly<Partial<Record<ScalarType, readonly string[]>>>;
+/**
+ * Normalize a MySQL type string for comparison: lowercase, whitespace
+ * stripped, base de-aliased, integer display widths dropped (MySQL 8.0.19+
+ * omits them; older catalogs report `int(11)`) — EXCEPT `tinyint(1)`, which is
+ * the Boolean marker and must survive normalization. A zero fractional
+ * precision on a temporal type is dropped: the catalog reports
+ * `datetime(0)` as `datetime`.
+ */
+export declare function normalizeMysqlNativeType(params: {
+    readonly raw: string;
+}): string;
+/**
+ * The column type migrate creates for a scalar field on `dialect`, in the
+ * spelling it compares types by (an explicit declaration's exact comparison):
+ * the same answer for two fields means the same column type. `nativeType` is
+ * the field's declared `@db.*` text; for a list field the answer is the
+ * element type.
+ *
+ * - PostgreSQL: `String` and `String @db.Text` are `"text"`; `Int`,
+ *   `@db.Int4` and `@db.Integer` are `"integer"`; `Float` and
+ *   `@db.DoublePrecision` are `"doubleprecision"`; `DateTime` and
+ *   `@db.Timestamptz(6)` are `"timestamptz"`, while `@db.Timestamptz(3)` is
+ *   `"timestamptz(3)"`.
+ * - MySQL: `String` is `"varchar(191)"`, `Boolean` `"tinyint(1)"`, display
+ *   widths dropped (`int(11)` is `"int"`).
+ * - SQLite: the storage class (`"TEXT"`, `"INTEGER"`, `"REAL"`, `"BLOB"`);
+ *   a native type changes nothing there.
+ */
+export declare function canonicalColumnType(params: {
+    readonly dialect: Dialect;
+    readonly scalar: ScalarType;
+    readonly nativeType?: string | undefined;
+}): string;
+//# sourceMappingURL=native-types.d.ts.map

package/dist/params.d.ts

@@ -4,8 +4,6 @@ export declare class ParamCollector {
     private reserved;
     readonly values: unknown[];
     constructor(dialect: SqlDialect);
-    /** @internal Allocate recorded positions without inserting sample values. */
-    reserve(): string;
     /** Actual positional slots, including repeats of a named input. */
     count(): number;
     /** Register one value; ordinary and reusable paths share transport spelling. */

package/dist/query/expressions.d.ts

@@ -1,36 +1,4 @@
-import type { ResultDecoder, ResultReadDecoder, SqlFragment, SqlInputContract } from "@vibeorm/sql";
-import type { ColumnDefinition, Expression, Expressions } from "./types.ts";
-import type { RenderContext } from "./state.ts";
-export declare function nullableDecoder<T>(decoder: ResultReadDecoder<T>): ResultReadDecoder<T | null>;
-export declare function assertDecoder(decoder: ResultReadDecoder<unknown>): void;
-/** Keep physical native refinements in the central codec implementations. */
-export declare function nativeColumnDefinition(definition: ColumnDefinition<unknown>): ColumnDefinition<unknown>;
-/** Transport conversion belongs only at the final result boundary. */
-export declare function transportProjection(params: {
-    context: RenderContext;
-    expression: string;
-    definition: ColumnDefinition<unknown>;
-}): string;
-/** Write contracts carry encoding identity independently from projection output. */
-export declare function columnInputContract(definition: ColumnDefinition<unknown>): SqlInputContract;
-export declare function bindColumnValue(params: {
-    context: RenderContext;
-    definition: ColumnDefinition<unknown>;
-    value: unknown;
-    encoder?: ResultDecoder<unknown>;
-    rejectNull?: boolean;
-}): string;
-/** Construct a typed value for the public qb.value contract. */
-export declare function literal<T>(params: {
-    value: T;
-    decoder: ResultDecoder<T>;
-}): Expression<T>;
-/** Construct an explicit fragment projection for the public qb.raw contract. */
-export declare function rawExpression<T>(params: {
-    sql: SqlFragment;
-    decoder: ResultReadDecoder<T>;
-    references?: readonly Expression<unknown>[];
-}): Expression<T>;
+import type { Expressions } from "./types.ts";
 /** Compare typed operands for equality, preserving SQL NULL propagation. */
 export declare const eq: Expressions["eq"];
 /** Compare typed operands for inequality. */