core-services-sdk 1.0.0

package/.prettierignore

@@ -0,0 +1 @@
+*.env

package/.prettierrc.json

@@ -0,0 +1,15 @@
+{
+  "arrowParens": "always",
+  "bracketSpacing": true,
+  "endOfLine": "lf",
+  "requirePragma": false,
+  "insertPragma": false,
+  "jsxBracketSameLine": false,
+  "jsxSingleQuote": true,
+  "printWidth": 80,
+  "quoteProps": "consistent",
+  "semi": false,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "all"
+}

package/.vscode/launch.json

@@ -0,0 +1,20 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug Vitest",
+      "autoAttachChildProcesses": true,
+      "program": "${workspaceFolder}/node_modules/vitest/vitest.mjs",
+      "args": ["run"],
+      "smartStep": true,
+      "skipFiles": ["<node_internals>/**"],
+      "console": "integratedTerminal"
+    }
+  ]
+}

package/.vscode/settings.json

@@ -0,0 +1,16 @@
+{
+  "explorer.sortOrder": "filesFirst",
+  "explorer.openEditors.visible": 0,
+  "editor.defaultFormatter": "esbenp.prettier-vscode",
+  "editor.formatOnSave": true,
+  "[javascript]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode"
+  },
+  "launch": {
+    "configurations": [],
+    "compounds": []
+  },
+  "javascript.preferences.importModuleSpecifierEnding": "js",
+  "js/ts.implicitProjectConfig.checkJs": true,
+  "javascript.validate.enable": false
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "core-services-sdk",
+  "version": "1.0.0",
+  "main": "src/index.js",
+  "type": "module",
+  "scripts": {
+    "test": "vitest run --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/haim-rubin/core-services-sdk.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/haim-rubin/core-services-sdk/issues"
+  },
+  "homepage": "https://github.com/haim-rubin/core-services-sdk#readme",
+  "description": "",
+  "dependencies": {
+    "amqplib": "^0.10.8",
+    "uuid": "^11.1.0"
+  },
+  "devDependencies": {
+    "@vitest/coverage-v8": "^3.2.4",
+    "path": "^0.12.7",
+    "url": "^0.11.4",
+    "vitest": "^3.2.4"
+  }
+}

package/src/index.js

@@ -0,0 +1 @@
+export * from './rabbit-mq/index.js'

package/src/rabbit-mq/index.js

@@ -0,0 +1,181 @@
+import amqp from 'amqplib'
+import { v4 as uuidv4 } from 'uuid'
+
+/**
+ * @typedef {Object} Log
+ * @property {(msg: string) => void} info
+ * @property {(msg: string, ...args: any[]) => void} error
+ */
+
+/**
+ * Connects to RabbitMQ server.
+ * @param {{ host: string }} options
+ * @returns {Promise<amqp.Connection>}
+ */
+export const connectQueueService = async ({ host }) => {
+  try {
+    return await amqp.connect(host)
+  } catch (error) {
+    console.error('Failed to connect to RabbitMQ:', error)
+    throw error
+  }
+}
+
+/**
+ * Creates a channel from RabbitMQ connection.
+ * @param {{ host: string }} options
+ * @returns {Promise<amqp.Channel>}
+ */
+export const createChannel = async ({ host }) => {
+  try {
+    const connection = await connectQueueService({ host })
+    return await connection.createChannel()
+  } catch (error) {
+    console.error('Failed to create channel:', error)
+    throw error
+  }
+}
+
+/**
+ * Parses a RabbitMQ message.
+ * @param {amqp.ConsumeMessage} msgInfo
+ * @returns {{ msgId: string, data: any }}
+ */
+const parseMessage = (msgInfo) => {
+  return JSON.parse(msgInfo.content.toString())
+}
+
+/**
+ * Subscribes to a queue to receive messages.
+ * @param {{
+ *   channel: amqp.Channel,
+ *   queue: string,
+ *   onReceive: (data: any) => Promise<void>,
+ *   log: Log,
+ *   nackOnError?: boolean
+ * }} options
+ * @returns {Promise<void>}
+ */
+export const subscribeToQueue = async ({
+  channel,
+  queue,
+  onReceive,
+  log,
+  nackOnError = false,
+}) => {
+  try {
+    await channel.assertQueue(queue, { durable: true })
+
+    channel.consume(queue, async (msgInfo) => {
+      if (!msgInfo) return
+
+      try {
+        const { msgId, data } = parseMessage(msgInfo)
+        log.info(`Handling message from '${queue}' msgId: ${msgId}`)
+        await onReceive(data)
+        channel.ack(msgInfo)
+      } catch (error) {
+        const { msgId } = parseMessage(msgInfo)
+        log.error(`Error handling message: ${msgId} on queue '${queue}'`)
+        log.error(error)
+        nackOnError ? channel.nack(msgInfo) : channel.ack(msgInfo)
+      }
+    })
+  } catch (error) {
+    console.error('Failed to subscribe to queue:', error)
+    throw error
+  }
+}
+
+/**
+ * Initializes RabbitMQ integration with publish and subscribe support.
+ *
+ * @param {Object} options
+ * @param {string} options.host - RabbitMQ connection URI (e.g., 'amqp://user:pass@localhost:5672')
+ * @param {Log} options.log - Logging utility with `info()` and `error()` methods
+ *
+ * @returns {Promise<{
+ *   publish: (queue: string, data: any) => Promise<boolean>,
+ *   subscribe: (options: {
+ *     queue: string,
+ *     onReceive: (data: any) => Promise<void>,
+ *     nackOnError?: boolean
+ *   }) => Promise<void>,
+ *   channel: amqp.Channel
+ * }>}
+ *
+ * @example
+ * const rabbit = await initializeQueue({ host, log });
+ * await rabbit.publish('jobs', { task: 'sendEmail' });
+ * await rabbit.subscribe({
+ *   queue: 'jobs',
+ *   onReceive: async (data) => { console.log(data); },
+ * });
+ */
+export const initializeQueue = async ({ host, log }) => {
+  const channel = await createChannel({ host })
+
+  /**
+   * Publishes a message to a queue.
+   * @param {string} queue
+   * @param {any} data
+   * @returns {Promise<boolean>}
+   */
+  const publish = async (queue, data) => {
+    const msgId = uuidv4()
+    try {
+      await channel.assertQueue(queue, { durable: true })
+      log.info(`Publishing to '${queue}' msgId: ${msgId}`)
+      return channel.sendToQueue(
+        queue,
+        Buffer.from(JSON.stringify({ msgId, data })),
+      )
+    } catch (error) {
+      log.error(`Error publishing to '${queue}' msgId: ${msgId}`)
+      log.error(error)
+      throw error
+    }
+  }
+
+  /**
+   * Subscribes to a queue.
+   * @param {{
+   *   queue: string,
+   *   onReceive: (data: any) => Promise<void>,
+   *   nackOnError?: boolean
+   * }} options
+   * @returns {Promise<void>}
+   */
+  const subscribe = async ({ queue, onReceive, nackOnError = false }) => {
+    return subscribeToQueue({ channel, queue, onReceive, log, nackOnError })
+  }
+
+  return {
+    channel,
+    publish,
+    subscribe,
+  }
+}
+
+/**
+ * Builds RabbitMQ URI from environment variables.
+ * @param {{
+ *   RABBIT_HOST: string,
+ *   RABBIT_PORT: string | number,
+ *   RABBIT_USERNAME: string,
+ *   RABBIT_PASSWORD: string,
+ *   RABBIT_PROTOCOL?: string
+ * }} env
+ * @returns {string}
+ */
+export const rabbitUriFromEnv = (env) => {
+  const {
+    RABBIT_HOST,
+    RABBIT_PORT,
+    RABBIT_USERNAME,
+    RABBIT_PASSWORD,
+    RABBIT_PROTOCOL = 'amqp',
+  } = env
+
+  return `${RABBIT_PROTOCOL}://${RABBIT_USERNAME}:${RABBIT_PASSWORD}@${RABBIT_HOST}:${RABBIT_PORT}`
+}

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

@@ -0,0 +1,22 @@
+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()

package/tests/rabbit-mq.test.js

@@ -0,0 +1,63 @@
+import { describe, it, expect, beforeAll } from 'vitest'
+import { initializeQueue, rabbitUriFromEnv } from '../src/rabbit-mq/index.js'
+
+const sleep = (ms) => new Promise((res) => setTimeout(res, ms))
+
+const testLog = {
+  info: () => {},
+  error: console.error,
+}
+
+describe('RabbitMQ SDK', () => {
+  const testQueue = 'testQueue'
+  const host = 'amqp://botq:botq@0.0.0.0:5672'
+  const testMessage = { text: 'Hello Rabbit' }
+
+  let sdk
+  let received = null
+
+  beforeAll(async () => {
+    sdk = await initializeQueue({ host, log: testLog })
+
+    await sdk.subscribe({
+      queue: testQueue,
+      onReceive: async (data) => {
+        received = data
+      },
+    })
+  })
+
+  it('should publish and receive message from queue', async () => {
+    await sdk.publish(testQueue, testMessage)
+    await sleep(300) // let the consumer process the message
+    expect(received).toEqual(testMessage)
+  })
+})
+
+describe('rabbitUriFromEnv', () => {
+  it('should build valid amqp URI from env', () => {
+    const env = {
+      RABBIT_HOST: '0.0.0.0',
+      RABBIT_PORT: 5672,
+      RABBIT_USERNAME: 'botq',
+      RABBIT_PASSWORD: 'botq',
+      _RABBIT_HOST: '0.0.0.0',
+      RABBIT_PROTOCOL: 'amqp',
+    }
+
+    const uri = rabbitUriFromEnv(env)
+    expect(uri).toBe('amqp://botq:botq@0.0.0.0:5672')
+  })
+
+  it('should fallback to amqp when protocol is missing', () => {
+    const env = {
+      RABBIT_HOST: '0.0.0.0',
+      RABBIT_PORT: 5672,
+      RABBIT_USERNAME: 'botq',
+      RABBIT_PASSWORD: 'botq',
+    }
+
+    const uri = rabbitUriFromEnv(env)
+    expect(uri).toBe('amqp://botq:botq@0.0.0.0:5672')
+  })
+})