@jmruthers/pace-core 0.5.86 → 0.5.88

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

@@ -1,447 +0,0 @@
-/**
- * @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');
-        }
-      });
-    });
-  });
-});