@c15t/backend 1.8.0 → 2.0.0-rc.0

package/src/v2/handlers/consent/post.handler.ts

@@ -1,258 +0,0 @@
-import { ORPCError } from '@orpc/server';
-import { os } from '~/v2/contracts';
-import { generateUniqueId } from '~/v2/db/registry/utils';
-import type { C15TContext } from '~/v2/types';
-
-/**
- * Handles the creation of a new consent record.
- *
- * This handler processes consent submissions, creates necessary records in the database,
- * and returns a formatted response. It handles different types of consent (cookie banner,
- * policy-based, and other types) with their specific requirements.
- *
- * @throws {ORPCError} When:
- * - Subject creation fails
- * - Policy is not found or inactive
- * - Database transaction fails
- * - Required fields are missing
- *
- * @example
- * ```ts
- * // Cookie banner consent
- * const response = await postConsent({
- *   type: 'cookie_banner',
- *   domain: 'example.com',
- *   preferences: { analytics: true, marketing: false }
- * });
- * ```
- */
-
-export const postConsent = os.consent.post.handler(
-	async ({ input, context }) => {
-		const typedContext = context as C15TContext;
-		const logger = typedContext.logger;
-		logger.info('Handling post-consent request');
-
-		const { db, registry } = typedContext;
-
-		const {
-			type,
-			subjectId,
-			identityProvider,
-			externalSubjectId,
-			domain,
-			metadata,
-			preferences,
-		} = input;
-
-		logger.debug('Request parameters', {
-			type,
-			subjectId,
-			identityProvider,
-			externalSubjectId,
-			domain,
-		});
-
-		try {
-			const subject = await registry.findOrCreateSubject({
-				subjectId,
-				externalSubjectId,
-				identityProvider,
-				ipAddress: typedContext.ipAddress,
-			});
-
-			if (!subject) {
-				throw new ORPCError('SUBJECT_CREATION_FAILED', {
-					data: {
-						subjectId,
-						externalSubjectId,
-					},
-				});
-			}
-
-			logger.debug('Subject found/created', { subjectId: subject.id });
-			const domainRecord =
-				await typedContext.registry.findOrCreateDomain(domain);
-
-			if (!domainRecord) {
-				throw new ORPCError('DOMAIN_CREATION_FAILED', {
-					data: {
-						domain,
-					},
-				});
-			}
-
-			let policyId: string | undefined;
-			let purposeIds: string[] = [];
-
-			if ('policyId' in input && input.policyId) {
-				policyId = input.policyId;
-
-				// Verify the policy exists and is active
-				const policy =
-					await typedContext.registry.findConsentPolicyById(policyId);
-				if (!policy) {
-					throw new ORPCError('POLICY_NOT_FOUND', {
-						data: {
-							policyId,
-							type,
-						},
-					});
-				}
-				if (!policy.isActive) {
-					throw new ORPCError('POLICY_INACTIVE', {
-						data: {
-							policyId,
-							type,
-						},
-					});
-				}
-			} else {
-				const policy = await typedContext.registry.findOrCreatePolicy(type);
-				if (!policy) {
-					throw new ORPCError('POLICY_CREATION_FAILED', {
-						data: {
-							type,
-						},
-					});
-				}
-				policyId = policy.id;
-			}
-
-			// Handle purposes if they exist
-			if (preferences) {
-				const consentedPurposes = Object.entries(preferences)
-					.filter(([_, isConsented]) => isConsented)
-					.map(([purposeCode]) => purposeCode);
-
-				logger.debug('Consented purposes', { consentedPurposes });
-
-				// Batch fetch all existing purposes
-				const purposesRaw = await Promise.all(
-					consentedPurposes.map((purposeCode) =>
-						typedContext.registry.findOrCreateConsentPurposeByCode(purposeCode)
-					)
-				);
-
-				const purposes = purposesRaw.map((purpose) => purpose?.id);
-
-				logger.debug('Purposes: ', { purposes });
-
-				purposeIds = purposes;
-			}
-
-			const result = await db.transaction(async (tx) => {
-				logger.debug('Creating consent record', {
-					subjectId: subject.id,
-					domainId: domainRecord.id,
-					policyId,
-					purposeIds,
-				});
-
-				const consentRecord = await tx.create('consent', {
-					id: await generateUniqueId(tx, 'consent', typedContext),
-					subjectId: subject.id,
-					domainId: domainRecord.id,
-					policyId,
-					purposeIds: { json: purposeIds },
-					status: 'active',
-					isActive: true,
-					ipAddress: typedContext.ipAddress || null,
-					userAgent: typedContext.userAgent || null,
-				});
-
-				logger.debug('Created consent', {
-					consentRecord: consentRecord.id,
-				});
-				logger.debug('Creating consentRecord entry', {
-					subjectId: subject.id,
-					consentId: consentRecord.id,
-					actionType: 'consent_given',
-					details: metadata,
-				});
-
-				const record = await tx.create('consentRecord', {
-					id: await generateUniqueId(tx, 'consentRecord', typedContext),
-					subjectId: subject.id,
-					consentId: consentRecord.id,
-					actionType: 'consent_given',
-					details: metadata,
-				});
-
-				logger.debug('Created record entry', {
-					record: record.id,
-				});
-				logger.debug('Creating audit log', {
-					subjectId: subject.id,
-					entityType: 'consent',
-					entityId: consentRecord.id,
-					actionType: 'consent_given',
-					metadata: metadata,
-				});
-
-				await tx.create('auditLog', {
-					id: await generateUniqueId(tx, 'auditLog', typedContext),
-					subjectId: subject.id,
-					entityType: 'consent',
-					entityId: consentRecord.id,
-					actionType: 'consent_given',
-					metadata: {
-						consentId: consentRecord.id,
-						type,
-					},
-					ipAddress: typedContext.ipAddress || null,
-					userAgent: typedContext.userAgent || null,
-					eventTimezone: 'UTC',
-				});
-
-				logger.debug('Created audit log');
-
-				if (!consentRecord || !record) {
-					throw new ORPCError('CONSENT_CREATION_FAILED', {
-						data: {
-							subjectId: subject.id,
-							domain,
-						},
-					});
-				}
-
-				return {
-					consent: consentRecord,
-					record,
-				};
-			});
-
-			// Return the response in the format defined by the contract
-			return {
-				id: result.consent.id,
-				subjectId: subject.id,
-				externalSubjectId: subject.externalId ?? undefined,
-				identityProvider: subject.identityProvider ?? undefined,
-				domainId: domainRecord.id,
-				domain: domainRecord.name,
-				type,
-				status: result.consent.status,
-				recordId: result.record.id,
-				metadata,
-				givenAt: result.consent.givenAt,
-			};
-		} catch (error) {
-			// Log all errors properly
-			logger.error('Error in post-consent handler', {
-				error: error instanceof Error ? error.message : String(error),
-				errorType:
-					error instanceof Error ? error.constructor.name : typeof error,
-			});
-
-			// Re-throw ORPCError instances
-			if (error instanceof ORPCError) {
-				throw error;
-			}
-
-			// Convert other errors to internal server error
-			throw new ORPCError('INTERNAL_SERVER_ERROR', {
-				message: error instanceof Error ? error.message : String(error),
-			});
-		}
-	}
-);

package/src/v2/handlers/consent/show-banner/geo.test.ts

@@ -1,281 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { JurisdictionMessages } from '~/v2/contracts/shared/jurisdiction.schema';
-import { checkJurisdiction } from './geo';
-
-describe('checkJurisdiction', () => {
-	describe('GDPR jurisdiction (EU countries)', () => {
-		const euCountries = [
-			'AT',
-			'BE',
-			'BG',
-			'HR',
-			'CY',
-			'CZ',
-			'DK',
-			'EE',
-			'FI',
-			'FR',
-			'DE',
-			'GR',
-			'HU',
-			'IE',
-			'IT',
-			'LV',
-			'LT',
-			'LU',
-			'MT',
-			'NL',
-			'PL',
-			'PT',
-			'RO',
-			'SK',
-			'SI',
-			'ES',
-			'SE',
-		];
-
-		it.each(euCountries)(
-			'should identify %s as GDPR jurisdiction',
-			(countryCode) => {
-				const result = checkJurisdiction(countryCode);
-
-				expect(result.showConsentBanner).toBe(true);
-				expect(result.jurisdictionCode).toBe('GDPR');
-				expect(result.message).toBe(JurisdictionMessages.GDPR);
-			}
-		);
-	});
-
-	describe('GDPR jurisdiction (EEA countries)', () => {
-		const eeaCountries = ['IS', 'NO', 'LI'];
-
-		it.each(eeaCountries)(
-			'should identify %s as GDPR jurisdiction',
-			(countryCode) => {
-				const result = checkJurisdiction(countryCode);
-
-				expect(result.showConsentBanner).toBe(true);
-				expect(result.jurisdictionCode).toBe('GDPR');
-				expect(result.message).toBe(JurisdictionMessages.GDPR);
-			}
-		);
-	});
-
-	describe('GDPR jurisdiction (UK)', () => {
-		it('should identify GB as GDPR jurisdiction', () => {
-			const result = checkJurisdiction('GB');
-
-			expect(result.showConsentBanner).toBe(true);
-			expect(result.jurisdictionCode).toBe('GDPR');
-			expect(result.message).toBe(JurisdictionMessages.GDPR);
-		});
-	});
-
-	describe('Other specific jurisdictions', () => {
-		const jurisdictionCases = [
-			{ country: 'CH', code: 'CH', message: JurisdictionMessages.CH },
-			{ country: 'BR', code: 'BR', message: JurisdictionMessages.BR },
-			{ country: 'CA', code: 'PIPEDA', message: JurisdictionMessages.PIPEDA },
-			{ country: 'AU', code: 'AU', message: JurisdictionMessages.AU },
-			{ country: 'JP', code: 'APPI', message: JurisdictionMessages.APPI },
-			{ country: 'KR', code: 'PIPA', message: JurisdictionMessages.PIPA },
-		] as const;
-
-		it.each(jurisdictionCases)(
-			'should identify $country as $code jurisdiction',
-			({ country, code, message }) => {
-				const result = checkJurisdiction(country);
-
-				expect(result.showConsentBanner).toBe(true);
-				expect(result.jurisdictionCode).toBe(code);
-				expect(result.message).toBe(message);
-			}
-		);
-	});
-
-	describe('Non-regulated countries', () => {
-		const nonRegulatedCountries = [
-			'US', // United States
-			'RU', // Russia
-			'CN', // China
-			'IN', // India
-			'MX', // Mexico
-			'AR', // Argentina
-			'EG', // Egypt
-			'ZA', // South Africa
-			'TH', // Thailand
-			'PH', // Philippines
-		];
-
-		it.each(nonRegulatedCountries)(
-			'should identify %s as non-regulated (NONE jurisdiction)',
-			(countryCode) => {
-				const result = checkJurisdiction(countryCode);
-
-				expect(result.showConsentBanner).toBe(false);
-				expect(result.jurisdictionCode).toBe('NONE');
-				expect(result.message).toBe(JurisdictionMessages.NONE);
-			}
-		);
-	});
-
-	describe('Edge cases', () => {
-		it('should handle null country code by defaulting to show banner with NONE jurisdiction', () => {
-			const result = checkJurisdiction(null);
-
-			expect(result.showConsentBanner).toBe(true);
-			expect(result.jurisdictionCode).toBe('NONE');
-			expect(result.message).toBe(JurisdictionMessages.NONE);
-		});
-
-		it('should handle empty string country code by defaulting to show banner with NONE jurisdiction', () => {
-			const result = checkJurisdiction('');
-
-			expect(result.showConsentBanner).toBe(true);
-			expect(result.jurisdictionCode).toBe('NONE');
-			expect(result.message).toBe(JurisdictionMessages.NONE);
-		});
-
-		it('should handle lowercase country codes correctly', () => {
-			const result = checkJurisdiction('de');
-
-			// Should now match because we normalize to uppercase
-			expect(result.showConsentBanner).toBe(true);
-			expect(result.jurisdictionCode).toBe('GDPR');
-			expect(result.message).toBe(JurisdictionMessages.GDPR);
-		});
-
-		it('should handle mixed case country codes across different jurisdictions', () => {
-			const testCases = [
-				{ input: 'de', expectedJurisdiction: 'GDPR' },
-				{ input: 'De', expectedJurisdiction: 'GDPR' },
-				{ input: 'DE', expectedJurisdiction: 'GDPR' },
-				{ input: 'ch', expectedJurisdiction: 'CH' },
-				{ input: 'Ch', expectedJurisdiction: 'CH' },
-				{ input: 'CH', expectedJurisdiction: 'CH' },
-				{ input: 'ca', expectedJurisdiction: 'PIPEDA' },
-				{ input: 'Ca', expectedJurisdiction: 'PIPEDA' },
-				{ input: 'CA', expectedJurisdiction: 'PIPEDA' },
-			] as const;
-
-			for (const { input, expectedJurisdiction } of testCases) {
-				const result = checkJurisdiction(input);
-
-				expect(result.showConsentBanner).toBe(true);
-				expect(result.jurisdictionCode).toBe(expectedJurisdiction);
-				expect(result.message).toBe(JurisdictionMessages[expectedJurisdiction]);
-			}
-		});
-
-		it('should handle invalid country codes', () => {
-			const invalidCodes = ['XX', 'ZZ', '123', 'ABC'];
-
-			for (const code of invalidCodes) {
-				const result = checkJurisdiction(code);
-
-				expect(result.showConsentBanner).toBe(false);
-				expect(result.jurisdictionCode).toBe('NONE');
-				expect(result.message).toBe(JurisdictionMessages.NONE);
-			}
-		});
-	});
-
-	describe('Return value structure', () => {
-		it('should always return an object with required properties', () => {
-			const result = checkJurisdiction('DE');
-
-			expect(result).toEqual({
-				showConsentBanner: expect.any(Boolean),
-				jurisdictionCode: expect.any(String),
-				message: expect.any(String),
-			});
-
-			expect(result).toHaveProperty('showConsentBanner');
-			expect(result).toHaveProperty('jurisdictionCode');
-			expect(result).toHaveProperty('message');
-		});
-
-		it('should return consistent types regardless of input', () => {
-			const inputs = ['DE', 'US', 'GB', 'XX', '', null];
-
-			for (const input of inputs) {
-				const result = checkJurisdiction(input);
-
-				expect(typeof result.showConsentBanner).toBe('boolean');
-				expect(typeof result.jurisdictionCode).toBe('string');
-				expect(typeof result.message).toBe('string');
-			}
-		});
-	});
-
-	describe('Comprehensive jurisdiction mapping', () => {
-		it('should correctly map all supported jurisdictions', () => {
-			// Test one representative from each jurisdiction group
-			const testCases = [
-				{
-					input: 'DE',
-					expectedJurisdiction: 'GDPR' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'NO',
-					expectedJurisdiction: 'GDPR' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'GB',
-					expectedJurisdiction: 'GDPR' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'CH',
-					expectedJurisdiction: 'CH' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'BR',
-					expectedJurisdiction: 'BR' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'CA',
-					expectedJurisdiction: 'PIPEDA' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'AU',
-					expectedJurisdiction: 'AU' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'JP',
-					expectedJurisdiction: 'APPI' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'KR',
-					expectedJurisdiction: 'PIPA' as const,
-					expectedShow: true,
-				},
-				{
-					input: 'US',
-					expectedJurisdiction: 'NONE' as const,
-					expectedShow: false,
-				},
-				{
-					input: null,
-					expectedJurisdiction: 'NONE' as const,
-					expectedShow: true,
-				},
-			];
-
-			for (const { input, expectedJurisdiction, expectedShow } of testCases) {
-				const result = checkJurisdiction(input);
-
-				expect(result.showConsentBanner).toBe(expectedShow);
-				expect(result.jurisdictionCode).toBe(expectedJurisdiction);
-				expect(result.message).toBe(JurisdictionMessages[expectedJurisdiction]);
-			}
-		});
-	});
-});

package/src/v2/handlers/consent/show-banner/geo.ts

@@ -1,96 +0,0 @@
-import {
-	type JurisdictionCode,
-	JurisdictionMessages,
-} from '~/v2/contracts/shared/jurisdiction.schema';
-
-/**
- * Determines if a consent banner should be shown based on country code
- * and returns appropriate jurisdiction information
- */
-export function checkJurisdiction(countryCode: string | null) {
-	// Country code sets for different jurisdictions
-	const jurisdictions = {
-		EU: new Set([
-			'AT',
-			'BE',
-			'BG',
-			'HR',
-			'CY',
-			'CZ',
-			'DK',
-			'EE',
-			'FI',
-			'FR',
-			'DE',
-			'GR',
-			'HU',
-			'IE',
-			'IT',
-			'LV',
-			'LT',
-			'LU',
-			'MT',
-			'NL',
-			'PL',
-			'PT',
-			'RO',
-			'SK',
-			'SI',
-			'ES',
-			'SE',
-		]),
-		EEA: new Set(['IS', 'NO', 'LI']),
-		UK: new Set(['GB']),
-		CH: new Set(['CH']),
-		BR: new Set(['BR']),
-		CA: new Set(['CA']),
-		AU: new Set(['AU']),
-		JP: new Set(['JP']),
-		KR: new Set(['KR']),
-	};
-
-	// Default to no jurisdiction, but show banner
-	let showConsentBanner = true;
-	let jurisdictionCode: JurisdictionCode = 'NONE';
-
-	// Check country code against jurisdiction sets
-	if (countryCode) {
-		// Normalize country code to uppercase for case-insensitive comparison
-		const normalizedCountryCode = countryCode.toUpperCase();
-
-		// Default to false as we don't know if it fits any jurisdiction yet
-		showConsentBanner = false;
-
-		// Map jurisdiction sets to their respective codes
-		const jurisdictionMap = [
-			{
-				sets: [jurisdictions.EU, jurisdictions.EEA, jurisdictions.UK],
-				code: 'GDPR',
-			},
-			{ sets: [jurisdictions.CH], code: 'CH' },
-			{ sets: [jurisdictions.BR], code: 'BR' },
-			{ sets: [jurisdictions.CA], code: 'PIPEDA' },
-			{ sets: [jurisdictions.AU], code: 'AU' },
-			{ sets: [jurisdictions.JP], code: 'APPI' },
-			{ sets: [jurisdictions.KR], code: 'PIPA' },
-		] as const;
-
-		// Find matching jurisdiction
-		for (const { sets, code } of jurisdictionMap) {
-			if (sets.some((set) => set.has(normalizedCountryCode))) {
-				jurisdictionCode = code;
-				showConsentBanner = true;
-				break;
-			}
-		}
-	}
-
-	// Get corresponding message from shared schema
-	const message = JurisdictionMessages[jurisdictionCode];
-
-	return {
-		showConsentBanner,
-		jurisdictionCode,
-		message,
-	};
-}