@c15t/backend 1.0.0 → 1.1.0-canary.0

package/src/handlers/consent/verify.handler.ts

@@ -0,0 +1,305 @@
+import { ORPCError } from '@orpc/server';
+import type { z } from 'zod';
+import { os } from '~/contracts';
+import type { Consent as DBConsent } from '~/schema/consent';
+import type { PolicyTypeSchema } from '~/schema/consent-policy';
+import type { C15TContext } from '~/types';
+
+/**
+ * Type representing a consent record with required fields
+ */
+interface Consent {
+	id: string;
+	purposeIds: string[];
+	[key: string]: unknown;
+}
+
+/**
+ * Input type for verifying consent
+ */
+type VerifyConsentInput = {
+	subjectId?: string;
+	externalSubjectId?: string;
+	domain: string;
+	type: z.infer<typeof PolicyTypeSchema>;
+	policyId?: string;
+	preferences?: string[];
+};
+
+/**
+ * Response type for consent verification
+ */
+type VerifyConsentOutput = {
+	isValid: boolean;
+	reasons?: string[];
+	consent?: Consent;
+};
+
+/**
+ * Parameters for checking policy consent
+ */
+interface PolicyConsentCheckParams {
+	policyId: string;
+	subjectId: string;
+	domainId: string;
+	purposeIds?: string[];
+	type: z.infer<typeof PolicyTypeSchema>;
+	context: C15TContext;
+}
+
+/**
+ * Handles verification of consent records.
+ *
+ * This handler checks if a subject has given valid consent for a specific policy
+ * and domain, optionally verifying specific purpose preferences.
+ *
+ * @throws {DoubleTieError} When:
+ * - Subject creation fails
+ * - Domain is not found
+ * - Policy is not found or invalid
+ * - Database query fails
+ *
+ * @example
+ * ```ts
+ * // Verify cookie banner consent
+ * const response = await verifyConsent({
+ *   type: 'cookie_banner',
+ *   domain: 'example.com',
+ *   preferences: ['analytics', 'marketing']
+ * });
+ * ```
+ */
+export const verifyConsent = os.consent.verify.handler(
+	async ({ input, context }) => {
+		const typedContext = context as C15TContext;
+		const logger = typedContext.logger;
+		logger.info('Handling verify-consent request');
+
+		const {
+			type,
+			subjectId,
+			externalSubjectId,
+			domain,
+			policyId,
+			preferences,
+		} = input as VerifyConsentInput;
+
+		logger.debug('Request parameters', {
+			type,
+			subjectId,
+			externalSubjectId,
+			domain,
+			policyId,
+			preferences,
+		});
+
+		try {
+			// Find subject
+			const subject = await typedContext.registry.findOrCreateSubject({
+				subjectId,
+				externalSubjectId,
+				ipAddress: typedContext.ipAddress || 'unknown',
+			});
+
+			if (!subject) {
+				throw new ORPCError('SUBJECT_NOT_FOUND', {
+					data: {
+						subjectId,
+						externalSubjectId,
+					},
+				});
+			}
+
+			// Find domain
+			const domainRecord = await typedContext.registry.findDomain(domain);
+			if (!domainRecord) {
+				throw new ORPCError('DOMAIN_NOT_FOUND', {
+					data: {
+						domain,
+					},
+				});
+			}
+
+			// Validate preferences for cookie banner
+			if (
+				type === 'cookie_banner' &&
+				(!preferences || preferences.length === 0)
+			) {
+				throw new ORPCError('COOKIE_BANNER_PREFERENCES_REQUIRED', {
+					data: {
+						type: 'cookie_banner',
+					},
+				});
+			}
+
+			// Find purpose IDs if preferences are provided
+			const purposePromises = preferences?.map((purpose: string) =>
+				typedContext.registry.findConsentPurposeByCode(purpose)
+			);
+
+			const rawPurposes = await Promise.all(purposePromises ?? []);
+			const purposeIds = rawPurposes
+				.filter(
+					(purpose): purpose is NonNullable<typeof purpose> => purpose !== null
+				)
+				.map((purpose) => purpose.id);
+
+			if (purposeIds.length !== (preferences?.length ?? 0)) {
+				throw new ORPCError('PURPOSES_NOT_FOUND', {
+					data: {
+						preferences: preferences ?? [],
+						foundPurposes: rawPurposes
+							.filter((p): p is NonNullable<typeof p> => p !== null)
+							.map((p) => p.code),
+					},
+				});
+			}
+
+			// Check policy consent
+			if (policyId) {
+				const policy =
+					await typedContext.registry.findConsentPolicyById(policyId);
+				if (!policy || policy.type !== type) {
+					throw new ORPCError('POLICY_NOT_FOUND', {
+						data: {
+							policyId,
+							type,
+						},
+					});
+				}
+
+				return await checkPolicyConsent({
+					policyId: policy.id,
+					subjectId: subject.id,
+					domainId: domainRecord.id,
+					purposeIds,
+					type,
+					context: typedContext,
+				});
+			}
+
+			// Check latest policy consent
+			const latestPolicy = await typedContext.registry.findOrCreatePolicy(type);
+			if (!latestPolicy) {
+				throw new ORPCError('POLICY_NOT_FOUND', {
+					data: {
+						policyId: 'latest',
+						type,
+					},
+				});
+			}
+
+			return await checkPolicyConsent({
+				policyId: latestPolicy.id,
+				subjectId: subject.id,
+				domainId: domainRecord.id,
+				purposeIds,
+				type,
+				context: typedContext,
+			});
+		} catch (error) {
+			logger.error('Error in verify-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),
+			});
+		}
+	}
+);
+
+/**
+ * Checks if consent has been given for a specific policy.
+ *
+ * @param params - Parameters for checking policy consent
+ * @returns Verification result with consent details if valid
+ *
+ * @throws {DoubleTieError} When database operations fail
+ */
+async function checkPolicyConsent({
+	policyId,
+	subjectId,
+	domainId,
+	purposeIds,
+	type,
+	context,
+}: PolicyConsentCheckParams): Promise<VerifyConsentOutput> {
+	const { registry, adapter } = context;
+
+	// Find all consents for the policy
+	const rawConsents = (await adapter.findMany({
+		model: 'consent',
+		where: [
+			{ field: 'subjectId', value: subjectId },
+			{ field: 'policyId', value: policyId },
+			{ field: 'domainId', value: domainId },
+		],
+		sortBy: {
+			field: 'givenAt',
+			direction: 'desc',
+		},
+	})) as unknown as DBConsent[];
+
+	// Filter consents by purpose IDs if provided
+	const filteredConsents = rawConsents.filter((consent) => {
+		if (!purposeIds) {
+			return true;
+		}
+		return purposeIds.every((id) =>
+			(consent.purposeIds as string[]).some((purposeId) => purposeId === id)
+		);
+	});
+
+	// Create audit log
+	await registry.createAuditLog({
+		subjectId,
+		entityType: 'consent_policy',
+		entityId: policyId,
+		actionType: 'verify_consent',
+		metadata: {
+			type,
+			policyId,
+			purposeIds,
+			success: filteredConsents.length !== 0,
+			...(filteredConsents.length > 0
+				? {
+						consentId: filteredConsents[0]?.id,
+					}
+				: {}),
+		},
+	});
+
+	if (rawConsents.length === 0) {
+		throw new ORPCError('NO_CONSENT_FOUND', {
+			data: {
+				policyId,
+				subjectId,
+				domainId,
+			},
+		});
+	}
+
+	if (filteredConsents.length === 0) {
+		throw new ORPCError('NO_CONSENT_FOUND', {
+			data: {
+				policyId,
+				subjectId,
+				domainId,
+			},
+		});
+	}
+
+	return {
+		isValid: true,
+		consent: filteredConsents[0],
+	};
+}

package/src/handlers/meta/index.ts

@@ -0,0 +1,5 @@
+import { statusHandler } from './status.handler';
+
+export const metaHandlers = {
+	status: statusHandler,
+};

package/src/handlers/meta/status.handler.ts

@@ -0,0 +1,47 @@
+import { os } from '~/contracts';
+import type { C15TContext } from '~/types';
+import { version } from '../../../package.json';
+
+// Use os.meta.status.handler to connect to the contract
+export const statusHandler = os.meta.status.handler(({ context }) => {
+	const typedContext = context as C15TContext;
+
+	// Extract country and region from request headers
+	const headers = typedContext.headers;
+	const normalizeHeader = (
+		value: string | string[] | null | undefined
+	): string | null => {
+		if (!value) {
+			return null;
+		}
+		return Array.isArray(value) ? (value[0] ?? null) : value;
+	};
+
+	const countryCode =
+		normalizeHeader(headers?.get('cf-ipcountry')) ??
+		normalizeHeader(headers?.get('x-vercel-ip-country')) ??
+		normalizeHeader(headers?.get('x-amz-cf-ipcountry')) ??
+		normalizeHeader(headers?.get('x-country-code'));
+
+	const regionCode =
+		normalizeHeader(headers?.get('x-vercel-ip-country-region')) ??
+		normalizeHeader(headers?.get('x-region-code'));
+
+	return {
+		status: 'ok' as const,
+		version,
+		timestamp: new Date(),
+		storage: {
+			type: typedContext.adapter?.id ?? 'MemoryAdapter',
+			available: !!typedContext.adapter,
+		},
+		client: {
+			ip: typedContext.ipAddress ?? null,
+			userAgent: typedContext.userAgent ?? null,
+			region: {
+				countryCode,
+				regionCode,
+			},
+		},
+	};
+});

package/src/init.ts

@@ -4,10 +4,10 @@ import { ConsoleSpanExporter } from '@opentelemetry/sdk-trace-base';
 import { defu } from 'defu';
 import type { DatabaseHook } from '~/pkgs/data-model';
 import { getAdapter } from '~/pkgs/db-adapters';
-import { createLogger } from '~/pkgs/logger';
 import type { RegistryContext } from '~/pkgs/types';
-import { env, getBaseURL, isProduction } from '~/pkgs/utils';
+import { getBaseURL } from '~/pkgs/utils';
 import type { C15TContext, C15TOptions, C15TPlugin } from '~/types';
+import { version } from '../package.json';
 import { generateId } from './pkgs/data-model/fields/id-generator';
 import type { EntityName } from './pkgs/data-model/schema/types';
 import {
@@ -22,6 +22,7 @@ import {
 } from './pkgs/results';
 
 import type { DoubleTieOptions } from './pkgs/types/options';
+import { getLogger, initLogger } from './pkgs/utils/logger';
 import { createRegistry } from './schema/create-registry';
 import { getConsentTables } from './schema/definition';
 
@@ -41,12 +42,6 @@ import { getConsentTables } from './schema/definition';
  * This is an internal module typically not used directly by consumers of the c15t library.
  */
 
-/**
- * Default secret used when no secret is provided
- * This should only be used in development environments
- */
-const DEFAULT_SECRET = 'c15t-default-secret-please-change-in-production';
-
 // SDK instance should be at module level for proper lifecycle management
 let telemetrySdk: NodeSDK | undefined;
 
@@ -66,7 +61,6 @@ let telemetrySdk: NodeSDK | undefined;
  * @example
  * ```typescript
  * const contextResult = await init({
- *   secret: process.env.CONSENT_SECRET,
  *   storage: memoryAdapter(),
  *   plugins: [geoPlugin()]
  * });
@@ -95,7 +89,8 @@ export const init = async <P extends C15TPlugin[]>(
 		const appName = options.appName || 'c15t';
 
 		// Create a single logger instance early in the initialization process
-		const logger = createLogger({
+		// Initialize the global logger for use throughout the application
+		const logger = initLogger({
 			...loggerOptions,
 			appName: String(appName),
 		});
@@ -120,7 +115,7 @@ export const init = async <P extends C15TPlugin[]>(
 				// Create a telemetry resource with provided values or safe defaults
 				const resource = new Resource({
 					'service.name': String(appName),
-					'service.version': String(process.env.npm_package_version || '1.0.0'),
+					'service.version': String(version || '1.0.0'),
 					...(telemetryOptions?.defaultAttributes || {}),
 				});
 				logger.debug('Initializing telemetry with resource attributes', {
@@ -187,23 +182,10 @@ export const init = async <P extends C15TPlugin[]>(
 
 		return adapterResult.andThen((adapter) => {
 			const resolvedBaseURL = getBaseURL(baseUrlStr, basePathStr);
-			const secret =
-				(options.secret as string) ||
-				env.C15T_SECRET ||
-				env.CONSENT_SECRET ||
-				DEFAULT_SECRET;
-
-			// Secret warning
-			if (secret === DEFAULT_SECRET && isProduction) {
-				logger.error(
-					'Using default secret in production. Set C15T_SECRET or pass secret in config.'
-				);
-			}
 
 			// Create normalized options directly with h3 patterns but no version field
 			const finalOptions: DoubleTieOptions = {
 				...options,
-				secret,
 				baseURL: resolvedBaseURL ? new URL(resolvedBaseURL).origin : '',
 				basePath: basePathStr || '/api/c15t',
 				plugins: [...(options.plugins || []), ...getInternalPlugins(options)],
@@ -236,7 +218,6 @@ export const init = async <P extends C15TPlugin[]>(
 				options: finalOptions,
 				trustedOrigins: options.trustedOrigins || [],
 				baseURL: resolvedBaseURL || '',
-				secret,
 				logger,
 				generateId: generateIdFunc,
 				adapter,
@@ -248,7 +229,8 @@ export const init = async <P extends C15TPlugin[]>(
 			return runPluginInit(ctx);
 		});
 	} catch (error) {
-		const errorLogger = createLogger(options.logger);
+		// Use getLogger here since we might be in an error case before logger initialization
+		const errorLogger = getLogger(options.logger);
 		errorLogger.error('Initialization failed', {
 			error: error instanceof Error ? error.message : String(error),
 			stack: error instanceof Error ? error.stack : undefined,

package/src/pkgs/api-router/hooks/__tests__/processor.test.ts

@@ -41,18 +41,21 @@ describe('Hook Processor Module', () => {
 
 			const hooks: Hook[] = [
 				{
+					//@ts-expect-error
 					matcher: (ctx: HookEndpointContext) => ctx.path === '/test',
 					handler: vi.fn().mockResolvedValue({
 						context: { testKey1: 'value1' },
 					}),
 				},
 				{
+					//@ts-expect-error
 					matcher: (ctx: HookEndpointContext) => ctx.method === 'GET',
 					handler: vi.fn().mockResolvedValue({
 						context: { testKey2: 'value2' },
 					}),
 				},
 				{
+					//@ts-expect-error
 					matcher: (ctx: HookEndpointContext) => ctx.path === '/other',
 					handler: vi.fn().mockResolvedValue({
 						context: { shouldNotInclude: true },
@@ -182,16 +185,19 @@ describe('Hook Processor Module', () => {
 
 			const hooks: Hook[] = [
 				{
+					//@ts-expect-error
 					matcher: (ctx: HookEndpointContext) => ctx.path === '/test',
 					handler: vi.fn().mockResolvedValue({
 						response: modifiedResponse,
 					}),
 				},
 				{
+					//@ts-expect-error
 					matcher: (ctx: HookEndpointContext) => ctx.method === 'GET',
 					handler: vi.fn().mockResolvedValue({}),
 				},
 				{
+					//@ts-expect-error
 					matcher: (ctx: HookEndpointContext) => ctx.path === '/other',
 					handler: vi.fn().mockResolvedValue({
 						response: { shouldNotUse: true },

package/src/pkgs/api-router/hooks/processor.ts

@@ -49,6 +49,7 @@ export async function runBeforeHooks(
 	} = {};
 	for (const hook of hooks) {
 		if (hook.matcher(context)) {
+			//@ts-expect-error
 			const result = await hook.handler(context, async () => Promise.resolve());
 			if (result && typeof result === 'object') {
 				if ('context' in result && typeof result.context === 'object') {
@@ -123,6 +124,7 @@ export async function runAfterHooks(
 	let response: unknown = null;
 	for (const hook of hooks) {
 		if (hook.matcher(context)) {
+			//@ts-expect-error
 			const result = await hook.handler(context, async () => Promise.resolve());
 			if (
 				result &&

package/src/pkgs/api-router/types/router-props.ts

@@ -1,5 +1,5 @@
+import type { Logger } from '@doubletie/logger';
 import type { Adapter } from '~/pkgs/db-adapters/types';
-import type { Logger } from '~/pkgs/logger';
 import type { createRegistry } from '~/schema/create-registry';
 import type { DoubleTieOptions } from '../../types/options';
 

package/src/pkgs/api-router/utils/cors.ts

@@ -1,4 +1,4 @@
-import type { Logger } from '~/pkgs/logger';
+import type { Logger } from '@doubletie/logger';
 
 /**
  * Regex to strip protocol, trailing slashes, and port numbers from URLs

package/src/pkgs/data-model/fields/field-types.ts

@@ -1,5 +1,5 @@
 /**
- * The set of field types supported by C15T.
+ * The set of field types supported by c15t.
  * Specifies the data types that can be used for database fields.
  *
  * @remarks

package/src/pkgs/data-model/fields/id-generator.ts

@@ -1,5 +1,5 @@
 /**
- * Custom ID generation system for C15T entities
+ * Custom ID generation system for c15t entities
  *
  * Provides prefixed, time-ordered, unique identifiers for all system entities.
  * Each entity type has a specific prefix to make IDs self-descriptive about

package/src/pkgs/db-adapters/README.md

@@ -18,7 +18,7 @@ import type { C15TOptions } from '~/types';
 // Create an empty in-memory database
 const db = {};
 
-// Configure the adapter in your C15T options
+// Configure the adapter in your c15t options
 const options: C15TOptions = {
   // ...other options
   storage: memoryAdapter(db)
@@ -46,7 +46,7 @@ const db = new Kysely({
   dialect: new PostgresDialect({ pool })
 });
 
-// Configure the adapter in your C15T options
+// Configure the adapter in your c15t options
 const options: C15TOptions = {
   // ...other options
   storage: kyselyAdapter(db, { type: 'postgres' })
@@ -61,7 +61,7 @@ The package also provides a utility to automatically select the appropriate adap
 import { getAdapter } from '~/db/utils/adapter-factory';
 import type { C15TOptions } from '~/types';
 
-// Configure C15T with database options
+// Configure c15t with database options
 const options: C15TOptions = {
   // ...other options
   database: {

package/src/pkgs/db-adapters/adapter-factory.ts

@@ -1,5 +1,5 @@
-import { createLogger } from '~/pkgs/logger';
 import { DoubleTieError, ERROR_CODES } from '~/pkgs/results';
+import { getLogger } from '~/pkgs/utils/logger';
 import { getConsentTables } from '~/schema';
 import type { C15TOptions } from '~/types';
 import { kyselyAdapter } from './adapters/kysely-adapter';
@@ -7,14 +7,14 @@ import { createKyselyAdapter } from './adapters/kysely-adapter/dialect';
 import { memoryAdapter } from './adapters/memory-adapter';
 
 /**
- * Creates and configures the appropriate database adapter based on C15T options
+ * Creates and configures the appropriate database adapter based on c15t options
  *
  * This function handles several scenarios:
  * 1. No database configuration - creates an in-memory adapter (development only)
  * 2. Custom database function - uses the provided function to create an adapter
  * 3. Standard database config - creates a Kysely adapter with the specified database
  *
- * @param options - The C15T configuration options
+ * @param options - The c15t configuration options
  * @returns A configured database adapter instance
  * @throws {DoubleTieError} If the database adapter initialization fails
  *
@@ -25,7 +25,11 @@ import { memoryAdapter } from './adapters/memory-adapter';
  * ```
  */
 export async function getAdapter(options: C15TOptions) {
-	const logger = createLogger({ appName: 'c15t' });
+	// Use any provided logger options and fall back to the configured appName
+	const logger = getLogger({
+		appName: options.appName ?? 'c15t',
+		...options.logger,
+	});
 
 	// If no database is configured, use an in-memory adapter for development
 	if (!options.database) {