@pioneer-platform/default-mongo-v2 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @pioneer-platform/default-mongo-v2
+
+## 1.0.1
+
+### Patch Changes
+
+- Automated patch version bump for all packages

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@pioneer-platform/default-mongo-v2",
+  "version": "1.0.1",
+  "description": "Bun & ts-node compatible MongoDB client wrapper (no monk)",
+  "main": "src/index.ts",
+  "dependencies": {
+    "mongodb": "^6.10.0",
+    "dotenv": "^16.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,237 @@
+/*
+    MongoDB Client V2 - Bun & ts-node Compatible
+
+    Modern MongoDB driver (v6) compatible with both Bun and Node.js runtimes.
+    Provides a simple interface similar to monk for backward compatibility.
+    No top-level await - lazy initialization on first use.
+*/
+
+import { MongoClient, Db, Collection, Document, Filter, FindOptions, UpdateFilter } from 'mongodb';
+
+const TAG = ' | mongo-v2 | ';
+
+// MongoDB connection singleton
+let client: MongoClient | null = null;
+let defaultDb: Db | null = null;
+let initializationPromise: Promise<void> | null = null;
+let isInitialized = false;
+
+// Get connection string from environment
+const getConnectionString = (): string => {
+  let connectionString = process.env.MONGO_CONNECTION;
+
+  if (!connectionString) {
+    console.log(TAG, "Looking for mongo on: 127.0.0.1:27017/pioneer");
+    connectionString = "mongodb://127.0.0.1:27017/pioneer";
+  } else if (!connectionString.startsWith('mongodb://') && !connectionString.startsWith('mongodb+srv://')) {
+    // Convert old format to new format
+    if (connectionString.includes('@')) {
+      const [auth, hosts] = connectionString.split('@');
+      const [username, password] = auth.split(':');
+
+      if (hosts && hosts.includes('/')) {
+        const [hostList, dbAndParams] = hosts.split('/', 2);
+        const [dbName, ...params] = dbAndParams ? dbAndParams.split('?') : ['pioneer'];
+        const paramsStr = params.length ? `?${params.join('?')}` : '';
+
+        connectionString = `mongodb://${username}:${password}@${hostList}/${dbName}${paramsStr}`;
+        console.log(TAG, "Reformatted MongoDB connection string to new format");
+      }
+    } else {
+      // Simple format without auth
+      connectionString = `mongodb://${connectionString}`;
+    }
+  }
+
+  return connectionString;
+};
+
+// Initialize MongoDB connection (async, called lazily)
+const connect = async (): Promise<MongoClient> => {
+  if (client) {
+    return client;
+  }
+
+  try {
+    const connectionString = getConnectionString();
+    client = new MongoClient(connectionString);
+
+    await client.connect();
+    console.log(TAG, "Connected to MongoDB successfully");
+
+    // Extract database name from connection string
+    const url = new URL(connectionString);
+    const dbName = url.pathname.slice(1).split('?')[0] || 'pioneer';
+    defaultDb = client.db(dbName);
+    isInitialized = true;
+
+    return client;
+  } catch (error) {
+    console.error(TAG, "Failed to connect to MongoDB:", error);
+    console.error(TAG, "Server will continue but database operations may fail");
+    throw error;
+  }
+};
+
+// Collection wrapper with monk-like interface
+class CollectionWrapper<T extends Document = Document> {
+  private collection: Collection<T>;
+
+  constructor(collection: Collection<T>) {
+    this.collection = collection;
+  }
+
+  // Find documents (returns array like monk)
+  async find(query: Filter<T> = {}, options: FindOptions = {}): Promise<T[]> {
+    return await this.collection.find(query, options).toArray();
+  }
+
+  // Find one document
+  async findOne(query: Filter<T>): Promise<T | null> {
+    return await this.collection.findOne(query);
+  }
+
+  // Insert one document
+  async insert(doc: Partial<T>): Promise<T> {
+    const result = await this.collection.insertOne(doc as any);
+    return { ...doc, _id: result.insertedId } as T;
+  }
+
+  // Update documents
+  async update(query: Filter<T>, update: UpdateFilter<T> | Partial<T>, options: any = {}): Promise<any> {
+    const updateDoc = ('$set' in update || '$inc' in update || '$push' in update)
+      ? update as UpdateFilter<T>
+      : { $set: update };
+
+    if (options.multi) {
+      return await this.collection.updateMany(query, updateDoc);
+    } else {
+      return await this.collection.updateOne(query, updateDoc);
+    }
+  }
+
+  // Remove documents
+  async remove(query: Filter<T>): Promise<any> {
+    return await this.collection.deleteMany(query);
+  }
+
+  // Count documents
+  async count(query: Filter<T> = {}): Promise<number> {
+    return await this.collection.countDocuments(query);
+  }
+
+  // Create index
+  async createIndex(keys: any, options: any = {}): Promise<string> {
+    return await this.collection.createIndex(keys, options);
+  }
+
+  // Drop collection
+  async drop(): Promise<boolean> {
+    return await this.collection.drop();
+  }
+
+  // Access native collection for advanced operations
+  async native(): Promise<Collection<T>> {
+    return this.collection;
+  }
+}
+
+// Connection object with monk-like interface
+class MongoConnection {
+  private client: MongoClient | null = null;
+  private defaultDb: Db | null = null;
+  private connections: Map<string, Db> = new Map();
+  private initPromise: Promise<void> | null = null;
+
+  // Initialize connection (idempotent)
+  async init(): Promise<void> {
+    if (this.initPromise) {
+      return this.initPromise;
+    }
+
+    this.initPromise = (async () => {
+      if (this.client) return; // Already initialized
+
+      this.client = await connect();
+      const connectionString = getConnectionString();
+      const url = new URL(connectionString);
+      const dbName = url.pathname.slice(1).split('?')[0] || 'pioneer';
+      this.defaultDb = this.client.db(dbName);
+    })();
+
+    return this.initPromise;
+  }
+
+  // Get collection from default database (monk-compatible - synchronous)
+  get<T extends Document = Document>(collectionName: string, dbName?: string): CollectionWrapper<T> {
+    // Trigger lazy initialization (non-blocking)
+    if (!isInitialized && !initializationPromise) {
+      initializationPromise = this.init().catch(err => {
+        console.error(TAG, "Lazy initialization failed:", err);
+      });
+    }
+
+    // Return wrapper immediately (will fail gracefully if not connected)
+    if (!defaultDb && !dbName) {
+      // Create a stub that will work once initialized
+      const self = this;
+      const stub = new Proxy({} as CollectionWrapper<T>, {
+        get(target, prop) {
+          if (!self.defaultDb && !dbName) {
+            console.warn(TAG, `MongoDB not yet initialized, operation '${String(prop)}' may fail`);
+          }
+          const db = dbName ? self.getDb(dbName) : self.defaultDb!;
+          const collection = db.collection<T>(collectionName);
+          const wrapper = new CollectionWrapper<T>(collection);
+          return (wrapper as any)[prop];
+        }
+      });
+      return stub;
+    }
+
+    const db = dbName ? this.getDb(dbName) : this.defaultDb!;
+    const collection = db.collection<T>(collectionName);
+    return new CollectionWrapper<T>(collection);
+  }
+
+  // Get database by name
+  getDb(dbName: string): Db {
+    if (!this.client) {
+      throw new Error("MongoDB client not initialized");
+    }
+
+    if (!this.connections.has(dbName)) {
+      this.connections.set(dbName, this.client.db(dbName));
+    }
+
+    return this.connections.get(dbName)!;
+  }
+
+  // Get collection from specific database (monk-like getFromDb)
+  getFromDb<T extends Document = Document>(collectionName: string, dbName: string): CollectionWrapper<T> {
+    return this.get<T>(collectionName, dbName);
+  }
+
+  // Close connection
+  async close(): Promise<void> {
+    if (this.client) {
+      await this.client.close();
+      this.client = null;
+      this.defaultDb = null;
+      this.connections.clear();
+      this.initPromise = null;
+    }
+  }
+
+  // Get native MongoDB client for advanced operations
+  get native(): MongoClient | null {
+    return this.client;
+  }
+}
+
+// Create and export connection instance (no top-level await)
+const connection = new MongoConnection();
+
+// ES module export (Bun handles both import and require automatically)
+export default connection;
+export { MongoConnection, CollectionWrapper };