@notionx/core 0.1.0

package/dist/media/routes/index.js

@@ -0,0 +1,585 @@
+// src/media/routes/notion-media.ts
+import { NextResponse } from "next/server";
+import { getRequestExecutionContext } from "vinext/shims/request-context";
+
+// src/cache/cache-keys.ts
+var CACHE_ORIGIN = "https://cache.local";
+var CACHE_NAMESPACE = "/__public-cache/v20260609a";
+var NOTION_MEDIA_R2_PREFIX = "notion-media/v1";
+function normalizePath(pathname) {
+  if (pathname === "/") return "/";
+  return pathname.endsWith("/") ? pathname.slice(0, -1) : pathname;
+}
+function publicMediaVariantForAccept(accept) {
+  if (accept.includes("image/avif")) return "avif";
+  if (accept.includes("image/webp")) return "webp";
+  return "source";
+}
+function publicMediaCacheKeyForUrl(input, variant) {
+  const url = new URL(
+    `${CACHE_NAMESPACE}${normalizePath(input.pathname)}${input.search}`,
+    CACHE_ORIGIN
+  );
+  url.searchParams.set("__variant", variant);
+  url.searchParams.sort();
+  return url.toString();
+}
+function keySegment(value) {
+  return encodeURIComponent(value || "none");
+}
+function notionMediaR2KeyForUrl(input, variant) {
+  if (variant === "source") return null;
+  const version = input.searchParams.get("v");
+  if (!version) return null;
+  const path = normalizePath(input.pathname).split("/").filter(Boolean).map(keySegment).join("/");
+  const width = input.searchParams.get("w") ?? "source";
+  const quality = input.searchParams.get("q") ?? "source";
+  return [
+    NOTION_MEDIA_R2_PREFIX,
+    variant,
+    path,
+    `v-${keySegment(version)}`,
+    `w-${keySegment(width)}`,
+    `q-${keySegment(quality)}.${variant}`
+  ].join("/");
+}
+
+// src/notion/client.ts
+import { Client } from "@notionhq/client";
+function createNotionClient(config) {
+  return new Client({
+    auth: config.token,
+    baseUrl: config.apiBaseUrl,
+    notionVersion: "2026-03-11"
+  });
+}
+
+// src/notion/config.ts
+function readProcessEnv() {
+  const env2 = {
+    NOTION_TOKEN: process.env.NOTION_TOKEN,
+    NOTION_DATA_SOURCE_ID: process.env.NOTION_DATA_SOURCE_ID,
+    NOTION_MOVIES_DATA_SOURCE_ID: process.env.NOTION_MOVIES_DATA_SOURCE_ID,
+    NOTION_API_BASE_URL: process.env.NOTION_API_BASE_URL,
+    NOTION_EDIT_BASE_URL: process.env.NOTION_EDIT_BASE_URL,
+    NOTION_WEBHOOK_VERIFICATION_TOKEN: process.env.NOTION_WEBHOOK_VERIFICATION_TOKEN
+  };
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.startsWith("NOTION_") && typeof value === "string") {
+      env2[key] = value;
+    }
+  }
+  return env2;
+}
+async function readWorkerEnv() {
+  try {
+    const mod = await import(
+      /* webpackIgnore: true */
+      "cloudflare:workers"
+    );
+    const env2 = {};
+    for (const [key, value] of Object.entries(mod.env ?? {})) {
+      if (key.startsWith("NOTION_") && typeof value === "string") {
+        env2[key] = value;
+      }
+    }
+    return env2;
+  } catch {
+    return {};
+  }
+}
+function readString(source, name) {
+  const value = String(source[name] ?? "").trim();
+  return value || void 0;
+}
+function mergeEnv(...sources) {
+  const merged = {};
+  for (const source of sources) {
+    for (const name of Object.keys(source)) {
+      if (!name.startsWith("NOTION_")) continue;
+      const value = readString(source, name);
+      if (value) merged[name] = value;
+    }
+  }
+  return merged;
+}
+async function readEnv() {
+  const processEnv = readProcessEnv();
+  return mergeEnv(await readWorkerEnv(), processEnv);
+}
+function readRequired(source, name) {
+  const value = readString(source, name);
+  if (!value) {
+    throw new Error(`Missing required Notion env: ${name}`);
+  }
+  return value;
+}
+async function getNotionClientConfig() {
+  const env2 = await readEnv();
+  return {
+    token: readRequired(env2, "NOTION_TOKEN"),
+    apiBaseUrl: readString(env2, "NOTION_API_BASE_URL")
+  };
+}
+
+// src/notion/media.ts
+function normalizeNotionFileSource(input) {
+  const file = input;
+  if (!file || typeof file !== "object") return null;
+  if (file.type === "external") {
+    const url = String(file.external?.url ?? "").trim();
+    return url ? { type: "external", url } : null;
+  }
+  if (file.type === "file") {
+    const url = String(file.file?.url ?? "").trim();
+    if (!url) return null;
+    return {
+      type: "file",
+      url,
+      expiryTime: String(file.file?.expiry_time ?? "").trim() || null
+    };
+  }
+  return null;
+}
+function pickFirstFilesPropertyValue(property) {
+  const value = property;
+  if (!value || value.type !== "files" || !Array.isArray(value.files)) {
+    return null;
+  }
+  return value.files[0] ?? null;
+}
+function fileObjectForMediaBlock(block) {
+  const typed = block[block.type];
+  if (!typed || typeof typed !== "object") return null;
+  if (block.type === "image" || block.type === "video" || block.type === "file" || block.type === "pdf" || block.type === "audio") {
+    return typed;
+  }
+  return null;
+}
+
+// src/util/env.ts
+import { env } from "cloudflare:workers";
+var workerEnv = env;
+
+// src/platform/runtime.ts
+function cacheRequestForKey(key) {
+  return new Request(key, { method: "GET" });
+}
+function createCloudflarePublicCacheAdapter(cache) {
+  return {
+    kind: "cloudflare-cache",
+    async match(key) {
+      return await cache.match(cacheRequestForKey(key)) ?? null;
+    },
+    put(key, response) {
+      return cache.put(cacheRequestForKey(key), response);
+    },
+    delete(key) {
+      return cache.delete(cacheRequestForKey(key));
+    }
+  };
+}
+function createCloudflareKeyValueCacheAdapter(namespace) {
+  return {
+    kind: "workers-kv",
+    async get(key, options) {
+      return await namespace.get(key, {
+        type: "json",
+        cacheTtl: options?.cacheTtl
+      });
+    },
+    async put(key, value, options) {
+      await namespace.put(key, JSON.stringify(value), {
+        expirationTtl: options?.expirationTtl,
+        metadata: options?.metadata
+      });
+    },
+    delete(key) {
+      return namespace.delete(key);
+    },
+    async list(options) {
+      const result = await namespace.list({
+        prefix: options?.prefix,
+        limit: options?.limit,
+        cursor: options?.cursor
+      });
+      return {
+        keys: result.keys.map((key) => ({ name: key.name })),
+        cursor: result.list_complete ? void 0 : result.cursor,
+        listComplete: result.list_complete
+      };
+    }
+  };
+}
+function r2ObjectToStoredObject(object) {
+  return {
+    body: object.body,
+    size: object.size,
+    etag: object.etag,
+    contentType: object.httpMetadata?.contentType
+  };
+}
+function createCloudflareRuntimePlatform(env2, options) {
+  const database = env2.DB ? {
+    kind: "d1",
+    prepare(query) {
+      return env2.DB.prepare(query);
+    },
+    async batch(statements) {
+      return await env2.DB.batch(
+        statements
+      );
+    }
+  } : null;
+  const objectStorage = env2.ASSETS_BUCKET ? {
+    kind: "r2",
+    async get(key) {
+      const object = await env2.ASSETS_BUCKET?.get(key);
+      return object ? r2ObjectToStoredObject(object) : null;
+    },
+    async put(key, value, options2) {
+      await env2.ASSETS_BUCKET?.put(key, value, {
+        httpMetadata: {
+          contentType: options2?.contentType,
+          cacheControl: options2?.cacheControl
+        },
+        customMetadata: options2?.metadata
+      });
+    },
+    async delete(key) {
+      await env2.ASSETS_BUCKET?.delete(key);
+    },
+    async list(options2) {
+      const listed = await env2.ASSETS_BUCKET?.list({
+        prefix: options2?.prefix,
+        limit: options2?.limit
+      });
+      return listed?.objects.map((object) => ({
+        key: object.key,
+        size: object.size,
+        uploaded: object.uploaded
+      })) ?? [];
+    }
+  } : null;
+  const imageTransformer = env2.IMAGES ? {
+    kind: "cloudflare-images",
+    async transform(body, options2) {
+      const result = await env2.IMAGES.input(body).transform(options2.width ? { width: options2.width } : {}).output({
+        format: options2.format,
+        quality: options2.quality
+      });
+      return {
+        body: result.image(),
+        contentType: result.contentType(),
+        response: () => result.response()
+      };
+    }
+  } : null;
+  const keyValueCache = env2.CONTENT_CACHE ? createCloudflareKeyValueCacheAdapter(env2.CONTENT_CACHE) : null;
+  return {
+    id: "cloudflare-workers",
+    database,
+    objectStorage,
+    imageTransformer,
+    keyValueCache,
+    publicCache: options?.publicCache ? createCloudflarePublicCacheAdapter(options.publicCache) : null
+  };
+}
+
+// src/platform/cloudflare-runtime.ts
+function getDefaultCloudflareCache() {
+  const globalWithCaches = globalThis;
+  return globalWithCaches.caches?.default ?? null;
+}
+function getRuntimePlatform() {
+  return createCloudflareRuntimePlatform(workerEnv, {
+    publicCache: getDefaultCloudflareCache()
+  });
+}
+function getPublicCache() {
+  const cache = getDefaultCloudflareCache();
+  if (!cache) {
+    throw new Error("Cloudflare cache binding not configured");
+  }
+  return createCloudflarePublicCacheAdapter(cache);
+}
+
+// src/platform/current.ts
+function getRuntimePlatform2() {
+  return getRuntimePlatform();
+}
+function getPublicCache2() {
+  return getPublicCache();
+}
+
+// src/media/routes/notion-media.ts
+var DEFAULT_WIDTH = 1200;
+var MAX_WIDTH = 2400;
+var DEFAULT_QUALITY = 75;
+var MIN_QUALITY = 40;
+var MAX_QUALITY = 85;
+var CACHEABLE_STATUS = /* @__PURE__ */ new Set([200]);
+var notionMediaRoute = {
+  async GET(_request, props) {
+    const { ref } = await props.params;
+    if (ref.some((part) => part === ".." || part.includes("/"))) {
+      return badRequest();
+    }
+    const url = new URL(_request.url);
+    url.pathname = buildNotionMediaPath(ref);
+    return notionMediaRoute.handle(new Request(url.toString(), _request));
+  },
+  async handle(request) {
+    const variant = publicMediaVariantForAccept(
+      request.headers.get("accept") ?? ""
+    );
+    return withEdgeMediaCache(request, variant, () => loadMedia(request));
+  }
+};
+function buildNotionMediaPath(ref) {
+  return `/api/notion/media/${ref.map(encodeURIComponent).join("/")}`;
+}
+function clampInt(value, min, max, fallback) {
+  const parsed = Number.parseInt(value ?? "", 10);
+  if (!Number.isFinite(parsed)) return fallback;
+  return Math.max(min, Math.min(max, parsed));
+}
+function cacheControl(request) {
+  const url = new URL(request.url);
+  if (url.searchParams.has("v")) {
+    return "public, max-age=31536000, immutable";
+  }
+  return "public, max-age=3600, s-maxage=3600, stale-while-revalidate=86400";
+}
+function canUseMediaCache(request) {
+  if (request.method !== "GET") return false;
+  return !request.headers.has("range");
+}
+function mediaCacheHeaders(response, request, state, r2State) {
+  const headers = new Headers(response.headers);
+  headers.set("Cache-Control", cacheControl(request));
+  headers.set("X-Notion-Media-Cache", state);
+  if (r2State) headers.set("X-Notion-Media-R2", r2State);
+  return headers;
+}
+async function responseFromR2Cache(request, variant) {
+  const url = new URL(request.url);
+  const r2Key = notionMediaR2KeyForUrl(url, variant);
+  const storage = getRuntimePlatform2().objectStorage;
+  if (!r2Key || !storage) return null;
+  const object = await storage.get(r2Key);
+  if (!object?.body) return null;
+  const contentType = object.contentType ?? (variant === "avif" ? "image/avif" : "image/webp");
+  const headers = new Headers();
+  headers.set("Content-Type", contentType);
+  headers.set("Cache-Control", cacheControl(request));
+  headers.set("Vary", "Accept");
+  headers.set("X-Notion-Media-Branch", "r2");
+  headers.set("X-Notion-Media-R2", "HIT");
+  if (object.etag) headers.set("ETag", object.etag);
+  return new Response(object.body, { headers });
+}
+async function withEdgeMediaCache(request, variant, load) {
+  if (!canUseMediaCache(request)) {
+    const response2 = await load();
+    return new Response(response2.body, {
+      status: response2.status,
+      headers: mediaCacheHeaders(response2, request, "BYPASS")
+    });
+  }
+  const url = new URL(request.url);
+  const cache = getPublicCache2();
+  const cacheKey = publicMediaCacheKeyForUrl(url, variant);
+  const cached = await cache.match(cacheKey);
+  if (cached) {
+    return new Response(cached.body, {
+      status: cached.status,
+      headers: mediaCacheHeaders(cached, request, "HIT")
+    });
+  }
+  const r2Response = await responseFromR2Cache(request, variant);
+  const response = r2Response ?? await load();
+  const headers = mediaCacheHeaders(response, request, "MISS");
+  const output = new Response(response.body, {
+    status: response.status,
+    headers
+  });
+  if (CACHEABLE_STATUS.has(response.status)) {
+    const toCache = output.clone();
+    getRequestExecutionContext()?.waitUntil(cache.put(cacheKey, toCache));
+  }
+  return output;
+}
+function mediaRedirect(url) {
+  const response = NextResponse.redirect(url, 302);
+  response.headers.set(
+    "Cache-Control",
+    "public, max-age=300, s-maxage=300, stale-while-revalidate=300"
+  );
+  return response;
+}
+function notFound() {
+  return NextResponse.json({ error: "Not found" }, { status: 404 });
+}
+function badRequest() {
+  return NextResponse.json({ error: "Invalid media ref" }, { status: 400 });
+}
+function forbidden() {
+  return NextResponse.json({ error: "Forbidden" }, { status: 403 });
+}
+async function serveFileObject(input, request, options) {
+  const source = normalizeNotionFileSource(input);
+  if (!source) return notFound();
+  if (options?.redirectNotionHosted) return mediaRedirect(source.url);
+  return proxyNotionHostedFile(source.url, request);
+}
+async function proxyNotionHostedFile(url, request) {
+  const range = request.headers.get("range");
+  const ifRange = request.headers.get("if-range");
+  const upstreamHeaders = new Headers({
+    Accept: request.headers.get("accept") ?? "*/*"
+  });
+  if (range) upstreamHeaders.set("Range", range);
+  if (ifRange) upstreamHeaders.set("If-Range", ifRange);
+  const upstream = await fetch(url, {
+    headers: upstreamHeaders
+  });
+  if (!upstream.ok && upstream.status !== 416 || !upstream.body) {
+    return NextResponse.json(
+      { error: "Unable to fetch Notion media" },
+      { status: upstream.status || 502 }
+    );
+  }
+  const contentType = upstream.headers.get("content-type") ?? "";
+  const isImage = contentType.startsWith("image/");
+  const accept = request.headers.get("accept") ?? "";
+  const variant = publicMediaVariantForAccept(accept);
+  const urlObj = new URL(request.url);
+  const width = clampInt(
+    urlObj.searchParams.get("w"),
+    64,
+    MAX_WIDTH,
+    DEFAULT_WIDTH
+  );
+  const quality = clampInt(
+    urlObj.searchParams.get("q"),
+    MIN_QUALITY,
+    MAX_QUALITY,
+    DEFAULT_QUALITY
+  );
+  let outputFormat = null;
+  if (variant === "avif") {
+    outputFormat = "image/avif";
+  } else if (variant === "webp") {
+    outputFormat = "image/webp";
+  }
+  const platform = getRuntimePlatform2();
+  const imageTransformer = platform.imageTransformer;
+  if (isImage && !range && outputFormat && imageTransformer) {
+    const r2Key = notionMediaR2KeyForUrl(urlObj, variant);
+    try {
+      const result = await imageTransformer.transform(upstream.body, {
+        width,
+        format: outputFormat,
+        quality
+      });
+      const transformed = result.response();
+      const headers2 = new Headers(transformed.headers);
+      headers2.set("Content-Type", result.contentType);
+      headers2.set("Cache-Control", cacheControl(request));
+      headers2.set("Vary", "Accept");
+      headers2.set("X-Notion-Media-Branch", "transformed");
+      headers2.set("X-Notion-Media-R2", r2Key ? "MISS" : "BYPASS");
+      headers2.set("X-Optimized-Width", String(width));
+      headers2.set("X-Optimized-Quality", String(quality));
+      if (transformed.body && r2Key && platform.objectStorage) {
+        const [clientBody, r2Body] = transformed.body.tee();
+        getRequestExecutionContext()?.waitUntil(
+          platform.objectStorage.put(r2Key, r2Body, {
+            contentType: result.contentType,
+            cacheControl: "public, max-age=31536000, immutable",
+            metadata: {
+              source: "notion",
+              cachedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              width: String(width),
+              quality: String(quality)
+            }
+          })
+        );
+        return new Response(clientBody, { headers: headers2 });
+      }
+      return new Response(transformed.body, { headers: headers2 });
+    } catch {
+    }
+  }
+  const headers = new Headers();
+  for (const header of [
+    "accept-ranges",
+    "content-disposition",
+    "content-encoding",
+    "content-length",
+    "content-range",
+    "content-type",
+    "etag",
+    "last-modified"
+  ]) {
+    const value = upstream.headers.get(header);
+    if (value) headers.set(header, value);
+  }
+  if (contentType && !headers.has("Content-Type")) {
+    headers.set("Content-Type", contentType);
+  }
+  headers.set("Cache-Control", cacheControl(request));
+  headers.set("X-Notion-Media-Branch", "proxied");
+  return new Response(upstream.body, { status: upstream.status, headers });
+}
+async function loadMedia(request) {
+  const url = new URL(request.url);
+  const ref = readRefFromPathname(url.pathname);
+  if (!ref) return badRequest();
+  const client = createNotionClient(await getNotionClientConfig());
+  if (ref[0] === "page" && ref[1] && ref[2] === "cover") {
+    const page = await client.pages.retrieve({
+      page_id: ref[1]
+    });
+    return serveFileObject(page.cover, request);
+  }
+  if (ref[0] === "page" && ref[1] && ref[2] === "property" && ref[3]) {
+    const page = await client.pages.retrieve({
+      page_id: ref[1]
+    });
+    const propertyName = decodeURIComponent(ref.slice(3).join("/"));
+    return serveFileObject(
+      pickFirstFilesPropertyValue(page.properties?.[propertyName]),
+      request
+    );
+  }
+  if (ref[0] === "block" && ref[1]) {
+    const block = await client.blocks.retrieve({
+      block_id: ref[1]
+    });
+    if (block.type === "video") {
+      return forbidden();
+    }
+    return serveFileObject(fileObjectForMediaBlock(block), request, {
+      redirectNotionHosted: block.type === "audio" || block.type === "pdf" || block.type === "file"
+    });
+  }
+  return badRequest();
+}
+function readRefFromPathname(pathname) {
+  const prefix = "/api/notion/media/";
+  if (!pathname.startsWith(prefix)) return null;
+  const encoded = pathname.slice(prefix.length);
+  if (!encoded) return null;
+  return encoded.split("/").map((part) => decodeURIComponent(part));
+}
+var GET = notionMediaRoute.GET;
+async function notionMediaRouteHandle(request) {
+  return notionMediaRoute.handle(request);
+}
+export {
+  notionMediaRoute,
+  notionMediaRouteHandle
+};
+//# sourceMappingURL=index.js.map