core-services-sdk 1.3.6 → 1.3.8

package/src/rabbit-mq/index.js

@@ -1,186 +1 @@
-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<import('amqplib').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 {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}`
-}
+export * from './rabbit-mq.js'

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')
+  })
+})