pn-new-crm/tests/integration/crud-audit.test.ts

/**
 * CRUD audit log integration tests.
 *
 * For each entity type (clients, interests, berths):
 *  - Create → verify audit log entry with action='create'
 *  - Update → verify audit log with action='update' and old/new values
 *  - Archive → verify audit log with action='archive'
 *  - Restore → verify audit log with action='restore'
 *
 * Skips gracefully when TEST_DATABASE_URL is not reachable.
 */
import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';

import {
  makeAuditMeta,
  makeCreateClientInput,
  makeCreateInterestInput,
} from '../helpers/factories';

vi.mock('@/lib/socket/server', () => ({ emitToRoom: vi.fn() }));
vi.mock('@/lib/queue', () => ({
  getQueue: () => ({ add: vi.fn().mockResolvedValue(undefined) }),
}));

const TEST_DB_URL =
  process.env.TEST_DATABASE_URL || 'postgresql://test:test@localhost:5433/portnimara_test';

let dbAvailable = false;

beforeAll(async () => {
  try {
    const postgres = (await import('postgres')).default;
    const sql = postgres(TEST_DB_URL, { max: 1, idle_timeout: 3, connect_timeout: 3 });
    await sql`SELECT 1`;
    await sql.end();
    dbAvailable = true;
  } catch {
    console.warn('[crud-audit] Test database not available — skipping integration tests');
  }
});

function itDb(name: string, fn: () => Promise<void>) {
  it(name, async () => {
    if (!dbAvailable) return;
    await fn();
  });
}

// ─── Helpers ─────────────────────────────────────────────────────────────────

async function seedPort(): Promise<string> {
  const postgres = (await import('postgres')).default;
  const sql = postgres(TEST_DB_URL, { max: 1 });
  const portId = crypto.randomUUID();
  await sql`
    INSERT INTO ports (id, name, slug, country, currency, timezone)
    VALUES (${portId}, 'Audit Test Port', ${'audit-' + portId.slice(0, 8)}, 'AU', 'AUD', 'UTC')
  `;
  await sql.end();
  return portId;
}

async function cleanupPort(portId: string): Promise<void> {
  const postgres = (await import('postgres')).default;
  const sql = postgres(TEST_DB_URL, { max: 1 });
  await sql`DELETE FROM ports WHERE id = ${portId}`;
  await sql.end();
}

async function getAuditEntries(
  portId: string,
  entityId: string,
  action?: string,
): Promise<Array<Record<string, unknown>>> {
  const postgres = (await import('postgres')).default;
  const sql = postgres(TEST_DB_URL, { max: 1 });
  let rows: Array<Record<string, unknown>>;

  if (action) {
    rows = await sql<Array<Record<string, unknown>>>`
      SELECT * FROM audit_logs
      WHERE port_id = ${portId}
        AND entity_id = ${entityId}
        AND action = ${action}
      ORDER BY created_at ASC
    `;
  } else {
    rows = await sql<Array<Record<string, unknown>>>`
      SELECT * FROM audit_logs
      WHERE port_id = ${portId}
        AND entity_id = ${entityId}
      ORDER BY created_at ASC
    `;
  }

  await sql.end();
  return rows;
}

// ─── Client Audit Tests ───────────────────────────────────────────────────────

describe('CRUD Audit — Clients', () => {
  let portId: string;

  beforeAll(async () => {
    if (!dbAvailable) return;
    portId = await seedPort();
  });

  afterAll(async () => {
    if (!dbAvailable) return;
    await cleanupPort(portId);
  });

  itDb('create generates an audit log entry with action=create', async () => {
    const { createClient } = await import('@/lib/services/clients.service');
    const meta = makeAuditMeta({ portId });

    const client = await createClient(
      portId,
      makeCreateClientInput({ fullName: 'Audit Create Client' }),
      meta,
    );

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, client.id, 'create');
    expect(logs.length).toBeGreaterThanOrEqual(1);

    const log = logs[0]!;
    expect(log.entity_type).toBe('client');
    expect(log.action).toBe('create');
    const newVal = log.new_value as Record<string, unknown>;
    expect(newVal.fullName).toBe('Audit Create Client');
  });

  itDb('update generates an audit log entry with action=update', async () => {
    const { createClient, updateClient } = await import('@/lib/services/clients.service');
    const meta = makeAuditMeta({ portId });

    const client = await createClient(
      portId,
      makeCreateClientInput({ fullName: 'Before Update' }),
      meta,
    );

    await updateClient(client.id, portId, { fullName: 'After Update' }, meta);

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, client.id, 'update');
    expect(logs.length).toBeGreaterThanOrEqual(1);

    const updateLog = logs[logs.length - 1]!;
    expect(updateLog.action).toBe('update');
    const newVal = updateLog.new_value as Record<string, unknown>;
    expect(newVal.fullName).toBe('After Update');
  });

  itDb('archive generates an audit log entry with action=archive', async () => {
    const { createClient, archiveClient } = await import('@/lib/services/clients.service');
    const meta = makeAuditMeta({ portId });

    const client = await createClient(
      portId,
      makeCreateClientInput({ fullName: 'Audit Archive Client' }),
      meta,
    );

    await archiveClient(client.id, portId, meta);

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, client.id, 'archive');
    expect(logs.length).toBeGreaterThanOrEqual(1);
    expect(logs[0]!.action).toBe('archive');
  });

  itDb('restore generates an audit log entry with action=restore', async () => {
    const { createClient, archiveClient, restoreClient } =
      await import('@/lib/services/clients.service');
    const meta = makeAuditMeta({ portId });

    const client = await createClient(
      portId,
      makeCreateClientInput({ fullName: 'Audit Restore Client' }),
      meta,
    );

    await archiveClient(client.id, portId, meta);
    await restoreClient(client.id, portId, meta);

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, client.id, 'restore');
    expect(logs.length).toBeGreaterThanOrEqual(1);
    expect(logs[0]!.action).toBe('restore');
  });
});

// ─── Interest Audit Tests ─────────────────────────────────────────────────────

describe('CRUD Audit — Interests', () => {
  let portId: string;
  let clientId: string;

  beforeAll(async () => {
    if (!dbAvailable) return;
    portId = await seedPort();

    const { createClient } = await import('@/lib/services/clients.service');
    const client = await createClient(
      portId,
      makeCreateClientInput({ fullName: 'Interest Audit Client' }),
      makeAuditMeta({ portId }),
    );
    clientId = client.id;
  });

  afterAll(async () => {
    if (!dbAvailable) return;
    await cleanupPort(portId);
  });

  itDb('create generates audit log with action=create', async () => {
    const { createInterest } = await import('@/lib/services/interests.service');
    const meta = makeAuditMeta({ portId });

    const interest = await createInterest(portId, makeCreateInterestInput({ clientId }), meta);

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, interest.id, 'create');
    expect(logs.length).toBeGreaterThanOrEqual(1);

    const log = logs[0]!;
    expect(log.entity_type).toBe('interest');
    const newVal = log.new_value as Record<string, unknown>;
    expect(newVal.pipelineStage).toBe('open');
  });

  itDb('update generates audit log with action=update', async () => {
    const { createInterest, updateInterest } = await import('@/lib/services/interests.service');
    const meta = makeAuditMeta({ portId });

    const interest = await createInterest(
      portId,
      { ...makeCreateInterestInput({ clientId }), source: 'initial' },
      meta,
    );

    await updateInterest(interest.id, portId, { source: 'updated' }, meta);

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, interest.id, 'update');
    expect(logs.length).toBeGreaterThanOrEqual(1);
  });

  itDb('archive generates audit log with action=archive', async () => {
    const { createInterest, archiveInterest } = await import('@/lib/services/interests.service');
    const meta = makeAuditMeta({ portId });

    const interest = await createInterest(portId, makeCreateInterestInput({ clientId }), meta);

    await archiveInterest(interest.id, portId, meta);

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, interest.id, 'archive');
    expect(logs.length).toBeGreaterThanOrEqual(1);
    expect(logs[0]!.action).toBe('archive');
  });

  itDb('restore generates audit log with action=restore', async () => {
    const { createInterest, archiveInterest, restoreInterest } =
      await import('@/lib/services/interests.service');
    const meta = makeAuditMeta({ portId });

    const interest = await createInterest(portId, makeCreateInterestInput({ clientId }), meta);

    await archiveInterest(interest.id, portId, meta);
    await restoreInterest(interest.id, portId, meta);

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, interest.id, 'restore');
    expect(logs.length).toBeGreaterThanOrEqual(1);
  });
});

// ─── Berth Audit Tests ────────────────────────────────────────────────────────

describe('CRUD Audit — Berths', () => {
  let portId: string;
  let berthId: string;

  beforeAll(async () => {
    if (!dbAvailable) return;
    portId = await seedPort();

    const postgres = (await import('postgres')).default;
    const sql = postgres(TEST_DB_URL, { max: 1 });
    berthId = crypto.randomUUID();
    await sql`
      INSERT INTO berths (id, port_id, mooring_number, status)
      VALUES (${berthId}, ${portId}, 'AUDIT-B1', 'available')
    `;
    await sql.end();
  });

  afterAll(async () => {
    if (!dbAvailable) return;
    await cleanupPort(portId);
  });

  itDb('updateBerth generates audit log with action=update', async () => {
    const { updateBerth } = await import('@/lib/services/berths.service');
    const meta = makeAuditMeta({ portId });

    await updateBerth(berthId, portId, { area: 'North Pier', berthApproved: true }, meta);

    await new Promise((r) => setTimeout(r, 100));

    const logs = await getAuditEntries(portId, berthId, 'update');
    expect(logs.length).toBeGreaterThanOrEqual(1);
    expect(logs[0]!.entity_type).toBe('berth');
  });

  itDb('updateBerth on wrong portId throws NotFoundError', async () => {
    const { updateBerth } = await import('@/lib/services/berths.service');
    const { NotFoundError } = await import('@/lib/errors');
    const wrongPortId = crypto.randomUUID();
    const meta = makeAuditMeta({ portId: wrongPortId });

    await expect(updateBerth(berthId, wrongPortId, { area: 'Should fail' }, meta)).rejects.toThrow(
      NotFoundError,
    );
  });
});