@nextlyhq/adapter-drizzle 0.0.2-alpha.50 → 0.0.2-alpha.52

package/dist/{adapter-C-DmzBg8.d.ts → adapter-BRcXAStD.d.ts}

@@ -197,6 +197,93 @@ declare abstract class DrizzleAdapter {
      * no change.
      */
     protected mapRowKeysToJs<T = unknown>(tableObj: unknown, row: T): T;
+    /**
+     * Decode a raw-SQL result row's DATE column values the way a Drizzle query
+     * would, so a write answers with the same representation a read of the same
+     * column gives.
+     *
+     * A Drizzle query path runs every value through its column definition; a
+     * raw-SQL path does not, so a dialect that stores a timestamp as a number
+     * answers a write with that number while every read answers a `Date`. Only
+     * date columns are touched, and a value that is already a `Date` is left
+     * alone, so a driver that decodes on its own is unaffected.
+     *
+     * Runs after {@link mapRowKeysToJs}: keys are Drizzle property names by then,
+     * which is what the table definition is keyed by.
+     */
+    protected mapDateValuesFromDriver<T = unknown>(tableObj: unknown, row: T): T;
+    /**
+     * Encode a row's DATE values the way a Drizzle query would before binding
+     * them, so what lands in the column does not depend on the server's timezone.
+     *
+     * A column declared without a time zone stores a wall clock and records
+     * nothing about which zone it belongs to, so both ends have to agree. Drizzle
+     * writes UTC and reads UTC. A driver handed a `Date` writes the LOCAL wall
+     * clock instead, and the same row then reads back shifted by the offset --
+     * on a UTC server the two agree and nothing is visibly wrong, which is why
+     * this survives CI.
+     *
+     * Only date columns are touched. A value that is not a `Date` is left as it
+     * is, so a caller that already encoded one is not encoded twice.
+     *
+     * Keys may be spelled either way at this point, so both the Drizzle property
+     * name and the SQL column name resolve.
+     */
+    protected mapDateValuesToDriver(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Bring a row about to be written through a raw-SQL statement into the shape
+     * a Drizzle query would have bound: SQL column names for keys, encoded values
+     * for date columns.
+     *
+     * The mirror of {@link mapRowFromRawSql}. The raw-SQL write paths exist
+     * because a dialect needs SQL a Drizzle query cannot express, not because
+     * their callers want different values in the table.
+     */
+    protected mapRowToRawSql(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Bring a raw-SQL result row into the shape a Drizzle query would have
+     * produced: Drizzle property names for keys, decoded values for date columns.
+     *
+     * The raw-SQL write paths exist because a dialect needs SQL a Drizzle query
+     * cannot express, not because their callers want a different row shape, so
+     * every one of them ends here.
+     */
+    protected mapRowFromRawSql<T = unknown>(tableObj: unknown, row: T, aliases?: ReadonlyArray<{
+        alias: string;
+        jsName: string;
+    }>): T;
+    /**
+     * The date columns a statement is about to return, and the alias each one's
+     * wall clock is spelled out under.
+     *
+     * A driver turns a timestamp into a `Date` using ITS zone before any of this
+     * code runs, and that conversion is lossy: a wall clock inside a
+     * daylight-saving gap is a local time that does not exist, so the driver
+     * normalizes it and the original is gone. Asking the database for the wall
+     * clock as text alongside the row is the only way to read it exactly.
+     *
+     * `"*"` covers every date column; a projection covers only the ones it asked
+     * for, so a caller still gets back what it requested and nothing more.
+     */
+    protected dateWallClockAliases(tableObj: unknown, returning: string[] | "*" | undefined): Array<{
+        sqlName: string;
+        alias: string;
+        jsName: string;
+    }>;
+    /**
+     * Replace each date in a row with the wall clock the database spelled out,
+     * read as UTC, and drop the aliases that carried it.
+     *
+     * The statement writes a UTC wall clock, so reading one back as UTC is what
+     * makes a write and a later read agree. Whatever the column actually stored
+     * is what arrives -- a column keeping only whole seconds reports whole
+     * seconds -- because this is the database's own text, not a value
+     * reconstructed from the one that was bound.
+     */
+    protected applyWallClockAliases<T>(row: T, aliases: ReadonlyArray<{
+        alias: string;
+        jsName: string;
+    }>): T;
     /**
      * Build a Drizzle column projection object (`{ propertyName: column }`) from a
      * requested column list, used by `select` (columns) and `insert` (returning).

package/dist/{adapter-CZUQ2aV4.d.cts → adapter-DVoa72DA.d.cts}

@@ -197,6 +197,93 @@ declare abstract class DrizzleAdapter {
      * no change.
      */
     protected mapRowKeysToJs<T = unknown>(tableObj: unknown, row: T): T;
+    /**
+     * Decode a raw-SQL result row's DATE column values the way a Drizzle query
+     * would, so a write answers with the same representation a read of the same
+     * column gives.
+     *
+     * A Drizzle query path runs every value through its column definition; a
+     * raw-SQL path does not, so a dialect that stores a timestamp as a number
+     * answers a write with that number while every read answers a `Date`. Only
+     * date columns are touched, and a value that is already a `Date` is left
+     * alone, so a driver that decodes on its own is unaffected.
+     *
+     * Runs after {@link mapRowKeysToJs}: keys are Drizzle property names by then,
+     * which is what the table definition is keyed by.
+     */
+    protected mapDateValuesFromDriver<T = unknown>(tableObj: unknown, row: T): T;
+    /**
+     * Encode a row's DATE values the way a Drizzle query would before binding
+     * them, so what lands in the column does not depend on the server's timezone.
+     *
+     * A column declared without a time zone stores a wall clock and records
+     * nothing about which zone it belongs to, so both ends have to agree. Drizzle
+     * writes UTC and reads UTC. A driver handed a `Date` writes the LOCAL wall
+     * clock instead, and the same row then reads back shifted by the offset --
+     * on a UTC server the two agree and nothing is visibly wrong, which is why
+     * this survives CI.
+     *
+     * Only date columns are touched. A value that is not a `Date` is left as it
+     * is, so a caller that already encoded one is not encoded twice.
+     *
+     * Keys may be spelled either way at this point, so both the Drizzle property
+     * name and the SQL column name resolve.
+     */
+    protected mapDateValuesToDriver(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Bring a row about to be written through a raw-SQL statement into the shape
+     * a Drizzle query would have bound: SQL column names for keys, encoded values
+     * for date columns.
+     *
+     * The mirror of {@link mapRowFromRawSql}. The raw-SQL write paths exist
+     * because a dialect needs SQL a Drizzle query cannot express, not because
+     * their callers want different values in the table.
+     */
+    protected mapRowToRawSql(tableObj: unknown, data: Record<string, unknown>): Record<string, unknown>;
+    /**
+     * Bring a raw-SQL result row into the shape a Drizzle query would have
+     * produced: Drizzle property names for keys, decoded values for date columns.
+     *
+     * The raw-SQL write paths exist because a dialect needs SQL a Drizzle query
+     * cannot express, not because their callers want a different row shape, so
+     * every one of them ends here.
+     */
+    protected mapRowFromRawSql<T = unknown>(tableObj: unknown, row: T, aliases?: ReadonlyArray<{
+        alias: string;
+        jsName: string;
+    }>): T;
+    /**
+     * The date columns a statement is about to return, and the alias each one's
+     * wall clock is spelled out under.
+     *
+     * A driver turns a timestamp into a `Date` using ITS zone before any of this
+     * code runs, and that conversion is lossy: a wall clock inside a
+     * daylight-saving gap is a local time that does not exist, so the driver
+     * normalizes it and the original is gone. Asking the database for the wall
+     * clock as text alongside the row is the only way to read it exactly.
+     *
+     * `"*"` covers every date column; a projection covers only the ones it asked
+     * for, so a caller still gets back what it requested and nothing more.
+     */
+    protected dateWallClockAliases(tableObj: unknown, returning: string[] | "*" | undefined): Array<{
+        sqlName: string;
+        alias: string;
+        jsName: string;
+    }>;
+    /**
+     * Replace each date in a row with the wall clock the database spelled out,
+     * read as UTC, and drop the aliases that carried it.
+     *
+     * The statement writes a UTC wall clock, so reading one back as UTC is what
+     * makes a write and a later read agree. Whatever the column actually stored
+     * is what arrives -- a column keeping only whole seconds reports whole
+     * seconds -- because this is the database's own text, not a value
+     * reconstructed from the one that was bound.
+     */
+    protected applyWallClockAliases<T>(row: T, aliases: ReadonlyArray<{
+        alias: string;
+        jsName: string;
+    }>): T;
     /**
      * Build a Drizzle column projection object (`{ propertyName: column }`) from a
      * requested column list, used by `select` (columns) and `insert` (returning).

package/dist/index.cjs

@@ -108,6 +108,36 @@ function createDatabaseError(options) {
 }
 
 // src/adapter.ts
+var DATE_DATA_TYPE = /(?:^|\s)date$/;
+var WALL_CLOCK_ALIAS_STEM = "__nx_wc";
+var WALL_CLOCK_PATTERN = /^(\d{4})-(\d{2})-(\d{2})[T ](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?$/;
+function parseWallClockAsUtc(text) {
+  const match = WALL_CLOCK_PATTERN.exec(text.trim());
+  if (!match) return void 0;
+  const [, year, month, day, hour, minute, second, fraction = ""] = match;
+  const millis = Number(`${fraction}000`.slice(0, 3));
+  const parsed = new Date(
+    Date.UTC(
+      Number(year),
+      Number(month) - 1,
+      Number(day),
+      Number(hour),
+      Number(minute),
+      Number(second),
+      millis
+    )
+  );
+  if (Number(year) < 100) parsed.setUTCFullYear(Number(year));
+  return parsed;
+}
+function isDateColumn(colDef) {
+  if (!colDef || typeof colDef !== "object") return false;
+  const candidate = colDef;
+  return typeof candidate.mapFromDriverValue === "function" && typeof candidate.mapToDriverValue === "function" && DATE_DATA_TYPE.test(String(candidate.dataType));
+}
+function carriesTimeZone(colDef) {
+  return colDef.withTimezone === true;
+}
 function affectedRowCount(result) {
   if (Array.isArray(result)) {
     const header = result[0];
@@ -304,6 +334,180 @@ var DrizzleAdapter = class {
     }
     return out;
   }
+  /**
+   * Decode a raw-SQL result row's DATE column values the way a Drizzle query
+   * would, so a write answers with the same representation a read of the same
+   * column gives.
+   *
+   * A Drizzle query path runs every value through its column definition; a
+   * raw-SQL path does not, so a dialect that stores a timestamp as a number
+   * answers a write with that number while every read answers a `Date`. Only
+   * date columns are touched, and a value that is already a `Date` is left
+   * alone, so a driver that decodes on its own is unaffected.
+   *
+   * Runs after {@link mapRowKeysToJs}: keys are Drizzle property names by then,
+   * which is what the table definition is keyed by.
+   */
+  mapDateValuesFromDriver(tableObj, row) {
+    if (!tableObj || typeof tableObj !== "object" || !row || typeof row !== "object") {
+      return row;
+    }
+    let decoded;
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (!isDateColumn(colDef)) continue;
+      const value = row[jsName];
+      if (value == null || value instanceof Date) continue;
+      decoded ??= { ...row };
+      decoded[jsName] = colDef.mapFromDriverValue(value);
+    }
+    return decoded ?? row;
+  }
+  /**
+   * Encode a row's DATE values the way a Drizzle query would before binding
+   * them, so what lands in the column does not depend on the server's timezone.
+   *
+   * A column declared without a time zone stores a wall clock and records
+   * nothing about which zone it belongs to, so both ends have to agree. Drizzle
+   * writes UTC and reads UTC. A driver handed a `Date` writes the LOCAL wall
+   * clock instead, and the same row then reads back shifted by the offset --
+   * on a UTC server the two agree and nothing is visibly wrong, which is why
+   * this survives CI.
+   *
+   * Only date columns are touched. A value that is not a `Date` is left as it
+   * is, so a caller that already encoded one is not encoded twice.
+   *
+   * Keys may be spelled either way at this point, so both the Drizzle property
+   * name and the SQL column name resolve.
+   */
+  mapDateValuesToDriver(tableObj, data) {
+    if (!tableObj || typeof tableObj !== "object" || !data) return data;
+    const dateColumns = /* @__PURE__ */ new Map();
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (!isDateColumn(colDef)) continue;
+      dateColumns.set(jsName, colDef);
+      const sqlName = colDef.name;
+      if (typeof sqlName === "string") dateColumns.set(sqlName, colDef);
+    }
+    if (dateColumns.size === 0) return data;
+    let encoded;
+    for (const [key, value] of Object.entries(data)) {
+      if (!(value instanceof Date)) continue;
+      const column = dateColumns.get(key);
+      if (!column) continue;
+      encoded ??= { ...data };
+      encoded[key] = column.mapToDriverValue(value);
+    }
+    return encoded ?? data;
+  }
+  /**
+   * Bring a row about to be written through a raw-SQL statement into the shape
+   * a Drizzle query would have bound: SQL column names for keys, encoded values
+   * for date columns.
+   *
+   * The mirror of {@link mapRowFromRawSql}. The raw-SQL write paths exist
+   * because a dialect needs SQL a Drizzle query cannot express, not because
+   * their callers want different values in the table.
+   */
+  mapRowToRawSql(tableObj, data) {
+    return this.mapDateValuesToDriver(
+      tableObj,
+      this.mapKeysToSqlColumns(tableObj, data)
+    );
+  }
+  /**
+   * Bring a raw-SQL result row into the shape a Drizzle query would have
+   * produced: Drizzle property names for keys, decoded values for date columns.
+   *
+   * The raw-SQL write paths exist because a dialect needs SQL a Drizzle query
+   * cannot express, not because their callers want a different row shape, so
+   * every one of them ends here.
+   */
+  mapRowFromRawSql(tableObj, row, aliases = []) {
+    const mapped = this.mapDateValuesFromDriver(
+      tableObj,
+      this.mapRowKeysToJs(tableObj, row)
+    );
+    return this.applyWallClockAliases(mapped, aliases);
+  }
+  /**
+   * The date columns a statement is about to return, and the alias each one's
+   * wall clock is spelled out under.
+   *
+   * A driver turns a timestamp into a `Date` using ITS zone before any of this
+   * code runs, and that conversion is lossy: a wall clock inside a
+   * daylight-saving gap is a local time that does not exist, so the driver
+   * normalizes it and the original is gone. Asking the database for the wall
+   * clock as text alongside the row is the only way to read it exactly.
+   *
+   * `"*"` covers every date column; a projection covers only the ones it asked
+   * for, so a caller still gets back what it requested and nothing more.
+   */
+  dateWallClockAliases(tableObj, returning) {
+    if (!tableObj || typeof tableObj !== "object" || returning === void 0) {
+      return [];
+    }
+    const requested = returning === "*" ? void 0 : new Set(returning.map(String));
+    const taken = /* @__PURE__ */ new Set();
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      taken.add(jsName);
+      const columnName = colDef.name;
+      if (typeof columnName === "string") taken.add(columnName);
+    }
+    let next = 0;
+    const freeAlias = () => {
+      let candidate = `${WALL_CLOCK_ALIAS_STEM}${next++}`;
+      while (taken.has(candidate)) {
+        candidate = `${WALL_CLOCK_ALIAS_STEM}${next++}`;
+      }
+      taken.add(candidate);
+      return candidate;
+    };
+    const aliases = [];
+    for (const [jsName, colDef] of Object.entries(
+      tableObj
+    )) {
+      if (!isDateColumn(colDef)) continue;
+      if (carriesTimeZone(colDef)) continue;
+      const sqlName = colDef.name;
+      if (typeof sqlName !== "string") continue;
+      if (requested && !requested.has(sqlName) && !requested.has(jsName)) {
+        continue;
+      }
+      aliases.push({ sqlName, alias: freeAlias(), jsName });
+    }
+    return aliases;
+  }
+  /**
+   * Replace each date in a row with the wall clock the database spelled out,
+   * read as UTC, and drop the aliases that carried it.
+   *
+   * The statement writes a UTC wall clock, so reading one back as UTC is what
+   * makes a write and a later read agree. Whatever the column actually stored
+   * is what arrives -- a column keeping only whole seconds reports whole
+   * seconds -- because this is the database's own text, not a value
+   * reconstructed from the one that was bound.
+   */
+  applyWallClockAliases(row, aliases) {
+    if (!row || typeof row !== "object" || aliases.length === 0) return row;
+    const record = row;
+    let resolved;
+    for (const { alias, jsName } of aliases) {
+      if (!(alias in record)) continue;
+      resolved ??= { ...record };
+      const text = resolved[alias];
+      delete resolved[alias];
+      if (typeof text !== "string") continue;
+      const parsed = parseWallClockAsUtc(text);
+      if (parsed !== void 0) resolved[jsName] = parsed;
+    }
+    return resolved ?? row;
+  }
   /**
    * Build a Drizzle column projection object (`{ propertyName: column }`) from a
    * requested column list, used by `select` (columns) and `insert` (returning).
@@ -1072,11 +1276,15 @@ var DrizzleAdapter = class {
           sql = `
             SELECT EXISTS (
               SELECT FROM information_schema.tables
-              WHERE table_schema = $1
+              WHERE table_schema = COALESCE($1, (
+                SELECT n.nspname FROM pg_class c
+                JOIN pg_namespace n ON n.oid = c.relnamespace
+                WHERE c.oid = to_regclass($2)
+              ))
               AND table_name = $2
             ) as exists
           `;
-          params.push(schema ?? "public", tableName);
+          params.push(schema ?? null, tableName);
           break;
         case "mysql":
           sql = `