@bernierllc/content-type-video 1.0.0

package/jest.config.cjs

@@ -0,0 +1,31 @@
+/*
+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.
+*/
+
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/__tests__'],
+  testMatch: ['**/__tests__/**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/index.ts'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 75,
+      functions: 90,
+      lines: 90,
+      statements: 90
+    }
+  },
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  transform: {
+    '^.+\\.ts$': 'ts-jest'
+  }
+};

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@bernierllc/content-type-video",
+  "version": "1.0.0",
+  "description": "Base video content type with file upload, local storage, and streaming URL generation",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest --watch",
+    "test:run": "jest",
+    "test:coverage": "jest --coverage",
+    "lint": "eslint src --ext .ts",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "content-type",
+    "video",
+    "media",
+    "upload",
+    "streaming",
+    "storage",
+    "metadata",
+    "bernierllc"
+  ],
+  "author": "Bernier LLC",
+  "license": "SEE LICENSE IN LICENSE",
+  "dependencies": {
+    "@bernierllc/content-type-registry": "^1.0.3",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/node": "^20.0.0",
+    "@typescript-eslint/eslint-plugin": "^6.0.0",
+    "@typescript-eslint/parser": "^6.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "peerDependencies": {
+    "@bernierllc/neverhub-adapter": "^1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@bernierllc/neverhub-adapter": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bernierllc": {
+    "integration": {
+      "neverhub": "optional",
+      "neveradmin": "not-applicable",
+      "logger": "planned"
+    }
+  }
+}

package/src/VideoContentType.ts

@@ -0,0 +1,142 @@
+/*
+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 { contentTypeRegistry, BaseContentType } from '@bernierllc/content-type-registry';
+import * as path from 'path';
+import * as fs from 'fs';
+import {
+  VideoContentData,
+  VideoContentTypeConfig,
+  VideoContentResult,
+  VideoMetadataSchema,
+} from './types';
+import { VideoStorage } from './storage/VideoStorage';
+import { LocalVideoStorage } from './storage/LocalVideoStorage';
+import { loadConfig } from './config';
+
+/**
+ * Video content type with file upload, local storage, and streaming URL generation
+ */
+export class VideoContentType {
+  public readonly typeName = 'video';
+  public readonly version = '1.0.0';
+  private config: VideoContentTypeConfig;
+  private storage: VideoStorage;
+
+  constructor(config: Partial<VideoContentTypeConfig> = {}) {
+    this.config = loadConfig(config);
+    this.storage = new LocalVideoStorage(this.config);
+  }
+
+  /**
+   * Register video content type with registry
+   */
+  async register(): Promise<void> {
+    contentTypeRegistry.register({
+      id: 'video',
+      name: 'Video',
+      description: 'Base video content type with file upload and streaming',
+      baseType: BaseContentType.VIDEO,
+      icon: 'video',
+      schema: VideoMetadataSchema,
+      editor: this.config.editor,
+      storage: this.config.storage,
+      publishing: this.config.publishing,
+    });
+  }
+
+  /**
+   * Validate video file
+   */
+  async validate(file: Buffer | string, filename: string): Promise<VideoContentResult<void>> {
+    // Check for zero-byte files
+    const fileSize = Buffer.isBuffer(file) ? file.length : fs.statSync(file).size;
+    if (fileSize === 0) {
+      return {
+        success: false,
+        error: 'File is empty (0 bytes)',
+      };
+    }
+
+    // Validate file format
+    const extension = path.extname(filename).slice(1).toLowerCase();
+    const allowedFormats = this.config.uploadOptions?.allowedFormats || ['mp4', 'webm', 'mov', 'avi'];
+
+    if (!allowedFormats.includes(extension)) {
+      return {
+        success: false,
+        error: `File format ${extension} not allowed. Allowed: ${allowedFormats.join(', ')}`,
+      };
+    }
+
+    // Validate file size
+    const maxSize = this.config.uploadOptions?.maxSizeBytes || 500 * 1024 * 1024;
+    if (fileSize > maxSize) {
+      return {
+        success: false,
+        error: `File size ${fileSize} exceeds maximum ${maxSize}`,
+      };
+    }
+
+    return { success: true };
+  }
+
+  /**
+   * Upload video file and extract metadata
+   */
+  async upload(
+    file: Buffer | string,
+    filename: string,
+    uploadedBy?: string
+  ): Promise<VideoContentResult<VideoContentData>> {
+    try {
+      const validation = await this.validate(file, filename);
+      if (!validation.success) {
+        return { success: false, error: validation.error || 'Validation failed' };
+      }
+
+      return await this.storage.save(file, filename, uploadedBy);
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown error during video upload',
+      };
+    }
+  }
+
+  async get(localPath: string): Promise<Buffer | null> {
+    return this.storage.get(localPath);
+  }
+
+  async delete(localPath: string): Promise<boolean> {
+    return this.storage.delete(localPath);
+  }
+
+  async exists(localPath: string): Promise<boolean> {
+    return this.storage.exists(localPath);
+  }
+
+  getStreamingUrl(localPath: string): string {
+    return this.storage.getStreamingUrl(localPath);
+  }
+
+  /**
+   * Validate video content data
+   */
+  validateContent(data: VideoContentData): VideoContentResult<VideoContentData> {
+    try {
+      VideoMetadataSchema.parse(data.metadata);
+      return { success: true, data };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Validation failed',
+      };
+    }
+  }
+}

package/src/config.ts

@@ -0,0 +1,63 @@
+/*
+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 { VideoContentTypeConfig } from './types';
+
+/**
+ * Load configuration from environment variables with fallback to defaults
+ */
+export function loadConfig(config: Partial<VideoContentTypeConfig> = {}): VideoContentTypeConfig {
+  const maxSizeBytes = config.uploadOptions?.maxSizeBytes
+    || (process.env.VIDEO_MAX_SIZE_BYTES ? parseInt(process.env.VIDEO_MAX_SIZE_BYTES, 10) : undefined)
+    || 500 * 1024 * 1024; // 500MB default
+
+  const storageBasePath = config.uploadOptions?.storageBasePath
+    || process.env.VIDEO_STORAGE_BASE_PATH
+    || './storage/videos';
+
+  const streamingBaseUrl = config.streamingBaseUrl
+    || process.env.VIDEO_STREAMING_BASE_URL
+    || '/api/video/stream';
+
+  const allowedFormats = config.uploadOptions?.allowedFormats
+    || (process.env.VIDEO_ALLOWED_FORMATS ? process.env.VIDEO_ALLOWED_FORMATS.split(',').map(f => f.trim()) : undefined)
+    || ['mp4', 'webm', 'mov', 'avi'];
+
+  const generateThumbnail = config.uploadOptions?.generateThumbnail
+    !== undefined ? config.uploadOptions.generateThumbnail
+    : (process.env.VIDEO_GENERATE_THUMBNAIL === 'true' || true);
+
+  const extractMetadata = config.uploadOptions?.extractMetadata
+    !== undefined ? config.uploadOptions.extractMetadata
+    : (process.env.VIDEO_EXTRACT_METADATA === 'true' || true);
+
+  return {
+    baseType: 'video',
+    editor: config.editor || {
+      component: 'file-upload-with-player',
+      settings: {},
+    },
+    storage: config.storage || {
+      method: 'file',
+      settings: {},
+    },
+    publishing: config.publishing || {
+      methods: ['streaming-url'],
+      defaultMethod: 'streaming-url',
+      settings: {},
+    },
+    uploadOptions: {
+      maxSizeBytes,
+      allowedFormats,
+      generateThumbnail,
+      extractMetadata,
+      storageBasePath,
+    },
+    streamingBaseUrl,
+  };
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+/*
+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.
+*/
+
+export * from './types';
+export * from './VideoContentType';
+export * from './config';
+export * from './storage/VideoStorage';
+export * from './storage/LocalVideoStorage';
+export { VideoContentType } from './VideoContentType';

package/src/storage/LocalVideoStorage.ts

@@ -0,0 +1,134 @@
+/*
+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 * as fs from 'fs/promises';
+import * as fsSync from 'fs';
+import * as path from 'path';
+import { VideoStorage } from './VideoStorage';
+import { VideoContentResult, VideoContentData, VideoMetadata, VideoMetadataSchema, VideoContentTypeConfig } from '../types';
+
+/**
+ * Local file system storage implementation for videos
+ */
+export class LocalVideoStorage implements VideoStorage {
+  private storageBasePath: string;
+  private streamingBaseUrl: string;
+
+  constructor(config: VideoContentTypeConfig) {
+    this.storageBasePath = config.uploadOptions?.storageBasePath || './storage/videos';
+    this.streamingBaseUrl = config.streamingBaseUrl || '/api/video/stream';
+  }
+
+  async save(file: Buffer | string, filename: string, uploadedBy?: string): Promise<VideoContentResult<VideoContentData>> {
+    try {
+      // Ensure storage directory exists
+      await fs.mkdir(this.storageBasePath, { recursive: true });
+
+      // Generate unique filename
+      const timestamp = Date.now();
+      const sanitizedFilename = filename.replace(/[^a-zA-Z0-9.-]/g, '_');
+      const uniqueFilename = `${timestamp}-${sanitizedFilename}`;
+
+      // Save file
+      const filePath = path.join(this.storageBasePath, uniqueFilename);
+
+      if (Buffer.isBuffer(file)) {
+        await fs.writeFile(filePath, file);
+      } else {
+        await fs.copyFile(file, filePath);
+      }
+
+      // Extract metadata
+      const metadata = await this.extractMetadata(filePath);
+
+      // Generate streaming URL
+      const streamingUrl = this.getStreamingUrl(filePath);
+
+      const contentData: VideoContentData = {
+        filePath,
+        streamingUrl,
+        metadata,
+        uploadedAt: new Date(),
+        uploadedBy,
+      };
+
+      return {
+        success: true,
+        data: contentData,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : 'Unknown save error',
+      };
+    }
+  }
+
+  async get(localPath: string): Promise<Buffer | null> {
+    try {
+      return await fs.readFile(localPath);
+    } catch {
+      return null;
+    }
+  }
+
+  async delete(localPath: string): Promise<boolean> {
+    try {
+      await fs.unlink(localPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  async exists(localPath: string): Promise<boolean> {
+    try {
+      await fs.access(localPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  getStreamingUrl(localPath: string): string {
+    const relativePath = path.relative(this.storageBasePath, localPath);
+    return `${this.streamingBaseUrl}/${encodeURIComponent(relativePath)}`;
+  }
+
+  /**
+   * Extract video metadata
+   * Note: In production, this would use ffmpeg/ffprobe for real metadata extraction
+   */
+  private async extractMetadata(filePath: string): Promise<VideoMetadata> {
+    const stats = fsSync.statSync(filePath);
+
+    // Basic metadata - in production, use ffmpeg/ffprobe for real extraction
+    const metadata: VideoMetadata = {
+      filename: path.basename(filePath),
+      mimeType: this.getMimeTypeFromExtension(filePath),
+      size: stats.size,
+      duration: 60, // Placeholder - would extract from video
+      width: 1920, // Placeholder - would extract from video
+      height: 1080, // Placeholder - would extract from video
+      fps: 30, // Placeholder - would extract from video
+    };
+
+    return VideoMetadataSchema.parse(metadata);
+  }
+
+  private getMimeTypeFromExtension(filePath: string): string {
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    const mimeTypes: Record<string, string> = {
+      mp4: 'video/mp4',
+      webm: 'video/webm',
+      mov: 'video/quicktime',
+      avi: 'video/x-msvideo',
+    };
+    return mimeTypes[ext] || 'video/mp4';
+  }
+}

package/src/storage/VideoStorage.ts

@@ -0,0 +1,20 @@
+/*
+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 { VideoContentResult, VideoContentData } from '../types';
+
+/**
+ * Video storage interface
+ */
+export interface VideoStorage {
+  save(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;
+}

package/src/types.ts

@@ -0,0 +1,99 @@
+/*
+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 { z } from 'zod';
+
+/**
+ * Video metadata schema
+ */
+export const VideoMetadataSchema = z.object({
+  filename: z.string(),
+  mimeType: z.string().regex(/^video\//),
+  size: z.number().positive(),
+  duration: z.number().positive(), // seconds
+  width: z.number().int().positive(),
+  height: z.number().int().positive(),
+  fps: z.number().positive(),
+  thumbnail: z.string().optional(), // base64 or URL to thumbnail
+  bitrate: z.number().positive().optional(),
+  codec: z.string().optional()
+});
+
+export type VideoMetadata = z.infer<typeof VideoMetadataSchema>;
+
+/**
+ * Video content data
+ */
+export interface VideoContentData {
+  filePath: string; // Local file path
+  streamingUrl: string; // Generated streaming URL
+  metadata: VideoMetadata;
+  uploadedAt: Date;
+  uploadedBy?: string | undefined;
+}
+
+/**
+ * Video upload options
+ */
+export interface VideoUploadOptions {
+  maxSizeBytes?: number; // Default: 500MB
+  allowedFormats?: string[]; // Default: ['mp4', 'webm', 'mov', 'avi']
+  generateThumbnail?: boolean; // Default: true
+  extractMetadata?: boolean; // Default: true
+  storageBasePath?: string; // Default: './storage/videos'
+}
+
+/**
+ * Video content type configuration
+ */
+export interface VideoContentTypeConfig {
+  baseType: 'video';
+  editor: {
+    component: string;
+    settings?: Record<string, unknown>;
+  };
+  storage: {
+    method: string;
+    settings?: Record<string, unknown>;
+  };
+  publishing: {
+    methods: string[];
+    defaultMethod?: string;
+    settings?: Record<string, unknown>;
+  };
+  uploadOptions?: VideoUploadOptions;
+  streamingBaseUrl?: string;
+}
+
+/**
+ * Result type for video operations
+ */
+export interface VideoContentResult<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: string;
+}
+
+/**
+ * Video content error codes
+ */
+export type VideoContentErrorCode =
+  | 'INVALID_FORMAT'
+  | 'FILE_TOO_LARGE'
+  | 'UPLOAD_FAILED'
+  | 'METADATA_EXTRACTION_FAILED'
+  | 'VALIDATION_FAILED';
+
+/**
+ * Video content error
+ */
+export interface VideoContentError {
+  code: VideoContentErrorCode;
+  message: string;
+  details?: unknown;
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "../../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "noEmit": false
+  },
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/*.test.tsx"
+  ]
+}