@jmruthers/pace-core 0.5.120 → 0.5.123

package/src/types/__tests__/file-reference.test.ts

@@ -0,0 +1,447 @@
+/**
+ * @file File Reference Type Tests
+ * @package @jmruthers/pace-core
+ * @module Types/__tests__
+ * @since 1.0.0
+ */
+
+import { describe, it, expect } from 'vitest';
+import type {
+  FileReference,
+  FileUploadOptions,
+  FileUploadResult,
+  FileValidationError,
+  FileMetadata,
+  FileStorageConfig,
+  FileAccessLevel
+} from '../file-reference';
+
+describe('[types] File Reference Types', () => {
+  describe('FileReference interface', () => {
+    it('validates FileReference type structure', () => {
+      const fileRef: FileReference = {
+        id: 'test-file-id',
+        filename: 'test-file.pdf',
+        originalName: 'Test File.pdf',
+        mimeType: 'application/pdf',
+        size: 1024,
+        url: 'https://example.com/files/test-file.pdf',
+        uploadedAt: '2024-01-01T00:00:00Z',
+        uploadedBy: 'user-123',
+        organisationId: 'org-123',
+        eventId: 'event-123',
+        accessLevel: 'private',
+        metadata: {
+          description: 'Test file description',
+          tags: ['document', 'test']
+        }
+      };
+
+      expect(fileRef).toHaveProperty('id');
+      expect(fileRef).toHaveProperty('filename');
+      expect(fileRef).toHaveProperty('originalName');
+      expect(fileRef).toHaveProperty('mimeType');
+      expect(fileRef).toHaveProperty('size');
+      expect(fileRef).toHaveProperty('url');
+      expect(fileRef).toHaveProperty('uploadedAt');
+      expect(fileRef).toHaveProperty('uploadedBy');
+      expect(fileRef).toHaveProperty('organisationId');
+      expect(fileRef).toHaveProperty('eventId');
+      expect(fileRef).toHaveProperty('accessLevel');
+      expect(fileRef).toHaveProperty('metadata');
+
+      expect(typeof fileRef.id).toBe('string');
+      expect(typeof fileRef.filename).toBe('string');
+      expect(typeof fileRef.originalName).toBe('string');
+      expect(typeof fileRef.mimeType).toBe('string');
+      expect(typeof fileRef.size).toBe('number');
+      expect(typeof fileRef.url).toBe('string');
+      expect(typeof fileRef.uploadedAt).toBe('string');
+      expect(typeof fileRef.uploadedBy).toBe('string');
+      expect(typeof fileRef.organisationId).toBe('string');
+      expect(typeof fileRef.eventId).toBe('string');
+      expect(typeof fileRef.accessLevel).toBe('string');
+      expect(typeof fileRef.metadata).toBe('object');
+    });
+
+    it('validates FileReference with minimal required fields', () => {
+      const fileRef: FileReference = {
+        id: 'test-file-id',
+        filename: 'test-file.pdf',
+        originalName: 'Test File.pdf',
+        mimeType: 'application/pdf',
+        size: 1024,
+        url: 'https://example.com/files/test-file.pdf',
+        uploadedAt: '2024-01-01T00:00:00Z',
+        uploadedBy: 'user-123',
+        organisationId: 'org-123',
+        accessLevel: 'private'
+      };
+
+      expect(fileRef).toHaveProperty('id');
+      expect(fileRef).toHaveProperty('filename');
+      expect(fileRef.eventId).toBeUndefined();
+      expect(fileRef.metadata).toBeUndefined();
+    });
+  });
+
+  describe('FileUploadOptions interface', () => {
+    it('validates FileUploadOptions type structure', () => {
+      const uploadOptions: FileUploadOptions = {
+        maxSize: 5 * 1024 * 1024, // 5MB
+        allowedTypes: ['image/jpeg', 'image/png', 'application/pdf'],
+        allowedExtensions: ['.jpg', '.jpeg', '.png', '.pdf'],
+        generateThumbnail: true,
+        compressImage: true,
+        quality: 0.8,
+        resize: {
+          width: 1920,
+          height: 1080,
+          maintainAspectRatio: true
+        },
+        metadata: {
+          description: 'Uploaded file',
+          tags: ['upload']
+        },
+        accessLevel: 'private',
+        organisationId: 'org-123',
+        eventId: 'event-123'
+      };
+
+      expect(uploadOptions).toHaveProperty('maxSize');
+      expect(uploadOptions).toHaveProperty('allowedTypes');
+      expect(uploadOptions).toHaveProperty('allowedExtensions');
+      expect(uploadOptions).toHaveProperty('generateThumbnail');
+      expect(uploadOptions).toHaveProperty('compressImage');
+      expect(uploadOptions).toHaveProperty('quality');
+      expect(uploadOptions).toHaveProperty('resize');
+      expect(uploadOptions).toHaveProperty('metadata');
+      expect(uploadOptions).toHaveProperty('accessLevel');
+      expect(uploadOptions).toHaveProperty('organisationId');
+      expect(uploadOptions).toHaveProperty('eventId');
+
+      expect(typeof uploadOptions.maxSize).toBe('number');
+      expect(Array.isArray(uploadOptions.allowedTypes)).toBe(true);
+      expect(Array.isArray(uploadOptions.allowedExtensions)).toBe(true);
+      expect(typeof uploadOptions.generateThumbnail).toBe('boolean');
+      expect(typeof uploadOptions.compressImage).toBe('boolean');
+      expect(typeof uploadOptions.quality).toBe('number');
+      expect(typeof uploadOptions.resize).toBe('object');
+      expect(typeof uploadOptions.metadata).toBe('object');
+      expect(typeof uploadOptions.accessLevel).toBe('string');
+      expect(typeof uploadOptions.organisationId).toBe('string');
+      expect(typeof uploadOptions.eventId).toBe('string');
+    });
+
+    it('validates FileUploadOptions with minimal fields', () => {
+      const uploadOptions: FileUploadOptions = {
+        maxSize: 1024 * 1024, // 1MB
+        allowedTypes: ['image/jpeg'],
+        accessLevel: 'public'
+      };
+
+      expect(uploadOptions).toHaveProperty('maxSize');
+      expect(uploadOptions).toHaveProperty('allowedTypes');
+      expect(uploadOptions).toHaveProperty('accessLevel');
+      expect(uploadOptions.allowedExtensions).toBeUndefined();
+      expect(uploadOptions.generateThumbnail).toBeUndefined();
+      expect(uploadOptions.compressImage).toBeUndefined();
+    });
+  });
+
+  describe('FileUploadResult interface', () => {
+    it('validates FileUploadResult success structure', () => {
+      const successResult: FileUploadResult = {
+        success: true,
+        file: {
+          id: 'test-file-id',
+          filename: 'test-file.pdf',
+          originalName: 'Test File.pdf',
+          mimeType: 'application/pdf',
+          size: 1024,
+          url: 'https://example.com/files/test-file.pdf',
+          uploadedAt: '2024-01-01T00:00:00Z',
+          uploadedBy: 'user-123',
+          organisationId: 'org-123',
+          accessLevel: 'private'
+        },
+        thumbnailUrl: 'https://example.com/thumbnails/test-file.jpg',
+        message: 'File uploaded successfully'
+      };
+
+      expect(successResult).toHaveProperty('success');
+      expect(successResult).toHaveProperty('file');
+      expect(successResult).toHaveProperty('thumbnailUrl');
+      expect(successResult).toHaveProperty('message');
+      expect(successResult.success).toBe(true);
+      expect(typeof successResult.file).toBe('object');
+      expect(typeof successResult.thumbnailUrl).toBe('string');
+      expect(typeof successResult.message).toBe('string');
+    });
+
+    it('validates FileUploadResult error structure', () => {
+      const errorResult: FileUploadResult = {
+        success: false,
+        error: 'File size exceeds maximum allowed size',
+        code: 'FILE_TOO_LARGE',
+        details: {
+          maxSize: 5 * 1024 * 1024,
+          actualSize: 10 * 1024 * 1024
+        }
+      };
+
+      expect(errorResult).toHaveProperty('success');
+      expect(errorResult).toHaveProperty('error');
+      expect(errorResult).toHaveProperty('code');
+      expect(errorResult).toHaveProperty('details');
+      expect(errorResult.success).toBe(false);
+      expect(typeof errorResult.error).toBe('string');
+      expect(typeof errorResult.code).toBe('string');
+      expect(typeof errorResult.details).toBe('object');
+      expect(errorResult.file).toBeUndefined();
+    });
+  });
+
+  describe('FileValidationError interface', () => {
+    it('validates FileValidationError type structure', () => {
+      const validationError: FileValidationError = {
+        field: 'file',
+        message: 'File type not allowed',
+        code: 'INVALID_FILE_TYPE',
+        value: 'test.exe',
+        allowedValues: ['image/jpeg', 'image/png', 'application/pdf']
+      };
+
+      expect(validationError).toHaveProperty('field');
+      expect(validationError).toHaveProperty('message');
+      expect(validationError).toHaveProperty('code');
+      expect(validationError).toHaveProperty('value');
+      expect(validationError).toHaveProperty('allowedValues');
+      expect(typeof validationError.field).toBe('string');
+      expect(typeof validationError.message).toBe('string');
+      expect(typeof validationError.code).toBe('string');
+      expect(typeof validationError.value).toBe('string');
+      expect(Array.isArray(validationError.allowedValues)).toBe(true);
+    });
+  });
+
+  describe('FileMetadata interface', () => {
+    it('validates FileMetadata type structure', () => {
+      const metadata: FileMetadata = {
+        description: 'Test file description',
+        tags: ['document', 'test', 'important'],
+        category: 'documents',
+        author: 'John Doe',
+        version: '1.0',
+        customFields: {
+          department: 'IT',
+          project: 'Test Project',
+          priority: 'high'
+        }
+      };
+
+      expect(metadata).toHaveProperty('description');
+      expect(metadata).toHaveProperty('tags');
+      expect(metadata).toHaveProperty('category');
+      expect(metadata).toHaveProperty('author');
+      expect(metadata).toHaveProperty('version');
+      expect(metadata).toHaveProperty('customFields');
+      expect(typeof metadata.description).toBe('string');
+      expect(Array.isArray(metadata.tags)).toBe(true);
+      expect(typeof metadata.category).toBe('string');
+      expect(typeof metadata.author).toBe('string');
+      expect(typeof metadata.version).toBe('string');
+      expect(typeof metadata.customFields).toBe('object');
+    });
+
+    it('validates FileMetadata with minimal fields', () => {
+      const metadata: FileMetadata = {
+        description: 'Test file'
+      };
+
+      expect(metadata).toHaveProperty('description');
+      expect(metadata.tags).toBeUndefined();
+      expect(metadata.category).toBeUndefined();
+      expect(metadata.author).toBeUndefined();
+      expect(metadata.version).toBeUndefined();
+      expect(metadata.customFields).toBeUndefined();
+    });
+  });
+
+  describe('FileStorageConfig interface', () => {
+    it('validates FileStorageConfig type structure', () => {
+      const storageConfig: FileStorageConfig = {
+        provider: 'supabase',
+        bucket: 'pace-files',
+        region: 'us-east-1',
+        cdnUrl: 'https://cdn.example.com',
+        maxFileSize: 10 * 1024 * 1024, // 10MB
+        allowedMimeTypes: ['image/*', 'application/pdf', 'text/*'],
+        compressionEnabled: true,
+        encryptionEnabled: true,
+        retentionPolicy: {
+          days: 365,
+          autoDelete: true
+        }
+      };
+
+      expect(storageConfig).toHaveProperty('provider');
+      expect(storageConfig).toHaveProperty('bucket');
+      expect(storageConfig).toHaveProperty('region');
+      expect(storageConfig).toHaveProperty('cdnUrl');
+      expect(storageConfig).toHaveProperty('maxFileSize');
+      expect(storageConfig).toHaveProperty('allowedMimeTypes');
+      expect(storageConfig).toHaveProperty('compressionEnabled');
+      expect(storageConfig).toHaveProperty('encryptionEnabled');
+      expect(storageConfig).toHaveProperty('retentionPolicy');
+      expect(typeof storageConfig.provider).toBe('string');
+      expect(typeof storageConfig.bucket).toBe('string');
+      expect(typeof storageConfig.region).toBe('string');
+      expect(typeof storageConfig.cdnUrl).toBe('string');
+      expect(typeof storageConfig.maxFileSize).toBe('number');
+      expect(Array.isArray(storageConfig.allowedMimeTypes)).toBe(true);
+      expect(typeof storageConfig.compressionEnabled).toBe('boolean');
+      expect(typeof storageConfig.encryptionEnabled).toBe('boolean');
+      expect(typeof storageConfig.retentionPolicy).toBe('object');
+    });
+  });
+
+  describe('FileAccessLevel type', () => {
+    it('validates FileAccessLevel values', () => {
+      const accessLevels: FileAccessLevel[] = ['public', 'private', 'restricted'];
+      
+      expect(accessLevels).toContain('public');
+      expect(accessLevels).toContain('private');
+      expect(accessLevels).toContain('restricted');
+    });
+
+    it('validates FileAccessLevel type usage', () => {
+      const accessLevel: FileAccessLevel = 'private';
+      expect(typeof accessLevel).toBe('string');
+      expect(['public', 'private', 'restricted']).toContain(accessLevel);
+    });
+  });
+});
+
+describe('[types] File Reference Usage Patterns', () => {
+  describe('File Upload Flow', () => {
+    it('validates complete file upload flow types', () => {
+      interface FileUploadFlow {
+        file: File;
+        options: FileUploadOptions;
+        onProgress: (progress: number) => void;
+        onSuccess: (result: FileUploadResult) => void;
+        onError: (error: FileValidationError) => void;
+      }
+
+      const uploadFlow: FileUploadFlow = {
+        file: new File(['test'], 'test.txt', { type: 'text/plain' }),
+        options: {
+          maxSize: 1024 * 1024,
+          allowedTypes: ['text/plain'],
+          accessLevel: 'private'
+        },
+        onProgress: (progress) => {
+          expect(typeof progress).toBe('number');
+          expect(progress).toBeGreaterThanOrEqual(0);
+          expect(progress).toBeLessThanOrEqual(100);
+        },
+        onSuccess: (result) => {
+          expect(result).toHaveProperty('success');
+          expect(result).toHaveProperty('file');
+        },
+        onError: (error) => {
+          expect(error).toHaveProperty('field');
+          expect(error).toHaveProperty('message');
+          expect(error).toHaveProperty('code');
+        }
+      };
+
+      expect(uploadFlow).toHaveProperty('file');
+      expect(uploadFlow).toHaveProperty('options');
+      expect(uploadFlow).toHaveProperty('onProgress');
+      expect(uploadFlow).toHaveProperty('onSuccess');
+      expect(uploadFlow).toHaveProperty('onError');
+      expect(uploadFlow.file).toBeInstanceOf(File);
+      expect(typeof uploadFlow.options).toBe('object');
+      expect(typeof uploadFlow.onProgress).toBe('function');
+      expect(typeof uploadFlow.onSuccess).toBe('function');
+      expect(typeof uploadFlow.onError).toBe('function');
+    });
+  });
+
+  describe('File Management Operations', () => {
+    it('validates file management operation types', () => {
+      interface FileManagementOperation {
+        operation: 'upload' | 'download' | 'delete' | 'update' | 'list';
+        fileId?: string;
+        options?: FileUploadOptions;
+        metadata?: FileMetadata;
+      }
+
+      const operations: FileManagementOperation[] = [
+        { operation: 'upload', options: { maxSize: 1024, allowedTypes: ['image/*'] } },
+        { operation: 'download', fileId: 'file-123' },
+        { operation: 'delete', fileId: 'file-123' },
+        { operation: 'update', fileId: 'file-123', metadata: { description: 'Updated' } },
+        { operation: 'list' }
+      ];
+
+      operations.forEach(op => {
+        expect(op).toHaveProperty('operation');
+        expect(['upload', 'download', 'delete', 'update', 'list']).toContain(op.operation);
+        if (op.fileId) {
+          expect(typeof op.fileId).toBe('string');
+        }
+        if (op.options) {
+          expect(typeof op.options).toBe('object');
+        }
+        if (op.metadata) {
+          expect(typeof op.metadata).toBe('object');
+        }
+      });
+    });
+  });
+
+  describe('File Validation Rules', () => {
+    it('validates file validation rule types', () => {
+      interface FileValidationRule {
+        field: keyof FileReference;
+        validator: (value: any) => boolean;
+        message: string;
+        required?: boolean;
+      }
+
+      const validationRules: FileValidationRule[] = [
+        {
+          field: 'filename',
+          validator: (value) => typeof value === 'string' && value.length > 0,
+          message: 'Filename is required',
+          required: true
+        },
+        {
+          field: 'size',
+          validator: (value) => typeof value === 'number' && value > 0,
+          message: 'File size must be greater than 0'
+        },
+        {
+          field: 'mimeType',
+          validator: (value) => typeof value === 'string' && value.includes('/'),
+          message: 'Invalid MIME type format'
+        }
+      ];
+
+      validationRules.forEach(rule => {
+        expect(rule).toHaveProperty('field');
+        expect(rule).toHaveProperty('validator');
+        expect(rule).toHaveProperty('message');
+        expect(typeof rule.field).toBe('string');
+        expect(typeof rule.validator).toBe('function');
+        expect(typeof rule.message).toBe('string');
+        if (rule.required !== undefined) {
+          expect(typeof rule.required).toBe('boolean');
+        }
+      });
+    });
+  });
+});