@prisma-next/driver-mongo 0.0.1

package/README.md

@@ -0,0 +1,13 @@
+# @prisma-next/driver-mongo
+
+MongoDB driver for Prisma Next. Executes wire-protocol documents against a MongoDB connection.
+
+## Responsibilities
+
+- **Command execution**: Sends lowered wire-protocol documents to MongoDB and returns raw results
+- **Connection management**: Creates and manages the MongoDB client connection
+
+## Dependencies
+
+- **Depends on**:
+  - `@prisma-next/mongo-core` (driver interface types)

package/dist/index.d.mts

@@ -0,0 +1,7 @@
+import { MongoDriver } from "@prisma-next/mongo-core";
+
+//#region src/mongo-driver.d.ts
+declare function createMongoDriver(uri: string, dbName: string): Promise<MongoDriver>;
+//#endregion
+export { createMongoDriver };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/mongo-driver.ts"],"sourcesContent":[],"mappings":";;;iBAoFsB,iBAAA,+BAAgD,QAAQ"}

package/dist/index.mjs

@@ -0,0 +1,60 @@
+import { MongoClient } from "mongodb";
+
+//#region src/mongo-driver.ts
+var MongoDriverImpl = class {
+	#db;
+	#client;
+	constructor(db, client) {
+		this.#db = db;
+		this.#client = client;
+	}
+	execute(wireCommand) {
+		switch (wireCommand.kind) {
+			case "find": return this.#executeFindCommand(wireCommand);
+			case "insertOne": return this.#executeInsertOneCommand(wireCommand);
+			case "updateOne": return this.#executeUpdateOneCommand(wireCommand);
+			case "deleteOne": return this.#executeDeleteOneCommand(wireCommand);
+			case "aggregate": return this.#executeAggregateCommand(wireCommand);
+			default: {
+				const _exhaustive = wireCommand;
+				throw new Error(`Unknown wire command kind: ${_exhaustive.kind}`);
+			}
+		}
+	}
+	async close() {
+		await this.#client.close();
+	}
+	async *#executeFindCommand(cmd) {
+		let cursor = this.#db.collection(cmd.collection).find(cmd.filter ?? {});
+		if (cmd.projection) cursor = cursor.project(cmd.projection);
+		if (cmd.sort) cursor = cursor.sort(cmd.sort);
+		if (cmd.limit !== void 0) cursor = cursor.limit(cmd.limit);
+		if (cmd.skip !== void 0) cursor = cursor.skip(cmd.skip);
+		yield* cursor;
+	}
+	async *#executeInsertOneCommand(cmd) {
+		yield { insertedId: (await this.#db.collection(cmd.collection).insertOne(cmd.document)).insertedId };
+	}
+	async *#executeUpdateOneCommand(cmd) {
+		const result = await this.#db.collection(cmd.collection).updateOne(cmd.filter, cmd.update);
+		yield {
+			matchedCount: result.matchedCount,
+			modifiedCount: result.modifiedCount
+		};
+	}
+	async *#executeDeleteOneCommand(cmd) {
+		yield { deletedCount: (await this.#db.collection(cmd.collection).deleteOne(cmd.filter)).deletedCount };
+	}
+	async *#executeAggregateCommand(cmd) {
+		yield* this.#db.collection(cmd.collection).aggregate(cmd.pipeline);
+	}
+};
+async function createMongoDriver(uri, dbName) {
+	const client = new MongoClient(uri);
+	await client.connect();
+	return new MongoDriverImpl(client.db(dbName), client);
+}
+
+//#endregion
+export { createMongoDriver };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["#db","#client","#executeFindCommand","#executeInsertOneCommand","#executeUpdateOneCommand","#executeDeleteOneCommand","#executeAggregateCommand","_exhaustive: never"],"sources":["../src/mongo-driver.ts"],"sourcesContent":["import type {\n  AnyMongoWireCommand,\n  DeleteOneResult,\n  InsertOneResult,\n  MongoDriver,\n  UpdateOneResult,\n} from '@prisma-next/mongo-core';\nimport { type Db, MongoClient, type Sort } from 'mongodb';\n\nclass MongoDriverImpl implements MongoDriver {\n  readonly #db: Db;\n  readonly #client: MongoClient;\n\n  constructor(db: Db, client: MongoClient) {\n    this.#db = db;\n    this.#client = client;\n  }\n\n  execute<Row = Record<string, unknown>>(wireCommand: AnyMongoWireCommand): AsyncIterable<Row> {\n    switch (wireCommand.kind) {\n      case 'find':\n        return this.#executeFindCommand<Row>(wireCommand);\n      case 'insertOne':\n        return this.#executeInsertOneCommand(wireCommand) as AsyncIterable<Row>;\n      case 'updateOne':\n        return this.#executeUpdateOneCommand(wireCommand) as AsyncIterable<Row>;\n      case 'deleteOne':\n        return this.#executeDeleteOneCommand(wireCommand) as AsyncIterable<Row>;\n      case 'aggregate':\n        return this.#executeAggregateCommand<Row>(wireCommand);\n      default: {\n        const _exhaustive: never = wireCommand;\n        throw new Error(`Unknown wire command kind: ${(_exhaustive as { kind: string }).kind}`);\n      }\n    }\n  }\n\n  async close(): Promise<void> {\n    await this.#client.close();\n  }\n\n  async *#executeFindCommand<Row>(cmd: AnyMongoWireCommand & { kind: 'find' }): AsyncIterable<Row> {\n    const collection = this.#db.collection(cmd.collection);\n    let cursor = collection.find(cmd.filter ?? {});\n    if (cmd.projection) cursor = cursor.project(cmd.projection);\n    if (cmd.sort) cursor = cursor.sort(cmd.sort as Sort);\n    if (cmd.limit !== undefined) cursor = cursor.limit(cmd.limit);\n    if (cmd.skip !== undefined) cursor = cursor.skip(cmd.skip);\n    yield* cursor as AsyncIterable<Row>;\n  }\n\n  async *#executeInsertOneCommand(\n    cmd: AnyMongoWireCommand & { kind: 'insertOne' },\n  ): AsyncIterable<InsertOneResult> {\n    const collection = this.#db.collection(cmd.collection);\n    const result = await collection.insertOne(cmd.document);\n    yield { insertedId: result.insertedId };\n  }\n\n  async *#executeUpdateOneCommand(\n    cmd: AnyMongoWireCommand & { kind: 'updateOne' },\n  ): AsyncIterable<UpdateOneResult> {\n    const collection = this.#db.collection(cmd.collection);\n    const result = await collection.updateOne(cmd.filter, cmd.update);\n    yield { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };\n  }\n\n  async *#executeDeleteOneCommand(\n    cmd: AnyMongoWireCommand & { kind: 'deleteOne' },\n  ): AsyncIterable<DeleteOneResult> {\n    const collection = this.#db.collection(cmd.collection);\n    const result = await collection.deleteOne(cmd.filter);\n    yield { deletedCount: result.deletedCount };\n  }\n\n  async *#executeAggregateCommand<Row>(\n    cmd: AnyMongoWireCommand & { kind: 'aggregate' },\n  ): AsyncIterable<Row> {\n    const collection = this.#db.collection(cmd.collection);\n    const cursor = collection.aggregate(cmd.pipeline as Record<string, unknown>[]);\n    yield* cursor as AsyncIterable<Row>;\n  }\n}\n\nexport async function createMongoDriver(uri: string, dbName: string): Promise<MongoDriver> {\n  const client = new MongoClient(uri);\n  await client.connect();\n  const db = client.db(dbName);\n  return new MongoDriverImpl(db, client);\n}\n"],"mappings":";;;AASA,IAAM,kBAAN,MAA6C;CAC3C,CAASA;CACT,CAASC;CAET,YAAY,IAAQ,QAAqB;AACvC,QAAKD,KAAM;AACX,QAAKC,SAAU;;CAGjB,QAAuC,aAAsD;AAC3F,UAAQ,YAAY,MAApB;GACE,KAAK,OACH,QAAO,MAAKC,mBAAyB,YAAY;GACnD,KAAK,YACH,QAAO,MAAKC,wBAAyB,YAAY;GACnD,KAAK,YACH,QAAO,MAAKC,wBAAyB,YAAY;GACnD,KAAK,YACH,QAAO,MAAKC,wBAAyB,YAAY;GACnD,KAAK,YACH,QAAO,MAAKC,wBAA8B,YAAY;GACxD,SAAS;IACP,MAAMC,cAAqB;AAC3B,UAAM,IAAI,MAAM,8BAA+B,YAAiC,OAAO;;;;CAK7F,MAAM,QAAuB;AAC3B,QAAM,MAAKN,OAAQ,OAAO;;CAG5B,QAAOC,mBAAyB,KAAiE;EAE/F,IAAI,SADe,MAAKF,GAAI,WAAW,IAAI,WAAW,CAC9B,KAAK,IAAI,UAAU,EAAE,CAAC;AAC9C,MAAI,IAAI,WAAY,UAAS,OAAO,QAAQ,IAAI,WAAW;AAC3D,MAAI,IAAI,KAAM,UAAS,OAAO,KAAK,IAAI,KAAa;AACpD,MAAI,IAAI,UAAU,OAAW,UAAS,OAAO,MAAM,IAAI,MAAM;AAC7D,MAAI,IAAI,SAAS,OAAW,UAAS,OAAO,KAAK,IAAI,KAAK;AAC1D,SAAO;;CAGT,QAAOG,wBACL,KACgC;AAGhC,QAAM,EAAE,aADO,MADI,MAAKH,GAAI,WAAW,IAAI,WAAW,CACtB,UAAU,IAAI,SAAS,EAC5B,YAAY;;CAGzC,QAAOI,wBACL,KACgC;EAEhC,MAAM,SAAS,MADI,MAAKJ,GAAI,WAAW,IAAI,WAAW,CACtB,UAAU,IAAI,QAAQ,IAAI,OAAO;AACjE,QAAM;GAAE,cAAc,OAAO;GAAc,eAAe,OAAO;GAAe;;CAGlF,QAAOK,wBACL,KACgC;AAGhC,QAAM,EAAE,eADO,MADI,MAAKL,GAAI,WAAW,IAAI,WAAW,CACtB,UAAU,IAAI,OAAO,EACxB,cAAc;;CAG7C,QAAOM,wBACL,KACoB;AAGpB,SAFmB,MAAKN,GAAI,WAAW,IAAI,WAAW,CAC5B,UAAU,IAAI,SAAsC;;;AAKlF,eAAsB,kBAAkB,KAAa,QAAsC;CACzF,MAAM,SAAS,IAAI,YAAY,IAAI;AACnC,OAAM,OAAO,SAAS;AAEtB,QAAO,IAAI,gBADA,OAAO,GAAG,OAAO,EACG,OAAO"}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@prisma-next/driver-mongo",
+  "version": "0.0.1",
+  "type": "module",
+  "sideEffects": false,
+  "description": "MongoDB driver for Prisma Next",
+  "scripts": {
+    "build": "tsdown",
+    "test": "vitest run --passWithNoTests",
+    "test:coverage": "vitest run --coverage --passWithNoTests",
+    "typecheck": "tsc --noEmit",
+    "lint": "biome check . --error-on-warnings",
+    "lint:fix": "biome check --write .",
+    "lint:fix:unsafe": "biome check --write --unsafe .",
+    "clean": "rm -rf dist dist-tsc dist-tsc-prod coverage .tmp-output"
+  },
+  "dependencies": {
+    "@prisma-next/mongo-core": "workspace:*",
+    "mongodb": "^6.16.0"
+  },
+  "devDependencies": {
+    "@prisma-next/test-utils": "workspace:*",
+    "@prisma-next/tsconfig": "workspace:*",
+    "@prisma-next/tsdown": "workspace:*",
+    "mongodb-memory-server": "^10.4.0",
+    "tsdown": "catalog:",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prisma/prisma-next.git",
+    "directory": "packages/3-mongo-target/3-mongo-driver"
+  }
+}

package/src/exports/index.ts

@@ -0,0 +1 @@
+export { createMongoDriver } from '../mongo-driver';

package/src/mongo-driver.ts

@@ -0,0 +1,90 @@
+import type {
+  AnyMongoWireCommand,
+  DeleteOneResult,
+  InsertOneResult,
+  MongoDriver,
+  UpdateOneResult,
+} from '@prisma-next/mongo-core';
+import { type Db, MongoClient, type Sort } from 'mongodb';
+
+class MongoDriverImpl implements MongoDriver {
+  readonly #db: Db;
+  readonly #client: MongoClient;
+
+  constructor(db: Db, client: MongoClient) {
+    this.#db = db;
+    this.#client = client;
+  }
+
+  execute<Row = Record<string, unknown>>(wireCommand: AnyMongoWireCommand): AsyncIterable<Row> {
+    switch (wireCommand.kind) {
+      case 'find':
+        return this.#executeFindCommand<Row>(wireCommand);
+      case 'insertOne':
+        return this.#executeInsertOneCommand(wireCommand) as AsyncIterable<Row>;
+      case 'updateOne':
+        return this.#executeUpdateOneCommand(wireCommand) as AsyncIterable<Row>;
+      case 'deleteOne':
+        return this.#executeDeleteOneCommand(wireCommand) as AsyncIterable<Row>;
+      case 'aggregate':
+        return this.#executeAggregateCommand<Row>(wireCommand);
+      default: {
+        const _exhaustive: never = wireCommand;
+        throw new Error(`Unknown wire command kind: ${(_exhaustive as { kind: string }).kind}`);
+      }
+    }
+  }
+
+  async close(): Promise<void> {
+    await this.#client.close();
+  }
+
+  async *#executeFindCommand<Row>(cmd: AnyMongoWireCommand & { kind: 'find' }): AsyncIterable<Row> {
+    const collection = this.#db.collection(cmd.collection);
+    let cursor = collection.find(cmd.filter ?? {});
+    if (cmd.projection) cursor = cursor.project(cmd.projection);
+    if (cmd.sort) cursor = cursor.sort(cmd.sort as Sort);
+    if (cmd.limit !== undefined) cursor = cursor.limit(cmd.limit);
+    if (cmd.skip !== undefined) cursor = cursor.skip(cmd.skip);
+    yield* cursor as AsyncIterable<Row>;
+  }
+
+  async *#executeInsertOneCommand(
+    cmd: AnyMongoWireCommand & { kind: 'insertOne' },
+  ): AsyncIterable<InsertOneResult> {
+    const collection = this.#db.collection(cmd.collection);
+    const result = await collection.insertOne(cmd.document);
+    yield { insertedId: result.insertedId };
+  }
+
+  async *#executeUpdateOneCommand(
+    cmd: AnyMongoWireCommand & { kind: 'updateOne' },
+  ): AsyncIterable<UpdateOneResult> {
+    const collection = this.#db.collection(cmd.collection);
+    const result = await collection.updateOne(cmd.filter, cmd.update);
+    yield { matchedCount: result.matchedCount, modifiedCount: result.modifiedCount };
+  }
+
+  async *#executeDeleteOneCommand(
+    cmd: AnyMongoWireCommand & { kind: 'deleteOne' },
+  ): AsyncIterable<DeleteOneResult> {
+    const collection = this.#db.collection(cmd.collection);
+    const result = await collection.deleteOne(cmd.filter);
+    yield { deletedCount: result.deletedCount };
+  }
+
+  async *#executeAggregateCommand<Row>(
+    cmd: AnyMongoWireCommand & { kind: 'aggregate' },
+  ): AsyncIterable<Row> {
+    const collection = this.#db.collection(cmd.collection);
+    const cursor = collection.aggregate(cmd.pipeline as Record<string, unknown>[]);
+    yield* cursor as AsyncIterable<Row>;
+  }
+}
+
+export async function createMongoDriver(uri: string, dbName: string): Promise<MongoDriver> {
+  const client = new MongoClient(uri);
+  await client.connect();
+  const db = client.db(dbName);
+  return new MongoDriverImpl(db, client);
+}