core-services-sdk 1.3.2 → 1.3.4

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

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest'
+
+import {
+  generateId,
+  generateUserId,
+  generateTenantId,
+  generatePrefixedId,
+  generatePermissionId,
+  generateCorrelationId,
+  generateVerificationId,
+  generateRolePermissionsId,
+} from '../../src/ids/generators.js'
+import { ID_PREFIXES } from '../../src/ids/prefixes.js'
+
+const UUID_V4_REGEX =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i
+
+const testPrefixFunction = (fn, expectedPrefix) => {
+  const id = fn()
+  expect(typeof id).toBe('string')
+  const [prefix, uuid] = id.split('_')
+  expect(prefix).toBe(expectedPrefix)
+  expect(uuid).toMatch(UUID_V4_REGEX)
+}
+
+describe('generateId', () => {
+  it('generates a valid UUID v4', () => {
+    const id = generateId()
+    expect(typeof id).toBe('string')
+    expect(id).toMatch(UUID_V4_REGEX)
+  })
+
+  it('generates unique UUIDs', () => {
+    const ids = new Set(Array.from({ length: 10 }, () => generateId()))
+    expect(ids.size).toBe(10)
+  })
+})
+
+describe('generatePrefixedId', () => {
+  it('generates an ID with the correct prefix', () => {
+    const prefixed = generatePrefixedId('test')
+    const [prefix, uuid] = prefixed.split('_')
+    expect(prefix).toBe('test')
+    expect(uuid).toMatch(UUID_V4_REGEX)
+  })
+})
+
+describe('generate*Id functions', () => {
+  it('generateUserId returns ID with usr_ prefix', () => {
+    testPrefixFunction(generateUserId, ID_PREFIXES.USER)
+  })
+
+  it('generateTenantId returns ID with tnt_ prefix', () => {
+    testPrefixFunction(generateTenantId, ID_PREFIXES.TENANT)
+  })
+
+  it('generatePermissionId returns ID with prm_ prefix', () => {
+    testPrefixFunction(generatePermissionId, ID_PREFIXES.PERMISSION)
+  })
+
+  it('generateCorrelationId returns ID with crln_ prefix', () => {
+    testPrefixFunction(generateCorrelationId, ID_PREFIXES.CORRELATION)
+  })
+
+  it('generateVerificationId returns ID with vrf_ prefix', () => {
+    testPrefixFunction(generateVerificationId, ID_PREFIXES.VERIFICATION)
+  })
+
+  it('generateRolePermissionsId returns ID with role_ prefix', () => {
+    testPrefixFunction(generateRolePermissionsId, ID_PREFIXES.ROLE_PERMISSIONS)
+  })
+})

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

@@ -0,0 +1,42 @@
+// @ts-nocheck
+import { describe, it, expect } from 'vitest'
+
+import { ID_PREFIXES } from '../../src/ids/prefixes.js'
+
+describe('ID_PREFIXES', () => {
+  it('contains expected keys and values', () => {
+    expect(ID_PREFIXES).toEqual({
+      USER: 'usr',
+      TENANT: 'tnt',
+      PERMISSION: 'prm',
+      CORRELATION: 'crln',
+      VERIFICATION: 'vrf',
+      ROLE_PERMISSIONS: 'role',
+    })
+  })
+
+  it('has string values for all keys', () => {
+    Object.values(ID_PREFIXES).forEach((value) => {
+      expect(typeof value).toBe('string')
+    })
+  })
+
+  it('has unique values', () => {
+    const values = Object.values(ID_PREFIXES)
+    const unique = new Set(values)
+    expect(unique.size).toBe(values.length)
+  })
+
+  it('is frozen (immutable)', () => {
+    expect(Object.isFrozen(ID_PREFIXES)).toBe(true)
+
+    // Try to mutate
+    try {
+      ID_PREFIXES.USER = 'hacked'
+    } catch (_) {
+      // Ignore error in strict mode
+    }
+
+    expect(ID_PREFIXES.USER).toBe('usr')
+  })
+})

package/tests/logger/get-logger.unit.test.js

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi } from 'vitest'
+import { getLogger } from '../../src/logger/get-logger.js'
+
+describe('getLogger', () => {
+  it('returns a default pino logger when called with undefined', () => {
+    const logger = getLogger(undefined)
+    expect(typeof logger.info).toBe('function')
+    // @ts-ignore
+    expect(logger.level).toBe('info')
+  })
+
+  it('returns a default pino logger when called with true', () => {
+    const logger = getLogger(true)
+    expect(typeof logger.info).toBe('function')
+    // @ts-ignore
+    expect(logger.level).toBe('info')
+  })
+
+  it('returns a pino logger when called with { logger: true } and optional level', () => {
+    const logger = getLogger({ logger: true, level: 'debug' })
+    expect(typeof logger.debug).toBe('function')
+    // @ts-ignore
+    expect(logger.level).toBe('debug')
+  })
+
+  it('returns the custom logger when provided and valid', () => {
+    const mockLogger = {
+      info: vi.fn(),
+      warn: vi.fn(),
+      error: vi.fn(),
+      debug: vi.fn(),
+    }
+
+    const result = getLogger({ logger: mockLogger })
+    expect(result).toBe(mockLogger)
+  })
+
+  it('returns the dummy logger when logger is invalid', () => {
+    const invalidLogger = { info: () => {}, warn: () => {} } // missing 'error' and 'debug'
+    const logger = getLogger({ logger: invalidLogger })
+
+    expect(logger.info).toBeDefined()
+    expect(logger.warn).toBeDefined()
+    expect(logger.error).toBeDefined()
+    expect(logger.debug).toBeDefined()
+
+    // Check that it's the dummy logger (no-op)
+    expect(() => logger.info('hello')).not.toThrow()
+    // @ts-ignore
+    expect(logger.info()).toBeUndefined()
+  })
+
+  it('returns the dummy logger when called with invalid object', () => {
+    const result = getLogger({ someOtherKey: 123 })
+    expect(result.info).toBeDefined()
+    expect(result.warn).toBeDefined()
+  })
+
+  it('logs a message when using internal pino', () => {
+    const logger = getLogger({ logger: true, level: 'warn' })
+    // @ts-ignore
+    expect(logger.level).toBe('warn')
+  })
+})

package/src/fastify/error-handlers/with-error-handling.types.js

@@ -1,10 +0,0 @@
-/**
- * @typedef {object} Reply
- * @property {(code: number) => Reply} status - Sets the HTTP status code
- * @property {(payload: any) => void} send - Sends the response
- */
-
-/**
- * @typedef {object} Logger
- * @property {(message: string, ...args: any[]) => void} error - Logs an error message
- */