@typesql/kysely 0.0.4 → 0.1.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @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

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
@@ -23,18 +23,23 @@ const q = sql(
 );
 //    ^? 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 = {}>(db?, options?)` | core's `createSql<FromKysely<DB, Overrides, Options>, TM>()`; `{ rowKeys: "camelCase" }` gives `CamelCasePlugin`-style row keys |
-| `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`; for other statements the number of rows returned, 0 for DDL) |
-| `executor(db)` | an `Executor` for `q.execute()` and `q.executeCount()`, also bypassing plugins |
+| `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 |
@@ -48,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 (use `{ rowKeys: "camelCase" }` for camelCase rows). 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
 
@@ -104,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.
@@ -136,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
@@ -152,7 +158,7 @@ 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 | null]>
 ```

package/dist/client.d.ts

@@ -1,7 +1,7 @@
 import { CompiledQuery, type QueryResult } from "kysely";
-import { type Executor, type Query, type 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 (`createSql(db,
  * { rowKeys: "camelCase" })` renames the top-level keys instead, in the types too).
@@ -10,19 +10,16 @@ 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, 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 its row count: `numAffectedRows` for
- * INSERT/UPDATE/DELETE/MERGE, otherwise the number of rows returned (0 for DDL).
- */
-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,EAAW,KAAK,QAAQ,EAAE,KAAK,KAAK,EAAE,KAAK,OAAO,EAAE,MAAM,eAAe,CAAC;AAEjF;;;;;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;CACzF;AAED,KAAK,QAAQ,GAAG,KAAK,CAAC,OAAO,EAAE,SAAS,OAAO,EAAE,CAAC,CAAC;AAcnD;;;GAGG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,cAAc,GAAG,QAAQ,CAKrD;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;;;GAGG;AACH,wBAAsB,OAAO,CAAC,EAAE,EAAE,cAAc,EAAE,CAAC,EAAE,QAAQ,GAAG,OAAO,CAAC,MAAM,CAAC,CAE9E"}
+{"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,5 +1,5 @@
 import { CompiledQuery } from "kysely";
-import { mapRows } from "@typesql/core";
+import { runTransaction } from "@typesql/core";
 function run(db, text, values) {
     return db.withoutPlugins().executeQuery(CompiledQuery.raw(text, Array.from(values)));
 }
@@ -20,16 +20,15 @@ export function executor(db) {
         return { rows: result.rows, rowCount: rowCount(result) };
     };
 }
-/** 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 mapRows(q, result.rows);
-}
 /**
- * Run a statement for its side effect and return its row count: `numAffectedRows` for
- * INSERT/UPDATE/DELETE/MERGE, otherwise the number of rows returned (0 for DDL).
+ * Run `fn` inside `db.transaction().execute()`. A Kysely `Transaction` cannot start another one,
+ * so inside one `fn` runs in a savepoint.
  */
-export async function execute(db, q) {
-    return rowCount(await run(db, q.text, q.values));
+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,OAAO,EAAE,OAAO,EAA2C,MAAM,eAAe,CAAC;AAcjF,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,2GAA2G;AAC3G,MAAM,CAAC,KAAK,UAAU,KAAK,CAAqB,EAAkB,EAAE,CAAI;IACtE,MAAM,MAAM,GAAG,MAAM,GAAG,CAAU,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC;IACxD,OAAO,OAAO,CAAC,CAAC,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;AACjC,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAAC,EAAkB,EAAE,CAAW;IAC3D,OAAO,QAAQ,CAAC,MAAM,GAAG,CAAU,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAC5D,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,27 +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,
- * bypassing its plugins. `{ rowKeys: "camelCase" }` camelCases the rows' top-level keys as
- * `CamelCasePlugin` does, in the types and at runtime, without touching JSON values:
+ * 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 | undefined, options: {
     readonly rowKeys: "camelCase";
-}): Sql<FromKysely<DB, Overrides, Options>, TM, "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";
-}): Sql<FromKysely<DB, Overrides, Options>, TM>;
+}): 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,EAAgB,KAAK,GAAG,EAAmB,MAAM,eAAe,CAAC;AACzH,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;;;;;;;;;;;;;GAaG;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,GAAG,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,EAAE,WAAW,CAAC,CAAC;AAC5D,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,GAAG,CAAC,UAAU,CAAC,EAAE,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,CAAC"}
+{"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,8 +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";
+export { executor } from "./client.js";
 export function createSql(db, options) {
-    return createCoreSql(db && executor(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,EAAgE,MAAM,eAAe,CAAC;AACzH,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;AAwB5E,MAAM,UAAU,SAAS,CACvB,EAAmB,EACnB,OAAoB;IAEpB,OAAO,aAAa,CAAyC,EAAE,IAAI,QAAQ,CAAC,EAAE,CAAC,EAAE,OAA4C,CAAC,CAAC;AACjI,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.4",
+  "version": "0.1.0",
   "description": "Use Kysely database interfaces (kysely-codegen, prisma-kysely) as a typesql schema.",
   "license": "MIT",
   "repository": {
@@ -28,7 +28,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@typesql/core": "0.0.4"
+    "@typesql/core": "0.1.0"
   },
   "peerDependencies": {
     "kysely": ">=0.27"

package/src/client.ts

@@ -1,18 +1,18 @@
 import { CompiledQuery, type QueryResult } from "kysely";
-import { mapRows, type Executor, type Query, type 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 (`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>);
 }
@@ -36,16 +36,14 @@ export function executor(db: KyselyExecutor): Executor {
   };
 }
 
-/** 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<unknown>(db, q.text, q.values);
-  return mapRows(q, result.rows);
-}
-
 /**
- * Run a statement for its side effect and return its row count: `numAffectedRows` for
- * INSERT/UPDATE/DELETE/MERGE, otherwise the number of rows returned (0 for DDL).
+ * Run `fn` inside `db.transaction().execute()`. A Kysely `Transaction` cannot start another one,
+ * so inside one `fn` runs in a savepoint.
  */
-export async function execute(db: KyselyExecutor, q: AnyQuery): Promise<number> {
-  return rowCount(await run<unknown>(db, q.text, q.values));
+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,36 +1,41 @@
-import { createSql as createCoreSql, type DefaultTypeMap, type RowKeys, type Sql, type SqlOptions } 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>();
- *   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,
- * bypassing its plugins. `{ rowKeys: "camelCase" }` camelCases the rows' top-level keys as
- * `CamelCasePlugin` does, in the types and at runtime, without touching JSON values:
+ * 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 function createSql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}>(
   db: KyselyExecutor | undefined,
   options: { readonly rowKeys: "camelCase" },
-): Sql<FromKysely<DB, Overrides, Options>, TM, "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" },
-): Sql<FromKysely<DB, Overrides, Options>, TM>;
+): KyselySql<DB, TM, Overrides, Options>;
 export function createSql<DB, TM = DefaultTypeMap, Overrides extends KyselyOverrides = {}, Options extends KyselyOptions = {}>(
   db?: KyselyExecutor,
   options?: SqlOptions,
-): Sql<FromKysely<DB, Overrides, Options>, TM, RowKeys> {
-  return createCoreSql<FromKysely<DB, Overrides, Options>, TM>(db && executor(db), options as { readonly rowKeys: "camelCase" });
+): KyselySql<DB, TM, Overrides, Options, RowKeys> {
+  return createTransactionalSql<FromKysely<DB, Overrides, Options>, TM, KyselyExecutor>(db, driver, options);
 }