qubu 0.3.4 → 0.4.0

package/dist/{types-Cec0xzo4.mjs → types-g-vVvj1B.mjs}

@@ -1,7 +1,8 @@
 import { s as resolveCastTarget } from "./json-CUZlv4HT.mjs";
 import { t as standardDialect } from "./standard-BTVYKh_F.mjs";
-import { c as makeExpression, l as makeSchemaExpression, p as fragment } from "./column-CXMxx8Hq.mjs";
-import { t as asValue } from "./value-BvilP0oz.mjs";
+import { C as fragment, v as makeExpression, y as makeSchemaExpression } from "./column-D-8OqGuV.mjs";
+import { a as columnResultValue } from "./column-LV7oGQde.mjs";
+import { t as asValue } from "./value-b6OFZXVS.mjs";
 //#region src/core/render.ts
 function render(query, options = {}) {
 	const dialect = isDialect(options) ? options : options.dialect ?? standardDialect();
@@ -51,7 +52,7 @@ function cast(expression, target) {
 		context.append(" AS ");
 		context.append(typeof target === "string" ? target : resolveCastTarget(context.dialect, target.castTarget));
 		context.append(")");
-	});
+	}, typeof target === "string" ? void 0 : columnResultValue(target));
 }
 /** Create a cast whose JS output and SQL result domain are declared up front. */
 function typedCast() {

package/dist/{value-BvilP0oz.mjs → value-b6OFZXVS.mjs}

@@ -1,4 +1,4 @@
-import { l as makeSchemaExpression, p as fragment } from "./column-CXMxx8Hq.mjs";
+import { C as fragment, y as makeSchemaExpression } from "./column-D-8OqGuV.mjs";
 //#region src/core/primitives/parameter.ts
 function parameter(_value) {
 	return fragment((context) => context.parameter(_value));

package/dist/vite/ambient.d.ts

@@ -133,41 +133,9 @@ declare global {
   const withCte: typeof import('qubu').withCte
   const uuid: typeof import('qubu').uuid
 
-  type ColumnDefinition<
-    TOutput = unknown,
-    TNullable extends boolean = false,
-    TInsert = TOutput,
-    TUpdate = TInsert,
-    THasDefault extends boolean = false,
-    TGenerated extends boolean = false,
-    TSqlType extends import('qubu').AnySqlType = import('qubu').SqlUnknown,
-    TStorage extends import('qubu').ColumnStorage | undefined = undefined,
-    TDefault extends import('qubu').ColumnDefault | undefined =
-      | import('qubu').ColumnDefault
-      | undefined,
-    TGeneratedColumn extends
-      | import('qubu').GeneratedColumnDescriptor
-      | undefined = import('qubu').GeneratedColumnDescriptor | undefined,
-    TIdentity extends import('qubu').IdentityDescriptor | undefined =
-      | import('qubu').IdentityDescriptor
-      | undefined,
-    TOnUpdate extends import('qubu').AnySchemaExpression | undefined =
-      | import('qubu').AnySchemaExpression
-      | undefined,
-  > = import('qubu').ColumnDefinition<
-    TOutput,
-    TNullable,
-    TInsert,
-    TUpdate,
-    THasDefault,
-    TGenerated,
-    TSqlType,
-    TStorage,
-    TDefault,
-    TGeneratedColumn,
-    TIdentity,
-    TOnUpdate
-  >
+  type ColumnDefinitionConfig = import('qubu').ColumnDefinitionConfig
+  type ColumnDefinition<TConfig extends ColumnDefinitionConfig = {}> =
+    import('qubu').ColumnDefinition<TConfig>
   type ColumnSqlType<T> = import('qubu').ColumnSqlType<T>
   type ColumnDefault = import('qubu').ColumnDefault
   type ColumnDefaultInput = import('qubu').ColumnDefaultInput
@@ -317,32 +285,16 @@ declare global {
   type StreamingTransactionalQueryAdapter =
     import('qubu').StreamingTransactionalQueryAdapter
   type RenderedQuery = import('qubu').RenderedQuery
-  type MutationQuery<
-    TRow extends object = Record<string, unknown>,
-    TKind extends import('qubu').MutationKind = import('qubu').MutationKind,
-    TMetadata = never,
-  > = import('qubu').MutationQuery<TRow, TKind, TMetadata>
-  type Query<
-    TRow extends object = import('qubu').Row,
-    TCardinality extends
-      import('qubu').QueryCardinality = import('qubu').QueryCardinality,
-    TMetadata = never,
-  > = import('qubu').Query<TRow, TCardinality, TMetadata>
-  type SelectQuery<
-    TRow extends object = Record<string, unknown>,
-    TCardinality extends
-      import('qubu').QueryCardinality = import('qubu').QueryCardinality,
-    TMetadata = never,
-  > = import('qubu').SelectQuery<TRow, TCardinality, TMetadata>
-  type Source<
-    TIdentity = unknown,
-    TRow extends object = Record<string, unknown>,
-    TMetadata = never,
-    TSqlTypes extends {
-      readonly [K in keyof TRow]: import('qubu').AnySqlType
-    } = { readonly [K in keyof TRow]: import('qubu').SqlUnknown },
-    TConstraints extends import('qubu').SourceConstraintsRecord = {},
-  > = import('qubu').Source<TIdentity, TRow, TMetadata, TSqlTypes, TConstraints>
+  type MutationQueryConfig = import('qubu').MutationQueryConfig
+  type MutationQuery<TConfig extends MutationQueryConfig = {}> =
+    import('qubu').MutationQuery<TConfig>
+  type QueryConfig = import('qubu').QueryConfig
+  type Query<TConfig extends QueryConfig = {}> = import('qubu').Query<TConfig>
+  type SelectQuery<TConfig extends QueryConfig = {}> =
+    import('qubu').SelectQuery<TConfig>
+  type SourceConfig = import('qubu').SourceConfig
+  type Source<TConfig extends SourceConfig = {}> =
+    import('qubu').Source<TConfig>
   type SourceConstraint = import('qubu').SourceConstraint
   type SourceConstraintsRecord = import('qubu').SourceConstraintsRecord
   type SourceIndexesRecord = import('qubu').SourceIndexesRecord

package/docs/dialects-and-execution.md

@@ -81,15 +81,16 @@ does not re-export concrete dialect constructors.
 
 ## The adapter owns the driver
 
-Qubu does not open connections, bind values for a particular client, or decode
-rows. An adapter receives an `ExecutionRequest` and returns an
-`ExecutionResult`. A `TransactionalQueryAdapter` can also pin one driver
-connection for a callback transaction:
+Qubu does not open connections or bind values for a particular client. An
+adapter receives an `ExecutionRequest` and returns driver-normalized object
+rows. Qubu then uses the query's result shape and the adapter's decoder policy
+to produce the typed `ExecutionResult`. A `TransactionalQueryAdapter` can also
+pin one driver connection for a callback transaction:
 
 ```ts
 import { qubu } from 'qubu'
 import { postgresDialect } from 'qubu/postgres'
-import type { ExecutionRequest, ExecutionResult, QueryAdapter } from 'qubu'
+import type { ExecutionRequest, QueryAdapter } from 'qubu'
 
 declare const driver: {
   query<TRow extends object>(
@@ -101,9 +102,9 @@ declare const driver: {
 
 const adapter: QueryAdapter = {
   dialect: postgresDialect(),
-  async execute<TRow extends object>(request: ExecutionRequest) {
+  async execute(request: ExecutionRequest) {
     const { statement, queryKind, signal } = request
-    const result = await driver.query<TRow>(
+    const result = await driver.query<Record<string, unknown>>(
       statement.text,
       statement.parameters,
       { signal }
@@ -115,11 +116,61 @@ const adapter: QueryAdapter = {
       result.rowCount !== null
         ? { affectedRows: result.rowCount }
         : {}),
-    } satisfies ExecutionResult<TRow>
+    }
   },
 }
 ```
 
+### Decode schema-aware result values
+
+Portable boolean, date, timestamp, and JSON columns retain their logical
+result domains through projection aliases, derived queries, CTEs, set
+operations, and mutation `RETURNING`. Register only the conversions required
+by the selected driver configuration:
+
+```ts
+import {
+  booleanResultDecoder,
+  dateResultDecoder,
+  jsonTextResultDecoder,
+  timestampResultDecoder,
+} from 'qubu'
+import type { AdapterExecutionResult, QueryAdapter, RenderedQuery } from 'qubu'
+import { sqliteDialect } from 'qubu/sqlite'
+
+declare const sqliteDriver: {
+  execute(statement: RenderedQuery): Promise<AdapterExecutionResult>
+}
+
+const adapter: QueryAdapter = {
+  dialect: sqliteDialect(),
+  decoders: {
+    boolean: booleanResultDecoder,
+    date: dateResultDecoder,
+    timestamp: timestampResultDecoder,
+    json: jsonTextResultDecoder,
+  },
+  async execute(request) {
+    return sqliteDriver.execute(request.statement)
+  },
+}
+```
+
+Do not register `jsonTextResultDecoder` when the driver already returns parsed
+JSON. A JSON string is otherwise ambiguous: it may be serialized JSON or an
+already-decoded JSON string scalar. With no registered decoder, Qubu preserves
+the driver's value.
+
+Use a column decoder for a custom stored type, or `mapResult()` for one
+expression. Both override adapter policy for that field:
+
+```ts
+import { column, mapResult, value } from 'qubu'
+
+const score = column<number>({ decode: value => Number(value) })
+const decodedTotal = mapResult(value('42'), value => Number(value))
+```
+
 ## Stream read results
 
 Add `StreamingQueryAdapter` when a driver can return rows through an
@@ -130,11 +181,7 @@ Mutations stay on `execute()` and `executeRows()`, including mutations with
 
 ```ts
 import { qubu } from 'qubu'
-import type {
-  ExecutionRequest,
-  ExecutionResult,
-  StreamingQueryAdapter,
-} from 'qubu'
+import type { ExecutionRequest, StreamingQueryAdapter } from 'qubu'
 import { postgresDialect } from 'qubu/postgres'
 
 declare const driver: {
@@ -152,8 +199,8 @@ declare const driver: {
 
 const adapter: StreamingQueryAdapter = {
   dialect: postgresDialect(),
-  async execute<TRow extends object>(request: ExecutionRequest) {
-    const result = await driver.query<TRow>(
+  async execute(request: ExecutionRequest) {
+    const result = await driver.query<Record<string, unknown>>(
       request.statement.text,
       request.statement.parameters,
       { signal: request.signal }
@@ -161,10 +208,10 @@ const adapter: StreamingQueryAdapter = {
     return {
       rows: result.rows,
       ...(result.rowCount === null ? {} : { affectedRows: result.rowCount }),
-    } satisfies ExecutionResult<TRow>
+    }
   },
-  stream<TRow extends object>(request: ExecutionRequest) {
-    return driver.stream<TRow>(
+  stream(request: ExecutionRequest) {
+    return driver.stream<Record<string, unknown>>(
       request.statement.text,
       request.statement.parameters,
       { signal: request.signal }
@@ -178,11 +225,11 @@ for await (const row of db.stream(readQuery)) {
 }
 ```
 
-Qubu renders the query before calling `stream()` and passes the selected
-dialect, ordered raw parameters, query kind, and optional `AbortSignal` in the
-same `ExecutionRequest` used by `execute()`. The adapter binds values, decodes
-rows, and returns the iterable. Qubu does not open a cursor or connection,
-iterate the result, buffer rows, or impose a fetch size.
+Qubu renders the query with the selected dialect before calling `stream()`. It
+passes ordered raw parameters, query kind, result shape, and the optional
+`AbortSignal` in the same `ExecutionRequest` used by `execute()`. The adapter
+binds values and returns the iterable. Qubu lazily decodes each row without
+opening a cursor or connection, buffering rows, or imposing a fetch size.
 
 The adapter owns the iterator's cleanup contract:
 
@@ -359,12 +406,12 @@ const result = await execute(query, adapter)
 const rows = await executeRows(readQuery, adapter)
 ```
 
-| Result field   | Type                         | Adapter contract                                                                      |
-| -------------- | ---------------------------- | ------------------------------------------------------------------------------------- |
-| `rows`         | `readonly TRow[]`            | Always present; use an empty array for a mutation without returned rows               |
-| `affectedRows` | `number \| bigint`           | Rows inserted, updated, or deleted when the driver reports an affected count          |
-| `changedRows`  | `number \| bigint`           | Rows whose stored values changed when the driver distinguishes them from matched rows |
-| `insertId`     | `string \| number \| bigint` | One insert identifier when the driver reports it                                      |
+| Result field   | Adapter type                         | Contract                                                                              |
+| -------------- | ------------------------------------ | ------------------------------------------------------------------------------------- |
+| `rows`         | `readonly Record<string, unknown>[]` | Key by rendered aliases; Qubu returns the decoded `readonly TRow[]`                   |
+| `affectedRows` | `number \| bigint`                   | Rows inserted, updated, or deleted when the driver reports an affected count          |
+| `changedRows`  | `number \| bigint`                   | Rows whose stored values changed when the driver distinguishes them from matched rows |
+| `insertId`     | `string \| number \| bigint`         | One insert identifier when the driver reports it                                      |
 
 The last three fields are optional. For example, an adapter can map PostgreSQL
 `rowCount`, MySQL `affectedRows`, `changedRows`, and `insertId`, or SQLite
@@ -373,9 +420,11 @@ report accurately. Qubu does not derive mutation metadata from returned rows.
 
 The adapter's `dialect` becomes the default for standalone and bound execution.
 A `dialect` in the execution options overrides that rendering policy. Qubu
-passes `signal` and the query's `queryKind` to the adapter without changing
+passes `signal`, `queryKind`, and `resultShape` to the adapter without changing
 them. The adapter decides whether and how its driver supports cancellation.
-Driver errors pass through unchanged.
+Driver errors pass through unchanged. Decoder failures become a
+`ResultDecodingError` that identifies the row and field without exposing the
+raw value.
 
 ```mermaid
 sequenceDiagram
@@ -386,11 +435,12 @@ sequenceDiagram
 
   App->>Qubu: db.execute(query, options)
   Qubu->>Qubu: render with selected dialect
-  Qubu->>Adapter: statement + queryKind + signal
+  Qubu->>Adapter: statement + queryKind + resultShape + signal
   Adapter->>Driver: bind and execute
   Driver-->>Adapter: driver result or error
-  Adapter-->>Qubu: typed rows + optional mutation facts
-  Qubu-->>App: result envelope or rows
+  Adapter-->>Qubu: normalized object rows + optional mutation facts
+  Qubu->>Qubu: apply field and adapter decoders
+  Qubu-->>App: typed result envelope or rows
 ```
 
 ## Create a small custom dialect

package/docs/guides/drizzle.md

@@ -68,6 +68,33 @@ const rows = await db
 Existing Qubu queries can keep importing `users`. Move call sites to
 `drizzleTables.users` one at a time without duplicating the table declaration.
 
+### Keep SQLite integer timestamps
+
+Use `sqliteTimestamp()` when an existing SQLite schema stores dates as integer
+Unix timestamps and Drizzle must continue reading and writing `Date` values:
+
+```ts
+import { schema, table } from 'qubu'
+import { sqliteTimestamp, toSqliteDrizzleSchema } from 'qubu/drizzle/sqlite'
+
+const events = table('events', {
+  createdAt: sqliteTimestamp({
+    mode: 'timestamp',
+    defaultFn: () => new Date(),
+  }),
+})
+
+const drizzleTables = toSqliteDrizzleSchema(schema({ events }))
+```
+
+`timestamp` stores Unix seconds and `timestamp_ms` stores Unix milliseconds.
+Both modes expose `Date` values through Drizzle. `defaultFn` runs when a
+Drizzle insert omits the column; it is runtime behavior and is not emitted as a
+database `DEFAULT` or serialized into a Qubu snapshot.
+
+Use Qubu's root `timestamp()` helper for portable schemas. SQLite stores that
+portable form as ISO text instead of an integer.
+
 ## Type behavior
 
 The converted columns preserve selected values, nullability, required insert

package/docs/reference/supported-surface.md

@@ -70,13 +70,13 @@ Snapshot creation, diffing, migration planning, and DDL emission are pure.
 interfaces the application provides. Qubu can emit DDL, but it never applies
 that DDL to a database.
 
-| Boundary                 | Qubu side                                                                                                                                                                                                                                                                                                                         | Application side                                                                                                                                                                                                                                                                |
-| ------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| Query rendering          | Builds a typed query and renders SQL text with ordered raw parameter values                                                                                                                                                                                                                                                       | Keeps the runtime database schema aligned with query definitions and validates any dynamic syntax passed to an unsafe helper                                                                                                                                                    |
-| Query execution          | Binds an adapter with `qubu()` when requested; renders and passes statements to `QueryAdapter`, `ExplainableQueryAdapter`, or a read-only `StreamingQueryAdapter`; scopes `db.transaction()` callbacks through `TransactionalQueryAdapter`; returns `ExecutionResult`, `ExplainResult`, rows, or an adapter-owned `AsyncIterable` | Owns the adapter, driver, connections, pools, cursors, stream cleanup, transaction begin/commit/rollback, savepoints, retries, parameter encoding, application-row and plan-row decoding, backpressure, cancellation behavior, driver error translation, and database lifecycle |
-| Catalog introspection    | Selects fixed parameterized catalog queries, normalizes rows, and maps catalog data to snapshots                                                                                                                                                                                                                                  | Supplies `CatalogConnection`, credentials, already-decoded catalog rows, logging, and connection lifecycle                                                                                                                                                                      |
-| Schema source generation | Prints deterministic TypeScript from complete, non-lossy Snapshot v1 introspection without writing files                                                                                                                                                                                                                          | Owns generated-file writes, replacement policy, hand-edit merging, and CLI integration                                                                                                                                                                                          |
-| Schema changes           | Creates snapshots, compares them, builds deterministic migration plans, and emits DDL from approved plans with preflight diagnostics                                                                                                                                                                                              | Reviews decisions, executes or rolls back statements, acquires locks, manages transactions and migration journals, and owns database lifecycle                                                                                                                                  |
+| Boundary                 | Qubu side                                                                                                                                                                                                                                                                      | Application side                                                                                                                                                                                                                                                             |
+| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| Query rendering          | Builds a typed query and renders SQL text with ordered raw parameter values                                                                                                                                                                                                    | Keeps the runtime database schema aligned with query definitions and validates any dynamic syntax passed to an unsafe helper                                                                                                                                                 |
+| Query execution          | Binds an adapter with `qubu()` when requested; passes rendered statements and result shapes to execution adapters; applies registered logical field decoders to buffered or streamed object rows; scopes transaction callbacks; returns typed results, plans, rows, or streams | Owns the adapter, driver, connections, pools, cursors, stream cleanup, transactions, savepoints, retries, parameter encoding, proprietary row normalization, decoder policy, plan-row decoding, backpressure, cancellation, driver error translation, and database lifecycle |
+| Catalog introspection    | Selects fixed parameterized catalog queries, normalizes rows, and maps catalog data to snapshots                                                                                                                                                                               | Supplies `CatalogConnection`, credentials, already-decoded catalog rows, logging, and connection lifecycle                                                                                                                                                                   |
+| Schema source generation | Prints deterministic TypeScript from complete, non-lossy Snapshot v1 introspection without writing files                                                                                                                                                                       | Owns generated-file writes, replacement policy, hand-edit merging, and CLI integration                                                                                                                                                                                       |
+| Schema changes           | Creates snapshots, compares them, builds deterministic migration plans, and emits DDL from approved plans with preflight diagnostics                                                                                                                                           | Reviews decisions, executes or rolls back statements, acquires locks, manages transactions and migration journals, and owns database lifecycle                                                                                                                               |
 
 Start with [Dialects and execution](../dialects-and-execution.md) for the query
 adapter contract. The schema path is documented in [Canonical schema

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "qubu",
-  "version": "0.3.4",
+  "version": "0.4.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/aleclarson/qubu"

package/dist/column-CXMxx8Hq.mjs

@@ -1,118 +0,0 @@
-import { a as assertDialectCapability } from "./json-CUZlv4HT.mjs";
-//#region src/core/fragment.ts
-function fragment(render) {
-	return Object.freeze({ render });
-}
-function sequence(parts, separator = " ") {
-	return fragment((context) => {
-		let first = true;
-		for (const part of parts) {
-			if (!first) context.append(separator);
-			context.render(part);
-			first = false;
-		}
-	});
-}
-function parenthesize(part) {
-	return fragment((context) => {
-		context.append("(");
-		context.render(part);
-		context.append(")");
-	});
-}
-function isFragment(value) {
-	return typeof value === "object" && value !== null && "render" in value && typeof value.render === "function";
-}
-//#endregion
-//#region src/expressions/types.ts
-/** Runtime/type-level proof that an expression is safe to use in schema SQL. */
-const schemaExpressionBrand = Symbol("qubu.schema-expression");
-/** Add a concrete dialect requirement without dropping expression metadata. */
-function withDialectCapability(expression, capability) {
-	const wrapped = makeExpression(expression.expressionKind, (context) => {
-		assertDialectCapability(context.dialect, capability);
-		context.render(expression);
-	});
-	return isSchemaExpression(expression) ? markSchemaExpression(wrapped) : wrapped;
-}
-function makeExpression(expressionKind, render, expressionCategory) {
-	return Object.freeze({
-		expressionKind,
-		...expressionCategory ? { expressionCategory } : {},
-		...fragment(render)
-	});
-}
-/** Mark a query-only expression category without changing its SQL renderer. */
-function markExpressionCategory(expression, category) {
-	return Object.freeze({
-		...expression,
-		expressionCategory: category
-	});
-}
-/**
-* Mark a built-in or explicitly audited renderer as schema-deterministic.
-* Prefer {@link defineSchemaExpression} for application extensions because it
-* supplies a restricted schema rendering context.
-*/
-function makeSchemaExpression(expressionKind, render) {
-	const expression = makeExpression(expressionKind, render);
-	return Object.freeze({
-		...expression,
-		[schemaExpressionBrand]: true
-	});
-}
-/** Add the schema-determinism brand to an explicitly audited expression. */
-function markSchemaExpression(expression) {
-	if (isSchemaExpression(expression)) return expression;
-	return Object.freeze({
-		...expression,
-		[schemaExpressionBrand]: true
-	});
-}
-/** Test the runtime brand used by schema rendering and validation. */
-function isSchemaExpression(value) {
-	return typeof value === "object" && value !== null && schemaExpressionBrand in value && value[schemaExpressionBrand] === true;
-}
-function isExpression(value) {
-	return typeof value === "object" && value !== null && "expressionKind" in value && "render" in value && typeof value.render === "function";
-}
-//#endregion
-//#region src/core/primitives/identifier.ts
-function identifier(name) {
-	return fragment((context) => context.append(context.dialect.quoteIdentifier(name)));
-}
-function qualifiedIdentifier(...parts) {
-	return fragment((context) => {
-		parts.forEach((part, index) => {
-			if (index > 0) context.append(".");
-			context.append(context.dialect.quoteIdentifier(part));
-		});
-	});
-}
-//#endregion
-//#region src/expressions/column.ts
-function createColumnReference(columnName, sourceReference, fieldName) {
-	const expression = makeSchemaExpression("column", (context) => {
-		if (context.renderColumnReference) {
-			context.renderColumnReference(columnName);
-			return;
-		}
-		context.render(sourceReference);
-		context.append(".");
-		context.render(identifier(columnName));
-	});
-	return Object.freeze({
-		...expression,
-		fieldName,
-		columnName
-	});
-}
-function isColumnReference(value) {
-	return typeof value === "object" && value !== null && "expressionKind" in value && value.expressionKind === "column";
-}
-/** Turn an expression into a fragment that renders it without changing it. */
-function expressionFragment(expression) {
-	return fragment((context) => context.render(expression));
-}
-//#endregion
-export { qualifiedIdentifier as a, makeExpression as c, markSchemaExpression as d, withDialectCapability as f, sequence as g, parenthesize as h, identifier as i, makeSchemaExpression as l, isFragment as m, expressionFragment as n, isExpression as o, fragment as p, isColumnReference as r, isSchemaExpression as s, createColumnReference as t, markExpressionCategory as u };

package/dist/naming-QVCOnSj2.mjs

@@ -1,20 +0,0 @@
-//#region src/core/naming.ts
-/** Convert an application-facing field name to a SQL-facing identifier. */
-function snakeCaseIdentifier(name) {
-	return name.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/[-\s]+/g, "_").toLowerCase();
-}
-function resolveSqlNames(fields) {
-	const sqlNames = {};
-	const fieldsBySqlName = /* @__PURE__ */ new Map();
-	for (const field of fields) {
-		const sqlName = field.sqlName ?? snakeCaseIdentifier(field.fieldName);
-		if (sqlName.length === 0) throw new Error(`SQL name for field "${field.fieldName}" cannot be empty`);
-		const existingField = fieldsBySqlName.get(sqlName);
-		if (existingField) throw new Error(`Fields "${existingField}" and "${field.fieldName}" both resolve to SQL name "${sqlName}"`);
-		fieldsBySqlName.set(sqlName, field.fieldName);
-		sqlNames[field.fieldName] = sqlName;
-	}
-	return Object.freeze(sqlNames);
-}
-//#endregion
-export { snakeCaseIdentifier as n, resolveSqlNames as t };