@frkntmbs/strapi-plugin-video-optimizer 1.0.0

package/server/src/services/optimizer.ts

@@ -0,0 +1,284 @@
+import fs from 'fs';
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { randomUUID } from 'crypto';
+import ffmpeg, { type FfmpegCommand } from 'fluent-ffmpeg';
+import ffmpegStatic from 'ffmpeg-static';
+import type { Core } from '@strapi/strapi';
+import { file as fileUtils } from '@strapi/utils';
+import type { OptimizationSettings } from '../constants';
+import { clampMaxFfmpegThreads } from '../constants';
+
+const { bytesToKbytes } = fileUtils;
+
+let ffmpegPathConfigured = false;
+
+const activeCommands = new Map<string, { command: FfmpegCommand; outputPath: string }>();
+
+const configureFfmpegPath = () => {
+  if (ffmpegPathConfigured) {
+    return;
+  }
+
+  if (ffmpegStatic) {
+    ffmpeg.setFfmpegPath(ffmpegStatic);
+    ffmpegPathConfigured = true;
+    return;
+  }
+
+  try {
+    const systemPath = execSync('which ffmpeg', { encoding: 'utf8' }).trim();
+    if (systemPath) {
+      ffmpeg.setFfmpegPath(systemPath);
+      ffmpegPathConfigured = true;
+    }
+  } catch {
+    // Fall through — fluent-ffmpeg will try PATH at runtime.
+  }
+};
+
+interface VideoMetadata {
+  width?: number;
+  height?: number;
+  duration?: number;
+}
+
+const probeVideo = (inputPath: string): Promise<VideoMetadata> =>
+  new Promise((resolve, reject) => {
+    ffmpeg.ffprobe(inputPath, (error, metadata) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      const videoStream = metadata.streams.find((stream) => stream.codec_type === 'video');
+
+      resolve({
+        width: videoStream?.width ?? undefined,
+        height: videoStream?.height ?? undefined,
+        duration: metadata.format.duration ?? undefined,
+      });
+    });
+  });
+
+const buildScaleFilter = (
+  settings: OptimizationSettings,
+  metadata: VideoMetadata,
+  resizeMode: 'exact' | 'fit-within' = 'exact'
+) => {
+  const targetWidth = settings.maxWidth;
+  const targetHeight = settings.maxHeight;
+  const sourceWidth = metadata.width ?? 0;
+  const sourceHeight = metadata.height ?? 0;
+
+  if (!targetWidth || !targetHeight || !sourceWidth || !sourceHeight) {
+    return null;
+  }
+
+  if (targetWidth === sourceWidth && targetHeight === sourceHeight) {
+    return null;
+  }
+
+  if (resizeMode === 'fit-within') {
+    if (sourceWidth <= targetWidth && sourceHeight <= targetHeight) {
+      return null;
+    }
+
+    return `scale='min(${targetWidth},iw)':'min(${targetHeight},ih)':force_original_aspect_ratio=decrease`;
+  }
+
+  return `scale=${targetWidth}:${targetHeight}`;
+};
+
+const buildVideoCodecOptions = (settings: OptimizationSettings, maxThreads: number) => {
+  if (settings.defaultFormat === 'webm' || settings.videoCodec === 'vp9') {
+    return {
+      videoCodec: 'libvpx-vp9',
+      outputOptions: [
+        '-crf',
+        String(settings.crf),
+        '-b:v',
+        '0',
+        '-row-mt',
+        maxThreads > 1 ? '1' : '0',
+        '-speed',
+        '4',
+      ],
+    };
+  }
+
+  return {
+    videoCodec: 'libx264',
+    outputOptions: [`-crf`, String(settings.crf), '-preset', settings.preset],
+  };
+};
+
+const buildThreadOptions = (maxThreads: number) => {
+  const threads = clampMaxFfmpegThreads(maxThreads);
+
+  return ['-threads', String(threads)];
+};
+
+const buildAudioOptions = (settings: OptimizationSettings) => {
+  if (settings.audioMode === 'remove') {
+    return { audioCodec: undefined as string | undefined, outputOptions: ['-an'] };
+  }
+
+  if (settings.audioMode === 'compress') {
+    const codec = settings.defaultFormat === 'webm' ? 'libopus' : 'aac';
+    return {
+      audioCodec: codec,
+      outputOptions: ['-b:a', settings.audioBitrate],
+    };
+  }
+
+  return { audioCodec: undefined as string | undefined, outputOptions: [] as string[] };
+};
+
+export interface ProcessOptions {
+  jobId: string;
+  inputPath: string;
+  settings: OptimizationSettings;
+  resizeMode?: 'exact' | 'fit-within';
+  onProgress?: (progress: number, stage: string) => void;
+}
+
+export interface ProcessResult {
+  outputPath: string;
+  width?: number;
+  height?: number;
+  sizeInBytes: number;
+  ext: string;
+  mime: string;
+  name: string;
+}
+
+export default ({ strapi }: { strapi: Core.Strapi }) => ({
+  cancel(jobId: string) {
+    const active = activeCommands.get(jobId);
+
+    if (!active) {
+      return false;
+    }
+
+    try {
+      active.command.kill('SIGKILL');
+    } catch {
+      // Ignore kill errors.
+    }
+
+    try {
+      if (fs.existsSync(active.outputPath)) {
+        fs.unlinkSync(active.outputPath);
+      }
+    } catch {
+      // Ignore cleanup errors.
+    }
+
+    activeCommands.delete(jobId);
+    return true;
+  },
+
+  async process({
+    jobId,
+    inputPath,
+    settings,
+    resizeMode = 'exact',
+    onProgress,
+  }: ProcessOptions): Promise<ProcessResult> {
+    configureFfmpegPath();
+
+    const metadata = await probeVideo(inputPath);
+    const outputExt = settings.defaultFormat === 'webm' ? '.webm' : '.mp4';
+    const outputMime = settings.defaultFormat === 'webm' ? 'video/webm' : 'video/mp4';
+    const outputPath = join(tmpdir(), `video-optimizer-${randomUUID()}${outputExt}`);
+
+    const scaleFilter = buildScaleFilter(settings, metadata, resizeMode);
+    const globalSettings = await strapi
+      .plugin('video-optimizer')
+      .service('preference')
+      .getGlobalSettings();
+    const maxThreads = globalSettings.maxFfmpegThreads;
+    const videoOptions = buildVideoCodecOptions(settings, maxThreads);
+    const audioOptions = buildAudioOptions(settings);
+    const threadOptions = buildThreadOptions(maxThreads);
+    const duration = metadata.duration ?? 0;
+
+    await new Promise<void>((resolve, reject) => {
+      let command = ffmpeg(inputPath);
+
+      if (scaleFilter) {
+        command = command.videoFilters(scaleFilter);
+      }
+
+      command = command
+        .format(settings.defaultFormat)
+        .videoCodec(videoOptions.videoCodec)
+        .outputOptions([
+          ...threadOptions,
+          ...videoOptions.outputOptions,
+          ...audioOptions.outputOptions,
+        ]);
+
+      if (audioOptions.audioCodec) {
+        command = command.audioCodec(audioOptions.audioCodec);
+      }
+
+      activeCommands.set(jobId, { command, outputPath });
+
+      command
+        .on('start', () => {
+          onProgress?.(5, 'encoding');
+        })
+        .on('progress', (progress) => {
+          if (!duration || !progress.timemark) {
+            onProgress?.(50, 'encoding');
+            return;
+          }
+
+          const parts = progress.timemark.split(':').map(Number);
+          const seconds =
+            (parts[0] ?? 0) * 3600 + (parts[1] ?? 0) * 60 + (parts[2] ?? 0);
+          const ratio = Math.min(1, seconds / duration);
+          onProgress?.(Math.round(5 + ratio * 90), 'encoding');
+        })
+        .on('end', () => {
+          onProgress?.(98, 'finalizing');
+          resolve();
+        })
+        .on('error', (error) => {
+          reject(error);
+        })
+        .save(outputPath);
+    }).finally(() => {
+      activeCommands.delete(jobId);
+    });
+
+    const outputMetadata = await probeVideo(outputPath);
+    const stats = fs.statSync(outputPath);
+    const baseName = inputPath.split('/').pop()?.replace(/\.[^.]+$/, '') ?? 'video';
+
+    return {
+      outputPath,
+      width: outputMetadata.width,
+      height: outputMetadata.height,
+      sizeInBytes: stats.size,
+      ext: outputExt,
+      mime: outputMime,
+      name: `${baseName}${outputExt}`,
+    };
+  },
+
+  async cleanup(path: string) {
+    try {
+      if (fs.existsSync(path)) {
+        fs.unlinkSync(path);
+      }
+    } catch {
+      // Ignore cleanup errors.
+    }
+  },
+
+  bytesToKbytes,
+});

package/server/src/services/preference.ts

@@ -0,0 +1,172 @@
+import type { Core } from '@strapi/strapi';
+import {
+  AUDIO_MODES,
+  FFMPEG_PRESETS,
+  OPTIMIZATION_CHOICES,
+  PLUGIN_ID,
+  VIDEO_CODECS,
+  VIDEO_FORMATS,
+  clampMaxConcurrentJobs,
+  codecForFormat,
+  type AudioMode,
+  type FfmpegPreset,
+  type OptimizationChoice,
+  type OptimizationSettings,
+  type ResolvedOptimization,
+  type VideoCodec,
+  type VideoFormat,
+} from '../constants';
+import type { PluginConfig } from '../config';
+import { DEFAULT_PLUGIN_CONFIG, normalizePluginConfig } from '../config/defaults';
+
+const GLOBAL_SETTINGS_KEY = 'global-settings';
+const JOBS_STORE_KEY = 'jobs';
+
+const userPreferenceKey = (userId: number) => `user-pref-${userId}`;
+
+const isValidChoice = (choice: unknown): choice is OptimizationChoice =>
+  typeof choice === 'string' && OPTIMIZATION_CHOICES.includes(choice as OptimizationChoice);
+
+const isValidFormat = (format: unknown): format is VideoFormat =>
+  typeof format === 'string' && VIDEO_FORMATS.includes(format as VideoFormat);
+
+const isValidCodec = (codec: unknown): codec is VideoCodec =>
+  typeof codec === 'string' && VIDEO_CODECS.includes(codec as VideoCodec);
+
+const isValidAudioMode = (mode: unknown): mode is AudioMode =>
+  typeof mode === 'string' && AUDIO_MODES.includes(mode as AudioMode);
+
+const isValidPreset = (preset: unknown): preset is FfmpegPreset =>
+  typeof preset === 'string' && FFMPEG_PRESETS.includes(preset as FfmpegPreset);
+
+const buildSettings = (
+  source: Partial<OptimizationSettings> | PluginConfig
+): OptimizationSettings => {
+  const defaultFormat = isValidFormat(source.defaultFormat) ? source.defaultFormat : 'mp4';
+  const videoCodec = isValidCodec(source.videoCodec)
+    ? source.videoCodec
+    : codecForFormat(defaultFormat);
+
+  return {
+    defaultFormat,
+    videoCodec,
+    crf: source.crf ?? 23,
+    preset: isValidPreset(source.preset) ? source.preset : 'medium',
+    maxWidth: source.maxWidth ?? 1920,
+    maxHeight: source.maxHeight ?? 1080,
+    audioMode: isValidAudioMode(source.audioMode) ? source.audioMode : 'compress',
+    audioBitrate: source.audioBitrate ?? '128k',
+  };
+};
+
+export default ({ strapi }: { strapi: Core.Strapi }) => ({
+  async getUserPreference(userId: number): Promise<VideoFormat | null> {
+    const stored = await strapi.store({
+      type: 'plugin',
+      name: PLUGIN_ID,
+      key: userPreferenceKey(userId),
+    }).get<{ defaultFormat?: VideoFormat }>();
+
+    if (stored?.defaultFormat && isValidFormat(stored.defaultFormat)) {
+      return stored.defaultFormat;
+    }
+
+    return null;
+  },
+
+  async setUserPreference(userId: number, defaultFormat: VideoFormat) {
+    await strapi.store({
+      type: 'plugin',
+      name: PLUGIN_ID,
+      key: userPreferenceKey(userId),
+    }).set({ value: { defaultFormat } });
+  },
+
+  async getGlobalSettings(): Promise<PluginConfig> {
+    const pluginConfig = strapi.plugin(PLUGIN_ID).config as Partial<PluginConfig>;
+    const stored = await strapi.store({
+      type: 'plugin',
+      name: PLUGIN_ID,
+      key: GLOBAL_SETTINGS_KEY,
+    }).get<Partial<PluginConfig>>();
+
+    return normalizePluginConfig(DEFAULT_PLUGIN_CONFIG, pluginConfig, stored ?? undefined);
+  },
+
+  async ensureGlobalSettingsDefaults() {
+    const store = strapi.store({
+      type: 'plugin',
+      name: PLUGIN_ID,
+      key: GLOBAL_SETTINGS_KEY,
+    });
+    const stored = await store.get<Partial<PluginConfig>>();
+
+    if (!stored || Object.keys(stored).length === 0) {
+      const pluginConfig = strapi.plugin(PLUGIN_ID).config as Partial<PluginConfig>;
+      const defaults = normalizePluginConfig(DEFAULT_PLUGIN_CONFIG, pluginConfig);
+      await store.set({ value: defaults });
+    }
+  },
+
+  async setGlobalSettings(settings: Partial<PluginConfig>) {
+    const current = await this.getGlobalSettings();
+    const next = { ...current, ...settings };
+
+    await strapi.store({
+      type: 'plugin',
+      name: PLUGIN_ID,
+      key: GLOBAL_SETTINGS_KEY,
+    }).set({ value: next });
+  },
+
+  async resolveOptimization(file: {
+    optimizationChoice?: OptimizationChoice;
+    optimizationCustom?: Partial<OptimizationSettings>;
+    mime?: string;
+  }): Promise<ResolvedOptimization> {
+    const global = await this.getGlobalSettings();
+
+    if (!file.mime || !file.mime.startsWith('video/')) {
+      return { skip: true };
+    }
+
+    const choice = isValidChoice(file.optimizationChoice)
+      ? file.optimizationChoice
+      : global.defaultChoice;
+
+    if (choice === 'original') {
+      return { skip: true };
+    }
+
+    if (choice === 'global') {
+      return {
+        skip: false,
+        settings: buildSettings(global),
+      };
+    }
+
+    const custom = file.optimizationCustom ?? {};
+
+    return {
+      skip: false,
+      settings: buildSettings({
+        defaultFormat: custom.defaultFormat ?? global.defaultFormat,
+        videoCodec: custom.videoCodec ?? global.videoCodec,
+        crf: custom.crf ?? global.crf,
+        preset: custom.preset ?? global.preset,
+        maxWidth: custom.maxWidth ?? global.maxWidth,
+        maxHeight: custom.maxHeight ?? global.maxHeight,
+        audioMode: custom.audioMode ?? global.audioMode,
+        audioBitrate: custom.audioBitrate ?? global.audioBitrate,
+      }),
+    };
+  },
+
+  getJobsStore() {
+    return strapi.store({
+      type: 'plugin',
+      name: PLUGIN_ID,
+      key: JOBS_STORE_KEY,
+    });
+  },
+});

package/server/src/utils/request-context.ts

@@ -0,0 +1,7 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+interface UploadRequestContext {
+  userId?: number;
+}
+
+export const uploadContext = new AsyncLocalStorage<UploadRequestContext>();

package/server/src/utils/upload-preferences-context.ts

@@ -0,0 +1,202 @@
+import { AsyncLocalStorage } from 'async_hooks';
+import type { OptimizationChoice, OptimizationSettings } from '../constants';
+
+export interface UploadFilePreference {
+  assetId?: string;
+  fileName: string;
+  preference: {
+    choice: OptimizationChoice;
+    custom?: OptimizationSettings;
+  };
+}
+
+interface OptimizerUploadContext {
+  preferences: UploadFilePreference[];
+  nextIndex: number;
+}
+
+export const optimizerUploadContext = new AsyncLocalStorage<OptimizerUploadContext>();
+
+let fallbackContext: OptimizerUploadContext | null = null;
+
+let batchPreferences: UploadFilePreference[] | null = null;
+
+export const registerUploadBatchPreferences = (preferences: UploadFilePreference[]) => {
+  batchPreferences = preferences;
+};
+
+export const clearUploadBatchPreferences = () => {
+  batchPreferences = null;
+};
+
+const normalizeFileName = (value: string) => value.trim().toLowerCase();
+
+export const resolveUploadBatchPreference = (fileName: string, assetId?: string) => {
+  if (!batchPreferences?.length) {
+    return null;
+  }
+
+  const normalizedTarget = normalizeFileName(fileName);
+
+  const match = batchPreferences.find((entry) => {
+    if (assetId && entry.assetId === assetId) {
+      return true;
+    }
+
+    return normalizeFileName(entry.fileName) === normalizedTarget;
+  });
+
+  return match?.preference ?? null;
+};
+
+export const createUploadContext = (preferences: UploadFilePreference[]): OptimizerUploadContext => ({
+  preferences,
+  nextIndex: 0,
+});
+
+export const setFallbackUploadPreferences = (preferences: UploadFilePreference[]) => {
+  fallbackContext = createUploadContext(preferences);
+};
+
+export const clearFallbackUploadPreferences = () => {
+  fallbackContext = null;
+};
+
+const getActivePreferences = () => {
+  const store = optimizerUploadContext.getStore();
+
+  if (store?.preferences.length) {
+    return store;
+  }
+
+  return fallbackContext;
+};
+
+export const parseUploadPreferences = (body: Record<string, unknown> | undefined) => {
+  const raw = body?.videoOptimizerPreferences;
+
+  if (!raw) {
+    return [] as UploadFilePreference[];
+  }
+
+  if (typeof raw === 'string') {
+    try {
+      const parsed = JSON.parse(raw) as UploadFilePreference[];
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+
+  return Array.isArray(raw) ? (raw as UploadFilePreference[]) : [];
+};
+
+export const findUploadPreference = (fileName: string, assetId?: string) => {
+  const store = getActivePreferences();
+
+  if (!store) {
+    return null;
+  }
+
+  const match = store.preferences.find((entry) => {
+    if (assetId && entry.assetId === assetId) {
+      return true;
+    }
+
+    return entry.fileName === fileName;
+  });
+
+  return match?.preference ?? null;
+};
+
+export const consumeUploadPreference = (fileName: string, assetId?: string) => {
+  const batchPreference = resolveUploadBatchPreference(fileName, assetId);
+
+  if (batchPreference) {
+    return batchPreference;
+  }
+
+  const store = getActivePreferences();
+
+  if (!store) {
+    return null;
+  }
+
+  const matched = store.preferences.find((entry) => {
+    if (assetId && entry.assetId === assetId) {
+      return true;
+    }
+
+    return normalizeFileName(entry.fileName) === normalizeFileName(fileName);
+  });
+
+  if (matched) {
+    return matched.preference;
+  }
+
+  const indexed = store.preferences[store.nextIndex];
+
+  if (indexed) {
+    store.nextIndex += 1;
+    return indexed.preference;
+  }
+
+  return null;
+};
+
+const UPLOAD_ROUTE_SUFFIXES = ['/upload', '/upload/unstable/upload-file'];
+
+export const isUploadRoute = (method: string, path: string) => {
+  if (method.toUpperCase() !== 'POST') {
+    return false;
+  }
+
+  const normalizedPath = path.replace(/\/+$/, '') || '/';
+
+  return UPLOAD_ROUTE_SUFFIXES.some(
+    (suffix) => normalizedPath === suffix || normalizedPath.endsWith(suffix)
+  );
+};
+
+interface StashedPreference {
+  choice: OptimizationChoice;
+  custom?: OptimizationSettings;
+}
+
+const pendingPreferencesByKey = new Map<string, StashedPreference>();
+
+const buildPreferenceKey = (fileName: string, assetId?: string) =>
+  assetId ? `asset:${assetId}` : `file:${fileName}`;
+
+export const stashUploadPreference = (
+  fileName: string,
+  assetId: string | undefined,
+  preference: StashedPreference
+) => {
+  pendingPreferencesByKey.set(buildPreferenceKey(fileName, assetId), preference);
+
+  if (assetId) {
+    pendingPreferencesByKey.set(buildPreferenceKey(fileName), preference);
+  }
+
+  pendingPreferencesByKey.set(`file:${fileName}`, preference);
+};
+
+export const takePendingPreference = (fileName: string, assetId?: string) => {
+  const keys = [
+    assetId ? buildPreferenceKey(fileName, assetId) : null,
+    buildPreferenceKey(fileName),
+    `file:${fileName}`,
+  ].filter(Boolean) as string[];
+
+  for (const key of keys) {
+    const preference = pendingPreferencesByKey.get(key);
+
+    if (preference) {
+      pendingPreferencesByKey.delete(key);
+      return preference;
+    }
+  }
+
+  return null;
+};

package/server/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "@strapi/typescript-utils/tsconfigs/server",
+  "include": ["./src"],
+  "compilerOptions": {
+    "rootDir": "../",
+    "baseUrl": "."
+  }
+}

package/strapi-admin.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { register } = require('esbuild-register/dist/node');
+const { unregister } = register({ extensions: ['.js', '.jsx', '.ts', '.tsx'] });
+const admin = require('./admin/src/index.ts');
+unregister();
+module.exports = admin.default || admin;

package/strapi-server.js

@@ -0,0 +1,7 @@
+'use strict';
+
+const { register } = require('esbuild-register/dist/node');
+const { unregister } = register({ extensions: ['.js', '.ts'] });
+const server = require('./server/src/index.ts');
+unregister();
+module.exports = server.default || server;