core-services-sdk 1.1.0 → 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/.vscode/settings.json

@@ -12,5 +12,5 @@
   },
   "javascript.preferences.importModuleSpecifierEnding": "js",
   "js/ts.implicitProjectConfig.checkJs": true,
-  "javascript.validate.enable": false
+  "javascript.validate.enable": true
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "core-services-sdk",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "main": "src/index.js",
   "type": "module",
   "scripts": {
@@ -21,8 +21,10 @@
   "dependencies": {
     "amqplib": "^0.10.8",
     "http-status": "^2.1.0",
+    "mongodb": "^6.17.0",
     "node-fetch": "^3.3.2",
-    "uuid": "^11.1.0"
+    "uuid": "^11.1.0",
+    "xml2js": "^0.6.2"
   },
   "devDependencies": {
     "@vitest/coverage-v8": "^3.2.4",

package/src/http/http.js

@@ -1,8 +1,10 @@
 import fetch from 'node-fetch'
 import httpStatus from 'http-status'
+import { parseStringPromise } from 'xml2js'
 
 import { HttpError } from './HttpError.js'
 import { HTTP_METHODS } from './http-method.js'
+import { ResponseType } from './responseType.js'
 
 const JSON_HEADER = {
   'Content-Type': 'application/json',
@@ -28,6 +30,11 @@ const checkStatus = async (res) => {
   return res
 }
 
+const getTextResponse = async (response) => {
+  const text = await response.text()
+  return text
+}
+
 const tryConvertJsonResponse = (responseText) => {
   try {
     const obj = JSON.parse(responseText)
@@ -39,12 +46,53 @@ const tryConvertJsonResponse = (responseText) => {
 }
 
 const tryGetJsonResponse = async (response) => {
-  const text = await response.text()
-  const obj = tryConvertJsonResponse(text)
-  return obj
+  let jsonText
+  try {
+    jsonText = getTextResponse(response)
+    const obj = tryConvertJsonResponse(jsonText)
+    return obj
+  } catch (error) {
+    if (!jsonText) {
+      throw error
+    }
+    return jsonText
+  }
 }
 
-export const get = async ({ url, headers = {}, credentials = 'include' }) => {
+const tryGetXmlResponse = async (response) => {
+  let xmlText
+  try {
+    xmlText = await getTextResponse(response)
+    const xml = await parseStringPromise(xmlText)
+    return xml
+  } catch (error) {
+    if (!xmlText) {
+      throw error
+    }
+    return xmlText
+  }
+}
+
+const getResponsePayload = async (response, responseType) => {
+  switch (responseType) {
+    case ResponseType.json:
+      return tryGetJsonResponse(response)
+
+    case ResponseType.xml:
+      return tryGetXmlResponse(response)
+
+    default:
+    case ResponseType.text:
+      return getTextResponse(response)
+  }
+}
+
+export const get = async ({
+  url,
+  headers = {},
+  credentials = 'include',
+  expectedType = ResponseType.json,
+}) => {
   const response = await fetch(url, {
     method: HTTP_METHODS.GET,
     headers: {
@@ -55,11 +103,17 @@ export const get = async ({ url, headers = {}, credentials = 'include' }) => {
   })
 
   await checkStatus(response)
-  const data = await tryGetJsonResponse(response)
+  const data = await getResponsePayload(response, expectedType)
   return data
 }
 
-export const post = async ({ url, body, headers, credentials = 'include' }) => {
+export const post = async ({
+  url,
+  body,
+  headers,
+  credentials = 'include',
+  expectedType = ResponseType.json,
+}) => {
   const response = await fetch(url, {
     method: HTTP_METHODS.POST,
     headers: {
@@ -70,7 +124,7 @@ export const post = async ({ url, body, headers, credentials = 'include' }) => {
     ...(credentials ? { credentials } : {}),
   })
   await checkStatus(response)
-  const data = await tryGetJsonResponse(response)
+  const data = await getResponsePayload(response, expectedType)
   return data
 }
 
@@ -79,6 +133,7 @@ export const put = async ({
   body,
   headers = {},
   credentials = 'include',
+  expectedType = ResponseType.json,
 }) => {
   const response = await fetch(url, {
     method: HTTP_METHODS.PUT,
@@ -91,7 +146,7 @@ export const put = async ({
   })
 
   await checkStatus(response)
-  const data = await tryGetJsonResponse(response)
+  const data = await getResponsePayload(response, expectedType)
   return data
 }
 
@@ -100,6 +155,7 @@ export const patch = async ({
   body,
   headers,
   credentials = 'include',
+  expectedType = ResponseType.json,
 }) => {
   const response = await fetch(url, {
     method: HTTP_METHODS.PATCH,
@@ -112,7 +168,7 @@ export const patch = async ({
   })
 
   await checkStatus(response)
-  const data = await tryGetJsonResponse(response)
+  const data = await getResponsePayload(response, expectedType)
   return data
 }
 
@@ -121,6 +177,7 @@ export const deleteApi = async ({
   body,
   headers,
   credentials = 'include',
+  expectedType = ResponseType.json,
 }) => {
   const response = await fetch(url, {
     method: HTTP_METHODS.DELETE,
@@ -133,14 +190,14 @@ export const deleteApi = async ({
   })
 
   await checkStatus(response)
-  const data = await tryGetJsonResponse(response)
+  const data = await getResponsePayload(response, expectedType)
   return data
 }
 
 export const http = {
   get,
+  put,
   post,
   patch,
-  put,
   deleteApi,
 }

package/src/http/responseType.js

@@ -0,0 +1,6 @@
+export const ResponseType = Object.freeze({
+  xml: 'xml',
+  json: 'json',
+  text: 'text',
+  file: 'file',
+})

package/src/index.js

@@ -1,3 +1,6 @@
+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'
 export { HttpError } from './http/HttpError.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()