@omersx/bemms 0.0.0-stage → 0.1.0

package/src/lib/db/schema/tickets.ts

@@ -0,0 +1,169 @@
+import { pgTable, uuid, text, timestamp, integer, jsonb, index } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import {
+  ticketStatusCodeEnum, ticketPriorityCodeEnum, ticketTypeCodeEnum,
+  ticketSourceEnum, reportedImpactCodeEnum, reporterProblemCategoryCodeEnum,
+  maintenanceTypeCodeEnum, technicalProblemCategoryCodeEnum,
+  ticketCommentVisibilityEnum, ticketEventTypeEnum, deviceStatusCodeEnum,
+} from './enums';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+import { departments } from './departments';
+import { locations } from './locations';
+import { users } from './users';
+import { devices } from './devices';
+import { roundDepartmentVisits } from './engineer-rounds';
+
+// ── Service Tickets ─────────────────────────────────────────────────────────────
+
+export const serviceTickets = pgTable('service_tickets', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  ticketNumber: text('ticket_number').notNull().unique(),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+
+  // Device & Location Context
+  deviceId: uuid('device_id').references(() => devices.id),
+  hospitalId: uuid('hospital_id').notNull().references(() => hospitals.id),
+  departmentId: uuid('department_id').notNull().references(() => departments.id),
+  locationId: uuid('location_id').references(() => locations.id),
+  exactLocationDescription: text('exact_location_description'),
+  deviceSnapshot: jsonb('device_snapshot'),
+  locationSnapshot: jsonb('location_snapshot'),
+
+  // Source & Original Report
+  source: ticketSourceEnum('source').notNull(),
+  ticketType: ticketTypeCodeEnum('ticket_type').default('device_problem').notNull(),
+  title: text('title').notNull(),
+  description: text('description').notNull(),
+  reportedProblemCategory: reporterProblemCategoryCodeEnum('reported_problem_category'),
+  reportedImpact: reportedImpactCodeEnum('reported_impact').notNull(),
+  reportedLocationCorrection: text('reported_location_correction'),
+  requesterContactName: text('requester_contact_name'),
+  requesterContactPhone: text('requester_contact_phone'),
+  reportedByUserId: uuid('reported_by_user_id').notNull().references(() => users.id),
+  reportedAt: timestamp('reported_at', { withTimezone: true }).defaultNow().notNull(),
+
+  // Triage & Engineering Classification
+  statusCode: ticketStatusCodeEnum('status_code').default('new').notNull(),
+  priorityCode: ticketPriorityCodeEnum('priority_code').default('p3_normal').notNull(),
+  priorityReason: text('priority_reason'),
+  triagedByUserId: uuid('triaged_by_user_id').references(() => users.id),
+  triagedAt: timestamp('triaged_at', { withTimezone: true }),
+  selectedMaintenanceType: maintenanceTypeCodeEnum('selected_maintenance_type'),
+  selectedTechnicalCategory: technicalProblemCategoryCodeEnum('selected_technical_category'),
+  internalTriageNote: text('internal_triage_note'),
+
+  // Assignment & SLA
+  assignedEngineerUserId: uuid('assigned_engineer_user_id').references(() => users.id),
+  assignedTeamId: uuid('assigned_team_id'),
+  assignedAt: timestamp('assigned_at', { withTimezone: true }),
+  acceptedAt: timestamp('accepted_at', { withTimezone: true }),
+  responseTargetAt: timestamp('response_target_at', { withTimezone: true }),
+  resolutionTargetAt: timestamp('resolution_target_at', { withTimezone: true }),
+
+  // Work & Resolution
+  waitingReason: text('waiting_reason'),
+  waitingDependencyType: text('waiting_dependency_type'),
+  resolutionSummary: text('resolution_summary'),
+  finalDeviceStatusCode: deviceStatusCodeEnum('final_device_status_code'),
+  resolvedAt: timestamp('resolved_at', { withTimezone: true }),
+  resolvedByUserId: uuid('resolved_by_user_id').references(() => users.id),
+  closedAt: timestamp('closed_at', { withTimezone: true }),
+  closedByUserId: uuid('closed_by_user_id').references(() => users.id),
+  closureReason: text('closure_reason'),
+  cancelledAt: timestamp('cancelled_at', { withTimezone: true }),
+  cancelledByUserId: uuid('cancelled_by_user_id').references(() => users.id),
+  cancellationReason: text('cancellation_reason'),
+  reopenedAt: timestamp('reopened_at', { withTimezone: true }),
+  reopenedByUserId: uuid('reopened_by_user_id').references(() => users.id),
+  reopenReason: text('reopen_reason'),
+
+  // Engineer's Round link (nullable — only set for tickets created during a round)
+  roundVisitId: uuid('round_visit_id').references(() => roundDepartmentVisits.id),
+
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  lookupIdx: index('idx_tickets_lookup').on(t.organizationId, t.hospitalId, t.departmentId, t.statusCode),
+  ticketNumIdx: index('idx_tickets_number').on(t.organizationId, t.ticketNumber),
+  deviceIdx: index('idx_tickets_device').on(t.deviceId, t.statusCode),
+  assigneeIdx: index('idx_tickets_assignee').on(t.assignedEngineerUserId, t.statusCode),
+  reporterIdx: index('idx_tickets_reporter').on(t.reportedByUserId),
+}));
+
+export const serviceTicketsRelations = relations(serviceTickets, ({ one }) => ({
+  organization: one(organizations, { fields: [serviceTickets.organizationId], references: [organizations.id] }),
+  device: one(devices, { fields: [serviceTickets.deviceId], references: [devices.id] }),
+  hospital: one(hospitals, { fields: [serviceTickets.hospitalId], references: [hospitals.id] }),
+  department: one(departments, { fields: [serviceTickets.departmentId], references: [departments.id] }),
+  location: one(locations, { fields: [serviceTickets.locationId], references: [locations.id] }),
+  reportedByUser: one(users, { fields: [serviceTickets.reportedByUserId], references: [users.id], relationName: 'ticketsReportedByUser' }),
+  triagedByUser: one(users, { fields: [serviceTickets.triagedByUserId], references: [users.id], relationName: 'ticketsTriagedByUser' }),
+  assignedEngineer: one(users, { fields: [serviceTickets.assignedEngineerUserId], references: [users.id], relationName: 'ticketsAssignedToEngineer' }),
+  resolvedByUser: one(users, { fields: [serviceTickets.resolvedByUserId], references: [users.id], relationName: 'ticketsResolvedByUser' }),
+  closedByUser: one(users, { fields: [serviceTickets.closedByUserId], references: [users.id], relationName: 'ticketsClosedByUser' }),
+}));
+
+// ── Ticket Comments ─────────────────────────────────────────────────────────────
+
+export const serviceTicketComments = pgTable('service_ticket_comments', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  serviceTicketId: uuid('service_ticket_id').notNull().references(() => serviceTickets.id, { onDelete: 'cascade' }),
+  authorUserId: uuid('author_user_id').notNull().references(() => users.id),
+  visibility: ticketCommentVisibilityEnum('visibility').default('public').notNull(),
+  body: text('body').notNull(),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  editedAt: timestamp('edited_at', { withTimezone: true }),
+  editedByUserId: uuid('edited_by_user_id').references(() => users.id),
+}, (t) => ({
+  ticketTimeIdx: index('idx_ticket_comments_ticket').on(t.serviceTicketId, t.createdAt),
+}));
+
+export const serviceTicketCommentsRelations = relations(serviceTicketComments, ({ one }) => ({
+  serviceTicket: one(serviceTickets, { fields: [serviceTicketComments.serviceTicketId], references: [serviceTickets.id] }),
+  author: one(users, { fields: [serviceTicketComments.authorUserId], references: [users.id], relationName: 'ticketCommentsAuthor' }),
+}));
+
+// ── Ticket Events (append-only timeline) ────────────────────────────────────────
+
+export const serviceTicketEvents = pgTable('service_ticket_events', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  serviceTicketId: uuid('service_ticket_id').notNull().references(() => serviceTickets.id, { onDelete: 'cascade' }),
+  eventType: ticketEventTypeEnum('event_type').notNull(),
+  previousValueJsonb: jsonb('previous_value_jsonb'),
+  newValueJsonb: jsonb('new_value_jsonb'),
+  visibility: ticketCommentVisibilityEnum('visibility').default('public').notNull(),
+  reason: text('reason'),
+  actorUserId: uuid('actor_user_id').notNull().references(() => users.id),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  relatedMaintenanceTaskId: uuid('related_maintenance_task_id'),
+}, (t) => ({
+  ticketTimeIdx: index('idx_ticket_events_ticket').on(t.serviceTicketId, t.createdAt),
+}));
+
+export const serviceTicketEventsRelations = relations(serviceTicketEvents, ({ one }) => ({
+  serviceTicket: one(serviceTickets, { fields: [serviceTicketEvents.serviceTicketId], references: [serviceTickets.id] }),
+  actor: one(users, { fields: [serviceTicketEvents.actorUserId], references: [users.id], relationName: 'ticketEventsActor' }),
+}));
+
+// ── Ticket Attachments ──────────────────────────────────────────────────────────
+
+export const serviceTicketAttachments = pgTable('service_ticket_attachments', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  serviceTicketId: uuid('service_ticket_id').notNull().references(() => serviceTickets.id, { onDelete: 'cascade' }),
+  fileName: text('file_name').notNull(),
+  fileSize: integer('file_size'),
+  mimeType: text('mime_type'),
+  storageKey: text('storage_key').notNull(),
+  visibility: ticketCommentVisibilityEnum('visibility').default('public').notNull(),
+  uploadedByUserId: uuid('uploaded_by_user_id').notNull().references(() => users.id),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+}, (t) => ({
+  ticketIdx: index('idx_ticket_attachments_ticket').on(t.serviceTicketId),
+}));
+
+export const serviceTicketAttachmentsRelations = relations(serviceTicketAttachments, ({ one }) => ({
+  serviceTicket: one(serviceTickets, { fields: [serviceTicketAttachments.serviceTicketId], references: [serviceTickets.id] }),
+  uploadedByUser: one(users, { fields: [serviceTicketAttachments.uploadedByUserId], references: [users.id], relationName: 'ticketAttachmentsUploader' }),
+}));
+

package/src/lib/db/schema/user-assignments.ts

@@ -0,0 +1,85 @@
+import { pgTable, uuid, timestamp } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { assignmentStatusEnum, scopeTypeEnum } from './enums';
+import { users } from './users';
+import { roles } from './roles';
+import { organizations } from './organizations';
+import { hospitals } from './hospitals';
+import { departments } from './departments';
+import { locations } from './locations';
+
+export const userRoleAssignments = pgTable('user_role_assignments', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  roleId: uuid('role_id').notNull().references(() => roles.id, { onDelete: 'cascade' }),
+  organizationId: uuid('organization_id').references(() => organizations.id),
+  effectiveFrom: timestamp('effective_from', { withTimezone: true }).defaultNow(),
+  effectiveTo: timestamp('effective_to', { withTimezone: true }),
+  assignedByUserId: uuid('assigned_by_user_id').references(() => users.id),
+  status: assignmentStatusEnum('status').default('active'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+});
+
+export const userAccessScopes = pgTable('user_access_scopes', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  userId: uuid('user_id').notNull().references(() => users.id, { onDelete: 'cascade' }),
+  organizationId: uuid('organization_id').notNull().references(() => organizations.id),
+  hospitalId: uuid('hospital_id').references(() => hospitals.id),
+  departmentId: uuid('department_id').references(() => departments.id),
+  locationId: uuid('location_id').references(() => locations.id),
+  scopeType: scopeTypeEnum('scope_type').notNull(),
+  status: assignmentStatusEnum('status').default('active'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  createdByUserId: uuid('created_by_user_id').references(() => users.id),
+});
+
+export const userRoleAssignmentsRelations = relations(userRoleAssignments, ({ one }) => ({
+  user: one(users, {
+    fields: [userRoleAssignments.userId],
+    references: [users.id],
+    relationName: 'roleAssignmentsForUser',
+  }),
+  role: one(roles, {
+    fields: [userRoleAssignments.roleId],
+    references: [roles.id],
+  }),
+  organization: one(organizations, {
+    fields: [userRoleAssignments.organizationId],
+    references: [organizations.id],
+  }),
+  assignedByUser: one(users, {
+    fields: [userRoleAssignments.assignedByUserId],
+    references: [users.id],
+    relationName: 'rolesAssignedByUser',
+  }),
+}));
+
+export const userAccessScopesRelations = relations(userAccessScopes, ({ one }) => ({
+  user: one(users, {
+    fields: [userAccessScopes.userId],
+    references: [users.id],
+    relationName: 'accessScopesForUser',
+  }),
+  organization: one(organizations, {
+    fields: [userAccessScopes.organizationId],
+    references: [organizations.id],
+  }),
+  hospital: one(hospitals, {
+    fields: [userAccessScopes.hospitalId],
+    references: [hospitals.id],
+  }),
+  department: one(departments, {
+    fields: [userAccessScopes.departmentId],
+    references: [departments.id],
+  }),
+  location: one(locations, {
+    fields: [userAccessScopes.locationId],
+    references: [locations.id],
+  }),
+  createdByUser: one(users, {
+    fields: [userAccessScopes.createdByUserId],
+    references: [users.id],
+    relationName: 'scopesCreatedByUser',
+  }),
+}));
+

package/src/lib/db/schema/users.ts

@@ -0,0 +1,39 @@
+import { pgTable, uuid, text, timestamp, jsonb } from 'drizzle-orm/pg-core';
+import { relations } from 'drizzle-orm';
+import { userAccountStatusEnum } from './enums';
+import { organizations } from './organizations';
+
+export const users = pgTable('users', {
+  id: uuid('id').primaryKey().$defaultFn(() => crypto.randomUUID()),
+  email: text('email').notNull().unique(),
+  passwordHash: text('password_hash'),
+  fullName: text('full_name').notNull(),
+  phone: text('phone'),
+  jobTitle: text('job_title'),
+  employeeIdentifier: text('employee_identifier'),
+  organizationId: uuid('organization_id').references(() => organizations.id),
+  accountStatus: userAccountStatusEnum('account_status').default('invited'),
+  avatarUrl: text('avatar_url'),
+  notificationPreferences: jsonb('notification_preferences').$type<{
+    pushEnabled: boolean;
+    categories: {
+      tickets: boolean;
+      maintenance: boolean;
+      devices: boolean;
+      system: boolean;
+    };
+  }>(),
+  lastLoginAt: timestamp('last_login_at', { withTimezone: true }),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull(),
+  updatedAt: timestamp('updated_at', { withTimezone: true }).defaultNow().notNull(),
+  createdByUserId: uuid('created_by_user_id'),
+  updatedByUserId: uuid('updated_by_user_id'),
+});
+
+export const usersRelations = relations(users, ({ one }) => ({
+  organization: one(organizations, {
+    fields: [users.organizationId],
+    references: [organizations.id],
+  }),
+}));
+

package/src/lib/db/seed.ts

@@ -0,0 +1,131 @@
+import { Pool } from 'pg';
+import { drizzle } from 'drizzle-orm/node-postgres';
+import * as schema from './schema';
+import { hashPassword } from '@/lib/auth/password';
+import { eq } from 'drizzle-orm';
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+const db = drizzle(pool, { schema });
+
+async function seed() {
+  console.log('Starting seed...');
+
+  try {
+    // 1. Create Default Organization
+    const [org] = await db.insert(schema.organizations).values({
+      name: 'Default Organization',
+      code: 'DEFAULT',
+      defaultTimezone: 'UTC',
+    }).onConflictDoNothing().returning();
+
+    let orgId = org?.id;
+    if (!orgId) {
+      const existingOrg = await db.query.organizations.findFirst({
+        where: (organizations, { eq }) => eq(organizations.code, 'DEFAULT'),
+      });
+      orgId = existingOrg!.id;
+    }
+
+    // 2. Create System Roles
+    const systemRoles = [
+      { code: 'SYS_ADMIN', name: 'System Administrator', isSystemRole: true },
+      { code: 'ORG_ADMIN', name: 'Organization Administrator', isSystemRole: true },
+      { code: 'HOSP_ADMIN', name: 'Hospital Administrator', isSystemRole: true },
+      { code: 'BIOMED_MGR', name: 'Biomedical Manager', isSystemRole: true },
+      { code: 'BIOMED_ENG', name: 'Biomedical Engineer', isSystemRole: true },
+      { code: 'BIOMED_TECH', name: 'Biomedical Technician', isSystemRole: true },
+      { code: 'DEPT_MGR', name: 'Department Manager', isSystemRole: true },
+      { code: 'STAFF', name: 'Staff', isSystemRole: true },
+      { code: 'AUDITOR', name: 'Auditor', isSystemRole: true },
+    ];
+
+    for (const role of systemRoles) {
+      await db.insert(schema.roles).values({
+        organizationId: orgId,
+        ...role,
+      }).onConflictDoNothing();
+    }
+
+    const sysAdminRole = await db.query.roles.findFirst({
+      where: (roles, { eq }) => eq(roles.code, 'SYS_ADMIN'),
+    });
+
+    if (!sysAdminRole) {
+      throw new Error('SYS_ADMIN role not found after insert');
+    }
+
+    // 3. Create all permissions
+    const modules = ['DEVICES', 'TICKETS', 'MAINTENANCE', 'PM_CALIBRATION', 'SIGNATURES', 'REPORTS', 'ADMIN', 'AUDIT'];
+    const actions = ['VIEW', 'CREATE', 'EDIT', 'ASSIGN', 'APPROVE', 'SIGN', 'RELEASE', 'ARCHIVE', 'EXPORT', 'MANAGE_POLICY'];
+
+    for (const mod of modules) {
+      for (const act of actions) {
+        await db.insert(schema.permissions).values({
+          module: mod as any,
+          action: act as any,
+        }).onConflictDoNothing();
+      }
+    }
+
+    // 4. Assign all permissions to SYS_ADMIN
+    const allPermissions = await db.query.permissions.findMany();
+    for (const permission of allPermissions) {
+      await db.insert(schema.rolePermissions).values({
+        roleId: sysAdminRole.id,
+        permissionId: permission.id,
+      }).onConflictDoNothing();
+    }
+
+    // 5. Create Admin User (only set password on first creation, never overwrite)
+    const adminEmail = process.env.ADMIN_EMAIL || 'admin@bemms.local';
+    const adminPassword = process.env.ADMIN_PASSWORD || 'admin123';
+    const passwordHash = await hashPassword(adminPassword);
+
+    const [adminUser] = await db.insert(schema.users).values({
+      email: adminEmail,
+      passwordHash,
+      fullName: process.env.ADMIN_FULL_NAME || 'System Administrator',
+      employeeIdentifier: 'admin',
+      organizationId: orgId,
+      accountStatus: 'active',
+    }).onConflictDoNothing().returning();
+
+    let adminId = adminUser?.id;
+    if (!adminId) {
+      // User already exists — do NOT overwrite password (may have been changed)
+      const existingUser = await db.query.users.findFirst({
+        where: (users, { eq }) => eq(users.email, adminEmail),
+      });
+      adminId = existingUser!.id;
+      console.log('Admin user already exists — skipping password update to preserve production credentials.');
+    }
+
+    // 6. Assign SYS_ADMIN role to admin user
+    await db.insert(schema.userRoleAssignments).values({
+      userId: adminId,
+      roleId: sysAdminRole.id,
+      organizationId: orgId,
+    }).onConflictDoNothing();
+
+    // 7. Create User Access Scope for Admin User
+    await db.insert(schema.userAccessScopes).values({
+      userId: adminId,
+      organizationId: orgId,
+      scopeType: 'organization',
+    }).onConflictDoNothing();
+
+    console.log('Seed completed successfully!');
+  } catch (error) {
+    console.error('Seed failed:', error);
+    await pool.end();
+    process.exit(1);
+  }
+
+  await pool.end();
+  process.exit(0);
+}
+
+seed();

package/src/lib/logger/__tests__/logger.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { createLogger, getLogger, jsonFormatter, prettyFormatter, LogEntry } from '../index';
+
+describe('Logger Module', () => {
+  let consoleLogSpy: any;
+  let consoleWarnSpy: any;
+  let consoleErrorSpy: any;
+
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+    consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('createLogger and log levels', () => {
+    it('should log messages according to minLevel', () => {
+      const logger = createLogger({ minLevel: 'warn' });
+
+      logger.debug('debug message');
+      logger.info('info message');
+      logger.warn('warn message');
+      logger.error('error message');
+
+      expect(consoleLogSpy).not.toHaveBeenCalled();
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('should emit debug and info to console.log', () => {
+      const logger = createLogger({ minLevel: 'debug' });
+
+      logger.debug('debug test');
+      expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+
+      logger.info('info test');
+      expect(consoleLogSpy).toHaveBeenCalledTimes(2);
+    });
+
+    it('should emit warn to console.warn and fatal to console.error', () => {
+      const logger = createLogger({ minLevel: 'debug' });
+
+      logger.warn('warning test');
+      expect(consoleWarnSpy).toHaveBeenCalledTimes(1);
+
+      logger.fatal('fatal error');
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('should properly serialize errors', () => {
+      const logger = createLogger({ minLevel: 'error' });
+      const testError = new Error('Database connection failed');
+
+      logger.error('Query failed', testError, { query: 'SELECT 1' });
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+    });
+
+    it('should support passing data object as error parameter', () => {
+      const logger = createLogger({ minLevel: 'error' });
+      logger.error('Something failed', { code: 500, detail: 'timeout' });
+      expect(consoleErrorSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('child logger', () => {
+    it('should inherit and merge module path and context', () => {
+      const parent = createLogger({
+        module: 'parent',
+        context: { env: 'test', requestId: '123' },
+        minLevel: 'info',
+      });
+
+      const child = parent.child({
+        module: 'child',
+        context: { operation: 'read' },
+      });
+
+      child.info('Child operation');
+      expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('getLogger helper', () => {
+    it('should instantiate logger with module identifier and context', () => {
+      const log = getLogger('audit', { tenant: 'org-1' });
+      expect(log).toBeDefined();
+      expect(typeof log.info).toBe('function');
+      expect(typeof log.error).toBe('function');
+    });
+  });
+
+  describe('formatters', () => {
+    it('jsonFormatter should produce valid JSON', () => {
+      const entry: LogEntry = {
+        level: 'info',
+        message: 'Test JSON message',
+        timestamp: new Date().toISOString(),
+        module: 'test-mod',
+        context: { count: 42, active: true },
+      };
+
+      const result = jsonFormatter(entry);
+      const parsed = JSON.parse(result);
+
+      expect(parsed.level).toBe('info');
+      expect(parsed.message).toBe('Test JSON message');
+      expect(parsed.module).toBe('test-mod');
+      expect(parsed.context.count).toBe(42);
+    });
+
+    it('jsonFormatter should handle circular references safely', () => {
+      const circularObj: any = { name: 'cyclic' };
+      circularObj.self = circularObj;
+
+      const entry: LogEntry = {
+        level: 'warn',
+        message: 'Circular test',
+        timestamp: new Date().toISOString(),
+        context: circularObj,
+      };
+
+      const result = jsonFormatter(entry);
+      expect(() => JSON.parse(result)).not.toThrow();
+      const parsed = JSON.parse(result);
+      expect(parsed.context.self).toBe('[Circular]');
+    });
+
+    it('prettyFormatter should format human-readable output with ANSI colors', () => {
+      const entry: LogEntry = {
+        level: 'error',
+        message: 'Something broke',
+        timestamp: '2026-10-11T14:00:00.000Z',
+        module: 'system',
+        context: { service: 'api' },
+        error: {
+          name: 'Error',
+          message: 'Broken connection',
+          stack: 'Error: Broken connection\n  at index.ts:1',
+        },
+      };
+
+      const result = prettyFormatter(entry);
+      expect(result).toContain('ERROR');
+      expect(result).toContain('system');
+      expect(result).toContain('Something broke');
+      expect(result).toContain('service=');
+      expect(result).toContain('api');
+      expect(result).toContain('Broken connection');
+    });
+  });
+});