@vibeorm/sql 2.5.0 → 4.0.0

package/dist/json-list-parameter.d.ts

@@ -0,0 +1,37 @@
+declare const JSON_LIST_PARAMETER: unique symbol;
+/**
+ * The element type of a postgres Json LIST column: `jsonb[]` by default,
+ * `json[]` for `Json[] @db.Json`. Comparison sites (`has`, `hasEvery`,
+ * `hasSome`, `equals`) render a `json` operand and its column as jsonb —
+ * `json` has no equality operator; write sites (`push`) keep `json`.
+ */
+export type JsonListStorage = "jsonb" | "json";
+/**
+ * A Json LIST parameter — one element's JSON text (`has`, `push` of one
+ * element) or a whole list of JSON texts (`hasEvery`, `hasSome`, `equals`,
+ * `push` of an array) — plus the column's element type. Never passed to a
+ * driver: the ParamCollector collects the plain value and renders
+ * `$n::text::jsonb` (or `$n::text::jsonb[]` for a whole list).
+ *
+ * Why it exists: an OID-typed driver (bun:sql with named statements) resolves
+ * the parameter's postgres type and re-serializes the JS value AS that type. A
+ * pre-stringified JSON element bound into a slot the server infers as `jsonb`
+ * (`$n = ANY("col")`, `array_append("col", $n)`) arrives DOUBLE-ENCODED, and
+ * `has: { a: 1 }` then matches nothing (live-proven on Bun 1.4.3). The `::text`
+ * pin makes every driver send the text and the SERVER parse it — the same
+ * trap `JsonParamCell` closes for Json columns.
+ */
+export type JsonListParameter = {
+    readonly [JSON_LIST_PARAMETER]: true;
+    readonly value: string | readonly string[];
+    readonly storage: JsonListStorage;
+};
+/** Attach the json/jsonb element type to an encoded Json list operand, without re-encoding it. */
+export declare function jsonListParameter(params: {
+    value: string | readonly string[];
+    storage: JsonListStorage;
+}): JsonListParameter;
+/** Narrow the internal typed parameter before collecting its plain wire value. */
+export declare function isJsonListParameter(value: unknown): value is JsonListParameter;
+export {};
+//# sourceMappingURL=json-list-parameter.d.ts.map

package/dist/parameter-snapshot.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Snapshot mutable values while preserving plain-object and array validation evidence.
+ * Reusable execution bags pass `isHandle` so authentic SQL handles refuse at every depth.
+ */
+export declare function snapshotSqlValue(value: unknown, ancestors?: ReadonlySet<object>, isHandle?: (value: object) => boolean): unknown;
+//# sourceMappingURL=parameter-snapshot.d.ts.map

package/dist/params.d.ts

@@ -1,17 +1,16 @@
-/**
- * Parameter collection during rendering.
- *
- * The single place placeholder indices are produced — renderers never
- * hand-write `$1`/`?`, so numbering and value order can never drift apart.
- */
 import type { SqlDialect } from "./dialect.ts";
 export declare class ParamCollector {
     private readonly dialect;
+    private reserved;
     readonly values: unknown[];
     constructor(dialect: SqlDialect);
-    /** Register one parameter value; returns its placeholder text. */
+    /** @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. */
     add(value: unknown): string;
-    /** Register many values; returns their placeholders in order. */
+    /** Register many values in positional order. */
     addMany(values: readonly unknown[]): string[];
 }
 //# sourceMappingURL=params.d.ts.map

package/dist/pg-array.d.ts

@@ -11,4 +11,17 @@ export declare function toPgArrayLiteral(params: {
 export declare function parsePgArrayLiteral(params: {
     literal: string;
 }): (string | null)[] | null;
+/** One element of a parsed array literal: its text, SQL NULL, or one nested dimension. */
+export type PgArrayLiteralElement = string | null | readonly PgArrayLiteralElement[];
+/**
+ * Parse a postgres array literal of ANY number of dimensions —
+ * `{{1,2},{3,NULL}}` becomes `[["1","2"],["3",null]]`, the nesting
+ * node-postgres returns for a known array type — or `null` when the text is
+ * not a well-formed literal. Explicit bounds (`[1:2][0:1]=`) are dropped.
+ * {@link parsePgArrayLiteral} stays the one-dimensional fast path; it would
+ * split `{{1,2}}` at every comma.
+ */
+export declare function parsePgArrayLiteralNested(params: {
+    literal: string;
+}): PgArrayLiteralElement[] | null;
 //# sourceMappingURL=pg-array.d.ts.map

package/dist/query/expressions.d.ts

@@ -0,0 +1,70 @@
+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>;
+/** Compare typed operands for equality, preserving SQL NULL propagation. */
+export declare const eq: Expressions["eq"];
+/** Compare typed operands for inequality. */
+export declare const ne: Expressions["ne"];
+/** Compare typed operands using greater-than. */
+export declare const gt: Expressions["gt"];
+/** Compare typed operands using greater-than-or-equal. */
+export declare const gte: Expressions["gte"];
+/** Compare typed operands using less-than. */
+export declare const lt: Expressions["lt"];
+/** Compare typed operands using less-than-or-equal. */
+export declare const lte: Expressions["lte"];
+/** Test SQL NULL without comparing a bound null value. */
+export declare const isNull: Expressions["isNull"];
+/** Test SQL non-nullness without comparing a bound null value. */
+export declare const isNotNull: Expressions["isNotNull"];
+/** Combine predicates with SQL AND; an empty conjunction is true. */
+export declare const and: Expressions["and"];
+/** Combine predicates with SQL OR; an empty disjunction is false. */
+export declare const or: Expressions["or"];
+/** Negate a predicate with SQL's three-valued boolean semantics. */
+export declare const not: Expressions["not"];
+/** Match a literal list; an empty list is false. */
+export declare const inList: Expressions["inList"];
+/** Exclude a literal list; an empty list is true. */
+export declare const notInList: Expressions["notInList"];
+/** Count rows or non-null expression values with exact bigint transport. */
+export declare const count: Expressions["count"];
+/** Minimum of a qualified ordered scalar, nullable for empty input. */
+export declare const min: Expressions["min"];
+/** Maximum of a qualified ordered scalar, nullable for empty input. */
+export declare const max: Expressions["max"];
+/** Sum of a qualified double-precision Float, nullable for empty input. */
+export declare const sum: Expressions["sum"];
+/** Average of a qualified double-precision Float, nullable for empty input. */
+export declare const avg: Expressions["avg"];
+//# sourceMappingURL=expressions.d.ts.map

package/dist/query/index.d.ts

@@ -0,0 +1,6 @@
+import type { QueryBuilder } from "./types.ts";
+/** Opt-in native SQL builder. Core fragments/plans are bare-imported from @vibeorm/sql. */
+export declare const qb: QueryBuilder;
+export { and, avg, count, eq, gt, gte, inList, isNotNull, isNull, lt, lte, max, min, ne, not, notInList, or, sum } from "./expressions.ts";
+export type { ColumnDefinition, ColumnDefinitions, Columns, Expression, Expressions, MutationBuilder, NullableRow, Order, Projection, ProjectionRow, QueryBuilder, Scope, SelectBuilder, Source, Table, WriteValues } from "./types.ts";
+//# sourceMappingURL=index.d.ts.map