@vibeorm/sql 5.9.0 → 5.11.0

package/dist/json-patch.d.ts

@@ -19,8 +19,6 @@
  * 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[];
@@ -71,18 +69,6 @@ export type JsonPatchPlan = {
 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;

package/dist/json-path.d.ts

@@ -1,3 +1,2 @@
-/** `$.a.b[0]` path string for sqlite/mysql — always bound, never spliced. */
-export declare function jsonPathString(path: readonly (string | number)[]): string;
+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
@@ -53,6 +42,44 @@ export declare function postgresKeyListElementType(params: {
 export declare function keyListBindsUntypedRows(params: {
     members: readonly KeyListMember[];
 }): boolean;
+/** How MySQL types a key it reads back from JSON text; see {@link mysqlJsonKeyTypeOf}. */
+export type MysqlJsonKeyType = "text" | "signed" | "unsigned";
+/**
+ * How MySQL turns the text of a key column, read back out of JSON, into a
+ * value its foreign-key column compares with through its index, or
+ * `undefined` for a key type nobody measured. `"text"`: the unquoted JSON
+ * string, compared under the column's collation like a bound literal.
+ * `"signed"` / `"unsigned"`: `CAST(… AS SIGNED | UNSIGNED)`, exact over the
+ * whole 64-bit range (text against a BIGINT column compares as a double).
+ * Dates, decimals, floats, booleans, bytes and enums are not admitted.
+ */
+export declare function mysqlJsonKeyTypeOf(params: {
+    member: KeyListMember;
+}): MysqlJsonKeyType | undefined;
+/**
+ * Does the token of a key read back from JSON (the key's text, written on the
+ * to-one's own row) need a text cast? A key the JSON carries as a number must
+ * travel as text, or a 64-bit integer would reach the client rounded; a MySQL
+ * string key is text already, and `CAST(… AS CHAR)` would convert it to the
+ * CONNECTION's character set, where a `utf8mb3` connection turns every
+ * character outside the BMP into `?` and two keys into one.
+ */
+export declare function jsonKeyTokenCast(params: {
+    dialect: SqlDialect;
+    member: KeyListMember;
+}): boolean;
+/**
+ * Can `dialect` type every one of `members` from its JSON text, as
+ * `SelectStatement.fromJsonKeys` must? PostgreSQL casts the text to the
+ * key-list's base type (not a `DateTime` without a declared native type,
+ * whose column may be a zone-less `timestamp`); MySQL admits the types of
+ * {@link mysqlJsonKeyTypeOf}. The renderer throws for a member this refuses,
+ * so the runtime asks here before it builds a dictionary level.
+ */
+export declare function jsonKeysTyped(params: {
+    dialect: SqlDialect;
+    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.
@@ -70,14 +97,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

@@ -40,7 +40,9 @@ export declare const POSTGRES_EXACT_EQUIVALENTS: Readonly<Partial<Record<ScalarT
  * 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.
+ * 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;

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. */