@vibeorm/sql 5.7.0 → 5.9.0

package/dist/json-patch.d.ts

@@ -0,0 +1,96 @@
+/**
+ * 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>`.
+ */
+import type { SqlDialect } from "./dialect.ts";
+import type { ParamCollector } from "./params.ts";
+/** 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;
+/**
+ * The patched value of one Json column — `CASE WHEN <a container is not an
+ * object> THEN <fail on purpose> … ELSE <patched document> END` — where `read`
+ * is the column as the assignment reads it (qualified in a conflict update).
+ * Every placeholder is collected in text order.
+ */
+export declare function renderJsonPatch(params: {
+    dialect: SqlDialect;
+    patch: JsonPatchOperation;
+    read: string;
+    collector: ParamCollector;
+}): string;
+/** 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,3 @@
+/** `$.a.b[0]` path string for sqlite/mysql — always bound, never spliced. */
+export declare function jsonPathString(path: readonly (string | number)[]): string;
+//# sourceMappingURL=json-path.d.ts.map

package/dist/native-types.d.ts

@@ -0,0 +1,70 @@
+/**
+ * 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.
+ */
+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/render.d.ts

@@ -26,6 +26,15 @@ export declare function renderProjection(params: {
     dialect: SqlDialect;
     columns: readonly ColRef[];
 }): string;
+/**
+ * Are `sets` (indexes into `count` grouping keys) exactly the rollup chain
+ * `[0..n-1], [0..n-2], …, []`, in any order and with members in any order?
+ * The one shape a `rollup` dialect can group by (`GROUP BY … WITH ROLLUP`).
+ */
+export declare function isRollupChain(params: {
+    count: number;
+    sets: readonly (readonly number[])[];
+}): boolean;
 /**
  * Render one boolean expression into SQL text, collecting parameters into the
  * shared collector. Public so extension delegates can AND user `where` trees

package/dist/result-decoder.d.ts

@@ -53,6 +53,8 @@ export declare const decode: {
     readonly int: ResultDecoder<number>;
     readonly float: ResultDecoder<number>;
     readonly bigInt: ResultDecoder<bigint>;
+    /** A BigInt column as a safe `number`; a value beyond `Number.MAX_SAFE_INTEGER` refuses (`VIBE_DATA_INVALID` read, `VIBE_VALIDATION` write). */
+    readonly bigIntNumber: ResultDecoder<number>;
     readonly decimal: ResultDecoder<string>;
     readonly dateTime: ResultDecoder<Date>;
     readonly extendedDateTime: ResultDecoder<ExtendedDateTime>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/sql",
-  "version": "5.7.0",
+  "version": "5.9.0",
   "description": "Dialect-aware SQL layer for VibeORM v2 — SQL AST, renderers and capability tables for postgres, sqlite and mysql",
   "keywords": [
     "orm",
@@ -50,7 +50,7 @@
     "bun": ">=1.2.0"
   },
   "dependencies": {
-    "@vibeorm/schema": "^5.7.0"
+    "@vibeorm/schema": "^5.9.0"
   },
   "publishConfig": {
     "access": "public"