@typesql/drizzle 0.0.4 → 0.1.1

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @typesql/drizzle
 
+## 0.1.1
+
+### Patch Changes
+
+- Docs, package descriptions and error messages spell the project name TypeSQL.
+
+- Updated dependencies:
+  - @typesql/core@0.1.1
+
+## 0.1.0
+
+### Minor Changes
+
+- `createSql<typeof schema>(db)` takes a Drizzle database or transaction on node-postgres or postgres.js instead of an `Executor`, runs the queries on its driver client, and has `sql.transaction(fn)`, which runs in `db.transaction`.
+
+### Patch Changes
+
+- Updated dependencies:
+  - @typesql/core@0.1.0
+
 ## 0.0.4
 
 ### Patch Changes

package/README.md

@@ -1,6 +1,6 @@
 # @typesql/drizzle
 
-Use your Drizzle ORM schema as a typesql schema. `FromDrizzle<typeof schema>` turns
+Use your Drizzle ORM schema as a TypeSQL schema. `FromDrizzle<typeof schema>` turns
 `pgTable`, `pgView`, `pgMaterializedView`, `pgEnum` and `pgSchema` definitions into the
 `DB` type that `createSql` expects, entirely at the type level: no code generation, and the
 SQL you write is checked against the same tables Drizzle manages.
@@ -9,7 +9,8 @@ SQL you write is checked against the same tables Drizzle manages.
 npm install @typesql/drizzle @typesql/core
 ```
 
-`drizzle-orm` (0.45 or later) is a peer dependency.
+`drizzle-orm` (0.45 or later) is a peer dependency. Queries run on node-postgres or postgres.js
+databases.
 
 ## Usage
 
@@ -39,10 +40,13 @@ export const usersRelations = relations(users, ({ many }) => ({ posts: many(post
 
 ```ts
 // db.ts
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
 import { createSql } from "@typesql/drizzle";
-import type * as schema from "./schema";
+import * as schema from "./schema";
 
-const sql = createSql<typeof schema>();
+const db = drizzle(new Pool(), { schema });
+const sql = createSql<typeof schema>(db);
 
 const q = sql(
   "SELECT u.email, u.display_name, p.title FROM users u JOIN posts p ON p.author_id = u.id WHERE u.mood = $1",
@@ -50,23 +54,58 @@ const q = sql(
 );
 // Query<{ email: string; display_name: string | null; title: string }, ["happy" | "sad"]>
 
-sql("INSERT INTO posts (author_id, title) VALUES ($1, $2) RETURNING id, created_at", 1, "Hello");
+const post = await sql("INSERT INTO posts (author_id, title) VALUES ($1, $2) RETURNING id, created_at", 1, "Hello").executeTakeFirstOrThrow();
 // id and created_at have defaults, so they can be left out
+
+await sql.transaction(async (tx) => {
+  await tx("UPDATE posts SET title = upper(title) WHERE author_id = $1", 1).execute();
+});
 ```
 
 Queries use SQL names: `display_name`, not `displayName`. Relations and any other
 non-table exports are ignored, so `typeof schema` can be passed as is.
 
-`createSql<Schema, TypeMap, Options>()` uses core's `DefaultTypeMap` unless you pass
-another one. To pair the schema with a driver adapter, convert it with `FromDrizzle` and use
-the adapter's `createSql`:
+`createSql<Schema, TypeMap, Options>(db)` uses core's `DefaultTypeMap` unless you pass
+another one, such as `PgTypeMap` from `@typesql/pg` for node-postgres' exact types:
+`createSql<typeof schema, PgTypeMap>(db)`.
+
+## Running queries
+
+`db` is a Drizzle database on node-postgres or postgres.js (`drizzle-orm/node-postgres`,
+`drizzle-orm/postgres-js`), or a transaction from `db.transaction(fn)`. Queries run on the
+driver client Drizzle holds: the `Pool`, `Client` or postgres.js `sql` you gave `drizzle()`, or
+the transaction's connection. Rows are what the driver returns; Drizzle's column mappers and
+its logger are not involved.
+
+| | |
+|---|---|
+| `q.execute()`, `q.executeTakeFirst()`, `q.executeTakeFirstOrThrow()`, `q.executeCount()` | `Promise<Row[]>`, `Promise<Row \| undefined>`, `Promise<Row>` (`NoResultError` on 0 rows), `Promise<number>` (the driver's row count) |
+| `sql.transaction(fn)` | `db.transaction(fn)` with `tx` bound to the transaction; `tx.transaction(fn)` is Drizzle's nested transaction (a savepoint) |
+| `executor(db)` | an `Executor` for `q.execute(executor)` and core's `createSql(executor)` |
+| `DrizzleSql<Schema, TM, Options>`, `DrizzleDatabase` | the type `createSql` returns, and what it accepts |
+
+To mix ORM and SQL queries in one transaction, bind a `sql` to Drizzle's `tx`:
+
+```ts
+await db.transaction(async (tx) => {
+  await tx.insert(schema.users).values({ email: "a@b.c" });
+  await createSql<typeof schema>(tx)("UPDATE users SET mood = 'happy' WHERE email = $1", "a@b.c").execute();
+});
+```
+
+`drizzle-orm/postgres-js` turns off postgres.js' date parsers on the client it is given, so on
+that driver `date`, `timestamp`, `timestamptz` and `interval` come back as strings: pass a type
+map that says so.
+
+To pair the schema with a driver adapter instead, convert it with `FromDrizzle` and use the
+adapter's `createSql` on the same pool:
 
 ```ts
 import { createSql } from "@typesql/pg";
 import type { FromDrizzle } from "@typesql/drizzle";
 import type * as schema from "./schema";
 
-const sql = createSql<FromDrizzle<typeof schema>>();
+const sql = createSql<FromDrizzle<typeof schema>>(pool);
 ```
 
 `FromDrizzle` also accepts a single table (`FromDrizzle<typeof users>`) or a record of
@@ -74,7 +113,7 @@ tables (`FromDrizzle<{ users: typeof users; posts: typeof posts }>`).
 
 ## What gets converted
 
-| Drizzle | typesql |
+| Drizzle | TypeSQL |
 |---|---|
 | `pgTable("users", …)` | `DB["users"]`, keyed by the SQL table name, not the export name |
 | `displayName: text("display_name")` | column `display_name`; columns without an explicit name use the key |
@@ -89,7 +128,7 @@ tables (`FromDrizzle<{ users: typeof users; posts: typeof posts }>`).
 ## Column types
 
 The Postgres type comes from Drizzle's column kind. Drizzle's `mode` options change the JS
-value Drizzle produces, but typesql queries go straight to the driver, so the row type comes
+value Drizzle produces, but TypeSQL queries go straight to the driver, so the row type comes
 from the type map: `bigint({ mode: "number" })` is `int8`, a `string` under node-postgres.
 
 | Drizzle | Postgres |
@@ -118,7 +157,7 @@ from the type map: `bigint({ mode: "number" })` is `int8`, a `string` under node
 | `customType(…)` | `unknown`, unless pinned with `pgType` |
 | `.array()`, `.array().array()` | `T[]`, `T[][]` |
 
-Types typesql has no TS mapping for (`geometry`, `vector`, …) read as `unknown` unless your
+Types TypeSQL has no TS mapping for (`geometry`, `vector`, …) read as `unknown` unless your
 type map has an entry for them.
 
 ### `timestamp` with time zone, and other types Drizzle's types do not record
@@ -129,7 +168,7 @@ type maps, but `timestamp` and `timestamptz` behave differently in SQL (`AT TIME
 `date_trunc`, comparisons with `now()`). Either set the default for all of them:
 
 ```ts
-createSql<typeof schema, DefaultTypeMap, { timestamp: "timestamptz"; time: "timetz" }>();
+createSql<typeof schema, DefaultTypeMap, { timestamp: "timestamptz"; time: "timetz" }>(db);
 // or: FromDrizzle<typeof schema, { timestamp: "timestamptz" }>
 ```
 
@@ -163,14 +202,14 @@ If you create Drizzle with `drizzle(client, { casing: "snake_case" })`, pass the
 setting so column names match what Drizzle sends to Postgres:
 
 ```ts
-createSql<typeof schema, DefaultTypeMap, { casing: "snake_case" }>();
+createSql<typeof schema, DefaultTypeMap, { casing: "snake_case" }>(db);
 // createdAt: timestamp() → column created_at
 ```
 
 ## Limitations
 
 - **Generated-always columns** (`generatedAlwaysAs`, `generatedAlwaysAsIdentity`) are treated
-  as columns with a default. typesql has no read-only columns, so an `INSERT` that sets one
+  as columns with a default. TypeSQL has no read-only columns, so an `INSERT` that sets one
   type-checks but fails in Postgres (unless `OVERRIDING SYSTEM VALUE` for identities).
 - **`$onUpdate` / `$onUpdateFn`** mark the column as having a default in Drizzle's types, with
   no way to tell them from a SQL default, so such a column is optional in `INSERT` even

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+import type { Executor, SqlDriver } from "@typesql/core";
+/**
+ * What the adapter uses from a Drizzle database (`drizzle(client)` from `drizzle-orm/node-postgres`,
+ * `drizzle-orm/postgres-js`, ...) or a transaction from `db.transaction(fn)`.
+ */
+export interface DrizzleDatabase {
+    readonly _: {
+        readonly session: object;
+    };
+    transaction<T>(fn: (tx: DrizzleDatabase) => Promise<T>): Promise<T>;
+}
+/**
+ * An `Executor` for core's `q.execute()`: runs queries on the driver client under `db`, so rows
+ * come back as the driver parses them (Drizzle's column mappers are not involved), and resolves to
+ * `{ rows, rowCount }` so `q.executeCount()` works.
+ */
+export declare function executor(db: DrizzleDatabase): Executor;
+/** How `createSql(db)` runs queries and transactions. */
+export declare const driver: SqlDriver<DrizzleDatabase>;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEzD;;;GAGG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,CAAC,EAAE;QAAE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,WAAW,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,EAAE,eAAe,KAAK,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACrE;AAmBD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,EAAE,EAAE,eAAe,GAAG,QAAQ,CAUtD;AAOD,yDAAyD;AACzD,eAAO,MAAM,MAAM,EAAE,SAAS,CAAC,eAAe,CAA6B,CAAC"}

package/dist/client.js

@@ -0,0 +1,34 @@
+/**
+ * The driver client under `db`: the `Pool`, `Client` or postgres.js `sql` given to `drizzle()`,
+ * or, inside `db.transaction(fn)`, the connection the transaction runs on. Drizzle keeps it as
+ * `session.client`.
+ */
+function clientOf(db) {
+    const client = db._.session.client;
+    if (client && (typeof client.unsafe === "function" || typeof client.query === "function"))
+        return client;
+    throw new Error("typesql: createSql(db) needs a Drizzle database on node-postgres or postgres.js (its session client has no query or unsafe method)");
+}
+/**
+ * An `Executor` for core's `q.execute()`: runs queries on the driver client under `db`, so rows
+ * come back as the driver parses them (Drizzle's column mappers are not involved), and resolves to
+ * `{ rows, rowCount }` so `q.executeCount()` works.
+ */
+export function executor(db) {
+    return async (text, values) => {
+        const client = clientOf(db);
+        if (client.unsafe) {
+            const result = (await client.unsafe(text, Array.from(values)));
+            return { rows: Array.from(result), rowCount: result.count ?? null };
+        }
+        const result = (await client.query(text, Array.from(values)));
+        return { rows: result.rows, rowCount: result.rowCount ?? null };
+    };
+}
+/** Run `fn` inside `db.transaction(fn)`; Drizzle nests a transaction inside one with a savepoint. */
+function transaction(db, _depth, fn) {
+    return db.transaction(fn);
+}
+/** How `createSql(db)` runs queries and transactions. */
+export const driver = { executor, transaction };
+//# sourceMappingURL=client.js.map

package/dist/client.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.js","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,SAAS,QAAQ,CAAC,EAAmB;IACnC,MAAM,MAAM,GAAI,EAAE,CAAC,CAAC,CAAC,OAA8C,CAAC,MAAM,CAAC;IAC3E,IAAI,MAAM,IAAI,CAAC,OAAO,MAAM,CAAC,MAAM,KAAK,UAAU,IAAI,OAAO,MAAM,CAAC,KAAK,KAAK,UAAU,CAAC;QAAE,OAAO,MAAM,CAAC;IACzG,MAAM,IAAI,KAAK,CAAC,oIAAoI,CAAC,CAAC;AACxJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,QAAQ,CAAC,EAAmB;IAC1C,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;QAC5B,MAAM,MAAM,GAAG,QAAQ,CAAC,EAAE,CAAC,CAAC;QAC5B,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;YAClB,MAAM,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAmD,CAAC;YACjH,OAAO,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,MAAM,CAAC,KAAK,IAAI,IAAI,EAAE,CAAC;QACtE,CAAC;QACD,MAAM,MAAM,GAAG,CAAC,MAAM,MAAM,CAAC,KAAM,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,CAAkD,CAAC;QAChH,OAAO,EAAE,IAAI,EAAE,MAAM,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI,EAAE,CAAC;IAClE,CAAC,CAAC;AACJ,CAAC;AAED,qGAAqG;AACrG,SAAS,WAAW,CAAI,EAAmB,EAAE,MAAc,EAAE,EAAuC;IAClG,OAAO,EAAE,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;AAC5B,CAAC;AAED,yDAAyD;AACzD,MAAM,CAAC,MAAM,MAAM,GAA+B,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC"}

package/dist/from-drizzle.d.ts

@@ -150,7 +150,7 @@ type Flat<T> = {
     [K in keyof T]: T[K];
 } & {};
 /**
- * A typesql schema from Drizzle `pg-core` definitions: `FromDrizzle<typeof schema>` with
+ * A TypeSQL schema from Drizzle `pg-core` definitions: `FromDrizzle<typeof schema>` with
  * `import * as schema from "./schema"`. Also accepts a record of tables or a single table.
  *
  * Keys are SQL names (tables, columns, `pgSchema` namespaces); views become `View<…>`;

package/dist/index.d.ts

@@ -1,14 +1,18 @@
-import { type DefaultTypeMap, type Executor, type Sql } from "@typesql/core";
+import { type DefaultTypeMap, type TransactionalSql } from "@typesql/core";
+import { type DrizzleDatabase } from "./client.js";
 import type { FromDrizzle, FromDrizzleOptions } from "./from-drizzle.js";
 export type { FromDrizzle, FromDrizzleOptions, DrizzleColumnTypes } from "./from-drizzle.js";
 export { pgType } from "./pg-type.js";
-export type { Sql, Query, RowType, ParamsType, DefaultTypeMap, TypeMap, Executor } from "@typesql/core";
+export { executor, type DrizzleDatabase } from "./client.js";
+export type { Sql, Query, RowType, ParamsType, DefaultTypeMap, TypeMap, Executor, TransactionalSql } from "@typesql/core";
 export { NoResultError } from "@typesql/core";
+/** What `createSql<typeof schema>(db)` returns: core's `Sql` over `FromDrizzle<Schema, Opts>`, with `transaction(fn)`. */
+export type DrizzleSql<Schema, TM = DefaultTypeMap, Opts extends FromDrizzleOptions = {}> = TransactionalSql<FromDrizzle<Schema, Opts>, TM>;
 /**
  * `createSql` from core with the schema converted from Drizzle definitions:
- * `createSql<typeof schema>()`, or `createSql<typeof schema, PgTypeMap>()` for a driver's type map.
- * With an `executor` from a driver adapter (`executor(pool)` from `@typesql/pg`), the queries'
- * `execute*` methods run on it.
+ * `createSql<typeof schema>(db)`, or `createSql<typeof schema, PgTypeMap>(db)` for a driver's type map.
+ * The queries' `execute*` methods run on `db` (a Drizzle database or transaction, on node-postgres
+ * or postgres.js), and `sql.transaction(fn)` runs `fn` with a `sql` bound to `db.transaction`.
  */
-export declare function createSql<Schema, TM = DefaultTypeMap, Opts extends FromDrizzleOptions = {}>(executor?: Executor): Sql<FromDrizzle<Schema, Opts>, TM>;
+export declare function createSql<Schema, TM = DefaultTypeMap, Opts extends FromDrizzleOptions = {}>(db?: DrizzleDatabase): DrizzleSql<Schema, TM, Opts>;
 //# 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,QAAQ,EAAE,KAAK,GAAG,EAAE,MAAM,eAAe,CAAC;AACzG,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC7F,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,YAAY,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACxG,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,EAAE,GAAG,cAAc,EAAE,IAAI,SAAS,kBAAkB,GAAG,EAAE,EAAE,QAAQ,CAAC,EAAE,QAAQ,GAAG,GAAG,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAEpJ"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAA0B,KAAK,cAAc,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAC;AACnG,OAAO,EAAU,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAC3D,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEzE,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAC7F,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAE,KAAK,eAAe,EAAE,MAAM,aAAa,CAAC;AAC7D,YAAY,EAAE,GAAG,EAAE,KAAK,EAAE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,OAAO,EAAE,QAAQ,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAC;AAC1H,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C,0HAA0H;AAC1H,MAAM,MAAM,UAAU,CAAC,MAAM,EAAE,EAAE,GAAG,cAAc,EAAE,IAAI,SAAS,kBAAkB,GAAG,EAAE,IAAI,gBAAgB,CAAC,WAAW,CAAC,MAAM,EAAE,IAAI,CAAC,EAAE,EAAE,CAAC,CAAC;AAE5I;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,EAAE,GAAG,cAAc,EAAE,IAAI,SAAS,kBAAkB,GAAG,EAAE,EAAE,EAAE,CAAC,EAAE,eAAe,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,IAAI,CAAC,CAE/I"}

package/dist/index.js

@@ -1,13 +1,15 @@
-import { createSql as createCoreSql } from "@typesql/core";
+import { createTransactionalSql } from "@typesql/core";
+import { driver } from "./client.js";
 export { pgType } from "./pg-type.js";
+export { executor } from "./client.js";
 export { NoResultError } from "@typesql/core";
 /**
  * `createSql` from core with the schema converted from Drizzle definitions:
- * `createSql<typeof schema>()`, or `createSql<typeof schema, PgTypeMap>()` for a driver's type map.
- * With an `executor` from a driver adapter (`executor(pool)` from `@typesql/pg`), the queries'
- * `execute*` methods run on it.
+ * `createSql<typeof schema>(db)`, or `createSql<typeof schema, PgTypeMap>(db)` for a driver's type map.
+ * The queries' `execute*` methods run on `db` (a Drizzle database or transaction, on node-postgres
+ * or postgres.js), and `sql.transaction(fn)` runs `fn` with a `sql` bound to `db.transaction`.
  */
-export function createSql(executor) {
-    return createCoreSql(executor);
+export function createSql(db) {
+    return createTransactionalSql(db, driver);
 }
 //# 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,EAAgD,MAAM,eAAe,CAAC;AAIzG,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9C;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAoE,QAAmB;IAC9G,OAAO,aAAa,CAAgC,QAAQ,CAAC,CAAC;AAChE,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAA8C,MAAM,eAAe,CAAC;AACnG,OAAO,EAAE,MAAM,EAAwB,MAAM,aAAa,CAAC;AAI3D,OAAO,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AACtC,OAAO,EAAE,QAAQ,EAAwB,MAAM,aAAa,CAAC;AAE7D,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAK9C;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAoE,EAAoB;IAC/G,OAAO,sBAAsB,CAAiD,EAAE,EAAE,MAAM,CAAiC,CAAC;AAC5H,CAAC"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@typesql/drizzle",
-  "version": "0.0.4",
-  "description": "Use Drizzle ORM table definitions as a typesql schema.",
+  "version": "0.1.1",
+  "description": "Use Drizzle ORM table definitions as a TypeSQL schema.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -28,14 +28,17 @@
     "access": "public"
   },
   "dependencies": {
-    "@typesql/core": "0.0.4"
+    "@typesql/core": "0.1.1"
   },
   "peerDependencies": {
     "drizzle-orm": ">=0.45"
   },
   "devDependencies": {
-    "@typesql/pg": "0.0.4",
+    "@types/pg": "^8.23.1",
+    "@typesql/pg": "0.1.1",
     "drizzle-orm": "^0.45.4",
+    "pg": "^8.23.1",
+    "postgres": "^3.4.9",
     "typescript": "7.0.2",
     "vitest": "^5.0.4"
   },

package/src/client.ts

@@ -0,0 +1,52 @@
+import type { Executor, SqlDriver } from "@typesql/core";
+
+/**
+ * What the adapter uses from a Drizzle database (`drizzle(client)` from `drizzle-orm/node-postgres`,
+ * `drizzle-orm/postgres-js`, ...) or a transaction from `db.transaction(fn)`.
+ */
+export interface DrizzleDatabase {
+  readonly _: { readonly session: object };
+  transaction<T>(fn: (tx: DrizzleDatabase) => Promise<T>): Promise<T>;
+}
+
+/** The driver client a Drizzle session holds: node-postgres' `query` or postgres.js' `unsafe`. */
+interface DriverClient {
+  query?(text: string, values: unknown[]): Promise<unknown>;
+  unsafe?(text: string, values: unknown[]): PromiseLike<unknown>;
+}
+
+/**
+ * The driver client under `db`: the `Pool`, `Client` or postgres.js `sql` given to `drizzle()`,
+ * or, inside `db.transaction(fn)`, the connection the transaction runs on. Drizzle keeps it as
+ * `session.client`.
+ */
+function clientOf(db: DrizzleDatabase): DriverClient {
+  const client = (db._.session as { readonly client?: DriverClient }).client;
+  if (client && (typeof client.unsafe === "function" || typeof client.query === "function")) return client;
+  throw new Error("typesql: createSql(db) needs a Drizzle database on node-postgres or postgres.js (its session client has no query or unsafe method)");
+}
+
+/**
+ * An `Executor` for core's `q.execute()`: runs queries on the driver client under `db`, so rows
+ * come back as the driver parses them (Drizzle's column mappers are not involved), and resolves to
+ * `{ rows, rowCount }` so `q.executeCount()` works.
+ */
+export function executor(db: DrizzleDatabase): Executor {
+  return async (text, values) => {
+    const client = clientOf(db);
+    if (client.unsafe) {
+      const result = (await client.unsafe(text, Array.from(values))) as unknown[] & { readonly count?: number | null };
+      return { rows: Array.from(result), rowCount: result.count ?? null };
+    }
+    const result = (await client.query!(text, Array.from(values))) as { rows: unknown[]; rowCount?: number | null };
+    return { rows: result.rows, rowCount: result.rowCount ?? null };
+  };
+}
+
+/** Run `fn` inside `db.transaction(fn)`; Drizzle nests a transaction inside one with a savepoint. */
+function transaction<T>(db: DrizzleDatabase, _depth: number, fn: (tx: DrizzleDatabase) => Promise<T>): Promise<T> {
+  return db.transaction(fn);
+}
+
+/** How `createSql(db)` runs queries and transactions. */
+export const driver: SqlDriver<DrizzleDatabase> = { executor, transaction };

package/src/from-drizzle.ts

@@ -145,7 +145,7 @@ type Build<S, Opts, E = Enums<S>> =
 type Flat<T> = { [K in keyof T]: T[K] } & {};
 
 /**
- * A typesql schema from Drizzle `pg-core` definitions: `FromDrizzle<typeof schema>` with
+ * A TypeSQL schema from Drizzle `pg-core` definitions: `FromDrizzle<typeof schema>` with
  * `import * as schema from "./schema"`. Also accepts a record of tables or a single table.
  *
  * Keys are SQL names (tables, columns, `pgSchema` namespaces); views become `View<…>`;

package/src/index.ts

@@ -1,17 +1,22 @@
-import { createSql as createCoreSql, type DefaultTypeMap, type Executor, type Sql } from "@typesql/core";
+import { createTransactionalSql, type DefaultTypeMap, type TransactionalSql } from "@typesql/core";
+import { driver, type DrizzleDatabase } from "./client.js";
 import type { FromDrizzle, FromDrizzleOptions } from "./from-drizzle.js";
 
 export type { FromDrizzle, FromDrizzleOptions, DrizzleColumnTypes } from "./from-drizzle.js";
 export { pgType } from "./pg-type.js";
-export type { Sql, Query, RowType, ParamsType, DefaultTypeMap, TypeMap, Executor } from "@typesql/core";
+export { executor, type DrizzleDatabase } from "./client.js";
+export type { Sql, Query, RowType, ParamsType, DefaultTypeMap, TypeMap, Executor, TransactionalSql } from "@typesql/core";
 export { NoResultError } from "@typesql/core";
 
+/** What `createSql<typeof schema>(db)` returns: core's `Sql` over `FromDrizzle<Schema, Opts>`, with `transaction(fn)`. */
+export type DrizzleSql<Schema, TM = DefaultTypeMap, Opts extends FromDrizzleOptions = {}> = TransactionalSql<FromDrizzle<Schema, Opts>, TM>;
+
 /**
  * `createSql` from core with the schema converted from Drizzle definitions:
- * `createSql<typeof schema>()`, or `createSql<typeof schema, PgTypeMap>()` for a driver's type map.
- * With an `executor` from a driver adapter (`executor(pool)` from `@typesql/pg`), the queries'
- * `execute*` methods run on it.
+ * `createSql<typeof schema>(db)`, or `createSql<typeof schema, PgTypeMap>(db)` for a driver's type map.
+ * The queries' `execute*` methods run on `db` (a Drizzle database or transaction, on node-postgres
+ * or postgres.js), and `sql.transaction(fn)` runs `fn` with a `sql` bound to `db.transaction`.
  */
-export function createSql<Schema, TM = DefaultTypeMap, Opts extends FromDrizzleOptions = {}>(executor?: Executor): Sql<FromDrizzle<Schema, Opts>, TM> {
-  return createCoreSql<FromDrizzle<Schema, Opts>, TM>(executor);
+export function createSql<Schema, TM = DefaultTypeMap, Opts extends FromDrizzleOptions = {}>(db?: DrizzleDatabase): DrizzleSql<Schema, TM, Opts> {
+  return createTransactionalSql<FromDrizzle<Schema, Opts>, TM, DrizzleDatabase>(db, driver) as DrizzleSql<Schema, TM, Opts>;
 }