@hazeljs/audit 0.2.0-beta.53 → 0.2.0-beta.55

package/README.md

@@ -161,4 +161,4 @@ Apache 2.0 © [HazelJS](https://hazeljs.com)
 - [Documentation](https://hazeljs.com/docs/packages/auth)
 - [GitHub](https://github.com/hazel-js/hazeljs)
 - [Issues](https://github.com/hazel-js/hazeljs/issues)
-- [Discord](https://discord.gg/hazeljs)
+- [Discord](https://discord.com/channels/1448263814238965833/1448263814859456575)

package/dist/audit.module.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=audit.module.test.d.ts.map

package/dist/audit.module.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.module.test.d.ts","sourceRoot":"","sources":["../src/audit.module.test.ts"],"names":[],"mappings":""}

package/dist/audit.module.test.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="jest" />
+const audit_module_1 = require("./audit.module");
+const audit_service_1 = require("./audit.service");
+describe('AuditModule', () => {
+    beforeEach(() => {
+        audit_service_1.AuditService.configure({});
+    });
+    it('should return module from forRoot with no options', () => {
+        const result = audit_module_1.AuditModule.forRoot();
+        expect(result).toBe(audit_module_1.AuditModule);
+    });
+    it('should configure AuditService when options provided', () => {
+        const transport = { log: jest.fn() };
+        audit_module_1.AuditModule.forRoot({ transports: [transport] });
+        const service = new audit_service_1.AuditService();
+        service.log({ action: 'test' });
+        expect(transport.log).toHaveBeenCalledWith(expect.objectContaining({ action: 'test' }));
+    });
+    it('should return options from getOptions', () => {
+        audit_module_1.AuditModule.forRoot({ includeRequestContext: true });
+        const opts = audit_module_1.AuditModule.getOptions();
+        expect(opts).toEqual({ includeRequestContext: true });
+    });
+    it('should return empty object when forRoot called with no options', () => {
+        audit_module_1.AuditModule.forRoot();
+        const opts = audit_module_1.AuditModule.getOptions();
+        expect(opts).toEqual({});
+    });
+});

package/dist/audit.service.js

@@ -103,6 +103,6 @@ let AuditService = AuditService_1 = class AuditService {
 exports.AuditService = AuditService;
 AuditService.staticOptions = {};
 exports.AuditService = AuditService = AuditService_1 = __decorate([
-    (0, core_1.Injectable)(),
+    (0, core_1.Service)(),
     __metadata("design:paramtypes", [Object])
 ], AuditService);

package/dist/audit.service.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=audit.service.test.d.ts.map

package/dist/audit.service.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.service.test.d.ts","sourceRoot":"","sources":["../src/audit.service.test.ts"],"names":[],"mappings":""}

package/dist/audit.service.test.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="jest" />
+const core_1 = require("@hazeljs/core");
+const audit_service_1 = require("./audit.service");
+describe('AuditService', () => {
+    let captured;
+    let mockTransport;
+    beforeEach(() => {
+        captured = [];
+        mockTransport = {
+            log: (event) => {
+                captured.push(event);
+            },
+        };
+        audit_service_1.AuditService.configure({});
+    });
+    it('should use provided transports', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        service.log({ action: 'user.login' });
+        expect(captured).toHaveLength(1);
+        expect(captured[0].action).toBe('user.login');
+    });
+    it('should use custom redactKeys', () => {
+        const service = new audit_service_1.AuditService({
+            transports: [mockTransport],
+            redactKeys: ['customSecret'],
+        });
+        service.log({ action: 'test', metadata: { customSecret: 'x', other: 'y' } });
+        expect(captured[0].metadata).toEqual({ customSecret: '[REDACTED]', other: 'y' });
+    });
+    it('configure merges options into new instances', () => {
+        audit_service_1.AuditService.configure({ transports: [mockTransport] });
+        const service = new audit_service_1.AuditService();
+        service.log({ action: 'configured' });
+        expect(captured[0].action).toBe('configured');
+    });
+    it('log adds timestamp when not provided', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        service.log({ action: 'test' });
+        expect(captured[0].timestamp).toBeDefined();
+    });
+    it('log uses provided timestamp', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        service.log({ action: 'test', timestamp: '2025-01-01T00:00:00.000Z' });
+        expect(captured[0].timestamp).toBe('2025-01-01T00:00:00.000Z');
+    });
+    it('log calls all transports', () => {
+        const second = [];
+        const service = new audit_service_1.AuditService({
+            transports: [
+                mockTransport,
+                {
+                    log: (e) => {
+                        second.push(e);
+                    },
+                },
+            ],
+        });
+        service.log({ action: 'multi' });
+        expect(captured).toHaveLength(1);
+        expect(second[0].action).toBe('multi');
+    });
+    it('log redacts default sensitive keys', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        service.log({ action: 'test', metadata: { password: 'secret', safe: 'ok' } });
+        expect(captured[0].metadata).toEqual({ password: '[REDACTED]', safe: 'ok' });
+    });
+    it('log catches transport errors', () => {
+        const spy = jest.spyOn(core_1.logger, 'error').mockImplementation();
+        const service = new audit_service_1.AuditService({
+            transports: [
+                {
+                    log: () => {
+                        throw new Error('fail');
+                    },
+                },
+            ],
+        });
+        service.log({ action: 'test' });
+        expect(spy).toHaveBeenCalled();
+        spy.mockRestore();
+    });
+    it('log handles async transport rejection', async () => {
+        const spy = jest.spyOn(core_1.logger, 'error').mockImplementation();
+        const service = new audit_service_1.AuditService({
+            transports: [{ log: () => Promise.reject(new Error('async fail')) }],
+        });
+        service.log({ action: 'test' });
+        await new Promise((r) => setImmediate(r));
+        expect(spy).toHaveBeenCalled();
+        spy.mockRestore();
+    });
+    it('addTransport adds a transport at runtime', () => {
+        const extra = [];
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        service.addTransport({
+            log: (e) => {
+                extra.push(e);
+            },
+        });
+        service.log({ action: 'runtime' });
+        expect(captured).toHaveLength(1);
+        expect(extra).toHaveLength(1);
+        expect(extra[0].action).toBe('runtime');
+    });
+    it('actorFromContext returns undefined when no user', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        const ctx = { method: 'GET', url: '/', headers: {}, params: {}, query: {}, body: undefined };
+        expect(service.actorFromContext(ctx)).toBeUndefined();
+    });
+    it('actorFromContext returns actor from context.user', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        const ctx = {
+            method: 'GET',
+            url: '/',
+            headers: {},
+            params: {},
+            query: {},
+            body: undefined,
+            user: { id: 1, username: 'alice', role: 'admin' },
+        };
+        expect(service.actorFromContext(ctx)).toEqual({ id: 1, username: 'alice', role: 'admin' });
+    });
+    it('eventFromContext builds event with action', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        const ctx = {
+            method: 'POST',
+            url: '/orders',
+            headers: {},
+            params: {},
+            query: {},
+            body: undefined,
+        };
+        const event = service.eventFromContext(ctx, 'success', 'order.create');
+        expect(event.action).toBe('order.create');
+        expect(event.result).toBe('success');
+        expect(event.method).toBe('POST');
+        expect(event.path).toBe('/orders');
+    });
+    it('eventFromContext uses default action', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        const ctx = {
+            method: 'GET',
+            url: '/users',
+            headers: {},
+            params: {},
+            query: {},
+            body: undefined,
+        };
+        const event = service.eventFromContext(ctx);
+        expect(event.action).toBe('http.get');
+    });
+    it('eventFromContext includes actor when user present', () => {
+        const service = new audit_service_1.AuditService({ transports: [mockTransport] });
+        const ctx = {
+            method: 'POST',
+            url: '/',
+            headers: {},
+            params: {},
+            query: {},
+            body: undefined,
+            user: { id: 'u1', username: 'bob', role: 'user' },
+        };
+        const event = service.eventFromContext(ctx, 'success');
+        expect(event.actor).toEqual({ id: 'u1', username: 'bob', role: 'user' });
+    });
+});

package/dist/decorators/audit.decorator.test.d.ts

@@ -0,0 +1,2 @@
+import 'reflect-metadata';
+//# sourceMappingURL=audit.decorator.test.d.ts.map

package/dist/decorators/audit.decorator.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.decorator.test.d.ts","sourceRoot":"","sources":["../../src/decorators/audit.decorator.test.ts"],"names":[],"mappings":"AACA,OAAO,kBAAkB,CAAC"}

package/dist/decorators/audit.decorator.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="jest" />
+require("reflect-metadata");
+const audit_decorator_1 = require("./audit.decorator");
+describe('Audit decorator', () => {
+    class TestClass {
+        create() { }
+        login() { }
+        noAudit() { }
+    }
+    // Apply decorators manually to avoid TS decorator signature mismatch in test context
+    const noopDescriptor = {
+        value: () => { },
+        writable: true,
+        enumerable: false,
+        configurable: true,
+    };
+    (0, audit_decorator_1.Audit)('order.create')(TestClass.prototype, 'create', noopDescriptor);
+    (0, audit_decorator_1.Audit)({ action: 'user.login', resource: 'User' })(TestClass.prototype, 'login', noopDescriptor);
+    const instance = new TestClass();
+    it('should set metadata when using string shorthand', () => {
+        expect((0, audit_decorator_1.hasAuditMetadata)(instance, 'create')).toBe(true);
+        expect((0, audit_decorator_1.getAuditMetadata)(instance, 'create')).toEqual({ action: 'order.create' });
+    });
+    it('should set metadata when using options object', () => {
+        expect((0, audit_decorator_1.hasAuditMetadata)(instance, 'login')).toBe(true);
+        expect((0, audit_decorator_1.getAuditMetadata)(instance, 'login')).toEqual({
+            action: 'user.login',
+            resource: 'User',
+        });
+    });
+    it('should return false for method without decorator', () => {
+        expect((0, audit_decorator_1.hasAuditMetadata)(instance, 'noAudit')).toBe(false);
+        expect((0, audit_decorator_1.getAuditMetadata)(instance, 'noAudit')).toBeUndefined();
+    });
+    it('should return undefined for unknown property', () => {
+        expect((0, audit_decorator_1.getAuditMetadata)(instance, 'unknown')).toBeUndefined();
+        expect((0, audit_decorator_1.hasAuditMetadata)(instance, 'unknown')).toBe(false);
+    });
+});

package/dist/interceptors/audit.interceptor.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=audit.interceptor.test.d.ts.map

package/dist/interceptors/audit.interceptor.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit.interceptor.test.d.ts","sourceRoot":"","sources":["../../src/interceptors/audit.interceptor.test.ts"],"names":[],"mappings":""}

package/dist/interceptors/audit.interceptor.test.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="jest" />
+const audit_interceptor_1 = require("./audit.interceptor");
+const audit_service_1 = require("../audit.service");
+describe('AuditInterceptor', () => {
+    let auditService;
+    let captured;
+    beforeEach(() => {
+        captured = [];
+        auditService = new audit_service_1.AuditService({
+            transports: [
+                {
+                    log: (e) => {
+                        captured.push(e);
+                    },
+                },
+            ],
+        });
+    });
+    const emptyContext = {
+        method: 'GET',
+        url: '/test',
+        headers: {},
+        params: {},
+        query: {},
+        body: undefined,
+    };
+    it('should call next and log success event', async () => {
+        const interceptor = new audit_interceptor_1.AuditInterceptor(auditService);
+        const next = jest.fn().mockResolvedValue('ok');
+        const result = await interceptor.intercept(emptyContext, next);
+        expect(result).toBe('ok');
+        expect(next).toHaveBeenCalledTimes(1);
+        expect(captured).toHaveLength(1);
+        expect(captured[0].result).toBe('success');
+        expect(captured[0].action).toBe('http.get');
+    });
+    it('should log failure and rethrow when next throws', async () => {
+        const interceptor = new audit_interceptor_1.AuditInterceptor(auditService);
+        const err = new Error('handler failed');
+        const next = jest.fn().mockRejectedValue(err);
+        await expect(interceptor.intercept(emptyContext, next)).rejects.toThrow('handler failed');
+        expect(next).toHaveBeenCalledTimes(1);
+        expect(captured).toHaveLength(1);
+        expect(captured[0].result).toBe('failure');
+    });
+    it('should use http.request when method is missing', async () => {
+        const interceptor = new audit_interceptor_1.AuditInterceptor(auditService);
+        const ctx = { ...emptyContext, method: '' };
+        const next = jest.fn().mockResolvedValue(undefined);
+        await interceptor.intercept(ctx, next);
+        expect(captured[0].action).toBe('http.request');
+    });
+});

package/dist/transports/console.transport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=console.transport.test.d.ts.map

package/dist/transports/console.transport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"console.transport.test.d.ts","sourceRoot":"","sources":["../../src/transports/console.transport.test.ts"],"names":[],"mappings":""}

package/dist/transports/console.transport.test.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="jest" />
+const console_transport_1 = require("./console.transport");
+describe('ConsoleAuditTransport', () => {
+    let writeSpy;
+    beforeEach(() => {
+        writeSpy = jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+    });
+    afterEach(() => {
+        writeSpy.mockRestore();
+    });
+    it('should write JSON line with _type audit', () => {
+        const transport = new console_transport_1.ConsoleAuditTransport();
+        const event = {
+            action: 'user.login',
+            timestamp: '2025-01-01T00:00:00.000Z',
+            result: 'success',
+        };
+        transport.log(event);
+        expect(writeSpy).toHaveBeenCalledTimes(1);
+        const line = writeSpy.mock.calls[0][0];
+        expect(line.endsWith('\n')).toBe(true);
+        const parsed = JSON.parse(line.trim());
+        expect(parsed._type).toBe('audit');
+        expect(parsed.action).toBe('user.login');
+        expect(parsed.timestamp).toBe(event.timestamp);
+        expect(parsed.result).toBe('success');
+    });
+    it('should include all event fields in output', () => {
+        const transport = new console_transport_1.ConsoleAuditTransport();
+        const event = {
+            action: 'order.create',
+            actor: { id: 1, username: 'alice' },
+            resource: 'Order',
+            resourceId: 'ord-123',
+            result: 'success',
+            timestamp: '2025-01-01T00:00:00.000Z',
+            metadata: { amount: 99 },
+        };
+        transport.log(event);
+        const parsed = JSON.parse(writeSpy.mock.calls[0][0].trim());
+        expect(parsed.actor).toEqual({ id: 1, username: 'alice' });
+        expect(parsed.resource).toBe('Order');
+        expect(parsed.resourceId).toBe('ord-123');
+        expect(parsed.metadata).toEqual({ amount: 99 });
+    });
+});

package/dist/transports/file.transport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=file.transport.test.d.ts.map

package/dist/transports/file.transport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file.transport.test.d.ts","sourceRoot":"","sources":["../../src/transports/file.transport.test.ts"],"names":[],"mappings":""}

package/dist/transports/file.transport.test.js

@@ -0,0 +1,125 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="jest" />
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const file_transport_1 = require("./file.transport");
+describe('FileAuditTransport', () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'audit-file-'));
+    });
+    afterEach(() => {
+        try {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+        }
+        catch {
+            // ignore
+        }
+    });
+    const baseEvent = {
+        action: 'test.action',
+        timestamp: '2025-01-01T00:00:00.000Z',
+        result: 'success',
+    };
+    it('should create parent directory when ensureDir is true', () => {
+        const subDir = path.join(tmpDir, 'nested', 'logs');
+        const filePath = path.join(subDir, 'audit.jsonl');
+        expect(fs.existsSync(subDir)).toBe(false);
+        new file_transport_1.FileAuditTransport({ filePath, ensureDir: true });
+        expect(fs.existsSync(subDir)).toBe(true);
+    });
+    it('should write when ensureDir is false and directory already exists', () => {
+        const filePath = path.join(tmpDir, 'audit.jsonl');
+        const transport = new file_transport_1.FileAuditTransport({ filePath, ensureDir: false });
+        transport.log(baseEvent);
+        expect(fs.readFileSync(filePath, 'utf8')).toContain('test.action');
+    });
+    it('should append one JSON line per log with _type audit', () => {
+        const filePath = path.join(tmpDir, 'audit.jsonl');
+        const transport = new file_transport_1.FileAuditTransport({ filePath });
+        transport.log(baseEvent);
+        transport.log({ ...baseEvent, action: 'second' });
+        const content = fs.readFileSync(filePath, 'utf8');
+        const lines = content.trim().split('\n');
+        expect(lines).toHaveLength(2);
+        expect(JSON.parse(lines[0])._type).toBe('audit');
+        expect(JSON.parse(lines[0]).action).toBe('test.action');
+        expect(JSON.parse(lines[1]).action).toBe('second');
+    });
+    it('should use absolute path as-is', () => {
+        const filePath = path.join(tmpDir, 'abs.jsonl');
+        const transport = new file_transport_1.FileAuditTransport({ filePath });
+        transport.log(baseEvent);
+        expect(fs.readFileSync(filePath, 'utf8')).toContain('test.action');
+    });
+    it('should roll to new file when size exceeds maxSizeBytes', () => {
+        const filePath = path.join(tmpDir, 'audit.jsonl');
+        const transport = new file_transport_1.FileAuditTransport({
+            filePath,
+            maxSizeBytes: 30,
+        });
+        // First log: write a line long enough that file size >= 30
+        const bigEvent = {
+            ...baseEvent,
+            metadata: { padding: 'x'.repeat(100) },
+        };
+        transport.log(bigEvent);
+        const filesAfterFirst = fs.readdirSync(tmpDir);
+        expect(filesAfterFirst).toHaveLength(1);
+        // Second log should trigger roll (current file is over 30 bytes)
+        transport.log({ ...baseEvent, action: 'after-roll' });
+        const files = fs.readdirSync(tmpDir);
+        expect(files.length).toBeGreaterThanOrEqual(2);
+        const rolledFile = files.find((f) => {
+            const content = fs.readFileSync(path.join(tmpDir, f), 'utf8');
+            return content.includes('after-roll');
+        });
+        expect(rolledFile).toBeDefined();
+        expect(rolledFile).not.toBe('audit.jsonl');
+    });
+    it('should use date suffix when rollDaily is true', () => {
+        const filePath = path.join(tmpDir, 'audit.jsonl');
+        const transport = new file_transport_1.FileAuditTransport({ filePath, rollDaily: true });
+        transport.log(baseEvent);
+        const files = fs.readdirSync(tmpDir);
+        expect(files.length).toBe(1);
+        const expectedSuffix = new Date().toISOString().slice(0, 10); // YYYY-MM-DD
+        expect(files[0]).toContain(expectedSuffix);
+        expect(fs.readFileSync(path.join(tmpDir, files[0]), 'utf8')).toContain('test.action');
+    });
+});

package/dist/transports/kafka.transport.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=kafka.transport.test.d.ts.map

package/dist/transports/kafka.transport.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"kafka.transport.test.d.ts","sourceRoot":"","sources":["../../src/transports/kafka.transport.test.ts"],"names":[],"mappings":""}

package/dist/transports/kafka.transport.test.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/// <reference types="jest" />
+const kafka_transport_1 = require("./kafka.transport");
+describe('KafkaAuditTransport', () => {
+    const baseEvent = {
+        action: 'order.create',
+        timestamp: '2025-01-01T00:00:00.000Z',
+        result: 'success',
+        resource: 'Order',
+        resourceId: 'ord-1',
+    };
+    it('should send JSON-serialized event by default', async () => {
+        const send = jest.fn().mockResolvedValue(undefined);
+        const sender = { send };
+        const transport = new kafka_transport_1.KafkaAuditTransport({ sender, topic: 'audit' });
+        await transport.log(baseEvent);
+        expect(send).toHaveBeenCalledTimes(1);
+        expect(send).toHaveBeenCalledWith('audit', { value: JSON.stringify(baseEvent) });
+    });
+    it('should include key when key option is provided', async () => {
+        const send = jest.fn().mockResolvedValue(undefined);
+        const sender = { send };
+        const transport = new kafka_transport_1.KafkaAuditTransport({
+            sender,
+            topic: 'audit',
+            key: (e) => e.resourceId ?? '',
+        });
+        await transport.log(baseEvent);
+        expect(send).toHaveBeenCalledWith('audit', { key: 'ord-1', value: JSON.stringify(baseEvent) });
+    });
+    it('should use custom serialize when provided', async () => {
+        const send = jest.fn().mockResolvedValue(undefined);
+        const sender = { send };
+        const transport = new kafka_transport_1.KafkaAuditTransport({
+            sender,
+            topic: 'events',
+            serialize: (e) => `custom:${e.action}`,
+        });
+        await transport.log(baseEvent);
+        expect(send).toHaveBeenCalledWith('events', { value: 'custom:order.create' });
+    });
+    it('should support async serialize', async () => {
+        const send = jest.fn().mockResolvedValue(undefined);
+        const sender = { send };
+        const transport = new kafka_transport_1.KafkaAuditTransport({
+            sender,
+            topic: 'audit',
+            serialize: (e) => Promise.resolve(Buffer.from(JSON.stringify(e))),
+        });
+        await transport.log(baseEvent);
+        expect(send).toHaveBeenCalledTimes(1);
+        const value = send.mock.calls[0][1].value;
+        expect(Buffer.isBuffer(value)).toBe(true);
+        expect(JSON.parse(value.toString())).toEqual(baseEvent);
+    });
+    it('should not include key when key function returns undefined', async () => {
+        const send = jest.fn().mockResolvedValue(undefined);
+        const sender = { send };
+        const transport = new kafka_transport_1.KafkaAuditTransport({
+            sender,
+            topic: 'audit',
+            key: () => undefined,
+        });
+        await transport.log(baseEvent);
+        expect(send).toHaveBeenCalledWith('audit', { value: JSON.stringify(baseEvent) });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hazeljs/audit",
-  "version": "0.2.0-beta.53",
+  "version": "0.2.0-beta.55",
   "description": "Audit logging and event trail for HazelJS applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -49,5 +49,5 @@
   "peerDependencies": {
     "@hazeljs/core": ">=0.2.0-beta.0"
   },
-  "gitHead": "84311f65083627fa53bf2a22f96cd212c196873c"
+  "gitHead": "f2e54f346eea552595a44607999454a9e388cb9e"
 }