@bernierllc/content-type-video 1.0.0

package/__tests__/VideoContentType.test.ts

@@ -0,0 +1,522 @@
+/*
+Copyright (c) 2025 Bernier LLC
+
+This file is licensed to the client under a limited-use license.
+The client may use and modify this code *only within the scope of the project it was delivered for*.
+Redistribution or use in other products or commercial offerings is not permitted without written consent from Bernier LLC.
+*/
+
+import { VideoContentType } from '../src/VideoContentType';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+describe('VideoContentType', () => {
+  let videoType: VideoContentType;
+  let testUploadDir: string;
+
+  beforeEach(async () => {
+    testUploadDir = path.join(__dirname, 'test-uploads');
+    videoType = new VideoContentType({
+      uploadOptions: {
+        storageBasePath: testUploadDir,
+        maxSizeBytes: 1024 * 1024, // 1MB for tests
+      },
+      streamingBaseUrl: '/test-videos',
+    });
+  });
+
+  afterEach(async () => {
+    await fs.rm(testUploadDir, { recursive: true, force: true });
+  });
+
+  describe('upload', () => {
+    it('should upload valid MP4 video successfully', async () => {
+      const testVideo = Buffer.from('fake mp4 video content for testing');
+      const result = await videoType.upload(testVideo, 'test-video.mp4', 'user123');
+
+      expect(result.success).toBe(true);
+      expect(result.data?.metadata.filename).toContain('test-video.mp4');
+      expect(result.data?.metadata.mimeType).toBe('video/mp4');
+      expect(result.data?.uploadedBy).toBe('user123');
+      expect(result.data?.streamingUrl).toMatch(/^\/test-videos\//);
+    });
+
+    it('should upload valid WebM video successfully', async () => {
+      const testVideo = Buffer.from('fake webm video content');
+      const result = await videoType.upload(testVideo, 'test.webm');
+
+      expect(result.success).toBe(true);
+      expect(result.data?.metadata.mimeType).toBe('video/webm');
+    });
+
+    it('should upload valid MOV video successfully', async () => {
+      const testVideo = Buffer.from('fake mov video content');
+      const result = await videoType.upload(testVideo, 'test.mov');
+
+      expect(result.success).toBe(true);
+      expect(result.data?.metadata.mimeType).toBe('video/quicktime');
+    });
+
+    it('should upload valid AVI video successfully', async () => {
+      const testVideo = Buffer.from('fake avi video content');
+      const result = await videoType.upload(testVideo, 'test.avi');
+
+      expect(result.success).toBe(true);
+      expect(result.data?.metadata.mimeType).toBe('video/x-msvideo');
+    });
+
+    it('should reject invalid MIME type', async () => {
+      const testFile = Buffer.from('fake pdf');
+      const result = await videoType.upload(testFile, 'test.pdf');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('not allowed');
+    });
+
+    it('should reject oversized file', async () => {
+      const largeFile = Buffer.alloc(2 * 1024 * 1024);
+      const result = await videoType.upload(largeFile, 'large.mp4');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('exceeds maximum');
+    });
+
+    it('should generate unique filenames for concurrent uploads', async () => {
+      const testVideo = Buffer.from('test video');
+
+      // Add small delays to ensure unique timestamps
+      const upload1 = await videoType.upload(testVideo, 'test.mp4');
+      await new Promise(resolve => setTimeout(resolve, 2));
+      const upload2 = await videoType.upload(testVideo, 'test.mp4');
+      await new Promise(resolve => setTimeout(resolve, 2));
+      const upload3 = await videoType.upload(testVideo, 'test.mp4');
+
+      const filenames = [
+        upload1.data?.metadata.filename,
+        upload2.data?.metadata.filename,
+        upload3.data?.metadata.filename,
+      ];
+      const uniqueFilenames = new Set(filenames);
+
+      expect(uniqueFilenames.size).toBe(3);
+    });
+
+    it('should handle upload without uploadedBy', async () => {
+      const testVideo = Buffer.from('test video');
+      const result = await videoType.upload(testVideo, 'test.mp4');
+
+      expect(result.success).toBe(true);
+      expect(result.data?.uploadedBy).toBeUndefined();
+    });
+
+    it('should handle zero-byte files', async () => {
+      const emptyFile = Buffer.alloc(0);
+      const result = await videoType.upload(emptyFile, 'empty.mp4');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('empty');
+    });
+
+    it('should sanitize special characters in filenames', async () => {
+      const testVideo = Buffer.from('test video');
+      const result = await videoType.upload(testVideo, 'test video (1).mp4');
+
+      expect(result.success).toBe(true);
+      expect(result.data?.filePath).toContain('test_video__1_.mp4');
+    });
+  });
+
+  describe('validate', () => {
+    it('should validate allowed formats', async () => {
+      const testFile = Buffer.from('test');
+      const mp4Result = await videoType.validate(testFile, 'test.mp4');
+      const webmResult = await videoType.validate(testFile, 'test.webm');
+      const movResult = await videoType.validate(testFile, 'test.mov');
+      const aviResult = await videoType.validate(testFile, 'test.avi');
+
+      expect(mp4Result.success).toBe(true);
+      expect(webmResult.success).toBe(true);
+      expect(movResult.success).toBe(true);
+      expect(aviResult.success).toBe(true);
+    });
+
+    it('should reject disallowed formats', async () => {
+      const testFile = Buffer.from('test');
+      const pdfResult = await videoType.validate(testFile, 'test.pdf');
+      const docResult = await videoType.validate(testFile, 'test.doc');
+
+      expect(pdfResult.success).toBe(false);
+      expect(pdfResult.error).toContain('not allowed');
+      expect(docResult.success).toBe(false);
+    });
+
+    it('should check file size limits', async () => {
+      const smallFile = Buffer.alloc(100);
+      const maxFile = Buffer.alloc(1024 * 1024);
+      const largeFile = Buffer.alloc(2 * 1024 * 1024);
+
+      const smallResult = await videoType.validate(smallFile, 'small.mp4');
+      const maxResult = await videoType.validate(maxFile, 'max.mp4');
+      const largeResult = await videoType.validate(largeFile, 'large.mp4');
+
+      expect(smallResult.success).toBe(true);
+      expect(maxResult.success).toBe(true);
+      expect(largeResult.success).toBe(false);
+      expect(largeResult.error).toContain('exceeds maximum');
+    });
+
+    it('should reject zero-byte files', async () => {
+      const emptyFile = Buffer.alloc(0);
+      const result = await videoType.validate(emptyFile, 'empty.mp4');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('empty');
+    });
+  });
+
+  describe('file operations', () => {
+    it('should retrieve uploaded video', async () => {
+      const testVideo = Buffer.from('test video content');
+      const uploadResult = await videoType.upload(testVideo, 'test.mp4');
+
+      expect(uploadResult.success).toBe(true);
+      const localPath = uploadResult.data?.filePath;
+      expect(localPath).toBeDefined();
+
+      if (localPath) {
+        const retrieved = await videoType.get(localPath);
+        expect(retrieved).not.toBeNull();
+        expect(retrieved?.length).toBe(testVideo.length);
+      }
+    });
+
+    it('should return null for non-existent video', async () => {
+      const result = await videoType.get('/non/existent/path.mp4');
+      expect(result).toBeNull();
+    });
+
+    it('should delete uploaded video', async () => {
+      const testVideo = Buffer.from('test video');
+      const uploadResult = await videoType.upload(testVideo, 'test.mp4');
+
+      expect(uploadResult.success).toBe(true);
+      const localPath = uploadResult.data?.filePath;
+      expect(localPath).toBeDefined();
+
+      if (localPath) {
+        const deleteResult = await videoType.delete(localPath);
+        expect(deleteResult).toBe(true);
+
+        const retrieved = await videoType.get(localPath);
+        expect(retrieved).toBeNull();
+      }
+    });
+
+    it('should return false when deleting non-existent video', async () => {
+      const result = await videoType.delete('/non/existent/path.mp4');
+      expect(result).toBe(false);
+    });
+
+    it('should check if video exists', async () => {
+      const testVideo = Buffer.from('test video');
+      const uploadResult = await videoType.upload(testVideo, 'test.mp4');
+
+      expect(uploadResult.success).toBe(true);
+      const filePath = uploadResult.data?.filePath;
+      expect(filePath).toBeDefined();
+
+      if (filePath) {
+        const exists = await videoType.exists(filePath);
+        expect(exists).toBe(true);
+
+        await videoType.delete(filePath);
+        const stillExists = await videoType.exists(filePath);
+        expect(stillExists).toBe(false);
+      }
+    });
+  });
+
+  describe('getStreamingUrl', () => {
+    it('should generate correct streaming URLs', async () => {
+      const testVideo = Buffer.from('test video');
+      const uploadResult = await videoType.upload(testVideo, 'test.mp4');
+
+      expect(uploadResult.success).toBe(true);
+      const filePath = uploadResult.data?.filePath;
+      expect(filePath).toBeDefined();
+
+      if (filePath) {
+        const streamingUrl = videoType.getStreamingUrl(filePath);
+        expect(streamingUrl).toMatch(/^\/test-videos\//);
+        expect(streamingUrl).toContain('.mp4');
+      }
+    });
+  });
+
+  describe('register', () => {
+    it('should register with content type registry', async () => {
+      await expect(videoType.register()).resolves.not.toThrow();
+    });
+  });
+
+  describe('error handling edge cases', () => {
+    it('should handle file operations that throw errors', async () => {
+      const testVideo = Buffer.from('test video');
+      const uploadResult = await videoType.upload(testVideo, 'test.mp4');
+
+      expect(uploadResult.success).toBe(true);
+      const localPath = uploadResult.data?.localPath;
+
+      if (localPath) {
+        await fs.chmod(localPath, 0o000);
+
+        const retrieved = await videoType.get(localPath);
+        expect(retrieved).toBeNull();
+
+        await fs.chmod(localPath, 0o644);
+        await videoType.delete(localPath);
+      }
+    });
+
+    it('should handle upload error when file system throws', async () => {
+      const invalidVideoType = new VideoContentType({
+        uploadOptions: {
+          storageBasePath: '/invalid/readonly/path/that/should/not/exist',
+        },
+      });
+
+      const testVideo = Buffer.from('test');
+      const result = await invalidVideoType.upload(testVideo, 'test.mp4');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it('should handle different error types in upload catch block', async () => {
+      const invalidVideoType = new VideoContentType({
+        uploadOptions: {
+          storageBasePath: '/root/absolutely/invalid/path/with/no/permissions',
+        },
+      });
+
+      const testVideo = Buffer.from('valid test data');
+      const result = await invalidVideoType.upload(testVideo, 'test.mp4');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeTruthy();
+      expect(typeof result.error).toBe('string');
+    });
+  });
+
+  describe('configuration', () => {
+    it('should use custom configuration', () => {
+      const customVideoType = new VideoContentType({
+        uploadOptions: {
+          maxSizeBytes: 100 * 1024 * 1024,
+          allowedFormats: ['mp4', 'webm'],
+          storageBasePath: './custom-storage',
+        },
+        streamingBaseUrl: '/custom/stream',
+      });
+
+      expect(customVideoType).toBeInstanceOf(VideoContentType);
+    });
+
+    it('should use default configuration', () => {
+      const defaultVideoType = new VideoContentType();
+      expect(defaultVideoType.typeName).toBe('video');
+      expect(defaultVideoType.version).toBe('1.0.0');
+    });
+
+    it('should use environment variables for configuration', () => {
+      process.env.VIDEO_MAX_SIZE_BYTES = '5000000';
+      process.env.VIDEO_ALLOWED_FORMATS = 'mp4,webm';
+      process.env.VIDEO_STORAGE_BASE_PATH = '/env/storage';
+      process.env.VIDEO_STREAMING_BASE_URL = '/env/stream';
+      process.env.VIDEO_GENERATE_THUMBNAIL = 'true';
+      process.env.VIDEO_EXTRACT_METADATA = 'false';
+
+      const envVideoType = new VideoContentType();
+      expect(envVideoType).toBeInstanceOf(VideoContentType);
+
+      delete process.env.VIDEO_MAX_SIZE_BYTES;
+      delete process.env.VIDEO_ALLOWED_FORMATS;
+      delete process.env.VIDEO_STORAGE_BASE_PATH;
+      delete process.env.VIDEO_STREAMING_BASE_URL;
+      delete process.env.VIDEO_GENERATE_THUMBNAIL;
+      delete process.env.VIDEO_EXTRACT_METADATA;
+    });
+
+    it('should handle partial configuration override', () => {
+      const partialVideoType = new VideoContentType({
+        uploadOptions: {
+          maxSizeBytes: 50 * 1024 * 1024,
+        },
+      });
+
+      expect(partialVideoType).toBeInstanceOf(VideoContentType);
+    });
+
+    it('should handle configuration with undefined boolean values', () => {
+      const videoTypeWithUndefined = new VideoContentType({
+        uploadOptions: {
+          generateThumbnail: undefined,
+          extractMetadata: undefined,
+        },
+      });
+
+      expect(videoTypeWithUndefined).toBeInstanceOf(VideoContentType);
+    });
+  });
+
+  describe('validateContent', () => {
+    it('should validate correct video content data', () => {
+      const validData = {
+        filePath: testUploadDir + '/test.mp4',
+        streamingUrl: '/test-videos/test.mp4',
+        metadata: {
+          filename: 'test.mp4',
+          mimeType: 'video/mp4',
+          size: 1024000,
+          duration: 30,
+          width: 1920,
+          height: 1080,
+          fps: 30,
+        },
+        uploadedAt: new Date(),
+      };
+
+      const result = videoType.validateContent(validData);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(validData);
+    });
+
+    it('should validate content with optional fields', () => {
+      const validData = {
+        filePath: testUploadDir + '/test.mp4',
+        streamingUrl: '/test-videos/test.mp4',
+        metadata: {
+          filename: 'test.mp4',
+          mimeType: 'video/mp4',
+          size: 1024000,
+          duration: 30,
+          width: 1920,
+          height: 1080,
+          fps: 30,
+          thumbnail: 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUg',
+          bitrate: 5000000,
+          codec: 'h264',
+        },
+        uploadedAt: new Date(),
+        uploadedBy: 'user123',
+      };
+
+      const result = videoType.validateContent(validData);
+
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(validData);
+    });
+
+    it('should reject invalid metadata - wrong MIME type', () => {
+      const invalidData = {
+        filePath: testUploadDir + '/test.mp4',
+        streamingUrl: '/test-videos/test.mp4',
+        metadata: {
+          filename: 'test.mp4',
+          mimeType: 'invalid/type',
+          size: 1024000,
+          duration: 30,
+          width: 1920,
+          height: 1080,
+          fps: 30,
+        },
+        uploadedAt: new Date(),
+      };
+
+      const result = videoType.validateContent(invalidData);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+
+    it('should handle non-Error exceptions in validateContent', () => {
+      const invalidData = {
+        filePath: testUploadDir + '/test.mp4',
+        streamingUrl: '/test-videos/test.mp4',
+        metadata: {
+          filename: '',
+          mimeType: 'video/mp4',
+          size: -1,
+          duration: -1,
+          width: 0,
+          height: 0,
+          fps: 0,
+        },
+        uploadedAt: new Date(),
+      };
+
+      const result = videoType.validateContent(invalidData);
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeDefined();
+    });
+  });
+
+  describe('storage edge cases', () => {
+    it('should handle file path validation from string', async () => {
+      const testFilePath = path.join(__dirname, 'fixtures', 'test.mp4');
+      await fs.mkdir(path.dirname(testFilePath), { recursive: true });
+      await fs.writeFile(testFilePath, 'test video content');
+
+      const result = await videoType.upload(testFilePath, 'test.mp4');
+
+      expect(result.success).toBe(true);
+      expect(result.data?.metadata.size).toBeGreaterThan(0);
+
+      // Clean up
+      await fs.rm(path.join(__dirname, 'fixtures'), { recursive: true, force: true });
+    });
+
+    it('should handle getMimeType for unknown extensions', async () => {
+      const testVideo = Buffer.from('test video');
+
+      const customVideoType = new VideoContentType({
+        uploadOptions: {
+          storageBasePath: testUploadDir,
+          allowedFormats: ['mp4', 'xyz'], // Add fake format
+        },
+      });
+
+      const result = await customVideoType.upload(testVideo, 'test.xyz');
+
+      expect(result.success).toBe(true);
+      // Unknown format falls back to video/mp4
+      expect(result.data?.metadata.mimeType).toBe('video/mp4');
+    });
+
+    it('should handle JPG extension mapping', async () => {
+      const customVideoType = new VideoContentType({
+        uploadOptions: {
+          storageBasePath: testUploadDir,
+          allowedFormats: ['mp4', 'jpg'], // Allow jpg for testing
+        },
+      });
+
+      const testVideo = Buffer.from('test');
+      const result = await customVideoType.upload(testVideo, 'test.jpg');
+
+      expect(result.success).toBe(true);
+      // jpg extension maps to video/mp4 (default fallback)
+      expect(result.data?.metadata.mimeType).toBe('video/mp4');
+    });
+
+    it('should handle uppercase file extensions', async () => {
+      const testVideo = Buffer.from('test');
+      const result = await videoType.upload(testVideo, 'TEST.MP4');
+
+      expect(result.success).toBe(true);
+      expect(result.data?.metadata.mimeType).toBe('video/mp4');
+    });
+  });
+});

package/dist/VideoContentType.d.ts

@@ -0,0 +1,32 @@
+import { VideoContentData, VideoContentTypeConfig, VideoContentResult } from './types';
+/**
+ * Video content type with file upload, local storage, and streaming URL generation
+ */
+export declare class VideoContentType {
+    readonly typeName = "video";
+    readonly version = "1.0.0";
+    private config;
+    private storage;
+    constructor(config?: Partial<VideoContentTypeConfig>);
+    /**
+     * Register video content type with registry
+     */
+    register(): Promise<void>;
+    /**
+     * Validate video file
+     */
+    validate(file: Buffer | string, filename: string): Promise<VideoContentResult<void>>;
+    /**
+     * Upload video file and extract metadata
+     */
+    upload(file: Buffer | string, filename: string, uploadedBy?: string): Promise<VideoContentResult<VideoContentData>>;
+    get(localPath: string): Promise<Buffer | null>;
+    delete(localPath: string): Promise<boolean>;
+    exists(localPath: string): Promise<boolean>;
+    getStreamingUrl(localPath: string): string;
+    /**
+     * Validate video content data
+     */
+    validateContent(data: VideoContentData): VideoContentResult<VideoContentData>;
+}
+//# sourceMappingURL=VideoContentType.d.ts.map

package/dist/VideoContentType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"VideoContentType.d.ts","sourceRoot":"","sources":["../src/VideoContentType.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,gBAAgB,EAChB,sBAAsB,EACtB,kBAAkB,EAEnB,MAAM,SAAS,CAAC;AAKjB;;GAEG;AACH,qBAAa,gBAAgB;IAC3B,SAAgB,QAAQ,WAAW;IACnC,SAAgB,OAAO,WAAW;IAClC,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,OAAO,CAAe;gBAElB,MAAM,GAAE,OAAO,CAAC,sBAAsB,CAAM;IAKxD;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAc/B;;OAEG;IACG,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAiC1F;;OAEG;IACG,MAAM,CACV,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,QAAQ,EAAE,MAAM,EAChB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,kBAAkB,CAAC,gBAAgB,CAAC,CAAC;IAgB1C,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAI9C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAI3C,MAAM,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAIjD,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM;IAI1C;;OAEG;IACH,eAAe,CAAC,IAAI,EAAE,gBAAgB,GAAG,kBAAkB,CAAC,gBAAgB,CAAC;CAW9E"}