core-services-sdk 1.3.7 → 1.3.8

package/src/rabbit-mq/rabbit-mq.js

@@ -0,0 +1,189 @@
+// @ts-nocheck
+import * as 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 = /** @type {amqp.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 {Object} options
+ * @param {import('amqplib').Channel} options.channel - RabbitMQ channel
+ * @param {string} options.queue - Queue name to subscribe to
+ * @param {(data: any) => Promise<void>} options.onReceive - Async handler for incoming message
+ * @param {Log} options.log - Logging utility
+ * @param {boolean} [options.nackOnError=false] - Whether to nack the message on error (default: false)
+ * @param {number} [options.prefetch=1] - Max unacked messages per consumer (default: 1)
+ *
+ * @returns {Promise<void>}
+ */
+export const subscribeToQueue = async ({
+  log,
+  queue,
+  channel,
+  prefetch = 1,
+  onReceive,
+  nackOnError = false,
+}) => {
+  try {
+    await channel.assertQueue(queue, { durable: true })
+
+    !!prefetch && (await channel.prefetch(prefetch))
+
+    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/templates/index.js

@@ -0,0 +1 @@
+export * from './template-loader.js'

package/tests/fastify/error-handler.unit.test.js

@@ -0,0 +1,39 @@
+import httpStatus from 'http-status'
+import { describe, it, expect } from 'vitest'
+
+import { GENERAL_ERROR } from '../../src/fastify/error-codes.js'
+
+describe('GENERAL_ERROR', () => {
+  it('should have correct status code', () => {
+    expect(GENERAL_ERROR.httpStatusCode).toBe(httpStatus.INTERNAL_SERVER_ERROR)
+  })
+
+  it('should have correct status text', () => {
+    expect(GENERAL_ERROR.httpStatusText).toBe(
+      httpStatus[httpStatus.INTERNAL_SERVER_ERROR],
+    )
+  })
+
+  it('should have correct code format', () => {
+    const expectedCode = `GENERAL.${
+      httpStatus[httpStatus.INTERNAL_SERVER_ERROR]
+    }`
+    expect(GENERAL_ERROR.code).toBe(expectedCode)
+  })
+
+  it('should have all required properties and types', () => {
+    expect(typeof GENERAL_ERROR.httpStatusCode).toBe('number')
+    expect(typeof GENERAL_ERROR.httpStatusText).toBe('string')
+    expect(typeof GENERAL_ERROR.code).toBe('string')
+  })
+
+  it('should match full expected structure', () => {
+    const expected = {
+      httpStatusCode: 500,
+      httpStatusText: 'Internal Server Error',
+      code: 'GENERAL.Internal Server Error',
+    }
+
+    expect(GENERAL_ERROR).toEqual(expected)
+  })
+})

package/tests/{with-error-handling.test.js → fastify/error-handlers/with-error-handling.test.js}

@@ -1,13 +1,14 @@
+// @ts-nocheck
 import httpStatus from 'http-status'
 import { describe, it, expect, vi, beforeEach } from 'vitest'
 
-import { HttpError } from '../src/http/HttpError.js'
-import { GENERAL_ERROR } from '../src/fastify/error-codes.js'
+import { HttpError } from '../../../src/http/HttpError.js'
+import { GENERAL_ERROR } from '../../../src/fastify/error-codes.js'
 import {
   replyOnErrorOnly,
   withErrorHandling,
   withErrorHandlingReply,
-} from '../src/fastify/error-handlers/with-error-handling.js'
+} from '../../../src/fastify/error-handlers/with-error-handling.js'
 
 describe('withErrorHandling', () => {
   const log = { error: vi.fn() }

package/tests/http/HttpError.unit.test.js

@@ -0,0 +1,112 @@
+import httpStatus from 'http-status'
+import { describe, it, expect } from 'vitest'
+
+import { HttpError } from '../../src/http/HttpError.js'
+
+describe('HttpError', () => {
+  it('should create an instance with custom message, code, and extendInfo', () => {
+    const error = new HttpError({
+      code: 'INVALID_INPUT',
+      message: 'Invalid input provided',
+      httpStatusCode: 400,
+      extendInfo: { field: 'email', reason: 'missing' },
+    })
+
+    expect(error).toBeInstanceOf(HttpError)
+    expect(error.message).toBe('Invalid input provided')
+    expect(error.code).toBe('INVALID_INPUT')
+    expect(error.httpStatusCode).toBe(400)
+    expect(error.httpStatusText).toBe(httpStatus[400])
+    expect(error.extendInfo).toEqual({ field: 'email', reason: 'missing' })
+  })
+
+  it('should fallback to default message from status if message is missing', () => {
+    const error = new HttpError({
+      code: 'BAD_REQUEST',
+      httpStatusCode: 400,
+    })
+
+    expect(error.message).toBe(httpStatus[400])
+    expect(error.httpStatusText).toBe(httpStatus[400])
+    expect(error.extendInfo).toBeUndefined()
+  })
+
+  it('should fallback to code as message if message and status code missing', () => {
+    const error = new HttpError({ code: 'ERROR_CODE_ONLY' })
+
+    expect(error.message).toBe('ERROR_CODE_ONLY')
+    expect(error.httpStatusCode).toBeUndefined()
+    expect(error.extendInfo).toBeUndefined()
+  })
+
+  it('should fallback to "Unknown error" if no data provided', () => {
+    const error = new HttpError()
+
+    expect(error.message).toBe('Unknown error')
+    expect(error.extendInfo).toBeUndefined()
+  })
+
+  it('should return correct JSON representation without extendInfo', () => {
+    const error = new HttpError({
+      code: 'NOT_FOUND',
+      message: 'Resource not found',
+      httpStatusCode: 404,
+    })
+
+    expect(error.toJSON()).toEqual({
+      code: 'NOT_FOUND',
+      message: 'Resource not found',
+      httpStatusCode: 404,
+      httpStatusText: httpStatus[404],
+    })
+  })
+
+  it('should return correct JSON representation with extendInfo', () => {
+    const error = new HttpError({
+      code: 'NOT_FOUND',
+      message: 'Resource not found',
+      httpStatusCode: 404,
+      extendInfo: { resource: 'user', id: 123 },
+    })
+
+    expect(error.toJSON()).toEqual({
+      code: 'NOT_FOUND',
+      message: 'Resource not found',
+      httpStatusCode: 404,
+      httpStatusText: httpStatus[404],
+      extendInfo: { resource: 'user', id: 123 },
+    })
+  })
+
+  it('should detect instance using isHttpError', () => {
+    const error = new HttpError({
+      code: 'TEST',
+      httpStatusCode: 500,
+    })
+
+    expect(HttpError.isHttpError(error)).toBe(true)
+    expect(HttpError.isHttpError(new Error('x'))).toBe(false)
+  })
+
+  it('FromError should return same instance if already HttpError', () => {
+    const original = new HttpError({
+      code: 'ALREADY_HTTP',
+      httpStatusCode: 401,
+    })
+    const result = HttpError.FromError(original)
+
+    expect(result).toBe(original)
+  })
+
+  it('FromError should wrap generic Error', () => {
+    const err = new Error('Boom!')
+    const httpError = HttpError.FromError(err)
+
+    expect(httpError).toBeInstanceOf(HttpError)
+    expect(httpError.message).toBe('Boom!')
+    expect(httpError.code).toBe('UNHANDLED_ERROR')
+    expect(httpError.httpStatusCode).toBe(500)
+    expect(httpError.httpStatusText).toBe(httpStatus[500])
+    expect(httpError.extendInfo).toBeUndefined()
+  })
+})

package/tests/http/http-method.unit.test.js

@@ -0,0 +1,29 @@
+// @ts-nocheck
+import { describe, it, expect } from 'vitest'
+
+import { HTTP_METHODS } from '../../src/http/http-method.js'
+
+describe('HTTP_METHODS constant', () => {
+  it('should include all standard HTTP methods', () => {
+    expect(HTTP_METHODS).toEqual({
+      GET: 'GET',
+      POST: 'POST',
+      PUT: 'PUT',
+      PATCH: 'PATCH',
+      DELETE: 'DELETE',
+    })
+  })
+
+  it('should be frozen (immutable)', () => {
+    expect(Object.isFrozen(HTTP_METHODS)).toBe(true)
+
+    // Attempt to mutate and verify it fails
+    try {
+      HTTP_METHODS.NEW = 'NEW'
+    } catch (err) {
+      // Ignore in strict mode
+    }
+
+    expect(HTTP_METHODS).not.toHaveProperty('NEW')
+  })
+})

package/tests/http/http.unit.test.js

@@ -0,0 +1,167 @@
+import { vi, it, expect, describe, afterEach } from 'vitest'
+
+import fetch from 'node-fetch'
+import { http } from '../../src/http/http.js'
+import { HttpError } from '../../src/http/HttpError.js'
+import { HTTP_METHODS } from '../../src/http/http-method.js'
+import { ResponseType } from '../../src/http/responseType.js'
+
+vi.mock('node-fetch', async () => {
+  const actual = await vi.importActual('node-fetch')
+  return {
+    ...actual,
+    default: vi.fn(),
+  }
+})
+
+const mockFetch = /** @type {typeof fetch} */ (fetch)
+
+const createMockResponse = ({
+  body = '',
+  status = 200,
+  statusText = 'OK',
+  headers = {},
+} = {}) => {
+  return {
+    ok: status >= 200 && status < 300,
+    status,
+    statusText,
+    text: vi.fn().mockResolvedValue(body),
+    headers: { get: vi.fn().mockImplementation((k) => headers[k]) },
+  }
+}
+
+describe('http client', () => {
+  afterEach(() => {
+    vi.clearAllMocks()
+  })
+
+  describe('GET', () => {
+    it('should return parsed JSON response', async () => {
+      // @ts-ignore
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({ body: JSON.stringify({ hello: 'world' }) }),
+      )
+
+      const result = await http.get({ url: 'http://test.com' })
+      expect(result).toEqual({ hello: 'world' })
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.com',
+        expect.objectContaining({ method: HTTP_METHODS.GET }),
+      )
+    })
+
+    it('should throw HttpError on non-2xx status', async () => {
+      // @ts-ignore
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({
+          status: 404,
+          statusText: 'Not Found',
+          body: JSON.stringify({ error: 'not found' }),
+        }),
+      )
+
+      await expect(http.get({ url: 'http://fail.com' })).rejects.toThrow(
+        HttpError,
+      )
+    })
+  })
+
+  describe('POST', () => {
+    it('should send a JSON body and return parsed JSON', async () => {
+      // @ts-ignore
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({ body: JSON.stringify({ ok: true }) }),
+      )
+
+      const result = await http.post({
+        url: 'http://test.com',
+        body: { test: 123 },
+      })
+
+      expect(result).toEqual({ ok: true })
+      expect(mockFetch).toHaveBeenCalledWith(
+        'http://test.com',
+        expect.objectContaining({
+          method: HTTP_METHODS.POST,
+          body: JSON.stringify({ test: 123 }),
+        }),
+      )
+    })
+  })
+
+  describe('PUT', () => {
+    it('should send a PUT request and return JSON', async () => {
+      // @ts-ignore
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({ body: JSON.stringify({ updated: true }) }),
+      )
+
+      const result = await http.put({
+        url: 'http://test.com',
+        body: { name: 'Updated' },
+      })
+
+      expect(result).toEqual({ updated: true })
+    })
+  })
+
+  describe('PATCH', () => {
+    it('should send a PATCH request and return JSON', async () => {
+      // @ts-ignore
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({ body: JSON.stringify({ patched: true }) }),
+      )
+
+      const result = await http.patch({
+        url: 'http://test.com',
+        body: { field: 'value' },
+      })
+
+      expect(result).toEqual({ patched: true })
+    })
+  })
+
+  describe('DELETE', () => {
+    it('should send a DELETE request with body and return JSON', async () => {
+      // @ts-ignore
+      mockFetch.mockResolvedValueOnce(
+        createMockResponse({ body: JSON.stringify({ deleted: true }) }),
+      )
+
+      const result = await http.deleteApi({
+        url: 'http://test.com',
+        body: { id: 1 },
+      })
+
+      expect(result).toEqual({ deleted: true })
+    })
+  })
+
+  describe('ResponseType', () => {
+    it('should return text if expectedType is text', async () => {
+      // @ts-ignore
+      mockFetch.mockResolvedValueOnce(createMockResponse({ body: 'hello' }))
+
+      const result = await http.get({
+        url: 'http://test.com',
+        expectedType: ResponseType.text,
+      })
+
+      expect(result).toBe('hello')
+    })
+
+    it('should return XML as parsed object if expectedType is xml', async () => {
+      const xml = `<note><to>User</to><from>ChatGPT</from></note>`
+      // @ts-ignore
+      mockFetch.mockResolvedValueOnce(createMockResponse({ body: xml }))
+
+      const result = await http.get({
+        url: 'http://test.com',
+        expectedType: ResponseType.xml,
+      })
+
+      expect(result).toHaveProperty('note')
+    })
+  })
+})

package/tests/http/responseType.unit.test.js

@@ -0,0 +1,45 @@
+// @ts-nocheck
+import { describe, it, expect } from 'vitest'
+
+import { ResponseType } from '../../src/http/responseType.js'
+
+describe('ResponseType', () => {
+  it('should contain correct response type mappings', () => {
+    expect(ResponseType).toEqual({
+      xml: 'xml',
+      json: 'json',
+      text: 'text',
+      file: 'file',
+    })
+  })
+
+  it('should be frozen (immutable)', () => {
+    expect(Object.isFrozen(ResponseType)).toBe(true)
+
+    // Try to add new property
+    expect(() => {
+      ResponseType.newType = 'something'
+    }).toThrow(TypeError)
+
+    // Try to overwrite existing property
+    expect(() => {
+      ResponseType.json = 'override'
+    }).toThrow(TypeError)
+
+    // Ensure original value remains unchanged
+    expect(ResponseType.json).toBe('json')
+  })
+
+  it('should include expected keys', () => {
+    const keys = Object.keys(ResponseType)
+    expect(keys).toEqual(['xml', 'json', 'text', 'file'])
+  })
+
+  it('should include expected values', () => {
+    const values = Object.values(ResponseType)
+    expect(values).toContain('json')
+    expect(values).toContain('xml')
+    expect(values).toContain('text')
+    expect(values).toContain('file')
+  })
+})

package/tests/ids/prefixes.unit.test.js

@@ -12,6 +12,7 @@ describe('ID_PREFIXES', () => {
       CORRELATION: 'crln',
       VERIFICATION: 'vrf',
       ROLE_PERMISSIONS: 'role',
+      ONBOARDING: 'onb',
     })
   })