@vibeorm/sql 5.8.0 → 5.10.0

package/dist/query/mutations.d.ts

@@ -1,15 +1,2 @@
-import type { Expression, MutationBuilder, Table, WriteValues } from "./types.ts";
-/** Explicit physical SQL DEFAULT, not an application-side default callback. */
-export declare const sqlDefault: Expression<never>;
-export declare function insert<Row, Input>(params: {
-    into: Table<Row, Input>;
-    values: WriteValues<NoInfer<Input>> | readonly WriteValues<NoInfer<Input>>[];
-}): MutationBuilder<Row>;
-export declare function update<Row, Input>(params: {
-    table: Table<Row, Input>;
-    set: Partial<WriteValues<NoInfer<Input>>>;
-}): MutationBuilder<Row>;
-export declare function deleteRows<Row, Input>(params: {
-    table: Table<Row, Input>;
-}): MutationBuilder<Row>;
+export {};
 //# sourceMappingURL=mutations.d.ts.map

package/dist/query/reusable.d.ts

@@ -1,17 +1,2 @@
-import type { ReusableSqlCommand, ReusableSqlQuery, SqlCommand, SqlInput, SqlInputMap, SqlInputTokens, SqlInputValues, SqlQuery } from "@vibeorm/sql";
-import type { Expression, Table } from "./types.ts";
-/** Capture a physical column's write input without borrowing its read output type. */
-export declare function input<Row, Input, K extends keyof Row & keyof Input & string>(params: {
-    readonly table: Table<Row, Input>;
-    readonly column: K;
-}): SqlInput<Exclude<Input[K], undefined | Expression<never>>>;
-/** Run one synchronous builder callback with private, write-only input tokens. */
-export declare function reusable<const D extends SqlInputMap, Row>(params: {
-    readonly params: D;
-    readonly build: (params: SqlInputTokens<D>) => SqlQuery<Row>;
-}): ReusableSqlQuery<SqlInputValues<D>, Row>;
-export declare function reusable<const D extends SqlInputMap>(params: {
-    readonly params: D;
-    readonly build: (params: SqlInputTokens<D>) => SqlCommand;
-}): ReusableSqlCommand<SqlInputValues<D>>;
+export {};
 //# sourceMappingURL=reusable.d.ts.map

package/dist/query/select.d.ts

@@ -1,11 +1,2 @@
-import type { SqlQuery } from "@vibeorm/sql";
-import type { SelectBuilder, Source } from "./types.ts";
-export declare function from<Row, A extends string>(params: {
-    source: Source<Row>;
-    as: A;
-}): SelectBuilder<Record<A, Row>>;
-export declare function union<Row>(params: {
-    queries: readonly SqlQuery<Row>[];
-    all?: boolean;
-}): SqlQuery<Row>;
+export {};
 //# sourceMappingURL=select.d.ts.map

package/dist/query/sources.d.ts

@@ -1,37 +1,2 @@
-import type { ResultReadDecoder, SqlQuery } from "@vibeorm/sql";
-import type { ColumnDefinitions, Columns, Expression, Projection, ProjectionRow, Scope, Source, Table } from "./types.ts";
-import type { Binding, ColumnKey, ProjectionEntry, RenderContext } from "./state.ts";
-export declare function makeTable<Row, Input = Partial<Row>>(params: {
-    name: string;
-    namespace?: string;
-    columns: ColumnDefinitions<Row>;
-    required?: readonly string[];
-    readOnly?: boolean;
-}): Table<Row, Input>;
-export declare function makeDerived<Row>(params: {
-    query: SqlQuery<Row>;
-    name?: string;
-}): Source<Row>;
-export declare function makeBinding(params: {
-    source: Source<unknown>;
-    alias: string;
-    nullable?: boolean;
-}): Binding;
-export declare function bindingColumns<Row>(binding: Binding, qualified?: boolean): Columns<Row>;
-export declare function scope<S>(bindings: readonly Binding[]): Scope<S>;
-export declare function renderSource(params: {
-    context: RenderContext;
-    binding: Binding;
-}): string;
-export declare function projectionEntries(params: {
-    projection: Projection;
-    bindings: readonly Binding[];
-    aggregates?: boolean;
-}): readonly ProjectionEntry[];
-export declare function renderEntries(params: {
-    entries: readonly ProjectionEntry[];
-    context: RenderContext;
-}): string;
-export declare function projectionDecoder<P extends Projection>(entries: readonly ProjectionEntry[]): ResultReadDecoder<ProjectionRow<P>>;
-export declare function groupKeys(expressions: readonly Expression<unknown>[]): ReadonlySet<ColumnKey>;
+export {};
 //# sourceMappingURL=sources.d.ts.map

package/dist/query/state.d.ts

@@ -1,78 +1,2 @@
-import type { ParamCollector, ResultDecoder, ResultReadDecoder, SqlDialect, SqlQuery } from "@vibeorm/sql";
-import type { ColumnDefinition, Expression, Source } from "./types.ts";
-export type RenderContext = {
-    readonly dialect: SqlDialect;
-    readonly collector: ParamCollector;
-    readonly transport?: boolean;
-};
-export type ColumnKey = {
-    readonly binding: object;
-    readonly name: string;
-};
-export type ExpressionState = {
-    readonly decoder: ResultReadDecoder<unknown>;
-    readonly render: (context: RenderContext) => string;
-    readonly projection?: (context: RenderContext) => string;
-    readonly references: ReadonlySet<object>;
-    readonly ungrouped: ReadonlySet<ColumnKey>;
-    readonly aggregate: boolean;
-    readonly contract: object | string;
-    readonly definition?: ColumnDefinition<unknown>;
-    readonly column?: ColumnKey;
-    readonly parameter?: {
-        readonly value: unknown;
-        readonly decoder: ResultDecoder<unknown>;
-    };
-    readonly default?: boolean;
-};
-export type ProjectionEntry = {
-    readonly alias: string;
-    readonly expression: Expression<unknown>;
-};
-export type ReadState = {
-    readonly entries: readonly ProjectionEntry[];
-    readonly render: (context: RenderContext) => string;
-    readonly physicalNames: readonly string[];
-    readonly ctes: readonly Source<unknown>[];
-};
-export type SourceState = {
-    readonly name?: string;
-    readonly namespace?: string;
-    readonly columns: Readonly<Record<string, ColumnDefinition<unknown>>>;
-    readonly required: readonly string[];
-    readonly readOnly?: boolean;
-    readonly query?: ReadState;
-    readonly cte?: string;
-};
-export type Binding = {
-    readonly source: Source<unknown>;
-    readonly alias: string;
-    readonly token: object;
-    readonly nullable: boolean;
-    readonly keys: Readonly<Record<string, ColumnKey>>;
-};
-export declare const expressionStates: WeakMap<object, ExpressionState>;
-export declare const sourceStates: WeakMap<object, SourceState>;
-export declare const readStates: WeakMap<object, ReadState>;
-export declare const builderTerminals: WeakSet<object>;
-export declare function columnContract(definition: ColumnDefinition<unknown>): string;
-/** Reject database-owned assignments before reading values or deriving input encoders. */
-export declare function assertWritableColumn({ table, column }: {
-    readonly table: SourceState;
-    readonly column: string;
-}): void;
-export declare function invalid(message: string): never;
-export declare function invalidData(message: string): never;
-export declare function unsupported(message: string): never;
-export declare function identifier(name: string): void;
-export declare function expressionState(expression: Expression<unknown>): ExpressionState;
-export declare function sourceState(source: Source<unknown>): SourceState;
-export declare function readState(query: SqlQuery<unknown>): ReadState;
-export declare function makeExpression<T>(state: ExpressionState): Expression<T>;
-export declare function checkScope(params: {
-    expression: Expression<unknown>;
-    bindings: readonly Binding[];
-    aggregates?: boolean;
-    nullableContracts?: boolean;
-}): void;
+export {};
 //# sourceMappingURL=state.d.ts.map

package/dist/query-plan.d.ts

@@ -58,12 +58,12 @@ export declare function isSqlCommand(value: unknown): value is SqlCommand;
 export declare function isReusableSqlQuery(value: unknown): value is ReusableSqlQuery<object, unknown>;
 /** Authentic reusable commands never masquerade as row queries. */
 export declare function isReusableSqlCommand(value: unknown): value is ReusableSqlCommand<object>;
-/** @internal Query-bundle provenance is checked by qb.reusable before this bridge. */
+/** Query-bundle provenance is checked by qb.reusable before this bridge. */
 export declare function createReusableSqlQuery<P extends object, Row>(params: {
     query: SqlQuery<Row>;
     scope: SqlInputScope;
 }): ReusableSqlQuery<P, Row>;
-/** @internal Wrap an admitted builder command without capturing an execution owner. */
+/** Wrap an admitted builder command without capturing an execution owner. */
 export declare function createReusableSqlCommand<P extends object>(params: {
     query: SqlCommand;
     scope: SqlInputScope;

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

@@ -40,6 +40,25 @@ type Fields = Readonly<Record<string, ResultDecoder<unknown>>>;
 type Shape<F extends Fields> = {
     [K in keyof F]: Decoded<F[K]>;
 };
+/**
+ * Decode one named column of a result row. A decoder's `VIBE_DATA_INVALID` comes back naming the column in the
+ * message and in `meta` (with the row index and the shape token when the caller has them), never the value; the
+ * decoder's own error is the `cause`. Any other error passes through unchanged.
+ */
+export declare function decodeResultColumn<T>(params: {
+    readonly decoder: ResultReadDecoder<T>;
+    readonly read: {
+        value: unknown;
+        dialect: Dialect;
+        wire?: WireFidelity;
+    };
+    readonly column: string;
+    readonly reason: string;
+    readonly prefix?: string;
+    readonly meta?: Readonly<Record<string, unknown>>;
+    readonly row?: number;
+    readonly token?: string;
+}): T;
 /** Write-only composition; elements are encoded once and SQL owns the final array transport. */
 export declare const encode: {
     readonly array: (params: {
@@ -76,7 +95,8 @@ export declare const decode: {
             decoder: ResultReadDecoder<T>;
         }): ResultReadDecoder<T[]>;
     };
-    readonly enum: <T extends string>(params: {
+    /** Membership in `values`; the members stay literal types where the decoder is written inline (`decode.object({ fields: { kind: decode.enum({ values: ["a", "b"] }) } })` reads `"a" | "b"`). */
+    readonly enum: <const T extends string>(params: {
         values: readonly T[];
     }) => ResultDecoder<T>;
     readonly object: <F extends Fields>(params: {

package/dist/row-rules.d.ts

@@ -1,23 +1,5 @@
-import type { FieldIR, ModelIR, QualifiedSqlName, RowRuleEvent, RowRuleIR, SchemaIR, SqlObjectIdentity } from "@vibeorm/schema";
+import type { ModelIR, RowRuleIR, SchemaIR, SqlObjectIdentity } from "@vibeorm/schema";
 import type { SqlDialect } from "./dialect.ts";
-/** Finalized row-only inputs for the two per-event trigger renderers; not a SQL root export. */
-export type EventRowRuleContext = {
-    readonly model: string;
-    readonly table: QualifiedSqlName;
-    readonly rule: RowRuleIR;
-    readonly triggers: readonly {
-        readonly event: RowRuleEvent;
-        readonly identity: {
-            readonly kind: "trigger";
-            readonly table: QualifiedSqlName;
-            readonly name: string;
-        };
-    }[];
-    readonly protectedFields: readonly FieldIR[];
-    readonly gateField?: FieldIR;
-    /** MySQL only: keep a re-created trigger at its earlier action-order position. */
-    readonly placement?: Readonly<Record<string, RowRuleTriggerPlacement>>;
-};
 /**
  * MySQL `FOLLOWS`/`PRECEDES` position for one rule trigger, keyed by its event
  * trigger name. Disposable references use it to re-create a trigger where it was,

package/dist/sql-bindings.d.ts

@@ -1,8 +1,8 @@
 import type { QualifiedSqlName } from "@vibeorm/schema";
 import type { SqlDialect } from "./dialect.ts";
 import type { ParamCollector } from "./params.ts";
-import type { SqlInputContract, SqlInputScope, SqlParam } from "./sql-input.ts";
-/** @internal Declared SQL transport is separate from execution-time values. */
+import type { SqlInputContract, SqlParam } from "./sql-input.ts";
+/** Declared SQL transport is separate from execution-time values. */
 export type SqlParameterTransport = {
     readonly kind: "plain";
 } | {
@@ -13,7 +13,7 @@ export type SqlParameterTransport = {
     readonly storage: "json" | "jsonb";
     readonly whole: boolean;
 };
-/** @internal A binding reads a captured literal or one named input. */
+/** A binding reads a captured literal or one named input. */
 export type SqlBindingSource = {
     readonly kind: "literal";
     readonly value: unknown;
@@ -21,41 +21,16 @@ export type SqlBindingSource = {
     readonly kind: "input";
     readonly param: SqlParam<unknown>;
 };
-/** @internal Value work reused by ordinary and structural parameter emission. */
+/** Value work reused by ordinary and structural parameter emission. */
 export type SqlBindingEncoder = (params: {
     readonly value: unknown;
     readonly dialect: SqlDialect;
 }) => unknown;
-declare const programBrand: unique symbol;
-/** @internal Binding programs are authentic and never expose their captured values. */
-export type SqlBindingProgram = {
-    readonly [programBrand]: true;
-};
-/** @internal Inspect already captured data only; never invoke an encoder. */
-export declare function sqlParameterTransport(params: {
-    value: unknown;
-}): SqlParameterTransport;
-/** @internal Shared ordinary/reusable placeholder suffixes. */
-export declare function renderSqlParameterTransport(params: {
-    dialect: SqlDialect;
-    placeholder: string;
-    transport: SqlParameterTransport;
-}): string;
-/** @internal Shared marker unwrapping; ordinary admission remains unchanged. */
-export declare function sqlParameterWireValue(params: {
-    value: unknown;
-}): unknown;
-/** @internal Detect structural recording without changing normal collector callers. */
+/** Detect structural recording without changing normal collector callers. */
 export declare function isSqlBindingCollector(params: {
     collector: ParamCollector;
 }): boolean;
-/** @internal Start one compiler pass with no execution values. */
-export declare function startSqlBindingCollection(params: {
-    collector: ParamCollector;
-    dialect: SqlDialect;
-    scope: SqlInputScope;
-}): void;
-/** @internal Register an encoded slot without executing its encoder. */
+/** Register an encoded slot without executing its encoder. */
 export declare function recordSqlBinding(params: {
     collector: ParamCollector;
     source: SqlBindingSource;
@@ -65,20 +40,9 @@ export declare function recordSqlBinding(params: {
     rejectNull?: boolean;
     validate?: (value: unknown) => void;
 }): string;
-/** @internal Retain per-call validation when a fixed NULL frame emits no slot. */
+/** Retain per-call validation when a fixed NULL frame emits no slot. */
 export declare function recordSqlBindingCheck(params: {
     collector: ParamCollector;
     check: () => void;
 }): void;
-/** @internal Seal the rendered program after checking actual emitted input usage. */
-export declare function finishSqlBindingCollection(params: {
-    collector: ParamCollector;
-}): SqlBindingProgram;
-/** @internal Snapshot and bind synchronously; no cache entry retains this call's values. */
-export declare function bindSqlBindingProgram(params: {
-    program: SqlBindingProgram;
-    params?: unknown;
-    isHandle: (value: object) => boolean;
-}): unknown[];
-export {};
 //# sourceMappingURL=sql-bindings.d.ts.map

package/dist/sql-handles.d.ts

@@ -1,7 +1,5 @@
-/** @internal Register a bundle's existing SQL-handle identity check, not object shapes. */
+/** Register a bundle's existing SQL-handle identity check, not object shapes. */
 export declare function registerSqlHandleCheck(params: {
     check: (value: object) => boolean;
 }): void;
-/** @internal Authentic SQL code cannot become parameter data, including nested values. */
-export declare function isSqlHandle(value: object): boolean;
 //# sourceMappingURL=sql-handles.d.ts.map

package/dist/sql-input.d.ts

@@ -29,11 +29,11 @@ export type SqlExecutionParams<P extends object> = keyof P extends never ? {
 } : {
     readonly params: NoInfer<P>;
 };
-/** @internal Opaque lifetime and ownership of a single build callback. */
+/** Opaque lifetime and ownership of a single build callback. */
 export type SqlInputScope = {
     readonly [scopeBrand]: true;
 };
-/** @internal Encoding and physical identity, with no read decoder or client authority. */
+/** Encoding and physical identity, with no read decoder or client authority. */
 export type SqlInputContract = {
     readonly encoder: ResultParameterEncoder;
     readonly scalar: ScalarType | "Enum" | "Unknown";
@@ -47,18 +47,16 @@ export type SqlInputContract = {
 };
 /** Authentic tokens remain recognizable after their build callback closes. */
 export declare function isSqlParam(value: unknown): value is SqlParam<unknown>;
-/** Authentic `qb.input` descriptors are declarations, never execution values. */
-export declare function isSqlInput(value: unknown): value is SqlInput<unknown>;
-/** @internal Snapshot descriptor metadata, never encode a sample value. */
+/** Snapshot descriptor metadata, never encode a sample value. */
 export declare function createSqlInput<T>(params: {
     contract: SqlInputContract;
 }): SqlInput<T>;
-/** @internal Read a descriptor or normalize an explicitly supplied decoder. */
+/** Read a descriptor or normalize an explicitly supplied decoder. */
 export declare function sqlInputContract(params: {
     input: SqlInput<unknown> | ResultDecoder<unknown>;
 }): SqlInputContract;
 /**
- * @internal Create one isolated environment of authentic named tokens. `isHandle` is the
+ * Create one isolated environment of authentic named tokens. `isHandle` is the
  * calling builder bundle's own expression/source authenticity check, applied to execution values.
  */
 export declare function createSqlInputScope<D extends SqlInputMap>(params: {
@@ -68,31 +66,17 @@ export declare function createSqlInputScope<D extends SqlInputMap>(params: {
     readonly scope: SqlInputScope;
     readonly params: SqlInputTokens<D>;
 };
-/** @internal Close admission even when a build callback throws. */
+/** Close admission even when a build callback throws. */
 export declare function sealSqlInputScope(params: {
     scope: SqlInputScope;
 }): void;
-/** @internal Tokens cannot enter new expressions after their build has returned. */
+/** Tokens cannot enter new expressions after their build has returned. */
 export declare function assertSqlParamBuilding(params: {
     param: SqlParam<unknown>;
 }): void;
-/** @internal Read the token's write contract without exposing mutable state. */
+/** Read the token's write contract without exposing mutable state. */
 export declare function sqlParamContract(params: {
     param: SqlParam<unknown>;
 }): SqlInputContract;
-/** @internal Validate ownership when an admitted expression is structurally rendered. */
-export declare function sqlParamKey(params: {
-    param: SqlParam<unknown>;
-    scope: SqlInputScope;
-}): string;
-/** @internal Ask the bundle that created this scope whether a value is one of its handles. */
-export declare function sqlInputScopeHandle(params: {
-    scope: SqlInputScope;
-    value: object;
-}): boolean;
-/** @internal Frozen declaration keys; an open scope cannot be compiled. */
-export declare function sqlInputScopeKeys(params: {
-    scope: SqlInputScope;
-}): readonly string[];
 export {};
 //# sourceMappingURL=sql-input.d.ts.map

package/dist/timestamp-identity.d.ts

@@ -11,15 +11,13 @@ type TimestampIdentity = {
      */
     key: string | undefined;
     readonly kind: "timestamp" | "time" | "timetz" | "sqlite";
+    /**
+     * A parameter the MySQL DateTime codec handed on for the adapter to write in
+     * its zone with every fraction digit ({@link boundTimestampParameter}); a
+     * Date a caller passes is never one.
+     */
+    readonly bound?: true;
 };
-/** Retain transport text while the ordinary Date still represents the decoded value. */
-export declare function rememberTimestampIdentity(params: {
-    date: Date;
-    text: string;
-    numeric?: number;
-    key?: string;
-    kind?: TimestampIdentity["kind"];
-}): Date;
 /** Exact equality key when available; caller-created/mutated Dates keep millisecond semantics. */
 export declare function timestampIdentityKey(params: {
     date: Date;
@@ -29,10 +27,6 @@ export declare function timestampIdentityText(params: {
     date: Date;
     kind?: TimestampIdentity["kind"];
 }): string | undefined;
-/** SQLite legacy integer epochs remain integers rather than being rewritten to ISO text. */
-export declare function sqliteTimestampIdentityValue(params: {
-    date: Date;
-}): string | number | undefined;
 /** Compare retained native identities; SQLite text ordering remains the database's collation. */
 export declare function compareTimestampDates(params: {
     left: Date;

package/dist/timestamp-text.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Char-code decoding of the fixed timestamp text PostgreSQL, MySQL and SQLite
+ * print: `YYYY-MM-DD HH:MM:SS[.f]`, with or without an offset.
+ *
+ * Parsing it by regular expression and `new Date(text)` costs a few hundred
+ * nanoseconds per value; the layout is fixed, so one pass over the character
+ * codes yields the same instant several times cheaper (node-postgres cells,
+ * the `::text` key columns of a keyset page, the join strategy's JSON).
+ *
+ * This function only ACCEPTS or DECLINES: it returns `undefined` for every
+ * text outside the plain form, and the caller then runs its general parser.
+ * An accepted text decodes to exactly the instant that parser returns
+ * (differential tests in adapter-pg `tests/timestamp-text.test.ts` and
+ * `tests/datetime-text-fast-path.test.ts` here).
+ */
+/**
+ * Decode `YYYY-MM-DD HH:MM:SS[.f{1,6}]` as a `Date`: zone-less text is read as
+ * UTC wall-clock time, zoned text at its offset. Fraction digits beyond the
+ * third are truncated.
+ *
+ * `zoned`: `true` requires `±HH` or `±HH:MM` after the time (PostgreSQL's
+ * `timestamptz` text), `false` requires nothing after it (`timestamp`, MySQL
+ * `DATETIME`); `"either"` also takes a `T` between date and time and a `Z`
+ * offset (ISO 8601: the join strategy's JSON, SQLite's stored text).
+ *
+ * Returns `undefined` — "use the general parser" — for anything else: years
+ * before 1000 (`Date.UTC` maps 0–99 to 1900–1999), BC dates, `infinity`,
+ * offsets with seconds (historic local mean time), date-only text, 7+
+ * fraction digits, and out-of-range fields (month 13, February 30, hour 24,
+ * second 60).
+ */
+export declare function parsePlainTimestampText(params: {
+    readonly text: string;
+    readonly zoned: boolean | "either";
+}): Date | undefined;
+//# sourceMappingURL=timestamp-text.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/sql",
-  "version": "5.8.0",
+  "version": "5.10.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.8.0"
+    "@vibeorm/schema": "^5.10.0"
   },
   "publishConfig": {
     "access": "public"