@c15t/backend 1.0.5 → 1.2.0-canary.0

package/src/contracts/meta/status.contract.test.ts

@@ -0,0 +1,338 @@
+import { describe, expect, it } from 'vitest';
+
+import { createContractTests } from '~/testing/contract-testing';
+import { statusContract } from './status.contract';
+
+// Create base tests for the contract using the utility
+const tester = createContractTests('Status', statusContract);
+
+// Add custom tests specific to the status contract
+describe('Status Contract Custom Tests', () => {
+	// Helper to access schemas consistently throughout tests
+	const schemas = {
+		input: statusContract['~orpc'].inputSchema,
+		output: statusContract['~orpc'].outputSchema,
+	};
+
+	// Helper functions for common test patterns
+	const validateInput = (input: unknown) => {
+		//@ts-expect-error
+		return schemas.input?.safeParse(input);
+	};
+
+	const validateOutput = (output: unknown) => {
+		return schemas.output?.safeParse(output);
+	};
+
+	describe('Schema Structure', () => {
+		it('input schema is an undefined', () => {
+			const result = validateInput(undefined);
+			expect(result?.success).toBe(undefined);
+		});
+
+		it('rejects input with extra properties', () => {
+			const result = validateInput({ extraProp: 'value' });
+			expect(result?.success).toBe(undefined);
+		});
+	});
+
+	describe('Output Validation', () => {
+		describe('Required fields', () => {
+			it('validates complete output object', () => {
+				const validOutput = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+					client: {
+						ip: '127.0.0.1',
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 'US',
+							regionCode: 'CA',
+						},
+					},
+				};
+
+				const result = validateOutput(validOutput);
+				expect(result?.success).toBe(true);
+			});
+
+			it('rejects output without required fields', () => {
+				const invalidOutput = {
+					status: 'ok',
+					// Missing version, timestamp, storage, and client
+				};
+
+				const result = validateOutput(invalidOutput);
+				expect(result?.success).toBe(false);
+			});
+		});
+
+		describe('Status field validation', () => {
+			it('accepts valid status values', () => {
+				for (const statusValue of ['ok', 'error']) {
+					const output = {
+						status: statusValue,
+						version: '1.0.0',
+						timestamp: new Date(),
+						storage: {
+							type: 'MemoryAdapter',
+							available: true,
+						},
+						client: {
+							ip: '127.0.0.1',
+							userAgent: 'Mozilla/5.0',
+							region: {
+								countryCode: 'US',
+								regionCode: 'CA',
+							},
+						},
+					};
+					const result = validateOutput(output);
+					expect(result?.success).toBe(true);
+				}
+			});
+
+			it('rejects invalid status values', () => {
+				const output = {
+					status: 'unknown', // Invalid status
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+					client: {
+						ip: '127.0.0.1',
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 'US',
+							regionCode: 'CA',
+						},
+					},
+				};
+				// Need to use type assertion to bypass TypeScript
+				const result = validateOutput(output);
+				expect(result?.success).toBe(false);
+			});
+		});
+
+		describe('Timestamp validation', () => {
+			it('accepts Date objects', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+					client: {
+						ip: '127.0.0.1',
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 'US',
+							regionCode: 'CA',
+						},
+					},
+				};
+				const result = validateOutput(output);
+				expect(result?.success).toBe(true);
+			});
+
+			it('rejects string timestamps', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date().toISOString(), // String instead of Date
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+				};
+
+				// Need to use type assertion to bypass TypeScript
+				const result = validateOutput(output);
+				expect(result?.success).toBe(false);
+			});
+		});
+
+		describe('Storage object validation', () => {
+			it('validates storage object structure', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+					client: {
+						ip: '127.0.0.1',
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 'US',
+							regionCode: 'CA',
+						},
+					},
+				};
+				const result = validateOutput(output);
+				expect(result?.success).toBe(true);
+			});
+
+			it('rejects invalid storage type', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 123, // Number instead of string
+						available: true,
+					},
+					client: {
+						ip: '127.0.0.1',
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 'US',
+							regionCode: 'CA',
+						},
+					},
+				};
+
+				// Need to use type assertion to bypass TypeScript
+				const result = validateOutput(output);
+				expect(result?.success).toBe(false);
+			});
+
+			it('rejects invalid available flag', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: 'yes', // String instead of boolean
+					},
+					client: {
+						ip: '127.0.0.1',
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 'US',
+							regionCode: 'CA',
+						},
+					},
+				};
+				// Need to use type assertion to bypass TypeScript
+				const result = validateOutput(output);
+				expect(result?.success).toBe(false);
+			});
+		});
+
+		describe('Client information validation', () => {
+			it('accepts null values for client fields', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+					client: {
+						ip: null,
+						userAgent: null,
+						region: {
+							countryCode: null,
+							regionCode: null,
+						},
+					},
+				};
+
+				const result = validateOutput(output);
+				expect(result?.success).toBe(true);
+			});
+
+			it('validates client object structure', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+					client: {
+						ip: '127.0.0.1',
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 'US',
+							regionCode: 'CA',
+						},
+					},
+				};
+
+				const result = validateOutput(output);
+				expect(result?.success).toBe(true);
+			});
+
+			it('rejects invalid client IP format', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+					client: {
+						ip: 123, // Number instead of string
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 'US',
+							regionCode: 'CA',
+						},
+					},
+				};
+
+				const result = validateOutput(output);
+				expect(result?.success).toBe(false);
+			});
+
+			it('rejects invalid region structure', () => {
+				const output = {
+					status: 'ok',
+					version: '1.0.0',
+					timestamp: new Date(),
+					storage: {
+						type: 'MemoryAdapter',
+						available: true,
+					},
+					client: {
+						ip: '127.0.0.1',
+						userAgent: 'Mozilla/5.0',
+						region: {
+							countryCode: 123, // Number instead of string
+							regionCode: 'CA',
+						},
+					},
+				};
+
+				const result = validateOutput(output);
+				expect(result?.success).toBe(false);
+			});
+		});
+	});
+});
+
+// Add required fields testing using the utility
+// No required fields for input since it's an empty object
+tester.testRequiredFields('output', [
+	'status',
+	'version',
+	'timestamp',
+	'storage',
+]);

package/src/contracts/meta/status.contract.ts

@@ -0,0 +1,37 @@
+import { oc } from '@orpc/contract';
+import { z } from 'zod';
+
+export const statusContract = oc
+	.route({
+		method: 'GET',
+		path: '/status',
+		description: `Returns the current operational status and health metrics of the service.
+This endpoint provides real-time information about:
+- Overall service status (ok/error)
+- Current API version
+- Server timestamp
+- Storage system status and availability
+- Client information (IP, User Agent, Region)
+
+Use this endpoint for health checks, monitoring, and service status verification.`,
+		tags: ['meta'],
+	})
+	.output(
+		z.object({
+			status: z.enum(['ok', 'error']),
+			version: z.string(),
+			timestamp: z.date(),
+			storage: z.object({
+				type: z.string(),
+				available: z.boolean(),
+			}),
+			client: z.object({
+				ip: z.string().nullable(),
+				userAgent: z.string().nullable(),
+				region: z.object({
+					countryCode: z.string().nullable(),
+					regionCode: z.string().nullable(),
+				}),
+			}),
+		})
+	);

package/src/contracts/shared/jurisdiction.schema.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+
+export const JurisdictionMessages = {
+	GDPR: 'GDPR or equivalent regulations require a cookie banner.',
+	CH: 'Switzerland requires similar data protection measures.',
+	BR: "Brazil's LGPD requires consent for cookies.",
+	PIPEDA: 'PIPEDA requires consent for data collection.',
+	AU: "Australia's Privacy Act mandates transparency about data collection.",
+	APPI: "Japan's APPI requires consent for data collection.",
+	PIPA: "South Korea's PIPA requires consent for data collection.",
+	NONE: 'No specific requirements',
+} as const;
+
+export type JurisdictionCode = keyof typeof JurisdictionMessages;
+
+export const JurisdictionCodeSchema = z.enum([
+	'GDPR',
+	'CH',
+	'BR',
+	'PIPEDA',
+	'AU',
+	'APPI',
+	'PIPA',
+	'NONE',
+]);
+
+export const JurisdictionInfoSchema = z.object({
+	code: JurisdictionCodeSchema,
+	message: z.string(),
+});