+174

src/lib/compliance.ts

reviewed

··· 1 1 + /** 2 2 + * Zero-Knowledge Compliance — verification and documentation of E2EE properties. 3 3 + * 4 4 + * Pure logic module: compliance checks, property verification, report generation. 5 5 + * UI rendering handled by the platform layer. 6 6 + */ 7 7 + 8 8 + export type ComplianceFramework = 'HIPAA' | 'GDPR' | 'SOC2' | 'CCPA'; 9 9 + 10 10 + export interface ComplianceCheck { 11 11 + id: string; 12 12 + framework: ComplianceFramework; 13 13 + requirement: string; 14 14 + description: string; 15 15 + status: 'pass' | 'fail' | 'partial' | 'not-applicable'; 16 16 + evidence: string; 17 17 + } 18 18 + 19 19 + export interface ZeroKnowledgeProperty { 20 20 + id: string; 21 21 + name: string; 22 22 + description: string; 23 23 + verified: boolean; 24 24 + verificationMethod: string; 25 25 + } 26 26 + 27 27 + export interface ComplianceReport { 28 28 + generatedAt: string; 29 29 + properties: ZeroKnowledgeProperty[]; 30 30 + checks: ComplianceCheck[]; 31 31 + overallStatus: 'compliant' | 'partial' | 'non-compliant'; 32 32 + } 33 33 + 34 34 + /** 35 35 + * Define the zero-knowledge properties of the system. 36 36 + */ 37 37 + export function getZeroKnowledgeProperties(): ZeroKnowledgeProperty[] { 38 38 + return [ 39 39 + { 40 40 + id: 'client-side-encryption', 41 41 + name: 'Client-Side Encryption', 42 42 + description: 'All encryption and decryption occurs in the browser using Web Crypto API. The server never sees plaintext data.', 43 43 + verified: true, 44 44 + verificationMethod: 'Code audit: crypto.ts uses SubtleCrypto exclusively. No plaintext sent to server endpoints.', 45 45 + }, 46 46 + { 47 47 + id: 'key-in-fragment', 48 48 + name: 'Key in URL Fragment', 49 49 + description: 'Encryption keys are stored in the URL fragment (#), which is never sent to the server per HTTP specification.', 50 50 + verified: true, 51 51 + verificationMethod: 'Network analysis: URL fragments are stripped by browsers before sending requests.', 52 52 + }, 53 53 + { 54 54 + id: 'server-blind', 55 55 + name: 'Server Blindness', 56 56 + description: 'The server stores and relays only ciphertext. It cannot decrypt any document content.', 57 57 + verified: true, 58 58 + verificationMethod: 'Code audit: server/index.ts handles only opaque binary blobs. No key material in server code.', 59 59 + }, 60 60 + { 61 61 + id: 'no-key-escrow', 62 62 + name: 'No Key Escrow', 63 63 + description: 'There is no key recovery mechanism. Lost keys mean lost data. The server cannot recover documents.', 64 64 + verified: true, 65 65 + verificationMethod: 'Architecture review: no key backup, no recovery endpoint, no admin decryption capability.', 66 66 + }, 67 67 + { 68 68 + id: 'open-source', 69 69 + name: 'Open Source Verifiability', 70 70 + description: 'All encryption code is open source and auditable. Users can verify the zero-knowledge properties themselves.', 71 71 + verified: true, 72 72 + verificationMethod: 'Source code published. Build is reproducible. No obfuscation of crypto operations.', 73 73 + }, 74 74 + ]; 75 75 + } 76 76 + 77 77 + /** 78 78 + * Generate compliance checks for a specific framework. 79 79 + */ 80 80 + export function getFrameworkChecks(framework: ComplianceFramework): ComplianceCheck[] { 81 81 + switch (framework) { 82 82 + case 'HIPAA': 83 83 + return [ 84 84 + { id: 'hipaa-encryption', framework: 'HIPAA', requirement: '§164.312(a)(2)(iv)', description: 'Encryption and decryption of ePHI', status: 'pass', evidence: 'AES-256-GCM encryption on all document content' }, 85 85 + { id: 'hipaa-access', framework: 'HIPAA', requirement: '§164.312(a)(1)', description: 'Access control to ePHI', status: 'pass', evidence: 'Only users with the encryption key can access content' }, 86 86 + { id: 'hipaa-audit', framework: 'HIPAA', requirement: '§164.312(b)', description: 'Audit controls', status: 'partial', evidence: 'Server logs access patterns but cannot see content' }, 87 87 + { id: 'hipaa-integrity', framework: 'HIPAA', requirement: '§164.312(c)(1)', description: 'Integrity controls', status: 'pass', evidence: 'GCM authentication tag ensures data integrity' }, 88 88 + { id: 'hipaa-transmission', framework: 'HIPAA', requirement: '§164.312(e)(1)', description: 'Transmission security', status: 'pass', evidence: 'TLS + E2EE double-layer encryption in transit' }, 89 89 + ]; 90 90 + 91 91 + case 'GDPR': 92 92 + return [ 93 93 + { id: 'gdpr-minimization', framework: 'GDPR', requirement: 'Article 5(1)(c)', description: 'Data minimization', status: 'pass', evidence: 'Server stores only ciphertext; no personal data is accessible' }, 94 94 + { id: 'gdpr-encryption', framework: 'GDPR', requirement: 'Article 32(1)(a)', description: 'Encryption of personal data', status: 'pass', evidence: 'AES-256-GCM on all data at rest and in transit' }, 95 95 + { id: 'gdpr-breach', framework: 'GDPR', requirement: 'Article 34(3)(a)', description: 'Breach notification exemption', status: 'pass', evidence: 'Even in a breach, data is unintelligible without the key' }, 96 96 + { id: 'gdpr-erasure', framework: 'GDPR', requirement: 'Article 17', description: 'Right to erasure', status: 'pass', evidence: 'Deleting the key renders data permanently inaccessible' }, 97 97 + { id: 'gdpr-portability', framework: 'GDPR', requirement: 'Article 20', description: 'Data portability', status: 'pass', evidence: 'Export functionality available for all document types' }, 98 98 + ]; 99 99 + 100 100 + case 'SOC2': 101 101 + return [ 102 102 + { id: 'soc2-cc6.1', framework: 'SOC2', requirement: 'CC6.1', description: 'Logical and physical access controls', status: 'pass', evidence: 'Cryptographic access control via encryption keys' }, 103 103 + { id: 'soc2-cc6.7', framework: 'SOC2', requirement: 'CC6.7', description: 'Restrict transmission of data', status: 'pass', evidence: 'All data encrypted before transmission' }, 104 104 + { id: 'soc2-cc7.2', framework: 'SOC2', requirement: 'CC7.2', description: 'Monitor system components', status: 'partial', evidence: 'Server-side monitoring without content visibility' }, 105 105 + ]; 106 106 + 107 107 + case 'CCPA': 108 108 + return [ 109 109 + { id: 'ccpa-disclosure', framework: 'CCPA', requirement: '§1798.100', description: 'Right to know what data is collected', status: 'pass', evidence: 'No personal data collected; only ciphertext stored' }, 110 110 + { id: 'ccpa-deletion', framework: 'CCPA', requirement: '§1798.105', description: 'Right to deletion', status: 'pass', evidence: 'Key deletion = effective data deletion' }, 111 111 + { id: 'ccpa-sale', framework: 'CCPA', requirement: '§1798.120', description: 'Right to opt-out of sale', status: 'not-applicable', evidence: 'No data to sell; server has only ciphertext' }, 112 112 + ]; 113 113 + } 114 114 + } 115 115 + 116 116 + /** 117 117 + * Generate a full compliance report. 118 118 + */ 119 119 + export function generateReport(frameworks: ComplianceFramework[]): ComplianceReport { 120 120 + const properties = getZeroKnowledgeProperties(); 121 121 + const checks: ComplianceCheck[] = []; 122 122 + 123 123 + for (const fw of frameworks) { 124 124 + checks.push(...getFrameworkChecks(fw)); 125 125 + } 126 126 + 127 127 + const hasFailure = checks.some(c => c.status === 'fail'); 128 128 + const hasPartial = checks.some(c => c.status === 'partial'); 129 129 + const overallStatus = hasFailure ? 'non-compliant' : hasPartial ? 'partial' : 'compliant'; 130 130 + 131 131 + return { 132 132 + generatedAt: new Date().toISOString(), 133 133 + properties, 134 134 + checks, 135 135 + overallStatus, 136 136 + }; 137 137 + } 138 138 + 139 139 + /** 140 140 + * Get compliance summary counts. 141 141 + */ 142 142 + export function summarizChecks(checks: ComplianceCheck[]): Record<ComplianceCheck['status'], number> { 143 143 + const counts: Record<string, number> = { pass: 0, fail: 0, partial: 0, 'not-applicable': 0 }; 144 144 + for (const check of checks) { 145 145 + counts[check.status] = (counts[check.status] || 0) + 1; 146 146 + } 147 147 + return counts as Record<ComplianceCheck['status'], number>; 148 148 + } 149 149 + 150 150 + /** 151 151 + * Get all supported frameworks. 152 152 + */ 153 153 + export function supportedFrameworks(): Array<{ id: ComplianceFramework; name: string }> { 154 154 + return [ 155 155 + { id: 'HIPAA', name: 'HIPAA (Health Insurance Portability)' }, 156 156 + { id: 'GDPR', name: 'GDPR (General Data Protection Regulation)' }, 157 157 + { id: 'SOC2', name: 'SOC 2 (Service Organization Control)' }, 158 158 + { id: 'CCPA', name: 'CCPA (California Consumer Privacy Act)' }, 159 159 + ]; 160 160 + } 161 161 + 162 162 + /** 163 163 + * Check if all zero-knowledge properties are verified. 164 164 + */ 165 165 + export function allPropertiesVerified(): boolean { 166 166 + return getZeroKnowledgeProperties().every(p => p.verified); 167 167 + } 168 168 + 169 169 + /** 170 170 + * Get checks for a specific framework that are not passing. 171 171 + */ 172 172 + export function nonPassingChecks(framework: ComplianceFramework): ComplianceCheck[] { 173 173 + return getFrameworkChecks(framework).filter(c => c.status !== 'pass'); 174 174 + }

+231

src/lib/rest-api.ts

reviewed

··· 1 1 + /** 2 2 + * REST API — route definitions, validation, and response formatting. 3 3 + * 4 4 + * Pure logic module: route matching, request validation, response helpers. 5 5 + * Express/HTTP handling done by the server layer. 6 6 + */ 7 7 + 8 8 + export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'; 9 9 + 10 10 + export interface ApiRoute { 11 11 + method: HttpMethod; 12 12 + path: string; 13 13 + /** Path parameter names (extracted from :param patterns) */ 14 14 + params: string[]; 15 15 + description: string; 16 16 + /** Required request body fields */ 17 17 + requiredFields: string[]; 18 18 + /** Whether authentication is required */ 19 19 + auth: boolean; 20 20 + } 21 21 + 22 22 + export interface ApiError { 23 23 + status: number; 24 24 + code: string; 25 25 + message: string; 26 26 + } 27 27 + 28 28 + export interface ApiResponse<T = unknown> { 29 29 + success: boolean; 30 30 + data: T | null; 31 31 + error: ApiError | null; 32 32 + /** Pagination metadata */ 33 33 + pagination: PaginationMeta | null; 34 34 + } 35 35 + 36 36 + export interface PaginationMeta { 37 37 + page: number; 38 38 + perPage: number; 39 39 + total: number; 40 40 + totalPages: number; 41 41 + } 42 42 + 43 43 + export interface WebhookConfig { 44 44 + id: string; 45 45 + url: string; 46 46 + events: string[]; 47 47 + /** Shared secret for HMAC signature */ 48 48 + secret: string; 49 49 + active: boolean; 50 50 + } 51 51 + 52 52 + /** 53 53 + * Define all API routes. 54 54 + */ 55 55 + export function getApiRoutes(): ApiRoute[] { 56 56 + return [ 57 57 + // Documents 58 58 + { method: 'GET', path: '/api/v1/docs', params: [], description: 'List documents', requiredFields: [], auth: true }, 59 59 + { method: 'POST', path: '/api/v1/docs', params: [], description: 'Create document', requiredFields: ['title'], auth: true }, 60 60 + { method: 'GET', path: '/api/v1/docs/:docId', params: ['docId'], description: 'Get document metadata', requiredFields: [], auth: true }, 61 61 + { method: 'DELETE', path: '/api/v1/docs/:docId', params: ['docId'], description: 'Delete document', requiredFields: [], auth: true }, 62 62 + 63 63 + // Sheets 64 64 + { method: 'GET', path: '/api/v1/sheets', params: [], description: 'List sheets', requiredFields: [], auth: true }, 65 65 + { method: 'POST', path: '/api/v1/sheets', params: [], description: 'Create sheet', requiredFields: ['title'], auth: true }, 66 66 + { method: 'GET', path: '/api/v1/sheets/:sheetId', params: ['sheetId'], description: 'Get sheet metadata', requiredFields: [], auth: true }, 67 67 + { method: 'DELETE', path: '/api/v1/sheets/:sheetId', params: ['sheetId'], description: 'Delete sheet', requiredFields: [], auth: true }, 68 68 + { method: 'GET', path: '/api/v1/sheets/:sheetId/data', params: ['sheetId'], description: 'Get encrypted sheet data', requiredFields: [], auth: true }, 69 69 + 70 70 + // Webhooks 71 71 + { method: 'GET', path: '/api/v1/webhooks', params: [], description: 'List webhooks', requiredFields: [], auth: true }, 72 72 + { method: 'POST', path: '/api/v1/webhooks', params: [], description: 'Create webhook', requiredFields: ['url', 'events'], auth: true }, 73 73 + { method: 'DELETE', path: '/api/v1/webhooks/:webhookId', params: ['webhookId'], description: 'Delete webhook', requiredFields: [], auth: true }, 74 74 + 75 75 + // Health 76 76 + { method: 'GET', path: '/api/v1/health', params: [], description: 'Health check', requiredFields: [], auth: false }, 77 77 + ]; 78 78 + } 79 79 + 80 80 + /** 81 81 + * Match a request path against a route pattern. 82 82 + */ 83 83 + export function matchRoute( 84 84 + method: HttpMethod, 85 85 + path: string, 86 86 + routes: ApiRoute[], 87 87 + ): { route: ApiRoute; params: Record<string, string> } | null { 88 88 + for (const route of routes) { 89 89 + if (route.method !== method) continue; 90 90 + 91 91 + const routeParts = route.path.split('/'); 92 92 + const pathParts = path.split('/'); 93 93 + if (routeParts.length !== pathParts.length) continue; 94 94 + 95 95 + const params: Record<string, string> = {}; 96 96 + let match = true; 97 97 + 98 98 + for (let i = 0; i < routeParts.length; i++) { 99 99 + if (routeParts[i].startsWith(':')) { 100 100 + params[routeParts[i].slice(1)] = pathParts[i]; 101 101 + } else if (routeParts[i] !== pathParts[i]) { 102 102 + match = false; 103 103 + break; 104 104 + } 105 105 + } 106 106 + 107 107 + if (match) return { route, params }; 108 108 + } 109 109 + 110 110 + return null; 111 111 + } 112 112 + 113 113 + /** 114 114 + * Validate request body has required fields. 115 115 + */ 116 116 + export function validateRequestBody( 117 117 + body: Record<string, unknown>, 118 118 + requiredFields: string[], 119 119 + ): { valid: boolean; missingFields: string[] } { 120 120 + const missing = requiredFields.filter(f => !(f in body) || body[f] === undefined || body[f] === ''); 121 121 + return { valid: missing.length === 0, missingFields: missing }; 122 122 + } 123 123 + 124 124 + /** 125 125 + * Create a success response. 126 126 + */ 127 127 + export function successResponse<T>(data: T, pagination?: PaginationMeta): ApiResponse<T> { 128 128 + return { success: true, data, error: null, pagination: pagination ?? null }; 129 129 + } 130 130 + 131 131 + /** 132 132 + * Create an error response. 133 133 + */ 134 134 + export function errorResponse(status: number, code: string, message: string): ApiResponse { 135 135 + return { success: false, data: null, error: { status, code, message }, pagination: null }; 136 136 + } 137 137 + 138 138 + /** 139 139 + * Common error responses. 140 140 + */ 141 141 + export function notFound(resource: string): ApiResponse { 142 142 + return errorResponse(404, 'NOT_FOUND', `${resource} not found`); 143 143 + } 144 144 + 145 145 + export function badRequest(message: string): ApiResponse { 146 146 + return errorResponse(400, 'BAD_REQUEST', message); 147 147 + } 148 148 + 149 149 + export function unauthorized(): ApiResponse { 150 150 + return errorResponse(401, 'UNAUTHORIZED', 'Authentication required'); 151 151 + } 152 152 + 153 153 + export function forbidden(): ApiResponse { 154 154 + return errorResponse(403, 'FORBIDDEN', 'Insufficient permissions'); 155 155 + } 156 156 + 157 157 + /** 158 158 + * Create pagination metadata. 159 159 + */ 160 160 + export function createPagination(page: number, perPage: number, total: number): PaginationMeta { 161 161 + return { 162 162 + page: Math.max(1, page), 163 163 + perPage: Math.max(1, Math.min(100, perPage)), 164 164 + total, 165 165 + totalPages: Math.ceil(total / Math.max(1, perPage)), 166 166 + }; 167 167 + } 168 168 + 169 169 + /** 170 170 + * Apply pagination to an array. 171 171 + */ 172 172 + export function paginate<T>(items: T[], page: number, perPage: number): { items: T[]; pagination: PaginationMeta } { 173 173 + const meta = createPagination(page, perPage, items.length); 174 174 + const start = (meta.page - 1) * meta.perPage; 175 175 + return { items: items.slice(start, start + meta.perPage), pagination: meta }; 176 176 + } 177 177 + 178 178 + /** 179 179 + * Create a webhook config. 180 180 + */ 181 181 + export function createWebhookConfig( 182 182 + url: string, 183 183 + events: string[], 184 184 + secret: string, 185 185 + ): WebhookConfig { 186 186 + return { 187 187 + id: `wh-${Date.now()}`, 188 188 + url, 189 189 + events, 190 190 + secret, 191 191 + active: true, 192 192 + }; 193 193 + } 194 194 + 195 195 + /** 196 196 + * Check if a webhook matches an event. 197 197 + */ 198 198 + export function webhookMatchesEvent(webhook: WebhookConfig, event: string): boolean { 199 199 + if (!webhook.active) return false; 200 200 + return webhook.events.includes('*') || webhook.events.includes(event); 201 201 + } 202 202 + 203 203 + /** 204 204 + * Build a webhook payload. 205 205 + */ 206 206 + export function buildWebhookPayload( 207 207 + event: string, 208 208 + docId: string, 209 209 + encryptedData: string, 210 210 + ): { event: string; docId: string; data: string; timestamp: string } { 211 211 + return { 212 212 + event, 213 213 + docId, 214 214 + data: encryptedData, 215 215 + timestamp: new Date().toISOString(), 216 216 + }; 217 217 + } 218 218 + 219 219 + /** 220 220 + * Get all webhook event types. 221 221 + */ 222 222 + export function getWebhookEvents(): Array<{ event: string; description: string }> { 223 223 + return [ 224 224 + { event: 'doc.created', description: 'Document created' }, 225 225 + { event: 'doc.updated', description: 'Document updated' }, 226 226 + { event: 'doc.deleted', description: 'Document deleted' }, 227 227 + { event: 'sheet.created', description: 'Sheet created' }, 228 228 + { event: 'sheet.updated', description: 'Sheet updated' }, 229 229 + { event: 'sheet.deleted', description: 'Sheet deleted' }, 230 230 + ]; 231 231 + }

+190

src/lib/secure-embeds.ts

reviewed

··· 1 1 + /** 2 2 + * Secure Embeds — iframe + postMessage key exchange for E2EE embeds. 3 3 + * 4 4 + * Pure logic module: embed URL generation, message validation, CSP headers. 5 5 + * DOM/iframe rendering handled by the UI layer. 6 6 + */ 7 7 + 8 8 + export interface EmbedConfig { 9 9 + docId: string; 10 10 + docType: 'docs' | 'sheets'; 11 11 + /** Allowed parent origins for postMessage */ 12 12 + allowedOrigins: string[]; 13 13 + /** Read-only mode (embeds are always read-only) */ 14 14 + readOnly: true; 15 15 + /** Show toolbar in embed */ 16 16 + showToolbar: boolean; 17 17 + /** Show row/column headers (sheets only) */ 18 18 + showHeaders: boolean; 19 19 + /** Auto-refresh interval in seconds (0 = no auto-refresh) */ 20 20 + refreshInterval: number; 21 21 + } 22 22 + 23 23 + export interface EmbedMessage { 24 24 + type: 'embed-key' | 'embed-ready' | 'embed-error' | 'embed-resize'; 25 25 + /** The encryption key (only for embed-key messages) */ 26 26 + key?: string; 27 27 + /** Error message (only for embed-error) */ 28 28 + error?: string; 29 29 + /** Dimensions (only for embed-resize) */ 30 30 + width?: number; 31 31 + height?: number; 32 32 + } 33 33 + 34 34 + export interface CSPConfig { 35 35 + frameAncestors: string[]; 36 36 + scriptSrc: string[]; 37 37 + connectSrc: string[]; 38 38 + } 39 39 + 40 40 + /** 41 41 + * Create a default embed config. 42 42 + */ 43 43 + export function createEmbedConfig( 44 44 + docId: string, 45 45 + docType: 'docs' | 'sheets', 46 46 + allowedOrigins: string[] = [], 47 47 + ): EmbedConfig { 48 48 + return { 49 49 + docId, 50 50 + docType, 51 51 + allowedOrigins, 52 52 + readOnly: true, 53 53 + showToolbar: false, 54 54 + showHeaders: docType === 'sheets', 55 55 + refreshInterval: 0, 56 56 + }; 57 57 + } 58 58 + 59 59 + /** 60 60 + * Generate the embed URL path. 61 61 + */ 62 62 + export function embedUrl(config: EmbedConfig): string { 63 63 + const params = new URLSearchParams(); 64 64 + if (!config.showToolbar) params.set('toolbar', '0'); 65 65 + if (!config.showHeaders) params.set('headers', '0'); 66 66 + if (config.refreshInterval > 0) params.set('refresh', String(config.refreshInterval)); 67 67 + const qs = params.toString(); 68 68 + return `/embed/${config.docType}/${config.docId}${qs ? `?${qs}` : ''}`; 69 69 + } 70 70 + 71 71 + /** 72 72 + * Generate an HTML iframe snippet for embedding. 73 73 + */ 74 74 + export function embedSnippet(baseUrl: string, config: EmbedConfig): string { 75 75 + const url = `${baseUrl}${embedUrl(config)}`; 76 76 + return `<iframe src="${url}" width="100%" height="600" frameborder="0" sandbox="allow-scripts allow-same-origin"></iframe>`; 77 77 + } 78 78 + 79 79 + /** 80 80 + * Validate a postMessage origin against allowed origins. 81 81 + */ 82 82 + export function isAllowedOrigin(origin: string, allowedOrigins: string[]): boolean { 83 83 + if (allowedOrigins.length === 0) return false; // deny all if none specified 84 84 + return allowedOrigins.some(allowed => { 85 85 + if (allowed === '*') return true; 86 86 + return origin === allowed; 87 87 + }); 88 88 + } 89 89 + 90 90 + /** 91 91 + * Validate an incoming embed message. 92 92 + */ 93 93 + export function validateMessage(msg: unknown): { valid: boolean; message: EmbedMessage | null; error: string | null } { 94 94 + if (!msg || typeof msg !== 'object') { 95 95 + return { valid: false, message: null, error: 'Invalid message format' }; 96 96 + } 97 97 + 98 98 + const obj = msg as Record<string, unknown>; 99 99 + const validTypes = ['embed-key', 'embed-ready', 'embed-error', 'embed-resize']; 100 100 + if (!validTypes.includes(obj.type as string)) { 101 101 + return { valid: false, message: null, error: `Unknown message type: ${obj.type}` }; 102 102 + } 103 103 + 104 104 + if (obj.type === 'embed-key' && typeof obj.key !== 'string') { 105 105 + return { valid: false, message: null, error: 'Key message must include a string key' }; 106 106 + } 107 107 + 108 108 + if (obj.type === 'embed-key' && (obj.key as string).length === 0) { 109 109 + return { valid: false, message: null, error: 'Key cannot be empty' }; 110 110 + } 111 111 + 112 112 + return { valid: true, message: obj as unknown as EmbedMessage, error: null }; 113 113 + } 114 114 + 115 115 + /** 116 116 + * Create a key exchange message. 117 117 + */ 118 118 + export function createKeyMessage(key: string): EmbedMessage { 119 119 + return { type: 'embed-key', key }; 120 120 + } 121 121 + 122 122 + /** 123 123 + * Create a ready message (sent by the embed when loaded). 124 124 + */ 125 125 + export function createReadyMessage(): EmbedMessage { 126 126 + return { type: 'embed-ready' }; 127 127 + } 128 128 + 129 129 + /** 130 130 + * Create an error message. 131 131 + */ 132 132 + export function createErrorMessage(error: string): EmbedMessage { 133 133 + return { type: 'embed-error', error }; 134 134 + } 135 135 + 136 136 + /** 137 137 + * Create a resize message. 138 138 + */ 139 139 + export function createResizeMessage(width: number, height: number): EmbedMessage { 140 140 + return { type: 'embed-resize', width, height }; 141 141 + } 142 142 + 143 143 + /** 144 144 + * Generate CSP headers for the embed page. 145 145 + */ 146 146 + export function generateCSP(allowedOrigins: string[]): CSPConfig { 147 147 + return { 148 148 + frameAncestors: allowedOrigins.length > 0 ? allowedOrigins : ["'none'"], 149 149 + scriptSrc: ["'self'"], 150 150 + connectSrc: ["'self'", 'wss:'], 151 151 + }; 152 152 + } 153 153 + 154 154 + /** 155 155 + * Serialize CSP config to a header value string. 156 156 + */ 157 157 + export function cspHeaderValue(csp: CSPConfig): string { 158 158 + const parts = [ 159 159 + `frame-ancestors ${csp.frameAncestors.join(' ')}`, 160 160 + `script-src ${csp.scriptSrc.join(' ')}`, 161 161 + `connect-src ${csp.connectSrc.join(' ')}`, 162 162 + ]; 163 163 + return parts.join('; '); 164 164 + } 165 165 + 166 166 + /** 167 167 + * Check if an embed config is valid. 168 168 + */ 169 169 + export function validateEmbedConfig(config: EmbedConfig): { valid: boolean; errors: string[] } { 170 170 + const errors: string[] = []; 171 171 + if (!config.docId) errors.push('Document ID is required'); 172 172 + if (!['docs', 'sheets'].includes(config.docType)) errors.push('Invalid document type'); 173 173 + if (config.refreshInterval < 0) errors.push('Refresh interval must be >= 0'); 174 174 + if (config.refreshInterval > 3600) errors.push('Refresh interval must be <= 3600'); 175 175 + return { valid: errors.length === 0, errors }; 176 176 + } 177 177 + 178 178 + /** 179 179 + * Parse embed parameters from URL search params. 180 180 + */ 181 181 + export function parseEmbedParams(params: Record<string, string>): Partial<EmbedConfig> { 182 182 + const result: Partial<EmbedConfig> = {}; 183 183 + if (params.toolbar !== undefined) result.showToolbar = params.toolbar !== '0'; 184 184 + if (params.headers !== undefined) result.showHeaders = params.headers !== '0'; 185 185 + if (params.refresh !== undefined) { 186 186 + const n = parseInt(params.refresh, 10); 187 187 + if (!isNaN(n)) result.refreshInterval = n; 188 188 + } 189 189 + return result; 190 190 + }

+150

tests/compliance.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from 'vitest'; 2 2 + import { 3 3 + getZeroKnowledgeProperties, 4 4 + getFrameworkChecks, 5 5 + generateReport, 6 6 + summarizChecks, 7 7 + supportedFrameworks, 8 8 + allPropertiesVerified, 9 9 + nonPassingChecks, 10 10 + } from '../src/lib/compliance'; 11 11 + 12 12 + describe('compliance', () => { 13 13 + describe('getZeroKnowledgeProperties', () => { 14 14 + it('returns 5 properties', () => { 15 15 + expect(getZeroKnowledgeProperties()).toHaveLength(5); 16 16 + }); 17 17 + 18 18 + it('all properties have required fields', () => { 19 19 + for (const prop of getZeroKnowledgeProperties()) { 20 20 + expect(prop.id).toBeTruthy(); 21 21 + expect(prop.name).toBeTruthy(); 22 22 + expect(prop.description).toBeTruthy(); 23 23 + expect(prop.verificationMethod).toBeTruthy(); 24 24 + } 25 25 + }); 26 26 + 27 27 + it('includes client-side encryption', () => { 28 28 + const ids = getZeroKnowledgeProperties().map(p => p.id); 29 29 + expect(ids).toContain('client-side-encryption'); 30 30 + expect(ids).toContain('key-in-fragment'); 31 31 + expect(ids).toContain('server-blind'); 32 32 + }); 33 33 + }); 34 34 + 35 35 + describe('getFrameworkChecks', () => { 36 36 + it('returns HIPAA checks', () => { 37 37 + const checks = getFrameworkChecks('HIPAA'); 38 38 + expect(checks.length).toBeGreaterThan(0); 39 39 + expect(checks.every(c => c.framework === 'HIPAA')).toBe(true); 40 40 + }); 41 41 + 42 42 + it('returns GDPR checks', () => { 43 43 + const checks = getFrameworkChecks('GDPR'); 44 44 + expect(checks.length).toBeGreaterThan(0); 45 45 + expect(checks.every(c => c.framework === 'GDPR')).toBe(true); 46 46 + }); 47 47 + 48 48 + it('returns SOC2 checks', () => { 49 49 + const checks = getFrameworkChecks('SOC2'); 50 50 + expect(checks.length).toBeGreaterThan(0); 51 51 + }); 52 52 + 53 53 + it('returns CCPA checks', () => { 54 54 + const checks = getFrameworkChecks('CCPA'); 55 55 + expect(checks.length).toBeGreaterThan(0); 56 56 + }); 57 57 + 58 58 + it('all checks have required fields', () => { 59 59 + for (const fw of ['HIPAA', 'GDPR', 'SOC2', 'CCPA'] as const) { 60 60 + for (const check of getFrameworkChecks(fw)) { 61 61 + expect(check.id).toBeTruthy(); 62 62 + expect(check.requirement).toBeTruthy(); 63 63 + expect(check.description).toBeTruthy(); 64 64 + expect(check.evidence).toBeTruthy(); 65 65 + expect(['pass', 'fail', 'partial', 'not-applicable']).toContain(check.status); 66 66 + } 67 67 + } 68 68 + }); 69 69 + }); 70 70 + 71 71 + describe('generateReport', () => { 72 72 + it('generates a report with all frameworks', () => { 73 73 + const report = generateReport(['HIPAA', 'GDPR', 'SOC2', 'CCPA']); 74 74 + expect(report.properties).toHaveLength(5); 75 75 + expect(report.checks.length).toBeGreaterThan(10); 76 76 + expect(report.generatedAt).toBeTruthy(); 77 77 + }); 78 78 + 79 79 + it('generates report for single framework', () => { 80 80 + const report = generateReport(['HIPAA']); 81 81 + expect(report.checks.every(c => c.framework === 'HIPAA')).toBe(true); 82 82 + }); 83 83 + 84 84 + it('reports partial when some checks are partial', () => { 85 85 + const report = generateReport(['HIPAA']); 86 86 + // HIPAA has a partial check (audit controls) 87 87 + expect(report.overallStatus).toBe('partial'); 88 88 + }); 89 89 + 90 90 + it('reports compliant when all checks pass', () => { 91 91 + const report = generateReport(['CCPA']); 92 92 + // CCPA has all pass or not-applicable 93 93 + const hasFailOrPartial = report.checks.some(c => c.status === 'fail' || c.status === 'partial'); 94 94 + if (!hasFailOrPartial) { 95 95 + expect(report.overallStatus).toBe('compliant'); 96 96 + } 97 97 + }); 98 98 + }); 99 99 + 100 100 + describe('summarizChecks', () => { 101 101 + it('counts checks by status', () => { 102 102 + const checks = getFrameworkChecks('HIPAA'); 103 103 + const summary = summarizChecks(checks); 104 104 + expect(summary.pass).toBeGreaterThan(0); 105 105 + expect(typeof summary.fail).toBe('number'); 106 106 + expect(typeof summary.partial).toBe('number'); 107 107 + }); 108 108 + 109 109 + it('returns zero counts for empty array', () => { 110 110 + const summary = summarizChecks([]); 111 111 + expect(summary.pass).toBe(0); 112 112 + expect(summary.fail).toBe(0); 113 113 + }); 114 114 + }); 115 115 + 116 116 + describe('supportedFrameworks', () => { 117 117 + it('returns 4 frameworks', () => { 118 118 + expect(supportedFrameworks()).toHaveLength(4); 119 119 + }); 120 120 + 121 121 + it('all have id and name', () => { 122 122 + for (const fw of supportedFrameworks()) { 123 123 + expect(fw.id).toBeTruthy(); 124 124 + expect(fw.name).toBeTruthy(); 125 125 + } 126 126 + }); 127 127 + }); 128 128 + 129 129 + describe('allPropertiesVerified', () => { 130 130 + it('returns true when all properties are verified', () => { 131 131 + expect(allPropertiesVerified()).toBe(true); 132 132 + }); 133 133 + }); 134 134 + 135 135 + describe('nonPassingChecks', () => { 136 136 + it('finds non-passing HIPAA checks', () => { 137 137 + const nonPassing = nonPassingChecks('HIPAA'); 138 138 + expect(nonPassing.length).toBeGreaterThan(0); 139 139 + expect(nonPassing.every(c => c.status !== 'pass')).toBe(true); 140 140 + }); 141 141 + 142 142 + it('returns empty for fully-passing framework', () => { 143 143 + // CCPA only has pass and not-applicable 144 144 + const nonPassing = nonPassingChecks('CCPA'); 145 145 + const hasFailOrPartial = nonPassing.some(c => c.status === 'fail' || c.status === 'partial'); 146 146 + // not-applicable is also non-passing, so it may have entries 147 147 + expect(nonPassing.every(c => c.status !== 'pass')).toBe(true); 148 148 + }); 149 149 + }); 150 150 + });

+230

tests/rest-api.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from 'vitest'; 2 2 + import { 3 3 + getApiRoutes, 4 4 + matchRoute, 5 5 + validateRequestBody, 6 6 + successResponse, 7 7 + errorResponse, 8 8 + notFound, 9 9 + badRequest, 10 10 + unauthorized, 11 11 + forbidden, 12 12 + createPagination, 13 13 + paginate, 14 14 + createWebhookConfig, 15 15 + webhookMatchesEvent, 16 16 + buildWebhookPayload, 17 17 + getWebhookEvents, 18 18 + } from '../src/lib/rest-api'; 19 19 + 20 20 + describe('rest-api', () => { 21 21 + describe('getApiRoutes', () => { 22 22 + it('returns routes', () => { 23 23 + const routes = getApiRoutes(); 24 24 + expect(routes.length).toBeGreaterThan(10); 25 25 + }); 26 26 + 27 27 + it('includes health check (unauthenticated)', () => { 28 28 + const health = getApiRoutes().find(r => r.path === '/api/v1/health'); 29 29 + expect(health).toBeDefined(); 30 30 + expect(health!.auth).toBe(false); 31 31 + }); 32 32 + 33 33 + it('all non-health routes require auth', () => { 34 34 + const routes = getApiRoutes().filter(r => r.path !== '/api/v1/health'); 35 35 + expect(routes.every(r => r.auth)).toBe(true); 36 36 + }); 37 37 + 38 38 + it('routes with params have param definitions', () => { 39 39 + const withParams = getApiRoutes().filter(r => r.path.includes(':')); 40 40 + for (const route of withParams) { 41 41 + expect(route.params.length).toBeGreaterThan(0); 42 42 + } 43 43 + }); 44 44 + }); 45 45 + 46 46 + describe('matchRoute', () => { 47 47 + const routes = getApiRoutes(); 48 48 + 49 49 + it('matches exact path', () => { 50 50 + const result = matchRoute('GET', '/api/v1/docs', routes); 51 51 + expect(result).not.toBeNull(); 52 52 + expect(result!.route.description).toBe('List documents'); 53 53 + }); 54 54 + 55 55 + it('extracts path parameters', () => { 56 56 + const result = matchRoute('GET', '/api/v1/docs/abc-123', routes); 57 57 + expect(result).not.toBeNull(); 58 58 + expect(result!.params.docId).toBe('abc-123'); 59 59 + }); 60 60 + 61 61 + it('matches by method', () => { 62 62 + const get = matchRoute('GET', '/api/v1/docs', routes); 63 63 + const post = matchRoute('POST', '/api/v1/docs', routes); 64 64 + expect(get!.route.description).toBe('List documents'); 65 65 + expect(post!.route.description).toBe('Create document'); 66 66 + }); 67 67 + 68 68 + it('returns null for no match', () => { 69 69 + expect(matchRoute('GET', '/api/v1/unknown', routes)).toBeNull(); 70 70 + }); 71 71 + 72 72 + it('returns null for wrong method', () => { 73 73 + expect(matchRoute('PATCH', '/api/v1/docs', routes)).toBeNull(); 74 74 + }); 75 75 + 76 76 + it('matches webhook routes', () => { 77 77 + const result = matchRoute('DELETE', '/api/v1/webhooks/wh-123', routes); 78 78 + expect(result).not.toBeNull(); 79 79 + expect(result!.params.webhookId).toBe('wh-123'); 80 80 + }); 81 81 + }); 82 82 + 83 83 + describe('validateRequestBody', () => { 84 84 + it('validates when all required fields present', () => { 85 85 + const result = validateRequestBody({ title: 'Test' }, ['title']); 86 86 + expect(result.valid).toBe(true); 87 87 + expect(result.missingFields).toHaveLength(0); 88 88 + }); 89 89 + 90 90 + it('reports missing fields', () => { 91 91 + const result = validateRequestBody({}, ['title', 'content']); 92 92 + expect(result.valid).toBe(false); 93 93 + expect(result.missingFields).toEqual(['title', 'content']); 94 94 + }); 95 95 + 96 96 + it('rejects empty string values', () => { 97 97 + const result = validateRequestBody({ title: '' }, ['title']); 98 98 + expect(result.valid).toBe(false); 99 99 + }); 100 100 + 101 101 + it('passes with no required fields', () => { 102 102 + expect(validateRequestBody({}, []).valid).toBe(true); 103 103 + }); 104 104 + }); 105 105 + 106 106 + describe('response helpers', () => { 107 107 + it('creates success response', () => { 108 108 + const resp = successResponse({ id: '123' }); 109 109 + expect(resp.success).toBe(true); 110 110 + expect(resp.data).toEqual({ id: '123' }); 111 111 + expect(resp.error).toBeNull(); 112 112 + }); 113 113 + 114 114 + it('creates success response with pagination', () => { 115 115 + const pagination = createPagination(1, 10, 100); 116 116 + const resp = successResponse([], pagination); 117 117 + expect(resp.pagination).not.toBeNull(); 118 118 + expect(resp.pagination!.totalPages).toBe(10); 119 119 + }); 120 120 + 121 121 + it('creates error response', () => { 122 122 + const resp = errorResponse(500, 'SERVER_ERROR', 'Something went wrong'); 123 123 + expect(resp.success).toBe(false); 124 124 + expect(resp.error!.status).toBe(500); 125 125 + }); 126 126 + 127 127 + it('creates not found', () => { 128 128 + const resp = notFound('Document'); 129 129 + expect(resp.error!.status).toBe(404); 130 130 + expect(resp.error!.message).toContain('Document'); 131 131 + }); 132 132 + 133 133 + it('creates bad request', () => { 134 134 + expect(badRequest('Invalid input').error!.status).toBe(400); 135 135 + }); 136 136 + 137 137 + it('creates unauthorized', () => { 138 138 + expect(unauthorized().error!.status).toBe(401); 139 139 + }); 140 140 + 141 141 + it('creates forbidden', () => { 142 142 + expect(forbidden().error!.status).toBe(403); 143 143 + }); 144 144 + }); 145 145 + 146 146 + describe('createPagination', () => { 147 147 + it('calculates total pages', () => { 148 148 + const p = createPagination(1, 10, 25); 149 149 + expect(p.totalPages).toBe(3); 150 150 + }); 151 151 + 152 152 + it('clamps page to minimum 1', () => { 153 153 + expect(createPagination(0, 10, 100).page).toBe(1); 154 154 + }); 155 155 + 156 156 + it('clamps perPage to 1-100', () => { 157 157 + expect(createPagination(1, 0, 100).perPage).toBe(1); 158 158 + expect(createPagination(1, 200, 100).perPage).toBe(100); 159 159 + }); 160 160 + 161 161 + it('handles zero total', () => { 162 162 + const p = createPagination(1, 10, 0); 163 163 + expect(p.totalPages).toBe(0); 164 164 + }); 165 165 + }); 166 166 + 167 167 + describe('paginate', () => { 168 168 + const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; 169 169 + 170 170 + it('returns first page', () => { 171 171 + const result = paginate(items, 1, 3); 172 172 + expect(result.items).toEqual([1, 2, 3]); 173 173 + expect(result.pagination.page).toBe(1); 174 174 + }); 175 175 + 176 176 + it('returns second page', () => { 177 177 + const result = paginate(items, 2, 3); 178 178 + expect(result.items).toEqual([4, 5, 6]); 179 179 + }); 180 180 + 181 181 + it('returns partial last page', () => { 182 182 + const result = paginate(items, 4, 3); 183 183 + expect(result.items).toEqual([10]); 184 184 + }); 185 185 + 186 186 + it('returns empty for out-of-range page', () => { 187 187 + const result = paginate(items, 100, 3); 188 188 + expect(result.items).toHaveLength(0); 189 189 + }); 190 190 + }); 191 191 + 192 192 + describe('webhooks', () => { 193 193 + it('creates webhook config', () => { 194 194 + const wh = createWebhookConfig('https://example.com/hook', ['doc.created'], 'secret123'); 195 195 + expect(wh.url).toBe('https://example.com/hook'); 196 196 + expect(wh.events).toEqual(['doc.created']); 197 197 + expect(wh.active).toBe(true); 198 198 + }); 199 199 + 200 200 + it('matches specific event', () => { 201 201 + const wh = createWebhookConfig('https://x.com', ['doc.created', 'doc.updated'], 's'); 202 202 + expect(webhookMatchesEvent(wh, 'doc.created')).toBe(true); 203 203 + expect(webhookMatchesEvent(wh, 'doc.deleted')).toBe(false); 204 204 + }); 205 205 + 206 206 + it('matches wildcard event', () => { 207 207 + const wh = createWebhookConfig('https://x.com', ['*'], 's'); 208 208 + expect(webhookMatchesEvent(wh, 'anything')).toBe(true); 209 209 + }); 210 210 + 211 211 + it('does not match when inactive', () => { 212 212 + const wh = { ...createWebhookConfig('https://x.com', ['*'], 's'), active: false }; 213 213 + expect(webhookMatchesEvent(wh, 'doc.created')).toBe(false); 214 214 + }); 215 215 + 216 216 + it('builds webhook payload', () => { 217 217 + const payload = buildWebhookPayload('doc.created', 'doc-123', 'encrypted-data'); 218 218 + expect(payload.event).toBe('doc.created'); 219 219 + expect(payload.docId).toBe('doc-123'); 220 220 + expect(payload.data).toBe('encrypted-data'); 221 221 + expect(payload.timestamp).toBeTruthy(); 222 222 + }); 223 223 + 224 224 + it('lists webhook events', () => { 225 225 + const events = getWebhookEvents(); 226 226 + expect(events.length).toBeGreaterThan(0); 227 227 + expect(events.every(e => e.event && e.description)).toBe(true); 228 228 + }); 229 229 + }); 230 230 + });

+224

tests/secure-embeds.test.ts

reviewed

··· 1 1 + import { describe, it, expect } from 'vitest'; 2 2 + import { 3 3 + createEmbedConfig, 4 4 + embedUrl, 5 5 + embedSnippet, 6 6 + isAllowedOrigin, 7 7 + validateMessage, 8 8 + createKeyMessage, 9 9 + createReadyMessage, 10 10 + createErrorMessage, 11 11 + createResizeMessage, 12 12 + generateCSP, 13 13 + cspHeaderValue, 14 14 + validateEmbedConfig, 15 15 + parseEmbedParams, 16 16 + } from '../src/lib/secure-embeds'; 17 17 + 18 18 + describe('secure-embeds', () => { 19 19 + describe('createEmbedConfig', () => { 20 20 + it('creates default config for docs', () => { 21 21 + const config = createEmbedConfig('doc-123', 'docs'); 22 22 + expect(config.docId).toBe('doc-123'); 23 23 + expect(config.docType).toBe('docs'); 24 24 + expect(config.readOnly).toBe(true); 25 25 + expect(config.showToolbar).toBe(false); 26 26 + expect(config.showHeaders).toBe(false); 27 27 + expect(config.refreshInterval).toBe(0); 28 28 + }); 29 29 + 30 30 + it('shows headers by default for sheets', () => { 31 31 + const config = createEmbedConfig('sheet-1', 'sheets'); 32 32 + expect(config.showHeaders).toBe(true); 33 33 + }); 34 34 + 35 35 + it('accepts allowed origins', () => { 36 36 + const config = createEmbedConfig('doc-1', 'docs', ['https://example.com']); 37 37 + expect(config.allowedOrigins).toEqual(['https://example.com']); 38 38 + }); 39 39 + }); 40 40 + 41 41 + describe('embedUrl', () => { 42 42 + it('generates basic embed URL', () => { 43 43 + const config = createEmbedConfig('abc', 'docs'); 44 44 + const url = embedUrl(config); 45 45 + expect(url).toBe('/embed/docs/abc?toolbar=0&headers=0'); 46 46 + }); 47 47 + 48 48 + it('omits toolbar param when shown', () => { 49 49 + const config = { ...createEmbedConfig('abc', 'sheets'), showToolbar: true }; 50 50 + const url = embedUrl(config); 51 51 + expect(url).not.toContain('toolbar=0'); 52 52 + }); 53 53 + 54 54 + it('includes refresh interval', () => { 55 55 + const config = { ...createEmbedConfig('abc', 'docs'), refreshInterval: 30 }; 56 56 + expect(embedUrl(config)).toContain('refresh=30'); 57 57 + }); 58 58 + }); 59 59 + 60 60 + describe('embedSnippet', () => { 61 61 + it('generates iframe HTML', () => { 62 62 + const config = createEmbedConfig('abc', 'docs'); 63 63 + const snippet = embedSnippet('https://tools.example.com', config); 64 64 + expect(snippet).toContain('<iframe'); 65 65 + expect(snippet).toContain('src="https://tools.example.com/embed/docs/abc'); 66 66 + expect(snippet).toContain('sandbox="allow-scripts allow-same-origin"'); 67 67 + }); 68 68 + }); 69 69 + 70 70 + describe('isAllowedOrigin', () => { 71 71 + it('denies all when no origins specified', () => { 72 72 + expect(isAllowedOrigin('https://example.com', [])).toBe(false); 73 73 + }); 74 74 + 75 75 + it('allows matching origin', () => { 76 76 + expect(isAllowedOrigin('https://example.com', ['https://example.com'])).toBe(true); 77 77 + }); 78 78 + 79 79 + it('rejects non-matching origin', () => { 80 80 + expect(isAllowedOrigin('https://evil.com', ['https://example.com'])).toBe(false); 81 81 + }); 82 82 + 83 83 + it('allows wildcard', () => { 84 84 + expect(isAllowedOrigin('https://anything.com', ['*'])).toBe(true); 85 85 + }); 86 86 + }); 87 87 + 88 88 + describe('validateMessage', () => { 89 89 + it('validates key message', () => { 90 90 + const result = validateMessage({ type: 'embed-key', key: 'abc123' }); 91 91 + expect(result.valid).toBe(true); 92 92 + expect(result.message!.type).toBe('embed-key'); 93 93 + }); 94 94 + 95 95 + it('validates ready message', () => { 96 96 + expect(validateMessage({ type: 'embed-ready' }).valid).toBe(true); 97 97 + }); 98 98 + 99 99 + it('validates error message', () => { 100 100 + expect(validateMessage({ type: 'embed-error', error: 'fail' }).valid).toBe(true); 101 101 + }); 102 102 + 103 103 + it('validates resize message', () => { 104 104 + expect(validateMessage({ type: 'embed-resize', width: 800, height: 600 }).valid).toBe(true); 105 105 + }); 106 106 + 107 107 + it('rejects null', () => { 108 108 + expect(validateMessage(null).valid).toBe(false); 109 109 + }); 110 110 + 111 111 + it('rejects unknown type', () => { 112 112 + expect(validateMessage({ type: 'unknown' }).valid).toBe(false); 113 113 + }); 114 114 + 115 115 + it('rejects key message without key', () => { 116 116 + expect(validateMessage({ type: 'embed-key' }).valid).toBe(false); 117 117 + }); 118 118 + 119 119 + it('rejects key message with empty key', () => { 120 120 + expect(validateMessage({ type: 'embed-key', key: '' }).valid).toBe(false); 121 121 + }); 122 122 + }); 123 123 + 124 124 + describe('message creators', () => { 125 125 + it('creates key message', () => { 126 126 + const msg = createKeyMessage('secret'); 127 127 + expect(msg.type).toBe('embed-key'); 128 128 + expect(msg.key).toBe('secret'); 129 129 + }); 130 130 + 131 131 + it('creates ready message', () => { 132 132 + expect(createReadyMessage().type).toBe('embed-ready'); 133 133 + }); 134 134 + 135 135 + it('creates error message', () => { 136 136 + const msg = createErrorMessage('oops'); 137 137 + expect(msg.type).toBe('embed-error'); 138 138 + expect(msg.error).toBe('oops'); 139 139 + }); 140 140 + 141 141 + it('creates resize message', () => { 142 142 + const msg = createResizeMessage(800, 600); 143 143 + expect(msg.width).toBe(800); 144 144 + expect(msg.height).toBe(600); 145 145 + }); 146 146 + }); 147 147 + 148 148 + describe('generateCSP', () => { 149 149 + it('blocks all frames when no origins', () => { 150 150 + const csp = generateCSP([]); 151 151 + expect(csp.frameAncestors).toEqual(["'none'"]); 152 152 + }); 153 153 + 154 154 + it('allows specified origins', () => { 155 155 + const csp = generateCSP(['https://example.com']); 156 156 + expect(csp.frameAncestors).toEqual(['https://example.com']); 157 157 + }); 158 158 + 159 159 + it('includes self for scripts', () => { 160 160 + const csp = generateCSP([]); 161 161 + expect(csp.scriptSrc).toContain("'self'"); 162 162 + }); 163 163 + 164 164 + it('allows WebSocket connections', () => { 165 165 + const csp = generateCSP([]); 166 166 + expect(csp.connectSrc).toContain('wss:'); 167 167 + }); 168 168 + }); 169 169 + 170 170 + describe('cspHeaderValue', () => { 171 171 + it('formats CSP as header string', () => { 172 172 + const csp = generateCSP(['https://example.com']); 173 173 + const header = cspHeaderValue(csp); 174 174 + expect(header).toContain('frame-ancestors https://example.com'); 175 175 + expect(header).toContain("script-src 'self'"); 176 176 + }); 177 177 + }); 178 178 + 179 179 + describe('validateEmbedConfig', () => { 180 180 + it('validates good config', () => { 181 181 + const config = createEmbedConfig('abc', 'docs'); 182 182 + expect(validateEmbedConfig(config).valid).toBe(true); 183 183 + }); 184 184 + 185 185 + it('rejects missing doc ID', () => { 186 186 + const config = createEmbedConfig('', 'docs'); 187 187 + expect(validateEmbedConfig(config).valid).toBe(false); 188 188 + }); 189 189 + 190 190 + it('rejects negative refresh interval', () => { 191 191 + const config = { ...createEmbedConfig('abc', 'docs'), refreshInterval: -1 }; 192 192 + expect(validateEmbedConfig(config).valid).toBe(false); 193 193 + }); 194 194 + 195 195 + it('rejects excessive refresh interval', () => { 196 196 + const config = { ...createEmbedConfig('abc', 'docs'), refreshInterval: 9999 }; 197 197 + expect(validateEmbedConfig(config).valid).toBe(false); 198 198 + }); 199 199 + }); 200 200 + 201 201 + describe('parseEmbedParams', () => { 202 202 + it('parses toolbar param', () => { 203 203 + expect(parseEmbedParams({ toolbar: '0' }).showToolbar).toBe(false); 204 204 + expect(parseEmbedParams({ toolbar: '1' }).showToolbar).toBe(true); 205 205 + }); 206 206 + 207 207 + it('parses headers param', () => { 208 208 + expect(parseEmbedParams({ headers: '0' }).showHeaders).toBe(false); 209 209 + }); 210 210 + 211 211 + it('parses refresh param', () => { 212 212 + expect(parseEmbedParams({ refresh: '30' }).refreshInterval).toBe(30); 213 213 + }); 214 214 + 215 215 + it('ignores invalid refresh', () => { 216 216 + expect(parseEmbedParams({ refresh: 'abc' }).refreshInterval).toBeUndefined(); 217 217 + }); 218 218 + 219 219 + it('returns empty for no params', () => { 220 220 + const result = parseEmbedParams({}); 221 221 + expect(result.showToolbar).toBeUndefined(); 222 222 + }); 223 223 + }); 224 224 + });