turbine-orm 0.91.0 → 0.92.0

package/dist/query/utils.js

@@ -824,6 +824,13 @@ function renderTemporal(value, kind) {
  * or a `±HH`, `±HHMM`, `±HH:MM` offset.
  */
 const TZ_SUFFIX_RE = /(?:Z|[+-]\d{2}(?::?\d{2})?)$/;
+const COLON_CHAR = 58;
+const PLUS_CHAR = 43;
+const MINUS_CHAR = 45;
+/** `0`-`9` as a char code. */
+function isDigitCode(code) {
+    return code >= 48 && code <= 57;
+}
 /**
  * Parse a database date-time string deterministically.
  *
@@ -846,6 +853,29 @@ export function parseDbDate(value) {
     return Number.isNaN(date.getTime()) ? (parseDbDateGeneral(value) ?? date) : date;
 }
 function parseDbDateCommon(value) {
+    // Fast path for the shape `timestamptz` arrives in, a trailing `±HH:MM`
+    // offset (`2026-07-07T17:15:41.896+00:00`). It is exactly the general path's
+    // answer for that shape, not an approximation of it: the string contains a
+    // ':' (at length-3), TZ_SUFFIX_RE matches, and neither normalizing replace
+    // below can fire (the first needs four digits after the sign, the second two
+    // digits at the very end after it), so that path also ends in
+    // `new Date(value)`. All six offset characters are checked, so a near miss
+    // (`+0a:00`, `05:30` without a sign) still takes the general path. It skips
+    // one regex test and two regex replaces per value, which on a nested read is
+    // the single largest cost in the decode. The invalid-date fallback in
+    // parseDbDate still runs on the result, so a BC or five-digit year is
+    // unchanged.
+    const n = value.length;
+    if (n >= 6 && value.charCodeAt(n - 3) === COLON_CHAR) {
+        const sign = value.charCodeAt(n - 6);
+        if ((sign === PLUS_CHAR || sign === MINUS_CHAR) &&
+            isDigitCode(value.charCodeAt(n - 5)) &&
+            isDigitCode(value.charCodeAt(n - 4)) &&
+            isDigitCode(value.charCodeAt(n - 2)) &&
+            isDigitCode(value.charCodeAt(n - 1))) {
+            return new Date(value);
+        }
+    }
     // Date-only values (`2026-07-07`, from `date` columns in json_agg output)
     // have no time to zone-pin, and their `-07` tail must not be read as an
     // offset. JS parses bare ISO dates as UTC midnight already.
@@ -885,6 +915,19 @@ function parseDbDateGeneral(value) {
     }
     return date;
 }
+/**
+ * Per-cell decode work in a row decode plan (`RowDecodePlan` in builder.ts).
+ * Defined here rather than in builder.ts because the positional nested-row
+ * plan in relations.ts reads the same codes, and relations.ts cannot import
+ * builder.ts.
+ */
+export const CELL_PLAIN = 0;
+export const CELL_TEMPORAL = 1;
+export const CELL_FLOAT = 2;
+export const CELL_FLOAT_ARRAY = 3;
+export const CELL_TEXT_ARRAY = 4;
+/** The dialect's own decode for a type whose storage differs (see `Dialect.decodeColumnValue`). */
+export const CELL_DIALECT = 5;
 /**
  * A float column's value as the driver reads it. JSON has no NaN or infinity,
  * so `json_build_object` renders them as the strings "NaN", "Infinity" and

package/dist/query/where.d.ts

@@ -133,6 +133,21 @@ export interface BuilderCtx {
     toColumn(field: string): string;
     castAgg(expr: string, target: 'int' | 'float'): string;
     parseRow(row: Record<string, unknown>, table: string): Record<string, unknown>;
+    /**
+     * The field name and cell kind {@link parseRow} applies to each key of a row
+     * whose keys are exactly `keys`, in order (`undefined` for a table with no
+     * metadata). Read once per relation shape by the positional nested-row plan
+     * in relations.ts, so a nested row decodes by the same answers `parseRow`
+     * would give. Optional, like the members above, so a hand-built ctx keeps
+     * compiling; without it (or {@link decodeCell}) the nested parser takes the
+     * general path.
+     */
+    rowDecodePlan?(table: string, keys: readonly string[]): {
+        readonly fields: readonly string[];
+        readonly kinds: readonly number[];
+    } | undefined;
+    /** {@link parseRow}'s decode of one cell whose kind is not `CELL_PLAIN` (see utils.ts). */
+    decodeCell?(kind: number, value: unknown, table: string, field: string): unknown;
     nullsSuffix(nulls: 'first' | 'last' | undefined): string;
     isRelationOrderByValue(value: unknown): boolean;
     resolveOrderByColumn(table: string, meta: TableMetadata, key: string): string;

package/dist/schema-builder.d.ts

@@ -73,8 +73,10 @@ export interface ColumnDef {
      * code-first declaration: it carries onto {@link ColumnConfig.pii} and, via
      * `schemaDefToMetadata` / codegen, onto
      * {@link import('./schema.js').ColumnMetadata.pii}. A PII column is excluded
-     * from default projections (read back only via an explicit `select` or
-     * `includePii: UNSAFE`, the imported sentinel symbol) and redacted by Studio.
+     * from default projections and comes back only from a read that passes
+     * `includePii: UNSAFE` (the imported sentinel symbol). Naming it in `select`
+     * without that flag throws (E003), a write never returns it, and Studio
+     * redacts it.
      * Introspection never auto-tags PII.
      */
     pii?: boolean;
@@ -248,9 +250,10 @@ export interface TableDef {
     checks?: readonly CheckDef[];
     /**
      * Index declarations for this table (plain column indexes and/or PowDB
-     * doc-field expression indexes). Consumed by the PowDB DDL generator
-     * (`powqlSchemaDDL`) and carried onto `IndexMetadata` by
-     * `schemaDefToMetadata`; the SQL DDL generators do not consume them yet.
+     * doc-field expression indexes). Plain column indexes are emitted as `CREATE [UNIQUE] INDEX` by
+     * `schemaToSQL` and added by `schemaDiff`; doc-field indexes are PowDB-only
+     * (`powqlSchemaDDL`). Both are carried onto `IndexMetadata` by
+     * `schemaDefToMetadata`.
      */
     indexes?: readonly SchemaIndexDef[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.91.0",
+  "version": "0.92.0",
   "description": "Postgres-native TypeScript ORM, runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "//exports": "Each subpath declares its types PER CONDITION. A single shared top-level \"types\" resolves to the ESM declarations for `require` too, which is TS1479 (\"is an ES module ... cannot be require()d\") for any CJS consumer on moduleResolution node16/nodenext. The require condition points at dist/cjs, which ships its own {\"type\":\"commonjs\"} package.json, so those declarations are CJS declarations. Gated in CI by publint + @arethetypeswrong/cli + a real .cts consumer typecheck (see the package-types job in ci.yml).",