@frkntmbs/strapi-plugin-video-optimizer 1.0.0

package/server/src/constants.ts

@@ -0,0 +1,83 @@
+export const PLUGIN_ID = 'video-optimizer';
+
+export type OptimizationChoice = 'original' | 'global' | 'custom';
+export type VideoFormat = 'mp4' | 'webm';
+export type VideoCodec = 'h264' | 'vp9';
+export type AudioMode = 'keep' | 'remove' | 'compress';
+export type FfmpegPreset =
+  | 'ultrafast'
+  | 'superfast'
+  | 'veryfast'
+  | 'faster'
+  | 'fast'
+  | 'medium'
+  | 'slow'
+  | 'slower'
+  | 'veryslow';
+
+export type JobStatus = 'queued' | 'processing' | 'completed' | 'failed';
+
+export const OPTIMIZATION_CHOICES: OptimizationChoice[] = ['original', 'global', 'custom'];
+export const VIDEO_FORMATS: VideoFormat[] = ['mp4', 'webm'];
+export const VIDEO_CODECS: VideoCodec[] = ['h264', 'vp9'];
+export const AUDIO_MODES: AudioMode[] = ['keep', 'remove', 'compress'];
+export const FFMPEG_PRESETS: FfmpegPreset[] = [
+  'ultrafast',
+  'superfast',
+  'veryfast',
+  'faster',
+  'fast',
+  'medium',
+  'slow',
+  'slower',
+  'veryslow',
+];
+export const JOB_STATUSES: JobStatus[] = ['queued', 'processing', 'completed', 'failed'];
+
+export const MAX_CONCURRENT_JOBS_LIMIT = 32;
+export const MAX_FFMPEG_THREADS_LIMIT = 8;
+
+export const clampMaxConcurrentJobs = (value: number) =>
+  Math.min(MAX_CONCURRENT_JOBS_LIMIT, Math.max(1, Math.round(value)));
+
+export const clampMaxFfmpegThreads = (value: number) =>
+  Math.min(MAX_FFMPEG_THREADS_LIMIT, Math.max(1, Math.round(value)));
+
+export interface OptimizationSettings {
+  defaultFormat: VideoFormat;
+  videoCodec: VideoCodec;
+  crf: number;
+  preset: FfmpegPreset;
+  maxWidth: number;
+  maxHeight: number;
+  audioMode: AudioMode;
+  audioBitrate: string;
+}
+
+export interface ResolvedOptimization {
+  skip: boolean;
+  settings?: OptimizationSettings;
+}
+
+export interface VideoOptimizerJob {
+  id: string;
+  fileId: number;
+  fileName?: string;
+  fileHash?: string;
+  status: JobStatus;
+  stage: string;
+  progress: number;
+  settings?: OptimizationSettings;
+  error?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export const isVideoMime = (mime: unknown): boolean =>
+  typeof mime === 'string' && mime.startsWith('video/');
+
+export const codecForFormat = (format: VideoFormat): VideoCodec =>
+  format === 'webm' ? 'vp9' : 'h264';
+
+export const formatForCodec = (codec: VideoCodec): VideoFormat =>
+  codec === 'vp9' ? 'webm' : 'mp4';

package/server/src/controllers/index.ts

@@ -0,0 +1,7 @@
+import preference from './preference';
+import job from './job';
+
+export default {
+  preference,
+  job,
+};

package/server/src/controllers/job.ts

@@ -0,0 +1,102 @@
+import type { Core } from '@strapi/strapi';
+import {
+  OPTIMIZATION_CHOICES,
+  type OptimizationChoice,
+  type OptimizationSettings,
+} from '../constants';
+
+const isValidChoice = (choice: unknown): choice is OptimizationChoice =>
+  typeof choice === 'string' && OPTIMIZATION_CHOICES.includes(choice as OptimizationChoice);
+
+export default ({ strapi }: { strapi: Core.Strapi }) => ({
+  async getJob(ctx) {
+    const { id } = ctx.params;
+    const job = await strapi.plugin('video-optimizer').service('job-queue').getJob(id);
+
+    if (!job) {
+      return ctx.notFound('Job not found');
+    }
+
+    ctx.body = job;
+  },
+
+  async getJobsByFiles(ctx) {
+    const raw = ctx.query.fileIds;
+
+    if (!raw || typeof raw !== 'string') {
+      return ctx.badRequest('fileIds query parameter is required');
+    }
+
+    const fileIds = raw
+      .split(',')
+      .map((value) => Number(value.trim()))
+      .filter((value) => Number.isFinite(value) && value > 0);
+
+    const jobs = await strapi.plugin('video-optimizer').service('job-queue').getJobsByFileIds(fileIds);
+    ctx.body = { jobs };
+  },
+
+  async listActive(ctx) {
+    const jobs = await strapi.plugin('video-optimizer').service('job-queue').listActiveJobs();
+    ctx.body = { jobs };
+  },
+
+  async enqueueFile(ctx) {
+    const body = ctx.request.body as {
+      fileId?: number | string;
+      optimizationChoice?: OptimizationChoice;
+      optimizationCustom?: Partial<OptimizationSettings>;
+    };
+
+    const fileId = Number(body.fileId);
+
+    if (!Number.isFinite(fileId) || fileId <= 0) {
+      return ctx.badRequest('fileId is required');
+    }
+
+    const file = await strapi.db.query('plugin::upload.file').findOne({
+      where: { id: fileId },
+    });
+
+    if (!file) {
+      return ctx.notFound('File not found');
+    }
+
+    if (!file.mime || !String(file.mime).startsWith('video/')) {
+      return ctx.badRequest('Only video files can be optimized');
+    }
+
+    const preferenceService = strapi.plugin('video-optimizer').service('preference');
+    const resolved = await preferenceService.resolveOptimization({
+      optimizationChoice: isValidChoice(body.optimizationChoice)
+        ? body.optimizationChoice
+        : undefined,
+      optimizationCustom: body.optimizationCustom,
+      mime: String(file.mime),
+    });
+
+    if (resolved.skip || !resolved.settings) {
+      return ctx.badRequest('Optimization is disabled for the selected choice');
+    }
+
+    const job = await strapi.plugin('video-optimizer').service('job-queue').enqueue({
+      fileId,
+      settings: resolved.settings,
+      choice: isValidChoice(body.optimizationChoice) ? body.optimizationChoice : undefined,
+    });
+
+    ctx.body = { job };
+  },
+
+  async cancelForFile(ctx) {
+    const body = ctx.request.body as { fileId?: number | string };
+    const fileId = Number(body.fileId);
+
+    if (!Number.isFinite(fileId) || fileId <= 0) {
+      return ctx.badRequest('fileId is required');
+    }
+
+    await strapi.plugin('video-optimizer').service('job-queue').cancelJobsForFile(fileId);
+    ctx.body = { ok: true };
+  },
+});

package/server/src/controllers/preference.ts

@@ -0,0 +1,206 @@
+import type { Core } from '@strapi/strapi';
+import {
+  AUDIO_MODES,
+  FFMPEG_PRESETS,
+  OPTIMIZATION_CHOICES,
+  MAX_CONCURRENT_JOBS_LIMIT,
+  MAX_FFMPEG_THREADS_LIMIT,
+  VIDEO_CODECS,
+  VIDEO_FORMATS,
+  clampMaxConcurrentJobs,
+  clampMaxFfmpegThreads,
+  codecForFormat,
+  type AudioMode,
+  type FfmpegPreset,
+  type OptimizationChoice,
+  type OptimizationSettings,
+  type VideoCodec,
+  type VideoFormat,
+} from '../constants';
+
+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 isValidCustomSettings = (custom: unknown): custom is OptimizationSettings => {
+  if (!custom || typeof custom !== 'object') {
+    return false;
+  }
+
+  const value = custom as Partial<OptimizationSettings>;
+
+  return (
+    isValidFormat(value.defaultFormat) &&
+    isValidCodec(value.videoCodec) &&
+    typeof value.crf === 'number' &&
+    value.crf >= 0 &&
+    value.crf <= 51 &&
+    isValidPreset(value.preset) &&
+    typeof value.maxWidth === 'number' &&
+    value.maxWidth >= 1 &&
+    typeof value.maxHeight === 'number' &&
+    value.maxHeight >= 1 &&
+    isValidAudioMode(value.audioMode) &&
+    typeof value.audioBitrate === 'string'
+  );
+};
+
+export default ({ strapi }: { strapi: Core.Strapi }) => ({
+  async getDefaultMode(ctx) {
+    const settings = await strapi.plugin('video-optimizer').service('preference').getGlobalSettings();
+    ctx.body = {
+      defaultChoice: settings.defaultChoice,
+      defaultFormat: settings.defaultFormat,
+      videoCodec: settings.videoCodec,
+      crf: settings.crf,
+      preset: settings.preset,
+      maxWidth: settings.maxWidth,
+      maxHeight: settings.maxHeight,
+      audioMode: settings.audioMode,
+      audioBitrate: settings.audioBitrate,
+      maxConcurrentJobs: settings.maxConcurrentJobs,
+      maxFfmpegThreads: settings.maxFfmpegThreads,
+    };
+  },
+
+  async getPreference(ctx) {
+    const userId = ctx.state.user?.id;
+
+    if (!userId) {
+      return ctx.unauthorized();
+    }
+
+    const preferenceService = strapi.plugin('video-optimizer').service('preference');
+    const defaultFormat = await preferenceService.getUserPreference(userId);
+    const settings = await preferenceService.getGlobalSettings();
+
+    ctx.body = {
+      defaultFormat: defaultFormat ?? settings.defaultFormat,
+      defaultChoice: settings.defaultChoice,
+    };
+  },
+
+  async updatePreference(ctx) {
+    const userId = ctx.state.user?.id;
+
+    if (!userId) {
+      return ctx.unauthorized();
+    }
+
+    const { defaultFormat } = ctx.request.body ?? {};
+
+    if (!isValidFormat(defaultFormat)) {
+      return ctx.badRequest('Invalid video format');
+    }
+
+    await strapi.plugin('video-optimizer').service('preference').setUserPreference(userId, defaultFormat);
+
+    ctx.body = { defaultFormat };
+  },
+
+  async getSettings(ctx) {
+    const settings = await strapi.plugin('video-optimizer').service('preference').getGlobalSettings();
+    ctx.body = settings;
+  },
+
+  async updateSettings(ctx) {
+    const {
+      defaultChoice,
+      defaultFormat,
+      videoCodec,
+      crf,
+      preset,
+      maxWidth,
+      maxHeight,
+      audioMode,
+      audioBitrate,
+      maxConcurrentJobs,
+      maxFfmpegThreads,
+    } = ctx.request.body ?? {};
+
+    if (defaultChoice !== undefined && !isValidChoice(defaultChoice)) {
+      return ctx.badRequest('Invalid default choice');
+    }
+
+    if (defaultFormat !== undefined && !isValidFormat(defaultFormat)) {
+      return ctx.badRequest('Invalid default format');
+    }
+
+    if (videoCodec !== undefined && !isValidCodec(videoCodec)) {
+      return ctx.badRequest('Invalid video codec');
+    }
+
+    if (crf !== undefined && (crf < 0 || crf > 51)) {
+      return ctx.badRequest('Invalid CRF value');
+    }
+
+    if (preset !== undefined && !isValidPreset(preset)) {
+      return ctx.badRequest('Invalid preset');
+    }
+
+    if (maxWidth !== undefined && maxWidth < 1) {
+      return ctx.badRequest('Invalid max width');
+    }
+
+    if (maxHeight !== undefined && maxHeight < 1) {
+      return ctx.badRequest('Invalid max height');
+    }
+
+    if (audioMode !== undefined && !isValidAudioMode(audioMode)) {
+      return ctx.badRequest('Invalid audio mode');
+    }
+
+    if (
+      maxConcurrentJobs !== undefined &&
+      clampMaxConcurrentJobs(Number(maxConcurrentJobs)) !== Number(maxConcurrentJobs)
+    ) {
+      return ctx.badRequest(`maxConcurrentJobs must be between 1 and ${MAX_CONCURRENT_JOBS_LIMIT}`);
+    }
+
+    if (
+      maxFfmpegThreads !== undefined &&
+      clampMaxFfmpegThreads(Number(maxFfmpegThreads)) !== Number(maxFfmpegThreads)
+    ) {
+      return ctx.badRequest(`maxFfmpegThreads must be between 1 and ${MAX_FFMPEG_THREADS_LIMIT}`);
+    }
+
+    const payload: Record<string, unknown> = {};
+
+    if (defaultChoice !== undefined) payload.defaultChoice = defaultChoice;
+    if (defaultFormat !== undefined) {
+      payload.defaultFormat = defaultFormat;
+      if (videoCodec === undefined) {
+        payload.videoCodec = codecForFormat(defaultFormat);
+      }
+    }
+    if (videoCodec !== undefined) payload.videoCodec = videoCodec;
+    if (crf !== undefined) payload.crf = Number(crf);
+    if (preset !== undefined) payload.preset = preset;
+    if (maxWidth !== undefined) payload.maxWidth = Number(maxWidth);
+    if (maxHeight !== undefined) payload.maxHeight = Number(maxHeight);
+    if (audioMode !== undefined) payload.audioMode = audioMode;
+    if (audioBitrate !== undefined) payload.audioBitrate = String(audioBitrate);
+    if (maxConcurrentJobs !== undefined) payload.maxConcurrentJobs = Number(maxConcurrentJobs);
+    if (maxFfmpegThreads !== undefined) payload.maxFfmpegThreads = Number(maxFfmpegThreads);
+
+    await strapi.plugin('video-optimizer').service('preference').setGlobalSettings(payload);
+
+    if (maxConcurrentJobs !== undefined) {
+      void strapi.plugin('video-optimizer').service('job-queue').drainQueue();
+    }
+
+    const settings = await strapi.plugin('video-optimizer').service('preference').getGlobalSettings();
+    ctx.body = settings;
+  },
+});

package/server/src/index.ts

@@ -0,0 +1,15 @@
+import register from './register';
+import bootstrap from './bootstrap';
+import config from './config';
+import controllers from './controllers';
+import routes from './routes';
+import services from './services';
+
+export default {
+  register,
+  bootstrap,
+  config,
+  controllers,
+  routes,
+  services,
+};

package/server/src/register.ts

@@ -0,0 +1,19 @@
+import type { Core } from '@strapi/strapi';
+import { PLUGIN_ID } from './constants';
+
+export default async ({ strapi }: { strapi: Core.Strapi }) => {
+  await strapi.admin.services.permission.actionProvider.registerMany([
+    {
+      section: 'plugins',
+      displayName: 'Read Video Optimizer settings',
+      uid: 'settings.read',
+      pluginName: PLUGIN_ID,
+    },
+    {
+      section: 'plugins',
+      displayName: 'Update Video Optimizer settings',
+      uid: 'settings.update',
+      pluginName: PLUGIN_ID,
+    },
+  ]);
+};

package/server/src/routes/index.ts

@@ -0,0 +1,103 @@
+export default {
+  admin: {
+    type: 'admin',
+    routes: [
+      {
+        method: 'GET',
+        path: '/default-mode',
+        handler: 'preference.getDefaultMode',
+        config: {
+          policies: ['admin::isAuthenticatedAdmin'],
+        },
+      },
+      {
+        method: 'GET',
+        path: '/preference',
+        handler: 'preference.getPreference',
+        config: {
+          policies: ['admin::isAuthenticatedAdmin'],
+        },
+      },
+      {
+        method: 'PUT',
+        path: '/preference',
+        handler: 'preference.updatePreference',
+        config: {
+          policies: ['admin::isAuthenticatedAdmin'],
+        },
+      },
+      {
+        method: 'GET',
+        path: '/settings',
+        handler: 'preference.getSettings',
+        config: {
+          policies: [
+            'admin::isAuthenticatedAdmin',
+            {
+              name: 'admin::hasPermissions',
+              config: {
+                actions: ['plugin::video-optimizer.settings.read'],
+              },
+            },
+          ],
+        },
+      },
+      {
+        method: 'PUT',
+        path: '/settings',
+        handler: 'preference.updateSettings',
+        config: {
+          policies: [
+            'admin::isAuthenticatedAdmin',
+            {
+              name: 'admin::hasPermissions',
+              config: {
+                actions: ['plugin::video-optimizer.settings.update'],
+              },
+            },
+          ],
+        },
+      },
+      {
+        method: 'GET',
+        path: '/jobs/active',
+        handler: 'job.listActive',
+        config: {
+          policies: ['admin::isAuthenticatedAdmin'],
+        },
+      },
+      {
+        method: 'GET',
+        path: '/jobs/by-files',
+        handler: 'job.getJobsByFiles',
+        config: {
+          policies: ['admin::isAuthenticatedAdmin'],
+        },
+      },
+      {
+        method: 'POST',
+        path: '/jobs/enqueue',
+        handler: 'job.enqueueFile',
+        config: {
+          policies: ['admin::isAuthenticatedAdmin'],
+        },
+      },
+      {
+        method: 'POST',
+        path: '/jobs/cancel',
+        handler: 'job.cancelForFile',
+        config: {
+          policies: ['admin::isAuthenticatedAdmin'],
+        },
+      },
+      {
+        method: 'GET',
+        path: '/jobs/:id',
+        handler: 'job.getJob',
+        config: {
+          policies: ['admin::isAuthenticatedAdmin'],
+        },
+      },
+    ],
+  },
+};

package/server/src/services/index.ts

@@ -0,0 +1,9 @@
+import preference from './preference';
+import optimizer from './optimizer';
+import jobQueue from './job-queue';
+
+export default {
+  preference,
+  optimizer,
+  'job-queue': jobQueue,
+};