@vibeorm/sql 3.0.0 → 4.0.0

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