@c15t/backend 1.8.0 → 2.0.0-rc.1

package/src/handlers/utils/consent-enrichment.test.ts

@@ -0,0 +1,380 @@
+import { describe, expect, it, vi } from 'vitest';
+import {
+	enrichConsents,
+	parsePurposeIds,
+	resolveConsentPolicies,
+} from './consent-enrichment';
+
+describe('consent-enrichment', () => {
+	// ── parsePurposeIds ─────────────────────────────────────────────────
+	describe('parsePurposeIds', () => {
+		it('extracts IDs from { json: [...] } wrapper', () => {
+			expect(parsePurposeIds({ json: ['a', 'b'] })).toEqual(['a', 'b']);
+		});
+
+		it('passes through raw string[]', () => {
+			expect(parsePurposeIds(['x', 'y'])).toEqual(['x', 'y']);
+		});
+
+		it('returns [] for null', () => {
+			expect(parsePurposeIds(null)).toEqual([]);
+		});
+
+		it('returns [] for undefined', () => {
+			expect(parsePurposeIds(undefined)).toEqual([]);
+		});
+
+		it('returns [] for empty array', () => {
+			expect(parsePurposeIds([])).toEqual([]);
+		});
+
+		it('returns [] for empty { json: [] }', () => {
+			expect(parsePurposeIds({ json: [] })).toEqual([]);
+		});
+
+		it('returns [] for non-array values', () => {
+			expect(parsePurposeIds('not-an-array')).toEqual([]);
+			expect(parsePurposeIds(42)).toEqual([]);
+		});
+	});
+
+	// ── enrichConsents ──────────────────────────────────────────────────
+	describe('enrichConsents', () => {
+		function createMockCtx(
+			policies: Array<{ id: string; type: string }> = [],
+			purposes: Array<{ id: string; code: string }> = [],
+			latestByType: Record<string, { id: string }> = {}
+		) {
+			const db = {
+				findMany: vi.fn((table: string, opts?: { where?: unknown }) => {
+					if (table === 'consentPolicy') return Promise.resolve(policies);
+					if (table === 'consentPurpose') return Promise.resolve(purposes);
+					return Promise.resolve([]);
+				}),
+			};
+
+			const registry = {
+				findOrCreatePolicy: vi.fn((type: string) =>
+					Promise.resolve(latestByType[type] ?? { id: `latest_${type}` })
+				),
+				findConsentPolicyById: vi.fn(),
+			};
+
+			return { db, registry } as unknown as Parameters<
+				typeof enrichConsents
+			>[1];
+		}
+
+		it('returns [] for empty consents', async () => {
+			const ctx = createMockCtx();
+			const result = await enrichConsents([], ctx);
+			expect(result).toEqual([]);
+			// No DB calls should be made
+			expect((ctx.db as any).findMany).not.toHaveBeenCalled();
+		});
+
+		it('enriches a single consent with policy and purposes', async () => {
+			const ctx = createMockCtx(
+				[{ id: 'pol_1', type: 'cookie_banner' }],
+				[
+					{ id: 'pur_1', code: 'analytics' },
+					{ id: 'pur_2', code: 'marketing' },
+				],
+				{ cookie_banner: { id: 'pol_1' } }
+			);
+
+			const result = await enrichConsents(
+				[
+					{
+						id: 'con_1',
+						policyId: 'pol_1',
+						purposeIds: ['pur_1', 'pur_2'],
+						givenAt: new Date('2024-01-01'),
+					},
+				],
+				ctx
+			);
+
+			expect(result).toHaveLength(1);
+			expect(result[0]).toEqual({
+				id: 'con_1',
+				type: 'cookie_banner',
+				policyId: 'pol_1',
+				isLatestPolicy: true,
+				preferences: { analytics: true, marketing: true },
+				givenAt: new Date('2024-01-01'),
+			});
+		});
+
+		it('uses batch findMany with "in" operator (not N individual calls)', async () => {
+			const policies = [
+				{ id: 'pol_1', type: 'cookie_banner' },
+				{ id: 'pol_2', type: 'privacy_policy' },
+			];
+			const purposes = [
+				{ id: 'pur_1', code: 'analytics' },
+				{ id: 'pur_2', code: 'marketing' },
+			];
+			const ctx = createMockCtx(policies, purposes, {
+				cookie_banner: { id: 'pol_1' },
+				privacy_policy: { id: 'pol_2' },
+			});
+
+			await enrichConsents(
+				[
+					{
+						id: 'c1',
+						policyId: 'pol_1',
+						purposeIds: ['pur_1'],
+						givenAt: new Date(),
+					},
+					{
+						id: 'c2',
+						policyId: 'pol_2',
+						purposeIds: ['pur_2'],
+						givenAt: new Date(),
+					},
+				],
+				ctx
+			);
+
+			const findManyCalls = (ctx.db as any).findMany.mock.calls;
+			// Exactly 2 findMany calls: one for policies, one for purposes
+			expect(findManyCalls).toHaveLength(2);
+			expect(findManyCalls[0][0]).toBe('consentPolicy');
+			expect(findManyCalls[1][0]).toBe('consentPurpose');
+		});
+
+		it('sets type = "unknown" and isLatestPolicy = false for null policyId', async () => {
+			const ctx = createMockCtx([], [{ id: 'pur_1', code: 'analytics' }]);
+
+			const result = await enrichConsents(
+				[
+					{
+						id: 'con_1',
+						policyId: null,
+						purposeIds: ['pur_1'],
+						givenAt: new Date('2024-01-01'),
+					},
+				],
+				ctx
+			);
+
+			expect(result[0]!.type).toBe('unknown');
+			expect(result[0]!.isLatestPolicy).toBe(false);
+			expect(result[0]!.policyId).toBeUndefined();
+		});
+
+		it('isLatestPolicy is false when consent has an older policy', async () => {
+			const ctx = createMockCtx(
+				[{ id: 'pol_old', type: 'cookie_banner' }],
+				[],
+				{ cookie_banner: { id: 'pol_new' } } // latest is different
+			);
+
+			const result = await enrichConsents(
+				[
+					{
+						id: 'con_1',
+						policyId: 'pol_old',
+						purposeIds: null,
+						givenAt: new Date(),
+					},
+				],
+				ctx
+			);
+
+			expect(result[0]!.isLatestPolicy).toBe(false);
+		});
+
+		it('handles { json: [...] } wrapper for purposeIds', async () => {
+			const ctx = createMockCtx(
+				[{ id: 'pol_1', type: 'cookie_banner' }],
+				[{ id: 'pur_1', code: 'analytics' }],
+				{ cookie_banner: { id: 'pol_1' } }
+			);
+
+			const result = await enrichConsents(
+				[
+					{
+						id: 'con_1',
+						policyId: 'pol_1',
+						purposeIds: { json: ['pur_1'] },
+						givenAt: new Date(),
+					},
+				],
+				ctx
+			);
+
+			expect(result[0]!.preferences).toEqual({ analytics: true });
+		});
+
+		it('skips purposes not found in DB', async () => {
+			const ctx = createMockCtx(
+				[{ id: 'pol_1', type: 'cookie_banner' }],
+				[{ id: 'pur_1', code: 'analytics' }], // pur_2 intentionally missing
+				{ cookie_banner: { id: 'pol_1' } }
+			);
+
+			const result = await enrichConsents(
+				[
+					{
+						id: 'con_1',
+						policyId: 'pol_1',
+						purposeIds: ['pur_1', 'pur_2_missing'],
+						givenAt: new Date(),
+					},
+				],
+				ctx
+			);
+
+			expect(result[0]!.preferences).toEqual({ analytics: true });
+		});
+
+		it('leaves preferences undefined when purposeIds is empty', async () => {
+			const ctx = createMockCtx([{ id: 'pol_1', type: 'cookie_banner' }], [], {
+				cookie_banner: { id: 'pol_1' },
+			});
+
+			const result = await enrichConsents(
+				[
+					{
+						id: 'con_1',
+						policyId: 'pol_1',
+						purposeIds: [],
+						givenAt: new Date(),
+					},
+				],
+				ctx
+			);
+
+			expect(result[0]!.preferences).toBeUndefined();
+		});
+
+		it('does not call findMany for policies when no consents have policyId', async () => {
+			const ctx = createMockCtx();
+
+			await enrichConsents(
+				[
+					{
+						id: 'con_1',
+						policyId: null,
+						purposeIds: null,
+						givenAt: new Date(),
+					},
+				],
+				ctx
+			);
+
+			const findManyCalls = (ctx.db as any).findMany.mock.calls;
+			// Should not call findMany for consentPolicy (empty policyIds set)
+			const policyCalls = findManyCalls.filter(
+				(c: unknown[]) => c[0] === 'consentPolicy'
+			);
+			expect(policyCalls).toHaveLength(0);
+		});
+	});
+
+	// ── resolveConsentPolicies ──────────────────────────────────────────
+	describe('resolveConsentPolicies', () => {
+		function createMockCtx(
+			policies: Array<{ id: string; type: string }> = [],
+			latestByType: Record<string, { id: string }> = {}
+		) {
+			const db = {
+				findMany: vi.fn(() => Promise.resolve(policies)),
+			};
+
+			const registry = {
+				findOrCreatePolicy: vi.fn((type: string) =>
+					Promise.resolve(latestByType[type] ?? { id: `latest_${type}` })
+				),
+				findConsentPolicyById: vi.fn(),
+			};
+
+			return { db, registry } as unknown as Parameters<
+				typeof resolveConsentPolicies
+			>[1];
+		}
+
+		it('returns [] for empty consents', async () => {
+			const ctx = createMockCtx();
+			const result = await resolveConsentPolicies([], ctx);
+			expect(result).toEqual([]);
+		});
+
+		it('returns correct policy info with isLatestPolicy', async () => {
+			const ctx = createMockCtx([{ id: 'pol_1', type: 'cookie_banner' }], {
+				cookie_banner: { id: 'pol_1' },
+			});
+
+			const result = await resolveConsentPolicies(
+				[{ id: 'con_1', policyId: 'pol_1' }],
+				ctx
+			);
+
+			expect(result).toEqual([
+				{
+					consentId: 'con_1',
+					policyType: 'cookie_banner',
+					policyId: 'pol_1',
+					isLatestPolicy: true,
+				},
+			]);
+		});
+
+		it('returns unknown type for null policyId', async () => {
+			const ctx = createMockCtx();
+
+			const result = await resolveConsentPolicies(
+				[{ id: 'con_1', policyId: null }],
+				ctx
+			);
+
+			expect(result[0]).toEqual({
+				consentId: 'con_1',
+				policyType: 'unknown',
+				policyId: undefined,
+				isLatestPolicy: false,
+			});
+		});
+
+		it('does not load purposes (no consentPurpose findMany call)', async () => {
+			const ctx = createMockCtx([{ id: 'pol_1', type: 'cookie_banner' }], {
+				cookie_banner: { id: 'pol_1' },
+			});
+
+			await resolveConsentPolicies([{ id: 'con_1', policyId: 'pol_1' }], ctx);
+
+			const findManyCalls = (ctx.db as any).findMany.mock.calls;
+			const purposeCalls = findManyCalls.filter(
+				(c: unknown[]) => c[0] === 'consentPurpose'
+			);
+			expect(purposeCalls).toHaveLength(0);
+		});
+
+		it('handles multiple consents with different policy types', async () => {
+			const ctx = createMockCtx(
+				[
+					{ id: 'pol_1', type: 'cookie_banner' },
+					{ id: 'pol_2', type: 'privacy_policy' },
+				],
+				{
+					cookie_banner: { id: 'pol_1' },
+					privacy_policy: { id: 'pol_latest' }, // different from pol_2
+				}
+			);
+
+			const result = await resolveConsentPolicies(
+				[
+					{ id: 'con_1', policyId: 'pol_1' },
+					{ id: 'con_2', policyId: 'pol_2' },
+				],
+				ctx
+			);
+
+			expect(result[0]!.isLatestPolicy).toBe(true);
+			expect(result[1]!.isLatestPolicy).toBe(false);
+		});
+	});
+});

package/src/handlers/utils/consent-enrichment.ts

@@ -0,0 +1,218 @@
+/**
+ * Shared consent enrichment utilities.
+ *
+ * Extracts duplicated consent-building logic from get/list/check handlers
+ * and batch-loads policies + purposes to eliminate N+1 queries.
+ *
+ * @packageDocumentation
+ */
+
+import type { PolicyType } from '~/db/schema';
+import type { C15TContext } from '~/types';
+
+type EnrichmentContext = Pick<C15TContext, 'db' | 'registry'>;
+
+export interface EnrichedConsentItem {
+	id: string;
+	type: string;
+	policyId: string | undefined;
+	isLatestPolicy: boolean;
+	preferences: Record<string, boolean> | undefined;
+	givenAt: Date;
+}
+
+export interface ConsentPolicyInfo {
+	consentId: string;
+	policyType: string;
+	policyId: string | undefined;
+	isLatestPolicy: boolean;
+}
+
+/**
+ * Parse purposeIds from DB — handles both `{ json: string[] }` wrapper
+ * (some adapters) and raw `string[]` format.
+ */
+export function parsePurposeIds(purposeIds: unknown): string[] {
+	if (purposeIds == null) return [];
+
+	const ids =
+		typeof purposeIds === 'object' && 'json' in (purposeIds as object)
+			? (purposeIds as { json: unknown }).json
+			: purposeIds;
+
+	return Array.isArray(ids) ? ids : [];
+}
+
+/**
+ * Batch-fetch all referenced policies and resolve the latest policy per type.
+ *
+ * 1 query for findMany('consentPolicy', { where: id IN ... })
+ * ≤7 calls for findOrCreatePolicy (one per unique PolicyType)
+ */
+async function batchLoadPolicies(
+	policyIds: Set<string>,
+	ctx: EnrichmentContext
+) {
+	const { db, registry } = ctx;
+
+	// Fetch all referenced policies in one query
+	const policyMap = new Map<
+		string,
+		{ id: string; type: string; [key: string]: unknown }
+	>();
+
+	if (policyIds.size > 0) {
+		const policies = await db.findMany('consentPolicy', {
+			where: (b) => b('id', 'in', [...policyIds]),
+		});
+		for (const p of policies) {
+			policyMap.set(p.id, p);
+		}
+	}
+
+	// Resolve the latest policy for each unique type
+	const uniqueTypes = new Set<string>();
+	for (const p of policyMap.values()) {
+		uniqueTypes.add(p.type);
+	}
+
+	const latestPolicyByType = new Map<string, string>();
+	for (const type of uniqueTypes) {
+		const latest = await registry.findOrCreatePolicy(type as PolicyType);
+		if (latest) {
+			latestPolicyByType.set(type, latest.id);
+		}
+	}
+
+	return { policyMap, latestPolicyByType };
+}
+
+/**
+ * Full consent enrichment for get/list handlers.
+ *
+ * Resolves policy types, isLatestPolicy, and purpose preferences
+ * using batch queries instead of per-consent lookups.
+ */
+export async function enrichConsents(
+	consents: Array<{
+		id: string;
+		policyId: string | null;
+		purposeIds: unknown;
+		givenAt: Date;
+	}>,
+	ctx: EnrichmentContext
+): Promise<EnrichedConsentItem[]> {
+	if (consents.length === 0) return [];
+
+	// Collect all policy IDs
+	const policyIds = new Set<string>();
+	for (const c of consents) {
+		if (c.policyId) policyIds.add(c.policyId);
+	}
+
+	const { policyMap, latestPolicyByType } = await batchLoadPolicies(
+		policyIds,
+		ctx
+	);
+
+	// Collect all purpose IDs across all consents
+	const allPurposeIds = new Set<string>();
+	for (const c of consents) {
+		for (const id of parsePurposeIds(c.purposeIds)) {
+			allPurposeIds.add(id);
+		}
+	}
+
+	// Batch-fetch all purposes in one query
+	const purposeMap = new Map<string, string>(); // id → code
+	if (allPurposeIds.size > 0) {
+		const purposes = await ctx.db.findMany('consentPurpose', {
+			where: (b) => b('id', 'in', [...allPurposeIds]),
+		});
+		for (const p of purposes) {
+			purposeMap.set(p.id, p.code);
+		}
+	}
+
+	// Map consents synchronously — zero additional queries
+	return consents.map((consent) => {
+		let policyType = 'unknown';
+		let isLatestPolicy = false;
+
+		if (consent.policyId) {
+			const policy = policyMap.get(consent.policyId);
+			if (policy) {
+				policyType = policy.type;
+				isLatestPolicy =
+					latestPolicyByType.get(policyType) === consent.policyId;
+			}
+		}
+
+		let preferences: Record<string, boolean> | undefined;
+		const ids = parsePurposeIds(consent.purposeIds);
+		if (ids.length > 0) {
+			preferences = {};
+			for (const purposeId of ids) {
+				const code = purposeMap.get(purposeId);
+				if (code) {
+					preferences[code] = true;
+				}
+			}
+		}
+
+		return {
+			id: consent.id,
+			type: policyType,
+			policyId: consent.policyId ?? undefined,
+			isLatestPolicy,
+			preferences,
+			givenAt: consent.givenAt,
+		};
+	});
+}
+
+/**
+ * Policy-only enrichment for check handler.
+ *
+ * Resolves policy type and isLatestPolicy without loading purposes.
+ */
+export async function resolveConsentPolicies(
+	consents: Array<{
+		id: string;
+		policyId: string | null;
+	}>,
+	ctx: EnrichmentContext
+): Promise<ConsentPolicyInfo[]> {
+	if (consents.length === 0) return [];
+
+	const policyIds = new Set<string>();
+	for (const c of consents) {
+		if (c.policyId) policyIds.add(c.policyId);
+	}
+
+	const { policyMap, latestPolicyByType } = await batchLoadPolicies(
+		policyIds,
+		ctx
+	);
+
+	return consents.map((consent) => {
+		let policyType = 'unknown';
+		let isLatestPolicy = false;
+
+		if (consent.policyId) {
+			const policy = policyMap.get(consent.policyId);
+			if (policy) {
+				policyType = policy.type;
+				isLatestPolicy =
+					latestPolicyByType.get(policyType) === consent.policyId;
+			}
+		}
+
+		return {
+			consentId: consent.id,
+			policyType,
+			policyId: consent.policyId ?? undefined,
+			isLatestPolicy,
+		};
+	});
+}

package/src/init.test.ts

@@ -0,0 +1,126 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { init } from './init';
+import type { C15TOptions } from './types';
+
+// Use vi.hoisted so these are available inside vi.mock factories (which are hoisted)
+const { mockLogger, mockClient, mockClientOrm } = vi.hoisted(() => {
+	const mockLogger = {
+		debug: vi.fn(),
+		info: vi.fn(),
+		warn: vi.fn(),
+		error: vi.fn(),
+		success: vi.fn(),
+	};
+
+	const mockClientOrm = vi.fn().mockReturnValue({});
+	const mockClient = vi.fn().mockReturnValue({
+		orm: mockClientOrm,
+	});
+
+	return { mockLogger, mockClient, mockClientOrm };
+});
+
+// Mock local modules
+vi.mock('./utils/logger', () => ({
+	initLogger: vi.fn(() => mockLogger),
+}));
+
+vi.mock('./utils/create-telemetry-options', () => ({
+	createTelemetryOptions: vi.fn((appName, config) => ({
+		enabled: config?.enabled ?? false,
+		tracer: config?.tracer,
+		meter: config?.meter,
+		defaultAttributes: {
+			'service.name': appName,
+			'service.version': '1.0.0',
+			...config?.defaultAttributes,
+		},
+	})),
+	isTelemetryEnabled: vi.fn(
+		(options) => options?.advanced?.telemetry?.enabled === true
+	),
+}));
+
+vi.mock('./db/registry', () => ({
+	createRegistry: vi.fn().mockReturnValue({}),
+}));
+
+vi.mock('./db/schema', () => ({
+	DB: {
+		client: mockClient,
+	},
+}));
+
+beforeEach(() => {
+	vi.clearAllMocks();
+});
+
+afterEach(() => {
+	vi.clearAllMocks();
+});
+
+function createOptions(overrides: Partial<C15TOptions> = {}): C15TOptions {
+	return {
+		trustedOrigins: [],
+		adapter: {} as C15TOptions['adapter'],
+		...overrides,
+	};
+}
+
+describe('init', () => {
+	it('uses "c15t" as default appName when none is provided', () => {
+		const options = createOptions();
+		const context = init(options);
+
+		expect(context.appName).toBe('c15t');
+		expect(mockClient).toHaveBeenCalledTimes(1);
+	});
+
+	it('uses the provided appName', () => {
+		const options = createOptions({ appName: 'MyAmazingApp' });
+		const context = init(options);
+
+		expect(context.appName).toBe('MyAmazingApp');
+	});
+
+	it('telemetry is disabled by default (opt-in)', () => {
+		const options = createOptions();
+		init(options);
+
+		// Check that logger was called with telemetry disabled message
+		expect(mockLogger.debug).toHaveBeenCalledWith(
+			'Telemetry is disabled (opt-in required)'
+		);
+	});
+
+	it('logs telemetry enabled when explicitly enabled', () => {
+		const options = createOptions({
+			advanced: {
+				telemetry: {
+					enabled: true,
+				},
+			},
+		});
+		init(options);
+
+		// Check that logger was called with telemetry enabled message
+		expect(mockLogger.debug).toHaveBeenCalledWith(
+			'Telemetry is enabled',
+			expect.objectContaining({
+				hasTracer: false,
+				hasMeter: false,
+			})
+		);
+	});
+
+	it('creates context with required properties', () => {
+		const options = createOptions();
+		const context = init(options);
+
+		expect(context).toHaveProperty('appName');
+		expect(context).toHaveProperty('logger');
+		expect(context).toHaveProperty('db');
+		expect(context).toHaveProperty('registry');
+		expect(context).toHaveProperty('trustedOrigins');
+	});
+});