@kimjansheden/payload-video-processor 0.1.1

package/dist/cli/start-worker.js

@@ -0,0 +1,678 @@
+#!/usr/bin/env node
+import { z } from 'zod';
+import ffmpeg2 from 'fluent-ffmpeg';
+import ffprobeStatic from 'ffprobe-static';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import payload from 'payload';
+import { mkdir, stat } from 'fs/promises';
+import ffmpegStatic from 'ffmpeg-static';
+import { Worker } from 'bullmq';
+import IORedis from 'ioredis';
+import fs from 'fs';
+import dotenv from 'dotenv';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var presetSchema, videoPluginOptionsSchema, ensureOptions;
+var init_options = __esm({
+  "src/options.ts"() {
+    presetSchema = z.object({
+      args: z.array(z.string()),
+      label: z.string().optional(),
+      enableCrop: z.boolean().optional()
+    });
+    videoPluginOptionsSchema = z.object({
+      presets: z.record(presetSchema).refine((value) => Object.keys(value).length > 0, {
+        message: "At least one preset must be defined."
+      }),
+      queue: z.object({
+        name: z.string().min(1).optional(),
+        redisUrl: z.string().optional(),
+        concurrency: z.number().int().positive().optional()
+      }).optional(),
+      access: z.any().optional(),
+      resolvePaths: z.any().optional()
+    });
+    ensureOptions = (options) => videoPluginOptionsSchema.parse(options);
+  }
+});
+var cropSchema, videoJobSchema;
+var init_job_types = __esm({
+  "src/queue/job.types.ts"() {
+    cropSchema = z.object({
+      x: z.number().min(0).max(1),
+      y: z.number().min(0).max(1),
+      width: z.number().positive().max(1),
+      height: z.number().positive().max(1)
+    }).refine((value) => value.width > 0 && value.height > 0, {
+      message: "Crop width and height must be > 0"
+    });
+    videoJobSchema = z.object({
+      collection: z.string().min(1),
+      id: z.union([z.string(), z.number()]).transform((value) => value.toString()),
+      preset: z.string().min(1),
+      crop: cropSchema.optional()
+    });
+  }
+});
+
+// src/ffmpeg/args.ts
+var FASTSTART_FLAGS, CRF_FLAG, hasCrf, hasFaststart, extractFilters, clamp, buildCropFilter, buildFfmpegArgs;
+var init_args = __esm({
+  "src/ffmpeg/args.ts"() {
+    FASTSTART_FLAGS = ["-movflags", "+faststart"];
+    CRF_FLAG = "-crf";
+    hasCrf = (args) => {
+      for (let i = 0; i < args.length; i += 1) {
+        if (args[i] === CRF_FLAG) {
+          return true;
+        }
+      }
+      return false;
+    };
+    hasFaststart = (args) => {
+      for (let i = 0; i < args.length; i += 1) {
+        if (args[i] === "-movflags") {
+          const value = args[i + 1];
+          if (typeof value === "string" && value.includes("faststart")) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    extractFilters = (args) => {
+      const rest = [];
+      const filters = [];
+      for (let i = 0; i < args.length; i += 1) {
+        const current = args[i];
+        if (current === "-vf" || current === "-filter:v") {
+          const value = args[i + 1];
+          if (typeof value === "string") {
+            filters.push(value);
+          }
+          i += 1;
+        } else {
+          rest.push(current);
+        }
+      }
+      return { rest, filters };
+    };
+    clamp = (value, min, max) => {
+      if (Number.isNaN(value)) return min;
+      if (value < min) return min;
+      if (value > max) return max;
+      return value;
+    };
+    buildCropFilter = (crop, dimensions) => {
+      if (!dimensions?.width || !dimensions?.height) return void 0;
+      const cropWidth = Math.max(1, Math.round(dimensions.width * crop.width));
+      const cropHeight = Math.max(1, Math.round(dimensions.height * crop.height));
+      const maxX = Math.max(0, dimensions.width - cropWidth);
+      const maxY = Math.max(0, dimensions.height - cropHeight);
+      const x = clamp(Math.round(dimensions.width * crop.x), 0, maxX);
+      const y = clamp(Math.round(dimensions.height * crop.y), 0, maxY);
+      return `crop=${cropWidth}:${cropHeight}:${x}:${y}`;
+    };
+    buildFfmpegArgs = ({
+      presetArgs,
+      crop,
+      dimensions,
+      defaultCrf = 24
+    }) => {
+      const args = [...presetArgs];
+      const { rest, filters } = extractFilters(args);
+      if (!hasCrf(rest)) {
+        rest.push(CRF_FLAG, String(defaultCrf));
+      }
+      if (!hasFaststart(rest)) {
+        rest.push(...FASTSTART_FLAGS);
+      }
+      if (crop) {
+        const cropFilter = buildCropFilter(crop, dimensions);
+        if (cropFilter) {
+          filters.push(cropFilter);
+        }
+      }
+      if (filters.length > 0) {
+        rest.push("-vf", filters.join(","));
+      }
+      return {
+        globalOptions: ["-y"],
+        outputOptions: rest
+      };
+    };
+  }
+});
+var probeVideo;
+var init_probe = __esm({
+  "src/ffmpeg/probe.ts"() {
+    if (ffprobeStatic.path) {
+      ffmpeg2.setFfprobePath(ffprobeStatic.path);
+    }
+    probeVideo = async (filePath) => new Promise((resolve, reject) => {
+      ffmpeg2.ffprobe(filePath, (error, metadata) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        const videoStream = metadata.streams.find(
+          (stream) => stream.codec_type === "video"
+        );
+        const width = videoStream?.width;
+        const height = videoStream?.height;
+        const durationRaw = videoStream?.duration ?? metadata.format?.duration;
+        const duration = typeof durationRaw !== "undefined" ? Number(durationRaw) : void 0;
+        const bitrateRaw = videoStream?.bit_rate ?? metadata.format?.bit_rate;
+        const bitrate = typeof bitrateRaw !== "undefined" ? Number(bitrateRaw) : void 0;
+        resolve({
+          width: width ?? void 0,
+          height: height ?? void 0,
+          duration: Number.isNaN(duration) ? void 0 : duration,
+          bitrate: Number.isNaN(bitrate) ? void 0 : bitrate
+        });
+      });
+    });
+  }
+});
+var normalizeUrl, defaultResolvePaths, buildStoredPath, buildWritePath;
+var init_paths = __esm({
+  "src/utils/paths.ts"() {
+    normalizeUrl = (input, filename) => {
+      if (!input) return filename ?? "";
+      const parts = input.split("?");
+      const base = parts[0];
+      const query = parts[1] ? `?${parts.slice(1).join("?")}` : "";
+      const lastSlash = base.lastIndexOf("/");
+      if (lastSlash === -1) {
+        return filename ?? base;
+      }
+      const prefix = base.slice(0, lastSlash);
+      const sanitized = filename ?? base.slice(lastSlash + 1);
+      return `${prefix}/${sanitized}${query}`;
+    };
+    defaultResolvePaths = ({
+      original,
+      presetName
+    }) => {
+      const originalFilename = original.filename ?? path.basename(original.path);
+      const extension = path.extname(originalFilename) || path.extname(original.path) || ".mp4";
+      const baseName = path.basename(originalFilename, extension);
+      const variantFilename = `${baseName}_${presetName}${extension}`;
+      const originalDir = path.dirname(original.path);
+      const absoluteDir = path.isAbsolute(original.path) ? originalDir : path.join(process.cwd(), originalDir);
+      const url = normalizeUrl(original.url, variantFilename);
+      return {
+        dir: absoluteDir,
+        filename: variantFilename,
+        url
+      };
+    };
+    buildStoredPath = (originalPath, variantFilename) => {
+      const originalDir = path.dirname(originalPath);
+      return path.join(originalDir, variantFilename);
+    };
+    buildWritePath = (dir, filename) => path.join(dir, filename);
+  }
+});
+var cachedClient, localInitialized, normalizeConfigPath, buildAuthHeaders, initLocalPayload, initRestClient, getPayloadClient;
+var init_payload = __esm({
+  "src/utils/payload.ts"() {
+    cachedClient = null;
+    localInitialized = false;
+    normalizeConfigPath = (configPath) => {
+      if (configPath.startsWith("file://")) return configPath;
+      return pathToFileURL(path.resolve(configPath)).href;
+    };
+    buildAuthHeaders = (token) => ({
+      Authorization: `Bearer ${token}`,
+      "X-Payload-API-Key": token
+    });
+    initLocalPayload = async () => {
+      const secret = process.env.PAYLOAD_SECRET;
+      const mongoURL = process.env.MONGODB_URI;
+      if (!secret || !mongoURL) {
+        return null;
+      }
+      try {
+        const configPath = process.env.PAYLOAD_CONFIG_PATH;
+        let configModule;
+        if (configPath) {
+          const imported = await import(normalizeConfigPath(configPath));
+          configModule = imported?.default ?? imported;
+        }
+        if (!localInitialized) {
+          const initOptions = {
+            secret,
+            mongoURL,
+            local: true
+          };
+          if (configModule) {
+            initOptions.config = configModule;
+          }
+          await payload.init(initOptions);
+          localInitialized = true;
+        }
+        const instance = payload;
+        return {
+          findByID: ({ collection, id }) => instance.findByID({
+            collection,
+            id
+          }),
+          update: ({ collection, id, data }) => instance.update({
+            collection,
+            id,
+            data
+          }),
+          getCollectionConfig: (slug) => instance.collections?.[slug]?.config
+        };
+      } catch (error) {
+        console.warn(
+          "[video-processor] Failed to initialize Payload locally, falling back to REST client.",
+          error
+        );
+        return null;
+      }
+    };
+    initRestClient = async () => {
+      const baseUrl = process.env.PAYLOAD_REST_URL || process.env.PAYLOAD_PUBLIC_URL || process.env.PAYLOAD_SERVER_URL;
+      const token = process.env.PAYLOAD_ADMIN_TOKEN;
+      if (!baseUrl || !token) {
+        throw new Error(
+          "Unable to establish Payload REST client. Provide PAYLOAD_REST_URL (or PAYLOAD_PUBLIC_URL) and PAYLOAD_ADMIN_TOKEN."
+        );
+      }
+      const base = baseUrl.replace(/\/$/, "");
+      const headers = buildAuthHeaders(token);
+      const request = async (url, init) => {
+        const response = await fetch(url, {
+          ...init,
+          headers: {
+            "Content-Type": "application/json",
+            Accept: "application/json",
+            ...headers,
+            ...init?.headers
+          }
+        });
+        if (!response.ok) {
+          const text = await response.text();
+          throw new Error(
+            `Payload REST request failed (${response.status}): ${text}`
+          );
+        }
+        return await response.json();
+      };
+      return {
+        findByID: async ({ collection, id }) => {
+          const result = await request(
+            `${base}/api/${collection}/${id}`
+          );
+          return result.doc ?? result;
+        },
+        update: async ({ collection, id, data }) => {
+          const result = await request(
+            `${base}/api/${collection}/${id}`,
+            {
+              method: "PATCH",
+              body: JSON.stringify(data)
+            }
+          );
+          return result.doc ?? result;
+        }
+      };
+    };
+    getPayloadClient = async () => {
+      if (cachedClient) return cachedClient;
+      const localClient = await initLocalPayload();
+      if (localClient) {
+        cachedClient = localClient;
+        return localClient;
+      }
+      const restClient = await initRestClient();
+      cachedClient = restClient;
+      return restClient;
+    };
+  }
+});
+
+// src/queue/createWorker.ts
+var createWorker_exports = {};
+__export(createWorker_exports, {
+  createWorker: () => createWorker
+});
+var envFfmpegPath, ffmpegBinary, createWorker;
+var init_createWorker = __esm({
+  "src/queue/createWorker.ts"() {
+    init_options();
+    init_job_types();
+    init_args();
+    init_probe();
+    init_paths();
+    init_payload();
+    envFfmpegPath = process.env.FFMPEG_BIN?.trim();
+    ffmpegBinary = envFfmpegPath && envFfmpegPath.length > 0 ? envFfmpegPath : typeof ffmpegStatic === "string" ? ffmpegStatic : null;
+    if (ffmpegBinary) {
+      ffmpeg2.setFfmpegPath(ffmpegBinary);
+    }
+    if (ffprobeStatic.path) {
+      ffmpeg2.setFfprobePath(ffprobeStatic.path);
+    }
+    createWorker = async (rawOptions) => {
+      const options = ensureOptions(rawOptions);
+      const presets = options.presets;
+      const queueName = options.queue?.name ?? "video-transcode";
+      const concurrency = options.queue?.concurrency ?? 1;
+      const redisUrl = options.queue?.redisUrl ?? process.env.REDIS_URL;
+      const connection = redisUrl ? new IORedis(redisUrl, { maxRetriesPerRequest: null }) : new IORedis({ maxRetriesPerRequest: null });
+      const worker = new Worker(
+        queueName,
+        async (job) => {
+          const parsed = videoJobSchema.parse(job.data);
+          const preset = presets[parsed.preset];
+          if (!preset) {
+            throw new Error(`Unknown preset ${parsed.preset}`);
+          }
+          job.updateProgress(5);
+          const client = await getPayloadClient();
+          const document = await client.findByID({
+            collection: parsed.collection,
+            id: parsed.id
+          });
+          if (!document) {
+            throw new Error(
+              `Document ${parsed.id} in collection ${parsed.collection} not found`
+            );
+          }
+          const originalPath = document?.path;
+          const filename = document?.filename;
+          const url = document?.url;
+          if (!originalPath) {
+            throw new Error("Source document does not expose a `path` property.");
+          }
+          const absoluteInputPath = path.isAbsolute(originalPath) ? originalPath : path.join(process.cwd(), originalPath);
+          const inputMetadata = await probeVideo(absoluteInputPath);
+          job.updateProgress(15);
+          const resolvePaths = options.resolvePaths ?? defaultResolvePaths;
+          const collectionConfig = client.getCollectionConfig?.(parsed.collection) ?? null;
+          const resolved = resolvePaths({
+            doc: document,
+            collection: collectionConfig,
+            collectionSlug: parsed.collection,
+            original: {
+              filename: filename ?? path.basename(originalPath),
+              path: originalPath,
+              url: url ?? ""
+            },
+            presetName: parsed.preset
+          });
+          const writeDir = resolved.dir;
+          const writeFilename = resolved.filename;
+          const targetUrl = resolved.url;
+          const writePath = buildWritePath(writeDir, writeFilename);
+          await mkdir(writeDir, { recursive: true });
+          const { globalOptions, outputOptions } = buildFfmpegArgs({
+            presetArgs: preset.args,
+            crop: parsed.crop,
+            dimensions: {
+              width: inputMetadata.width,
+              height: inputMetadata.height
+            }
+          });
+          await new Promise((resolve, reject) => {
+            const command = ffmpeg2(absoluteInputPath);
+            globalOptions.forEach((option) => command.addOption(option));
+            command.outputOptions(outputOptions);
+            command.output(writePath);
+            command.on("progress", (progress) => {
+              if (typeof progress.percent === "number") {
+                const bounded = Math.min(95, 15 + progress.percent * 0.7);
+                void job.updateProgress(bounded);
+              }
+            });
+            command.on("end", () => resolve());
+            command.on("error", (error) => reject(error));
+            command.run();
+          });
+          const fileStats = await stat(writePath);
+          const outputMetadata = await probeVideo(writePath);
+          const storedPath = buildStoredPath(originalPath, writeFilename);
+          const variant = {
+            preset: parsed.preset,
+            url: targetUrl,
+            path: storedPath,
+            size: fileStats.size,
+            duration: outputMetadata.duration ?? inputMetadata.duration,
+            width: outputMetadata.width ?? inputMetadata.width,
+            height: outputMetadata.height ?? inputMetadata.height,
+            bitrate: outputMetadata.bitrate,
+            createdAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+          const existingVariants = Array.isArray(document.variants) ? document.variants : [];
+          const nextVariants = [
+            ...existingVariants.filter((item) => item?.preset !== variant.preset),
+            variant
+          ];
+          await client.update({
+            collection: parsed.collection,
+            id: parsed.id,
+            data: {
+              variants: nextVariants
+            }
+          });
+          await job.updateProgress(100);
+          return variant;
+        },
+        {
+          connection,
+          concurrency
+        }
+      );
+      worker.on("failed", (job, error) => {
+        console.error(`[video-processor] Job ${job?.id} failed`, error);
+      });
+      worker.on("completed", (job) => {
+        console.log(`[video-processor] Job ${job.id} completed`);
+      });
+      await worker.waitUntilReady();
+      console.log(`[video-processor] Worker listening on queue ${queueName}`);
+      const shutdown = async () => {
+        await worker.close();
+        await connection.quit();
+      };
+      process.once("SIGINT", () => {
+        void shutdown().then(() => process.exit(0));
+      });
+      process.once("SIGTERM", () => {
+        void shutdown().then(() => process.exit(0));
+      });
+      return worker;
+    };
+  }
+});
+var helpText = `
+payload-video-worker
+
+Start the Payload video processing worker using the same options you pass to the plugin.
+
+Usage:
+  payload-video-worker --config ./dist-config/videoPluginOptions.js [options]
+
+Options:
+  -c, --config <path>          Path to a module exporting the worker options (defaults to PAYLOAD_VIDEO_WORKER_CONFIG)
+  -p, --payload-config <path>  Path to a Payload config file for local execution (sets PAYLOAD_CONFIG_PATH)
+  -s, --static-dir <path>      Override STATIC_DIR before starting the worker
+  -e, --env <path>             Load additional .env file (can be repeated)
+      --no-default-env         Skip automatic loading of .env, .env.local, .env.development, .env.production
+  -h, --help                   Show this message and exit
+`.trim();
+var parseArgs = (argv) => {
+  const options = {
+    envFiles: [],
+    loadDefaultEnv: true
+  };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    switch (arg) {
+      case "-c":
+      case "--config": {
+        const next = argv[index + 1];
+        if (!next) {
+          throw new Error("Missing value for --config option.");
+        }
+        options.configPath = next;
+        index += 1;
+        break;
+      }
+      case "-p":
+      case "--payload-config": {
+        const next = argv[index + 1];
+        if (!next) {
+          throw new Error("Missing value for --payload-config option.");
+        }
+        options.payloadConfigPath = next;
+        index += 1;
+        break;
+      }
+      case "-s":
+      case "--static-dir": {
+        const next = argv[index + 1];
+        if (!next) {
+          throw new Error("Missing value for --static-dir option.");
+        }
+        options.staticDir = next;
+        index += 1;
+        break;
+      }
+      case "-e":
+      case "--env": {
+        const next = argv[index + 1];
+        if (!next) {
+          throw new Error("Missing value for --env option.");
+        }
+        options.envFiles.push(next);
+        index += 1;
+        break;
+      }
+      case "--no-default-env": {
+        options.loadDefaultEnv = false;
+        break;
+      }
+      case "-h":
+      case "--help": {
+        options.showHelp = true;
+        break;
+      }
+      default: {
+        if (arg.startsWith("-")) {
+          throw new Error(
+            `Unknown option \`${arg}\`. Use --help to list supported flags.`
+          );
+        }
+        options.envFiles.push(arg);
+      }
+    }
+  }
+  return options;
+};
+var printHelp = () => {
+  console.log(helpText);
+};
+var resolvePath = (input) => path.isAbsolute(input) ? input : path.resolve(process.cwd(), input);
+var loadEnvFile = (filePath) => {
+  const resolved = resolvePath(filePath);
+  if (!fs.existsSync(resolved)) {
+    return false;
+  }
+  dotenv.config({ path: resolved, override: false });
+  console.log(`[video-processor] Loaded env file ${resolved}`);
+  return true;
+};
+var ensureEnvVariables = () => {
+  if (!process.env.MONGODB_URI && process.env.DATABASE_URI) {
+    process.env.MONGODB_URI = process.env.DATABASE_URI;
+  }
+  if (!process.env.PAYLOAD_SECRET) {
+    process.env.PAYLOAD_SECRET = "dev-secret";
+  }
+};
+var toModuleUrl = (input) => pathToFileURL(resolvePath(input)).href;
+var loadWorkerOptions = async (modulePath) => {
+  const moduleUrl = toModuleUrl(modulePath);
+  const imported = await import(moduleUrl);
+  const value = imported?.default ?? imported;
+  if (!value || typeof value !== "object") {
+    throw new Error(
+      `Worker options module at ${modulePath} did not export a configuration object.`
+    );
+  }
+  return value;
+};
+void (async () => {
+  try {
+    const options = parseArgs(process.argv.slice(2));
+    if (options.showHelp) {
+      printHelp();
+      process.exit(0);
+    }
+    const defaultEnvFiles = [
+      ".env",
+      ".env.local",
+      ".env.development",
+      ".env.production"
+    ];
+    if (options.loadDefaultEnv) {
+      for (const candidate of defaultEnvFiles) {
+        loadEnvFile(candidate);
+      }
+    }
+    for (const envFile of options.envFiles) {
+      loadEnvFile(envFile);
+    }
+    if (options.staticDir) {
+      process.env.STATIC_DIR = resolvePath(options.staticDir);
+      console.log(
+        `[video-processor] Using STATIC_DIR=${process.env.STATIC_DIR}`
+      );
+    }
+    if (options.payloadConfigPath) {
+      const resolvedPayloadConfig = resolvePath(options.payloadConfigPath);
+      process.env.PAYLOAD_CONFIG_PATH = resolvedPayloadConfig;
+      console.log(
+        `[video-processor] Using PAYLOAD_CONFIG_PATH=${resolvedPayloadConfig}`
+      );
+    }
+    const configPath = options.configPath ?? process.env.PAYLOAD_VIDEO_WORKER_CONFIG;
+    if (!configPath) {
+      throw new Error(
+        "No worker config provided. Pass --config or set PAYLOAD_VIDEO_WORKER_CONFIG."
+      );
+    }
+    process.env.PAYLOAD_VIDEO_WORKER_CONFIG = resolvePath(configPath);
+    ensureEnvVariables();
+    const workerOptions = await loadWorkerOptions(
+      process.env.PAYLOAD_VIDEO_WORKER_CONFIG
+    );
+    const { createWorker: createWorker2 } = await Promise.resolve().then(() => (init_createWorker(), createWorker_exports));
+    await createWorker2(workerOptions);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error("[video-processor] Worker failed to start:", error.message);
+      if (error.stack) {
+        console.error(error.stack);
+      }
+    } else {
+      console.error("[video-processor] Worker failed to start:", error);
+    }
+    process.exit(1);
+  }
+})();
+//# sourceMappingURL=start-worker.js.map
+//# sourceMappingURL=start-worker.js.map