@typesql/kysely 0.0.3 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,31 @@
 # @typesql/kysely
 
+## 0.1.0
+
+### Minor Changes
+
+- Queries run from the `sql` bound to your client: `createSql<DB>(client)` then `sql("…").execute()` (or `executeTakeFirst`, `executeTakeFirstOrThrow`, `executeCount`), and `sql.transaction(async (tx) => …)` for transactions, nested with savepoints; the `query`, `one`, `maybeOne`, `many`, `execute`, `transaction` and `RowCountError` exports of `@typesql/pg` and `@typesql/postgres`, `query` and `execute` of `@typesql/kysely`, and `queryRaw` and `executeRaw` of `@typesql/prisma` are removed.
+
+### Patch Changes
+
+- Updated dependencies:
+  - @typesql/core@0.1.0
+
+## 0.0.4
+
+### Patch Changes
+
+- Queries have `executeCount()`, which resolves to the affected row count: an `Executor` may resolve to `{ rows, rowCount }` instead of the rows, as the `executor()` of `@typesql/pg`, `@typesql/postgres` and `@typesql/kysely` now do.
+
+- `createSql(executor, { rowKeys: "camelCase" })` (and the adapters' `createSql(client, { rowKeys: "camelCase" })`) camelCases the top-level row keys the way Kysely's `CamelCasePlugin` does, in the row types and in the rows `execute*` and the `query`/`one`/`maybeOne`/`many` helpers return, leaving JSON values untouched.
+
+- `execute(db, q)` returns the number of rows for statements Kysely reports no `numAffectedRows` for (`SELECT`), as `@typesql/pg` does, instead of 0.
+
+- Parameters accept `null` wherever Postgres does: comparisons (`col = $1`, `IN`, `ANY`, `LIKE`), `LIMIT`/`OFFSET`, casts in comparisons and function arguments (`coalesce($1::text, 'x')`), and array elements (`(number | null)[]`); assigning `null` to a `NOT NULL` column is still an error.
+
+- Updated dependencies:
+  - @typesql/core@0.0.4
+
 ## 0.0.3
 
 ### Patch Changes

package/README.md

@@ -10,10 +10,10 @@ pnpm add @typesql/core @typesql/kysely kysely
 ```
 
 ```ts
-import { createSql, query } from "@typesql/kysely";
+import { createSql } from "@typesql/kysely";
 import type { DB } from "./db"; // kysely-codegen output
 
-const sql = createSql<DB>();
+const sql = createSql<DB>(db); // db: your Kysely<DB> instance, or a Transaction<DB>
 
 const q = sql(
   `SELECT u.id, u.email, p.title, p.views
@@ -21,19 +21,25 @@ const q = sql(
     WHERE u.id = $1 AND p.published = $2`,
   1, true,
 );
-//    ^? Query<{ id: number; email: string; title: string; views: string }, [number, boolean]>
+//    ^? Query<{ id: number; email: string; title: string; views: string }, [number | null, boolean | null]>
 
-const rows = await query(db, q); // db: Kysely<DB> or a Transaction<DB>
+const rows = await q.execute();
+
+await sql.transaction(async (tx) => {
+  await tx("UPDATE posts SET published = true WHERE author_id = $1", 1).execute();
+});
 ```
 
 ## API
 
 | Export | What it is |
 |---|---|
-| `createSql<DB, TM = DefaultTypeMap, Overrides = {}, Options = {}>()` | core's `createSql<FromKysely<DB, Overrides, Options>, TM>()` |
-| `FromKysely<DB, Overrides = {}, Options = {}>` | the converted schema type, for use with core's `createSql<Schema, TM>()` or the adapters' `createSql<Schema>()` |
-| `query(db, q)` | runs a typesql `Query` through Kysely, `Promise<Row[]>` |
-| `execute(db, q)` | runs a statement, `Promise<number>` (`numAffectedRows`, or 0) |
+| `createSql<DB, TM = DefaultTypeMap, Overrides = {}, Options = {}>(db, options?)` | core's `createSql<FromKysely<DB, Overrides, Options>, TM>()` with the queries running on `db`; `{ rowKeys: "camelCase" }` gives `CamelCasePlugin`-style row keys |
+| `q.execute()`, `q.executeTakeFirst()`, `q.executeTakeFirstOrThrow()`, `q.executeCount()` | `Promise<Row[]>`, `Promise<Row \| undefined>`, `Promise<Row>` (`NoResultError` on 0 rows), `Promise<number>` (`numAffectedRows`; for other statements the number of rows returned, 0 for DDL) |
+| `sql.transaction(fn)` | `db.transaction().execute(...)` with `tx` bound to the transaction; on a `Transaction`, and for `tx.transaction(fn)`, a savepoint |
+| `FromKysely<DB, Overrides = {}, Options = {}>` | the converted schema type, for use with core's `createSql<Schema, TM>()` or the adapters' `createSql<Schema>(client)` |
+| `KyselySql<DB, TM, Overrides, Options, Keys>` | the type `createSql` returns |
+| `executor(db)` | an `Executor` for `q.execute(executor)` and core's `createSql(executor)`, also bypassing plugins |
 | `InferColumn<T>` | the descriptor inferred for one Kysely column type (handy to check a mapping) |
 | `SnakeCase<S>` | `CamelCasePlugin`'s default camelCase → snake_case mapping, at the type level |
 | `KyselyOverrides`, `TableOverride`, `ColumnOverride`, `KyselyOptions`, `KyselyExecutor` | parameter types |
@@ -47,15 +53,16 @@ import type { PgTypeMap } from "@typesql/pg";
 import { createSql, type FromKysely } from "@typesql/kysely";
 import { createSql as createCoreSql } from "@typesql/core";
 
-const sql = createSql<DB, PgTypeMap>();
-const same = createCoreSql<FromKysely<DB>, PgTypeMap>();
+const sql = createSql<DB, PgTypeMap>(db);
+const same = createCoreSql<FromKysely<DB>, PgTypeMap>(); // types only, no client
 ```
 
-`query` and `execute` send `CompiledQuery.raw(q.text, q.values)` through
+Queries are sent as `CompiledQuery.raw(q.text, q.values)` through
 `db.withoutPlugins().executeQuery(...)`. Plugins are bypassed on purpose: typesql's row types
 describe what Postgres returns (`created_at`), and a result transformer such as
-`CamelCasePlugin` would rename the keys. Logging, the dialect and the connection pool are
-unaffected. Any `sql(...)` result can also be run with `@typesql/pg` directly on the pool.
+`CamelCasePlugin` would rename the keys (use `{ rowKeys: "camelCase" }` for camelCase rows).
+Logging, the dialect and the connection pool are unaffected. Inside a Kysely transaction,
+`createSql<DB>(trx)` binds a `sql` to it, so builder and SQL queries share the transaction.
 
 ## How columns are converted
 
@@ -103,7 +110,7 @@ const sql = createSql<DB, DefaultTypeMap, {
   "auth.users": { id: "uuid" };
   active_users: { $view: true };                   // a view: INSERT/UPDATE/DELETE are rejected
   $types: { mood: Mood; "auth.role": AuthRole };   // enum names, see below
-}>();
+}>(db);
 ```
 
 A descriptor may set any of `type`, `nullable` and `hasDefault`; the others stay inferred.
@@ -135,7 +142,7 @@ under `$types` and every column whose values are **exactly** that union gets the
 ```ts
 import type { Mood, AuthRole } from "./db"; // kysely-codegen exports one alias per enum
 
-createSql<DB, DefaultTypeMap, { $types: { mood: Mood; "auth.role": AuthRole } }>();
+createSql<DB, DefaultTypeMap, { $types: { mood: Mood; "auth.role": AuthRole } }>(db);
 ```
 
 If two `$types` entries have the same values the column keeps its derived name; set the column's
@@ -151,14 +158,24 @@ back to the database's snake_case names the way `CamelCasePlugin` does by defaul
 `created_at`, `userID` → `user_id`), so the SQL you write and the rows you get use the real names:
 
 ```ts
-const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>();
+const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>(db);
 const q = sql("SELECT author_id, created_at FROM blog_posts WHERE id = $1", 1);
-//    ^? Query<{ author_id: number; created_at: Date }, [number]>
+//    ^? Query<{ author_id: number; created_at: Date }, [number | null]>
 ```
 
 Overrides still use the interface's (camelCase) keys. The plugin's non-default options
 (`upperCase`, `underscoreBeforeDigits`, `underscoreBetweenUppercaseLetters`) are not modelled.
 
+For camelCase **rows**, add `{ rowKeys: "camelCase" }`. The top-level keys are renamed with
+`CamelCasePlugin`'s default snake_case → camelCase mapping, in the row types and at runtime.
+The plugin itself stays bypassed, so keys inside JSON values are left alone:
+
+```ts
+const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>(db, { rowKeys: "camelCase" });
+const post = await sql("SELECT author_id, created_at FROM blog_posts WHERE id = $1", 1).executeTakeFirstOrThrow();
+//    ^? { authorId: number; createdAt: Date }
+```
+
 ## Limitations
 
 - **The TS → Postgres mapping is lossy.** `number`, `string` and `Date` each stand for several

package/dist/client.d.ts

@@ -1,21 +1,25 @@
 import { CompiledQuery, type QueryResult } from "kysely";
-import type { Executor, Query, RowType } from "@typesql/core";
+import { type Executor, type SqlDriver } from "@typesql/core";
 /**
- * What the helpers use from a `Kysely<DB>` or `Transaction<DB>`. Queries run through
+ * What the adapter uses from a `Kysely<DB>` or `Transaction<DB>`. Queries run through
  * `withoutPlugins()`: typesql's row types describe what the driver returns, so result
- * transformers such as `CamelCasePlugin` must not rename the columns.
+ * transformers such as `CamelCasePlugin` must not rename the columns (`createSql(db,
+ * { rowKeys: "camelCase" })` renames the top-level keys instead, in the types too).
  */
 export interface KyselyExecutor {
     withoutPlugins(): {
         executeQuery<R>(query: CompiledQuery<R>): Promise<QueryResult<R>>;
     };
+    transaction(): {
+        execute<T>(fn: (trx: KyselyExecutor) => Promise<T>): Promise<T>;
+    };
+    readonly isTransaction: boolean;
 }
-type AnyQuery = Query<unknown, readonly unknown[]>;
-/** An `Executor` for core's `q.execute()`: runs queries on a Kysely instance (or transaction), without its plugins. */
+/**
+ * An `Executor` for core's `q.execute()`: runs queries on a Kysely instance (or transaction),
+ * without its plugins, and resolves to `{ rows, rowCount }` so `q.executeCount()` works.
+ */
 export declare function executor(db: KyselyExecutor): Executor;
-/** Run a typesql query on a Kysely instance (or transaction) and return its rows, typed from the query. */
-export declare function query<Q extends AnyQuery>(db: KyselyExecutor, q: Q): Promise<RowType<Q>[]>;
-/** Run a statement for its side effect and return the affected row count (`numAffectedRows`, or 0). */
-export declare function execute(db: KyselyExecutor, q: AnyQuery): Promise<number>;
-export {};
+/** How `createSql(db)` runs queries and transactions. */
+export declare const driver: SqlDriver<KyselyExecutor>;
 //# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AACzD,OAAO,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAE9D;;;;GAIG;AACH,MAAM,WAAW,cAAc;IAC7B,cAAc,IAAI;QAAE,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC;CACzF;AAED,KAAK,QAAQ,GAAG,KAAK,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC;AAMnD,uHAAuH;AACvH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,cAAc,GAAG,QAAQ,CAErD;AAED,2GAA2G;AAC3G,wBAAsB,KAAK,CAAC,CAAC,SAAS,QAAQ,EAAE,EAAE,EAAE,cAAc,EAAE,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,CAAC,CAG/F;AAED,uGAAuG;AACvG,wBAAsB,OAAO,CAAC,EAAE,EAAE,cAAc,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAG9E"}
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,KAAK,WAAW,EAAE,MAAM,QAAQ,CAAC;AACzD,OAAO,EAAkB,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAC;AAE9E;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,cAAc,IAAI;QAAE,YAAY,CAAC,CAAC,EAAE,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC;IACxF,WAAW,IAAI;QAAE,OAAO,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,cAAc,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC;IACnF,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;CACjC;AAcD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,cAAc,GAAG,QAAQ,CAKrD;AAWD,yDAAyD;AACzD,eAAO,MAAM,MAAM,EAAE,SAAS,CAAC,cAAc,CAA6B,CAAC"}

package/dist/client.js

@@ -1,19 +1,34 @@
 import { CompiledQuery } from "kysely";
+import { runTransaction } from "@typesql/core";
 function run(db, text, values) {
     return db.withoutPlugins().executeQuery(CompiledQuery.raw(text, Array.from(values)));
 }
-/** An `Executor` for core's `q.execute()`: runs queries on a Kysely instance (or transaction), without its plugins. */
-export function executor(db) {
-    return async (text, values) => (await run(db, text, values)).rows;
+/**
+ * Kysely reports `numAffectedRows` for INSERT/UPDATE/DELETE/MERGE only; for other statements the
+ * count is the rows returned (SELECT), or 0 (DDL), as Postgres' command tag says.
+ */
+function rowCount(result) {
+    return result.numAffectedRows === undefined ? result.rows.length : Number(result.numAffectedRows);
 }
-/** Run a typesql query on a Kysely instance (or transaction) and return its rows, typed from the query. */
-export async function query(db, q) {
-    const result = await run(db, q.text, q.values);
-    return result.rows;
+/**
+ * An `Executor` for core's `q.execute()`: runs queries on a Kysely instance (or transaction),
+ * without its plugins, and resolves to `{ rows, rowCount }` so `q.executeCount()` works.
+ */
+export function executor(db) {
+    return async (text, values) => {
+        const result = await run(db, text, values);
+        return { rows: result.rows, rowCount: rowCount(result) };
+    };
 }
-/** Run a statement for its side effect and return the affected row count (`numAffectedRows`, or 0). */
-export async function execute(db, q) {
-    const result = await run(db, q.text, q.values);
-    return Number(result.numAffectedRows ?? 0n);
+/**
+ * Run `fn` inside `db.transaction().execute()`. A Kysely `Transaction` cannot start another one,
+ * so inside one `fn` runs in a savepoint.
+ */
+function transaction(db, depth, fn) {
+    if (!db.isTransaction)
+        return db.transaction().execute(fn);
+    return runTransaction((statement) => run(db, statement, []), () => fn(db), { savepoint: `typesql_${depth + 1}` });
 }
+/** How `createSql(db)` runs queries and transactions. */
+export const driver = { executor, transaction };
 //# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -1 +1 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAoB,MAAM,QAAQ,CAAC;AAczD,SAAS,GAAG,CAAI,EAAkB,EAAE,IAAY,EAAE,MAA0B;IAC1E,OAAO,EAAE,CAAC,cAAc,EAAE,CAAC,YAAY,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAqB,CAAC,CAAC;AAC3G,CAAC;AAED,uHAAuH;AACvH,MAAM,UAAU,QAAQ,CAAC,EAAkB;IACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,CAAC,CAAC,MAAM,GAAG,CAAU,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC;AAC7E,CAAC;AAED,2GAA2G;AAC3G,MAAM,CAAC,KAAK,UAAU,KAAK,CAAqB,EAAkB,EAAE,CAAI;IACtE,MAAM,MAAM,GAAG,MAAM,GAAG,CAAa,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IAC3D,OAAO,MAAM,CAAC,IAAI,CAAC;AACrB,CAAC;AAED,uGAAuG;AACvG,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,EAAkB,EAAE,CAAW;IAC3D,MAAM,MAAM,GAAG,MAAM,GAAG,CAAU,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IACxD,OAAO,MAAM,CAAC,MAAM,CAAC,eAAe,IAAI,EAAE,CAAC,CAAC;AAC9C,CAAC"}
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAoB,MAAM,QAAQ,CAAC;AACzD,OAAO,EAAE,cAAc,EAAiC,MAAM,eAAe,CAAC;AAc9E,SAAS,GAAG,CAAI,EAAkB,EAAE,IAAY,EAAE,MAA0B;IAC1E,OAAO,EAAE,CAAC,cAAc,EAAE,CAAC,YAAY,CAAC,aAAa,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAqB,CAAC,CAAC;AAC3G,CAAC;AAED;;;GAGG;AACH,SAAS,QAAQ,CAAC,MAA4B;IAC5C,OAAO,MAAM,CAAC,eAAe,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,CAAC;AACpG,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAkB;IACzC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;QAC5B,MAAM,MAAM,GAAG,MAAM,GAAG,CAAU,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC;QACpD,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,CAAC;IAC3D,CAAC,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,WAAW,CAAI,EAAkB,EAAE,KAAa,EAAE,EAAuC;IAChG,IAAI,CAAC,EAAE,CAAC,aAAa;QAAE,OAAO,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC,CAAC;IAC3D,OAAO,cAAc,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,GAAG,CAAC,EAAE,EAAE,SAAS,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,SAAS,EAAE,WAAW,KAAK,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC;AACpH,CAAC;AAED,yDAAyD;AACzD,MAAM,CAAC,MAAM,MAAM,GAA8B,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC"}

package/dist/index.d.ts

@@ -1,18 +1,30 @@
-import { type DefaultTypeMap, type Sql } from "@typesql/core";
+import { type DefaultTypeMap, type RowKeys, type TransactionalSql } from "@typesql/core";
 import { type KyselyExecutor } from "./client.js";
 import type { FromKysely, KyselyOptions, KyselyOverrides } from "./from-kysely.js";
-export { NoResultError, type Executor } from "@typesql/core";
+export { NoResultError, type Executor, type TransactionalSql } from "@typesql/core";
 export type { FromKysely, KyselyOverrides, KyselyOptions, TableOverride, ColumnOverride, InferColumn, SnakeCase } from "./from-kysely.js";
-export { query, execute, executor, type KyselyExecutor } from "./client.js";
+export { executor, type KyselyExecutor } from "./client.js";
+/** What `createSql<DB>(db)` returns: core's `Sql` over `FromKysely<DB, ...>`, with `transaction(fn)`. */
+export type KyselySql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}, Keys extends RowKeys = "preserve"> = TransactionalSql<FromKysely<DB, Overrides, Options>, TM, Keys>;
 /**
  * `createSql` from core with a Kysely `DB` interface as the schema:
- * `createSql<DB>()` is `createSql<FromKysely<DB>, DefaultTypeMap>()`.
+ * `createSql<DB>(db)` is `createSql<FromKysely<DB>, DefaultTypeMap>()` bound to `db`.
  *
- *   const sql = createSql<DB>();
- *   const sql = createSql<DB, PgTypeMap, { users: { id: "int8" } }>();
- *   const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>();
+ *   const sql = createSql<DB>(db);
+ *   const sql = createSql<DB, PgTypeMap, { users: { id: "int8" } }>(db);
+ *   const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>(db);
  *
- * With a `db` (a `Kysely` instance or transaction), the queries' `execute*` methods run on it.
+ * The queries' `execute*` methods run on `db` (a `Kysely` instance or transaction), bypassing
+ * its plugins, and `sql.transaction(fn)` runs `fn` with a `sql` bound to one transaction.
+ * `{ rowKeys: "camelCase" }` camelCases the rows' top-level keys as `CamelCasePlugin` does, in
+ * the types and at runtime, without touching JSON values:
+ *
+ *   const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>(db, { rowKeys: "camelCase" });
  */
-export declare function createSql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}>(db?: KyselyExecutor): Sql<FromKysely<DB, Overrides, Options>, TM>;
+export declare function createSql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}>(db: KyselyExecutor | undefined, options: {
+    readonly rowKeys: "camelCase";
+}): KyselySql<DB, TM, Overrides, Options, "camelCase">;
+export declare function createSql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}>(db?: KyselyExecutor, options?: {
+    readonly rowKeys?: "preserve";
+}): KyselySql<DB, TM, Overrides, Options>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAA8B,KAAK,cAAc,EAAE,KAAK,GAAG,EAAE,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAY,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAC5D,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnF,OAAO,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAC;AAC7D,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC1I,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAE5E;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CACvB,EAAE,EACF,EAAE,GAAG,cAAc,EACnB,SAAS,SAAS,eAAe,GAAG,EAAE,EACtC,OAAO,SAAS,aAAa,GAAG,EAAE,EAClC,EAAE,CAAC,EAAE,cAAc,GAAG,GAAG,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAElE"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,cAAc,EAAE,KAAK,OAAO,EAAmB,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAClI,OAAO,EAAU,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAEnF,OAAO,EAAE,aAAa,EAAE,KAAK,QAAQ,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACpF,YAAY,EAAE,UAAU,EAAE,eAAe,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC1I,OAAO,EAAE,QAAQ,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAC;AAE5D,yGAAyG;AACzG,MAAM,MAAM,SAAS,CAAC,EAAE,EAAE,EAAE,GAAG,cAAc,EAAE,SAAS,SAAS,eAAe,GAAG,EAAE,EAAE,OAAO,SAAS,aAAa,GAAG,EAAE,EAAE,IAAI,SAAS,OAAO,GAAG,UAAU,IAC1J,gBAAgB,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,IAAI,CAAC,CAAC;AAEjE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,GAAG,cAAc,EAAE,SAAS,SAAS,eAAe,GAAG,EAAE,EAAE,OAAO,SAAS,aAAa,GAAG,EAAE,EAC3H,EAAE,EAAE,cAAc,GAAG,SAAS,EAC9B,OAAO,EAAE;IAAE,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAA;CAAE,GACzC,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,WAAW,CAAC,CAAC;AACtD,wBAAgB,SAAS,CAAC,EAAE,EAAE,EAAE,GAAG,cAAc,EAAE,SAAS,SAAS,eAAe,GAAG,EAAE,EAAE,OAAO,SAAS,aAAa,GAAG,EAAE,EAC3H,EAAE,CAAC,EAAE,cAAc,EACnB,OAAO,CAAC,EAAE;IAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,UAAU,CAAA;CAAE,GAC1C,SAAS,CAAC,EAAE,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC"}

package/dist/index.js

@@ -1,18 +1,8 @@
-import { createSql as createCoreSql } from "@typesql/core";
-import { executor } from "./client.js";
+import { createTransactionalSql } from "@typesql/core";
+import { driver } from "./client.js";
 export { NoResultError } from "@typesql/core";
-export { query, execute, executor } from "./client.js";
-/**
- * `createSql` from core with a Kysely `DB` interface as the schema:
- * `createSql<DB>()` is `createSql<FromKysely<DB>, DefaultTypeMap>()`.
- *
- *   const sql = createSql<DB>();
- *   const sql = createSql<DB, PgTypeMap, { users: { id: "int8" } }>();
- *   const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>();
- *
- * With a `db` (a `Kysely` instance or transaction), the queries' `execute*` methods run on it.
- */
-export function createSql(db) {
-    return createCoreSql(db && executor(db));
+export { executor } from "./client.js";
+export function createSql(db, options) {
+    return createTransactionalSql(db, driver, options);
 }
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,IAAI,aAAa,EAAiC,MAAM,eAAe,CAAC;AAC1F,OAAO,EAAE,QAAQ,EAAuB,MAAM,aAAa,CAAC;AAG5D,OAAO,EAAE,aAAa,EAAiB,MAAM,eAAe,CAAC;AAE7D,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAuB,MAAM,aAAa,CAAC;AAE5E;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS,CAKvB,EAAmB;IACnB,OAAO,aAAa,CAAyC,EAAE,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC;AACnF,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAA6E,MAAM,eAAe,CAAC;AAClI,OAAO,EAAE,MAAM,EAAuB,MAAM,aAAa,CAAC;AAG1D,OAAO,EAAE,aAAa,EAAwC,MAAM,eAAe,CAAC;AAEpF,OAAO,EAAE,QAAQ,EAAuB,MAAM,aAAa,CAAC;AA6B5D,MAAM,UAAU,SAAS,CACvB,EAAmB,EACnB,OAAoB;IAEpB,OAAO,sBAAsB,CAAyD,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAC7G,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typesql/kysely",
-  "version": "0.0.3",
+  "version": "0.1.0",
   "description": "Use Kysely database interfaces (kysely-codegen, prisma-kysely) as a typesql schema.",
   "license": "MIT",
   "repository": {
@@ -28,13 +28,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@typesql/core": "0.0.3"
+    "@typesql/core": "0.1.0"
   },
   "peerDependencies": {
     "kysely": ">=0.27"
   },
   "devDependencies": {
+    "@types/pg": "^8.23.1",
     "kysely": "^0.29.6",
+    "pg": "^8.23.1",
     "typescript": "7.0.2",
     "vitest": "^5.0.4"
   },

package/src/client.ts

@@ -1,34 +1,49 @@
 import { CompiledQuery, type QueryResult } from "kysely";
-import type { Executor, Query, RowType } from "@typesql/core";
+import { runTransaction, type Executor, type SqlDriver } from "@typesql/core";
 
 /**
- * What the helpers use from a `Kysely<DB>` or `Transaction<DB>`. Queries run through
+ * What the adapter uses from a `Kysely<DB>` or `Transaction<DB>`. Queries run through
  * `withoutPlugins()`: typesql's row types describe what the driver returns, so result
- * transformers such as `CamelCasePlugin` must not rename the columns.
+ * transformers such as `CamelCasePlugin` must not rename the columns (`createSql(db,
+ * { rowKeys: "camelCase" })` renames the top-level keys instead, in the types too).
  */
 export interface KyselyExecutor {
   withoutPlugins(): { executeQuery<R>(query: CompiledQuery<R>): Promise<QueryResult<R>> };
+  transaction(): { execute<T>(fn: (trx: KyselyExecutor) => Promise<T>): Promise<T> };
+  readonly isTransaction: boolean;
 }
 
-type AnyQuery = Query<unknown, readonly unknown[]>;
-
 function run<R>(db: KyselyExecutor, text: string, values: readonly unknown[]): Promise<QueryResult<R>> {
   return db.withoutPlugins().executeQuery(CompiledQuery.raw(text, Array.from(values)) as CompiledQuery<R>);
 }
 
-/** An `Executor` for core's `q.execute()`: runs queries on a Kysely instance (or transaction), without its plugins. */
-export function executor(db: KyselyExecutor): Executor {
-  return async (text, values) => (await run<unknown>(db, text, values)).rows;
+/**
+ * Kysely reports `numAffectedRows` for INSERT/UPDATE/DELETE/MERGE only; for other statements the
+ * count is the rows returned (SELECT), or 0 (DDL), as Postgres' command tag says.
+ */
+function rowCount(result: QueryResult<unknown>): number {
+  return result.numAffectedRows === undefined ? result.rows.length : Number(result.numAffectedRows);
 }
 
-/** Run a typesql query on a Kysely instance (or transaction) and return its rows, typed from the query. */
-export async function query<Q extends AnyQuery>(db: KyselyExecutor, q: Q): Promise<RowType<Q>[]> {
-  const result = await run<RowType<Q>>(db, q.text, q.values);
-  return result.rows;
+/**
+ * An `Executor` for core's `q.execute()`: runs queries on a Kysely instance (or transaction),
+ * without its plugins, and resolves to `{ rows, rowCount }` so `q.executeCount()` works.
+ */
+export function executor(db: KyselyExecutor): Executor {
+  return async (text, values) => {
+    const result = await run<unknown>(db, text, values);
+    return { rows: result.rows, rowCount: rowCount(result) };
+  };
 }
 
-/** Run a statement for its side effect and return the affected row count (`numAffectedRows`, or 0). */
-export async function execute(db: KyselyExecutor, q: AnyQuery): Promise<number> {
-  const result = await run<unknown>(db, q.text, q.values);
-  return Number(result.numAffectedRows ?? 0n);
+/**
+ * Run `fn` inside `db.transaction().execute()`. A Kysely `Transaction` cannot start another one,
+ * so inside one `fn` runs in a savepoint.
+ */
+function transaction<T>(db: KyselyExecutor, depth: number, fn: (trx: KyselyExecutor) => Promise<T>): Promise<T> {
+  if (!db.isTransaction) return db.transaction().execute(fn);
+  return runTransaction((statement) => run(db, statement, []), () => fn(db), { savepoint: `typesql_${depth + 1}` });
 }
+
+/** How `createSql(db)` runs queries and transactions. */
+export const driver: SqlDriver<KyselyExecutor> = { executor, transaction };

package/src/index.ts

@@ -1,26 +1,41 @@
-import { createSql as createCoreSql, type DefaultTypeMap, type Sql } from "@typesql/core";
-import { executor, type KyselyExecutor } from "./client.js";
+import { createTransactionalSql, type DefaultTypeMap, type RowKeys, type SqlOptions, type TransactionalSql } from "@typesql/core";
+import { driver, type KyselyExecutor } from "./client.js";
 import type { FromKysely, KyselyOptions, KyselyOverrides } from "./from-kysely.js";
 
-export { NoResultError, type Executor } from "@typesql/core";
+export { NoResultError, type Executor, type TransactionalSql } from "@typesql/core";
 export type { FromKysely, KyselyOverrides, KyselyOptions, TableOverride, ColumnOverride, InferColumn, SnakeCase } from "./from-kysely.js";
-export { query, execute, executor, type KyselyExecutor } from "./client.js";
+export { executor, type KyselyExecutor } from "./client.js";
+
+/** What `createSql<DB>(db)` returns: core's `Sql` over `FromKysely<DB, ...>`, with `transaction(fn)`. */
+export type KyselySql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}, Keys extends RowKeys = "preserve"> =
+  TransactionalSql<FromKysely<DB, Overrides, Options>, TM, Keys>;
 
 /**
  * `createSql` from core with a Kysely `DB` interface as the schema:
- * `createSql<DB>()` is `createSql<FromKysely<DB>, DefaultTypeMap>()`.
+ * `createSql<DB>(db)` is `createSql<FromKysely<DB>, DefaultTypeMap>()` bound to `db`.
+ *
+ *   const sql = createSql<DB>(db);
+ *   const sql = createSql<DB, PgTypeMap, { users: { id: "int8" } }>(db);
+ *   const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>(db);
  *
- *   const sql = createSql<DB>();
- *   const sql = createSql<DB, PgTypeMap, { users: { id: "int8" } }>();
- *   const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>();
+ * The queries' `execute*` methods run on `db` (a `Kysely` instance or transaction), bypassing
+ * its plugins, and `sql.transaction(fn)` runs `fn` with a `sql` bound to one transaction.
+ * `{ rowKeys: "camelCase" }` camelCases the rows' top-level keys as `CamelCasePlugin` does, in
+ * the types and at runtime, without touching JSON values:
  *
- * With a `db` (a `Kysely` instance or transaction), the queries' `execute*` methods run on it.
+ *   const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>(db, { rowKeys: "camelCase" });
  */
-export function createSql<
-  DB,
-  TM = DefaultTypeMap,
-  Overrides extends KyselyOverrides = {},
-  Options extends KyselyOptions = {},
->(db?: KyselyExecutor): Sql<FromKysely<DB, Overrides, Options>, TM> {
-  return createCoreSql<FromKysely<DB, Overrides, Options>, TM>(db && executor(db));
+export function createSql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}>(
+  db: KyselyExecutor | undefined,
+  options: { readonly rowKeys: "camelCase" },
+): KyselySql<DB, TM, Overrides, Options, "camelCase">;
+export function createSql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}>(
+  db?: KyselyExecutor,
+  options?: { readonly rowKeys?: "preserve" },
+): KyselySql<DB, TM, Overrides, Options>;
+export function createSql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}>(
+  db?: KyselyExecutor,
+  options?: SqlOptions,
+): KyselySql<DB, TM, Overrides, Options, RowKeys> {
+  return createTransactionalSql<FromKysely<DB, Overrides, Options>, TM, KyselyExecutor>(db, driver, options);
 }