core-services-sdk 1.3.56 → 1.3.59

package/tests/http/helpers/create-request-logger.test.js

@@ -0,0 +1,113 @@
+// @ts-nocheck
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+import { createRequestLogger } from '../../../src/http/helpers/create-request-logger.js'
+import { Context } from '../../../src/util/context.js'
+//@ts-ignore
+describe('createRequestLogger', () => {
+  let baseLogger
+
+  beforeEach(() => {
+    baseLogger = {
+      child: vi.fn(),
+    }
+  })
+
+  it('creates a child logger with context and request data', () => {
+    const request = {
+      method: 'GET',
+      url: '/test',
+      raw: { url: '/raw-test' },
+    }
+
+    const childLogger = {}
+    baseLogger.child.mockReturnValue(childLogger)
+
+    Context.run(
+      {
+        correlationId: 'corr-123',
+        ip: '127.0.0.1',
+        userAgent: 'vitest-agent',
+      },
+      () => {
+        const result = createRequestLogger(request, baseLogger)
+
+        expect(baseLogger.child).toHaveBeenCalledOnce()
+        expect(baseLogger.child).toHaveBeenCalledWith({
+          ip: '127.0.0.1',
+          userAgent: 'vitest-agent',
+          correlationId: 'corr-123',
+          op: 'GET /test',
+        })
+
+        expect(result).toBe(childLogger)
+      },
+    )
+  })
+
+  it('falls back to routeOptions.url when request.url is missing', () => {
+    const request = {
+      method: 'POST',
+      routeOptions: { url: '/route-url' },
+      raw: { url: '/raw-url' },
+    }
+
+    Context.run(
+      {
+        correlationId: 'corr-456',
+        ip: '10.0.0.1',
+        userAgent: 'agent-x',
+      },
+      () => {
+        createRequestLogger(request, baseLogger)
+
+        expect(baseLogger.child).toHaveBeenCalledWith(
+          expect.objectContaining({
+            op: 'POST /route-url',
+          }),
+        )
+      },
+    )
+  })
+
+  it('falls back to request.raw.url when neither url nor routeOptions.url exist', () => {
+    const request = {
+      method: 'PUT',
+      raw: { url: '/raw-only' },
+    }
+
+    Context.run(
+      {
+        correlationId: 'corr-789',
+        ip: '192.168.1.1',
+        userAgent: 'agent-y',
+      },
+      () => {
+        createRequestLogger(request, baseLogger)
+
+        expect(baseLogger.child).toHaveBeenCalledWith(
+          expect.objectContaining({
+            op: 'PUT /raw-only',
+          }),
+        )
+      },
+    )
+  })
+
+  it('handles missing context gracefully when no Context is active', () => {
+    const request = {
+      method: 'DELETE',
+      url: '/delete',
+      raw: { url: '/delete' },
+    }
+
+    createRequestLogger(request, baseLogger)
+
+    expect(baseLogger.child).toHaveBeenCalledWith({
+      ip: undefined,
+      userAgent: undefined,
+      correlationId: undefined,
+      op: 'DELETE /delete',
+    })
+  })
+})

package/tests/postgresql/paginate.integration.test.js

@@ -0,0 +1,165 @@
+import { describe, it, beforeAll, afterAll, beforeEach, expect } from 'vitest'
+import knex from 'knex'
+
+import {
+  stopPostgres,
+  startPostgres,
+  buildPostgresUri,
+} from '../../src/postgresql/start-stop-postgres-docker.js'
+
+import { sqlPaginate } from '../../src/postgresql/paginate.js'
+
+const PG_OPTIONS = {
+  port: 5443,
+  containerName: 'postgres-paginate-test',
+  user: 'testuser',
+  pass: 'testpass',
+  db: 'testdb',
+}
+
+const DATABASE_URI = buildPostgresUri(PG_OPTIONS)
+
+let db
+
+beforeAll(async () => {
+  startPostgres(PG_OPTIONS)
+
+  db = knex({
+    client: 'pg',
+    connection: DATABASE_URI,
+  })
+
+  await db.schema.createTable('tenants', (table) => {
+    table.uuid('id').primary()
+    table.string('name').notNullable()
+    table.string('type').notNullable()
+    table.timestamp('created_at').notNullable()
+  })
+})
+
+afterAll(async () => {
+  if (db) {
+    await db.destroy()
+  }
+  stopPostgres(PG_OPTIONS.containerName)
+})
+
+beforeEach(async () => {
+  await db('tenants').truncate()
+
+  await db('tenants').insert([
+    {
+      id: '00000000-0000-0000-0000-000000000001',
+      name: 'Tenant A',
+      type: 'business',
+      created_at: new Date('2024-01-01'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000002',
+      name: 'Tenant B',
+      type: 'business',
+      created_at: new Date('2024-01-02'),
+    },
+    {
+      id: '00000000-0000-0000-0000-000000000003',
+      name: 'Tenant C',
+      type: 'cpa',
+      created_at: new Date('2024-01-03'),
+    },
+  ])
+})
+
+describe('paginate integration', () => {
+  it('returns first page without ordering guarantees', async () => {
+    const result = await sqlPaginate({
+      db,
+      tableName: 'tenants',
+      page: 1,
+      limit: 2,
+    })
+
+    expect(result.totalCount).toBe(3)
+    expect(result.totalPages).toBe(2)
+    expect(result.currentPage).toBe(1)
+    expect(result.hasPrevious).toBe(false)
+    expect(result.hasNext).toBe(true)
+
+    expect(result.list).toHaveLength(2)
+  })
+
+  it('returns second page without ordering guarantees', async () => {
+    const result = await sqlPaginate({
+      db,
+      tableName: 'tenants',
+      page: 2,
+      limit: 2,
+    })
+
+    expect(result.totalCount).toBe(3)
+    expect(result.totalPages).toBe(2)
+    expect(result.currentPage).toBe(2)
+    expect(result.hasPrevious).toBe(true)
+    expect(result.hasNext).toBe(false)
+
+    expect(result.list).toHaveLength(1)
+  })
+
+  it('applies filters correctly without ordering guarantees', async () => {
+    const result = await sqlPaginate({
+      db,
+      tableName: 'tenants',
+      filter: { type: 'business' },
+      limit: 10,
+    })
+
+    expect(result.totalCount).toBe(2)
+
+    const names = result.list.map((t) => t.name).sort()
+    expect(names).toEqual(['Tenant A', 'Tenant B'])
+  })
+
+  it('supports custom ordering', async () => {
+    const result = await sqlPaginate({
+      db,
+      tableName: 'tenants',
+      orderBy: {
+        column: 'created_at',
+        direction: 'asc',
+      },
+    })
+
+    expect(result.list.map((t) => t.name)).toEqual([
+      'Tenant A',
+      'Tenant B',
+      'Tenant C',
+    ])
+  })
+
+  it('supports row mapping', async () => {
+    const result = await sqlPaginate({
+      db,
+      tableName: 'tenants',
+      mapRow: (row) => ({
+        ...row,
+        mapped: true,
+      }),
+    })
+
+    expect(result.list.length).toBeGreaterThan(0)
+    expect(result.list[0].mapped).toBe(true)
+  })
+
+  it('returns empty list when no records match filter', async () => {
+    const result = await sqlPaginate({
+      db,
+      tableName: 'tenants',
+      filter: { type: 'non-existing' },
+    })
+
+    expect(result.totalCount).toBe(0)
+    expect(result.totalPages).toBe(0)
+    expect(result.list).toEqual([])
+    expect(result.hasNext).toBe(false)
+    expect(result.hasPrevious).toBe(false)
+  })
+})

package/tests/rabbit-mq/rabbit-mq.test.js

@@ -1,69 +1,139 @@
-import { describe, it, expect, beforeAll } from 'vitest'
+import pino from 'pino'
+import { describe, it, beforeAll, afterAll, expect } from 'vitest'
 
-import { initializeQueue, rabbitUriFromEnv } from '../../src/rabbit-mq/index.js'
+import {
+  stopRabbit,
+  startRabbit,
+  buildRabbitUri,
+} from '../../src/rabbit-mq/start-stop-rabbitmq.js'
 
-const sleep = (ms) => new Promise((res) => setTimeout(res, ms))
+import { initializeQueue } from '../../src/rabbit-mq/index.js'
 
-const testLog = {
-  info: () => {},
-  error: console.error,
-  debug: console.debug,
-  child() {
-    return testLog
-  },
-}
+const RABBIT_CONTAINER = 'rabbit-test'
+const AMQP_PORT = 5679
+const UI_PORT = 15679
+const USER = 'test'
+const PASS = 'test'
+const QUEUE = 'integration-test-queue'
 
-describe('RabbitMQ SDK', () => {
-  const testQueue = 'testQueue'
-  const host = 'amqp://botq:botq@0.0.0.0:5672'
-  const testMessage = { text: 'Hello Rabbit' }
+const log = pino({
+  level: 'silent',
+})
+// @ts-ignore
+async function waitForRabbitConnection({ uri, log, timeoutMs = 10000 }) {
+  const start = Date.now()
 
-  let sdk
-  let received = null
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const rabbit = await initializeQueue({ host: uri, log })
+      return rabbit
+    } catch {
+      await sleep(300)
+    }
+  }
+
+  throw new Error('RabbitMQ AMQP endpoint did not become ready in time')
+}
+
+describe('RabbitMQ integration', () => {
+  // @ts-ignore
+  let rabbit
+  // @ts-ignore
+  let unsubscribe
+  // @ts-ignore
+  let receivedMessages
 
   beforeAll(async () => {
-    // @ts-ignore
-    sdk = await initializeQueue({ host, log: testLog })
+    startRabbit({
+      containerName: RABBIT_CONTAINER,
+      amqpPort: AMQP_PORT,
+      uiPort: UI_PORT,
+      user: USER,
+      pass: PASS,
+    })
+
+    const uri = buildRabbitUri({
+      user: USER,
+      pass: PASS,
+      port: AMQP_PORT,
+    })
+
+    rabbit = await waitForRabbitConnection({
+      uri,
+      log,
+    })
+  }, 60_000)
 
-    await sdk.subscribe({
-      queue: testQueue,
+  afterAll(async () => {
+    try {
+      // @ts-ignore
+      if (unsubscribe) {
+        await unsubscribe()
+      }
+      // @ts-ignore
+      if (rabbit) {
+        await rabbit.close()
+      }
+    } finally {
+      stopRabbit(RABBIT_CONTAINER)
+    }
+  })
+
+  it('should publish, consume, unsubscribe, and stop consuming', async () => {
+    receivedMessages = []
+
+    // @ts-ignore
+    unsubscribe = await rabbit.subscribe({
+      queue: QUEUE,
+      // @ts-ignore
       onReceive: async (data) => {
-        received = data
+        receivedMessages.push(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)
-  })
-})
+    // @ts-ignore
+    await rabbit.publish(QUEUE, { step: 1 })
+    await waitFor(() => receivedMessages.length === 1)
 
-describe('rabbitUriFromEnv', () => {
-  it('should build valid amqp URI from env', () => {
-    const env = {
-      RABBIT_PORT: 5672,
-      RABBIT_HOST: '0.0.0.0',
-      RABBIT_USERNAME: 'botq',
-      RABBIT_PASSWORD: 'botq',
-      _RABBIT_HOST: '0.0.0.0',
-      RABBIT_PROTOCOL: 'amqp',
-    }
+    // @ts-ignore
+    expect(receivedMessages).toEqual([{ step: 1 }])
 
-    const uri = rabbitUriFromEnv(env)
-    expect(uri).toBe('amqp://botq:botq@0.0.0.0:5672')
-  })
+    await unsubscribe()
 
-  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',
-    }
+    // @ts-ignore
+    await rabbit.publish(QUEUE, { step: 2 })
+
+    await sleep(1000)
 
-    const uri = rabbitUriFromEnv(env)
-    expect(uri).toBe('amqp://botq:botq@0.0.0.0:5672')
+    // @ts-ignore
+    expect(receivedMessages).toEqual([{ step: 1 }])
   })
 })
+
+/**
+ * Waits until a condition becomes true or times out.
+ *
+ * @param {() => boolean} predicate
+ * @param {number} timeoutMs
+ */
+async function waitFor(predicate, timeoutMs = 5000) {
+  const start = Date.now()
+
+  while (Date.now() - start < timeoutMs) {
+    if (predicate()) {
+      return
+    }
+    await sleep(50)
+  }
+
+  throw new Error('Condition not met within timeout')
+}
+
+/**
+ * Sleeps for the given number of milliseconds.
+ *
+ * @param {number} ms
+ */
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}

package/tests/resources/docker-mongo-test.js

@@ -80,15 +80,13 @@ function isConnected(port) {
  */
 function waitForMongo(port) {
   console.log(`[MongoTest] Waiting for MongoDB to be ready...`)
-  const maxRetries = 20
+  const maxRetries = 60
   let retries = 0
   let connected = false
 
   while (!connected && retries < maxRetries) {
-    try {
-      connected = isConnected(port)
-      retries++
-    } catch {
+    connected = isConnected(port)
+    if (!connected) {
       retries++
       execSync(`sleep 1`)
     }

package/types/http/helpers/create-request-logger.d.ts

@@ -0,0 +1,4 @@
+export function createRequestLogger(
+  request: import('fastify').FastifyRequest,
+  log: import('pino').Logger,
+): import('pino').Logger

package/types/http/index.d.ts

@@ -2,3 +2,4 @@ export * from './http.js'
 export * from './HttpError.js'
 export * from './http-method.js'
 export * from './responseType.js'
+export * from './helpers/create-request-logger.js'

package/types/mongodb/index.d.ts

@@ -3,3 +3,4 @@ export * from './paginate.js'
 export * from './dsl-to-mongo.js'
 export * from './initialize-mongodb.js'
 export * from './validate-mongo-uri.js'
+export { paginate as mongoPaginate } from './paginate.js'

package/types/postgresql/index.d.ts

@@ -1,3 +1,4 @@
+export * from './paginate.js'
 export * from './connect-to-pg.js'
 export * from './validate-schema.js'
 export * from './start-stop-postgres-docker.js'

package/types/postgresql/paginate.d.ts

@@ -0,0 +1,26 @@
+export function sqlPaginate({
+  db,
+  mapRow,
+  orderBy,
+  page,
+  limit,
+  tableName,
+  filter,
+}?: {
+  db: any
+  tableName: string
+  page?: number
+  limit?: number
+  filter?: any
+  orderBy?: {
+    column: string
+    direction?: 'asc' | 'desc'
+  }
+}): Promise<{
+  list: any[]
+  totalCount: number
+  totalPages: number
+  currentPage: number
+  hasNext: boolean
+  hasPrevious: boolean
+}>

package/types/rabbit-mq/index.d.ts

@@ -1 +1,2 @@
 export * from './rabbit-mq.js'
+export * from './start-stop-rabbitmq.js'

package/types/rabbit-mq/rabbit-mq.d.ts

@@ -29,7 +29,7 @@ export function subscribeToQueue({
   log: import('pino').Logger
   nackOnError?: boolean
   prefetch?: number
-}): Promise<string>
+}): Promise<() => Promise<void>>
 export function initializeQueue({
   host,
   log,

package/types/rabbit-mq/start-stop-rabbitmq.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Starts a RabbitMQ Docker container for testing purposes.
+ *
+ * If a container with the same name already exists, it will be removed first.
+ * The container is started with the RabbitMQ Management plugin enabled and
+ * waits until the health check reports the container as healthy.
+ *
+ * @param {Object} options
+ * @param {string} options.containerName
+ *   Docker container name.
+ *
+ * @param {number} options.amqpPort
+ *   Host port mapped to RabbitMQ AMQP port (5672).
+ *
+ * @param {number} options.uiPort
+ *   Host port mapped to RabbitMQ Management UI port (15672).
+ *
+ * @param {string} options.user
+ *   Default RabbitMQ username.
+ *
+ * @param {string} options.pass
+ *   Default RabbitMQ password.
+ *
+ * @returns {void}
+ *
+ * @throws {Error}
+ *   Throws if the RabbitMQ container fails to become healthy within the timeout.
+ */
+export function startRabbit({
+  containerName,
+  ...rest
+}: {
+  containerName: string
+  amqpPort: number
+  uiPort: number
+  user: string
+  pass: string
+}): void
+/**
+ * Stops and removes a RabbitMQ Docker container.
+ *
+ * This function is safe to call even if the container does not exist.
+ *
+ * @param {string} [containerName='rabbit-test']
+ *   Docker container name.
+ *
+ * @returns {void}
+ */
+export function stopRabbit(containerName?: string): void
+/**
+ * Builds a RabbitMQ AMQP connection URI for local testing.
+ *
+ * @param {Object} options
+ * @param {string} options.user
+ *   RabbitMQ username.
+ *
+ * @param {string} options.pass
+ *   RabbitMQ password.
+ *
+ * @param {number} options.port
+ *   Host port mapped to RabbitMQ AMQP port.
+ *
+ * @returns {string}
+ *   RabbitMQ AMQP connection URI.
+ */
+export function buildRabbitUri({
+  user,
+  pass,
+  port,
+}: {
+  user: string
+  pass: string
+  port: number
+}): string