core-services-sdk 1.3.7 → 1.3.9

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

package/tests/mailer/mailer.integration.test.js

@@ -0,0 +1,95 @@
+import nodemailer from 'nodemailer'
+import { describe, it, expect, beforeAll } from 'vitest'
+
+import { Mailer } from '../../src/mailer/mailer.service.js'
+
+describe('Mailer (integration)', () => {
+  let transporter
+  let mailer
+  let testAccount
+
+  beforeAll(async () => {
+    testAccount = await nodemailer.createTestAccount()
+
+    transporter = nodemailer.createTransport({
+      host: testAccount.smtp.host,
+      port: testAccount.smtp.port,
+      secure: testAccount.smtp.secure,
+      auth: {
+        user: testAccount.user,
+        pass: testAccount.pass,
+      },
+    })
+
+    mailer = new Mailer(transporter)
+  })
+
+  it('should send email with HTML + text', async () => {
+    const result = await mailer.send({
+      to: 'recipient@example.com',
+      from: '"My App" <no-reply@example.com>',
+      subject: 'Integration Test: HTML + text',
+      text: 'Hello from plain text',
+      html: '<strong>Hello HTML</strong>',
+      cc: '',
+      bcc: '',
+      replyTo: '',
+      attachments: '',
+    })
+
+    expect(result.messageId).toBeDefined()
+    expect(result.envelope).toBeDefined()
+    expect(result.accepted).toContain('recipient@example.com')
+
+    const previewUrl = nodemailer.getTestMessageUrl(result)
+    console.log(`📨 Preview (HTML+text): ${previewUrl}`)
+    expect(previewUrl).toMatch(/^https:\/\/ethereal\.email/)
+  })
+
+  it('should send HTML-only email', async () => {
+    const result = await mailer.send({
+      to: 'recipient2@example.com',
+      from: '"My App" <no-reply@example.com>',
+      subject: 'Integration Test: HTML only',
+      html: '<h2>Only HTML</h2>',
+      cc: '',
+      bcc: '',
+      text: '',
+      replyTo: '',
+      attachments: '',
+    })
+
+    expect(result.messageId).toBeDefined()
+    expect(result.accepted).toContain('recipient2@example.com')
+
+    const previewUrl = nodemailer.getTestMessageUrl(result)
+    console.log(`📨 Preview (HTML only): ${previewUrl}`)
+    expect(previewUrl).toMatch(/^https:\/\/ethereal\.email/)
+  })
+
+  it('should send email with attachment', async () => {
+    const result = await mailer.send({
+      to: 'recipient3@example.com',
+      from: '"My App" <no-reply@example.com>',
+      subject: 'Integration Test: With Attachment',
+      text: 'See attached file.',
+      html: '<p>See attached file.</p>',
+      attachments: [
+        {
+          filename: 'test.txt',
+          content: 'This is the content of the attachment.',
+        },
+      ],
+      cc: '',
+      bcc: '',
+      replyTo: '',
+    })
+
+    expect(result.messageId).toBeDefined()
+    expect(result.accepted).toContain('recipient3@example.com')
+
+    const previewUrl = nodemailer.getTestMessageUrl(result)
+    console.log(`📨 Preview (With Attachment): ${previewUrl}`)
+    expect(previewUrl).toMatch(/^https:\/\/ethereal\.email/)
+  })
+})

package/tests/{mailer.unit.test.js → mailer/mailer.unit.test.js}

@@ -4,9 +4,9 @@ const mockTransport = {
   sendMail: vi.fn(),
 }
 
-// Dynamically mock the TransportFactory module and turn .create into a spy
-vi.mock('../src/mailer/transport.factory.js', async () => {
-  const actual = await vi.importActual('../src/mailer/transport.factory.js')
+// Mock the TransportFactory with a spy
+vi.mock('../../src/mailer/transport.factory.js', async () => {
+  const actual = await vi.importActual('../../src/mailer/transport.factory.js') // fixed path
   return {
     ...actual,
     TransportFactory: {
@@ -16,17 +16,16 @@ vi.mock('../src/mailer/transport.factory.js', async () => {
 })
 
 // Mock Mailer class
-vi.mock('../src/mailer/mailer.service.js', async () => {
+vi.mock('../../src/mailer/mailer.service.js', async () => {
   const Mailer = vi.fn().mockImplementation((transport) => ({
     send: vi.fn((opts) => transport.sendMail(opts)),
   }))
   return { Mailer }
 })
 
-// Only now import code under test
-import { initMailer } from '../src/mailer/index.js'
-import { TransportFactory } from '../src/mailer/transport.factory.js'
-import { Mailer } from '../src/mailer/mailer.service.js'
+import { initMailer } from '../../src/mailer/index.js'
+import { Mailer } from '../../src/mailer/mailer.service.js'
+import { TransportFactory } from '../../src/mailer/transport.factory.js'
 
 describe('initMailer', () => {
   beforeEach(() => {
@@ -44,10 +43,7 @@ describe('initMailer', () => {
 
     const mailer = initMailer(config)
 
-    // Ensure TransportFactory.create was called
     expect(TransportFactory.create).toHaveBeenCalledWith(config)
-
-    // Ensure Mailer was created with the mock transport
     expect(Mailer).toHaveBeenCalledWith(mockTransport)
 
     const emailOptions = {

package/tests/mailer/transport.factory.unit.test.js

@@ -0,0 +1,204 @@
+import nodemailer from 'nodemailer'
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+// ===================
+// SAFELY MOCK MODULES
+// ===================
+
+vi.mock('nodemailer', () => {
+  const createTransport = vi.fn((options) => ({
+    type: 'mock-transport',
+    options,
+  }))
+  return {
+    __esModule: true,
+    default: { createTransport },
+    createTransport,
+  }
+})
+
+vi.mock('nodemailer-sendgrid-transport', () => ({
+  __esModule: true,
+  default: vi.fn((opts) => ({
+    sendgrid: true,
+    options: opts,
+  })),
+}))
+
+vi.mock('@aws-sdk/client-ses', () => {
+  const mockSesInstance = { mocked: true } // consistent reference
+  const sesClient = vi.fn(() => mockSesInstance)
+
+  globalThis.__mockedSesClient__ = sesClient
+  globalThis.__mockedSesInstance__ = mockSesInstance
+
+  return {
+    SESClient: sesClient,
+    SendRawEmailCommand: 'mocked-command',
+  }
+})
+
+vi.mock('@aws-sdk/credential-provider-node', () => {
+  const defaultProvider = vi.fn(() => 'mocked-default-provider')
+  globalThis.__mockedDefaultProvider__ = defaultProvider
+  return {
+    defaultProvider,
+  }
+})
+
+// ==========================
+// NOW IMPORT MODULE UNDER TEST
+// ==========================
+
+import { TransportFactory } from '../../src/mailer/transport.factory.js'
+
+describe('TransportFactory', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+  })
+
+  it('should create smtp transport', () => {
+    const config = {
+      type: 'smtp',
+      host: 'smtp.example.com',
+      port: 587,
+      secure: false,
+      auth: { user: 'user', pass: 'pass' },
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    expect(nodemailer.createTransport).toHaveBeenCalledWith({
+      host: config.host,
+      port: config.port,
+      secure: config.secure,
+      auth: config.auth,
+    })
+
+    // @ts-ignore
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should create gmail transport', () => {
+    const config = {
+      type: 'gmail',
+      auth: { user: 'user@gmail.com', pass: 'pass' },
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    expect(nodemailer.createTransport).toHaveBeenCalledWith({
+      service: 'gmail',
+      auth: config.auth,
+    })
+
+    // @ts-ignore
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should create sendgrid transport', () => {
+    const config = {
+      type: 'sendgrid',
+      apiKey: 'SG.xxxx',
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    // @ts-ignore
+    const args = nodemailer.createTransport.mock.calls[0][0]
+
+    expect(args).toEqual({
+      sendgrid: true,
+      options: {
+        auth: { api_key: config.apiKey },
+      },
+    })
+
+    expect(transport).toEqual({
+      type: 'mock-transport',
+      options: {
+        sendgrid: true,
+        options: {
+          auth: { api_key: config.apiKey },
+        },
+      },
+    })
+  })
+
+  it('should create ses transport with credentials', () => {
+    const config = {
+      type: 'ses',
+      accessKeyId: 'AKIA...',
+      secretAccessKey: 'secret',
+      region: 'us-west-2',
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    expect(globalThis.__mockedSesClient__).toHaveBeenCalledWith({
+      region: config.region,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey,
+      },
+    })
+
+    // @ts-ignore
+    const args = nodemailer.createTransport.mock.calls[0][0]
+
+    expect(args).toEqual({
+      SES: {
+        ses: globalThis.__mockedSesInstance__,
+        aws: {
+          SendRawEmailCommand: 'mocked-command',
+        },
+      },
+    })
+
+    // @ts-ignore
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should create ses transport with defaultProvider fallback', () => {
+    const config = {
+      type: 'ses',
+      region: 'us-east-1',
+    }
+
+    // @ts-ignore
+    const transport = TransportFactory.create(config)
+
+    expect(globalThis.__mockedDefaultProvider__).toHaveBeenCalled()
+
+    expect(globalThis.__mockedSesClient__).toHaveBeenCalledWith({
+      region: config.region,
+      credentials: 'mocked-default-provider',
+    })
+
+    // @ts-ignore
+    const args = nodemailer.createTransport.mock.calls[0][0]
+
+    expect(args).toEqual({
+      SES: {
+        ses: globalThis.__mockedSesInstance__,
+        aws: {
+          SendRawEmailCommand: 'mocked-command',
+        },
+      },
+    })
+
+    // @ts-ignore
+    expect(transport.type).toBe('mock-transport')
+  })
+
+  it('should throw error for unsupported type', () => {
+    expect(() => {
+      // @ts-ignore
+      TransportFactory.create({ type: 'invalid' })
+    }).toThrow('Unsupported transport type: invalid')
+  })
+})

package/tests/mongodb/connect.unit.test.js

@@ -0,0 +1,60 @@
+// @ts-nocheck
+import { MongoClient, ServerApiVersion } from 'mongodb'
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+import { mongoConnect } from '../../src/mongodb/connect.js'
+
+vi.mock('mongodb', async () => {
+  const actual = await vi.importActual('mongodb')
+  return {
+    ...actual,
+    MongoClient: {
+      connect: vi.fn(),
+    },
+    ServerApiVersion: actual.ServerApiVersion, // use real enum
+  }
+})
+
+describe('mongoConnect', () => {
+  const fakeClient = { db: vi.fn() }
+
+  beforeEach(() => {
+    vi.clearAllMocks()
+    MongoClient.connect.mockResolvedValue(fakeClient)
+  })
+
+  it('should call MongoClient.connect with default serverApi options', async () => {
+    const uri = 'mongodb://localhost:27017'
+    await mongoConnect({ uri })
+
+    expect(MongoClient.connect).toHaveBeenCalledWith(uri, {
+      serverApi: {
+        version: ServerApiVersion.v1,
+        strict: true,
+        deprecationErrors: true,
+      },
+    })
+  })
+
+  it('should merge custom serverApi options', async () => {
+    const uri = 'mongodb://localhost:27017'
+    const serverApi = { strict: false }
+
+    await mongoConnect({ uri, serverApi })
+
+    expect(MongoClient.connect).toHaveBeenCalledWith(uri, {
+      serverApi: {
+        version: ServerApiVersion.v1,
+        strict: false,
+        deprecationErrors: true,
+      },
+    })
+  })
+
+  it('should return the connected client', async () => {
+    const uri = 'mongodb://localhost:27017'
+    const client = await mongoConnect({ uri })
+
+    expect(client).toBe(fakeClient)
+  })
+})