@notionx/core 0.1.0

package/dist/notion/index.js

@@ -0,0 +1,1278 @@
+// 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
+var DEFAULT_NOTION_MOVIES_DATA_SOURCE_ID = "371dc62d-0738-8015-a601-000bc3944fcb";
+function readProcessEnv() {
+  const env = {
+    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") {
+      env[key] = value;
+    }
+  }
+  return env;
+}
+async function readWorkerEnv() {
+  try {
+    const mod = await import(
+      /* webpackIgnore: true */
+      "cloudflare:workers"
+    );
+    const env = {};
+    for (const [key, value] of Object.entries(mod.env ?? {})) {
+      if (key.startsWith("NOTION_") && typeof value === "string") {
+        env[key] = value;
+      }
+    }
+    return env;
+  } 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;
+}
+function getNotionEditBaseUrl() {
+  return readString(readProcessEnv(), "NOTION_EDIT_BASE_URL") ?? "https://www.notion.so";
+}
+async function hasNotionConfig() {
+  const env = await readEnv();
+  return Boolean(
+    readString(env, "NOTION_TOKEN") && readString(env, "NOTION_DATA_SOURCE_ID")
+  );
+}
+async function hasNotionMovieConfig() {
+  const env = await readEnv();
+  return Boolean(readString(env, "NOTION_TOKEN"));
+}
+async function hasNotionModelConfig(model) {
+  const env = await readEnv();
+  return Boolean(
+    readString(env, "NOTION_TOKEN") && (readString(env, model.source.dataSourceEnv) || model.source.defaultDataSourceId)
+  );
+}
+async function getNotionClientConfig() {
+  const env = await readEnv();
+  return {
+    token: readRequired(env, "NOTION_TOKEN"),
+    apiBaseUrl: readString(env, "NOTION_API_BASE_URL")
+  };
+}
+async function getNotionConfig() {
+  const env = await readEnv();
+  return {
+    token: readRequired(env, "NOTION_TOKEN"),
+    dataSourceId: readRequired(env, "NOTION_DATA_SOURCE_ID"),
+    apiBaseUrl: readString(env, "NOTION_API_BASE_URL"),
+    editBaseUrl: readString(env, "NOTION_EDIT_BASE_URL"),
+    webhookVerificationToken: readString(
+      env,
+      "NOTION_WEBHOOK_VERIFICATION_TOKEN"
+    )
+  };
+}
+async function getNotionWebhookVerificationToken() {
+  const env = await readEnv();
+  return readString(env, "NOTION_WEBHOOK_VERIFICATION_TOKEN");
+}
+async function getNotionMovieConfig() {
+  const env = await readEnv();
+  return {
+    token: readRequired(env, "NOTION_TOKEN"),
+    dataSourceId: readString(env, "NOTION_MOVIES_DATA_SOURCE_ID") ?? DEFAULT_NOTION_MOVIES_DATA_SOURCE_ID,
+    apiBaseUrl: readString(env, "NOTION_API_BASE_URL"),
+    editBaseUrl: readString(env, "NOTION_EDIT_BASE_URL"),
+    webhookVerificationToken: readString(
+      env,
+      "NOTION_WEBHOOK_VERIFICATION_TOKEN"
+    )
+  };
+}
+async function getNotionConfigForModel(model) {
+  const env = await readEnv();
+  const dataSourceId = readString(env, model.source.dataSourceEnv) ?? model.source.defaultDataSourceId;
+  if (!dataSourceId) {
+    throw new Error(`Missing required Notion env: ${model.source.dataSourceEnv}`);
+  }
+  return {
+    token: readRequired(env, model.source.tokenEnv),
+    dataSourceId,
+    apiBaseUrl: readString(env, "NOTION_API_BASE_URL"),
+    editBaseUrl: readString(env, "NOTION_EDIT_BASE_URL"),
+    webhookVerificationToken: readString(
+      env,
+      "NOTION_WEBHOOK_VERIFICATION_TOKEN"
+    )
+  };
+}
+
+// src/notion/blocks.ts
+function normalizeBlock(input) {
+  if (!input || typeof input !== "object") return null;
+  const block = input;
+  return block.id && block.type ? block : null;
+}
+async function listBlockChildren(client, blockId) {
+  const results = [];
+  let cursor;
+  do {
+    const response = await client.blocks.children.list({
+      block_id: blockId,
+      page_size: 100,
+      ...cursor ? { start_cursor: cursor } : {}
+    });
+    for (const item of response.results ?? []) {
+      const block = normalizeBlock(item);
+      if (block) results.push(block);
+    }
+    cursor = response.next_cursor ?? void 0;
+    if (!response.has_more) break;
+  } while (cursor);
+  return results;
+}
+async function listBlockChildrenDeep(client, blockId, options) {
+  const maxDepth = options?.maxDepth ?? 6;
+  async function visit(id, depth) {
+    const children = await listBlockChildren(client, id);
+    if (depth >= maxDepth) return children;
+    return Promise.all(
+      children.map(async (block) => {
+        if (!block.has_children) return block;
+        return {
+          ...block,
+          children: await visit(block.id, depth + 1)
+        };
+      })
+    );
+  }
+  return visit(blockId, 0);
+}
+
+// src/notion/block-text.ts
+function typedValue(block) {
+  return block[block.type] ?? {};
+}
+function richTextPlainText(parts) {
+  if (!Array.isArray(parts)) return "";
+  return parts.map(
+    (part) => part.type === "equation" ? part.equation?.expression ?? "" : part.plain_text ?? part.text?.content ?? ""
+  ).join("");
+}
+function blockPlainText(block) {
+  const value = typedValue(block);
+  const text = [
+    richTextPlainText(value.rich_text),
+    richTextPlainText(value.caption),
+    richTextPlainText(value.title),
+    value.expression ?? "",
+    ...(value.cells ?? []).map(richTextPlainText)
+  ];
+  return text.filter(Boolean).join(" ");
+}
+function flattenNotionBlockText(blocks) {
+  const parts = [];
+  function visit(block) {
+    const text = blockPlainText(block).trim();
+    if (text) parts.push(text);
+    for (const child of block.children ?? []) {
+      visit(child);
+    }
+  }
+  for (const block of blocks) visit(block);
+  return parts.join(" ").normalize("NFKC").replace(/\s+/g, " ").trim();
+}
+
+// src/notion/content-cache.ts
+var CACHE_VERSION = "v2";
+var NOTION_LIST_CACHE_TTL_SECONDS = 300;
+var NOTION_BLOCKS_CACHE_TTL_SECONDS = 60 * 60 * 24;
+var CONTENT_CACHE_READ_TTL_SECONDS = 60;
+function modelPrefix(modelId) {
+  return `notion:${CACHE_VERSION}:${modelId}`;
+}
+function notionModelListCacheKey(modelId) {
+  return `${modelPrefix(modelId)}:list`;
+}
+function versionSegment(value) {
+  const version = String(value ?? "").trim();
+  return version ? `:v:${encodeURIComponent(version)}` : "";
+}
+function notionPageBlocksCacheKey(modelId, pageId, cacheVersion) {
+  return `${modelPrefix(modelId)}:page:${pageId}:blocks${versionSegment(cacheVersion)}`;
+}
+function notionModelCachePrefix(modelId) {
+  return `${modelPrefix(modelId)}:`;
+}
+function notionPageCachePrefix(modelId, pageId) {
+  return `${modelPrefix(modelId)}:page:${pageId}:`;
+}
+function logNotionContentCache(fields) {
+  try {
+    console.log(JSON.stringify({ tag: "notion_content_cache", ...fields }));
+  } catch {
+  }
+}
+async function getCachedNotionValue(cache2, key) {
+  if (!cache2) return null;
+  try {
+    const value = await cache2.get(key, {
+      cacheTtl: CONTENT_CACHE_READ_TTL_SECONDS
+    });
+    logNotionContentCache({
+      op: "get",
+      key,
+      hit: value !== null,
+      cache: cache2.kind
+    });
+    return value;
+  } catch (error) {
+    logNotionContentCache({
+      op: "get_error",
+      key,
+      cache: cache2.kind,
+      message: error instanceof Error ? error.message : String(error)
+    });
+    return null;
+  }
+}
+async function putCachedNotionValue(cache2, key, value, options) {
+  if (!cache2) return;
+  try {
+    await cache2.put(key, value, {
+      expirationTtl: options?.expirationTtl ?? NOTION_BLOCKS_CACHE_TTL_SECONDS,
+      metadata: {
+        source: "notion",
+        cachedAt: (/* @__PURE__ */ new Date()).toISOString()
+      }
+    });
+    logNotionContentCache({
+      op: "put",
+      key,
+      cache: cache2.kind
+    });
+  } catch (error) {
+    logNotionContentCache({
+      op: "put_error",
+      key,
+      cache: cache2.kind,
+      message: error instanceof Error ? error.message : String(error)
+    });
+  }
+}
+async function getCachedNotionBlocks(cache2, input) {
+  return getCachedNotionValue(
+    cache2,
+    notionPageBlocksCacheKey(input.modelId, input.pageId, input.cacheVersion)
+  );
+}
+async function putCachedNotionBlocks(cache2, input) {
+  await putCachedNotionValue(
+    cache2,
+    notionPageBlocksCacheKey(input.modelId, input.pageId, input.cacheVersion),
+    input.blocks,
+    { expirationTtl: NOTION_BLOCKS_CACHE_TTL_SECONDS }
+  );
+}
+async function deleteNotionContentCache(input) {
+  let cache2;
+  try {
+    cache2 = input.cache ?? input.getCache?.() ?? null;
+  } catch (error) {
+    return {
+      ok: false,
+      skipped: true,
+      deleted: [],
+      failed: [
+        {
+          error: error instanceof Error ? error.message : String(error)
+        }
+      ]
+    };
+  }
+  if (!cache2) {
+    return { ok: true, skipped: true, deleted: [], failed: [] };
+  }
+  const prefixes = /* @__PURE__ */ new Set();
+  if (input.pageId) {
+    prefixes.add(notionPageCachePrefix(input.modelId, input.pageId));
+  } else {
+    prefixes.add(notionModelCachePrefix(input.modelId));
+  }
+  prefixes.add(notionModelListCacheKey(input.modelId));
+  const deleted = [];
+  const failed = [];
+  for (const prefix of prefixes) {
+    let cursor;
+    do {
+      try {
+        const result = await cache2.list({ prefix, cursor, limit: 100 });
+        for (const { name } of result.keys) {
+          try {
+            await cache2.delete(name);
+            deleted.push(name);
+          } catch (error) {
+            failed.push({
+              key: name,
+              error: error instanceof Error ? error.message : String(error)
+            });
+          }
+        }
+        cursor = result.listComplete ? void 0 : result.cursor;
+      } catch (error) {
+        failed.push({
+          key: prefix,
+          error: error instanceof Error ? error.message : String(error)
+        });
+        cursor = void 0;
+      }
+    } while (cursor);
+  }
+  return {
+    ok: failed.length === 0,
+    skipped: false,
+    deleted,
+    failed
+  };
+}
+
+// src/notion/media.ts
+function stripLeadingSlash(value) {
+  return value.startsWith("/") ? value.slice(1) : value;
+}
+function encodePathPart(value) {
+  return encodeURIComponent(stripLeadingSlash(value));
+}
+function appendVersion(path, version) {
+  const value = String(version ?? "").trim();
+  if (!value) return path;
+  return `${path}?${new URLSearchParams({ v: value })}`;
+}
+function blockVersion(block) {
+  return typeof block.last_edited_time === "string" ? block.last_edited_time : void 0;
+}
+function notionPageCoverMediaPath(pageId) {
+  return `/api/notion/media/page/${encodePathPart(pageId)}/cover`;
+}
+function notionPagePropertyMediaPath(pageId, propertyName) {
+  return `/api/notion/media/page/${encodePathPart(pageId)}/property/${encodePathPart(propertyName)}`;
+}
+function notionBlockMediaPath(blockId) {
+  return `/api/notion/media/block/${encodePathPart(blockId)}`;
+}
+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 resolveNotionFileUrl(input) {
+  return normalizeNotionFileSource(input)?.url ?? null;
+}
+function isNotionHostedFile(input) {
+  return normalizeNotionFileSource(input)?.type === "file";
+}
+function pickFirstFilesPropertyValue(property) {
+  const value = property;
+  if (!value || value.type !== "files" || !Array.isArray(value.files)) {
+    return null;
+  }
+  return value.files[0] ?? null;
+}
+function pickPageCoverFile(page) {
+  return page.cover ?? null;
+}
+function coverImageUrlForPage(page, coverPropertyName = "Cover") {
+  const propertyFile = pickFirstFilesPropertyValue(
+    page.properties?.[coverPropertyName]
+  );
+  const propertySource = normalizeNotionFileSource(propertyFile);
+  if (propertySource) {
+    return appendVersion(
+      notionPagePropertyMediaPath(page.id, coverPropertyName),
+      page.last_edited_time
+    );
+  }
+  const coverSource = normalizeNotionFileSource(pickPageCoverFile(page));
+  if (coverSource) {
+    return appendVersion(notionPageCoverMediaPath(page.id), page.last_edited_time);
+  }
+  return 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;
+}
+function mediaUrlForBlock(block) {
+  const source = normalizeNotionFileSource(fileObjectForMediaBlock(block));
+  if (!source) return null;
+  if (source.type === "external" && block.type !== "image") {
+    return source.url;
+  }
+  return appendVersion(notionBlockMediaPath(block.id), blockVersion(block));
+}
+function firstImageUrlFromBlocks(blocks) {
+  for (const block of blocks) {
+    if (block.type === "image") {
+      const imageUrl = mediaUrlForBlock(block);
+      if (imageUrl) return imageUrl;
+    }
+    const nested = block.children?.length ? firstImageUrlFromBlocks(block.children) : null;
+    if (nested) return nested;
+  }
+  return null;
+}
+function publicMediaBlockForApi(block) {
+  const value = block[block.type];
+  const source = normalizeNotionFileSource(value);
+  const children = block.children?.map(publicMediaBlockForApi);
+  if (!source) {
+    return children ? { ...block, children } : { ...block };
+  }
+  const path = appendVersion(notionBlockMediaPath(block.id), blockVersion(block));
+  const publicValue = source.type === "external" ? block.type === "image" ? {
+    ...value,
+    external: { url: path }
+  } : value : {
+    ...value,
+    file: {
+      url: path,
+      expiry_time: null
+    }
+  };
+  return {
+    ...block,
+    [block.type]: publicValue,
+    ...children ? { children } : {}
+  };
+}
+function gatedMediaBlockForApi(block, options) {
+  const value = block[block.type];
+  const source = normalizeNotionFileSource(value);
+  const children = block.children?.map(
+    (child) => gatedMediaBlockForApi(child, options)
+  );
+  if (block.type !== "video" || !source) {
+    const publicBlock = publicMediaBlockForApi(block);
+    return children ? { ...publicBlock, children } : publicBlock;
+  }
+  const gatedValue = {
+    ...value,
+    gated: true,
+    access_url: options?.movieId ? `/api/movies/${encodePathPart(options.movieId)}/video/${encodePathPart(block.id)}` : null
+  };
+  if (source.type === "external") {
+    gatedValue.external = { url: null };
+  } else {
+    gatedValue.file = {
+      url: null,
+      expiry_time: null
+    };
+  }
+  return {
+    ...block,
+    video: gatedValue,
+    ...children ? { children } : {}
+  };
+}
+function isDirectVideoUrl(url) {
+  try {
+    const parsed = new URL(url);
+    return /\.(mp4|webm|mov|m4v)(?:$|\?)/i.test(parsed.pathname);
+  } catch {
+    return false;
+  }
+}
+function videoEmbedUrl(url) {
+  try {
+    const parsed = new URL(url);
+    const host = parsed.hostname.replace(/^www\./, "");
+    if (host === "youtube.com" || host === "m.youtube.com") {
+      const id = parsed.searchParams.get("v");
+      return id ? `https://www.youtube.com/embed/${encodeURIComponent(id)}` : null;
+    }
+    if (host === "youtu.be") {
+      const id = parsed.pathname.split("/").filter(Boolean)[0];
+      return id ? `https://www.youtube.com/embed/${encodeURIComponent(id)}` : null;
+    }
+    if (host === "youtube-nocookie.com") {
+      return parsed.toString();
+    }
+    if (host === "vimeo.com") {
+      const id = parsed.pathname.split("/").filter(Boolean)[0];
+      return id ? `https://player.vimeo.com/video/${encodeURIComponent(id)}` : null;
+    }
+    if (host === "player.vimeo.com") {
+      return parsed.toString();
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+// src/notion/generic-source.ts
+import { cache } from "react";
+
+// src/notion/property-mappers.ts
+function isRecord(value) {
+  return Boolean(value && typeof value === "object");
+}
+function getPlainText(parts) {
+  if (!Array.isArray(parts)) return "";
+  return parts.map((part) => part.plain_text ?? "").join("").trim();
+}
+function getProperty(properties, key) {
+  return properties[key];
+}
+function firstPropertyOfType(properties, type) {
+  return Object.values(properties).find(
+    (property) => isRecord(property) && property.type === type
+  );
+}
+function getFirstTitleProperty(properties) {
+  const property = firstPropertyOfType(properties, "title");
+  return property ? getPlainText(property.title) : "";
+}
+function getRichTextProperty(properties, key) {
+  const property = getProperty(properties, key);
+  if (!property) return "";
+  if (property.type === "title") return getPlainText(property.title);
+  if (property.type === "rich_text") return getPlainText(property.rich_text);
+  if (property.type === "url") return String(property.url ?? "").trim();
+  if (property.type === "email") return String(property.email ?? "").trim();
+  if (property.type === "phone_number") {
+    return String(property.phone_number ?? "").trim();
+  }
+  return "";
+}
+function getDateProperty(properties, key) {
+  const property = getProperty(properties, key);
+  if (property?.type !== "date") return "";
+  const date = property.date;
+  return String(date?.start ?? "").trim();
+}
+function getFirstDateProperty(properties) {
+  const property = firstPropertyOfType(properties, "date");
+  if (!property) return "";
+  const date = property.date;
+  return String(date?.start ?? "").trim();
+}
+function getSelectProperty(properties, key) {
+  const property = getProperty(properties, key);
+  if (property?.type !== "select") return "";
+  const select = property.select;
+  return String(select?.name ?? "").trim();
+}
+function getCheckboxProperty(properties, key) {
+  const property = getProperty(properties, key);
+  if (property?.type !== "checkbox") return false;
+  return Boolean(property.checkbox);
+}
+function getRelationPageIds(properties, key) {
+  const property = getProperty(properties, key);
+  if (property?.type !== "relation" || !Array.isArray(property.relation)) {
+    return [];
+  }
+  return property.relation.map((item) => String(item.id ?? "").trim()).filter(Boolean);
+}
+function getTagsProperty(properties, key) {
+  const property = getProperty(properties, key);
+  if (property?.type === "multi_select" && Array.isArray(property.multi_select)) {
+    return property.multi_select.map((item) => String(item.name ?? "").trim()).filter(Boolean);
+  }
+  if (property?.type === "select") {
+    const select = property.select;
+    const name = String(select?.name ?? "").trim();
+    return name ? [name] : [];
+  }
+  return [];
+}
+function getFirstTagsProperty(properties) {
+  const multiSelect = firstPropertyOfType(properties, "multi_select");
+  if (multiSelect && Array.isArray(multiSelect.multi_select)) {
+    return multiSelect.multi_select.map((item) => String(item.name ?? "").trim()).filter(Boolean);
+  }
+  const select = firstPropertyOfType(properties, "select");
+  const name = String(select?.select?.name ?? "").trim();
+  return name ? [name] : [];
+}
+function getAuthorProperty(properties, key) {
+  const property = getProperty(properties, key);
+  if (!property) return "";
+  if (property.type === "people" && Array.isArray(property.people)) {
+    return property.people.map(
+      (person) => String(person.name ?? person.person?.email ?? "").trim()
+    ).filter(Boolean).join(", ");
+  }
+  return getRichTextProperty(properties, key);
+}
+function getFirstPeopleProperty(properties) {
+  const property = firstPropertyOfType(properties, "people");
+  if (!property || !Array.isArray(property.people)) return "";
+  return property.people.map(
+    (person) => String(person.name ?? person.person?.email ?? "").trim()
+  ).filter(Boolean).join(", ");
+}
+function pickPublishedFlag(properties) {
+  const published = getProperty(properties, "Published");
+  if (published?.type === "checkbox") {
+    return Boolean(published.checkbox);
+  }
+  const status = getProperty(properties, "Status");
+  if (status?.type === "status") {
+    const statusValue = status.status;
+    return String(statusValue?.name ?? "").trim().toLowerCase() === "published";
+  }
+  if (status?.type === "select") {
+    const statusValue = status.select;
+    return String(statusValue?.name ?? "").trim().toLowerCase() === "published";
+  }
+  return false;
+}
+function pickDescriptionFallback(description, title) {
+  return description.trim() || title.trim();
+}
+function isValidPublicSlug(slug) {
+  return /^[a-z0-9][a-z0-9-]{0,79}$/.test(slug);
+}
+function notionPageEditUrl(pageId, editBaseUrl) {
+  const compactPageId = pageId.replaceAll("-", "");
+  if (editBaseUrl?.includes("{pageId}")) {
+    return editBaseUrl.replaceAll("{pageId}", compactPageId);
+  }
+  return `https://www.notion.so/${compactPageId}`;
+}
+function compactNotionId(id) {
+  return id.replaceAll("-", "").toLowerCase();
+}
+
+// src/notion/generic-source.ts
+function normalizePage(input) {
+  if (!input || typeof input !== "object") return null;
+  const page = input;
+  return page.id ? page : null;
+}
+function firstFieldName(value) {
+  if (Array.isArray(value)) return value[0];
+  return value;
+}
+function getFieldName(fields, key) {
+  return firstFieldName(fields[key]);
+}
+function pickPublishedFlagForModel(properties, fields) {
+  const publishedField = getFieldName(fields, "published") ?? "Published";
+  const published = properties[publishedField];
+  if (published?.type === "checkbox") return Boolean(published.checkbox);
+  const statusField = getFieldName(fields, "status") ?? "Status";
+  const status = properties[statusField];
+  if (status?.type === "status") {
+    const value = status.status;
+    return String(value?.name ?? "").trim().toLowerCase() === "published";
+  }
+  if (status?.type === "select") {
+    const value = status.select;
+    return String(value?.name ?? "").trim().toLowerCase() === "published";
+  }
+  return true;
+}
+function coverImageUrlForModel(page, fields) {
+  const coverField = fields.cover;
+  if (Array.isArray(coverField)) {
+    for (const field of coverField) {
+      const imageUrl = coverImageUrlForPage(page, field);
+      if (imageUrl) return imageUrl;
+    }
+  }
+  if (typeof coverField === "string") {
+    return coverImageUrlForPage(page, coverField);
+  }
+  return coverImageUrlForPage(page);
+}
+function mapExtraProperties(properties, fields) {
+  const result = {};
+  for (const [key, value] of Object.entries(fields)) {
+    const field = firstFieldName(value);
+    if (!field) continue;
+    const tags = getTagsProperty(properties, field);
+    result[key] = tags.length > 0 ? tags : getRichTextProperty(properties, field);
+  }
+  return result;
+}
+function mapNotionPageToGenericContentItem(model, page, options) {
+  const fields = model.source.fields;
+  const properties = isRecord2(page.properties) ? page.properties : {};
+  const titleField = getFieldName(fields, "title");
+  const slugField = getFieldName(fields, "slug");
+  const descriptionField = getFieldName(fields, "description");
+  const dateField = getFieldName(fields, "date");
+  const tagsField = getFieldName(fields, "tags");
+  const title = titleField ? getRichTextProperty(properties, titleField) : "";
+  const slug = slugField ? getRichTextProperty(properties, slugField).toLowerCase() : page.id.replaceAll("-", "").toLowerCase();
+  const description = pickDescriptionFallback(
+    descriptionField ? getRichTextProperty(properties, descriptionField) : "",
+    title
+  );
+  return {
+    pageId: page.id,
+    slug,
+    title,
+    description,
+    date: dateField ? getDateProperty(properties, dateField) : "",
+    tags: tagsField ? getTagsProperty(properties, tagsField) : [],
+    coverImage: coverImageUrlForModel(page, fields),
+    published: pickPublishedFlagForModel(properties, fields),
+    editUrl: notionPageEditUrl(page.id, options?.editBaseUrl),
+    properties: mapExtraProperties(properties, fields)
+  };
+}
+function isRenderableGenericContentItem(item) {
+  return Boolean(item.published && item.title && item.slug && isValidPublicSlug(item.slug));
+}
+function createGenericNotionContentSource(deps) {
+  return {
+    async listItems() {
+      const pages = [];
+      let cursor;
+      do {
+        const response = await deps.queryDataSource({ startCursor: cursor });
+        for (const item of response.results ?? []) {
+          const page = normalizePage(item);
+          if (page) pages.push(page);
+        }
+        cursor = response.next_cursor ?? void 0;
+        if (!response.has_more) break;
+      } while (cursor);
+      return pages.map(
+        (page) => mapNotionPageToGenericContentItem(deps.model, page, {
+          editBaseUrl: deps.editBaseUrl
+        })
+      ).filter(isRenderableGenericContentItem).sort((a, b) => b.date.localeCompare(a.date));
+    },
+    async getItemBySlug(slug) {
+      const items = await this.listItems();
+      const item = items.find((candidate) => candidate.slug === slug);
+      if (!item) return null;
+      return {
+        ...item,
+        blocks: await deps.getPageBlocks(item.pageId)
+      };
+    }
+  };
+}
+async function createDefaultGenericSource(model) {
+  if (!await hasNotionModelConfig(model)) return null;
+  const config = await getNotionConfigForModel(model);
+  const client = createNotionClient(config);
+  return createGenericNotionContentSource({
+    model,
+    dataSourceId: config.dataSourceId,
+    editBaseUrl: config.editBaseUrl,
+    queryDataSource: async ({ startCursor } = {}) => client.dataSources.query({
+      data_source_id: config.dataSourceId,
+      page_size: model.source.query.pageSize,
+      sorts: model.source.query.sorts ? [...model.source.query.sorts] : void 0,
+      filter_properties: model.source.query.filterProperties ? [...model.source.query.filterProperties] : void 0,
+      ...startCursor ? { start_cursor: startCursor } : {}
+    }),
+    getPageBlocks: (pageId) => listBlockChildrenDeep(client, pageId)
+  });
+}
+var sourceCache = cache(createDefaultGenericSource);
+async function listGenericNotionContent(model) {
+  const source = await sourceCache(model);
+  if (!source) return [];
+  return source.listItems();
+}
+async function getGenericNotionContentBySlug(model, slug) {
+  const source = await sourceCache(model);
+  if (!source) return null;
+  return source.getItemBySlug(slug);
+}
+function isRecord2(value) {
+  return Boolean(value && typeof value === "object");
+}
+
+// src/notion/webhook.ts
+var WEBHOOK_VERIFICATION_TOKEN_CACHE_KEY = "notion:webhook:verification-token:v1";
+function isRecord3(value) {
+  return Boolean(value && typeof value === "object" && !Array.isArray(value));
+}
+function readString2(source, key) {
+  if (!isRecord3(source)) return "";
+  const value = source[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+function asRecords(value) {
+  if (Array.isArray(value)) return value.filter(isRecord3);
+  if (isRecord3(value)) return [value];
+  return [];
+}
+function nestedRecords(source, ...keys) {
+  const records = [];
+  for (const key of keys) {
+    const value = source[key];
+    if (isRecord3(value)) records.push(value);
+  }
+  return records;
+}
+function firstString(...values) {
+  return values.find(Boolean) ?? "";
+}
+function normalizeId(value) {
+  return value.replaceAll("-", "").toLowerCase();
+}
+function findIdByType(input, type) {
+  const stack = [input];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || seen.has(current)) continue;
+    seen.add(current);
+    if (readString2(current, "type") === type) {
+      const id = readString2(current, "id");
+      if (id) return id;
+    }
+    for (const value of Object.values(current)) {
+      if (isRecord3(value)) stack.push(value);
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (isRecord3(item)) stack.push(item);
+        }
+      }
+    }
+  }
+  return "";
+}
+function findDataSourceId(input) {
+  const stack = [input];
+  const seen = /* @__PURE__ */ new Set();
+  while (stack.length > 0) {
+    const current = stack.pop();
+    if (!current || seen.has(current)) continue;
+    seen.add(current);
+    const direct = firstString(
+      readString2(current, "data_source_id"),
+      readString2(current, "source_id")
+    );
+    if (direct) return direct;
+    const type = readString2(current, "type");
+    if (type === "data_source") {
+      const id = readString2(current, "id");
+      if (id) return id;
+    }
+    for (const value of Object.values(current)) {
+      if (isRecord3(value)) stack.push(value);
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (isRecord3(item)) stack.push(item);
+        }
+      }
+    }
+  }
+  return "";
+}
+function firstFieldName2(value) {
+  if (Array.isArray(value)) return value[0];
+  return value;
+}
+function defaultRouteIdFromProperties(model, page) {
+  const properties = isRecord3(page.properties) ? page.properties : {};
+  const slugField = firstFieldName2(model.source.fields.slug);
+  const slug = slugField ? getRichTextProperty(properties, slugField).toLowerCase() : "";
+  return isValidPublicSlug(slug) ? slug : "";
+}
+function defaultLocaleFromProperties(model, page) {
+  const properties = isRecord3(page.properties) ? page.properties : {};
+  const localeField = firstFieldName2(model.source.fields.locale);
+  return localeField ? getSelectProperty(properties, localeField) : "";
+}
+function eventKind(eventType) {
+  if (eventType.includes(".deleted")) return "delete";
+  if (eventType.includes(".created") || eventType.includes(".undeleted")) {
+    return "publish";
+  }
+  return "update";
+}
+function defaultGetModelDataSourceId(model) {
+  const fromEnv = process.env[model.source.dataSourceEnv];
+  if (fromEnv) return fromEnv;
+  return model.source.defaultDataSourceId ?? null;
+}
+function matchModelByDataSourceId(models, dataSourceId, getDataSourceId) {
+  if (!dataSourceId) return null;
+  const normalized = normalizeId(dataSourceId);
+  return models.find((model) => {
+    const configured = getDataSourceId(model);
+    return configured ? normalizeId(configured) === normalized : false;
+  }) ?? null;
+}
+function findModelForEvent(models, event, page, getDataSourceId) {
+  const modelId = firstString(
+    readString2(event, "modelId"),
+    readString2(event, "model_id"),
+    readString2(event.data, "modelId"),
+    readString2(event.data, "model_id")
+  );
+  if (modelId) {
+    return models.find((model) => model.id === modelId) ?? null;
+  }
+  const dataSourceId = firstString(
+    findDataSourceId(event),
+    findIdByType(event, "data_source"),
+    readString2(event, "data_source_id"),
+    readString2(event.data, "data_source_id"),
+    readString2(page?.parent, "data_source_id"),
+    readString2(page?.parent, "database_id")
+  );
+  return matchModelByDataSourceId(models, dataSourceId, getDataSourceId);
+}
+function pageIdForEvent(event, page) {
+  return firstString(
+    readString2(page, "id"),
+    findIdByType(event, "page"),
+    readString2(event, "page_id"),
+    readString2(event.data, "page_id")
+  );
+}
+function pageForEvent(event) {
+  let fallback = null;
+  for (const record of [
+    ...nestedRecords(isRecord3(event.data) ? event.data : {}, "page", "entity"),
+    ...nestedRecords(event, "page", "entity"),
+    event
+  ]) {
+    const type = readString2(record, "type");
+    if (type === "page" || readString2(record, "object") === "page") {
+      if (!readString2(record, "id")) continue;
+      if (isRecord3(record.properties) || isRecord3(record.parent)) return record;
+      fallback ??= record;
+    }
+  }
+  return fallback;
+}
+function parseNotionWebhookPayload(payload, options) {
+  if (!isRecord3(payload)) return { type: "events", events: [] };
+  const verificationToken = readString2(payload, "verification_token");
+  if (verificationToken) {
+    return { type: "verification", verificationToken };
+  }
+  const getDataSourceId = options.getModelDataSourceId ?? defaultGetModelDataSourceId;
+  const events = asRecords(payload.events ?? payload.event ?? payload).map(
+    (event) => parseEvent(event, options.models, getDataSourceId)
+  ).filter((event) => Boolean(event));
+  return { type: "events", events };
+}
+function parseEvent(event, models, getDataSourceId) {
+  const eventType = firstString(readString2(event, "type"), readString2(event, "event"));
+  if (!eventType) return null;
+  const page = pageForEvent(event);
+  const model = findModelForEvent(
+    models,
+    event,
+    page ?? void 0,
+    getDataSourceId
+  );
+  if (!model) return null;
+  const routeId = page ? model.resolveRouteId?.(page) ?? defaultRouteIdFromProperties(model, page) : "";
+  const locale = page ? model.resolveLocale?.(page) ?? defaultLocaleFromProperties(model, page) : "";
+  const dataSourceId = firstString(
+    findDataSourceId(event),
+    findIdByType(event, "data_source"),
+    readString2(event, "data_source_id"),
+    readString2(event.data, "data_source_id"),
+    readString2(page?.parent, "data_source_id"),
+    readString2(page?.parent, "database_id")
+  );
+  const dataSourceEvent = eventType.startsWith("data_source.") || eventType.startsWith("database.");
+  return {
+    id: readString2(event, "id") || void 0,
+    eventType,
+    modelId: model.id,
+    pageId: pageIdForEvent(event, page ?? void 0) || void 0,
+    dataSourceId: dataSourceId || void 0,
+    routeId: routeId || void 0,
+    locale: locale || void 0,
+    kind: eventKind(eventType),
+    includeApi: true,
+    reason: page && routeId ? "page" : dataSourceEvent ? "data_source" : "page"
+  };
+}
+async function defaultRetrieveNotionPage(pageId, model) {
+  const config = await getNotionConfigForModel(model);
+  const client = createNotionClient(config);
+  const page = await client.pages.retrieve({ page_id: pageId });
+  return page;
+}
+function resolveWebhookEventRoute(event, models, retrievePage) {
+  if (event.routeId || !event.pageId) return Promise.resolve(event);
+  if (event.kind === "delete") return Promise.resolve(event);
+  const model = models.find((m) => m.id === event.modelId);
+  if (!model) return Promise.resolve(event);
+  return retrievePage(event.pageId, model).then((page) => {
+    if (!page) return event;
+    const pageRecord = page;
+    const routeId = model.resolveRouteId?.(pageRecord) ?? defaultRouteIdFromProperties(model, pageRecord);
+    const locale = model.resolveLocale?.(pageRecord) ?? defaultLocaleFromProperties(model, pageRecord);
+    if (!routeId) return event;
+    return {
+      ...event,
+      routeId,
+      locale: locale || event.locale,
+      reason: "page"
+    };
+  }).catch((error) => {
+    const err = error;
+    console.warn(
+      JSON.stringify({
+        tag: "notion_webhook_page_lookup_failed",
+        eventId: event.id,
+        eventType: event.eventType,
+        modelId: event.modelId,
+        pageId: event.pageId,
+        code: err?.code,
+        status: err?.status,
+        message: err?.message ?? String(error)
+      })
+    );
+    return event;
+  });
+}
+async function parseNotionWebhookPayloadWithPageLookup(payload, options) {
+  const parsed = parseNotionWebhookPayload(payload, options);
+  if (parsed.type === "verification") return parsed;
+  if (options?.lookupPages === false) return parsed;
+  const retrievePage = options?.retrievePage ?? defaultRetrieveNotionPage;
+  return {
+    type: "events",
+    events: await Promise.all(
+      parsed.events.map(
+        (event) => resolveWebhookEventRoute(event, options.models, retrievePage)
+      )
+    )
+  };
+}
+function notionWebhookEventToRevalidateRequest(event) {
+  return {
+    modelId: event.modelId,
+    pageId: event.pageId,
+    routeId: event.routeId,
+    locale: event.locale,
+    kind: event.kind,
+    includeApi: event.includeApi
+  };
+}
+async function signNotionWebhookBody(body, verificationToken) {
+  const key = await crypto.subtle.importKey(
+    "raw",
+    new TextEncoder().encode(verificationToken),
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign(
+    "HMAC",
+    key,
+    new TextEncoder().encode(body)
+  );
+  return Array.from(new Uint8Array(signature)).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function normalizeNotionSignature(signature) {
+  const value = String(signature ?? "").trim();
+  const prefixed = value.match(/^sha256=(.+)$/i);
+  return prefixed && prefixed[1] ? prefixed[1].trim() : value;
+}
+async function verifyNotionWebhookSignature(input) {
+  const token = String(input.verificationToken ?? "").trim();
+  const signature = normalizeNotionSignature(input.signature);
+  if (!token || !signature) return false;
+  const expected = await signNotionWebhookBody(input.body, token);
+  if (expected.length !== signature.length) return false;
+  let diff = 0;
+  for (let index = 0; index < expected.length; index += 1) {
+    diff |= expected.charCodeAt(index) ^ signature.charCodeAt(index);
+  }
+  return diff === 0;
+}
+async function verifyNotionWebhookSignatureWithTokens(input) {
+  const tokens = Array.from(
+    new Set(input.verificationTokens.map((token) => String(token ?? "").trim()))
+  ).filter(Boolean);
+  for (const token of tokens) {
+    if (await verifyNotionWebhookSignature({
+      body: input.body,
+      signature: input.signature,
+      verificationToken: token
+    })) {
+      return true;
+    }
+  }
+  return false;
+}
+function readStoredWebhookVerificationToken(value) {
+  if (typeof value === "string") return value.trim() || null;
+  if (!isRecord3(value)) return null;
+  const token = readString2(value, "token");
+  return token || null;
+}
+async function getStoredNotionWebhookVerificationToken(cache2) {
+  if (!cache2) return null;
+  try {
+    const value = await cache2.get(
+      WEBHOOK_VERIFICATION_TOKEN_CACHE_KEY,
+      { cacheTtl: 60 }
+    );
+    return readStoredWebhookVerificationToken(value);
+  } catch (error) {
+    console.warn(
+      JSON.stringify({
+        tag: "notion_webhook_token_lookup_failed",
+        message: error instanceof Error ? error.message : String(error)
+      })
+    );
+    return null;
+  }
+}
+async function putStoredNotionWebhookVerificationToken(cache2, token) {
+  const normalized = token.trim();
+  if (!cache2 || !normalized) return false;
+  await cache2.put(
+    WEBHOOK_VERIFICATION_TOKEN_CACHE_KEY,
+    {
+      token: normalized,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    },
+    {
+      metadata: {
+        source: "notion-webhook"
+      }
+    }
+  );
+  return true;
+}
+export {
+  DEFAULT_NOTION_MOVIES_DATA_SOURCE_ID,
+  NOTION_BLOCKS_CACHE_TTL_SECONDS,
+  NOTION_LIST_CACHE_TTL_SECONDS,
+  compactNotionId,
+  coverImageUrlForPage,
+  createGenericNotionContentSource,
+  createNotionClient,
+  deleteNotionContentCache,
+  fileObjectForMediaBlock,
+  firstImageUrlFromBlocks,
+  flattenNotionBlockText,
+  gatedMediaBlockForApi,
+  getAuthorProperty,
+  getCachedNotionBlocks,
+  getCachedNotionValue,
+  getCheckboxProperty,
+  getDateProperty,
+  getFirstDateProperty,
+  getFirstPeopleProperty,
+  getFirstTagsProperty,
+  getFirstTitleProperty,
+  getGenericNotionContentBySlug,
+  getNotionClientConfig,
+  getNotionConfig,
+  getNotionConfigForModel,
+  getNotionEditBaseUrl,
+  getNotionMovieConfig,
+  getNotionWebhookVerificationToken,
+  getRelationPageIds,
+  getRichTextProperty,
+  getSelectProperty,
+  getStoredNotionWebhookVerificationToken,
+  getTagsProperty,
+  hasNotionConfig,
+  hasNotionModelConfig,
+  hasNotionMovieConfig,
+  isDirectVideoUrl,
+  isNotionHostedFile,
+  isRecord,
+  isRenderableGenericContentItem,
+  isValidPublicSlug,
+  listBlockChildren,
+  listBlockChildrenDeep,
+  listGenericNotionContent,
+  mapNotionPageToGenericContentItem,
+  mediaUrlForBlock,
+  normalizeNotionFileSource,
+  notionBlockMediaPath,
+  notionModelCachePrefix,
+  notionModelListCacheKey,
+  notionPageBlocksCacheKey,
+  notionPageCachePrefix,
+  notionPageCoverMediaPath,
+  notionPageEditUrl,
+  notionPagePropertyMediaPath,
+  notionWebhookEventToRevalidateRequest,
+  parseNotionWebhookPayload,
+  parseNotionWebhookPayloadWithPageLookup,
+  pickDescriptionFallback,
+  pickFirstFilesPropertyValue,
+  pickPageCoverFile,
+  pickPublishedFlag,
+  publicMediaBlockForApi,
+  putCachedNotionBlocks,
+  putCachedNotionValue,
+  putStoredNotionWebhookVerificationToken,
+  resolveNotionFileUrl,
+  signNotionWebhookBody,
+  verifyNotionWebhookSignature,
+  verifyNotionWebhookSignatureWithTokens,
+  videoEmbedUrl
+};
+//# sourceMappingURL=index.js.map