@c15t/backend 2.0.0-rc.4 → 2.0.0-rc.5

package/src/db/registry/consent-policy.test.ts

@@ -1,451 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { ConsentPolicy, PolicyType } from '../schema';
-import { policyRegistry } from './consent-policy';
-import type { Registry } from './types';
-
-describe('policyRegistry', () => {
-	const mockLogger = {
-		debug: vi.fn(),
-		error: vi.fn(),
-		info: vi.fn(),
-		warn: vi.fn(),
-	};
-
-	vi.mock('./utils/generate-id', () => ({
-		generateUniqueId: vi.fn().mockResolvedValue('pol_test'),
-	}));
-
-	/**
-	 * Creates a mock consent policy object with the specified overrides
-	 *
-	 * @param overrides - Partial consent policy properties to override defaults
-	 * @returns A complete ConsentPolicy object for testing
-	 */
-	const createMockConsentPolicy = (
-		overrides: Partial<ConsentPolicy> = {}
-	): ConsentPolicy => ({
-		id: 'pol_test',
-		version: '1.0.0',
-		type: 'privacy_policy',
-		effectiveDate: new Date('2024-01-01T00:00:00.000Z'),
-		isActive: true,
-		createdAt: new Date('2024-01-01T00:00:00.000Z'),
-		...overrides,
-	});
-
-	afterEach(() => {
-		vi.clearAllMocks();
-	});
-
-	describe('findConsentPolicyById', () => {
-		it('should return policy when found by id', async () => {
-			const mockPolicy = createMockConsentPolicy({
-				id: 'pol_specific_123',
-				type: 'cookie_banner',
-			});
-
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(mockPolicy),
-			};
-
-			const registry = policyRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			const result = await registry.findConsentPolicyById('pol_specific_123');
-
-			expect(db.findFirst).toHaveBeenCalledWith('consentPolicy', {
-				where: expect.any(Function),
-			});
-
-			expect(result).toEqual(mockPolicy);
-		});
-
-		it('should return null when policy not found by id', async () => {
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(null),
-			};
-
-			const registry = policyRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			const result = await registry.findConsentPolicyById('nonexistent_id');
-
-			expect(db.findFirst).toHaveBeenCalledWith('consentPolicy', {
-				where: expect.any(Function),
-			});
-
-			expect(result).toBeNull();
-		});
-
-		it('should handle various policy id formats', async () => {
-			const testIds = [
-				'pol_123',
-				'policy_test_long_id_name',
-				'SHORT',
-				'ID_WITH_UNDERSCORES',
-				'mixed.Case-id_123',
-			];
-
-			for (const testId of testIds) {
-				const mockPolicy = createMockConsentPolicy({ id: testId });
-
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(mockPolicy),
-				};
-
-				const registry = policyRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const result = await registry.findConsentPolicyById(testId);
-
-				expect(result?.id).toBe(testId);
-				expect(db.findFirst).toHaveBeenCalledWith('consentPolicy', {
-					where: expect.any(Function),
-				});
-
-				vi.clearAllMocks();
-			}
-		});
-
-		it('should propagate database errors', async () => {
-			const dbError = new Error('Database connection failed');
-			const db = {
-				findFirst: vi.fn().mockRejectedValue(dbError),
-			};
-
-			const registry = policyRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			const promise = registry.findConsentPolicyById('error_id');
-
-			await expect(promise).rejects.toThrow('Database connection failed');
-		});
-	});
-
-	describe('findOrCreatePolicy', () => {
-		describe('when policy exists', () => {
-			it('should return existing active policy for given type', async () => {
-				const mockPolicy = createMockConsentPolicy({
-					type: 'terms_and_conditions',
-					version: '2.1.0',
-					isActive: true,
-				});
-
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(mockPolicy),
-					create: vi.fn(),
-				};
-
-				const registry = policyRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const result = await registry.findOrCreatePolicy(
-					'terms_and_conditions'
-				);
-
-				expect(db.findFirst).toHaveBeenCalledWith('consentPolicy', {
-					where: expect.any(Function),
-					orderBy: ['effectiveDate', 'desc'],
-				});
-
-				expect(db.create).not.toHaveBeenCalled();
-				expect(result).toEqual(mockPolicy);
-				expect(mockLogger.debug).toHaveBeenCalledWith('Found existing policy', {
-					type: 'terms_and_conditions',
-					policyId: mockPolicy.id,
-				});
-			});
-
-			it('should handle all valid policy types', async () => {
-				const validPolicyTypes: PolicyType[] = [
-					'cookie_banner',
-					'privacy_policy',
-					'dpa',
-					'terms_and_conditions',
-					'marketing_communications',
-					'age_verification',
-					'other',
-				];
-
-				for (const policyType of validPolicyTypes) {
-					const mockPolicy = createMockConsentPolicy({
-						type: policyType,
-					});
-
-					const db = {
-						findFirst: vi.fn().mockResolvedValue(mockPolicy),
-						create: vi.fn(),
-					};
-
-					const registry = policyRegistry({
-						db,
-						ctx: { logger: mockLogger },
-					} as unknown as Registry);
-
-					const result = await registry.findOrCreatePolicy(policyType);
-
-					expect(result.type).toBe(policyType);
-					expect(db.create).not.toHaveBeenCalled();
-
-					vi.clearAllMocks();
-				}
-			});
-
-			it('should return most recent active policy when multiple exist', async () => {
-				const mostRecentPolicy = createMockConsentPolicy({
-					id: 'pol_most_recent',
-					effectiveDate: new Date('2024-03-01T00:00:00.000Z'),
-					version: '3.0.0',
-				});
-
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(mostRecentPolicy),
-					create: vi.fn(),
-				};
-
-				const registry = policyRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const result = await registry.findOrCreatePolicy('privacy_policy');
-
-				expect(db.findFirst).toHaveBeenCalledWith('consentPolicy', {
-					where: expect.any(Function),
-					orderBy: ['effectiveDate', 'desc'],
-				});
-
-				expect(result).toEqual(mostRecentPolicy);
-				expect(result.id).toBe('pol_most_recent');
-			});
-		});
-
-		describe('when policy does not exist', () => {
-			it('should create new policy with minimal fields', async () => {
-				const fakeDate = new Date('2024-01-15T10:30:00.000Z');
-				vi.useFakeTimers();
-				vi.setSystemTime(fakeDate);
-
-				const newMockPolicy = createMockConsentPolicy({
-					id: 'pol_test',
-					type: 'dpa',
-					effectiveDate: fakeDate,
-				});
-
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(null),
-					create: vi.fn().mockResolvedValue(newMockPolicy),
-				};
-
-				const registry = policyRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const result = await registry.findOrCreatePolicy('dpa');
-
-				expect(db.findFirst).toHaveBeenCalledWith('consentPolicy', {
-					where: expect.any(Function),
-					orderBy: ['effectiveDate', 'desc'],
-				});
-
-				expect(db.create).toHaveBeenCalledWith('consentPolicy', {
-					id: 'pol_test',
-					version: '1.0.0',
-					type: 'dpa',
-					effectiveDate: fakeDate,
-					isActive: true,
-				});
-
-				expect(result).toEqual(newMockPolicy);
-
-				vi.useRealTimers();
-			});
-
-			it('should create policies for all valid types with correct defaults', async () => {
-				const validPolicyTypes: PolicyType[] = [
-					'cookie_banner',
-					'privacy_policy',
-					'dpa',
-					'terms_and_conditions',
-					'marketing_communications',
-					'age_verification',
-					'other',
-				];
-
-				const fakeDate = new Date('2024-02-01T00:00:00.000Z');
-				vi.useFakeTimers();
-				vi.setSystemTime(fakeDate);
-
-				for (const policyType of validPolicyTypes) {
-					const mockPolicy = createMockConsentPolicy({
-						type: policyType,
-						effectiveDate: fakeDate,
-					});
-
-					const db = {
-						findFirst: vi.fn().mockResolvedValue(null),
-						create: vi.fn().mockResolvedValue(mockPolicy),
-					};
-
-					const registry = policyRegistry({
-						db,
-						ctx: { logger: mockLogger },
-					} as unknown as Registry);
-
-					const result = await registry.findOrCreatePolicy(policyType);
-
-					expect(db.create).toHaveBeenCalledWith('consentPolicy', {
-						id: 'pol_test',
-						version: '1.0.0',
-						type: policyType,
-						effectiveDate: fakeDate,
-						isActive: true,
-					});
-
-					expect(result.type).toBe(policyType);
-					expect(result.version).toBe('1.0.0');
-					expect(result.isActive).toBe(true);
-
-					vi.clearAllMocks();
-				}
-
-				vi.useRealTimers();
-			});
-		});
-
-		describe('error handling', () => {
-			it('should propagate database findFirst errors', async () => {
-				const dbError = new Error('Database query failed');
-				const db = {
-					findFirst: vi.fn().mockRejectedValue(dbError),
-				};
-
-				const registry = policyRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const promise = registry.findOrCreatePolicy('privacy_policy');
-
-				await expect(promise).rejects.toThrow('Database query failed');
-			});
-
-			it('should propagate database create errors', async () => {
-				const dbError = new Error('Create operation failed');
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(null),
-					create: vi.fn().mockRejectedValue(dbError),
-				};
-
-				const registry = policyRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const promise = registry.findOrCreatePolicy('privacy_policy');
-
-				await expect(promise).rejects.toThrow('Create operation failed');
-			});
-		});
-	});
-
-	describe('database query construction', () => {
-		it('should construct correct query for policy lookup by id', async () => {
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(null),
-			};
-
-			const registry = policyRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			await registry.findConsentPolicyById('test_id');
-
-			expect(db.findFirst).toHaveBeenCalledWith('consentPolicy', {
-				where: expect.any(Function),
-			});
-
-			const whereCall = db.findFirst.mock.calls[0]?.[1];
-			expect(whereCall).toHaveProperty('where');
-			expect(typeof whereCall?.where).toBe('function');
-		});
-
-		it('should construct correct query for active policy lookup by type', async () => {
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(null),
-				create: vi.fn().mockResolvedValue(createMockConsentPolicy()),
-			};
-
-			const registry = policyRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			await registry.findOrCreatePolicy('privacy_policy');
-
-			expect(db.findFirst).toHaveBeenCalledWith('consentPolicy', {
-				where: expect.any(Function),
-				orderBy: ['effectiveDate', 'desc'],
-			});
-
-			const findCall = db.findFirst.mock.calls[0]?.[1];
-			expect(findCall).toHaveProperty('where');
-			expect(findCall).toHaveProperty('orderBy');
-			expect(findCall?.orderBy).toEqual(['effectiveDate', 'desc']);
-		});
-	});
-
-	describe('edge cases', () => {
-		it('should handle concurrent policy creation requests', async () => {
-			const fakeDate = new Date('2024-01-01T00:00:00.000Z');
-			vi.useFakeTimers();
-			vi.setSystemTime(fakeDate);
-
-			const mockPolicy = createMockConsentPolicy({
-				type: 'privacy_policy',
-				effectiveDate: fakeDate,
-			});
-
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(null),
-				create: vi.fn().mockResolvedValue(mockPolicy),
-			};
-
-			const registry = policyRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			// Simulate concurrent requests
-			const promises = [
-				registry.findOrCreatePolicy('privacy_policy'),
-				registry.findOrCreatePolicy('privacy_policy'),
-				registry.findOrCreatePolicy('privacy_policy'),
-			];
-
-			const results = await Promise.all(promises);
-
-			// All should succeed (actual uniqueness would be handled by database constraints)
-			expect(results).toHaveLength(3);
-			for (const result of results) {
-				expect(result.type).toBe('privacy_policy');
-			}
-
-			expect(db.create).toHaveBeenCalledTimes(3);
-
-			vi.useRealTimers();
-		});
-	});
-});

package/src/db/registry/consent-policy.ts

@@ -1,82 +0,0 @@
-import { withDatabaseSpan } from '~/utils/instrumentation';
-import { getMetrics } from '~/utils/metrics';
-import type { PolicyType } from '../schema';
-import type { Registry } from './types';
-import { generateUniqueId } from './utils/generate-id';
-
-export function policyRegistry({ db, ctx }: Registry) {
-	const { logger } = ctx;
-
-	return {
-		findConsentPolicyById: async (policyId: string) => {
-			const start = Date.now();
-			try {
-				const result = await withDatabaseSpan(
-					{ operation: 'find', entity: 'consentPolicy' },
-					async () => {
-						const policy = await db.findFirst('consentPolicy', {
-							where: (b) => b('id', '=', policyId),
-						});
-						return policy;
-					}
-				);
-				getMetrics()?.recordDbQuery(
-					{ operation: 'find', entity: 'consentPolicy' },
-					Date.now() - start
-				);
-				return result;
-			} catch (error) {
-				getMetrics()?.recordDbError({
-					operation: 'find',
-					entity: 'consentPolicy',
-				});
-				throw error;
-			}
-		},
-		findOrCreatePolicy: async (type: PolicyType) => {
-			const start = Date.now();
-			try {
-				const result = await withDatabaseSpan(
-					{ operation: 'findOrCreate', entity: 'consentPolicy' },
-					async () => {
-						// Gets most recent active policy for a given type
-						const existingPolicy = await db.findFirst('consentPolicy', {
-							where: (b) =>
-								b.and(b('isActive', '=', true), b('type', '=', type)),
-							orderBy: ['effectiveDate', 'desc'],
-						});
-
-						if (existingPolicy) {
-							logger.debug('Found existing policy', {
-								type,
-								policyId: existingPolicy.id,
-							});
-							return existingPolicy;
-						}
-
-						const policy = await db.create('consentPolicy', {
-							id: await generateUniqueId(db, 'consentPolicy', ctx),
-							version: '1.0.0',
-							type,
-							effectiveDate: new Date(),
-							isActive: true,
-						});
-
-						return policy;
-					}
-				);
-				getMetrics()?.recordDbQuery(
-					{ operation: 'findOrCreate', entity: 'consentPolicy' },
-					Date.now() - start
-				);
-				return result;
-			} catch (error) {
-				getMetrics()?.recordDbError({
-					operation: 'findOrCreate',
-					entity: 'consentPolicy',
-				});
-				throw error;
-			}
-		},
-	};
-}