okengine 0.2.6 → 0.3.2

package/src/elements/store/sql-session.ts

@@ -5,9 +5,14 @@
  * Same flow code runs against sqlite, postgres, and memory.
  */
 
+import type { DomainDdlMode } from "../../config/index.ts";
 import type { ClassificationMap, SqlConnection, SqlRow } from "../../drivers/types.ts";
+import { throwOke } from "../../kernel/errors.ts";
 import { maskRows, tableFromSql } from "./classify.ts";
+import { isMissingDomainRelationError } from "./missing-relation.ts";
 import {
+  andWhere,
+  compileOrderBy,
   compileWhere,
   resolveSelectColumns,
   type WhereMap,
@@ -15,6 +20,7 @@ import {
 import {
   mapRowToJs,
   prepareInsertRow,
+  prepareUpdateRow,
   resolveColumns,
   resolveTableName,
   type TableHandle,
@@ -32,31 +38,89 @@ export interface SqlSessionOptions {
   readonly revealPii?: boolean;
   /** Which connection was chosen — exposed for replica proofs. */
   readonly routedRole: "primary" | "replica";
+  /**
+   * Domain DDL policy. `ensure` runs `CREATE TABLE IF NOT EXISTS` on first
+   * touch; `off` means migrations / `oke db push` own the schema (docker/prod
+   * and local+autoPush). Default `ensure` for backward-compatible tests.
+   */
+  readonly domainDdl?: DomainDdlMode;
 }
 
 /**
- * Continuations after `.where(...)` on a select — awaitable, optional `.limit`.
+ * Continuations after `.orderBy(...)` — awaitable, optional `.limit` /
+ * `.offset`.
+ */
+export interface SelectOrderBuilder extends PromiseLike<SqlRow[]> {
+  /**
+   * Cap the number of returned rows.
+   *
+   * @param n - Max rows
+   */
+  limit(n: number): Promise<SqlRow[]>;
+  /**
+   * Skip the first `n` rows (`LIMIT … OFFSET …`).
+   *
+   * @param n - Rows to skip
+   */
+  offset(n: number): Promise<SqlRow[]>;
+}
+
+/**
+ * Continuations after `.where(...)` on a select — awaitable, optional
+ * `.orderBy(...)` / `.limit(...)` / `.offset(...)`.
  */
 export interface SelectWhereBuilder extends PromiseLike<SqlRow[]> {
+  /**
+   * Order rows with Drizzle `asc()` / `desc()` terms.
+   *
+   * @param orders - Order terms
+   */
+  orderBy(...orders: readonly unknown[]): SelectOrderBuilder;
   /**
    * Cap the number of returned rows.
    *
    * @param n - Max rows
    */
   limit(n: number): Promise<SqlRow[]>;
+  /**
+   * Skip the first `n` rows.
+   *
+   * @param n - Rows to skip
+   */
+  offset(n: number): Promise<SqlRow[]>;
 }
 
 /**
- * Result of `.from(table)` — awaitable (all rows) or chain `.where(...)`.
+ * Result of `.from(table)` — awaitable (all rows) or chain
+ * `.where(...)` / `.orderBy(...)` / `.limit(...)` / `.offset(...)` in any
+ * order.
  */
 export interface SelectFromBuilder extends PromiseLike<SqlRow[]> {
   /**
    * Filter with a plain equality map or a Drizzle SQL condition
-   * (`eq`, `and`, `lt`, …).
+   * (`eq`, `and`, `or`, `lt`, `like`, …).
    *
    * @param where - Condition
    */
   where(where: unknown): SelectWhereBuilder;
+  /**
+   * Order rows with Drizzle `asc()` / `desc()` terms.
+   *
+   * @param orders - Order terms
+   */
+  orderBy(...orders: readonly unknown[]): SelectOrderBuilder;
+  /**
+   * Cap the number of returned rows.
+   *
+   * @param n - Max rows
+   */
+  limit(n: number): Promise<SqlRow[]>;
+  /**
+   * Skip the first `n` rows.
+   *
+   * @param n - Rows to skip
+   */
+  offset(n: number): Promise<SqlRow[]>;
 }
 
 /** Fluent select builder. */
@@ -172,10 +236,7 @@ export interface SqlStoreHandle {
    * @param table - Table
    * @param idOrWhere - Primary key string, or column equality map
    */
-  exists(
-    table: TableHandle | unknown,
-    idOrWhere: string | WhereMap,
-  ): Promise<boolean>;
+  exists(table: TableHandle | unknown, idOrWhere: string | WhereMap): Promise<boolean>;
   /**
    * Atomically add `by` to `column` on the PK row.
    *
@@ -184,12 +245,7 @@ export interface SqlStoreHandle {
    * @param column - Numeric column to bump
    * @param by - Delta (default `1`)
    */
-  increment(
-    table: TableHandle | unknown,
-    id: string,
-    column: string,
-    by?: number,
-  ): Promise<number>;
+  increment(table: TableHandle | unknown, id: string, column: string, by?: number): Promise<number>;
   /**
    * Raw SQL — PII masking still applied at the boundary.
    *
@@ -197,6 +253,21 @@ export interface SqlStoreHandle {
    * @param params - Bound parameters
    */
   raw(sql: string, params?: readonly unknown[]): Promise<SqlRow[]>;
+  /**
+   * Count rows (`COUNT(*)`), optionally filtered.
+   *
+   * @param table - Table
+   * @param where - Optional condition
+   */
+  count(table: TableHandle | unknown, where?: unknown): Promise<number>;
+  /**
+   * One page of rows — offset or keyset mode, composed through the same
+   * fluent select path (Drizzle conditions in, `compileWhere` out).
+   *
+   * @param table - Table
+   * @param options - Page options
+   */
+  page(table: TableHandle | unknown, options: SqlPageOptions): Promise<SqlRow[]>;
   /**
    * Ensure a simple table exists (test / bootstrap helper).
    *
@@ -205,6 +276,24 @@ export interface SqlStoreHandle {
   ensureTable(table: TableHandle): Promise<void>;
 }
 
+/** Options for {@link SqlStoreHandle.page}. */
+export interface SqlPageOptions {
+  /** Filter condition (equality map or Drizzle SQL). */
+  readonly where?: unknown;
+  /** Drizzle `asc()` / `desc()` terms (or bare columns). */
+  readonly orderBy?: readonly unknown[];
+  /** Max rows to return. */
+  readonly limit?: number;
+  /** Offset mode — skip rows (uses `OFFSET`). */
+  readonly offset?: number;
+  /**
+   * Keyset mode — a Drizzle SQL condition describing "rows strictly after
+   * the cursor" (composed by the caller / `store.resource`); ANDed onto
+   * `where`. Cannot combine with `offset`.
+   */
+  readonly after?: unknown;
+}
+
 /**
  * Create a SQL store handle over a connection.
  *
@@ -216,38 +305,55 @@ export function createSqlStoreHandle(
   options: SqlSessionOptions,
 ): SqlStoreHandle {
   const { connection, classifications, revealPii } = options;
+  const domainDdl: DomainDdlMode = options.domainDdl ?? "ensure";
 
   function mask(rows: SqlRow[], table?: string): SqlRow[] {
     return maskRows(rows, { classifications, table, revealPii });
   }
 
+  /**
+   * Run a connection op; remap missing-relation driver errors to OKE1101
+   * when domain auto-DDL is off.
+   */
+  async function withSchemaGuard<T>(fn: () => Promise<T>): Promise<T> {
+    try {
+      return await fn();
+    } catch (err) {
+      if (domainDdl === "off" && isMissingDomainRelationError(err)) {
+        throwOke("DOMAIN_SCHEMA_MISSING");
+      }
+      throw err;
+    }
+  }
+
+  function query(sql: string, params: readonly unknown[] = []): Promise<SqlRow[]> {
+    return withSchemaGuard(() => connection.query(sql, params));
+  }
+
+  function exec(sql: string, params: readonly unknown[] = []): Promise<{ changes: number }> {
+    return withSchemaGuard(() => connection.exec(sql, params));
+  }
+
   async function ensureFromMeta(table: TableHandle | unknown): Promise<void> {
+    if (domainDdl !== "ensure") return;
     const cols = resolveColumns(table);
     if (cols.length === 0) return;
     const name = resolveTableName(table);
     const pk = cols.find((c) => c.primary)?.sqlName;
     const colSql = cols
       .map((c) => {
-        const typ =
-          pk && c.sqlName === pk
-            ? `${c.sqlType} PRIMARY KEY`
-            : c.sqlType;
+        const typ = pk && c.sqlName === pk ? `${c.sqlType} PRIMARY KEY` : c.sqlType;
         return `${quoteIdent(c.sqlName)} ${typ}`;
       })
       .join(", ");
-    await connection.exec(
-      `CREATE TABLE IF NOT EXISTS ${quoteIdent(name)} (${colSql})`,
-    );
+    await exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(name)} (${colSql})`);
   }
 
   function toJs(table: TableHandle | unknown, rows: SqlRow[]): SqlRow[] {
     return rows.map((r) => mapRowToJs(table, r) as SqlRow);
   }
 
-  function normalizeWhereMap(
-    table: TableHandle | unknown,
-    where: WhereMap,
-  ): WhereMap {
+  function normalizeWhereMap(table: TableHandle | unknown, where: WhereMap): WhereMap {
     const cols = resolveColumns(table);
     if (cols.length === 0) return where;
     const out: Record<string, unknown> = {};
@@ -273,11 +379,18 @@ export function createSqlStoreHandle(
     return compileWhere(where);
   }
 
+  /** Accumulated select state across the fluent chain. */
+  interface SelectPlan {
+    readonly where?: unknown;
+    readonly orders?: readonly unknown[];
+    readonly limit?: number;
+    readonly offset?: number;
+  }
+
   async function runSelect(
     table: TableHandle | unknown,
     projection: ReturnType<typeof resolveSelectColumns>,
-    where: unknown | undefined,
-    limit?: number,
+    plan: SelectPlan = {},
   ): Promise<SqlRow[]> {
     await ensureFromMeta(table);
     const name = resolveTableName(table);
@@ -294,20 +407,31 @@ export function createSqlStoreHandle(
 
     let sql = `SELECT ${selectList} FROM ${quoteIdent(name)}`;
     const params: unknown[] = [];
-    if (where !== undefined) {
-      const compiled = compileTableWhere(table, where);
+    if (plan.where !== undefined) {
+      const compiled = compileTableWhere(table, plan.where);
       if (compiled.clause) {
         sql += ` WHERE ${compiled.clause}`;
         params.push(...compiled.params);
       }
     }
-    if (limit !== undefined) {
-      sql += ` LIMIT ${Math.max(0, Math.floor(limit))}`;
+    if (plan.orders !== undefined && plan.orders.length > 0) {
+      const terms = compileOrderBy(plan.orders);
+      sql += ` ORDER BY ${terms.map((o) => `${quoteIdent(o.column)} ${o.direction}`).join(", ")}`;
+    }
+    if (plan.limit !== undefined) {
+      sql += ` LIMIT ${Math.max(0, Math.floor(plan.limit))}`;
+    }
+    if (plan.offset !== undefined) {
+      sql += ` OFFSET ${Math.max(0, Math.floor(plan.offset))}`;
     }
 
-    const rows = await connection.query(sql, params);
+    const rows = await query(sql, params);
+    // Map to declared JS keys first, then mask — classifications are keyed by
+    // TS field names (`email`), so masking before remapping would miss a
+    // `.pii()` column whose SQL name differs (`email_addr`) and leak cleartext
+    // under the final client-facing key.
     if (projection === null) {
-      return toJs(table, mask(rows, name));
+      return mask(toJs(table, rows), name);
     }
     // Projected aliases are already the returned keys.
     return mask(
@@ -322,26 +446,39 @@ export function createSqlStoreHandle(
     );
   }
 
-  function selectFrom(
-    table: TableHandle | unknown,
-    columns?: unknown,
-  ): SelectFromBuilder {
+  function selectFrom(table: TableHandle | unknown, columns?: unknown): SelectFromBuilder {
     const projection = resolveSelectColumns(columns);
-    const all = runSelect(table, projection, undefined);
+
+    // Builders are lazy: the query runs on the first await / `.limit(n)` /
+    // `.offset(n)`, so a chained `where → orderBy → limit` issues one SELECT.
+    function tail(plan: SelectPlan): SelectOrderBuilder {
+      return {
+        limit(n) {
+          return runSelect(table, projection, { ...plan, limit: n });
+        },
+        offset(n) {
+          return runSelect(table, projection, { ...plan, offset: n });
+        },
+        then(onfulfilled, onrejected) {
+          return runSelect(table, projection, plan).then(onfulfilled, onrejected);
+        },
+      };
+    }
+
+    function filtered(where: unknown): SelectWhereBuilder {
+      const plan: SelectPlan = where === undefined ? {} : { where };
+      return {
+        ...tail(plan),
+        orderBy(...orders) {
+          return tail({ ...plan, orders });
+        },
+      };
+    }
+
     return {
+      ...filtered(undefined),
       where(where) {
-        const filtered = runSelect(table, projection, where);
-        return {
-          limit(n) {
-            return runSelect(table, projection, where, n);
-          },
-          then(onfulfilled, onrejected) {
-            return filtered.then(onfulfilled, onrejected);
-          },
-        };
-      },
-      then(onfulfilled, onrejected) {
-        return all.then(onfulfilled, onrejected);
+        return filtered(where);
       },
     };
   }
@@ -371,7 +508,7 @@ export function createSqlStoreHandle(
             const colList = cols.map(quoteIdent).join(", ");
             const params = cols.map((c) => prepared[c]);
             const sql = `INSERT INTO ${quoteIdent(name)} (${colList}) VALUES (${placeholders})`;
-            await connection.exec(sql, params);
+            await exec(sql, params);
           };
           return {
             async returning() {
@@ -382,8 +519,8 @@ export function createSqlStoreHandle(
               const colList = cols.map(quoteIdent).join(", ");
               const params = cols.map((c) => prepared[c]);
               const sql = `INSERT INTO ${quoteIdent(name)} (${colList}) VALUES (${placeholders}) RETURNING *`;
-              const rows = await connection.query(sql, params);
-              return toJs(table, mask(rows, name));
+              const rows = await query(sql, params);
+              return mask(toJs(table, rows), name);
             },
             execute: runExecute,
             then(onfulfilled, onrejected) {
@@ -401,21 +538,16 @@ export function createSqlStoreHandle(
           return {
             async where(where) {
               await ensureFromMeta(table);
-              const prepared = prepareInsertRow(table, row);
+              const prepared = prepareUpdateRow(table, row);
               const setEntries = Object.entries(prepared);
               if (setEntries.length === 0) return 0;
-              const setSql = setEntries
-                .map(([col]) => `${quoteIdent(col)} = ?`)
-                .join(", ");
+              const setSql = setEntries.map(([col]) => `${quoteIdent(col)} = ?`).join(", ");
               const compiled = compileTableWhere(table, where);
               if (!compiled.clause) {
                 throw new Error("update().set().where(): condition required");
               }
-              const params = [
-                ...setEntries.map(([, v]) => v),
-                ...compiled.params,
-              ];
-              const result = await connection.exec(
+              const params = [...setEntries.map(([, v]) => v), ...compiled.params];
+              const result = await exec(
                 `UPDATE ${quoteIdent(name)} SET ${setSql} WHERE ${compiled.clause}`,
                 params,
               );
@@ -430,27 +562,22 @@ export function createSqlStoreHandle(
       await ensureFromMeta(table);
       const name = resolveTableName(table);
       const pk = resolvePkColumn(table);
-      const rows = await connection.query(
-        `SELECT * FROM ${quoteIdent(name)} WHERE ${quoteIdent(pk)} = ?`,
-        [idValue],
-      );
-      const masked = toJs(table, mask(rows, name));
+      const rows = await query(`SELECT * FROM ${quoteIdent(name)} WHERE ${quoteIdent(pk)} = ?`, [
+        idValue,
+      ]);
+      const masked = mask(toJs(table, rows), name);
       return masked[0] ?? null;
     },
 
-    delete: ((
-      table: TableHandle | unknown,
-      idValue?: string,
-    ): DeleteBuilder | Promise<boolean> => {
+    delete: ((table: TableHandle | unknown, idValue?: string): DeleteBuilder | Promise<boolean> => {
       if (idValue !== undefined) {
         return (async () => {
           await ensureFromMeta(table);
           const name = resolveTableName(table);
           const pk = resolvePkColumn(table);
-          const result = await connection.exec(
-            `DELETE FROM ${quoteIdent(name)} WHERE ${quoteIdent(pk)} = ?`,
-            [idValue],
-          );
+          const result = await exec(`DELETE FROM ${quoteIdent(name)} WHERE ${quoteIdent(pk)} = ?`, [
+            idValue,
+          ]);
           return result.changes > 0;
         })();
       }
@@ -462,7 +589,7 @@ export function createSqlStoreHandle(
           if (!compiled.clause) {
             throw new Error("delete().where(): condition required");
           }
-          const result = await connection.exec(
+          const result = await exec(
             `DELETE FROM ${quoteIdent(name)} WHERE ${compiled.clause}`,
             compiled.params,
           );
@@ -483,7 +610,7 @@ export function createSqlStoreHandle(
       if (!compiled.clause) {
         throw new Error("exists() requires at least one where predicate");
       }
-      const rows = await connection.query(
+      const rows = await query(
         `SELECT 1 AS "ok" FROM ${quoteIdent(name)} WHERE ${compiled.clause} LIMIT 1`,
         compiled.params,
       );
@@ -498,25 +625,57 @@ export function createSqlStoreHandle(
       const colMeta = cols.find((c) => c.key === column || c.sqlName === column);
       const sqlCol = colMeta?.sqlName ?? column;
       const col = quoteIdent(sqlCol);
-      const rows = await connection.query(
+      const rows = await query(
         `UPDATE ${quoteIdent(name)} SET ${col} = ${col} + ? WHERE ${quoteIdent(pk)} = ? RETURNING ${col}`,
         [by, idValue],
       );
       const row = rows[0];
       if (!row) {
-        throw new Error(
-          `increment(): no row with ${pk} ${JSON.stringify(idValue)} in ${name}`,
-        );
+        throw new Error(`increment(): no row with ${pk} ${JSON.stringify(idValue)} in ${name}`);
       }
       return asNumber(row[sqlCol], sqlCol);
     },
 
     async raw(sql, params = []) {
       const table = tableFromSql(sql);
-      const rows = await connection.query(sql, params);
+      const rows = await query(sql, params);
       return mask(rows, table);
     },
 
+    async count(table, where) {
+      await ensureFromMeta(table);
+      const name = resolveTableName(table);
+      let sql = `SELECT COUNT(*) AS "count" FROM ${quoteIdent(name)}`;
+      const params: unknown[] = [];
+      if (where !== undefined) {
+        const compiled = compileTableWhere(table, where);
+        if (compiled.clause) {
+          sql += ` WHERE ${compiled.clause}`;
+          params.push(...compiled.params);
+        }
+      }
+      const rows = await query(sql, params);
+      return asNumber(rows[0]?.count ?? rows[0]?.COUNT ?? 0, "count");
+    },
+
+    async page(table, options) {
+      if (options.offset !== undefined && options.after !== undefined) {
+        throw new Error("page(): offset and after (keyset) cannot combine");
+      }
+      const where =
+        options.after === undefined
+          ? options.where
+          : options.where === undefined
+            ? options.after
+            : andWhere(options.where, options.after);
+      return runSelect(table, null, {
+        where,
+        orders: options.orderBy,
+        limit: options.limit,
+        offset: options.offset,
+      });
+    },
+
     async ensureTable(table) {
       const cols = Object.values(table.columns);
       const pk = resolvePkColumn(table);
@@ -534,9 +693,7 @@ export function createSqlStoreHandle(
           return `${quoteIdent(c.name)} ${typ}`;
         })
         .join(", ");
-      await connection.exec(
-        `CREATE TABLE IF NOT EXISTS ${quoteIdent(table.name)} (${colSql})`,
-      );
+      await exec(`CREATE TABLE IF NOT EXISTS ${quoteIdent(table.name)} (${colSql})`);
     },
   };
 

package/src/elements/store/table.ts

@@ -31,9 +31,7 @@ export interface TableHandle {
  */
 export function defineTable(
   name: string,
-  columns: Readonly<
-    Record<string, ColumnDef | ColumnClassification | true | undefined>
-  >,
+  columns: Readonly<Record<string, ColumnDef | ColumnClassification | true | undefined>>,
 ): TableHandle {
   const resolved: Record<string, ColumnDef> = {};
   for (const [key, value] of Object.entries(columns)) {
@@ -120,14 +118,38 @@ export function resolveColumns(table: unknown): ResolvedColumn[] {
   if (table && typeof table === "object") {
     const t = table as Record<string, unknown>;
     if ("columns" in t && t.columns && typeof t.columns === "object") {
-      return Object.entries(t.columns as Record<string, ColumnDef>).map(
-        ([key, col]) => ({
+      return Object.entries(
+        t.columns as Record<
+          string,
+          ColumnDef & {
+            sqlName?: string;
+            sqlType?: string;
+            primaryKey?: boolean;
+            defaultFn?: () => unknown;
+          }
+        >,
+      ).map(([key, col]) => {
+        const sqlName = col.sqlName ?? col.name;
+        const primary =
+          typeof col.primaryKey === "boolean"
+            ? col.primaryKey
+            : col.name === "id" || key === "id" || sqlName === "id";
+        const sqlType =
+          col.sqlType === "integer" || col.sqlType === "INTEGER"
+            ? ("INTEGER" as const)
+            : col.sqlType === "real" || col.sqlType === "REAL"
+              ? ("REAL" as const)
+              : col.sqlType === "blob" || col.sqlType === "BLOB"
+                ? ("BLOB" as const)
+                : ("TEXT" as const);
+        return {
           key,
-          sqlName: col.name,
-          primary: col.name === "id" || key === "id",
-          sqlType: "TEXT" as const,
-        }),
-      );
+          sqlName,
+          primary,
+          sqlType,
+          ...(typeof col.defaultFn === "function" ? { defaultFn: col.defaultFn } : {}),
+        };
+      });
     }
     if (isDrizzleTable(t)) {
       return drizzleColumns(t);
@@ -168,18 +190,14 @@ function drizzleColumns(t: Record<string, unknown>): ResolvedColumn[] {
       config?: { primaryKey?: boolean };
     };
     const sqlName = typeof col.name === "string" ? col.name : key;
-    const primary = Boolean(
-      col.primary || col.config?.primaryKey || sqlName === "id",
-    );
+    const primary = Boolean(col.primary || col.config?.primaryKey || sqlName === "id");
     const sqlType = drizzleSqlType(col.columnType, col.dataType);
     out.push({
       key,
       sqlName,
       primary,
       sqlType,
-      ...(typeof col.defaultFn === "function"
-        ? { defaultFn: col.defaultFn.bind(col) }
-        : {}),
+      ...(typeof col.defaultFn === "function" ? { defaultFn: col.defaultFn.bind(col) } : {}),
     });
   }
   return out;
@@ -234,10 +252,39 @@ export function prepareInsertRow(
 }
 
 /**
- * Map a SQL-keyed row back to JS keys when Drizzle/TableHandle metadata exists.
+ * Map a JS-keyed partial row to SQL column names for `UPDATE … SET`.
+ * Unlike {@link prepareInsertRow}, `$defaultFn`s are never applied — column
+ * defaults are insert physics, not update physics.
  *
  * @param table - Table-like value
- * @param row - Driver row
+ * @param row - Incoming values (JS keys)
+ */
+export function prepareUpdateRow(
+  table: unknown,
+  row: Readonly<Record<string, unknown>>,
+): Record<string, unknown> {
+  const cols = resolveColumns(table);
+  if (cols.length === 0) return { ...row };
+  const byKey = new Map(cols.map((c) => [c.key, c]));
+  const bySql = new Map(cols.map((c) => [c.sqlName, c]));
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(row)) {
+    const col = byKey.get(k) ?? bySql.get(k);
+    out[col?.sqlName ?? k] = v;
+  }
+  return out;
+}
+
+/**
+ * Map a SQL-keyed driver row to declared JS field names only.
+ *
+ * When Drizzle/TableHandle metadata exists, the result contains exactly the
+ * table's declared keys (`createdAt`) — never the raw SQL names
+ * (`created_at`) alongside or instead of them. Without metadata, the row is
+ * returned as-is (opaque / raw SQL).
+ *
+ * @param table - Table-like value
+ * @param row - Driver row (SQL column names, or already JS-keyed)
  */
 export function mapRowToJs(
   table: unknown,
@@ -245,9 +292,10 @@ export function mapRowToJs(
 ): Record<string, unknown> {
   const cols = resolveColumns(table);
   if (cols.length === 0) return { ...row };
-  const out: Record<string, unknown> = { ...row };
+  const out: Record<string, unknown> = {};
   for (const col of cols) {
-    if (col.sqlName in row) out[col.key] = row[col.sqlName];
+    if (col.key in row) out[col.key] = row[col.key];
+    else if (col.sqlName in row) out[col.key] = row[col.sqlName];
   }
   return out;
 }
@@ -257,9 +305,7 @@ export function mapRowToJs(
  *
  * @param table - Table handle
  */
-export function classificationsFromTable(
-  table: TableHandle,
-): Record<string, ColumnClassification> {
+export function classificationsFromTable(table: TableHandle): Record<string, ColumnClassification> {
   const out: Record<string, ColumnClassification> = {};
   for (const [key, col] of Object.entries(table.columns)) {
     if (col.classification) out[key] = col.classification;