@kimjansheden/payload-video-processor 0.1.1

package/dist/index.js

@@ -0,0 +1,1125 @@
+import { z } from 'zod';
+import { Worker, Queue, QueueEvents } from 'bullmq';
+import IORedis from 'ioredis';
+import fs2, { mkdir, stat } from 'fs/promises';
+import path from 'path';
+import { pathToFileURL } from 'url';
+import payload from 'payload';
+import ffmpeg2 from 'fluent-ffmpeg';
+import ffmpegStatic from 'ffmpeg-static';
+import ffprobeStatic from 'ffprobe-static';
+
+// src/options.ts
+var presetSchema = z.object({
+  args: z.array(z.string()),
+  label: z.string().optional(),
+  enableCrop: z.boolean().optional()
+});
+var 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()
+});
+var normalizePresets = (presets) => {
+  const entries = Object.entries(presets).map(([name, preset]) => [
+    name,
+    { ...preset }
+  ]);
+  return Object.fromEntries(entries);
+};
+var ensureOptions = (options) => videoPluginOptionsSchema.parse(options);
+var createQueue = ({
+  name,
+  redisUrl
+}) => {
+  const connection = redisUrl ? new IORedis(redisUrl, { maxRetriesPerRequest: null }) : new IORedis({ maxRetriesPerRequest: null });
+  const queue = new Queue(name, {
+    connection
+  });
+  const events = new QueueEvents(name, {
+    connection: connection.duplicate()
+  });
+  events.on("error", (error) => {
+    console.error("[video-processor] QueueEvents error", error);
+  });
+  void events.waitUntilReady();
+  return { queue, events };
+};
+var 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"
+});
+var 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/api/shared.ts
+var readRequestBody = async (req) => {
+  if (typeof req.json === "function") {
+    try {
+      return await req.json();
+    } catch {
+    }
+  }
+  if (typeof req.body !== "undefined") {
+    return req.body;
+  }
+  return void 0;
+};
+
+// src/api/enqueue.ts
+var bodySchema = videoJobSchema.extend({
+  crop: videoJobSchema.shape.crop.optional()
+});
+var createEnqueueHandler = ({ getQueue, presets, access }) => async (req) => {
+  try {
+    if (access?.enqueue) {
+      const allowed = await access.enqueue({ req });
+      if (!allowed) {
+        return Response.json(
+          { error: "Not allowed to enqueue video processing jobs." },
+          { status: 403 }
+        );
+      }
+    }
+    const rawBody = await readRequestBody(req);
+    const parsed = bodySchema.parse(rawBody);
+    if (!presets[parsed.preset]) {
+      return Response.json(
+        { error: `Unknown preset \`${parsed.preset}\`.` },
+        { status: 400 }
+      );
+    }
+    const payloadClient = req.payload;
+    const doc = await payloadClient.findByID({
+      collection: parsed.collection,
+      id: parsed.id
+    });
+    if (!doc) {
+      return Response.json({ error: "Document not found." }, { status: 404 });
+    }
+    const queue = getQueue();
+    const job = await queue.add(parsed.preset, parsed, {
+      // Keep completed jobs briefly so the status endpoint can report "completed"
+      // before BullMQ removes the job entry.
+      removeOnComplete: { age: 60 },
+      removeOnFail: false
+    });
+    return Response.json({ id: job.id, state: "queued" }, { status: 202 });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return Response.json(
+        { error: error.message, issues: error.issues },
+        { status: 400 }
+      );
+    }
+    console.error("[video-processor] Enqueue handler failed", error);
+    return Response.json(
+      { error: "Unexpected error while enqueuing video job." },
+      { status: 500 }
+    );
+  }
+};
+
+// src/api/status.ts
+var readJobId = (req) => {
+  const directParam = req.params?.jobId;
+  if (typeof directParam === "string" && directParam.length > 0) {
+    return directParam;
+  }
+  const routeParam = req.routeParams?.jobId;
+  if (typeof routeParam === "string" && routeParam.length > 0) {
+    return routeParam;
+  }
+  return void 0;
+};
+var createStatusHandler = ({ getQueue }) => async (req) => {
+  try {
+    const jobId = readJobId(req);
+    if (!jobId) {
+      return Response.json(
+        { error: "jobId parameter is required." },
+        { status: 400 }
+      );
+    }
+    const queue = getQueue();
+    const job = await queue.getJob(jobId);
+    if (!job) {
+      return Response.json({ error: "Job not found." }, { status: 404 });
+    }
+    const state = await job.getState();
+    return Response.json({ id: job.id, state, progress: job.progress });
+  } catch (error) {
+    console.error("[video-processor] Status handler failed", error);
+    return Response.json(
+      { error: "Unexpected error while reading job status." },
+      { status: 500 }
+    );
+  }
+};
+var safeNormalize = (input) => path.resolve(input);
+var ensureTrailingSep = (input) => input.endsWith(path.sep) ? input : `${input}${path.sep}`;
+var isWithinRoot = (candidate, root) => {
+  const normalizedCandidate = safeNormalize(candidate);
+  const normalizedRoot = safeNormalize(root);
+  return normalizedCandidate === normalizedRoot || normalizedCandidate.startsWith(ensureTrailingSep(normalizedRoot));
+};
+var gatherAllowedRoots = ({
+  collection,
+  doc
+}) => {
+  const roots = /* @__PURE__ */ new Set();
+  roots.add(safeNormalize(process.cwd()));
+  const staticDirEnv = process.env.STATIC_DIR;
+  if (typeof staticDirEnv === "string" && staticDirEnv.trim()) {
+    roots.add(safeNormalize(staticDirEnv));
+  }
+  const uploadsDirEnv = process.env.PAYLOAD_UPLOADS_DIR;
+  if (typeof uploadsDirEnv === "string" && uploadsDirEnv.trim()) {
+    roots.add(safeNormalize(uploadsDirEnv));
+  }
+  const uploadConfig = collection && typeof collection.upload === "object" ? collection.upload : null;
+  const staticDirConfig = uploadConfig && typeof uploadConfig.staticDir === "string" ? uploadConfig.staticDir : null;
+  if (staticDirConfig) {
+    roots.add(safeNormalize(staticDirConfig));
+  }
+  const docPath = doc && typeof doc.path === "string" ? doc.path.trim() : void 0;
+  if (docPath && docPath.length > 0) {
+    if (path.isAbsolute(docPath)) {
+      roots.add(safeNormalize(path.dirname(docPath)));
+    } else {
+      roots.add(safeNormalize(path.join(process.cwd(), path.dirname(docPath))));
+      if (staticDirConfig) {
+        roots.add(
+          safeNormalize(path.join(staticDirConfig, path.dirname(docPath)))
+        );
+      }
+    }
+  }
+  return Array.from(roots);
+};
+var resolveAbsolutePath = (input, allowedRoots) => {
+  if (!input) return null;
+  const trimmed = input.trim();
+  if (!trimmed) return null;
+  const normalizedRoots = allowedRoots.map(safeNormalize);
+  if (path.isAbsolute(trimmed)) {
+    const normalized = safeNormalize(trimmed);
+    return normalizedRoots.some((root) => isWithinRoot(normalized, root)) ? normalized : null;
+  }
+  for (const root of normalizedRoots) {
+    const candidate = safeNormalize(path.join(root, trimmed));
+    if (isWithinRoot(candidate, root)) {
+      return candidate;
+    }
+  }
+  return null;
+};
+var cachedClient = null;
+var localInitialized = false;
+var normalizeConfigPath = (configPath) => {
+  if (configPath.startsWith("file://")) return configPath;
+  return pathToFileURL(path.resolve(configPath)).href;
+};
+var buildAuthHeaders = (token) => ({
+  Authorization: `Bearer ${token}`,
+  "X-Payload-API-Key": token
+});
+var 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;
+  }
+};
+var 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;
+    }
+  };
+};
+var getPayloadClient = async () => {
+  if (cachedClient) return cachedClient;
+  const localClient = await initLocalPayload();
+  if (localClient) {
+    cachedClient = localClient;
+    return localClient;
+  }
+  const restClient = await initRestClient();
+  cachedClient = restClient;
+  return restClient;
+};
+var getCollectionConfigFromRequest = (req, slug) => {
+  const payloadInstance = req.payload;
+  const collections = payloadInstance?.collections;
+  const fromCollections = collections?.[slug];
+  if (fromCollections) {
+    if (typeof fromCollections.config === "object") {
+      return fromCollections.config;
+    }
+    if (typeof fromCollections === "object") {
+      return fromCollections;
+    }
+  }
+  const configured = Array.isArray(payloadInstance.config?.collections) ? payloadInstance.config?.collections : void 0;
+  if (configured) {
+    const match = configured.find(
+      (collection) => collection && collection.slug === slug
+    );
+    if (match) {
+      return match;
+    }
+  }
+  return null;
+};
+
+// src/api/removeVariant.ts
+var bodySchema2 = z.object({
+  collection: z.string().min(1, "collection is required"),
+  id: z.string().min(1, "id is required"),
+  preset: z.string().min(1).optional(),
+  variantId: z.string().min(1).optional(),
+  variantIndex: z.union([z.number().int().nonnegative(), z.string().regex(/^\d+$/)]).optional()
+}).superRefine((value, ctx) => {
+  if (typeof value.variantIndex === "undefined" && !value.variantId && !value.preset) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      message: "preset, variantId or variantIndex must be provided to remove a variant.",
+      path: ["variantIndex"]
+    });
+  }
+});
+var createRemoveVariantHandler = ({ access }) => async (req) => {
+  try {
+    const rawBody = await readRequestBody(req);
+    const parsed = bodySchema2.parse(rawBody);
+    const variantIndex = typeof parsed.variantIndex === "number" ? parsed.variantIndex : typeof parsed.variantIndex === "string" ? Number(parsed.variantIndex) : void 0;
+    if (Number.isNaN(variantIndex)) {
+      return Response.json(
+        { error: "variantIndex must be a non-negative integer." },
+        { status: 400 }
+      );
+    }
+    if (access?.removeVariant) {
+      const allowed = await access.removeVariant({
+        req,
+        collection: parsed.collection,
+        id: parsed.id,
+        preset: parsed.preset,
+        variantId: parsed.variantId,
+        variantIndex
+      });
+      if (!allowed) {
+        return Response.json(
+          { error: "Not allowed to remove video variants." },
+          { status: 403 }
+        );
+      }
+    }
+    const payloadClient = req.payload;
+    const doc = await payloadClient.findByID({
+      collection: parsed.collection,
+      id: parsed.id
+    }).catch((error) => {
+      console.error("[video-processor] Failed to load document", error);
+      return null;
+    });
+    if (!doc) {
+      return Response.json({ error: "Document not found." }, { status: 404 });
+    }
+    const variants = Array.isArray(doc.variants) ? doc.variants : [];
+    let targetIndex = typeof variantIndex === "number" ? variantIndex : Number.NaN;
+    if (Number.isNaN(targetIndex) && parsed.variantId) {
+      targetIndex = variants.findIndex(
+        (variant) => Boolean(
+          variant && typeof variant === "object" && variant.id === parsed.variantId
+        )
+      );
+    }
+    if (Number.isNaN(targetIndex) && parsed.preset) {
+      targetIndex = variants.findIndex(
+        (variant) => Boolean(
+          variant && typeof variant === "object" && variant.preset === parsed.preset
+        )
+      );
+    }
+    if (!Number.isInteger(targetIndex) || targetIndex < 0) {
+      return Response.json({ error: "Variant not found." }, { status: 404 });
+    }
+    const targetVariant = variants[targetIndex];
+    if (!targetVariant || typeof targetVariant !== "object") {
+      return Response.json({ error: "Variant not found." }, { status: 404 });
+    }
+    const collectionConfig = getCollectionConfigFromRequest(
+      req,
+      parsed.collection
+    );
+    const allowedRoots = gatherAllowedRoots({
+      collection: collectionConfig,
+      doc
+    });
+    const variantPath = typeof targetVariant.path === "string" ? targetVariant.path.trim() : "";
+    let resolvedVariantPath = null;
+    if (variantPath) {
+      resolvedVariantPath = resolveAbsolutePath(variantPath, allowedRoots);
+      if (!resolvedVariantPath) {
+        return Response.json(
+          { error: "Variant path is outside allowed directories." },
+          { status: 400 }
+        );
+      }
+    }
+    const nextVariants = variants.filter(
+      (_variant, index) => index !== targetIndex
+    );
+    if (resolvedVariantPath) {
+      await fs2.rm(resolvedVariantPath).catch(() => {
+        console.warn(
+          `[video-processor] Could not remove variant file at ${resolvedVariantPath}`
+        );
+      });
+    } else {
+      const fallbackUrl = typeof targetVariant.url === "string" ? targetVariant.url : "";
+      const fallbackFilename = fallbackUrl.split("/").pop();
+      if (fallbackFilename) {
+        const fallbackPath = resolveAbsolutePath(
+          fallbackFilename,
+          allowedRoots
+        );
+        if (fallbackPath) {
+          await fs2.rm(fallbackPath).catch(() => {
+            console.warn(
+              `[video-processor] Could not remove fallback variant file at ${fallbackPath}`
+            );
+          });
+        }
+      }
+    }
+    const updated = await payloadClient.update({
+      collection: parsed.collection,
+      id: doc.id ?? parsed.id,
+      data: { variants: nextVariants }
+    });
+    return Response.json({ success: true, doc: updated });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return Response.json(
+        { error: error.message, issues: error.issues },
+        { status: 400 }
+      );
+    }
+    console.error("[video-processor] Failed to remove variant", error);
+    return Response.json(
+      { error: "Unable to remove video variant." },
+      { status: 500 }
+    );
+  }
+};
+var bodySchema3 = z.object({
+  collection: z.string().min(1, "collection is required"),
+  id: z.string().min(1, "id is required"),
+  preset: z.string().min(1).optional()
+});
+var createReplaceOriginalHandler = ({ access }) => async (req) => {
+  try {
+    const rawBody = await readRequestBody(req);
+    const parsed = bodySchema3.parse(rawBody);
+    if (access?.replaceOriginal) {
+      const allowed = await access.replaceOriginal({
+        req,
+        collection: parsed.collection,
+        id: parsed.id,
+        preset: parsed.preset
+      });
+      if (!allowed) {
+        return Response.json(
+          { error: "Not allowed to replace original video." },
+          { status: 403 }
+        );
+      }
+    }
+    const payloadClient = req.payload;
+    const doc = await payloadClient.findByID({
+      collection: parsed.collection,
+      id: parsed.id
+    }).catch((error) => {
+      console.error(
+        "[video-processor] Failed to load document for replace-original",
+        error
+      );
+      return null;
+    });
+    if (!doc) {
+      return Response.json({ error: "Document not found." }, { status: 404 });
+    }
+    const variants = Array.isArray(doc.variants) ? [...doc.variants] : [];
+    if (variants.length === 0) {
+      return Response.json(
+        { error: "No variants are available for replacement." },
+        { status: 400 }
+      );
+    }
+    const targetVariant = parsed.preset ? variants.find((variant) => variant?.preset === parsed.preset) : variants[0];
+    if (!targetVariant) {
+      return Response.json(
+        { error: "Requested variant was not found." },
+        { status: 404 }
+      );
+    }
+    const collectionConfig = getCollectionConfigFromRequest(
+      req,
+      parsed.collection
+    );
+    const allowedRoots = gatherAllowedRoots({
+      collection: collectionConfig,
+      doc
+    });
+    const variantPath = typeof targetVariant.path === "string" ? targetVariant.path.trim() : "";
+    if (!variantPath) {
+      return Response.json(
+        { error: "Variant does not expose a file path." },
+        { status: 400 }
+      );
+    }
+    const resolvedVariantPath = resolveAbsolutePath(
+      variantPath,
+      allowedRoots
+    );
+    if (!resolvedVariantPath) {
+      return Response.json(
+        { error: "Variant path is outside allowed directories." },
+        { status: 400 }
+      );
+    }
+    const originalPath = typeof doc.path === "string" && doc.path.trim().length > 0 ? doc.path.trim() : typeof doc.filename === "string" && doc.filename.trim().length > 0 ? doc.filename.trim() : "";
+    const resolvedOriginalPath = originalPath ? resolveAbsolutePath(originalPath, allowedRoots) : null;
+    if (!resolvedOriginalPath) {
+      return Response.json(
+        { error: "Original file path could not be resolved." },
+        { status: 400 }
+      );
+    }
+    await fs2.rm(resolvedOriginalPath).catch(() => void 0);
+    await fs2.mkdir(path.dirname(resolvedOriginalPath), { recursive: true });
+    await fs2.rename(resolvedVariantPath, resolvedOriginalPath);
+    const updateData = {
+      variants: variants.filter(
+        (variant) => variant?.preset !== targetVariant.preset
+      )
+    };
+    if (typeof targetVariant.size === "number") {
+      updateData.filesize = targetVariant.size;
+    }
+    if (typeof targetVariant.duration === "number") {
+      updateData.duration = targetVariant.duration;
+    }
+    if (typeof targetVariant.width === "number") {
+      updateData.width = targetVariant.width;
+    }
+    if (typeof targetVariant.height === "number") {
+      updateData.height = targetVariant.height;
+    }
+    if (typeof targetVariant.bitrate === "number") {
+      updateData.bitrate = targetVariant.bitrate;
+    }
+    const updated = await payloadClient.update({
+      collection: parsed.collection,
+      id: doc.id ?? parsed.id,
+      data: updateData
+    });
+    return Response.json({ success: true, doc: updated });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return Response.json(
+        { error: error.message, issues: error.issues },
+        { status: 400 }
+      );
+    }
+    console.error("[video-processor] Failed to replace original", error);
+    return Response.json(
+      { error: "Unable to replace original video file." },
+      { status: 500 }
+    );
+  }
+};
+
+// src/ffmpeg/args.ts
+var FASTSTART_FLAGS = ["-movflags", "+faststart"];
+var CRF_FLAG = "-crf";
+var hasCrf = (args) => {
+  for (let i = 0; i < args.length; i += 1) {
+    if (args[i] === CRF_FLAG) {
+      return true;
+    }
+  }
+  return false;
+};
+var 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;
+};
+var 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 };
+};
+var clamp = (value, min, max) => {
+  if (Number.isNaN(value)) return min;
+  if (value < min) return min;
+  if (value > max) return max;
+  return value;
+};
+var 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}`;
+};
+var 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
+  };
+};
+if (ffprobeStatic.path) {
+  ffmpeg2.setFfprobePath(ffprobeStatic.path);
+}
+var 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 = (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}`;
+};
+var 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
+  };
+};
+var buildStoredPath = (originalPath, variantFilename) => {
+  const originalDir = path.dirname(originalPath);
+  return path.join(originalDir, variantFilename);
+};
+var buildWritePath = (dir, filename) => path.join(dir, filename);
+
+// src/queue/createWorker.ts
+var envFfmpegPath = process.env.FFMPEG_BIN?.trim();
+var ffmpegBinary = envFfmpegPath && envFfmpegPath.length > 0 ? envFfmpegPath : typeof ffmpegStatic === "string" ? ffmpegStatic : null;
+if (ffmpegBinary) {
+  ffmpeg2.setFfmpegPath(ffmpegBinary);
+}
+if (ffprobeStatic.path) {
+  ffmpeg2.setFfprobePath(ffprobeStatic.path);
+}
+var 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;
+};
+
+// src/index.ts
+var adminFieldPath = "@kimjansheden/payload-video-processor/client#VideoField";
+var acceptsVideoUploads = (collection) => {
+  const upload = collection.upload;
+  if (!upload) return false;
+  if (upload === true) {
+    return false;
+  }
+  const mimeTypes = Array.isArray(upload?.mimeTypes) ? upload.mimeTypes : [];
+  return mimeTypes.some((type) => type.startsWith("video/"));
+};
+var createVariantsField = () => ({
+  name: "variants",
+  type: "array",
+  label: "Video variants",
+  admin: {
+    readOnly: true
+  },
+  defaultValue: [],
+  fields: [
+    {
+      name: "preset",
+      label: "Preset",
+      type: "text",
+      admin: { readOnly: true }
+    },
+    {
+      name: "url",
+      label: "URL",
+      type: "text",
+      admin: { readOnly: true }
+    },
+    {
+      name: "path",
+      label: "Path",
+      type: "text",
+      admin: { readOnly: true }
+    },
+    {
+      name: "size",
+      label: "Size (bytes)",
+      type: "number",
+      admin: { readOnly: true }
+    },
+    {
+      name: "duration",
+      label: "Duration (s)",
+      type: "number",
+      admin: { readOnly: true }
+    },
+    {
+      name: "width",
+      label: "Width",
+      type: "number",
+      admin: { readOnly: true }
+    },
+    {
+      name: "height",
+      label: "Height",
+      type: "number",
+      admin: { readOnly: true }
+    },
+    {
+      name: "bitrate",
+      label: "Bitrate",
+      type: "number",
+      admin: { readOnly: true }
+    },
+    {
+      name: "createdAt",
+      label: "Created",
+      type: "date",
+      admin: { readOnly: true }
+    }
+  ]
+});
+var buildAdminPresetMap = (presets) => Object.fromEntries(
+  Object.entries(presets).map(([name, preset]) => [
+    name,
+    {
+      label: preset.label ?? name,
+      enableCrop: Boolean(preset.enableCrop)
+    }
+  ])
+);
+var trimTrailingSlash = (value) => value.endsWith("/") ? value.slice(0, -1) : value;
+var getApiBasePath = (_config) => "";
+var pluginFactory = (rawOptions) => {
+  const options = ensureOptions(rawOptions);
+  const presets = normalizePresets(options.presets);
+  const plugin = (config) => {
+    const queueName = options.queue?.name ?? "video-transcode";
+    const redisUrl = options.queue?.redisUrl ?? process.env.REDIS_URL;
+    const apiBase = getApiBasePath();
+    const endpointEnqueuePath = `${apiBase}/video-queue/enqueue`;
+    const endpointStatusBase = `${apiBase}/video-queue/status`;
+    const endpointReplaceOriginalPath = `${apiBase}/video-queue/replace-original`;
+    const endpointRemoveVariantPath = `${apiBase}/video-queue/remove-variant`;
+    const routesApiBase = trimTrailingSlash(config.routes?.api ?? "/api");
+    const clientEnqueuePath = `${routesApiBase}/video-queue/enqueue`;
+    const clientStatusBase = `${routesApiBase}/video-queue/status`;
+    const clientReplaceOriginalPath = `${routesApiBase}/video-queue/replace-original`;
+    const clientRemoveVariantPath = `${routesApiBase}/video-queue/remove-variant`;
+    console.log(
+      `[payload-video-processor] enabled (queue: ${queueName}, presets: ${Object.keys(presets).length})`
+    );
+    const queueRef = {};
+    const getQueue = () => {
+      if (!queueRef.queue) {
+        queueRef.queue = createQueue({ name: queueName, redisUrl });
+      }
+      return queueRef.queue.queue;
+    };
+    const collections = (config.collections ?? []).map(
+      (collection) => {
+        if (!acceptsVideoUploads(collection)) {
+          return collection;
+        }
+        const fields = [...collection.fields ?? []];
+        const hasVariantsField = fields.some(
+          (field) => "name" in field && field.name === "variants"
+        );
+        if (!hasVariantsField) {
+          fields.push(createVariantsField());
+        }
+        const hasControlField = fields.some(
+          (field) => "name" in field && field.name === "videoProcessing"
+        );
+        if (!hasControlField) {
+          const clientProps = {
+            presets: buildAdminPresetMap(presets),
+            enqueuePath: clientEnqueuePath,
+            statusPath: clientStatusBase,
+            replaceOriginalPath: clientReplaceOriginalPath,
+            removeVariantPath: clientRemoveVariantPath,
+            queueName,
+            collectionSlug: collection.slug
+          };
+          const controlField = {
+            name: "videoProcessing",
+            type: "ui",
+            label: "Video processing",
+            admin: {
+              components: {
+                Field: {
+                  path: adminFieldPath,
+                  clientProps
+                }
+              },
+              position: "sidebar"
+            },
+            custom: clientProps
+          };
+          fields.push(controlField);
+        }
+        return {
+          ...collection,
+          fields
+        };
+      }
+    );
+    const endpoints = [
+      {
+        method: "post",
+        path: endpointEnqueuePath,
+        handler: createEnqueueHandler({
+          getQueue,
+          presets,
+          access: options.access
+        })
+      },
+      {
+        method: "get",
+        path: `${endpointStatusBase}/:jobId`,
+        handler: createStatusHandler({ getQueue })
+      },
+      {
+        method: "post",
+        path: endpointReplaceOriginalPath,
+        handler: createReplaceOriginalHandler({ access: options.access })
+      },
+      {
+        method: "post",
+        path: endpointRemoveVariantPath,
+        handler: createRemoveVariantHandler({ access: options.access })
+      }
+    ];
+    const existingEndpoints = Array.isArray(config.endpoints) ? config.endpoints : [];
+    return {
+      ...config,
+      collections,
+      endpoints: [...existingEndpoints, ...endpoints]
+    };
+  };
+  return plugin;
+};
+var src_default = pluginFactory;
+
+export { createWorker, src_default as default, defaultResolvePaths };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map