@notionx/core 0.1.1 → 0.1.3

package/dist/pages/index.d.ts

@@ -0,0 +1,117 @@
+import { NotionBlock, NotionPageLike } from '../notion/types.js';
+
+type SitePageLayout = "home" | "default" | "legal" | "content-list";
+type SitePageFields = {
+    title: string;
+    key: string;
+    slug: string;
+    status: string;
+    layout: string;
+    description: string;
+    seoTitle: string;
+    seoDescription: string;
+    showHeader: string;
+    showFooter: string;
+    showInNav: string;
+    navLabel: string;
+    navOrder: string;
+    showInFooter: string;
+    footerLabel: string;
+    footerGroup: string;
+    footerOrder: string;
+    contentSource: string;
+    cover: string;
+};
+type SitePage = {
+    pageId: string;
+    key: string;
+    slug: string;
+    href: string;
+    title: string;
+    description: string;
+    seoTitle: string;
+    seoDescription: string;
+    layout: SitePageLayout;
+    published: boolean;
+    showHeader: boolean;
+    showFooter: boolean;
+    showInNav: boolean;
+    navLabel: string;
+    navOrder: number;
+    showInFooter: boolean;
+    footerLabel: string;
+    footerGroup: string;
+    footerOrder: number;
+    contentSource: string;
+    coverImage: string | null;
+    editUrl: string | null;
+    blocks: NotionBlock[];
+};
+type SitePageNavItem = {
+    label: string;
+    href: string;
+    order: number;
+    pageKey: string;
+};
+type SitePageFooterGroup = {
+    label: string;
+    items: SitePageNavItem[];
+};
+type SitePageModel = {
+    source: {
+        tokenEnv: string;
+        dataSourceEnv: string;
+        defaultDataSourceId?: string;
+        fields?: Partial<SitePageFields>;
+        query?: {
+            pageSize?: number;
+        };
+    };
+};
+type DefinedSitePageModel = SitePageModel & {
+    source: Omit<SitePageModel["source"], "fields" | "query"> & {
+        fields: SitePageFields;
+        query: {
+            pageSize: number;
+        };
+    };
+};
+type SitePageSourceDeps = {
+    queryDataSource: (input?: {
+        startCursor?: string;
+    }) => Promise<{
+        results?: unknown[];
+        has_more?: boolean;
+        next_cursor?: string | null;
+    }>;
+    getPageBlocks: (pageId: string) => Promise<NotionBlock[]>;
+    editBaseUrl?: string;
+};
+
+declare const defaultSitePageFields: SitePageFields;
+declare const defaultPagesDataSourceEnv = "NOTION_PAGES_DATA_SOURCE_ID";
+declare function defineSitePageModel(model: SitePageModel): DefinedSitePageModel;
+
+declare function slugToHref(slug: string): string;
+declare function normalizePageSlug(slug: string): string;
+declare function mapNotionPageToSitePage(page: NotionPageLike, fields: SitePageFields, blocks?: NotionBlock[], options?: {
+    editBaseUrl?: string;
+}): SitePage | null;
+declare function createSitePageSource(modelInput: SitePageModel, deps: SitePageSourceDeps): {
+    listPages(): Promise<SitePage[]>;
+};
+declare function createSitePagesApi(input: {
+    model: SitePageModel;
+    fallbackPages?: readonly SitePage[];
+}): {
+    listSitePages: () => Promise<SitePage[]>;
+    getSitePageByKey(key: string): Promise<SitePage | null>;
+    getSitePageBySlug(slug: string): Promise<SitePage | null>;
+    getSitePageForContentSource(sourceId: string): Promise<SitePage | null>;
+    getSiteNavigation(): Promise<SitePageNavItem[]>;
+    getSiteFooterGroups(): Promise<SitePageFooterGroup[]>;
+};
+declare function deriveSiteNavigation(pages: readonly SitePage[]): SitePageNavItem[];
+declare function deriveSiteFooterGroups(pages: readonly SitePage[]): SitePageFooterGroup[];
+
+export { type DefinedSitePageModel, type SitePage, type SitePageFields, type SitePageFooterGroup, type SitePageLayout, type SitePageModel, type SitePageNavItem, type SitePageSourceDeps, createSitePageSource, createSitePagesApi, defaultPagesDataSourceEnv, defaultSitePageFields, defineSitePageModel, deriveSiteFooterGroups, deriveSiteNavigation, mapNotionPageToSitePage, normalizePageSlug, slugToHref };

package/dist/pages/index.js

@@ -0,0 +1,487 @@
+// src/pages/model.ts
+var defaultSitePageFields = {
+  title: "Name",
+  key: "Key",
+  slug: "Slug",
+  status: "Status",
+  layout: "Layout",
+  description: "Description",
+  seoTitle: "SEO Title",
+  seoDescription: "SEO Description",
+  showHeader: "Show Header",
+  showFooter: "Show Footer",
+  showInNav: "Show in Nav",
+  navLabel: "Nav Label",
+  navOrder: "Nav Order",
+  showInFooter: "Show in Footer",
+  footerLabel: "Footer Label",
+  footerGroup: "Footer Group",
+  footerOrder: "Footer Order",
+  contentSource: "Content Source",
+  cover: "Cover"
+};
+var defaultPagesDataSourceEnv = "NOTION_PAGES_DATA_SOURCE_ID";
+function defineSitePageModel(model) {
+  return {
+    ...model,
+    source: {
+      ...model.source,
+      fields: {
+        ...defaultSitePageFields,
+        ...model.source.fields ?? {}
+      },
+      query: {
+        pageSize: 100,
+        ...model.source.query ?? {}
+      }
+    }
+  };
+}
+
+// src/pages/source.ts
+import { cache } from "react";
+
+// 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/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 env = {
+    NOTION_TOKEN: process.env.NOTION_TOKEN,
+    NOTION_DATA_SOURCE_ID: process.env.NOTION_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;
+}
+async function hasNotionModelConfig(model) {
+  const env = await readEnv();
+  return Boolean(
+    readString(env, "NOTION_TOKEN") && (readString(env, model.source.dataSourceEnv) || model.source.defaultDataSourceId)
+  );
+}
+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/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 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 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 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;
+}
+
+// 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 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 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 getNumberProperty(properties, key, fallback = 0) {
+  const property = getProperty(properties, key);
+  if (property?.type !== "number") return fallback;
+  const value = Number(property.number);
+  return Number.isFinite(value) ? value : fallback;
+}
+function notionPageEditUrl(pageId, editBaseUrl) {
+  const compactPageId = pageId.replaceAll("-", "");
+  if (editBaseUrl?.includes("{pageId}")) {
+    return editBaseUrl.replaceAll("{pageId}", compactPageId);
+  }
+  return `https://www.notion.so/${compactPageId}`;
+}
+
+// src/pages/source.ts
+function normalizePage(input) {
+  if (!input || typeof input !== "object") return null;
+  const page = input;
+  return page.id ? page : null;
+}
+function slugToHref(slug) {
+  const normalized = slug.trim().replace(/^\/+|\/+$/g, "");
+  return normalized ? `/${normalized}` : "/";
+}
+function normalizePageSlug(slug) {
+  return slug.trim().replace(/^\/+|\/+$/g, "").toLowerCase();
+}
+function isPublishedStatus(value) {
+  return value.trim().toLowerCase() === "published";
+}
+function getCheckboxPropertyWithFallback(properties, key, fallback) {
+  const property = properties[key];
+  if (property?.type !== "checkbox") return fallback;
+  return getCheckboxProperty(properties, key);
+}
+function normalizeLayout(value) {
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "home") return "home";
+  if (normalized === "legal") return "legal";
+  if (normalized === "content-list") return "content-list";
+  return "default";
+}
+function mapNotionPageToSitePage(page, fields, blocks = [], options) {
+  const properties = isRecord(page.properties) ? page.properties : {};
+  const title = getRichTextProperty(properties, fields.title);
+  const key = getRichTextProperty(properties, fields.key).toLowerCase();
+  const slug = normalizePageSlug(getRichTextProperty(properties, fields.slug));
+  const status = getSelectProperty(properties, fields.status);
+  if (!title || !key || !isPublishedStatus(status)) return null;
+  const description = getRichTextProperty(properties, fields.description);
+  const seoTitle = getRichTextProperty(properties, fields.seoTitle) || title;
+  const seoDescription = getRichTextProperty(properties, fields.seoDescription) || description;
+  const navLabel = getRichTextProperty(properties, fields.navLabel) || title;
+  const footerLabel = getRichTextProperty(properties, fields.footerLabel) || navLabel;
+  return {
+    pageId: page.id,
+    key,
+    slug,
+    href: slugToHref(slug),
+    title,
+    description,
+    seoTitle,
+    seoDescription,
+    layout: normalizeLayout(getSelectProperty(properties, fields.layout)),
+    published: true,
+    showHeader: getCheckboxPropertyWithFallback(
+      properties,
+      fields.showHeader,
+      true
+    ),
+    showFooter: getCheckboxPropertyWithFallback(
+      properties,
+      fields.showFooter,
+      true
+    ),
+    showInNav: getCheckboxProperty(properties, fields.showInNav),
+    navLabel,
+    navOrder: getNumberProperty(properties, fields.navOrder, 100),
+    showInFooter: getCheckboxProperty(properties, fields.showInFooter),
+    footerLabel,
+    footerGroup: getSelectProperty(properties, fields.footerGroup) || "Company",
+    footerOrder: getNumberProperty(properties, fields.footerOrder, 100),
+    contentSource: getRichTextProperty(properties, fields.contentSource),
+    coverImage: coverImageUrlForPage(page, fields.cover),
+    editUrl: notionPageEditUrl(page.id, options?.editBaseUrl),
+    blocks
+  };
+}
+function createSitePageSource(modelInput, deps) {
+  const model = defineSitePageModel(modelInput);
+  const fields = model.source.fields;
+  return {
+    async listPages() {
+      const pages = [];
+      let cursor;
+      do {
+        const response = await deps.queryDataSource({ startCursor: cursor });
+        for (const item of response.results ?? []) {
+          const page = normalizePage(item);
+          if (!page) continue;
+          const mapped = mapNotionPageToSitePage(
+            page,
+            fields,
+            await deps.getPageBlocks(page.id),
+            { editBaseUrl: deps.editBaseUrl }
+          );
+          if (mapped) pages.push(mapped);
+        }
+        cursor = response.next_cursor ?? void 0;
+        if (!response.has_more) break;
+      } while (cursor);
+      return pages.sort((a, b) => a.navOrder - b.navOrder || a.title.localeCompare(b.title));
+    }
+  };
+}
+async function createDefaultSitePageSource(modelInput) {
+  const model = defineSitePageModel(modelInput);
+  if (!await hasNotionModelConfig(model)) return null;
+  const config = await getNotionConfigForModel(model);
+  const client = createNotionClient(config);
+  return createSitePageSource(model, {
+    editBaseUrl: config.editBaseUrl,
+    queryDataSource: async ({ startCursor } = {}) => client.dataSources.query({
+      data_source_id: config.dataSourceId,
+      page_size: model.source.query.pageSize,
+      sorts: [{ property: model.source.fields.navOrder, direction: "ascending" }],
+      ...startCursor ? { start_cursor: startCursor } : {}
+    }),
+    getPageBlocks: (pageId) => listBlockChildrenDeep(client, pageId)
+  });
+}
+var defaultSourceCache = cache(createDefaultSitePageSource);
+function createSitePagesApi(input) {
+  const fallbackPages = [...input.fallbackPages ?? []];
+  const listSitePages = cache(async () => {
+    try {
+      const source = await defaultSourceCache(input.model);
+      const pages = source ? await source.listPages() : [];
+      return pages.length ? pages : fallbackPages;
+    } catch {
+      return fallbackPages;
+    }
+  });
+  return {
+    listSitePages,
+    async getSitePageByKey(key) {
+      const pages = await listSitePages();
+      return pages.find((page) => page.key === key.toLowerCase()) ?? null;
+    },
+    async getSitePageBySlug(slug) {
+      const normalized = normalizePageSlug(slug);
+      const pages = await listSitePages();
+      return pages.find((page) => page.slug === normalized) ?? null;
+    },
+    async getSitePageForContentSource(sourceId) {
+      const pages = await listSitePages();
+      return pages.find(
+        (page) => page.layout === "content-list" && page.contentSource === sourceId
+      ) ?? null;
+    },
+    async getSiteNavigation() {
+      const pages = await listSitePages();
+      return deriveSiteNavigation(pages);
+    },
+    async getSiteFooterGroups() {
+      const pages = await listSitePages();
+      return deriveSiteFooterGroups(pages);
+    }
+  };
+}
+function deriveSiteNavigation(pages) {
+  return pages.filter((page) => page.showInNav).map((page) => ({
+    label: page.navLabel,
+    href: page.href,
+    order: page.navOrder,
+    pageKey: page.key
+  })).sort((a, b) => a.order - b.order || a.label.localeCompare(b.label));
+}
+function deriveSiteFooterGroups(pages) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const page of pages.filter((candidate) => candidate.showInFooter)) {
+    const label = page.footerGroup || "Company";
+    const items = groups.get(label) ?? [];
+    items.push({
+      label: page.footerLabel,
+      href: page.href,
+      order: page.footerOrder,
+      pageKey: page.key
+    });
+    groups.set(label, items);
+  }
+  return Array.from(groups.entries()).map(([label, items]) => ({
+    label,
+    items: items.sort(
+      (a, b) => a.order - b.order || a.label.localeCompare(b.label)
+    )
+  }));
+}
+export {
+  createSitePageSource,
+  createSitePagesApi,
+  defaultPagesDataSourceEnv,
+  defaultSitePageFields,
+  defineSitePageModel,
+  deriveSiteFooterGroups,
+  deriveSiteNavigation,
+  mapNotionPageToSitePage,
+  normalizePageSlug,
+  slugToHref
+};
+//# sourceMappingURL=index.js.map