sql: add support for column name transforms (snake_case to camelCase)

[pjb3]

What does this PR do?

Implements Unicode-aware column name transforms for Bun SQL (new SQL() / postgres()), resolving the Roadmap item in docs/runtime/sql.mdx.

Details:

• Adds Unicode-aware casing helpers: toCamel, toPascal, toKebab, toSnake supporting multi-language characters (accents, Cyrillic, German Eszett, etc.).
• Exposes transform presets postgres.camel, postgres.pascal, postgres.kebab, postgres.snake on SQL, postgres, and bun module exports.
• Applies bidirectional column transforms:
  • Results: transforms DB column names (e.g. user_id -> userId) when reading query results.
  • Helpers: transforms JS object keys back to DB column names when constructing sql({ firstName: "Alice" }) INSERT / UPDATE queries.
• Includes $O(1)$ per-column memoization cache to optimize multi-row result sets.
• Adds comprehensive unit tests in test/js/sql/sql-transform.test.ts.

Related Docs:

• Updates docs/runtime/sql.mdx documentation and removes column transforms from the Roadmap list.

[claude]

Claude Code Review

This pull request is from a fork — automated review is disabled. A repository maintainer can comment @claude review to run a one-time review.

[coderabbitai]

Walkthrough

Column transformation support is added to SQL clients, including public types, casing helpers, adapter configuration, transformed query results, helper-generated SQL values and identifiers, tests, and documentation.

Changes

SQL transformations

Layer / File(s)	Summary
Transformation API and exports packages/bun-types/sql.d.ts, src/js/bun/sql.ts	Adds public transform types, adapter options, casing utilities, and runtime exports.
Transform parsing and result processing src/js/internal/sql/shared.ts	Implements Unicode-aware casing helpers, transform normalization, and column, value, and row result processing.
Adapter and query integration src/js/internal/sql/shared.ts, src/js/internal/sql/query.ts	Parses adapter transforms, applies them during query resolution, and maps transformed identifiers and values for helper queries.
Behavior validation and documentation test/js/sql/sql-transform.test.ts, docs/runtime/sql.mdx	Adds coverage for casing, Unicode, custom hooks, result processing, transformed helper queries, invalid options, and documents the new option.

Suggested reviewers: robobun, jarred-sumner, alii

🚥 Pre-merge checks | ✅ 4

✅ Passed checks (4 passed)

Check name	Status	Explanation
Title check	✅ Passed	The title is concise and accurately summarizes the main change: SQL column-name transforms.
Description check	✅ Passed	The description is mostly complete and matches the template's intent, though it omits an explicit verification section.
Linked Issues check	✅ Passed	Check skipped because no linked issues were found for this pull request.
Out of Scope Changes check	✅ Passed	Check skipped because no linked issues were found for this pull request.

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands.}

[coderabbitai]

Actionable comments posted: 3

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

src/js/internal/sql/query.ts (1)

183-200: 🩺 Stability & Availability | 🟠 Major | ⚡ Quick win

User-supplied transform functions can throw uncaught inside resolve().

applyResultTransform invokes arbitrary user callbacks (column/value/row transforms). Unlike #run()/#runAsync() in this same file, which wrap handler calls in try/catch and reject the query on error, this call is unguarded — a throwing transform function will escape resolve() instead of rejecting the query gracefully.

🔧 Proposed fix

     const transform = (this[_adapter] as any)?.connectionInfo?.transform;
     if (transform) {
-      const { applyResultTransform } = require("./shared");
-      applyResultTransform(x, transform);
+      try {
+        const { applyResultTransform } = require("./shared");
+        applyResultTransform(x, transform);
+      } catch (err) {
+        this[_queryStatus] |= SQLQueryStatus.error;
+        return this.reject(err as Error);
+      }
     }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/query.ts` around lines 183 - 200, Wrap the transform
application in resolve() with the same error-handling behavior used by `#run`()
and `#runAsync`(): catch exceptions from applyResultTransform, reject the query
through the established rejection path, and return without invoking the success
resolver. Preserve normal transformation and resolution when no error occurs.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/js/internal/sql/shared.ts`:
- Line 1: Implement the documented bidirectional value transform by applying
ParsedTransform.value.from during INSERT and UPDATE parameter binding in
normalizeQuery, while preserving value.to in applyResultTransform for reads.
Ensure parseTransform and the public TransformOptions.value type remain aligned
with the now-supported from behavior.
- Around line 2242-2353: Wire the parsed transform.value.from handler into
outbound value binding for INSERT and UPDATE operations, using the binding paths
in normalizeQuery and buildDefinedColumnsAndQuery. Apply it to each value before
pushing binding_values, while preserving transform.value.to for result reads and
existing behavior when no from handler is configured.

In `@test/js/sql/sql-transform.test.ts`:
- Around line 42-197: Update each SQL transform test to declare its SQL instance
with await using, including the tests covering column, row, value, INSERT, and
UPDATE transforms. Remove the manual await sql.close() calls so disposal occurs
automatically even when assertions fail.

---

Outside diff comments:
In `@src/js/internal/sql/query.ts`:
- Around line 183-200: Wrap the transform application in resolve() with the same
error-handling behavior used by `#run`() and `#runAsync`(): catch exceptions from
applyResultTransform, reject the query through the established rejection path,
and return without invoking the success resolver. Preserve normal transformation
and resolution when no error occurs.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: cba47d58-9db4-44be-b5da-090484a50b60

📥 Commits

Reviewing files that changed from the base of the PR and between c08f665 and 60b837b.

📒 Files selected for processing (6)

• docs/runtime/sql.mdx
• packages/bun-types/sql.d.ts
• src/js/bun/sql.ts
• src/js/internal/sql/query.ts
• src/js/internal/sql/shared.ts
• test/js/sql/sql-transform.test.ts

[coderabbitai]

Actionable comments posted: 10

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

src/js/internal/sql/shared.ts (1)

477-500: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Extract the repeated value.from application.

The same four-line guard is duplicated at four binding sites, and it has already drifted — the single-row INSERT path (Lines 497-499) adds a typeof boundVal !== "undefined" check the other three lack. A local helper keeps the null/undefined policy in one place.

♻️ Proposed refactor

           const valFromTransform = transform?.value?.from;
+          const bindValue = (v: unknown) =>
+            valFromTransform && v !== null && typeof v !== "undefined" ? valFromTransform(v) : v;

Then each site becomes binding_values.push(bindValue(columnValue)).

Also applies to: 532-548, 582-586

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 477 - 500, Extract the repeated
transform-and-bind logic into a local helper near the binding code, such as
bindValue, that applies valFromTransform only for non-null and non-undefined
values while preserving null/undefined unchanged. Replace all four duplicated
binding sites, including the single-row INSERT path and the sites around the
other binding loops, with binding_values.push(bindValue(columnValue)), removing
the inconsistent guards.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@docs/runtime/sql.mdx`:
- Around line 1209-1217: Extend the custom transform documentation near the
existing transform.column example to also cover transform.value and
transform.row. Add a concise example describing value’s bidirectional { to, from
} behavior for reads and bound helper values on writes, and document row as
another supported transform option consistent with the types in sql.d.ts.

In `@packages/bun-types/sql.d.ts`:
- Around line 162-173: Update the module-export declarations in bun.d.ts to
expose the SQL transform symbols camel, pascal, kebab, snake, toCamel, toPascal,
toKebab, toSnake, fromCamel, fromPascal, fromKebab, and fromSnake as named "bun"
exports, matching the runtime imports. Reuse the existing ColumnTransform type
and helper signatures from the SQL declarations rather than changing their
behavior or limiting them to SQL/postgres access.

In `@src/js/internal/sql/shared.ts`:
- Around line 442-444: Update the QueryNormalizationAdapter interface to declare
optional readonly connectionInfo with an optional transform of type
ParsedTransform, then access connectionInfo directly in the transform extraction
within the affected function and remove the any cast.
- Around line 2340-2362: Update the result-column metadata alongside
transformRowObj so result.columns and result.statement.columns expose names
transformed by colTo. Preserve the original metadata when no column transform is
configured, and ensure transformed metadata matches the keys emitted in each
transformed row.
- Around line 2318-2375: Update applyResultTransform to use the module’s
intrinsic helpers instead of mutable globals: replace each Array.isArray call
with $isArray and Object.keys(row) with $Object.keys(row). Preserve the existing
transformation and branching behavior.
- Around line 1-18: In src/js/internal/sql/shared.ts lines 1-18, remove the
globalThis.$isArray patch and getQueryMod fallback; restore the static
string-literal require and destructuring of the internal/sql/query exports so
load failures propagate. In src/js/internal/sql/query.ts lines 193-203, replace
the per-resolution require("./shared") with a module-scope memoized
lazyApplyResultTransform accessor using
require("internal/sql/shared").applyResultTransform.
- Around line 1-18: Remove the globalThis.$isArray initialization and replace
getQueryMod with static string-literal require("internal/sql/query")
destructuring, preserving the Query, SQLQueryFlags, _strings, and _values
bindings from that module. Do not retain a catch-all fallback or allow
module-loading errors to be swallowed.
- Around line 2191-2223: Update getWords and the casing transforms to preserve
identifier separators, including leading/trailing underscores and dots, while
treating alphanumeric runs such as user2024 as a single identifier component.
Ensure toCamel, toPascal, toKebab, and toSnake round-trip legal SQL identifiers
without dropping existing separators or introducing new ones.

In `@test/js/sql/sql-transform.test.ts`:
- Around line 6-38: Extend the casing-helper tests for toCamel, toPascal,
toKebab, and toSnake to explicitly cover degenerate inputs where getWords
returns an empty result or splitting is lossy: "", "_", "___", "_private_id",
"user2024", and "col$x". Assert each helper preserves the original input
unchanged for these cases.
- Around line 171-200: Update the “Bidirectional value transform function” test
so it verifies both transformed output and the actual stored lowercase value.
Use a non-transforming SQL client connected to the same database, query through
that client, assert the raw value is lowercase, and manage it with await using;
retain the transforming read assertion so removing either value.from or value.to
fails.

---

Outside diff comments:
In `@src/js/internal/sql/shared.ts`:
- Around line 477-500: Extract the repeated transform-and-bind logic into a
local helper near the binding code, such as bindValue, that applies
valFromTransform only for non-null and non-undefined values while preserving
null/undefined unchanged. Replace all four duplicated binding sites, including
the single-row INSERT path and the sites around the other binding loops, with
binding_values.push(bindValue(columnValue)), removing the inconsistent guards.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: 3462407b-8436-4910-91a1-579e8bf0348b

📥 Commits

Reviewing files that changed from the base of the PR and between 60b837b and ade4bdc.

📒 Files selected for processing (6)

• docs/runtime/sql.mdx
• packages/bun-types/sql.d.ts
• src/js/bun/sql.ts
• src/js/internal/sql/query.ts
• src/js/internal/sql/shared.ts
• test/js/sql/sql-transform.test.ts

[coderabbitai]

📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Document transform.value and transform.row.

The section only covers transform.column, but value ({ to, from }, applied on read and to bound helper values on write) and row are both supported and typed in sql.d.ts. Worth a short example so the bidirectional value semantics aren't discovered by reading the source.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@docs/runtime/sql.mdx` around lines 1209 - 1217, Extend the custom transform
documentation near the existing transform.column example to also cover
transform.value and transform.row. Add a concise example describing value’s
bidirectional { to, from } behavior for reads and bound helper values on writes,
and document row as another supported transform option consistent with the types
in sql.d.ts.

[coderabbitai]

🩺 Stability & Availability | 🟠 Major | ⚡ Quick win

Ad-hoc dynamic requires on both sides of the shared ↔ query cycle. These two modules require each other, and rather than establishing one memoized lazy accessor, each side improvised its own dynamic require — one with an error-swallowing fallback plus a globalThis patch, the other repeated per query resolution with a relative specifier. Pick a single convention: static require("internal/sql/query") where the cycle allows it, and one memoized lazy getter where it doesn't.

• src/js/internal/sql/shared.ts#L1-L18: drop getQueryMod()'s catch/./query fallback and the globalThis.$isArray assignment; restore the static string-literal destructuring require so a broken internal/sql/query fails at load instead of leaving Query undefined.
• src/js/internal/sql/query.ts#L193-L203: replace the per-resolution require("./shared") with a module-scope memoized lazyApplyResultTransform ??= require("internal/sql/shared").applyResultTransform.

📍 Affects 2 files

• src/js/internal/sql/shared.ts#L1-L18 (this comment)
• src/js/internal/sql/query.ts#L193-L203

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 1 - 18, In
src/js/internal/sql/shared.ts lines 1-18, remove the globalThis.$isArray patch
and getQueryMod fallback; restore the static string-literal require and
destructuring of the internal/sql/query exports so load failures propagate. In
src/js/internal/sql/query.ts lines 193-203, replace the per-resolution
require("./shared") with a module-scope memoized lazyApplyResultTransform
accessor using require("internal/sql/shared").applyResultTransform.

Source: Coding guidelines

---

🩺 Stability & Availability | 🟠 Major | ⚡ Quick win

Don't ship a globalThis patch and a swallow-all module fallback in a builtin.

Two problems here:

1. globalThis.$isArray = Array.isArray mutates the global object from a builtin. $isArray is a build-time intrinsic in this pipeline, so the assignment is only needed when the file is loaded outside it — that scaffolding shouldn't be in the shipped module.
2. getQueryMod()'s bare catch swallows any error thrown while evaluating internal/sql/query (not just resolution failure). If both requires fail, queryModExp becomes {} and Query, SQLQueryFlags, _strings, _values are all undefined — value instanceof Query then throws TypeError: Right-hand side of 'instanceof' is not callable deep inside normalizeQuery instead of failing loudly at load.

Restore the static, string-literal require("internal/sql/query") destructuring.

As per coding guidelines: "Modules in Bun's builtin/compatibility code are not ES modules: use require("...") with string literals only".

♻️ Proposed fix

-if (typeof (globalThis as any).$isArray === "undefined") {
-  (globalThis as any).$isArray = Array.isArray;
-}
-
 const PublicArray = globalThis.Array;
-function getQueryMod() {
-  try {
-    return require("internal/sql/query");
-  } catch {
-    return require("./query");
-  }
-}
-const queryMod = getQueryMod();
-const queryModExp = queryMod?.default || queryMod || {};
-const Query = queryModExp.Query;
-const SQLQueryFlags = queryModExp.SQLQueryFlags;
-const _strings = queryModExp.symbols?._strings;
-const _values = queryModExp.symbols?._values;
+const {
+  Query,
+  SQLQueryFlags,
+  symbols: { _strings, _values },
+} = require("internal/sql/query");

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	if (typeof (globalThis as any).$isArray === "undefined") {
	(globalThis as any).$isArray = Array.isArray;
	}
	const PublicArray = globalThis.Array;
	const {
	Query,
	SQLQueryFlags,
	symbols: { _strings, _values },
	} = require("internal/sql/query");
	function getQueryMod() {
	try {
	return require("internal/sql/query");
	} catch {
	return require("./query");
	}
	}
	const queryMod = getQueryMod();
	const queryModExp = queryMod?.default || queryMod || {};
	const Query = queryModExp.Query;
	const SQLQueryFlags = queryModExp.SQLQueryFlags;
	const _strings = queryModExp.symbols?._strings;
	const _values = queryModExp.symbols?._values;
	const PublicArray = globalThis.Array;
	const {
	Query,
	SQLQueryFlags,
	symbols: { _strings, _values },
	} = require("internal/sql/query");

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 1 - 18, Remove the
globalThis.$isArray initialization and replace getQueryMod with static
string-literal require("internal/sql/query") destructuring, preserving the
Query, SQLQueryFlags, _strings, and _values bindings from that module. Do not
retain a catch-all fallback or allow module-loading errors to be swallowed.

Source: Coding guidelines

[coderabbitai]

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🌐 Web query:

postgres.js toCamel toSnake column transform leading underscore digits behavior

💡 Result:

In postgres.js, the built-in toCamel and fromCamel (and their counterparts for pascal and kebab cases) transformations are designed to convert between snake_case and their respective naming conventions [1][2][3]. These transformations rely on standard string manipulation logic. Regarding leading underscores and digits, the default behavior follows the logic implemented in the library's internal transformation functions: 1. Leading Underscores: The transformation functions typically preserve leading underscores, as they are often treated as part of the identifier name rather than separators. 2. Digits: Transformation functions generally treat digits as part of the alphanumeric sequence. Because they are not separators (like underscores), they do not trigger a case change in the resulting string (e.g., test1_column would typically transform to test1Column). If you have specific requirements that differ from the library's default behavior—such as handling leading underscores or digits in a way that deviates from standard camelCase conversion—postgres.js allows you to define custom transformation functions [4][5]. You can configure this via the transform option in the postgres configuration object: javascript const sql = postgres({ transform: { column: { to: (columnName) => { /* Custom logic for outgoing column names */ }, from: (columnName) => { /* Custom logic for incoming column names */ } } } }) By providing your own functions, you gain full control over how specific patterns—including those with leading underscores or embedded digits—are processed [4]. If you do not provide your own, the library falls back to its default internal implementation [4]. To see the exact current implementation used for toCamel or fromCamel, you can reference the library's source code [4], specifically within the types.js file [4].

Citations:

• 1: https://raw.githubusercontent.com/porsager/postgres/refs/heads/master/README.md
• 2: https://registry.npmjs.org/postgres
• 3: https://github.com/porsager/postgres?tab=readme-ov-file
• 4: https://github.com/porsager/postgres/blob/master/README.md
• 5: https://cdn.jsdelivr.net/npm/postgres@3.4.7/types/index.d.ts

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

# Locate and inspect the relevant casing helpers and their column mapping usage.
if [ -f src/js/internal/sql/shared.ts ]; then
  echo '--- relevant helper code ---'
  sed -n '2180,2230p' src/js/internal/sql/shared.ts

  echo '--- references to toSnake/toPascal/toCamel/toKebab/getWords ---'
  rg -n "toSnake|toPascal|toCamel|toKebab|getWords|column\\.(to|from)" src/js/internal/sql/src? src/js/internal/sql -g '*.ts' || true

  echo '--- package/version hints ---'
  rg -n '"postgres"|postgres\\:' package.json bun.lock bun.lockb . 2>/dev/null | head -80 || true
else
  echo 'src/js/internal/sql/shared.ts not found'
  fd -a shared.ts .
fi

echo '--- deterministic regex behavior probe ---'
node - <<'JS'
const WORD_REGEX = /(\p{Lu}\p{Ll}+|\p{Lu}+(?!\p{Ll})|\p{Ll}+|\p{N}+)/gu;

function getWords(str) {
  if (typeof str !== "string" || !str) return [];
  const matches = str.match(WORD_REGEX);
  return matches || [];
}

function toCamel(str) {
  const words = getWords(str);
  if (words.length === 0) return str;
  const first = words[0].toLowerCase();
  const rest = words.slice(1).map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase());
  return first + rest.join("");
}

function toPascal(str) {
  const words = getWords(str);
  if (words.length === 0) return str;
  return words.map(w => w.charAt(0).toUpperCase() + w.slice(1).toLowerCase()).join("");
}

function toKebab(str) {
  const words = getWords(str);
  if (words.length === 0) return str;
  return words.map(w => w.toLowerCase()).join("-");
}

function toSnake(str) {
  const words = getWords(str);
  if (words.length === 0) return str;
  return words.map(w => w.toLowerCase()).join("_");
}

const samples = [
  "_private_id",
  "user2024",
  "col$x",
  "_id",
  "$col",
  "getURL",
  "v2Model",
  "__id",
  "col_"
];
for (const s of samples) {
  const c = toCamel(s);
  const s2 = toSnake(c);
  const p = toPascal(s);
  const k = toKebab(s);
  console.log(JSON.stringify({
    input: s,
    words: getWords(s),
    toCamel: c,
    toSnakeAfterToCamel: s2,
    roundTripBackToSnakeIdentical: s2 === s,
    toPascal: p,
    toKebab: k
  }));
}
JS

Repository: oven-sh/bun

Length of output: 13156

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '--- shared.ts transform setup ---'
sed -n '2225,2415p' src/js/internal/sql/shared.ts

echo '--- inspect installed postgres package implementation files ---'
for path in node_modules/postgres/cjs/types.js node_modules/postgres/types/types.js node_modules/postgres/lib/types.js; do
  if [ -f "$path" ]; then
    echo "### $path"
    rg -n "toCamel|fromCamel|snake|camel|kebab|pascal|to\\:" "$path" -C 4 || true
  fi
done

echo '--- inspect benchmark postgres package implementation files if available ---'
for path in \
  /test/pkg/node_modules/postgres/types/types.js \
  /bench/install/node_modules/postgres/types/types.js \
  /bench/postgres/node_modules/postgres/types/types.js \
  node_modules/postgres/cjs/types.js \
  node_modules/postgres/types/types.js \
  node_modules/postgres/lib/types.js; do
  if [ -f "$path" ]; then
    echo "### $path"
    sed -n '1,180p' "$path" | rg -n "toCamel|fromCamel|snake|camel|to\\:" -C 6 || true
  fi
done

Repository: oven-sh/bun

Length of output: 5510

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo '--- transform usage in shared.ts ---'
rg -n "snake|toCamel|pascal|kebab|applyResultTransform|Bun\\.SQL|transform" src/js/internal/sql/shared.ts -A 4 -B 4

echo '--- inspect sql.ts exports for postgres/bun helpers ---'
for f in src/js/bun/sql.ts src/js/internal/sql/shared.ts; do
  if [ -f "$f" ]; then
    echo "### $f"
    rg -n "postgres|camel|toCamel|snake|toSnake|transform|const SQL|export.*SQL" "$f" -A 3 -B 3 || true
  fi
done

echo '--- deterministic compare against postgres 3.3.5 behavior ---'
node - <<'JS'
const module = { cache: {} };
const name = require.resolve("postgres", module);
console.log("resolved", name);
const pg = require(name);
const samples = [
  "_private_id",
  "user2024",
  "col$x",
  "_id",
  "$col",
  "getURL",
  "v2Model",
  "__id",
  "col_",
  "private_id",
  "user_2024",
  "col_x"
];
for (const s of samples) {
  const c = pg.toCamel(s);
  const s2 = pg.fromCamel(c);
  console.log(JSON.stringify({
    input: s,
    pg_toCamel: c,
    pg_fromCamel_after_toCamel: s2,
    roundTripBackToInputIdentical: s2 === s
  }));
}
JS

Repository: oven-sh/bun

Length of output: 29231

---

Preserve identifier separators in the SQL casing transforms.

WORD_REGEX discards non-letter/non-digit characters and splits digit runs, so snake.to / camel.from can map legal column names to different SQL identifiers. For example, _private_id → camel → privateId → snake → private_id, causing an INSERT/UPDATE helper to reference the wrong column. Handle leading/trailing separators and alphanumeric runs like user2024 without inserting new separators.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 2191 - 2223, Update getWords and
the casing transforms to preserve identifier separators, including
leading/trailing underscores and dots, while treating alphanumeric runs such as
user2024 as a single identifier component. Ensure toCamel, toPascal, toKebab,
and toSnake round-trip legal SQL identifiers without dropping existing
separators or introducing new ones.

[coderabbitai]

🗄️ Data Integrity & Integration | 🟡 Minor | ⚡ Quick win

result.columns still reports untransformed names.

Rows are rebuilt with transformed keys, but the result's column metadata (result.columns / result.statement.columns) is left holding the original database names. Consumers that iterate result.columns to index into a row will get undefined for every column once a transform is configured.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 2340 - 2362, Update the
result-column metadata alongside transformRowObj so result.columns and
result.statement.columns expose names transformed by colTo. Preserve the
original metadata when no column transform is configured, and ensure transformed
metadata matches the keys emitted in each transformed row.

[coderabbitai]

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Enumerate the degenerate inputs for the casing helpers.

The matrix covers realistic identifiers but skips exactly the inputs where getWords returns [] and the functions fall back to returning the input unchanged: "", "_", "___", and names where splitting is lossy ("_private_id", "user2024", "col$x"). Those fallbacks are load-bearing for the write path — please pin them.

As per coding guidelines: "Deliberately enumerate input spaces, including empty, zero, unset, delimiter-only, CRLF, IPv6, integer limits, and every accepted option spelling".

💚 Suggested additions

     test("toSnake", () => {
       expect(toSnake("userId")).toBe("user_id");
+      expect(toSnake("")).toBe("");
+      expect(toSnake("___")).toBe("___");
+      expect(toSnake("user2024")).toBe("user_2024");

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	test("toCamel", () => {
	expect(toCamel("user_id")).toBe("userId");
	expect(toCamel("USER_ID")).toBe("userId");
	expect(toCamel("first_name")).toBe("firstName");
	expect(toCamel("user_id_2024")).toBe("userId2024");
	expect(toCamel("créée_à")).toBe("crééeÀ");
	expect(toCamel("über_größe")).toBe("überGröße");
	expect(toCamel("имя_пользователя")).toBe("имяПользователя");
	expect(toCamel("FooBar")).toBe("fooBar");
	expect(toCamel("foo-bar")).toBe("fooBar");
	});
	test("toPascal", () => {
	expect(toPascal("user_id")).toBe("UserId");
	expect(toPascal("USER_ID")).toBe("UserId");
	expect(toPascal("first_name")).toBe("FirstName");
	expect(toPascal("créée_à")).toBe("CrééeÀ");
	expect(toPascal("foo-bar")).toBe("FooBar");
	});
	test("toKebab", () => {
	expect(toKebab("user_id")).toBe("user-id");
	expect(toKebab("userId")).toBe("user-id");
	expect(toKebab("First_Name")).toBe("first-name");
	});
	test("toSnake", () => {
	expect(toSnake("userId")).toBe("user_id");
	expect(toSnake("UserId")).toBe("user_id");
	expect(toSnake("first-name")).toBe("first_name");
	expect(toSnake("FOO_BAR")).toBe("foo_bar");
	expect(toSnake("crééeÀ")).toBe("créée_à");
	});
	test("toSnake", () => {
	expect(toSnake("userId")).toBe("user_id");
	expect(toSnake("")).toBe("");
	expect(toSnake("___")).toBe("___");
	expect(toSnake("user2024")).toBe("user_2024");
	expect(toSnake("UserId")).toBe("user_id");
	expect(toSnake("first-name")).toBe("first_name");
	expect(toSnake("FOO_BAR")).toBe("foo_bar");
	expect(toSnake("crééeÀ")).toBe("créée_à");
	});

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/js/sql/sql-transform.test.ts` around lines 6 - 38, Extend the
casing-helper tests for toCamel, toPascal, toKebab, and toSnake to explicitly
cover degenerate inputs where getWords returns an empty result or splitting is
lossy: "", "_", "___", "_private_id", "user2024", and "col$x". Assert each
helper preserves the original input unchanged for these cases.

Source: Coding guidelines

[coderabbitai]

Actionable comments posted: 2

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@src/js/internal/sql/shared.ts`:
- Around line 2318-2375: Move the column-name memoization cache out of
applyResultTransform and into the connection-scoped transform setup performed by
parseTransform, so the same cache is reused across query results. Update the
parsed transform’s column.to wrapper to capture that persistent Map, while
preserving the existing key transformation behavior and row processing in
applyResultTransform.
- Around line 2264-2316: Update parseTransform to validate the top-level
transform input and throw the established $ERR_INVALID_ARG_TYPE error when it is
neither a function nor an object, instead of silently returning undefined.
Preserve the existing parsing behavior for valid function and object transforms,
including the final undefined result when a valid object contains no recognized
transform handlers.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: 3dff7d18-6856-4796-9bb5-79e9bc9255a4

📥 Commits

Reviewing files that changed from the base of the PR and between ade4bdc and 4d08ae9.

📒 Files selected for processing (6)

• docs/runtime/sql.mdx
• packages/bun-types/sql.d.ts
• src/js/bun/sql.ts
• src/js/internal/sql/query.ts
• src/js/internal/sql/shared.ts
• test/js/sql/sql-transform.test.ts

[coderabbitai]

Actionable comments posted: 9

Caution

Some comments are outside the diff and can’t be posted inline due to platform limitations.

⚠️ Outside diff range comments (1)

src/js/internal/sql/shared.ts (1)

477-500: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

valFromTransform guards on !== null but not undefined in the multi-value paths.

Lines 477-481 and 532-548 normalize undefined → null first so they're safe, and 496-500 checks both; the UPDATE path (582-586) can't see undefined because of the continue above. Consistent, but the three near-identical let boundVal / if (valFromTransform …) / push blocks would read better as one local helper.

Also applies to: 532-548, 580-586

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 477 - 500, Extract the repeated
bound-value normalization logic into a local helper near the affected
SQL-building code, covering undefined-to-null conversion, conditional
valFromTransform application, and binding_values insertion. Replace the
equivalent blocks in the multi-value paths and UPDATE path around the visible
let boundVal/valFromTransform/push sequences with calls to that helper,
preserving their existing null and undefined behavior.

🤖 Prompt for all review comments with AI agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

Inline comments:
In `@packages/bun-types/sql.d.ts`:
- Around line 229-233: Remove the redundant `(column: string) => string` union
member from the `transform` property in both option interfaces, leaving
`TransformOptions | ColumnTransform | undefined`; use `ColumnTransform` as the
sole function-compatible type.
- Around line 188-198: Update the TransformOptions interface to include the
top-level { to, from } column-transform shape accepted by parseTransform when no
column key is present, adding it to the existing column union while preserving
current function and nested-object forms.

In `@src/js/bun/sql.ts`:
- Around line 10-29: Remove the unused toCamelTransform, toPascalTransform,
toKebabTransform, and toSnakeTransform bindings from the destructuring in
sql.ts, and remove their corresponding exports from the shared.ts export
surface. Preserve the existing toCamel, toPascal, toKebab, toSnake, and
from*Transform APIs.

In `@src/js/internal/sql/shared.ts`:
- Around line 2334-2378: Update applyResultTransform so column metadata stays
consistent with transformed row keys: apply colTo to result.columns and
result.statement.columns when present, preserving the existing value and row
transformations. Replace Array.isArray, Object.keys, and Buffer.isBuffer in
transformRowObj and result traversal with this directory’s approved $-prefixed
intrinsic/private equivalents, avoiding global resolution.
- Around line 442-444: Move value.from handling to the shared bindParam boundary
so both ordinary interpolated parameters and INSERT/IN/UPDATE helper values use
the same transformation path. Update the relevant bindParam flow and remove the
per-helper valFromTransform handling to prevent syntax-dependent behavior.
Expose connectionInfo on QueryNormalizationAdapter and access it without the
(adapter as any) cast.
- Around line 2276-2308: Update parseTransform’s handling of transform.column so
postgres.js semantics are preserved: assign column.to to the direction used for
generated SQL identifiers (colFrom) and column.from to the direction used for
result-row transformation (colTo), including function metadata and object forms.
Compensate the built-in helper assignments as needed, while leaving value and
row transformation behavior unchanged.
- Around line 2314-2332: Update the memoization wrapper around colTo in the
returned transform setup to distinguish a missing cache entry from a cached
undefined result by checking cache presence with cache.has(key) before invoking
rawColTo. Preserve undefined values in the cache and prevent repeated user
transform calls or unintended out[undefined] keys.

In `@test/js/sql/sql-transform.test.ts`:
- Around line 196-203: Strengthen the assertion in “Throws error for invalid
transform options type” by matching the thrown validation error’s message,
ensuring it identifies the transform option and the rejected type. Keep the
invalid transform setup unchanged while replacing the bare toThrow assertion
with a message-specific expectation.
- Around line 42-152: Expand the transform integration tests around the existing
preset tests to parameterize every exported preset in both namespaces: postgres
and SQL, covering camel, pascal, kebab, and snake aliases. Exercise
result-column conversion in both directions for each preset, including Unicode
where applicable, and add matching SQLHelper INSERT/UPDATE assertions for
non-camel presets. Ensure the matrix verifies each exported entry point and its
inverse mapping.

---

Outside diff comments:
In `@src/js/internal/sql/shared.ts`:
- Around line 477-500: Extract the repeated bound-value normalization logic into
a local helper near the affected SQL-building code, covering undefined-to-null
conversion, conditional valFromTransform application, and binding_values
insertion. Replace the equivalent blocks in the multi-value paths and UPDATE
path around the visible let boundVal/valFromTransform/push sequences with calls
to that helper, preserving their existing null and undefined behavior.

🪄 Autofix (Beta)

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

---

ℹ️ Review info

⚙️ Run configuration

Configuration used: Path: .coderabbit.yaml

Review profile: ASSERTIVE

Plan: Pro Plus

Run ID: aeba1b05-2130-4362-975d-53710bf4da01

📥 Commits

Reviewing files that changed from the base of the PR and between 4d08ae9 and 3fbf163.

📒 Files selected for processing (6)

• docs/runtime/sql.mdx
• packages/bun-types/sql.d.ts
• src/js/bun/sql.ts
• src/js/internal/sql/query.ts
• src/js/internal/sql/shared.ts
• test/js/sql/sql-transform.test.ts

[coderabbitai]

🗄️ Data Integrity & Integration | 🟡 Minor | ⚡ Quick win

TransformOptions doesn't express the top-level { to, from } shape the runtime accepts.

parseTransform in src/js/internal/sql/shared.ts (Lines 2304-2307) treats an object with bare to/from and no column key as a column transform, but that form is a type error against this declaration. Either add it to the union or drop the runtime branch so the public contract and the parser agree.

♻️ Proposed type addition

     interface TransformOptions {
       column?: ColumnTransform | {
         to?: (column: string) => string;
         from?: (column: string) => string;
       } | undefined;
+      /** Shorthand for `column`, applied when `column` is not set. */
+      to?: ((column: string) => string) | undefined;
+      from?: ((column: string) => string) | undefined;
       value?: ((value: any) => any) | {

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	interface TransformOptions {
	column?: ColumnTransform | {
	to?: (column: string) => string;
	from?: (column: string) => string;
	} | undefined;
	value?: ((value: any) => any) | {
	to?: (value: any) => any;
	from?: (value: any) => any;
	} | undefined;
	row?: ((row: any) => any) | undefined;
	}
	interface TransformOptions {
	column?: ColumnTransform | {
	to?: (column: string) => string;
	from?: (column: string) => string;
	} | undefined;
	/** Shorthand for `column`, applied when `column` is not set. */
	to?: ((column: string) => string) | undefined;
	from?: ((column: string) => string) | undefined;
	value?: ((value: any) => any) | {
	to?: (value: any) => any;
	from?: (value: any) => any;
	} | undefined;
	row?: ((row: any) => any) | undefined;
	}

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/bun-types/sql.d.ts` around lines 188 - 198, Update the
TransformOptions interface to include the top-level { to, from }
column-transform shape accepted by parseTransform when no column key is present,
adding it to the existing column union while preserving current function and
nested-object forms.

[coderabbitai]

📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

(column: string) => string is already subsumed by ColumnTransform.

ColumnTransform has a bare call signature with optional to/from, so a plain function satisfies it; the third union member is redundant noise in both option interfaces.

Also applies to: 428-432

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@packages/bun-types/sql.d.ts` around lines 229 - 233, Remove the redundant
`(column: string) => string` union member from the `transform` property in both
option interfaces, leaving `TransformOptions | ColumnTransform | undefined`; use
`ColumnTransform` as the sole function-compatible type.

[coderabbitai]

📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

toCamelTransform/toPascalTransform/toKebabTransform/toSnakeTransform are destructured but never used.

Only the from*Transform bindings are referenced (Lines 1067-1070, 1131-1134); the to*Transform aliases duplicate toCamel/toPascal/toKebab/toSnake and can be dropped from both this destructuring and the shared.ts export surface.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/bun/sql.ts` around lines 10 - 29, Remove the unused toCamelTransform,
toPascalTransform, toKebabTransform, and toSnakeTransform bindings from the
destructuring in sql.ts, and remove their corresponding exports from the
shared.ts export surface. Preserve the existing toCamel, toPascal, toKebab,
toSnake, and from*Transform APIs.

[coderabbitai]

🗄️ Data Integrity & Integration | 🟠 Major | 🏗️ Heavy lift

value.from only reaches helper-bound values, never plain interpolated parameters.

valFromTransform is consulted in the INSERT/IN/UPDATE helper branches, but ordinary interpolation still goes through adapter.bindParam(value, ...) (Line 597) untouched. So sql\insert into t ${sql(row)}`transforms values whilesql`update t set a = ${v}`` does not — the same logical write is transformed or not depending on syntax, which can persist inconsistent data.

Route the transform through the single bindParam boundary instead of per-helper branches.

The (adapter as any) cast here also hides connectionInfo from QueryNormalizationAdapter (previously noted).

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 442 - 444, Move value.from
handling to the shared bindParam boundary so both ordinary interpolated
parameters and INSERT/IN/UPDATE helper values use the same transformation path.
Update the relevant bindParam flow and remove the per-helper valFromTransform
handling to prevent syntax-dependent behavior. Expose connectionInfo on
QueryNormalizationAdapter and access it without the (adapter as any) cast.

[coderabbitai]

🗄️ Data Integrity & Integration | 🟠 Major | ⚡ Quick win

🧩 Analysis chain

🌐 Web query:

postgres.js transform column to from direction outgoing incoming column names

💡 Result:

In postgres.js, column name transformations are handled via the transform option in the connection configuration [1][2]. You can control how column names are mapped between your application code and the database by defining custom functions for the to and from directions within transform.column [1][3][4]. The transformation works as follows: - to: Defines the function to transform outgoing column names (e.g., from your application's naming convention, like camelCase, to the database's convention, like snake_case, in interpolated identifiers) [1][4]. - from: Defines the function to transform incoming column names (e.g., from the database's snake_case to your application's camelCase) [1][4]. Example Configuration: const sql = postgres({ transform: { column: { to: (column) => { /* logic to transform outgoing column name / }, from: (column) => { / logic to transform incoming column name */ } } } }) Important Notes: 1. Static SQL: Postgres.js does not rewrite static parts of template strings [1][4]. If you need transformations for identifiers, you must use the sql helper (e.g., ${sql('columnName')}) [1][2][4]. 2. Built-in Transformers: The library provides built-in helpers like postgres.camel, postgres.pascal, and postgres.kebab which perform two-way transformations by default [1][3]. If you only want to perform half of the transformation (e.g., only incoming from snake_case to camelCase), you can use specific functions like postgres.fromCamel [1][4]. 3. JSONB caveat: Be aware that column transformations applied via this feature may also affect keys within JSONB columns, as the library may apply the logic to result rows globally [5].

Citations:

• 1: https://github.com/porsager/postgres?tab=readme-ov-file
• 2: https://github.com/porsager/postgres/blob/master/README.md
• 3: https://registry.npmjs.org/postgres
• 4: https://deno.land/x/postgresjs@v3.3.5
• 5: Prevent transform to be applied to the content of an jsonb column porsager/postgres#983

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "Locate file and relevant symbols"
if [ -f src/js/internal/sql/shared.ts ]; then
  wc -l src/js/internal/sql/shared.ts
  ast-grep outline src/js/internal/sql/shared.ts --match parseTransform --view expanded || true
  ast-grep outline src/js/internal/sql/shared.ts --match applyResultTransform --view expanded || true
  ast-grep outline src/js/internal/sql/shared.ts --match normalizeQuery --view expanded || true
else
  echo "src/js/internal/sql/shared.ts not found"
  fd -i 'shared.ts' src/js/internal/sql 2>/dev/null || true
fi

echo
echo "Relevant parseTransform/applyResultTransform/normalizeQuery snippets"
rg -n "function parseTransform|parseTransform\\(|function applyResultTransform|applyResultTransform\\(|function normalizeQuery|normalizeQuery\\(" src/js/internal/sql/shared.ts || true

echo
echo "Read focused sections around parseTransform and call sites"
sed -n '2200,2345p' src/js/internal/sql/shared.ts
sed -n '2345,2465p' src/js/internal/sql/shared.ts
sed -n '2465,2620p' src/js/internal/sql/shared.ts

echo
echo "Search transform docs/options in repository"
rg -n "transform:|transform.column|postgres.camel|postgres.fromCamel|fromCamel|column names|column to|column from" src/js/internal sql README.md packages test -g '*{ts,js,mdjs,mdd,mdx,ts}' 2>/dev/null | head -n 200 || true

Repository: oven-sh/bun

Length of output: 28646

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "Inspect normalizeQuery relevant section"
sed -n '340,445p' src/js/internal/sql/shared.ts

echo
echo "Inspect shared.transform module/type docs and transform tests"
sed -n '200,260p' packages/bun-types/sql.d.ts
sed -n '35,215p' test/js/sql/sql-transform.test.ts
sed -n '2730,2815p' test/js/sql/sql.test.ts

echo
echo "Find parseTransform / colTo / colFrom usage around buildDefinedColumnsAndQuery"
sed -n '1440,1525p' src/js/internal/sql/shared.ts
sed -n '2090,2180p' src/js/internal/sql/shared.ts

echo
echo "Behavioral model: postgres.js semantics require outgoing to=id(input), from=id(result_key) -> Bun's parseTransform currently puts transform.column.to into result key transformation, and transform.column.from into normalizeQuery identifier generation"
python3 - <<'PY'
# Model the actual parser assignments and transformers used by the built-ins.
def parseTransform(transform):
    col_to = None
    col_from = None
    if isinstance(transform, dict) and transform.get("column"):
        col = transform["column"]
        if callable(col):
            col_to = col
            col_from = getattr(col, "from", None)
            col_to = getattr(col, "to", col_to)
        elif isinstance(col, dict):
            col_to = col.get("to")
            col_from = col.get("from")
    if not col_to and not col_from:
        return None
    # normalizeQuery uses the original stored col_to; applyResultTransform uses the returned result.column.to.
    return {"result": "column": {"to": col_to, "from": col_from}, "normalize": {"colTo": col_to}}

def to_snake(s):
    out = ""
    for c in s:
        if c.isupper():
            out += "_" + c.lower()
        else:
            out += c
    out = out.strip("_").lower()
    return out
def to_camel(s):
    return s[0].lower() + s[1:] if s else s

camel = lambda s: to_camel(s, *()) if True else None
# Use the explicit built-in functions from source lines 2228–2233:
camel_to = to_camel          # js -> db? no, buildIdentifier calls this directly via colTo in Bun
camel_from = to_snake

# Simulate postgres.js expected direction, as documented in search results:
# to = outgoing JS -> database; from = incoming database -> JS.
postgres_column = {
    "to": lambda c: f"<out:{c}>",
    "from": lambda c: f"<in:{c}>"
}

user = {"column": postgres_column}
p = parseTransform(user)
print("parseTransform column.from:", getattr(p["result"]["column"].get("from"), "__name__", p["result"]["column"]["from"] if p["result"]["column"]["from"] else None))
print("parseTransform column.to:", getattr(p["result"]["column"].get("to"), "__name__", p["result"]["column"]["to"] if p["result"]["column"]["to"] else None))
PY

Repository: oven-sh/bun

Length of output: 19348

---

🏁 Script executed:

#!/bin/bash
set -euo pipefail

echo "postgres.transform helper definitions from repository"
rg -n "toCamelTransform|fromCamelTransform|postgres.fromCamel|postgres.toCamel|postgres.camel|toPascalTransform|fromPascalTransform|toKebabTransform|fromKebabTransform" src/js/internal/sql packages/bun-types test/js/sql | head -n 120

echo
echo "Relevant sqlite adapter normalize helper usage"
sed -n '425,525p' src/js/internal/sql/shared.ts
sed -n '160,240p' test/js/sql/sql-transform.test.ts

echo
echo "Inspect SQL helper buildDefinedColumnsAndQuery implementation"
sed -n '180,230p' src/js/internal/sql/shared.ts
rg -n "buildDefinedColumnsAndQuery|sql\\(", src/js/internal/sql/shared.ts | head -n 80

Repository: oven-sh/bun

Length of output: 11577

---

Align column.to / column.from semantics with postgres.js

In postgres.js, transform.column.to maps outgoing JS names to database identifiers and transform.column.from maps incoming database column names to JS objects. Here colTo is used by result row transformation while colFrom is used for generated SQL identifiers, so a user’s postgres-compatible transform: { column: { to, from } } config can be silently swapped. Keep the built-in helpers working by compensating their assignments, but make parseTransform apply column.to and column.from in the documented directions.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 2276 - 2308, Update
parseTransform’s handling of transform.column so postgres.js semantics are
preserved: assign column.to to the direction used for generated SQL identifiers
(colFrom) and column.from to the direction used for result-row transformation
(colTo), including function metadata and object forms. Compensate the built-in
helper assignments as needed, while leaving value and row transformation
behavior unchanged.

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Memoization miss when the user transform legitimately returns undefined.

cached === undefined is used as the miss sentinel, so a user column.to returning undefined is re-invoked on every row and out[undefined] keys silently appear. Use cache.has(key) (or $Map intrinsic accessors) for the presence check.

♻️ Proposed fix

     colTo = (key: string) => {
-      let cached = cache.get(key);
-      if (cached === undefined) {
-        cached = rawColTo(key);
-        cache.set(key, cached);
-      }
-      return cached;
+      if (cache.$has(key)) return cache.$get(key)!;
+      const computed = rawColTo(key);
+      cache.$set(key, computed);
+      return computed;
     };

📝 Committable suggestion

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

Suggested change

	if (colTo) {
	const rawColTo = colTo;
	const cache = new Map<string, string>();
	colTo = (key: string) => {
	let cached = cache.get(key);
	if (cached === undefined) {
	cached = rawColTo(key);
	cache.set(key, cached);
	}
	return cached;
	};
	}
	return {
	column: colTo || colFrom ? { to: colTo, from: colFrom } : undefined,
	value: valTo || valFrom ? { to: valTo, from: valFrom } : undefined,
	row: rowFn,
	};
	}
	if (colTo) {
	const rawColTo = colTo;
	const cache = new Map<string, string>();
	colTo = (key: string) => {
	if (cache.$has(key)) return cache.$get(key)!;
	const computed = rawColTo(key);
	cache.$set(key, computed);
	return computed;
	};
	}
	return {
	column: colTo || colFrom ? { to: colTo, from: colFrom } : undefined,
	value: valTo || valFrom ? { to: valTo, from: valFrom } : undefined,
	row: rowFn,
	};
	}

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 2314 - 2332, Update the
memoization wrapper around colTo in the returned transform setup to distinguish
a missing cache entry from a cached undefined result by checking cache presence
with cache.has(key) before invoking rawColTo. Preserve undefined values in the
cache and prevent repeated user transform calls or unintended out[undefined]
keys.

[coderabbitai]

📐 Maintainability & Code Quality | 🟠 Major | ⚡ Quick win

applyResultTransform mutates rows in place but leaves result.columns untransformed and uses non-primordial globals.

Two points on this function:

1. The column-metadata gap flagged previously is unresolved — rows get transformed keys while result.columns / result.statement.columns keep database names.
2. Array.isArray, Object.keys, Buffer.isBuffer should be $isArray, $Object.keys, and the intrinsic-safe equivalents per this directory's conventions; Buffer is also resolved from the global here.

As per coding guidelines: "use $-prefixed intrinsics/private APIs such as $Array, $newArrayWithSize, $debug, and $assert".

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@src/js/internal/sql/shared.ts` around lines 2334 - 2378, Update
applyResultTransform so column metadata stays consistent with transformed row
keys: apply colTo to result.columns and result.statement.columns when present,
preserving the existing value and row transformations. Replace Array.isArray,
Object.keys, and Buffer.isBuffer in transformRowObj and result traversal with
this directory’s approved $-prefixed intrinsic/private equivalents, avoiding
global resolution.

Source: Coding guidelines

[coderabbitai]

🎯 Functional Correctness | 🟠 Major | ⚡ Quick win

Exercise every exported preset in both directions.

Integration tests omit postgres.kebab, all documented SQL.camel/pascal/kebab/snake aliases, and helper-key conversion for the non-camel presets. A broken export or inverse mapping can therefore ship without coverage. Add a parameterized result-and-helper matrix for both namespaces. As per coding guidelines: “Tests must cover the complete variant matrix, including … sibling entry points … [and] alternate modes.”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/js/sql/sql-transform.test.ts` around lines 42 - 152, Expand the
transform integration tests around the existing preset tests to parameterize
every exported preset in both namespaces: postgres and SQL, covering camel,
pascal, kebab, and snake aliases. Exercise result-column conversion in both
directions for each preset, including Unicode where applicable, and add matching
SQLHelper INSERT/UPDATE assertions for non-camel presets. Ensure the matrix
verifies each exported entry point and its inverse mapping.

Source: Coding guidelines

[coderabbitai]

🎯 Functional Correctness | 🟡 Minor | ⚡ Quick win

Assert the expected validation error.

Bare toThrow() also passes when construction fails for an unrelated reason. Assert that the error identifies transform and the rejected type. As per coding guidelines: “Every test assertion must be able to fail and assert the strongest invariant; avoid … bare toThrow().”

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@test/js/sql/sql-transform.test.ts` around lines 196 - 203, Strengthen the
assertion in “Throws error for invalid transform options type” by matching the
thrown validation error’s message, ensuring it identifies the transform option
and the rejected type. Keep the invalid transform setup unchanged while
replacing the bare toThrow assertion with a message-specific expectation.

Source: Coding guidelines

[Jarred-Sumner]

(This is Claude, working with Jarred on consolidating the open SQL PRs.)

@pjb3, thank you for picking up the Roadmap item: one transform option for every adapter, renaming both result columns and sql() helper keys, and case conversion in plain JS where the Roadmap note had it blocked on a C++ implementation. Sorry that no person reviewed it.

The feature is in #45304: new SQL({ transform: SQL.camel }), SQL.pascal, SQL.kebab, the six functions SQL.toCamel ... SQL.fromKebab, and transform: { column: fn | { from, to }, undefined: value }. Your diff was read line by line for the idea and the API, and the code was reimplemented, so here is what differs.

from and to follow postgres.js: from renames a name that comes from the database, to a name that goes to it. The PR applied column.to to results and column.from to helper keys, so a config copied from postgres.js would have done the reverse.

Columns are renamed once, when Bun learns the shape of a result (RowDescription, MySQL column definitions, SQLite prepare) and before the row structure is built. There is no pass over the rows in JS, and result.columns[i].name is the new name. The function must return the same name every time.

The casing rules are postgres.js's too: _private stays, USER_ID becomes USERID, a__b becomes a_b. The word splitter in the PR turns _private into private, and the way back then names a column that does not exist.

Not taken: snake / toSnake / fromSnake, transform.value and transform.row (so keys inside json / jsonb values are not renamed), the copies of the names on sql and as module exports (they are on SQL only), and the globalThis.$isArray fallback. Added: sql("userId") goes through to, and a wrong transform throws ERR_INVALID_ARG_TYPE.

test/js/sql/sql-transform.test.ts (the PR's file name, new content) runs on SQLite, PostgreSQL, MySQL and MariaDB; "is called once for a column of a result shape, not once for a row" pins the call count. docs/runtime/sql.mdx has "Column name transforms" and the Roadmap line is gone. #15087 (Bun.camelCase) is a separate request and stays as it is. You are credited in the description of #45304.