prisma-extension-kysely 1.0.4 → 2.0.0

package/README.md

@@ -9,6 +9,16 @@
 
 Writing and maintaining raw SQL queries for Prisma can be a tedious and error-prone task. The moment you need to write a query that is not supported out-of-the-box by Prisma, you lose all of that type-safety and autocompletion. This is where `prisma-extension-kysely` comes in! It allows you to easily write raw SQL queries in a type-safe manner with [`kysely`](https://kysely.dev/) and integrate them seamlessly with Prisma.
 
+And the best part? You can use all of your favorite [`kysely`](https://kysely.dev/) plugins with `prisma-extension-kysely` too!
+
+You don't have to take our word for it, though:
+
+> I have to say, this is BY FAR the most amazing community package I've seen in the Prisma ecosystem!
+>
+> It makes it so much more convenient to drop down to raw SQL when needed without sacrificing DX — best of both worlds! 🚀
+
+— [Nikolas Burk, DevRel @ Prisma](https://twitter.com/nikolasburk/status/1747901827960471699)
+
 ## Features
 
 - **Type-safe** — Write raw SQL queries in a type-safe manner with `kysely`
@@ -52,17 +62,22 @@ Extend your Prisma Client:
 import kyselyExtension from "prisma-extension-kysely";
 import type { DB } from "./prisma/generated/types";
 
-// Don't forget to customize this to match your database!
-const kysely = new Kysely<DB>({
-  dialect: {
-    createAdapter: () => new PostgresAdapter(),
-    createDriver: () => new DummyDriver(),
-    createIntrospector: (db) => new PostgresIntrospector(db),
-    createQueryCompiler: () => new PostgresQueryCompiler(),
-  },
-});
-
-const prisma = new PrismaClient().$extends(kyselyExtension({ kysely }));
+const prisma = new PrismaClient().$extends(
+  kyselyExtension({
+    kysely: (driver) =>
+      new Kysely<DB>({
+        dialect: {
+          // This is where the magic happens!
+          createDriver: () => driver,
+          // Don't forget to customize these to match your database!
+          createAdapter: () => new PostgresAdapter(),
+          createIntrospector: (db) => new PostgresIntrospector(db),
+          createQueryCompiler: () => new PostgresQueryCompiler(),
+        },
+        plugins: [new CamelCasePlugin()],
+      }),
+  }),
+);
 ```
 
 It's that simple! Now you can write raw SQL queries with `kysely` and use them with Prisma:
@@ -78,20 +93,76 @@ const query = prisma.$kysely
   .where("id", "=", id);
 
 // Thanks to kysely's magic, everything is type-safe!
-const result = await prisma.$kyselyQuery(query);
+const result = await query.execute();
 
 // You can also execute queries without fetching the results
-await prisma.$kyselyExecute(
-  prisma.$kysely.deleteFrom("User").where("id", "=", id),
+await prisma.$kysely.deleteFrom("User").where("id", "=", id).execute();
+```
+
+## Transactions
+
+Prisma's interactive transactions are fully supported by `prisma-extension-kysely`! Just remeber to use `tx.$kysely` instead of `prisma.$kysely`, and you're good to go:
+
+```typescript
+await prisma.$transaction(async (tx) => {
+  await tx.$kysely
+    .insertInto("User")
+    .values({ id: 1, name: "John Doe" })
+    .execute();
+
+  await tx.$kysely
+    .insertInto("User")
+    .values({ id: 2, name: "Jane Doe" })
+    .execute();
+});
+```
+
+Don't try to use Kysely's `transaction` method directly, though. It's not supported by `prisma-extension-kysely`, and it will throw an error if you try to use it.
+
+```typescript
+// Don't do this! Prefer prisma.$transaction instead.
+await prisma.$kysely.transaction().execute(async (trx) => {});
+```
+
+## Plugins
+
+Do you love Kysely's plugins? So do we! You can use them with `prisma-extension-kysely` as well:
+
+```typescript
+const prisma = new PrismaClient().$extends(
+  kyselyExtension({
+    kysely: (driver) =>
+      new Kysely<DB>({
+        dialect: {
+          createDriver: () => driver,
+          createAdapter: () => new PostgresAdapter(),
+          createIntrospector: (db) => new PostgresIntrospector(db),
+          createQueryCompiler: () => new PostgresQueryCompiler(),
+        },
+        // Use your favorite plugins!
+        plugins: [new CamelCasePlugin()],
+      }),
+  }),
 );
 ```
 
+If you're using the `CamelCasePlugin`, don't forget to add the `camelCase` option to your Prisma schema too:
+
+```prisma
+generator kysely {
+  provider = "prisma-kysely"
+  camelCase = true
+}
+```
+
+Take a look at [the camel case example](examples/camel-case/) to see it in action! Check out the [Kysely documentation](https://kysely.dev/) for more information about plugins.
+
 ## Examples
 
-Check out the [example](example) directory for a sample project!
+Check out the [examples](examples) directory for a sample project!
 
 ```shell
-cd examples
+cd examples/basic
 npm install
 npx prisma db push
 npm run dev

package/dist/connection.d.ts

@@ -0,0 +1,11 @@
+import { PrismaClient } from "@prisma/client/extension";
+import { CompiledQuery, DatabaseConnection, QueryResult } from "kysely";
+/**
+ * A Kysely database connection that uses Prisma as the driver
+ */
+export declare class PrismaConnection implements DatabaseConnection {
+    private readonly prisma;
+    constructor(prisma: PrismaClient);
+    executeQuery<R>(compiledQuery: CompiledQuery<unknown>): Promise<QueryResult<R>>;
+    streamQuery<R>(_compiledQuery: CompiledQuery<unknown>, _chunkSize?: number | undefined): AsyncIterableIterator<QueryResult<R>>;
+}

package/dist/connection.js

@@ -0,0 +1,47 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaConnection = void 0;
+const kysely_1 = require("kysely");
+/**
+ * A Kysely database connection that uses Prisma as the driver
+ */
+class PrismaConnection {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    executeQuery(compiledQuery) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { sql, parameters, query } = compiledQuery;
+            // Delete, update and insert queries return the number of affected rows if no returning clause is specified
+            const supportsReturning = kysely_1.DeleteQueryNode.is(query) ||
+                kysely_1.UpdateQueryNode.is(query) ||
+                kysely_1.InsertQueryNode.is(query);
+            const shouldReturnAffectedRows = supportsReturning && !query.returning;
+            // Execute the query with $executeRawUnsafe to get the number of affected rows
+            if (shouldReturnAffectedRows) {
+                const numAffectedRows = BigInt(yield this.prisma.$executeRawUnsafe(sql, ...parameters));
+                return {
+                    rows: [],
+                    numAffectedRows: numAffectedRows,
+                    numUpdatedOrDeletedRows: numAffectedRows,
+                };
+            }
+            // Otherwise, execute it with $queryRawUnsafe to get the query results
+            const rows = yield this.prisma.$queryRawUnsafe(sql, ...parameters);
+            return { rows };
+        });
+    }
+    streamQuery(_compiledQuery, _chunkSize) {
+        throw new Error("prisma-extension-kysely does not support streaming queries");
+    }
+}
+exports.PrismaConnection = PrismaConnection;

package/dist/driver.d.ts

@@ -0,0 +1,13 @@
+import { PrismaClient } from "@prisma/client/extension";
+import { DatabaseConnection, Driver, TransactionSettings } from "kysely";
+export declare class PrismaDriver<T extends PrismaClient> implements Driver {
+    private readonly prisma;
+    constructor(prisma: T);
+    init(): Promise<void>;
+    acquireConnection(): Promise<DatabaseConnection>;
+    beginTransaction(_connection: DatabaseConnection, _settings: TransactionSettings): Promise<void>;
+    commitTransaction(_connection: DatabaseConnection): Promise<void>;
+    rollbackTransaction(_connection: DatabaseConnection): Promise<void>;
+    releaseConnection(_connection: DatabaseConnection): Promise<void>;
+    destroy(): Promise<void>;
+}

package/dist/driver.js

@@ -0,0 +1,42 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrismaDriver = void 0;
+const connection_1 = require("./connection");
+class PrismaDriver {
+    constructor(prisma) {
+        this.prisma = prisma;
+    }
+    init() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    acquireConnection() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new connection_1.PrismaConnection(this.prisma);
+        });
+    }
+    beginTransaction(_connection, _settings) {
+        throw new Error("prisma-extension-kysely does not support transactions");
+    }
+    commitTransaction(_connection) {
+        throw new Error("prisma-extension-kysely does not support transactions");
+    }
+    rollbackTransaction(_connection) {
+        throw new Error("prisma-extension-kysely does not support transactions");
+    }
+    releaseConnection(_connection) {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+    destroy() {
+        return __awaiter(this, void 0, void 0, function* () { });
+    }
+}
+exports.PrismaDriver = PrismaDriver;

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import type { PrismaPromise } from "@prisma/client/runtime/library";
-import type { Compilable, Kysely, Simplify } from "kysely";
+import { Kysely } from "kysely";
+import { PrismaDriver } from "./driver";
 /**
  * The configuration object for the Prisma Kysely extension
  */
@@ -7,28 +7,22 @@ export type PrismaKyselyExtensionArgs<Database> = {
     /**
      * The Kysely instance to provide to the Prisma client
      */
-    kysely: Kysely<Database>;
+    kysely: (driver: PrismaDriver<any>) => Kysely<Database>;
 };
 /**
  * Define a Prisma extension that adds Kysely query builder methods to the Prisma client
  * @param extensionArgs The extension configuration object
  */
-declare const _default: <Database>(extensionArgs: PrismaKyselyExtensionArgs<Database>) => (client: any) => import("@prisma/client/extension").PrismaClientExtends<import("@prisma/client/runtime/library").InternalArgs<{}, {}, {}, {
-    /**
-     * The Kysely instance used by the Prisma client
-     */
-    $kysely: Kysely<Database>;
-    /**
-     * Execute a Kysely query and return the result
-     * @param query A Kysely select, insert, delete or update query builder
-     * @returns The result of the query
-     */
-    $kyselyQuery<T>(query: Compilable<T>): Promise<Simplify<T>[]>;
-    /**
-     * Execute a Kysely query and return the number of rows affected
-     * @param query A Kysely select, insert, delete or update query builder
-     * @returns The number of rows affected
-     */
-    $kyselyExecute(query: Compilable): PrismaPromise<number>;
-}> & import("@prisma/client/runtime/library").DefaultArgs>;
+declare const _default: <Database>(extensionArgs: PrismaKyselyExtensionArgs<Database>) => (client: any) => {
+    $extends: {
+        extArgs: {
+            result: {};
+            model: {};
+            query: {};
+            client: {
+                $kysely: () => Kysely<Database>;
+            };
+        };
+    };
+};
 export default _default;

package/dist/index.js

@@ -1,40 +1,59 @@
 "use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-const extension_1 = require("@prisma/client/extension");
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const client_1 = require("@prisma/client");
+const driver_1 = require("./driver");
 /**
  * Define a Prisma extension that adds Kysely query builder methods to the Prisma client
  * @param extensionArgs The extension configuration object
  */
-exports.default = (extensionArgs) => extension_1.Prisma.defineExtension((client) => {
-    return client.$extends({
+exports.default = (extensionArgs) => client_1.Prisma.defineExtension((client) => {
+    const driver = new driver_1.PrismaDriver(client);
+    const kysely = extensionArgs.kysely(driver);
+    const extendedClient = client.$extends({
         name: "prisma-extension-kysely",
         client: {
             /**
              * The Kysely instance used by the Prisma client
              */
-            $kysely: extensionArgs.kysely,
-            /**
-             * Execute a Kysely query and return the result
-             * @param query A Kysely select, insert, delete or update query builder
-             * @returns The result of the query
-             */
-            $kyselyQuery(query) {
-                const { sql, parameters } = query.compile();
-                const ctx = extension_1.Prisma.getExtensionContext(this);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                return ctx.$queryRawUnsafe(sql, ...parameters);
-            },
-            /**
-             * Execute a Kysely query and return the number of rows affected
-             * @param query A Kysely select, insert, delete or update query builder
-             * @returns The number of rows affected
-             */
-            $kyselyExecute(query) {
-                const { sql, parameters } = query.compile();
-                const ctx = extension_1.Prisma.getExtensionContext(this);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                return ctx.$executeRawUnsafe(sql, ...parameters);
-            },
+            $kysely: kysely,
+        },
+    });
+    // Wrap the $transaction method to attach a fresh Kysely instance to the transaction client
+    const kyselyTransaction = (target) => (...args) => {
+        if (typeof args[0] === "function") {
+            // If the first argument is a function, add a fresh Kysely instance to the transaction client
+            const [fn, options] = args;
+            return target.$transaction((tx) => __awaiter(void 0, void 0, void 0, function* () {
+                // The Kysely instance should call the transaction client, not the original client
+                const driver = new driver_1.PrismaDriver(tx);
+                const kysely = extensionArgs.kysely(driver);
+                tx.$kysely = kysely;
+                return fn(tx);
+            }), options);
+        }
+        else {
+            // Otherwise, just call the original $transaction method
+            return target.$transaction(...args);
+        }
+    };
+    // Attach the wrapped $transaction method to the extended client using a proxy
+    const extendedClientProxy = new Proxy(extendedClient, {
+        get: (target, prop, receiver) => {
+            if (prop === "$transaction") {
+                return kyselyTransaction(target);
+            }
+            return Reflect.get(target, prop, receiver);
         },
     });
+    return extendedClientProxy;
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-extension-kysely",
-  "version": "1.0.4",
+  "version": "2.0.0",
   "author": {
     "name": "Eoin O'Brien",
     "url": "https://eoin.ai",
@@ -33,8 +33,8 @@
   "scripts": {
     "pretest": "npm run build && prisma db push",
     "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage",
+    "test:watch": "npm run test -- --watch",
+    "test:coverage": "npm run test -- --coverage",
     "clean": "rm -rf ./dist",
     "build": "tsc",
     "prepack": "npm run clean && npm run build",
@@ -68,7 +68,7 @@
     "jest": "^29.7.0",
     "jest-mock-extended": "^3.0.5",
     "kysely": "^0.27.0",
-    "prettier": "3.1.1",
+    "prettier": "3.2.4",
     "prisma": "latest",
     "prisma-kysely": "^1.7.1",
     "ts-jest": "^29.1.1",