@pioneer-platform/mongo-atlas 1.0.0

package/README.md

@@ -0,0 +1,70 @@
+# MongoDB Atlas Connection Manager
+
+A modern, robust connection manager for MongoDB Atlas specifically designed for the Pioneer platform.
+
+## Features
+
+- Proper connection pooling and reuse
+- Support for MongoDB Atlas connection strings
+- Automatic reconnection
+- Connection caching
+- Monk-like API for backward compatibility
+- MongoDB native driver for optimal performance
+
+## Usage
+
+```javascript
+const mongo = require('@pioneer-platform/mongo-atlas');
+
+// Get a collection from a specific database
+async function getTickets() {
+  const ticketsCollection = await mongo.get('tickets', 'support');
+  return ticketsCollection.find({ status: 'open' });
+}
+
+// Use the MongoDB native collection
+async function advancedQuery() {
+  const collection = await mongo.get('users', 'admin');
+  return collection.collection.aggregate([
+    { $match: { active: true } },
+    { $group: { _id: '$role', count: { $sum: 1 } } }
+  ]).toArray();
+}
+```
+
+## Environment Variables
+
+- `MONGO_CONNECTION`: MongoDB connection string (required)
+- `MONGO_DEFAULT_DB`: Default database name (optional, defaults to 'pioneer')
+
+## Installation
+
+```bash
+npm install @pioneer-platform/mongo-atlas
+```
+
+## Migrating from @pioneer-platform/default-mongo
+
+### Before:
+```javascript
+const connection = require('@pioneer-platform/default-mongo');
+const ticketsDb = connection.get('tickets');
+
+// Using ticketsDb
+const tickets = await ticketsDb.find({ status: 'open' });
+```
+
+### After:
+```javascript
+const mongo = require('@pioneer-platform/mongo-atlas');
+
+// Make sure to await the get method as it's now async
+const ticketsDb = await mongo.get('tickets', 'support');
+
+// The same methods are available
+const tickets = await ticketsDb.find({ status: 'open' });
+```
+
+## License
+
+MIT 

package/index.js

@@ -0,0 +1,145 @@
+/*
+ * MongoDB Atlas Connection Manager
+ * Modern, robust connection handling for MongoDB Atlas
+ */
+
+const { MongoClient } = require('mongodb');
+const debug = require('debug')('mongo-atlas');
+
+// Connection cache to avoid multiple connections to the same DB
+const connectionCache = {
+  clients: {},
+  databases: {}
+};
+
+// Default options for MongoDB connections
+const defaultOptions = {
+  useUnifiedTopology: true,
+  useNewUrlParser: true,
+  connectTimeoutMS: 10000,
+  socketTimeoutMS: 45000,
+  serverSelectionTimeoutMS: 15000,
+  maxPoolSize: 20,
+  minPoolSize: 5
+};
+
+// Get or create a MongoClient for a connection string
+async function getOrCreateClient(connectionString, options = {}) {
+  // Use original connection string as the cache key
+  if (!connectionCache.clients[connectionString]) {
+    debug(`Creating new MongoClient for ${connectionString}`);
+    const client = new MongoClient(connectionString, { ...defaultOptions, ...options });
+    await client.connect();
+    connectionCache.clients[connectionString] = client;
+    
+    // Set up automatic reconnection
+    client.on('close', () => {
+      debug(`Connection to ${connectionString} closed, will reconnect on next use`);
+      delete connectionCache.clients[connectionString];
+    });
+  }
+  
+  return connectionCache.clients[connectionString];
+}
+
+// Main connection object
+const connection = {
+  /**
+   * Get a collection from a specific database
+   * @param {string} collection - Collection name
+   * @param {string} dbName - Database name (defaults to env variable or 'pioneer')
+   * @param {object} options - MongoDB connection options
+   * @returns {object} - MongoDB collection with added helper methods
+   */
+  async get(collection, dbName, options = {}) {
+    const connectionString = process.env.MONGO_CONNECTION || 'mongodb://localhost:27017/pioneer';
+    const targetDb = dbName || process.env.MONGO_DEFAULT_DB || 'pioneer';
+    
+    debug(`Getting collection ${collection} from database ${targetDb}`);
+    
+    try {
+      const client = await getOrCreateClient(connectionString, options);
+      const db = client.db(targetDb);
+      const mongoCollection = db.collection(collection);
+      
+      // Cache the database connection
+      const cacheKey = `${connectionString}:${targetDb}`;
+      connectionCache.databases[cacheKey] = db;
+      
+      // Enhance the collection with useful methods
+      return enhanceCollection(mongoCollection);
+    } catch (error) {
+      debug(`Error getting collection ${collection}: ${error.message}`);
+      throw error;
+    }
+  },
+  
+  /**
+   * Get a database instance
+   * @param {string} dbName - Database name
+   * @returns {object} - MongoDB database instance
+   */
+  async getDb(dbName) {
+    const connectionString = process.env.MONGO_CONNECTION || 'mongodb://localhost:27017/pioneer';
+    const targetDb = dbName || process.env.MONGO_DEFAULT_DB || 'pioneer';
+    
+    debug(`Getting database ${targetDb}`);
+    
+    try {
+      const client = await getOrCreateClient(connectionString);
+      return client.db(targetDb);
+    } catch (error) {
+      debug(`Error getting database ${targetDb}: ${error.message}`);
+      throw error;
+    }
+  },
+  
+  /**
+   * Close all connections
+   */
+  async close() {
+    debug('Closing all connections');
+    
+    const clients = Object.values(connectionCache.clients);
+    for (const client of clients) {
+      await client.close();
+    }
+    
+    connectionCache.clients = {};
+    connectionCache.databases = {};
+  }
+};
+
+// Add Monk-like methods to a MongoDB collection
+function enhanceCollection(collection) {
+  return {
+    // Original collection
+    collection,
+    
+    // Monk-like methods for backward compatibility
+    find: (query = {}, options = {}) => collection.find(query, options).toArray(),
+    findOne: (query = {}, options = {}) => collection.findOne(query, options),
+    insert: (doc, options = {}) => collection.insertOne(doc, options),
+    update: (query, update, options = {}) => collection.updateOne(query, update, options),
+    findOneAndUpdate: (query, update, options = {}) => collection.findOneAndUpdate(query, update, { returnDocument: 'after', ...options }),
+    remove: (query, options = {}) => collection.deleteOne(query, options),
+    removeMany: (query, options = {}) => collection.deleteMany(query, options),
+    count: (query = {}) => collection.countDocuments(query),
+    distinct: (field, query = {}) => collection.distinct(field, query)
+  };
+}
+
+// Handle process termination
+process.on('SIGINT', async () => {
+  debug('Received SIGINT, closing connections');
+  await connection.close();
+  process.exit(0);
+});
+
+process.on('SIGTERM', async () => {
+  debug('Received SIGTERM, closing connections');
+  await connection.close();
+  process.exit(0);
+});
+
+module.exports = connection; 

package/package.json

@@ -0,0 +1,28 @@
+{
+  "name": "@pioneer-platform/mongo-atlas",
+  "version": "1.0.0",
+  "description": "Modern MongoDB Atlas connection manager for Pioneer platform",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "keywords": [
+    "mongodb",
+    "atlas",
+    "database",
+    "connection",
+    "pioneer"
+  ],
+  "author": "Pioneer Team",
+  "license": "MIT",
+  "dependencies": {
+    "mongodb": "^4.12.0",
+    "debug": "^4.3.4"
+  },
+  "devDependencies": {
+    "jest": "^29.2.2"
+  },
+  "directories": {
+    "test": "tests"
+  }
+}

package/tests/connection.test.js

@@ -0,0 +1,134 @@
+const mongodb = require('mongodb');
+const connection = require('../index');
+
+// Mock MongoDB client
+jest.mock('mongodb', () => {
+  const mockCollection = {
+    find: jest.fn().mockReturnThis(),
+    toArray: jest.fn().mockResolvedValue([]),
+    findOne: jest.fn().mockResolvedValue({}),
+    insertOne: jest.fn().mockResolvedValue({ insertedId: 'mock-id' }),
+    updateOne: jest.fn().mockResolvedValue({ modifiedCount: 1 }),
+    findOneAndUpdate: jest.fn().mockResolvedValue({ value: {} }),
+    deleteOne: jest.fn().mockResolvedValue({ deletedCount: 1 }),
+    deleteMany: jest.fn().mockResolvedValue({ deletedCount: 5 }),
+    countDocuments: jest.fn().mockResolvedValue(10),
+    distinct: jest.fn().mockResolvedValue(['value1', 'value2']),
+    aggregate: jest.fn().mockReturnThis(),
+  };
+
+  const mockDb = {
+    collection: jest.fn().mockReturnValue(mockCollection),
+  };
+
+  const mockClient = {
+    connect: jest.fn().mockResolvedValue(this),
+    db: jest.fn().mockReturnValue(mockDb),
+    close: jest.fn().mockResolvedValue(true),
+    on: jest.fn(),
+  };
+
+  return {
+    MongoClient: jest.fn().mockImplementation(() => mockClient),
+  };
+});
+
+describe('MongoDB Atlas Connection Manager', () => {
+  beforeEach(() => {
+    // Reset mocks
+    jest.clearAllMocks();
+    
+    // Set environment variables for testing
+    process.env.MONGO_CONNECTION = 'mongodb://localhost:27017/test';
+  });
+  
+  afterEach(() => {
+    // Clean up
+    delete process.env.MONGO_CONNECTION;
+    delete process.env.MONGO_DEFAULT_DB;
+  });
+  
+  describe('get method', () => {
+    it('should get a collection from the specified database', async () => {
+      const collection = await connection.get('tickets', 'support');
+      
+      // Verify MongoClient was created with correct connection string
+      expect(mongodb.MongoClient).toHaveBeenCalledWith(
+        'mongodb://localhost:27017/test',
+        expect.objectContaining({
+          connectTimeoutMS: 10000,
+          socketTimeoutMS: 45000,
+        })
+      );
+      
+      // Verify db was called with correct name
+      const mockClientInstance = mongodb.MongoClient.mock.results[0].value;
+      expect(mockClientInstance.db).toHaveBeenCalledWith('support');
+      
+      // Verify collection was requested
+      const mockDbInstance = mockClientInstance.db.mock.results[0].value;
+      expect(mockDbInstance.collection).toHaveBeenCalledWith('tickets');
+      
+      // Verify enhanced methods exist
+      expect(collection.findOne).toBeDefined();
+      expect(collection.find).toBeDefined();
+      expect(collection.insert).toBeDefined();
+      expect(collection.update).toBeDefined();
+      expect(collection.findOneAndUpdate).toBeDefined();
+      expect(collection.remove).toBeDefined();
+      expect(collection.removeMany).toBeDefined();
+      expect(collection.count).toBeDefined();
+      expect(collection.distinct).toBeDefined();
+    });
+    
+    it('should use default database when dbName is not specified', async () => {
+      process.env.MONGO_DEFAULT_DB = 'default-db';
+      
+      await connection.get('users');
+      
+      // Verify db was called with default DB name
+      const mockClientInstance = mongodb.MongoClient.mock.results[0].value;
+      expect(mockClientInstance.db).toHaveBeenCalledWith('default-db');
+    });
+    
+    it('should reuse existing client connection', async () => {
+      // Get two collections
+      await connection.get('tickets', 'support');
+      await connection.get('users', 'admin');
+      
+      // MongoDB client should only be created once
+      expect(mongodb.MongoClient).toHaveBeenCalledTimes(1);
+      
+      // But db should be called twice with different names
+      const mockClientInstance = mongodb.MongoClient.mock.results[0].value;
+      expect(mockClientInstance.db).toHaveBeenCalledTimes(2);
+      expect(mockClientInstance.db).toHaveBeenNthCalledWith(1, 'support');
+      expect(mockClientInstance.db).toHaveBeenNthCalledWith(2, 'admin');
+    });
+  });
+  
+  describe('getDb method', () => {
+    it('should get a database instance', async () => {
+      const db = await connection.getDb('custom-db');
+      
+      // Verify db was called with correct name
+      const mockClientInstance = mongodb.MongoClient.mock.results[0].value;
+      expect(mockClientInstance.db).toHaveBeenCalledWith('custom-db');
+      expect(db).toBeDefined();
+    });
+  });
+  
+  describe('close method', () => {
+    it('should close all connections', async () => {
+      // Create a connection first
+      await connection.get('tickets', 'support');
+      
+      // Close connections
+      await connection.close();
+      
+      // Verify close was called
+      const mockClientInstance = mongodb.MongoClient.mock.results[0].value;
+      expect(mockClientInstance.close).toHaveBeenCalled();
+    });
+  });
+});