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

package/src/db/registry/domain.test.ts

@@ -1,445 +0,0 @@
-import { HTTPException } from 'hono/http-exception';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import type { Domain } from '../schema';
-import { domainRegistry } from './domain';
-import type { Registry } from './types';
-
-describe('domainRegistry', () => {
-	const mockLogger = {
-		debug: vi.fn(),
-		error: vi.fn(),
-		info: vi.fn(),
-		warn: vi.fn(),
-	};
-
-	vi.mock('./utils/generate-id', () => ({
-		generateUniqueId: vi.fn().mockResolvedValue('dom_test'),
-	}));
-
-	/**
-	 * Creates a mock domain object with the specified overrides
-	 *
-	 * @param overrides - Partial domain properties to override defaults
-	 * @returns A complete Domain object for testing
-	 */
-	const createMockDomain = (overrides: Partial<Domain> = {}): Domain => ({
-		id: 'dom_test',
-		name: 'example.com',
-		createdAt: new Date('2024-01-01T00:00:00.000Z'),
-		updatedAt: new Date('2024-01-01T00:00:00.000Z'),
-		...overrides,
-	});
-
-	afterEach(() => {
-		vi.clearAllMocks();
-	});
-
-	describe('findDomainByName', () => {
-		it('should return domain when found by name', async () => {
-			const mockDomain = createMockDomain({
-				name: 'example.com',
-			});
-
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(mockDomain),
-			};
-
-			const registry = domainRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			const result = await registry.findDomainByName('example.com');
-
-			expect(db.findFirst).toHaveBeenCalledWith('domain', {
-				where: expect.any(Function),
-			});
-
-			expect(result).toEqual(mockDomain);
-		});
-
-		it('should return null when domain not found by name', async () => {
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(null),
-			};
-
-			const registry = domainRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			const result = await registry.findDomainByName('nonexistent.com');
-
-			expect(db.findFirst).toHaveBeenCalledWith('domain', {
-				where: expect.any(Function),
-			});
-
-			expect(result).toBeNull();
-			expect(mockLogger.debug).toHaveBeenCalledWith('No domain found', {
-				name: 'nonexistent.com',
-			});
-		});
-
-		it('should handle empty string domain name', async () => {
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(null),
-			};
-
-			const registry = domainRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			const result = await registry.findDomainByName('');
-
-			expect(db.findFirst).toHaveBeenCalledWith('domain', {
-				where: expect.any(Function),
-			});
-
-			expect(result).toBeNull();
-			expect(mockLogger.debug).toHaveBeenCalledWith('No domain found', {
-				name: '',
-			});
-		});
-	});
-
-	describe('findOrCreateDomain', () => {
-		describe('when domain exists', () => {
-			it('should return existing domain when found', async () => {
-				const mockDomain = createMockDomain({
-					name: 'existing.com',
-				});
-
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(mockDomain),
-					create: vi.fn(),
-				};
-
-				const registry = domainRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const result = await registry.findOrCreateDomain('existing.com');
-
-				expect(db.findFirst).toHaveBeenCalledWith('domain', {
-					where: expect.any(Function),
-				});
-
-				expect(db.create).not.toHaveBeenCalled();
-				expect(result).toEqual(mockDomain);
-				expect(mockLogger.debug).toHaveBeenCalledWith('Found existing domain', {
-					name: 'existing.com',
-				});
-			});
-		});
-
-		describe('when domain does not exist', () => {
-			it('should create and return new domain', async () => {
-				const newMockDomain = createMockDomain({
-					name: 'new.com',
-				});
-
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(null),
-					create: vi.fn().mockResolvedValue(newMockDomain),
-				};
-
-				const registry = domainRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const result = await registry.findOrCreateDomain('new.com');
-
-				expect(db.findFirst).toHaveBeenCalledWith('domain', {
-					where: expect.any(Function),
-				});
-
-				expect(db.create).toHaveBeenCalledWith('domain', {
-					id: 'dom_test',
-					name: 'new.com',
-				});
-
-				expect(result).toEqual(newMockDomain);
-				expect(mockLogger.debug).toHaveBeenCalledWith('Creating new domain', {
-					name: 'new.com',
-				});
-			});
-
-			it('should create domain with correct default values', async () => {
-				const newMockDomain = createMockDomain({
-					name: 'test.org',
-				});
-
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(null),
-					create: vi.fn().mockResolvedValue(newMockDomain),
-				};
-
-				const registry = domainRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				await registry.findOrCreateDomain('test.org');
-
-				expect(db.create).toHaveBeenCalledWith('domain', {
-					id: 'dom_test',
-					name: 'test.org',
-				});
-			});
-
-			it('should handle special domain names correctly', async () => {
-				const specialDomains = [
-					'localhost',
-					'127.0.0.1',
-					'sub.domain.example.com',
-					'domain-with-hyphens.co.uk',
-					'123numeric.com',
-				];
-
-				for (const domainName of specialDomains) {
-					const mockDomain = createMockDomain({
-						name: domainName,
-					});
-
-					const db = {
-						findFirst: vi.fn().mockResolvedValue(null),
-						create: vi.fn().mockResolvedValue(mockDomain),
-					};
-
-					const registry = domainRegistry({
-						db,
-						ctx: { logger: mockLogger },
-					} as unknown as Registry);
-
-					const result = await registry.findOrCreateDomain(domainName);
-
-					expect(db.create).toHaveBeenCalledWith('domain', {
-						id: 'dom_test',
-						name: domainName,
-					});
-
-					expect(result).toEqual(mockDomain);
-
-					vi.clearAllMocks();
-				}
-			});
-		});
-
-		describe('error handling', () => {
-			it('should throw HTTPException when domain creation fails', async () => {
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(null),
-					create: vi.fn().mockResolvedValue(null),
-				};
-
-				const registry = domainRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const promise = registry.findOrCreateDomain('failed.com');
-
-				await expect(promise).rejects.toBeInstanceOf(HTTPException);
-				await expect(promise).rejects.toEqual(
-					expect.objectContaining({
-						message: 'Failed to create domain',
-						status: 503,
-					})
-				);
-				const error = await registry
-					.findOrCreateDomain('failed.com')
-					.catch((e: any) => e);
-				expect(error.cause).toEqual(
-					expect.objectContaining({
-						code: 'DOMAIN_CREATION_FAILED',
-					})
-				);
-
-				expect(db.findFirst).toHaveBeenCalledWith('domain', {
-					where: expect.any(Function),
-				});
-
-				expect(db.create).toHaveBeenCalledWith('domain', {
-					id: 'dom_test',
-					name: 'failed.com',
-				});
-
-				expect(mockLogger.debug).toHaveBeenCalledWith('Creating new domain', {
-					name: 'failed.com',
-				});
-			});
-
-			it('should throw HTTPException when domain creation returns undefined', async () => {
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(null),
-					create: vi.fn().mockResolvedValue(undefined),
-				};
-
-				const registry = domainRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const promise = registry.findOrCreateDomain('undefined.com');
-
-				await expect(promise).rejects.toBeInstanceOf(HTTPException);
-				await expect(promise).rejects.toEqual(
-					expect.objectContaining({
-						message: 'Failed to create domain',
-						status: 503,
-					})
-				);
-				const error = await registry
-					.findOrCreateDomain('undefined.com')
-					.catch((e: any) => e);
-				expect(error.cause).toEqual(
-					expect.objectContaining({
-						code: 'DOMAIN_CREATION_FAILED',
-					})
-				);
-			});
-
-			it('should propagate database findFirst errors', async () => {
-				const dbError = new Error('Database connection failed');
-				const db = {
-					findFirst: vi.fn().mockRejectedValue(dbError),
-				};
-
-				const registry = domainRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const promise = registry.findOrCreateDomain('error.com');
-
-				await expect(promise).rejects.toThrow('Database connection 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 = domainRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const promise = registry.findOrCreateDomain('create-error.com');
-
-				await expect(promise).rejects.toThrow('Create operation failed');
-			});
-		});
-	});
-
-	describe('database query construction', () => {
-		it('should construct correct query for domain lookup by name', async () => {
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(null),
-			};
-
-			const registry = domainRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			await registry.findDomainByName('query-test.com');
-
-			expect(db.findFirst).toHaveBeenCalledWith('domain', {
-				where: expect.any(Function),
-			});
-
-			// Verify the where function is properly constructed
-			const whereCall = db.findFirst.mock.calls[0]?.[1];
-			expect(whereCall).toHaveProperty('where');
-			expect(typeof whereCall?.where).toBe('function');
-		});
-
-		it('should construct correct query for findOrCreateDomain lookup', async () => {
-			const mockDomain = createMockDomain();
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(mockDomain),
-			};
-
-			const registry = domainRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			await registry.findOrCreateDomain('query-existing.com');
-
-			expect(db.findFirst).toHaveBeenCalledWith('domain', {
-				where: expect.any(Function),
-			});
-
-			// Verify the where function is properly constructed
-			const whereCall = db.findFirst.mock.calls[0]?.[1];
-			expect(whereCall).toHaveProperty('where');
-			expect(typeof whereCall?.where).toBe('function');
-		});
-	});
-
-	describe('edge cases', () => {
-		it('should handle domain names with various formats', async () => {
-			const edgeCaseDomains = [
-				'a.b', // Minimal valid domain
-				'very-long-subdomain.example.org', // Long subdomain
-				'test.co.uk', // Multiple TLDs
-				'xn--nxasmq6b.xn--o3cw4h', // IDN (internationalized domain)
-			];
-
-			for (const domainName of edgeCaseDomains) {
-				const mockDomain = createMockDomain({
-					name: domainName,
-				});
-
-				const db = {
-					findFirst: vi.fn().mockResolvedValue(null),
-					create: vi.fn().mockResolvedValue(mockDomain),
-				};
-
-				const registry = domainRegistry({
-					db,
-					ctx: { logger: mockLogger },
-				} as unknown as Registry);
-
-				const result = await registry.findOrCreateDomain(domainName);
-
-				expect(result.name).toBe(domainName);
-
-				vi.clearAllMocks();
-			}
-		});
-
-		it('should maintain domain name case sensitivity', async () => {
-			const upperCaseDomain = 'EXAMPLE.COM';
-			const mockDomain = createMockDomain({
-				name: upperCaseDomain,
-			});
-
-			const db = {
-				findFirst: vi.fn().mockResolvedValue(null),
-				create: vi.fn().mockResolvedValue(mockDomain),
-			};
-
-			const registry = domainRegistry({
-				db,
-				ctx: { logger: mockLogger },
-			} as unknown as Registry);
-
-			const result = await registry.findOrCreateDomain(upperCaseDomain);
-
-			expect(db.create).toHaveBeenCalledWith('domain', {
-				id: 'dom_test',
-				name: upperCaseDomain,
-			});
-
-			expect(result.name).toBe(upperCaseDomain);
-		});
-	});
-});

package/src/db/registry/domain.ts

@@ -1,91 +0,0 @@
-import { HTTPException } from 'hono/http-exception';
-import { withDatabaseSpan } from '~/utils/instrumentation';
-import { getMetrics } from '~/utils/metrics';
-import type { Registry } from './types';
-import { generateUniqueId } from './utils/generate-id';
-
-export function domainRegistry({ db, ctx }: Registry) {
-	const { logger } = ctx;
-
-	const findDomainByName = async (name: string) => {
-		const start = Date.now();
-		try {
-			const result = await withDatabaseSpan(
-				{ operation: 'find', entity: 'domain' },
-				async () => {
-					const domain = await db.findFirst('domain', {
-						where: (b) => b('name', '=', name),
-					});
-
-					if (!domain) {
-						logger.debug('No domain found', { name });
-					}
-
-					return domain;
-				}
-			);
-			getMetrics()?.recordDbQuery(
-				{ operation: 'find', entity: 'domain' },
-				Date.now() - start
-			);
-			return result;
-		} catch (error) {
-			getMetrics()?.recordDbError({
-				operation: 'find',
-				entity: 'domain',
-			});
-			throw error;
-		}
-	};
-
-	return {
-		findDomainByName,
-		findOrCreateDomain: async (name: string) => {
-			const start = Date.now();
-			try {
-				const result = await withDatabaseSpan(
-					{ operation: 'findOrCreate', entity: 'domain' },
-					async () => {
-						const existingDomain = await db.findFirst('domain', {
-							where: (b) => b('name', '=', name),
-						});
-
-						if (existingDomain) {
-							logger.debug('Found existing domain', { name });
-							return existingDomain;
-						}
-
-						logger.debug('Creating new domain', { name });
-						const domain = await db.create('domain', {
-							id: await generateUniqueId(db, 'domain', ctx),
-							name,
-						});
-
-						if (!domain) {
-							throw new HTTPException(503, {
-								message: 'Failed to create domain',
-								cause: {
-									code: 'DOMAIN_CREATION_FAILED',
-									name,
-								},
-							});
-						}
-
-						return domain;
-					}
-				);
-				getMetrics()?.recordDbQuery(
-					{ operation: 'findOrCreate', entity: 'domain' },
-					Date.now() - start
-				);
-				return result;
-			} catch (error) {
-				getMetrics()?.recordDbError({
-					operation: 'findOrCreate',
-					entity: 'domain',
-				});
-				throw error;
-			}
-		},
-	};
-}

package/src/db/registry/index.ts

@@ -1,14 +0,0 @@
-import { policyRegistry } from './consent-policy';
-import { consentPurposeRegistry } from './consent-purpose';
-import { domainRegistry } from './domain';
-import { subjectRegistry } from './subject';
-import type { Registry } from './types';
-
-export const createRegistry = (ctx: Registry) => {
-	return {
-		...subjectRegistry(ctx),
-		...consentPurposeRegistry(ctx),
-		...policyRegistry(ctx),
-		...domainRegistry(ctx),
-	};
-};