Added dummy implementation of Mongo shim

src/package.json

@@ -63,6 +63,8 @@
   ],
   "devDependencies": {
     "@faker-js/faker": "8.4.1",
+    "@testcontainers/mongodb": "^10.10.1",
+    "@testcontainers/postgresql": "^10.10.1",
     "@types/mongodb": "^4.0.7",
     "@types/node": "20.11.30",
     "@types/pg": "^8.11.6",
@@ -85,12 +87,14 @@
     "vitepress": "1.0.1"
   },
   "peerDependencies": {
+    "close-with-grace": "^1.3.0",
     "pg": "^8.12.0",
-    "pg-format": "^1.0.4",
-    "close-with-grace": "^1.3.0"
+    "pg-format": "^1.0.4"
   },
   "workspaces": [
     "packages/pongo"
   ],
-  "dependencies": {}
+  "dependencies": {
+    "testcontainers": "^10.10.1"
+  }
 }

src/packages/pongo/src/e2e/compatibilityTest.e2e.spec.ts

@@ -0,0 +1,217 @@
+import {
+  MongoDBContainer,
+  type StartedMongoDBContainer,
+} from '@testcontainers/mongodb';
+import {
+  PostgreSqlContainer,
+  type StartedPostgreSqlContainer,
+} from '@testcontainers/postgresql';
+import assert from 'assert';
+import { Db as MongoDb, MongoClient as OriginalMongoClient } from 'mongodb';
+import { after, before, describe, it } from 'node:test';
+import MongoClient from '../mongo/mongoClient';
+import type { Db } from '../mongo/mongoDb';
+import { endAllPools } from '../postgres';
+
+type User = { name: string; age: number };
+
+void describe('MongoDB Compatibility Tests', () => {
+  let postgres: StartedPostgreSqlContainer;
+  let postgresConnectionString: string;
+  let pongoClient: MongoClient;
+
+  let mongo: StartedMongoDBContainer;
+  let mongoConnectionString: string;
+  let mongoClient: OriginalMongoClient;
+
+  let pongoDb: Db;
+  let mongoDb: MongoDb;
+
+  before(async () => {
+    postgres = await new PostgreSqlContainer().start();
+    postgresConnectionString = postgres.getConnectionUri();
+    pongoClient = new MongoClient(postgresConnectionString);
+    await pongoClient.connect();
+
+    mongo = await new MongoDBContainer('mongo:6.0.12').start();
+    mongoConnectionString = mongo.getConnectionString();
+    mongoClient = new OriginalMongoClient(mongoConnectionString, {
+      directConnection: true,
+    });
+    await mongoClient.connect();
+
+    const dbName = postgres.getDatabase();
+
+    pongoDb = pongoClient.db(dbName);
+    mongoDb = mongoClient.db(dbName);
+  });
+
+  after(async () => {
+    try {
+      await endAllPools();
+      await postgres.stop();
+    } catch (error) {
+      console.log(error);
+    }
+    try {
+      await mongoClient.close();
+      await mongo.stop();
+    } catch (error) {
+      console.log(error);
+    }
+  });
+
+  void describe('Insert Operations', () => {
+    void it('should insert a document into both PostgreSQL and MongoDB', async () => {
+      const pongoCollection = pongoDb.collection<User>('testCollection');
+      const mongoCollection = mongoDb.collection<User>('testCollection');
+
+      const doc = { name: 'Alice', age: 25 };
+
+      const pongoInsertResult = await pongoCollection.insertOne(doc);
+      const mongoInsertResult = await mongoCollection.insertOne(doc);
+
+      assert(pongoInsertResult.insertedId);
+      assert(mongoInsertResult.insertedId);
+
+      const pongoDoc = await pongoCollection.findOne({
+        _id: pongoInsertResult.insertedId,
+      });
+      const mongoDoc = await mongoCollection.findOne({
+        _id: mongoInsertResult.insertedId,
+      });
+
+      assert.deepStrictEqual(
+        {
+          name: pongoDoc!.name,
+          age: pongoDoc!.age,
+        },
+        {
+          name: mongoDoc!.name,
+          age: mongoDoc!.age,
+        },
+      );
+    });
+  });
+
+  void describe('Update Operations', () => {
+    void it('should update a document in both PostgreSQL and MongoDB', async () => {
+      const pongoCollection = pongoDb.collection<User>('testCollection');
+      const mongoCollection = mongoDb.collection<User>('testCollection');
+      const doc = { name: 'Bob', age: 30 };
+
+      const pongoInsertResult = await pongoCollection.insertOne(doc);
+      const mongoInsertResult = await mongoCollection.insertOne(doc);
+
+      const update = { $set: { age: 31 } };
+
+      await pongoCollection.updateOne(
+        { _id: pongoInsertResult.insertedId },
+        update,
+      );
+      await mongoCollection.updateOne(
+        { _id: mongoInsertResult.insertedId },
+        update,
+      );
+
+      const pongoDoc = await pongoCollection.findOne({
+        _id: pongoInsertResult.insertedId,
+      });
+      const mongoDoc = await mongoCollection.findOne({
+        _id: mongoInsertResult.insertedId,
+      });
+
+      assert.deepStrictEqual(
+        {
+          name: pongoDoc!.name,
+          age: 31,
+        },
+        {
+          name: mongoDoc!.name,
+          age: 31,
+        },
+      );
+    });
+  });
+
+  void describe('Delete Operations', () => {
+    void it('should delete a document from both PostgreSQL and MongoDB', async () => {
+      const pongoCollection = pongoDb.collection<User>('testCollection');
+      const mongoCollection = mongoDb.collection<User>('testCollection');
+      const doc = { name: 'Charlie', age: 35 };
+
+      const pongoInsertResult = await pongoCollection.insertOne(doc);
+      const mongoInsertResult = await mongoCollection.insertOne(doc);
+
+      await pongoCollection.deleteOne({ _id: pongoInsertResult.insertedId });
+      await mongoCollection.deleteOne({ _id: mongoInsertResult.insertedId });
+
+      const pongoDoc = await pongoCollection.findOne({
+        _id: pongoInsertResult.insertedId,
+      });
+      const mongoDoc = await mongoCollection.findOne({
+        _id: mongoInsertResult.insertedId,
+      });
+
+      assert.strictEqual(pongoDoc, null);
+      assert.strictEqual(mongoDoc, null);
+    });
+  });
+
+  void describe('Find Operations', () => {
+    void it('should find documents with a filter in both PostgreSQL and MongoDB', async () => {
+      const pongoCollection = pongoDb.collection<User>('testCollection');
+      const mongoCollection = mongoDb.collection<User>('testCollection');
+      const docs = [
+        { name: 'David', age: 40 },
+        { name: 'Eve', age: 45 },
+        { name: 'Frank', age: 50 },
+      ];
+
+      await pongoCollection.insertOne(docs[0]!);
+      await pongoCollection.insertOne(docs[1]!);
+      await pongoCollection.insertOne(docs[2]!);
+
+      await mongoCollection.insertOne(docs[0]!);
+      await mongoCollection.insertOne(docs[1]!);
+      await mongoCollection.insertOne(docs[2]!);
+
+      const pongoDocs = await pongoCollection
+        .find({ age: { $gte: 45 } })
+        .toArray();
+      const mongoDocs = await mongoCollection
+        .find({ age: { $gte: 45 } })
+        .toArray();
+
+      assert.strictEqual(pongoDocs.length, 2);
+
+      assert.deepStrictEqual(
+        pongoDocs.map((d) => ({ name: d.name, age: d.age })),
+        mongoDocs.map((d) => ({ name: d.name, age: d.age })),
+      );
+    });
+
+    void it('should find one document with a filter in both PostgreSQL and MongoDB', async () => {
+      const pongoCollection = pongoDb.collection<User>('testCollection');
+      const mongoCollection = mongoDb.collection<User>('testCollection');
+      const doc = { name: 'Grace', age: 55 };
+
+      await pongoCollection.insertOne(doc);
+      await mongoCollection.insertOne(doc);
+
+      const pongoDoc = await pongoCollection.findOne({ name: 'Grace' });
+      const mongoDoc = await mongoCollection.findOne({ name: 'Grace' });
+
+      assert.deepStrictEqual(
+        {
+          name: pongoDoc!.name,
+          age: pongoDoc!.age,
+        },
+        {
+          name: mongoDoc!.name,
+          age: mongoDoc!.age,
+        },
+      );
+    });
+  });
+});

src/packages/pongo/src/main/client.ts

@@ -4,10 +4,15 @@ import type { PongoClient, PongoDb } from './typing';
 export const pongoClient = (connectionString: string): PongoClient => {
   const dbClient = getDbClient(connectionString);
 
-  return {
-    connect: () => dbClient.connect(),
+  const pongoClient: PongoClient = {
+    connect: async () => {
+      await dbClient.connect();
+      return pongoClient;
+    },
     close: () => dbClient.close(),
     db: (dbName?: string): PongoDb =>
       dbName ? getDbClient(connectionString, dbName) : dbClient,
   };
+
+  return pongoClient;
 };

src/packages/pongo/src/main/typing.ts

@@ -1,5 +1,5 @@
 export interface PongoClient {
-  connect(): Promise<void>;
+  connect(): Promise<this>;
 
   close(): Promise<void>;
 
@@ -12,7 +12,7 @@ export interface PongoDb {
 
 export interface PongoCollection<T> {
   createCollection(): Promise<void>;
-  insertOne(document: T): Promise<PongoInsertResult>;
+  insertOne(document: T): Promise<PongoInsertOneResult>;
   updateOne(
     filter: PongoFilter<T>,
     update: PongoUpdate<T>,
@@ -44,15 +44,17 @@ export type PongoUpdate<T> = {
   $push?: { [P in keyof T]?: T[P] };
 };
 
-export interface PongoInsertResult {
+export interface PongoInsertOneResult {
   insertedId: string | null;
-  insertedCount: number | null;
+  acknowledged: boolean;
 }
 
 export interface PongoUpdateResult {
-  modifiedCount: number | null;
+  acknowledged: boolean;
+  modifiedCount: number;
 }
 
 export interface PongoDeleteResult {
-  deletedCount: number | null;
+  acknowledged: boolean;
+  deletedCount: number;
 }

src/packages/pongo/src/mongo/findCursor.ts

@@ -0,0 +1,37 @@
+export class FindCursor<T> {
+  private findDocumentsPromise: Promise<T[]>;
+  private documents: T[] | null = null;
+  private index: number = 0;
+
+  constructor(documents: Promise<T[]>) {
+    this.findDocumentsPromise = documents;
+  }
+
+  async toArray(): Promise<T[]> {
+    return this.findDocuments();
+  }
+
+  async forEach(callback: (doc: T) => void): Promise<void> {
+    const docs = await this.findDocuments();
+
+    for (const doc of docs) {
+      callback(doc);
+    }
+    return Promise.resolve();
+  }
+
+  hasNext(): boolean {
+    if (this.documents === null) throw Error('Error while fetching documents');
+    return this.index < this.documents.length;
+  }
+
+  async next(): Promise<T | null> {
+    const docs = await this.findDocuments();
+    return this.hasNext() ? docs[this.index++] ?? null : null;
+  }
+
+  private async findDocuments(): Promise<T[]> {
+    this.documents = await this.findDocumentsPromise;
+    return this.documents;
+  }
+}

src/packages/pongo/src/mongo/mongoClient.ts

@@ -0,0 +1,24 @@
+// src/MongoClientShim.ts
+import { pongoClient, type PongoClient } from '../main';
+import { Db } from './mongoDb';
+
+export default class MongoClient {
+  private pongoClient: PongoClient;
+
+  constructor(connectionString: string) {
+    this.pongoClient = pongoClient(connectionString);
+  }
+
+  async connect() {
+    await this.pongoClient.connect();
+    return this;
+  }
+
+  async close() {
+    await this.pongoClient.close();
+  }
+
+  db(dbName: string): Db {
+    return new Db(this.pongoClient.db(dbName));
+  }
+}