feat: support custom Prisma client output paths

Author: LucianBuzzo

README.md

@@ -30,6 +30,27 @@ const client = new PrismaClient();
 client.$use(stableSortMiddleware(client));
 ```
 
+### Usage with a custom Prisma Client output path
+
+If your Prisma schema generates the client to a custom location, import your generated client from that location and pass it to the middleware as usual.
+
+```prisma
+generator client {
+  provider = "prisma-client-js"
+  output   = "../src/generated/prisma"
+}
+```
+
+```ts
+import { stableSortMiddleware } from "@cerebruminc/prisma-stable-sort-middleware";
+import { PrismaClient } from "../src/generated/prisma";
+
+const client = new PrismaClient();
+client.$use(stableSortMiddleware(client));
+```
+
+This package does not import `@prisma/client/runtime/library`; it only requires a generated Prisma client instance that exposes Prisma's runtime data model.
+
 ## License
 
 The project is licensed under the MIT license.
@@ -43,3 +64,12 @@ The project is licensed under the MIT license.
 ![Cerebrum](./images/powered-by-cerebrum-dm.svg#gh-dark-mode-only)
 
 </div>
+
+## Contributing
+
+Before opening a pull request, please run:
+
+- `npm test`
+- `npm run test:integration`
+
+Please also follow the [Conventional Commits](https://www.conventionalcommits.org/en/v1.0.0/) specification when writing commit messages.

docker-compose.yml

@@ -26,12 +26,12 @@ services:
       POSTGRES_PASSWORD: postgres
       POSTGRES_DB: yates
     ports:
-      - 5432:5432
+      - 55432:5432
     networks:
       - internal
     healthcheck:
       test: ["CMD-SHELL", "pg_isready -U postgres"]
       interval: 5s
       timeout: 5s
       retries: 5
-    # command: ["postgres", "-c", "log_statement=all", "-c", "log_destination=stderr"]
+    # command: ["postgres", "-c", "log_statement=all", "-c", "log_destination=stderr"]

src/index.ts

@@ -1,8 +1,48 @@
-import type { Prisma, PrismaClient } from "@prisma/client";
-import { defineDmmfProperty } from "@prisma/client/runtime/library";
+export interface RuntimeFieldLike {
+	name: string;
+	isId: boolean;
+	isUnique: boolean;
+}
 
-// RuntimeDataModel is not exported from Prisma, so we need to use some type infiltration to get it
-export type RuntimeDataModel = Parameters<typeof defineDmmfProperty>[1];
+export interface RuntimeModelLike {
+	fields: RuntimeFieldLike[];
+}
+
+export interface RuntimeDataModelLike {
+	models: { [model: string]: RuntimeModelLike };
+}
+
+export type RuntimeDataModel = RuntimeDataModelLike;
+
+export type PrismaClientLike = object & { _runtimeDataModel?: RuntimeDataModelLike };
+
+export interface MiddlewareParamsLike {
+	model?: string;
+	action?: string;
+	args?: {
+		orderBy?: Record<string, unknown> | Array<Record<string, unknown>>;
+		[key: string]: unknown;
+	};
+	dataPath?: string[];
+	runInTransaction?: boolean;
+	[key: string]: unknown;
+}
+
+type MiddlewareNextLike = (params: any) => Promise<any> | any;
+
+export type MiddlewareLike = (params: any, next: MiddlewareNextLike) => Promise<any> | any;
+
+const getRuntimeDataModel = (client: PrismaClientLike): RuntimeDataModelLike => {
+	const runtimeDataModel = client._runtimeDataModel;
+
+	if (!(runtimeDataModel?.models && typeof runtimeDataModel.models === "object")) {
+		throw new Error(
+			`Could not access Prisma runtime data model on the provided client. Ensure you pass a generated Prisma client instance that exposes "_runtimeDataModel".`,
+		);
+	}
+
+	return runtimeDataModel;
+};
 
 const castArray = <T>(value: T | T[]): T[] => {
 	if (Array.isArray(value)) {
@@ -12,9 +52,9 @@ const castArray = <T>(value: T | T[]): T[] => {
 };
 
 // Creates an object indicating the unique fields for each model
-const getUniqueFieldData = (client: PrismaClient) => {
+const getUniqueFieldData = (client: PrismaClientLike) => {
 	const uniqueFields: { [model: string]: { [field: string]: boolean } } = {};
-	const runtimeDataModel = (client as any)._runtimeDataModel as RuntimeDataModel;
+	const runtimeDataModel = getRuntimeDataModel(client);
 	for (const key in runtimeDataModel.models) {
 		if (!uniqueFields[key]) {
 			uniqueFields[key] = {};
@@ -30,20 +70,24 @@ const getUniqueFieldData = (client: PrismaClient) => {
 // If the orderBy is just createdAt, add an id desc to the end of the orderBy
 // The unique ID stabilizes the sort, providing consistent ordering when the createdAt is the same
 // This is needed because the createdAt is not unique, and batch uploads will have the same createdAt
-export const stableSortMiddleware = (client: PrismaClient): Prisma.Middleware => {
+export const stableSortMiddleware = (client: PrismaClientLike): MiddlewareLike => {
 	const uniqueFields = getUniqueFieldData(client);
 
-	return (params, next) => {
+	return (params: MiddlewareParamsLike, next: MiddlewareNextLike) => {
 		const { model, action } = params;
 
 		if (!(model && action)) {
 			return next(params);
 		}
+		if (!uniqueFields[model]) {
+			return next(params);
+		}
 
+		const args = params.args;
 		// In Prisma, sorting by a single field can be done by passing a plain object, so for convenience we cast it to an array
-		const orderBy = params?.args?.orderBy ? castArray(params.args.orderBy) : null;
+		const orderBy = args?.orderBy ? castArray(args.orderBy) : null;
 
-		if (orderBy) {
+		if (orderBy && args) {
 			const hasUniqueField = orderBy.some((o) => {
 				const [field] = Object.keys(o);
 				return uniqueFields[model][field];
@@ -65,7 +109,7 @@ export const stableSortMiddleware = (client: PrismaClient): Prisma.Middleware =>
 						orderBy.push({ [fieldName]: "desc" });
 					}
 				}
-				params.args.orderBy = orderBy;
+				args.orderBy = orderBy;
 			}
 		}
 		return next(params);

test/unit/index.spec.ts

@@ -0,0 +1,45 @@
+import { stableSortMiddleware, type MiddlewareParamsLike, type PrismaClientLike } from "../../src";
+
+describe("stableSortMiddleware", () => {
+	it("throws a clear error when the runtime data model is missing", () => {
+		expect(() => stableSortMiddleware({})).toThrow(
+			'Could not access Prisma runtime data model on the provided client. Ensure you pass a generated Prisma client instance that exposes "_runtimeDataModel".',
+		);
+	});
+
+	it("adds a unique id field to stabilize sorting when orderBy is not unique", async () => {
+		const client: PrismaClientLike = {
+			_runtimeDataModel: {
+				models: {
+					User: {
+						fields: [
+							{ name: "id", isId: true, isUnique: false },
+							{ name: "createdAt", isId: false, isUnique: false },
+							{ name: "email", isId: false, isUnique: true },
+						],
+					},
+				},
+			},
+		};
+
+		const middleware = stableSortMiddleware(client);
+		const params: MiddlewareParamsLike = {
+			model: "User",
+			action: "findMany",
+			args: {
+				orderBy: {
+					createdAt: "desc",
+				},
+			},
+			dataPath: [],
+			runInTransaction: false,
+		};
+
+		const next = jest.fn(async (nextParams: MiddlewareParamsLike) => nextParams);
+
+		await middleware(params, next);
+
+		expect(params.args?.orderBy).toEqual([{ createdAt: "desc" }, { id: "desc" }]);
+		expect(next).toHaveBeenCalledWith(params);
+	});
+});