core-services-sdk 1.1.1 → 1.2.1

package/.vscode/launch.json

@@ -15,6 +15,20 @@
       "smartStep": true,
       "skipFiles": ["<node_internals>/**"],
       "console": "integratedTerminal"
+    },
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug Vitest Current File",
+      "autoAttachChildProcesses": true,
+      "program": "${workspaceFolder}/node_modules/vitest/vitest.mjs",
+      "args": [
+        "run",
+        "${relativeFile}" // ← no `--test`
+      ],
+      "smartStep": true,
+      "skipFiles": ["<node_internals>/**"],
+      "console": "integratedTerminal"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.1.1",
+  "version": "1.2.1",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
@@ -21,6 +21,7 @@
   "dependencies": {
     "amqplib": "^0.10.8",
     "http-status": "^2.1.0",
+    "mongodb": "^6.17.0",
     "node-fetch": "^3.3.2",
     "uuid": "^11.1.0",
     "xml2js": "^0.6.2"

package/src/index.js

@@ -1,3 +1,5 @@
+export * from './mongodb/index.js'
+export * from './mongodb/connect.js'
 export * from './rabbit-mq/index.js'
 export * as http from './http/http.js'
 export * from './http/responseType.js'

package/src/mongodb/connect.js

@@ -0,0 +1,23 @@
+import { MongoClient, ServerApiVersion } from 'mongodb'
+
+/**
+ * Connects to MongoDB.
+ *
+ * @param {Object} options
+ * @param {string} options.uri - MongoDB connection URI.
+ * @param {object} [options.serverApi] - Optional serverApi configuration.
+ * @returns {Promise<import('mongodb').MongoClient>}
+ */
+
+export const mongoConnect = async ({ uri, serverApi }) => {
+  const client = await MongoClient.connect(uri, {
+    serverApi: {
+      version: ServerApiVersion.v1,
+      strict: true,
+      deprecationErrors: true,
+      ...serverApi,
+    },
+  })
+
+  return client
+}

package/src/mongodb/index.js

@@ -0,0 +1,71 @@
+// @ts-nocheck
+import { mongoConnect } from './connect.js'
+
+/**
+ * Initializes MongoDB collections and provides a transaction wrapper and read-only client accessor.
+ *
+ * @param {Object} options
+ * @param {{ uri: string, options: { dbName: string } }} options.config - MongoDB connection config
+ * @param {Record<string, string>} options.collectionNames - Map of collection keys to MongoDB collection names
+ *
+ * @returns {Promise<
+ *   Record<string, import('mongodb').Collection> & {
+ *     withTransaction: (action: ({ session: import('mongodb').ClientSession }) => Promise<void>) => Promise<void>,
+ *     readonly client: import('mongodb').MongoClient
+ *   }
+ * >}
+ *
+ * @example
+ * const { users, logs, withTransaction, client } = await initializeMongoDb({
+ *   config: {
+ *     uri: 'mongodb://localhost:27017',
+ *     options: { dbName: 'mydb' },
+ *   },
+ *   collectionNames: {
+ *     users: 'users',
+ *     logs: 'system_logs',
+ *   },
+ * });
+ *
+ * await withTransaction(async ({ session }) => {
+ *   await users.insertOne({ name: 'Alice' }, { session });
+ *   await logs.insertOne({ event: 'UserCreated', user: 'Alice' }, { session });
+ * });
+ *
+ * await client.close(); // Close connection manually
+ */
+export const initializeMongoDb = async ({ config, collectionNames }) => {
+  const client = await mongoConnect(config)
+  const db = client.db(config.options.dbName)
+
+  const collectionRefs = Object.entries(collectionNames).reduce(
+    (collections, [key, collectionName]) => ({
+      ...collections,
+      [key]: db.collection(collectionName),
+    }),
+    {},
+  )
+
+  const withTransaction = async (action) => {
+    const session = client.startSession()
+    try {
+      session.startTransaction()
+      await action({ session })
+      await session.commitTransaction()
+    } catch (error) {
+      await session.abortTransaction()
+      throw error
+    } finally {
+      await session.endSession()
+    }
+  }
+
+  return {
+    ...collectionRefs,
+    withTransaction,
+    /** @type {import('mongodb').MongoClient} */
+    get client() {
+      return client
+    },
+  }
+}

package/src/rabbit-mq/index.js

@@ -10,7 +10,7 @@ import { v4 as uuidv4 } from 'uuid'
 /**
  * Connects to RabbitMQ server.
  * @param {{ host: string }} options
- * @returns {Promise<amqp.Connection>}
+ * @returns {Promise<import('amqplib').Connection>}
  */
 export const connectQueueService = async ({ host }) => {
   try {
@@ -57,10 +57,10 @@ const parseMessage = (msgInfo) => {
  * @returns {Promise<void>}
  */
 export const subscribeToQueue = async ({
-  channel,
+  log,
   queue,
+  channel,
   onReceive,
-  log,
   nackOnError = false,
 }) => {
   try {

package/tests/core-util.js

@@ -0,0 +1,24 @@
+import { exec } from 'child_process'
+/**
+ * Starts a MongoDB Docker container on the specified port.
+ * @param {string} command - Command to run, like: 'docker run -d --name mongo-test -p 2730:27017 mongo'.
+ * @returns {Promise<void>}
+ */
+export const runInTerminal = async (command) => {
+  return new Promise((resolve, reject) => {
+    exec(command, (error, stdout, stderr) => {
+      if (error) {
+        console.error('Error starting command:', error.message)
+        return reject(error)
+      }
+      if (stderr) {
+        console.warn('stderr:', stderr)
+      }
+      console.log('Command started:', stdout.trim())
+      resolve()
+    })
+  })
+}
+
+export const sleep = async (milliseconds) =>
+  new Promise((res) => setTimeout(res, milliseconds))

package/tests/mongodb.test.js

@@ -0,0 +1,70 @@
+import { describe, it, expect, beforeAll, afterAll } from 'vitest'
+import { runInTerminal, sleep } from './core-util.js'
+import { initializeMongoDb } from '../src/mongodb/index.js'
+
+const port = 2730
+const dbName = 'testdb'
+const host = 'localhost'
+const mongoUri = `mongodb://${host}:${port}/?replicaSet=rs0`
+const dockerStopCommand = `docker stop ${dbName} && docker rm ${dbName}`
+const dockerCreateCommant = `docker run -d --name ${dbName} -p ${port}:27017 mongo --replSet rs0`
+const dockerReplicaSetCommand = `docker exec -i ${dbName} mongosh --eval "rs.initiate()"`
+
+describe('MongoDB Init & Transaction SDK', () => {
+  let collections
+
+  beforeAll(async () => {
+    try {
+      await runInTerminal(dockerStopCommand)
+    } catch (error) {
+      console.log('No existing container to stop.')
+    }
+
+    await runInTerminal(dockerCreateCommant)
+    await sleep(5000)
+    await runInTerminal(dockerReplicaSetCommand)
+
+    collections = await initializeMongoDb({
+      config: {
+        uri: mongoUri,
+        options: { dbName },
+      },
+      collectionNames: {
+        users: 'users',
+        logs: 'logs',
+      },
+    })
+
+    await collections.users.deleteMany({})
+    await collections.logs.deleteMany({})
+  }, 60000)
+
+  afterAll(async () => {
+    if (collections?.client) {
+      await collections.client.db(dbName).dropDatabase()
+      await collections.client.close()
+    }
+  }, 20000)
+
+  it.skip('should insert into multiple collections within a transaction', async () => {
+    if (!collections) throw new Error('collections not initialized')
+
+    await collections.withTransaction(async ({ session }) => {
+      const userInsert = collections.users.insertOne(
+        { name: 'Alice' },
+        { session },
+      )
+      const logInsert = collections.logs.insertOne(
+        { action: 'UserCreated', user: 'Alice' },
+        { session },
+      )
+      await Promise.all([userInsert, logInsert])
+    })
+
+    const insertedUser = await collections.users.findOne({ name: 'Alice' })
+    const insertedLog = await collections.logs.findOne({ user: 'Alice' })
+
+    expect(insertedUser).not.toBeNull()
+    expect(insertedLog).not.toBeNull()
+  }, 20000)
+}, 60000)

package/vitest.config.js

@@ -0,0 +1,6 @@
+export default {
+  test: {
+    testTimeout: 30000,
+    hookTimeout: 30000,
+  },
+}

package/src/rabbit-mq/use-how-to.js

@@ -1,22 +0,0 @@
-import { initializeQueue, rabbitUriFromEnv } from './rabbit.js'
-
-const log = {
-  info: console.log,
-  error: console.error,
-}
-
-const start = async () => {
-  const host = rabbitUriFromEnv(process.env)
-  const rabbit = await initializeQueue({ host, log })
-
-  await rabbit.subscribe({
-    queue: 'testQueue',
-    onReceive: async (data) => {
-      console.log('Received:', data)
-    },
-  })
-
-  await rabbit.publish('testQueue', { hello: 'world' })
-}
-
-start()