@typesql/kysely 0.0.3 → 0.0.4

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @typesql/kysely
 
+## 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

@@ -21,7 +21,7 @@ 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>
 ```
@@ -30,10 +30,11 @@ const rows = await query(db, q); // db: Kysely<DB> or a Transaction<DB>
 
 | Export | What it is |
 |---|---|
-| `createSql<DB, TM = DefaultTypeMap, Overrides = {}, Options = {}>()` | core's `createSql<FromKysely<DB, Overrides, Options>, TM>()` |
+| `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`, or 0) |
+| `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 |
 | `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 |
@@ -54,7 +55,7 @@ const same = createCoreSql<FromKysely<DB>, PgTypeMap>();
 `query` and `execute` send `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
+`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.
 
 ## How columns are converted
@@ -153,12 +154,22 @@ back to the database's snake_case names the way `CamelCasePlugin` does by defaul
 ```ts
 const sql = createSql<DB, DefaultTypeMap, {}, { camelCase: true }>();
 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,9 +1,10 @@
 import { CompiledQuery, type QueryResult } from "kysely";
-import type { Executor, Query, RowType } from "@typesql/core";
+import { type Executor, type Query, type RowType } from "@typesql/core";
 /**
  * What the helpers use 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(): {
@@ -11,11 +12,17 @@ export interface KyselyExecutor {
     };
 }
 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). */
+/**
+ * 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 {};
 //# 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,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"}

package/dist/client.js

@@ -1,19 +1,35 @@
 import { CompiledQuery } from "kysely";
+import { mapRows } 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. */
+/**
+ * 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);
+}
+/**
+ * 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) => (await run(db, text, values)).rows;
+    return async (text, values) => {
+        const result = await run(db, text, values);
+        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 result.rows;
+    return mapRows(q, result.rows);
 }
-/** Run a statement for its side effect and return the affected row count (`numAffectedRows`, or 0). */
+/**
+ * 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 async function execute(db, q) {
-    const result = await run(db, q.text, q.values);
-    return Number(result.numAffectedRows ?? 0n);
+    return rowCount(await run(db, q.text, q.values));
 }
 //# 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,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"}

package/dist/index.d.ts

@@ -12,7 +12,16 @@ export { query, execute, executor, type KyselyExecutor } from "./client.js";
  *   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.
+ * 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:
+ *
+ *   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";
+}): Sql<FromKysely<DB, Overrides, Options>, TM, "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>;
 //# 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,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"}

package/dist/index.js

@@ -2,17 +2,7 @@ import { createSql as createCoreSql } from "@typesql/core";
 import { executor } 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 function createSql(db, options) {
+    return createCoreSql(db && executor(db), 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,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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typesql/kysely",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "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.0.4"
   },
   "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,10 +1,11 @@
 import { CompiledQuery, type QueryResult } from "kysely";
-import type { Executor, Query, RowType } from "@typesql/core";
+import { mapRows, type Executor, type Query, type RowType } from "@typesql/core";
 
 /**
  * What the helpers use 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>> };
@@ -16,19 +17,35 @@ function run<R>(db: KyselyExecutor, text: string, values: readonly unknown[]): P
   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. */
+/**
+ * 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);
+}
+
+/**
+ * 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) => (await run<unknown>(db, text, values)).rows;
+  return async (text, values) => {
+    const result = await run<unknown>(db, text, values);
+    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<Q extends AnyQuery>(db: KyselyExecutor, q: Q): Promise<RowType<Q>[]> {
-  const result = await run<RowType<Q>>(db, q.text, q.values);
-  return result.rows;
+  const result = await run<unknown>(db, q.text, q.values);
+  return mapRows(q, result.rows);
 }
 
-/** Run a statement for its side effect and return the affected row count (`numAffectedRows`, or 0). */
+/**
+ * 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 async function execute(db: KyselyExecutor, q: AnyQuery): Promise<number> {
-  const result = await run<unknown>(db, q.text, q.values);
-  return Number(result.numAffectedRows ?? 0n);
+  return rowCount(await run<unknown>(db, q.text, q.values));
 }

package/src/index.ts

@@ -1,4 +1,4 @@
-import { createSql as createCoreSql, type DefaultTypeMap, type Sql } from "@typesql/core";
+import { createSql as createCoreSql, type DefaultTypeMap, type RowKeys, type Sql, type SqlOptions } from "@typesql/core";
 import { executor, type KyselyExecutor } from "./client.js";
 import type { FromKysely, KyselyOptions, KyselyOverrides } from "./from-kysely.js";
 
@@ -14,13 +14,23 @@ export { query, execute, executor, type KyselyExecutor } from "./client.js";
  *   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.
+ * 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:
+ *
+ *   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" },
+): Sql<FromKysely<DB, Overrides, Options>, TM, "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>;
+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" });
 }