@c15t/backend 1.0.5 → 1.2.0-canary.0

package/src/schema/audit-log/table.ts

@@ -9,7 +9,7 @@ import { auditLogSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain audit log table customizations
+ * @param options - c15t configuration options that may contain audit log table customizations
  * @param auditLogFields - Additional fields from plugins to include in the audit log table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/consent/table.ts

@@ -8,7 +8,7 @@ import { consentSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain consent table customizations
+ * @param options - c15t configuration options that may contain consent table customizations
  * @param consentFields - Additional fields from plugins to include in the consent table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/consent-policy/table.ts

@@ -9,7 +9,7 @@ import { consentPolicySchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain policy table customizations
+ * @param options - c15t configuration options that may contain policy table customizations
  * @param policyFields - Additional fields from plugins to include in the policy table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/consent-purpose/table.ts

@@ -9,7 +9,7 @@ import { purposeSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain consentPurpose table customizations
+ * @param options - c15t configuration options that may contain consentPurpose table customizations
  * @param purposeFields - Additional fields from plugins to include in the consentPurpose table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/consent-record/table.ts

@@ -9,7 +9,7 @@ import { consentRecordSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain consent record table customizations
+ * @param options - c15t configuration options that may contain consent record table customizations
  * @param recordFields - Additional fields from plugins to include in the consent record table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/definition.ts

@@ -1,6 +1,6 @@
-import { ZodError } from 'node_modules/zod/lib/ZodError';
+import { logger } from '@doubletie/logger';
+import { ZodError } from 'zod';
 import type { Field, PluginSchema } from '~/pkgs/data-model';
-import { logger } from '~/pkgs/logger';
 import type { C15TOptions } from '~/types';
 import { getAuditLogTable } from './audit-log/table';
 import { getConsentPolicyTable } from './consent-policy/table';

package/src/schema/domain/table.ts

@@ -9,7 +9,7 @@ import { domainSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain domain table customizations
+ * @param options - c15t configuration options that may contain domain table customizations
  * @param domainFields - Additional fields from plugins to include in the domain table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/schema/subject/table.ts

@@ -9,7 +9,7 @@ import { subjectSchema } from './schema';
  * and any additional fields from plugins or configuration. The resulting schema is used
  * for database migrations, schema validation, and query building.
  *
- * @param options - C15T configuration options that may contain subject table customizations
+ * @param options - c15t configuration options that may contain subject table customizations
  * @param subjectFields - Additional fields from plugins to include in the subject table
  * @returns A complete table schema definition with fields, model name, and metadata
  *

package/src/server.ts

@@ -0,0 +1,130 @@
+import { createServer } from 'node:http';
+import { c15tInstance } from './core';
+import { DoubleTieError } from './pkgs/results';
+import { getLogger } from './pkgs/utils/logger';
+
+// Use the centralized logger
+const logger = getLogger({
+	level: 'info',
+	// appName: 'c15t-server'
+});
+
+// Create the c15t instance with our configuration
+const instance = c15tInstance({
+	advanced: {
+		cors: {
+			allowedOrigins: ['*'], // Allow all origins for development
+		},
+	},
+	// Add OpenAPI configuration
+	openapi: {
+		enabled: true, // Set to true to enable docs
+		// Additional OpenAPI options can be added here
+	},
+	// Add logger
+	logger: {
+		level: 'info',
+	},
+});
+
+// Create HTTP server
+const server = createServer(async (req, res) => {
+	// Convert Node.js request to Web Request
+	const url = new URL(req.url || '/', `http://${req.headers.host}`);
+	const headers = new Headers();
+
+	// Convert Node.js headers to Headers object
+	for (const [key, value] of Object.entries(req.headers)) {
+		if (value) {
+			headers.set(key, Array.isArray(value) ? value.join(', ') : value);
+		}
+	}
+
+	// Create a Request object compatible with oRPC
+	const request = new Request(url.toString(), {
+		method: req.method || 'GET',
+		headers,
+		// Handle request body for POST/PUT/PATCH requests
+		...(req.method !== 'GET' &&
+			req.method !== 'HEAD' && {
+				body: req,
+			}),
+	});
+
+	try {
+		// Use c15tInstance handler to process the request
+		// It will automatically handle OpenAPI spec and docs UI
+		const response = await instance.handler(request);
+
+		// Convert Web API Response to Node.js response
+		res.writeHead(
+			response.status,
+			response.statusText,
+			Object.fromEntries(response.headers.entries())
+		);
+
+		// Handle different response types
+		if (response.body) {
+			// Stream the response body
+			const reader = response.body.getReader();
+			const processChunk = async () => {
+				try {
+					const { done, value } = await reader.read();
+					if (done) {
+						res.end();
+						return;
+					}
+
+					// Check if response already ended
+					if (!res.writableEnded) {
+						const canContinue = res.write(value);
+						if (canContinue) {
+							processChunk();
+						} else {
+							// If the buffer is full, wait for the drain event
+							res.once('drain', processChunk);
+						}
+					}
+				} catch (err) {
+					logger.error('Error while streaming response:', err);
+					if (!res.writableEnded) {
+						res.end();
+					}
+				}
+			};
+			processChunk();
+		} else {
+			res.end();
+		}
+	} catch (error) {
+		logger.error('Error handling request:', error);
+
+		// Return a proper error response based on the error type
+		if (error instanceof DoubleTieError) {
+			res.writeHead(error.statusCode, { 'Content-Type': 'application/json' });
+			res.end(
+				JSON.stringify({
+					code: error.code,
+					message: error.message,
+					data: error.meta,
+				})
+			);
+		} else {
+			// Generic error handler
+			res.writeHead(500, { 'Content-Type': 'application/json' });
+			res.end(
+				JSON.stringify({
+					error: 'Internal Server Error',
+					message: error instanceof Error ? error.message : String(error),
+				})
+			);
+		}
+	}
+});
+
+// Start the server
+const PORT = process.env.PORT ? Number.parseInt(process.env.PORT, 10) : 3000;
+server.listen(PORT, () => {
+	logger.info(`c15t server is running at http://localhost:${PORT}`);
+	logger.info(`API documentation available at http://localhost:${PORT}/docs`);
+});

package/src/testing/contract-testing.ts

@@ -0,0 +1,437 @@
+import type { Schema as ORPCSchema } from '@orpc/contract';
+import { describe, expect, it } from 'vitest';
+import type { ZodIssue, z } from 'zod';
+
+/**
+ * Contract test utilities for creating reusable test patterns
+ * across multiple contracts
+ */
+
+type ContractTestHelpers = {
+	validateInput?: (
+		input: unknown
+	) => z.SafeParseReturnType<unknown, unknown> | undefined;
+	validateOutput: (
+		output: unknown
+	) => z.SafeParseReturnType<unknown, unknown> | undefined;
+	testInput: (testName: string, input: unknown, shouldBeValid: boolean) => void;
+	testOutput: (
+		testName: string,
+		output: unknown,
+		shouldBeValid: boolean
+	) => void;
+	testDiscriminatedUnion: (
+		discriminator: string,
+		validValues: string[]
+	) => void;
+	testRequiredFields: (schema: 'input' | 'output', fields: string[]) => void;
+};
+
+type ContractSchema = z.ZodType | ORPCSchema<unknown, unknown>;
+
+/**
+ * Creates a test suite for basic contract validation
+ * @param contractName Display name for the contract
+ * @param contract The contract to test
+ */
+export function createContractTests(
+	contractName: string,
+	contract: {
+		'~orpc'?: { inputSchema?: ContractSchema; outputSchema?: ContractSchema };
+	}
+): ContractTestHelpers {
+	const schemas = {
+		input: contract['~orpc']?.inputSchema,
+		output: contract['~orpc']?.outputSchema,
+	};
+
+	// Helper functions
+	const validateInput = (input: unknown) => {
+		const schema = schemas.input;
+		if (!schema) {
+			return undefined;
+		}
+
+		// Handle both Zod and oRPC schemas
+		if ('safeParse' in schema) {
+			return schema.safeParse(input);
+		}
+		// For oRPC schemas, we'll need to implement validation
+		// This is a placeholder - you may need to implement actual validation
+		return { success: true, data: input } as z.SafeParseReturnType<
+			unknown,
+			unknown
+		>;
+	};
+
+	const validateOutput = (output: unknown) => {
+		const schema = schemas.output;
+		if (!schema) {
+			return undefined;
+		}
+
+		// Handle both Zod and oRPC schemas
+		if ('safeParse' in schema) {
+			return schema.safeParse(output);
+		}
+		// For oRPC schemas, we'll need to implement validation
+		// This is a placeholder - you may need to implement actual validation
+		return { success: true, data: output } as z.SafeParseReturnType<
+			unknown,
+			unknown
+		>;
+	};
+
+	// Create base test suite
+	describe(`${contractName} Contract`, () => {
+		describe('Schema Structure', () => {
+			it('has properly defined schemas', () => {
+				// Only require output schema
+				expect(schemas.output).toBeDefined();
+
+				// Input schema is optional
+				if (schemas.input) {
+					expect(schemas.input).toBeDefined();
+				}
+			});
+
+			it('schemas are serializable', () => {
+				// Test serialization for output schema
+				if (schemas.output) {
+					const serialized = JSON.stringify(schemas.output);
+					expect(serialized).toBeDefined();
+					expect(typeof serialized).toBe('string');
+					expect(() => JSON.parse(serialized)).not.toThrow();
+				}
+
+				// Test serialization for input schema if it exists
+				if (schemas.input) {
+					const serialized = JSON.stringify(schemas.input);
+					expect(serialized).toBeDefined();
+					expect(typeof serialized).toBe('string');
+					expect(() => JSON.parse(serialized)).not.toThrow();
+				}
+			});
+		});
+	});
+
+	// Define test helpers
+	const testInput = (
+		testName: string,
+		input: unknown,
+		shouldBeValid: boolean
+	) => {
+		it(`${testName}`, () => {
+			const result = validateInput(input);
+			if (!result) {
+				throw new Error('Validation result is undefined');
+			}
+			expect(result.success).toBe(shouldBeValid);
+		});
+	};
+
+	const testOutput = (
+		testName: string,
+		output: unknown,
+		shouldBeValid: boolean
+	) => {
+		it(`${testName}`, () => {
+			const result = validateOutput(output);
+			if (!result) {
+				throw new Error('Validation result is undefined');
+			}
+			expect(result.success).toBe(shouldBeValid);
+		});
+	};
+
+	const testDiscriminatedUnion = (
+		discriminator: string,
+		validValues: string[]
+	) => {
+		describe('Discriminated Union validation', () => {
+			it(`uses '${discriminator}' as discriminator`, () => {
+				if (!schemas.input) {
+					return;
+				}
+				// Only check Zod schemas for discriminated unions
+				if ('_def' in schemas.input) {
+					const schema = schemas.input as z.ZodDiscriminatedUnion<
+						string,
+						z.ZodObject<z.ZodRawShape>[]
+					>;
+					expect(schema._def.typeName).toBe('ZodDiscriminatedUnion');
+					expect(schema._def.discriminator).toBe(discriminator);
+				}
+			});
+
+			it('validates all defined discriminator values', () => {
+				if (!schemas.input) {
+					return;
+				}
+				for (const value of validValues) {
+					const input = {
+						[discriminator]: value,
+						// Add minimum required fields based on your contract
+					};
+
+					// This test assumes minimal input - you may need to add required fields
+					// based on the specific contract being tested
+					const result = validateInput(input);
+					// Specifically assert that it fails due to missing required fields
+					expect(result?.success).toBe(false);
+					if (!result?.success) {
+						expect(
+							result?.error.issues.some(
+								(issue) => issue.code === 'invalid_type'
+							)
+						).toBe(true);
+					}
+				}
+			});
+		});
+	};
+
+	const testRequiredFields = (schema: 'input' | 'output', fields: string[]) => {
+		describe(`Required ${schema} fields`, () => {
+			// Skip if testing input fields but no input schema exists
+			if (schema === 'input' && !schemas.input) {
+				it('skips input field tests as no input schema exists', () => {
+					expect(true).toBe(true);
+				});
+				return;
+			}
+
+			// Create a sample of valid data to test against
+			let sampleValid: Record<string, unknown>;
+
+			if (schema === 'input') {
+				// For input schema, we need a valid input based on the contract type
+				sampleValid = {
+					type: 'marketing_communications', // A common type that most contracts would have
+					domain: 'example.com',
+					// Add other fields that might be required by your contracts
+					subjectId: 'test-123',
+					metadata: {},
+				};
+			} else {
+				// For output schema, create a generic valid output
+				sampleValid = {
+					id: 'test-123',
+					domainId: 'domain-123',
+					domain: 'example.com',
+					type: 'marketing_communications',
+					status: 'granted',
+					recordId: 'record-123',
+					givenAt: new Date().toISOString(),
+					metadata: {},
+				};
+			}
+
+			for (const field of fields) {
+				it(`requires '${field}' field`, () => {
+					// Create a copy of the valid data without the tested field
+					const invalidData = { ...sampleValid };
+					delete invalidData[field];
+
+					const validator = schema === 'input' ? validateInput : validateOutput;
+					const result = validator(invalidData);
+
+					if (!result) {
+						throw new Error('Validation result is undefined');
+					}
+
+					expect(result.success).toBe(false);
+					if (!result.success) {
+						expect(
+							result.error.issues.some(
+								(issue: ZodIssue) =>
+									issue.path.some((p) => String(p).includes(field)) ||
+									issue.message.includes('required')
+							)
+						).toBe(true);
+					}
+				});
+			}
+		});
+	};
+
+	// Return the test helpers for re-use
+	return {
+		validateInput,
+		validateOutput,
+		testInput,
+		testOutput,
+		testDiscriminatedUnion,
+		testRequiredFields,
+	};
+}
+
+/**
+ * Creates consistency tests for multiple related contracts
+ */
+export function createConsistencyTests(
+	contracts: Record<
+		string,
+		{
+			'~orpc'?: {
+				inputSchema?: ContractSchema;
+				outputSchema?: ContractSchema;
+			};
+		}
+	>
+) {
+	describe('Contract Consistency', () => {
+		it('all contracts have output schemas', () => {
+			for (const [_name, contract] of Object.entries(contracts)) {
+				expect(contract['~orpc']?.outputSchema).toBeDefined();
+			}
+		});
+
+		// Field type consistency - ensure common fields use same types across contracts
+		// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: excessive cognitive complexity is acceptable here
+		it('common fields have consistent types across contracts', () => {
+			const commonFields = ['id', 'domainId', 'type', 'status'];
+			const contractEntries = Object.entries(contracts);
+
+			for (const field of commonFields) {
+				const fieldTypes = new Set();
+
+				for (const [_name, contract] of contractEntries) {
+					const schema = contract['~orpc']?.outputSchema;
+					if (!schema || !('shape' in schema)) {
+						continue;
+					}
+
+					const shape = schema.shape as Record<string, z.ZodTypeAny>;
+					if (field in shape) {
+						const fieldDef = shape[field];
+						if (fieldDef) {
+							fieldTypes.add(fieldDef.constructor.name);
+						}
+					}
+				}
+
+				// If the field exists in multiple contracts, they should all use the same type
+				if (fieldTypes.size > 0) {
+					expect(
+						fieldTypes.size,
+						`Field '${field}' has inconsistent types across contracts`
+					).toBe(1);
+				}
+			}
+		});
+
+		// Validate enum value consistency across contracts
+		// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: excessive cognitive complexity is acceptable here
+		it('enum values are consistent across contracts', () => {
+			// Example: status field should have the same allowed values in all contracts
+			const statusValues = new Map<string, string[]>();
+
+			for (const [name, contract] of Object.entries(contracts)) {
+				const schema = contract['~orpc']?.outputSchema;
+				if (!schema || !('shape' in schema)) {
+					continue;
+				}
+
+				const shape = schema.shape as Record<string, z.ZodTypeAny>;
+				if (!shape.status) {
+					continue;
+				}
+
+				const statusField = shape.status;
+				if ('_def' in statusField && 'values' in statusField._def) {
+					statusValues.set(name, statusField._def.values as string[]);
+				}
+			}
+
+			// All status enums should have the same values
+			const allValues = Array.from(statusValues.values());
+			if (allValues.length > 1) {
+				for (let i = 1; i < allValues.length; i++) {
+					expect(allValues[i]).toEqual(allValues[0]);
+				}
+			}
+		});
+
+		// Validation rule consistency for common fields
+		// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: excessive cognitive complexity is acceptable here
+		it('validation rules for common fields are consistent', () => {
+			const contractEntries = Object.entries(contracts);
+			const commonStringFields = ['domain', 'subjectId', 'externalSubjectId'];
+
+			for (const field of commonStringFields) {
+				const minLengths = new Set();
+				const maxLengths = new Set();
+
+				for (const [_name, contract] of contractEntries) {
+					const schema = contract['~orpc']?.inputSchema;
+					if (!schema || !('shape' in schema)) {
+						continue;
+					}
+
+					const shape = schema.shape as Record<string, z.ZodTypeAny>;
+					if (!shape[field]) {
+						continue;
+					}
+
+					const fieldSchema = shape[field];
+					if (
+						'_def' in fieldSchema &&
+						fieldSchema._def.typeName === 'ZodString'
+					) {
+						// Extract min/max length if they exist
+						const checks = fieldSchema._def.checks || [];
+						for (const check of checks) {
+							if (check.kind === 'min') {
+								minLengths.add(check.value);
+							}
+							if (check.kind === 'max') {
+								maxLengths.add(check.value);
+							}
+						}
+					}
+				}
+
+				// All contracts should use the same min/max for common string fields
+				expect(
+					minLengths.size,
+					`Inconsistent min length for field '${field}'`
+				).toBeLessThanOrEqual(1);
+				expect(
+					maxLengths.size,
+					`Inconsistent max length for field '${field}'`
+				).toBeLessThanOrEqual(1);
+			}
+		});
+
+		// Discriminated union consistency
+		it('discriminated unions use consistent discriminator across contracts', () => {
+			const discriminators = new Set();
+
+			for (const [_name, contract] of Object.entries(contracts)) {
+				const schema = contract['~orpc']?.inputSchema;
+				if (!schema || !('_def' in schema)) {
+					continue;
+				}
+
+				// Check if schema is a discriminated union
+				if (
+					'typeName' in schema._def &&
+					schema._def.typeName === 'ZodDiscriminatedUnion' &&
+					'discriminator' in schema._def
+				) {
+					// Safe assertion since we've checked the property exists
+					discriminators.add(
+						(schema._def as { discriminator: string }).discriminator
+					);
+				}
+			}
+
+			// All contracts should use the same discriminator (e.g., 'type')
+			expect(
+				discriminators.size,
+				'Inconsistent discriminator fields used across contracts'
+			).toBeLessThanOrEqual(1);
+		});
+	});
+}

package/src/types/context.ts

@@ -2,7 +2,7 @@ import type { DoubleTieContext } from '~/pkgs/types/context';
 import type { C15TPlugin, InferPluginContexts } from './plugins';
 
 /**
- * Complete C15T context type for consent management
+ * Complete c15t context type for consent management
  *
  * This type combines the base consent context with plugin-specific context extensions.
  * It's the primary context type used throughout the consent management system.

package/src/types/index.ts

@@ -1,7 +1,7 @@
 /**
- * C15T Types Package
+ * c15t Types Package
  *
- * This package provides type definitions specific to the C15T consent management system.
+ * This package provides type definitions specific to the c15t consent management system.
  * It extends the base DoubleTie framework types with consent management specific functionality.
  *
  * The types in this folder should be used for consent management specific features, while