@geekmidas/audit 9.0.2 → 10.0.0-alpha.1

package/src/__tests__/KyselyAuditStorage.spec.ts

@@ -1,443 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { type AuditLogTable, KyselyAuditStorage } from '../kysely';
-import type { AuditRecord } from '../types';
-
-// Mock Kysely database
-function createMockDb() {
-	const rows: AuditLogTable[] = [];
-
-	const insertBuilder = {
-		values: vi.fn().mockReturnThis(),
-		execute: vi.fn(async () => {
-			return [];
-		}),
-	};
-
-	const selectBuilder = {
-		selectAll: vi.fn().mockReturnThis(),
-		select: vi.fn().mockReturnThis(),
-		where: vi.fn().mockReturnThis(),
-		orderBy: vi.fn().mockReturnThis(),
-		limit: vi.fn().mockReturnThis(),
-		offset: vi.fn().mockReturnThis(),
-		execute: vi.fn(async () => rows),
-		executeTakeFirst: vi.fn(async () => ({ count: rows.length })),
-	};
-
-	const db = {
-		insertInto: vi.fn(() => insertBuilder),
-		selectFrom: vi.fn(() => selectBuilder),
-	};
-
-	return {
-		db,
-		insertBuilder,
-		selectBuilder,
-		rows,
-		addRow: (row: AuditLogTable) => rows.push(row),
-	};
-}
-
-describe('KyselyAuditStorage', () => {
-	let mockDb: ReturnType<typeof createMockDb>;
-	let storage: KyselyAuditStorage<{ audit_logs: AuditLogTable }>;
-
-	beforeEach(() => {
-		mockDb = createMockDb();
-		storage = new KyselyAuditStorage({
-			db: mockDb.db as any,
-			tableName: 'audit_logs',
-		});
-	});
-
-	describe('write', () => {
-		it('should write records to database', async () => {
-			const records: AuditRecord[] = [
-				{
-					id: 'audit-1',
-					type: 'user.created',
-					operation: 'INSERT',
-					table: 'users',
-					entityId: 'user-123',
-					payload: { email: 'test@example.com' },
-					timestamp: new Date('2024-01-01T00:00:00Z'),
-					actor: { id: 'admin-1', type: 'admin' },
-					metadata: { requestId: 'req-123' },
-				},
-			];
-
-			await storage.write(records);
-
-			expect(mockDb.db.insertInto).toHaveBeenCalledWith('audit_logs');
-			expect(mockDb.insertBuilder.values).toHaveBeenCalledWith([
-				expect.objectContaining({
-					id: 'audit-1',
-					type: 'user.created',
-					operation: 'INSERT',
-					table: 'users',
-					entityId: 'user-123',
-					payload: { email: 'test@example.com' },
-					actorId: 'admin-1',
-					actorType: 'admin',
-					metadata: { requestId: 'req-123' },
-				}),
-			]);
-		});
-
-		it('should use transaction when provided', async () => {
-			const mockTrx = {
-				insertInto: vi.fn(() => ({
-					values: vi.fn().mockReturnThis(),
-					execute: vi.fn(),
-				})),
-			};
-
-			const records: AuditRecord[] = [
-				{
-					id: 'audit-1',
-					type: 'user.created',
-					operation: 'CUSTOM',
-					timestamp: new Date(),
-				},
-			];
-
-			await storage.write(records, mockTrx);
-
-			expect(mockTrx.insertInto).toHaveBeenCalledWith('audit_logs');
-			expect(mockDb.db.insertInto).not.toHaveBeenCalled();
-		});
-
-		it('should do nothing for empty records', async () => {
-			await storage.write([]);
-
-			expect(mockDb.db.insertInto).not.toHaveBeenCalled();
-		});
-
-		it('should handle complex entity IDs', async () => {
-			const records: AuditRecord[] = [
-				{
-					id: 'audit-1',
-					type: 'relation.created',
-					operation: 'INSERT',
-					entityId: { userId: 'u1', roleId: 'r1' },
-					timestamp: new Date(),
-				},
-			];
-
-			await storage.write(records);
-
-			expect(mockDb.insertBuilder.values).toHaveBeenCalledWith([
-				expect.objectContaining({
-					entityId: JSON.stringify({ userId: 'u1', roleId: 'r1' }),
-				}),
-			]);
-		});
-
-		it('should store extra actor properties', async () => {
-			const records: AuditRecord[] = [
-				{
-					id: 'audit-1',
-					type: 'user.created',
-					operation: 'CUSTOM',
-					timestamp: new Date(),
-					actor: {
-						id: 'user-1',
-						type: 'user',
-						email: 'user@example.com',
-						role: 'admin',
-					},
-				},
-			];
-
-			await storage.write(records);
-
-			expect(mockDb.insertBuilder.values).toHaveBeenCalledWith([
-				expect.objectContaining({
-					actorId: 'user-1',
-					actorType: 'user',
-					actorData: {
-						email: 'user@example.com',
-						role: 'admin',
-					},
-				}),
-			]);
-		});
-
-		it('should generate ID with nanoid when autoId is false (default)', async () => {
-			const records: AuditRecord[] = [
-				{
-					id: '', // Empty ID
-					type: 'user.created',
-					operation: 'CUSTOM',
-					timestamp: new Date(),
-				},
-			];
-
-			await storage.write(records);
-
-			const calledValues = mockDb.insertBuilder.values.mock.calls[0][0];
-			expect(calledValues[0].id).toBeDefined();
-			expect(calledValues[0].id.length).toBeGreaterThan(0);
-		});
-
-		it('should use provided ID when autoId is false (default)', async () => {
-			const records: AuditRecord[] = [
-				{
-					id: 'my-custom-id',
-					type: 'user.created',
-					operation: 'CUSTOM',
-					timestamp: new Date(),
-				},
-			];
-
-			await storage.write(records);
-
-			expect(mockDb.insertBuilder.values).toHaveBeenCalledWith([
-				expect.objectContaining({
-					id: 'my-custom-id',
-				}),
-			]);
-		});
-
-		it('should omit ID when autoId is true and no ID provided', async () => {
-			const storageAutoId = new KyselyAuditStorage({
-				db: mockDb.db as any,
-				tableName: 'audit_logs',
-				autoId: true,
-			});
-
-			const records: AuditRecord[] = [
-				{
-					id: '', // Empty ID - let database generate
-					type: 'user.created',
-					operation: 'CUSTOM',
-					timestamp: new Date(),
-				},
-			];
-
-			await storageAutoId.write(records);
-
-			const calledValues = mockDb.insertBuilder.values.mock.calls[0][0];
-			expect(calledValues[0].id).toBeUndefined();
-		});
-
-		it('should omit ID even if provided when autoId is true', async () => {
-			const storageAutoId = new KyselyAuditStorage({
-				db: mockDb.db as any,
-				tableName: 'audit_logs',
-				autoId: true,
-			});
-
-			const records: AuditRecord[] = [
-				{
-					id: 'explicit-id', // This should be ignored when autoId is true
-					type: 'user.created',
-					operation: 'CUSTOM',
-					timestamp: new Date(),
-				},
-			];
-
-			await storageAutoId.write(records);
-
-			// When autoId is true, ID should always be omitted (let database generate)
-			const calledValues = mockDb.insertBuilder.values.mock.calls[0][0];
-			expect(calledValues[0].id).toBeUndefined();
-		});
-	});
-
-	describe('query', () => {
-		it('should return records from database', async () => {
-			mockDb.addRow({
-				id: 'audit-1',
-				type: 'user.created',
-				operation: 'INSERT',
-				table: 'users',
-				entityId: 'user-123',
-				oldValues: null,
-				newValues: JSON.stringify({ name: 'Test' }),
-				payload: JSON.stringify({ email: 'test@example.com' }),
-				timestamp: new Date('2024-01-01T00:00:00Z'),
-				actorId: 'admin-1',
-				actorType: 'admin',
-				actorData: null,
-				metadata: JSON.stringify({ requestId: 'req-123' }),
-			});
-
-			const results = await storage.query({});
-
-			expect(results).toHaveLength(1);
-			expect(results[0]).toMatchObject({
-				id: 'audit-1',
-				type: 'user.created',
-				operation: 'INSERT',
-				table: 'users',
-				entityId: 'user-123',
-				newValues: { name: 'Test' },
-				payload: { email: 'test@example.com' },
-				actor: { id: 'admin-1', type: 'admin' },
-				metadata: { requestId: 'req-123' },
-			});
-		});
-
-		it('should apply type filter', async () => {
-			await storage.query({ type: 'user.created' });
-
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith(
-				'type',
-				'=',
-				'user.created',
-			);
-		});
-
-		it('should apply type array filter', async () => {
-			await storage.query({ type: ['user.created', 'user.updated'] });
-
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith('type', 'in', [
-				'user.created',
-				'user.updated',
-			]);
-		});
-
-		it('should apply entity ID filter', async () => {
-			await storage.query({ entityId: 'user-123' });
-
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith(
-				'entityId',
-				'=',
-				'user-123',
-			);
-		});
-
-		it('should apply table filter', async () => {
-			await storage.query({ table: 'users' });
-
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith(
-				'table',
-				'=',
-				'users',
-			);
-		});
-
-		it('should apply actor ID filter', async () => {
-			await storage.query({ actorId: 'admin-1' });
-
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith(
-				'actorId',
-				'=',
-				'admin-1',
-			);
-		});
-
-		it('should apply date range filters', async () => {
-			const from = new Date('2024-01-01');
-			const to = new Date('2024-12-31');
-
-			await storage.query({ from, to });
-
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith(
-				'timestamp',
-				'>=',
-				from,
-			);
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith(
-				'timestamp',
-				'<=',
-				to,
-			);
-		});
-
-		it('should apply pagination', async () => {
-			await storage.query({ limit: 10, offset: 20 });
-
-			expect(mockDb.selectBuilder.limit).toHaveBeenCalledWith(10);
-			expect(mockDb.selectBuilder.offset).toHaveBeenCalledWith(20);
-		});
-
-		it('should apply ordering', async () => {
-			await storage.query({ orderBy: 'type', orderDirection: 'asc' });
-
-			expect(mockDb.selectBuilder.orderBy).toHaveBeenCalledWith('type', 'asc');
-		});
-
-		it('should default to timestamp desc ordering', async () => {
-			await storage.query({});
-
-			expect(mockDb.selectBuilder.orderBy).toHaveBeenCalledWith(
-				'timestamp',
-				'desc',
-			);
-		});
-
-		it('should parse complex entity IDs', async () => {
-			mockDb.addRow({
-				id: 'audit-1',
-				type: 'relation.created',
-				operation: 'INSERT',
-				table: null,
-				entityId: JSON.stringify({ userId: 'u1', roleId: 'r1' }),
-				oldValues: null,
-				newValues: null,
-				payload: null,
-				timestamp: new Date(),
-				actorId: null,
-				actorType: null,
-				actorData: null,
-				metadata: null,
-			});
-
-			const results = await storage.query({});
-
-			expect(results[0].entityId).toEqual({ userId: 'u1', roleId: 'r1' });
-		});
-
-		it('should merge actor data', async () => {
-			mockDb.addRow({
-				id: 'audit-1',
-				type: 'user.created',
-				operation: 'CUSTOM',
-				table: null,
-				entityId: null,
-				oldValues: null,
-				newValues: null,
-				payload: null,
-				timestamp: new Date(),
-				actorId: 'user-1',
-				actorType: 'user',
-				actorData: JSON.stringify({ email: 'user@example.com' }),
-				metadata: null,
-			});
-
-			const results = await storage.query({});
-
-			expect(results[0].actor).toEqual({
-				id: 'user-1',
-				type: 'user',
-				email: 'user@example.com',
-			});
-		});
-	});
-
-	describe('count', () => {
-		it('should return count from database', async () => {
-			const count = await storage.count({});
-
-			expect(count).toBe(0);
-			expect(mockDb.selectBuilder.select).toHaveBeenCalled();
-		});
-
-		it('should apply filters to count', async () => {
-			await storage.count({ type: 'user.created', actorId: 'admin-1' });
-
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith(
-				'type',
-				'=',
-				'user.created',
-			);
-			expect(mockDb.selectBuilder.where).toHaveBeenCalledWith(
-				'actorId',
-				'=',
-				'admin-1',
-			);
-		});
-	});
-});

package/src/cache.ts

@@ -1,263 +0,0 @@
-import type { Cache } from '@geekmidas/cache';
-import type { AuditQueryOptions, AuditStorage } from './storage';
-import type { AuditableAction, AuditRecord } from './types';
-
-/**
- * Configuration for CacheAuditStorage.
- */
-export interface CacheAuditStorageConfig {
-	/** Cache instance to use for storage */
-	cache: Cache;
-	/**
-	 * Key prefix for audit records.
-	 * Records are stored as `${prefix}:${id}`.
-	 * @default 'audit'
-	 */
-	prefix?: string;
-	/**
-	 * TTL (time-to-live) in seconds for audit records.
-	 * If not set, records use the cache's default TTL.
-	 */
-	ttl?: number;
-}
-
-/**
- * Cache-based audit storage implementation.
- * Uses any @geekmidas/cache implementation for storage.
- *
- * Best suited for:
- * - Development and testing
- * - Temporary audit logs that don't need persistence
- * - Applications with existing cache infrastructure
- * - Distributed systems needing shared audit state (with Redis/Upstash)
- *
- * Note: Query performance may degrade with large numbers of records
- * since filtering happens in memory after fetching all records.
- *
- * @template TAuditAction - Optional type parameter for type-safe audit actions.
- *
- * @example
- * ```typescript
- * import { CacheAuditStorage } from '@geekmidas/audit/cache';
- * import { InMemoryCache } from '@geekmidas/cache/memory';
- * import { UpstashCache } from '@geekmidas/cache/upstash';
- *
- * // With in-memory cache (development/testing)
- * const storage = new CacheAuditStorage({
- *   cache: new InMemoryCache(),
- *   ttl: 86400, // 24 hours
- * });
- *
- * // With Upstash Redis (production)
- * const storage = new CacheAuditStorage({
- *   cache: new UpstashCache({
- *     url: process.env.UPSTASH_REDIS_URL,
- *     token: process.env.UPSTASH_REDIS_TOKEN,
- *   }),
- *   ttl: 604800, // 7 days
- * });
- * ```
- */
-export class CacheAuditStorage<
-	TAuditAction extends AuditableAction<string, unknown> = AuditableAction<
-		string,
-		unknown
-	>,
-> implements AuditStorage<TAuditAction>
-{
-	private readonly cache: Cache;
-	private readonly prefix: string;
-	private readonly ttl?: number;
-	private readonly indexKey: string;
-
-	constructor(config: CacheAuditStorageConfig) {
-		this.cache = config.cache;
-		this.prefix = config.prefix ?? 'audit';
-		this.ttl = config.ttl;
-		this.indexKey = `${this.prefix}:__index__`;
-	}
-
-	/**
-	 * Write audit records to cache.
-	 */
-	async write(records: AuditRecord[]): Promise<void> {
-		if (records.length === 0) {
-			return;
-		}
-
-		// Get existing index
-		const existingIds = (await this.cache.get<string[]>(this.indexKey)) ?? [];
-		const newIds: string[] = [];
-
-		// Write each record
-		for (const record of records) {
-			const key = this.getRecordKey(record.id);
-			// Serialize Date to ISO string for cache storage
-			const serialized = this.serializeRecord(record);
-			await this.cache.set(key, serialized, this.ttl);
-			newIds.push(record.id);
-		}
-
-		// Update index with new IDs
-		const updatedIds = [...existingIds, ...newIds];
-		await this.cache.set(this.indexKey, updatedIds, this.ttl);
-	}
-
-	/**
-	 * Query audit records from cache.
-	 */
-	async query(options: AuditQueryOptions): Promise<AuditRecord[]> {
-		const allRecords = await this.getAllRecords();
-		let results = this.applyFilters(allRecords, options);
-
-		// Ordering
-		const orderBy = options.orderBy ?? 'timestamp';
-		const orderDirection = options.orderDirection ?? 'desc';
-		results.sort((a, b) => {
-			const aValue = orderBy === 'timestamp' ? a.timestamp.getTime() : a.type;
-			const bValue = orderBy === 'timestamp' ? b.timestamp.getTime() : b.type;
-			if (aValue < bValue) return orderDirection === 'asc' ? -1 : 1;
-			if (aValue > bValue) return orderDirection === 'asc' ? 1 : -1;
-			return 0;
-		});
-
-		// Pagination
-		if (options.offset !== undefined) {
-			results = results.slice(options.offset);
-		}
-		if (options.limit !== undefined) {
-			results = results.slice(0, options.limit);
-		}
-
-		return results;
-	}
-
-	/**
-	 * Count audit records matching filters.
-	 */
-	async count(
-		options: Omit<AuditQueryOptions, 'limit' | 'offset'>,
-	): Promise<number> {
-		const allRecords = await this.getAllRecords();
-		return this.applyFilters(allRecords, options).length;
-	}
-
-	/**
-	 * Get all stored records (for testing/debugging).
-	 */
-	async getRecords(): Promise<AuditRecord[]> {
-		return this.getAllRecords();
-	}
-
-	/**
-	 * Clear all stored records.
-	 */
-	async clear(): Promise<void> {
-		const ids = (await this.cache.get<string[]>(this.indexKey)) ?? [];
-
-		// Delete all records
-		for (const id of ids) {
-			await this.cache.delete(this.getRecordKey(id));
-		}
-
-		// Delete index
-		await this.cache.delete(this.indexKey);
-	}
-
-	private getRecordKey(id: string): string {
-		return `${this.prefix}:${id}`;
-	}
-
-	private async getAllRecords(): Promise<AuditRecord[]> {
-		const ids = (await this.cache.get<string[]>(this.indexKey)) ?? [];
-		const records: AuditRecord[] = [];
-		const validIds: string[] = [];
-
-		for (const id of ids) {
-			const key = this.getRecordKey(id);
-			const serialized = await this.cache.get<SerializedAuditRecord>(key);
-			if (serialized) {
-				records.push(this.deserializeRecord(serialized));
-				validIds.push(id);
-			}
-		}
-
-		// Clean up index if some records expired
-		if (validIds.length !== ids.length) {
-			await this.cache.set(this.indexKey, validIds, this.ttl);
-		}
-
-		return records;
-	}
-
-	private serializeRecord(record: AuditRecord): SerializedAuditRecord {
-		return {
-			...record,
-			timestamp: record.timestamp.toISOString(),
-		};
-	}
-
-	private deserializeRecord(serialized: SerializedAuditRecord): AuditRecord {
-		return {
-			...serialized,
-			timestamp: new Date(serialized.timestamp),
-		};
-	}
-
-	private applyFilters(
-		records: AuditRecord[],
-		options: AuditQueryOptions,
-	): AuditRecord[] {
-		return records.filter((record) => {
-			// Type filter
-			if (options.type !== undefined) {
-				if (Array.isArray(options.type)) {
-					if (!options.type.includes(record.type)) return false;
-				} else {
-					if (record.type !== options.type) return false;
-				}
-			}
-
-			// Entity ID filter
-			if (options.entityId !== undefined) {
-				const entityId =
-					typeof options.entityId === 'string'
-						? options.entityId
-						: JSON.stringify(options.entityId);
-				const recordEntityId =
-					typeof record.entityId === 'string'
-						? record.entityId
-						: JSON.stringify(record.entityId);
-				if (recordEntityId !== entityId) return false;
-			}
-
-			// Table filter
-			if (options.table !== undefined) {
-				if (record.table !== options.table) return false;
-			}
-
-			// Actor ID filter
-			if (options.actorId !== undefined) {
-				if (record.actor?.id !== options.actorId) return false;
-			}
-
-			// Date range filters
-			if (options.from !== undefined) {
-				if (record.timestamp < options.from) return false;
-			}
-			if (options.to !== undefined) {
-				if (record.timestamp > options.to) return false;
-			}
-
-			return true;
-		});
-	}
-}
-
-/**
- * Serialized version of AuditRecord for cache storage.
- * Dates are stored as ISO strings.
- */
-type SerializedAuditRecord = Omit<AuditRecord, 'timestamp'> & {
-	timestamp: string;
-};