nuxt-media-library 0.0.44

package/dist/runtime/schemas/resource-policy.schema.js

@@ -0,0 +1,117 @@
+import { AssetKind, Visibility, ResourcePolicySchemaMode } from "../types/resourcePolicy.js";
+const enumVisibility = Object.values(Visibility);
+const enumAssetKind = Object.values(AssetKind);
+export const FileConstraintsJsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["allowed_mime_types"],
+  properties: {
+    allowed_mime_types: { type: "array", items: { type: "string" }, minItems: 1 },
+    max_size_bytes: { type: ["integer", "null"] },
+    min_size_bytes: { type: ["integer", "null"] },
+    allow_multiple: { type: "boolean" }
+  }
+};
+export const PermissionRequirementsJsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    required_permissions: { type: "array", items: { type: "string" } },
+    allow_anonymous: { type: "boolean" }
+  }
+};
+export const StorageConfigJsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    storage_class: { type: "string" },
+    visibility: { type: "string" }
+  }
+};
+export const ProcessingConfigJsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: ["auto_process"],
+  properties: {
+    auto_process: { type: "boolean" },
+    step_options: { type: ["object", "null"], additionalProperties: true }
+  }
+};
+export const CreateResourcePolicyJsonSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "CreateResourcePolicyRequest",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "resource_type",
+    "file_constraints",
+    "processing_config",
+    "kind",
+    "visibility"
+  ],
+  properties: {
+    resource_type: { type: "string", minLength: 1 },
+    collection_name: { type: ["string", "null"] },
+    file_constraints: FileConstraintsJsonSchema,
+    permission_requirements: PermissionRequirementsJsonSchema,
+    processing_config: ProcessingConfigJsonSchema,
+    kind: { type: "string", enum: enumAssetKind },
+    visibility: { type: "string", enum: enumVisibility }
+  }
+};
+export const UpdateResourcePolicyJsonSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "UpdateResourcePolicyRequest",
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    file_constraints: { anyOf: [FileConstraintsJsonSchema, { type: "null" }] },
+    permission_requirements: { anyOf: [PermissionRequirementsJsonSchema, { type: "null" }] },
+    processing_config: { anyOf: [ProcessingConfigJsonSchema, { type: "null" }] },
+    kind: { anyOf: [{ type: "string", enum: enumAssetKind }, { type: "null" }] },
+    visibility: { anyOf: [{ type: "string", enum: enumVisibility }, { type: "null" }] },
+    is_active: { type: ["boolean", "null"] }
+  }
+};
+export const ResourcePolicyResponseJsonSchema = {
+  $schema: "http://json-schema.org/draft-07/schema#",
+  title: "ResourcePolicyResponse",
+  type: "object",
+  additionalProperties: false,
+  required: [
+    "id",
+    "tenant_id",
+    "resource_type",
+    "collection_name",
+    "file_constraints",
+    "permission_requirements",
+    "processing_config",
+    "kind",
+    "visibility",
+    "is_active",
+    "version",
+    "created_at",
+    "updated_at"
+  ],
+  properties: {
+    id: { type: "string" },
+    tenant_id: { type: "string" },
+    resource_type: { type: "string" },
+    collection_name: { type: ["string", "null"] },
+    file_constraints: FileConstraintsJsonSchema,
+    permission_requirements: PermissionRequirementsJsonSchema,
+    processing_config: ProcessingConfigJsonSchema,
+    storage_config: StorageConfigJsonSchema,
+    kind: { type: "string", enum: enumAssetKind },
+    visibility: { type: "string", enum: enumVisibility },
+    is_active: { type: "boolean" },
+    version: { type: "integer" },
+    created_at: { type: "string" },
+    updated_at: { type: "string" }
+  }
+};
+export function getResourcePolicyJsonSchema(mode) {
+  if (mode === ResourcePolicySchemaMode.Update) return UpdateResourcePolicyJsonSchema;
+  if (mode === ResourcePolicySchemaMode.Response) return ResourcePolicyResponseJsonSchema;
+  return CreateResourcePolicyJsonSchema;
+}

package/dist/runtime/server/assets-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/assets-proxy.js

@@ -0,0 +1,81 @@
+import { createError, defineEventHandler, getRequestHeaders, getRequestURL, proxyRequest } from "h3";
+import { useRuntimeConfig } from "#imports";
+const normalizeHeaders = (headers) => {
+  if (!headers) return {};
+  return typeof headers === "function" ? headers() : headers;
+};
+export default defineEventHandler(async (event) => {
+  try {
+    const config = useRuntimeConfig();
+    const baseURL = config.mediaLibrary?.baseURL;
+    const routes = config.mediaLibrary?.routes;
+    if (!baseURL) {
+      throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL is required for assets proxying." });
+    }
+    try {
+      const parsed = new URL(baseURL);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Invalid protocol");
+      }
+    } catch {
+      throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL must be an absolute http(s) URL." });
+    }
+    const reqUrl = getRequestURL(event);
+    const path = reqUrl.pathname;
+    const prefix = "/api/media-library/manage/assets";
+    if (!path.startsWith(prefix)) {
+      throw createError({ statusCode: 404, statusMessage: "Not found" });
+    }
+    const rest = path.slice(prefix.length);
+    const method = event.node.req.method || "GET";
+    const trimmedRest = rest.replace(/\/+$/, "");
+    const isCollection = trimmedRest === "";
+    const isResolve = trimmedRest === "/resolve";
+    const isItem = /^\/[^/]+$/.test(trimmedRest) && !isResolve;
+    const subResourceMatch = trimmedRest.match(/^\/[^/]+\/(renditions)$/);
+    const isSubResource = subResourceMatch !== null;
+    if (!isCollection && !isResolve && !isItem && !isSubResource) {
+      throw createError({ statusCode: 404, statusMessage: "Not found" });
+    }
+    if (isCollection && method !== "GET") {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    if (isResolve && method !== "POST") {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    if (isItem && !["GET", "PATCH", "DELETE"].includes(method)) {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    if (isSubResource && method !== "GET") {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    const assetsBase = routes?.assets || "/manage/assets";
+    const upstreamPath = `${assetsBase}${trimmedRest}`;
+    const normalizedBase = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+    const upstreamUrl = new URL(`.${upstreamPath}`, normalizedBase);
+    const incoming = new URLSearchParams(reqUrl.search);
+    incoming.forEach((value, key) => {
+      upstreamUrl.searchParams.append(key, value);
+    });
+    const forwardedHeaders = { ...getRequestHeaders(event) };
+    const extraHeaders = normalizeHeaders(config.mediaLibrary?.headers);
+    const proxyHeaders = { ...forwardedHeaders, ...extraHeaders };
+    delete proxyHeaders.connection;
+    delete proxyHeaders["transfer-encoding"];
+    delete proxyHeaders["keep-alive"];
+    delete proxyHeaders.upgrade;
+    delete proxyHeaders.expect;
+    delete proxyHeaders.host;
+    const result = await proxyRequest(event, upstreamUrl.toString(), {
+      headers: proxyHeaders,
+      streamRequest: true
+    });
+    if (event.node.res.statusCode >= 400) {
+      console.error(`[media-library] assets-proxy upstream responded ${event.node.res.statusCode} for ${method} ${upstreamUrl.toString()}`);
+    }
+    return result;
+  } catch (err) {
+    console.error("[media-library] assets-proxy error:", err);
+    throw err;
+  }
+});

package/dist/runtime/server/create-ml-proxy.d.ts

@@ -0,0 +1,47 @@
+import type { H3Event } from 'h3';
+export type MLProxyType = 'assets' | 'uploads' | 'delivery' | 'processing' | 'resource-policy';
+export interface MLProxyOptions {
+    /**
+     * Per-request header factory. Receives the H3 event and the incoming
+     * request headers so you can inject auth tokens, tenant IDs, etc.
+     * Returned headers are merged on top of the static `mediaLibrary.headers`
+     * from runtimeConfig.
+     */
+    requestHeaders?: (event: H3Event, incoming: Record<string, string>) => Record<string, string> | Promise<Record<string, string>>;
+}
+/**
+ * Create a Nitro event handler that replicates one of the media library's
+ * built-in proxy handlers with optional per-request header injection.
+ *
+ * Register it in a consumer server route that shadows the module's default
+ * handler (consumer app routes take priority over module routes):
+ *
+ * @example
+ * // server/api/media-library/manage/assets/[...].ts
+ * import { createMLProxy } from '@fritill-team/nuxt-media-library/server'
+ * import { getAccessToken } from '~/server/utils/session'
+ *
+ * export default createMLProxy('assets', {
+ *   requestHeaders: async (event) => ({
+ *     Authorization: `Bearer ${await getAccessToken(event)}`,
+ *   }),
+ * })
+ */
+/**
+ * Create a single catch-all Nitro event handler that covers all media library
+ * proxy routes. Register it at `server/api/media-library/[...].ts` to shadow
+ * every built-in proxy with one file and one shared requestHeaders factory.
+ *
+ * @example
+ * // server/api/media-library/[...].ts
+ * import { createMLCatchAllProxy } from '@fritill-team/nuxt-media-library/server'
+ * import { getAccessToken } from '~/server/utils/session'
+ *
+ * export default createMLCatchAllProxy({
+ *   requestHeaders: async (event) => ({
+ *     Authorization: `Bearer ${await getAccessToken(event)}`,
+ *   }),
+ * })
+ */
+export declare function createMLCatchAllProxy(options?: MLProxyOptions): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export declare function createMLProxy(type: MLProxyType, options?: MLProxyOptions): import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;

package/dist/runtime/server/create-ml-proxy.js

@@ -0,0 +1,232 @@
+import { createError, defineEventHandler, getRequestHeaders, getRequestURL, proxyRequest, readRawBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+const HOP_BY_HOP = ["connection", "transfer-encoding", "keep-alive", "upgrade", "expect", "host"];
+function stripHopByHop(headers) {
+  return Object.fromEntries(Object.entries(headers).filter(([k]) => !HOP_BY_HOP.includes(k)));
+}
+async function buildProxyHeaders(event, staticHeaders, requestHeadersFn) {
+  const incoming = getRequestHeaders(event);
+  const dynamic = requestHeadersFn ? await requestHeadersFn(event, incoming) : {};
+  return stripHopByHop({ ...incoming, ...staticHeaders, ...dynamic });
+}
+function buildUpstreamUrl(baseURL, upstreamPath, search) {
+  const base = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+  const url = new URL(`.${upstreamPath}`, base);
+  new URLSearchParams(search).forEach((v, k) => url.searchParams.append(k, v));
+  return url;
+}
+function validateBaseURL(baseURL, name) {
+  if (!baseURL) {
+    throw createError({ statusCode: 500, statusMessage: `mediaLibrary.baseURL is required for ${name} proxying.` });
+  }
+  try {
+    const { protocol } = new URL(baseURL);
+    if (protocol !== "http:" && protocol !== "https:") throw new Error("Invalid protocol");
+  } catch {
+    throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL must be an absolute http(s) URL." });
+  }
+  return baseURL;
+}
+function resolveRoute(route, params) {
+  return route.replace(/:(\w+)/g, (_, key) => {
+    const value = params[key];
+    return value === void 0 ? "" : String(value);
+  });
+}
+async function handleAssetsProxy(event, baseURL, staticHeaders, assetsBase, requestHeadersFn) {
+  const reqUrl = getRequestURL(event);
+  const prefix = "/api/media-library/manage/assets";
+  const rest = reqUrl.pathname.slice(prefix.length);
+  const method = event.node.req.method || "GET";
+  const trimmedRest = rest.replace(/\/+$/, "");
+  const isCollection = trimmedRest === "";
+  const isResolve = trimmedRest === "/resolve";
+  const isItem = /^\/[^/]+$/.test(trimmedRest) && !isResolve;
+  const isSubResource = /^\/[^/]+\/renditions$/.test(trimmedRest);
+  if (!isCollection && !isResolve && !isItem && !isSubResource) {
+    throw createError({ statusCode: 404, statusMessage: "Not found" });
+  }
+  if (isCollection && method !== "GET") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  if (isResolve && method !== "POST") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  if (isItem && !["GET", "PATCH", "DELETE"].includes(method)) throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  if (isSubResource && method !== "GET") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  const upstreamUrl = buildUpstreamUrl(baseURL, `${assetsBase}${trimmedRest}`, reqUrl.search);
+  const headers = await buildProxyHeaders(event, staticHeaders, requestHeadersFn);
+  const result = await proxyRequest(event, upstreamUrl.toString(), { headers, streamRequest: true });
+  if (event.node.res.statusCode >= 400) {
+    console.error(`[media-library] assets-proxy upstream responded ${event.node.res.statusCode} for ${method} ${upstreamUrl}`);
+  }
+  return result;
+}
+async function handleUploadsProxy(event, baseURL, staticHeaders, routes, requestHeadersFn) {
+  const reqUrl = getRequestURL(event);
+  const prefix = "/api/media-library/manage/uploads";
+  const rest = reqUrl.pathname.slice(prefix.length);
+  const method = event.node.req.method || "GET";
+  let upstreamPath = "";
+  if (rest === "/sessions" || rest === "/sessions/") {
+    if (method !== "POST") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    upstreamPath = routes.createSession;
+  } else {
+    const partMatch = rest.match(/^\/sessions\/([^/]+)\/parts\/([^/]+)$/);
+    const finalizeMatch = rest.match(/^\/sessions\/([^/]+)\/finalize$/);
+    const abortMatch = rest.match(/^\/sessions\/([^/]+)\/abort$/);
+    const sessionMatch = rest.match(/^\/sessions\/([^/]+)$/);
+    if (partMatch) {
+      if (method !== "PUT") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+      upstreamPath = resolveRoute(routes.uploadPart, { id: partMatch[1], part: partMatch[2] });
+    } else if (finalizeMatch) {
+      if (method !== "POST") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+      upstreamPath = resolveRoute(routes.finalize, { id: finalizeMatch[1] });
+    } else if (abortMatch && routes.abort) {
+      if (method !== "DELETE") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+      upstreamPath = resolveRoute(routes.abort, { id: abortMatch[1] });
+    } else if (sessionMatch) {
+      if (method !== "GET") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+      upstreamPath = resolveRoute(routes.getSession, { id: sessionMatch[1] });
+    }
+  }
+  if (!upstreamPath) throw createError({ statusCode: 404, statusMessage: "Unknown upload route" });
+  const upstreamUrl = buildUpstreamUrl(baseURL, upstreamPath, reqUrl.search);
+  const headers = await buildProxyHeaders(event, staticHeaders, requestHeadersFn);
+  const result = await proxyRequest(event, upstreamUrl.toString(), { headers, streamRequest: true });
+  if (event.node.res.statusCode >= 400) {
+    console.error(`[media-library] uploads-proxy upstream responded ${event.node.res.statusCode} for ${method} ${upstreamUrl}`);
+  }
+  return result;
+}
+async function handleDeliveryProxy(event, baseURL, staticHeaders, requestHeadersFn) {
+  const reqUrl = getRequestURL(event);
+  const prefix = "/api/media-library/delivery";
+  const rest = reqUrl.pathname.slice(prefix.length);
+  const method = event.node.req.method || "GET";
+  const trimmedRest = rest.replace(/\/+$/, "");
+  const isCollection = /^\/assets$/.test(trimmedRest);
+  const isResolve = /^\/assets\/resolve$/.test(trimmedRest);
+  const isItem = /^\/assets\/[^/]+$/.test(trimmedRest) && !isResolve;
+  if (!isCollection && !isResolve && !isItem) throw createError({ statusCode: 404, statusMessage: "Not found" });
+  if (isCollection && method !== "GET") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  if (isResolve && method !== "POST") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  if (isItem && method !== "GET") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  const upstreamUrl = buildUpstreamUrl(baseURL, `/delivery${trimmedRest}`, reqUrl.search);
+  const headers = await buildProxyHeaders(event, staticHeaders, requestHeadersFn);
+  const result = await proxyRequest(event, upstreamUrl.toString(), { headers, streamRequest: true });
+  if (event.node.res.statusCode >= 400) {
+    console.error(`[media-library] delivery-proxy upstream responded ${event.node.res.statusCode} for ${method} ${upstreamUrl}`);
+  }
+  return result;
+}
+async function handleProcessingProxy(event, baseURL, staticHeaders, requestHeadersFn) {
+  const reqUrl = getRequestURL(event);
+  const prefix = "/api/media-library/manage/processing";
+  const rest = reqUrl.pathname.slice(prefix.length);
+  const method = event.node.req.method || "GET";
+  const allowed = /^\/stream$/.test(rest) && method === "GET" || /^\/assets\/[^/]+\/stream$/.test(rest) && method === "GET" || /^\/assets\/[^/]+\/tasks$/.test(rest) && method === "GET" || /^\/assets\/[^/]+\/process$/.test(rest) && method === "POST" || /^\/tasks\/[^/]+\/retry$/.test(rest) && method === "POST" || /^\/tasks\/[^/]+\/configure$/.test(rest) && method === "POST" || /^\/processors$/.test(rest) && method === "GET";
+  if (!allowed) throw createError({ statusCode: 404, statusMessage: "Not found" });
+  const upstreamUrl = buildUpstreamUrl(baseURL, `/manage/processing${rest}`, reqUrl.search);
+  const headers = await buildProxyHeaders(event, staticHeaders, requestHeadersFn);
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const body = hasBody ? await readRawBody(event, false) : void 0;
+  return proxyRequest(event, upstreamUrl.toString(), {
+    headers,
+    ...body !== void 0 ? { body } : {}
+  });
+}
+async function handleResourcePolicyProxy(event, baseURL, staticHeaders, requestHeadersFn) {
+  const reqUrl = getRequestURL(event);
+  const prefix = "/api/media-library/manage/resource-policies";
+  const rest = reqUrl.pathname.slice(prefix.length);
+  const method = event.node.req.method || "GET";
+  const trimmedRest = rest.replace(/\/+$/, "");
+  const isCollection = trimmedRest === "";
+  const isSchema = trimmedRest === "/schema";
+  const isPipelineSteps = trimmedRest === "/pipelines/available-steps";
+  const isItem = !isSchema && !isPipelineSteps && /^\/[^/]+$/.test(trimmedRest);
+  if (!isCollection && !isSchema && !isPipelineSteps && !isItem) {
+    throw createError({ statusCode: 404, statusMessage: "Not found" });
+  }
+  const isDev = import.meta.dev;
+  const writeMethods = ["POST", "PUT", "DELETE"];
+  if (isSchema && method !== "GET") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  if (isPipelineSteps && method !== "GET") throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  if (isCollection && method !== "GET" && !(isDev && method === "POST")) throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  if (isItem && method !== "GET" && !(isDev && writeMethods.includes(method))) throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+  const upstreamUrl = buildUpstreamUrl(baseURL, `/manage/resource-policies${trimmedRest}`, reqUrl.search);
+  const headers = await buildProxyHeaders(event, staticHeaders, requestHeadersFn);
+  const result = await proxyRequest(event, upstreamUrl.toString(), { headers, streamRequest: true });
+  if (event.node.res.statusCode >= 400) {
+    console.error(`[media-library] resource-policy-proxy upstream responded ${event.node.res.statusCode} for ${method} ${upstreamUrl}`);
+  }
+  return result;
+}
+function resolveMLProxyType(pathname) {
+  if (pathname.startsWith("/api/media-library/delivery/")) return { type: "delivery" };
+  if (pathname.startsWith("/api/media-library/manage/assets")) return { type: "assets" };
+  if (pathname.startsWith("/api/media-library/manage/uploads/")) return { type: "uploads" };
+  if (pathname.startsWith("/api/media-library/manage/processing/")) return { type: "processing" };
+  if (pathname.startsWith("/api/media-library/manage/resource-policies")) return { type: "resource-policy" };
+  return null;
+}
+export function createMLCatchAllProxy(options) {
+  return defineEventHandler(async (event) => {
+    const pathname = getRequestURL(event).pathname;
+    const resolved = resolveMLProxyType(pathname);
+    if (!resolved) throw createError({ statusCode: 404, statusMessage: "Not found" });
+    const config = useRuntimeConfig();
+    const mlConfig = config.mediaLibrary ?? {};
+    const baseURL = validateBaseURL(mlConfig.baseURL, resolved.type);
+    const staticHeaders = mlConfig.headers && typeof mlConfig.headers === "object" && !Array.isArray(mlConfig.headers) ? mlConfig.headers : {};
+    switch (resolved.type) {
+      case "assets":
+        return handleAssetsProxy(
+          event,
+          baseURL,
+          staticHeaders,
+          mlConfig.routes?.assets || "/manage/assets",
+          options?.requestHeaders
+        );
+      case "uploads":
+        return handleUploadsProxy(event, baseURL, staticHeaders, mlConfig.routes, options?.requestHeaders);
+      case "delivery":
+        return handleDeliveryProxy(event, baseURL, staticHeaders, options?.requestHeaders);
+      case "processing":
+        return handleProcessingProxy(event, baseURL, staticHeaders, options?.requestHeaders);
+      case "resource-policy":
+        return handleResourcePolicyProxy(event, baseURL, staticHeaders, options?.requestHeaders);
+    }
+  });
+}
+export function createMLProxy(type, options) {
+  return defineEventHandler(async (event) => {
+    const config = useRuntimeConfig();
+    const mlConfig = config.mediaLibrary ?? {};
+    const baseURL = validateBaseURL(mlConfig.baseURL, type);
+    const staticHeaders = mlConfig.headers && typeof mlConfig.headers === "object" && !Array.isArray(mlConfig.headers) ? mlConfig.headers : {};
+    switch (type) {
+      case "assets":
+        return handleAssetsProxy(
+          event,
+          baseURL,
+          staticHeaders,
+          mlConfig.routes?.assets || "/manage/assets",
+          options?.requestHeaders
+        );
+      case "uploads":
+        return handleUploadsProxy(
+          event,
+          baseURL,
+          staticHeaders,
+          mlConfig.routes,
+          options?.requestHeaders
+        );
+      case "delivery":
+        return handleDeliveryProxy(event, baseURL, staticHeaders, options?.requestHeaders);
+      case "processing":
+        return handleProcessingProxy(event, baseURL, staticHeaders, options?.requestHeaders);
+      case "resource-policy":
+        return handleResourcePolicyProxy(event, baseURL, staticHeaders, options?.requestHeaders);
+      default:
+        throw createError({ statusCode: 500, statusMessage: `Unknown MLProxy type: ${type}` });
+    }
+  });
+}

package/dist/runtime/server/delivery-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/delivery-proxy.js

@@ -0,0 +1,74 @@
+import { createError, defineEventHandler, getRequestHeaders, getRequestURL, proxyRequest } from "h3";
+import { useRuntimeConfig } from "#imports";
+const normalizeHeaders = (headers) => {
+  if (!headers) return {};
+  return typeof headers === "function" ? headers() : headers;
+};
+export default defineEventHandler(async (event) => {
+  try {
+    const config = useRuntimeConfig();
+    const baseURL = config.mediaLibrary?.baseURL;
+    if (!baseURL) {
+      throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL is required for delivery proxying." });
+    }
+    try {
+      const parsed = new URL(baseURL);
+      if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("Invalid protocol");
+      }
+    } catch {
+      throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL must be an absolute http(s) URL." });
+    }
+    const reqUrl = getRequestURL(event);
+    const path = reqUrl.pathname;
+    const prefix = "/api/media-library/delivery";
+    if (!path.startsWith(prefix)) {
+      throw createError({ statusCode: 404, statusMessage: "Not found" });
+    }
+    const rest = path.slice(prefix.length);
+    const method = event.node.req.method || "GET";
+    const trimmedRest = rest.replace(/\/+$/, "");
+    const isCollection = /^\/assets$/.test(trimmedRest);
+    const isResolve = /^\/assets\/resolve$/.test(trimmedRest);
+    const isItem = /^\/assets\/[^/]+$/.test(trimmedRest) && !isResolve;
+    if (!isCollection && !isResolve && !isItem) {
+      throw createError({ statusCode: 404, statusMessage: "Not found" });
+    }
+    if (isCollection && method !== "GET") {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    if (isResolve && method !== "POST") {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    if (isItem && method !== "GET") {
+      throw createError({ statusCode: 405, statusMessage: "Method Not Allowed" });
+    }
+    const upstreamPath = `/delivery${trimmedRest}`;
+    const normalizedBase = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+    const upstreamUrl = new URL(`.${upstreamPath}`, normalizedBase);
+    const incoming = new URLSearchParams(reqUrl.search);
+    incoming.forEach((value, key) => {
+      upstreamUrl.searchParams.append(key, value);
+    });
+    const forwardedHeaders = { ...getRequestHeaders(event) };
+    const extraHeaders = normalizeHeaders(config.mediaLibrary?.headers);
+    const proxyHeaders = { ...forwardedHeaders, ...extraHeaders };
+    delete proxyHeaders.connection;
+    delete proxyHeaders["transfer-encoding"];
+    delete proxyHeaders["keep-alive"];
+    delete proxyHeaders.upgrade;
+    delete proxyHeaders.expect;
+    delete proxyHeaders.host;
+    const result = await proxyRequest(event, upstreamUrl.toString(), {
+      headers: proxyHeaders,
+      streamRequest: true
+    });
+    if (event.node.res.statusCode >= 400) {
+      console.error(`[media-library] delivery-proxy upstream responded ${event.node.res.statusCode} for ${method} ${upstreamUrl.toString()}`);
+    }
+    return result;
+  } catch (err) {
+    console.error("[media-library] delivery-proxy error:", err);
+    throw err;
+  }
+});

package/dist/runtime/server/index.d.ts

@@ -0,0 +1,2 @@
+export { createMLProxy, createMLCatchAllProxy } from './create-ml-proxy.js';
+export type { MLProxyType, MLProxyOptions } from './create-ml-proxy.js';

package/dist/runtime/server/index.js

@@ -0,0 +1 @@
+export { createMLProxy, createMLCatchAllProxy } from "./create-ml-proxy.js";

package/dist/runtime/server/processing-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;

package/dist/runtime/server/processing-proxy.js

@@ -0,0 +1,55 @@
+import { createError, defineEventHandler, getRequestHeaders, getRequestURL, proxyRequest, readRawBody } from "h3";
+import { useRuntimeConfig } from "#imports";
+const normalizeHeaders = (headers) => {
+  if (!headers) return {};
+  return typeof headers === "function" ? headers() : headers;
+};
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig();
+  const baseURL = config.mediaLibrary?.baseURL;
+  if (!baseURL) {
+    throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL is required for processing proxying." });
+  }
+  try {
+    const parsed = new URL(baseURL);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      throw new Error("Invalid protocol");
+    }
+  } catch {
+    throw createError({ statusCode: 500, statusMessage: "mediaLibrary.baseURL must be an absolute http(s) URL." });
+  }
+  const reqUrl = getRequestURL(event);
+  const path = reqUrl.pathname;
+  const prefix = "/api/media-library/manage/processing";
+  if (!path.startsWith(prefix)) {
+    throw createError({ statusCode: 404, statusMessage: "Not found" });
+  }
+  const rest = path.slice(prefix.length);
+  const method = event.node.req.method || "GET";
+  const allowed = /^\/stream$/.test(rest) && method === "GET" || /^\/assets\/[^/]+\/stream$/.test(rest) && method === "GET" || /^\/assets\/[^/]+\/tasks$/.test(rest) && method === "GET" || /^\/assets\/[^/]+\/process$/.test(rest) && method === "POST" || /^\/tasks\/[^/]+\/retry$/.test(rest) && method === "POST" || /^\/tasks\/[^/]+\/configure$/.test(rest) && method === "POST" || /^\/processors$/.test(rest) && method === "GET";
+  if (!allowed) {
+    throw createError({ statusCode: 404, statusMessage: "Not found" });
+  }
+  const upstreamPath = `/manage/processing${rest}`;
+  const normalizedBase = baseURL.endsWith("/") ? baseURL : `${baseURL}/`;
+  const upstreamUrl = new URL(`.${upstreamPath}`, normalizedBase);
+  const incoming = new URLSearchParams(reqUrl.search);
+  incoming.forEach((value, key) => {
+    upstreamUrl.searchParams.append(key, value);
+  });
+  const forwardedHeaders = { ...getRequestHeaders(event) };
+  const extraHeaders = normalizeHeaders(config.mediaLibrary?.headers);
+  const proxyHeaders = { ...forwardedHeaders, ...extraHeaders };
+  delete proxyHeaders.connection;
+  delete proxyHeaders["transfer-encoding"];
+  delete proxyHeaders["keep-alive"];
+  delete proxyHeaders.upgrade;
+  delete proxyHeaders.expect;
+  delete proxyHeaders.host;
+  const hasBody = method !== "GET" && method !== "HEAD";
+  const body = hasBody ? await readRawBody(event, false) : void 0;
+  return proxyRequest(event, upstreamUrl.toString(), {
+    headers: proxyHeaders,
+    ...body !== void 0 ? { body } : {}
+  });
+});

package/dist/runtime/server/resource-policy-proxy.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<any>>;
+export default _default;