@notionx/create-notionx-app 1.0.0

package/dist/templates/lib/pages/source.ts.tmpl

@@ -0,0 +1,566 @@
+import {
+  getGenericNotionContentBySlug,
+  type GenericContentDetail,
+  type NotionBlock,
+} from "@notionx/core/notion";
+import {
+  createSitePagesApi,
+  type SitePage as BaseSitePage,
+  type SitePageBlockRef,
+} from "@notionx/core/pages";
+import { blocksSource, contentSources } from "@/lib/content/models";
+import { pageFields, pagesDataSourceEnv } from "./model";
+
+const pagesModel = {
+  source: {
+    tokenEnv: "NOTION_TOKEN",
+    dataSourceEnv: pagesDataSourceEnv,
+    fields: pageFields,
+  },
+};
+
+const fallbackBlocks = (text: string): NotionBlock[] => [
+  {
+    id: "fallback-intro",
+    type: "paragraph",
+    paragraph: {
+      rich_text: [
+        {
+          type: "text",
+          text: { content: text },
+          plain_text: text,
+        },
+      ],
+    },
+  },
+];
+
+type BlockPropertyValue = string | string[] | number | boolean;
+
+type BlockCta = {
+  label: string;
+  href: string;
+};
+
+type FeatureGridItem = {
+  title: string;
+  description: string;
+  icon: string;
+  href?: string;
+};
+
+export type StructuredHeroBlock = {
+  type: "hero";
+  slug: string;
+  title: string;
+  description: string;
+  eyebrow: string;
+  headline: string;
+  subheadline: string;
+  primaryCta: BlockCta | null;
+  secondaryCta: BlockCta | null;
+  alignment: "left" | "center";
+  theme: "default" | "muted" | "inverse";
+  coverImage: string | null;
+  editUrl: string | null;
+};
+
+export type StructuredFeatureGridBlock = {
+  type: "feature-grid";
+  slug: string;
+  title: string;
+  description: string;
+  headline: string;
+  body: string;
+  columns: 2 | 3 | 4;
+  items: FeatureGridItem[];
+  coverImage: string | null;
+  editUrl: string | null;
+};
+
+export type StructuredStoryBlock = {
+  type: "story";
+  slug: string;
+  title: string;
+  description: string;
+  headline: string;
+  body: string;
+  quote: string;
+  quoteAttribution: string;
+  mediaUrl: string | null;
+  layout: "text-left" | "media-left" | "media-right";
+  coverImage: string | null;
+  editUrl: string | null;
+};
+
+export type StructuredLatestPostsBlock = {
+  type: "latest-posts";
+  slug: string;
+  title: string;
+  description: string;
+  headline: string;
+  body: string;
+  count: number;
+  primaryCta: BlockCta | null;
+  coverImage: string | null;
+  editUrl: string | null;
+};
+
+export type LegacyStructuredPageBlock = {
+  type: "legacy";
+  slug: string;
+  title: string;
+  description: string;
+  variant: string;
+  coverImage: string | null;
+  editUrl: string | null;
+  blocks: NotionBlock[];
+};
+
+export type StructuredPageBlock =
+  | StructuredHeroBlock
+  | StructuredFeatureGridBlock
+  | StructuredStoryBlock
+  | StructuredLatestPostsBlock
+  | LegacyStructuredPageBlock;
+
+export type SitePage = Omit<BaseSitePage, "structuredBlocks"> & {
+  structuredBlocks: StructuredPageBlock[];
+};
+
+const fallbackStructuredBlocks: Record<
+  string,
+  Exclude<StructuredPageBlock, LegacyStructuredPageBlock>
+> = {
+  "home-hero": {
+    type: "hero",
+    slug: "home-hero",
+    title: "Homepage Hero",
+    description:
+      "Editable hero module seeded into the reusable blocks source for the homepage.",
+    eyebrow: "Notion + Cloudflare",
+    headline: "Start with a homepage you can keep editing",
+    subheadline:
+      "Keep the layout stable in code while the hero copy, positioning, and primary call to action evolve in Notion.",
+    primaryCta: { label: "Explore the blog", href: "{{contentSourceListPath}}" },
+    secondaryCta: { label: "Read the story", href: "/about" },
+    alignment: "center",
+    theme: "muted",
+    coverImage: null,
+    editUrl: null,
+  },
+  "home-feature-grid": {
+    type: "feature-grid",
+    slug: "home-feature-grid",
+    title: "Homepage Feature Grid",
+    description:
+      "Reusable mid-page section for capabilities, benefits, or service pillars.",
+    headline: "Show the system working together",
+    body:
+      "Use this grid to explain how editing, infrastructure, and publishing fit together without overwhelming the homepage.",
+    columns: 3,
+    items: [
+      {
+        title: "Editorial workflows",
+        description:
+          "Use Notion as the editor for pages, posts, and reusable sections.",
+        icon: "pen-square",
+        href: "/about",
+      },
+      {
+        title: "Cloudflare runtime",
+        description:
+          "Ship on Workers with storage and caching primitives ready to grow.",
+        icon: "cloud",
+      },
+      {
+        title: "{{contentSourceListTitle}} updates",
+        description:
+          "Publish new entries and surface them through the generated routes automatically.",
+        icon: "newspaper",
+        href: "{{contentSourceListPath}}",
+      },
+    ],
+    coverImage: null,
+    editUrl: null,
+  },
+  "home-latest-posts": {
+    type: "latest-posts",
+    slug: "home-latest-posts",
+    title: "Homepage Latest Posts",
+    description: "Reusable homepage section for surfacing the latest published posts.",
+    headline: "Read the latest from the blog",
+    body:
+      "Use this section to prove the content model is working with a grid of recent published posts right on the homepage.",
+    count: 6,
+    primaryCta: { label: "View all posts", href: "{{contentSourceListPath}}" },
+    coverImage: null,
+    editUrl: null,
+  },
+};
+
+const fallbackPages: BaseSitePage[] = [
+  {
+    pageId: "fallback-home",
+    key: "home",
+    slug: "",
+    href: "/",
+    title: "Home",
+    description:
+      "A Notion-powered site built on @notionx/core, running on Cloudflare Workers with D1, R2, and Cloudflare Images.",
+    seoTitle: "Home",
+    seoDescription:
+      "A Notion-powered site built on @notionx/core, running on Cloudflare Workers with D1, R2, and Cloudflare Images.",
+    layout: "home",
+    published: true,
+    showHeader: true,
+    showFooter: true,
+    showInNav: true,
+    navLabel: "Home",
+    navOrder: 0,
+    showInFooter: true,
+    footerLabel: "Home",
+    footerGroup: "Company",
+    footerOrder: 0,
+    contentSource: "",
+    coverImage: null,
+    editUrl: null,
+    structuredBlocks: [
+      { slug: "home-hero", variant: "hero", order: 10 },
+      { slug: "home-feature-grid", variant: "feature-grid", order: 20 },
+      { slug: "home-latest-posts", order: 30 },
+    ],
+    blocks: fallbackBlocks("Configure Notion Pages to edit this homepage from Notion."),
+  },
+  {
+    pageId: "fallback-about",
+    key: "about",
+    slug: "about",
+    href: "/about",
+    title: "About",
+    description:
+      "Use this page to explain the project, the team, or the editorial point of view behind the site.",
+    seoTitle: "About",
+    seoDescription:
+      "Use this page to explain the project, the team, or the editorial point of view behind the site.",
+    layout: "default",
+    published: true,
+    showHeader: true,
+    showFooter: true,
+    showInNav: true,
+    navLabel: "About",
+    navOrder: 10,
+    showInFooter: true,
+    footerLabel: "About",
+    footerGroup: "Company",
+    footerOrder: 10,
+    contentSource: "",
+    coverImage: null,
+    editUrl: null,
+    structuredBlocks: [],
+    blocks: fallbackBlocks("Configure Notion Pages to edit this About page from Notion."),
+  },
+  {
+    pageId: "fallback-blog",
+    key: "{{contentSourceId}}",
+    slug: "{{contentSourceId}}",
+    href: "{{contentSourceListPath}}",
+    title: "{{contentSourceListTitle}}",
+    description: "{{contentSourceListDescription}}",
+    seoTitle: "{{contentSourceListTitle}}",
+    seoDescription: "{{contentSourceListDescription}}",
+    layout: "content-list",
+    published: true,
+    showHeader: true,
+    showFooter: true,
+    showInNav: true,
+    navLabel: "{{contentSourceNavLabel}}",
+    navOrder: 20,
+    showInFooter: true,
+    footerLabel: "{{contentSourceNavLabel}}",
+    footerGroup: "Content",
+    footerOrder: 10,
+    contentSource: "{{contentSourceId}}",
+    coverImage: null,
+    editUrl: null,
+    structuredBlocks: [],
+    blocks: fallbackBlocks("Latest posts from the default Notion content source."),
+  },
+  {
+    pageId: "fallback-privacy",
+    key: "privacy",
+    slug: "privacy",
+    href: "/privacy",
+    title: "Privacy",
+    description: "Publish your privacy policy here once the project is live.",
+    seoTitle: "Privacy",
+    seoDescription: "Publish your privacy policy here once the project is live.",
+    layout: "default",
+    published: true,
+    showHeader: true,
+    showFooter: true,
+    showInNav: false,
+    navLabel: "Privacy",
+    navOrder: 0,
+    showInFooter: true,
+    footerLabel: "Privacy",
+    footerGroup: "Legal",
+    footerOrder: 10,
+    contentSource: "",
+    coverImage: null,
+    editUrl: null,
+    structuredBlocks: [],
+    blocks: fallbackBlocks("Replace this placeholder with your privacy policy in Notion."),
+  },
+];
+
+const pagesApi = createSitePagesApi({
+  model: pagesModel,
+  fallbackPages,
+});
+
+function fallbackPageBlock(ref: SitePageBlockRef): StructuredPageBlock | null {
+  const fallback = fallbackStructuredBlocks[ref.slug];
+  if (!fallback) return null;
+  return fallback;
+}
+
+function fallbackToLegacyNotionBlocks(
+  detail: GenericContentDetail,
+  ref: SitePageBlockRef
+): LegacyStructuredPageBlock | null {
+  if (!detail.blocks.length) return null;
+  return {
+    type: "legacy",
+    slug: detail.slug,
+    title: detail.title,
+    description: detail.description,
+    variant: ref.variant ?? "story",
+    coverImage: detail.coverImage,
+    editUrl: detail.editUrl,
+    blocks: detail.blocks,
+  };
+}
+
+function readString(value: BlockPropertyValue | undefined) {
+  if (Array.isArray(value)) return String(value[0] ?? "").trim();
+  if (typeof value === "string") return value.trim();
+  return "";
+}
+
+function readNumber(value: BlockPropertyValue | undefined) {
+  return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+
+function normalizeAlignment(value: string): StructuredHeroBlock["alignment"] {
+  return value === "left" ? "left" : "center";
+}
+
+function normalizeTheme(value: string): StructuredHeroBlock["theme"] {
+  if (value === "default" || value === "inverse") return value;
+  return "muted";
+}
+
+function normalizeColumns(value: number | null): StructuredFeatureGridBlock["columns"] {
+  if (value === 2 || value === 4) return value;
+  return 3;
+}
+
+function normalizeLayout(value: string): StructuredStoryBlock["layout"] {
+  if (value === "text-left" || value === "media-left") return value;
+  return "media-right";
+}
+
+function normalizeCount(value: number | null) {
+  if (typeof value === "number" && value > 0) return Math.min(Math.floor(value), 12);
+  return 6;
+}
+
+function readCta(
+  labelValue: BlockPropertyValue | undefined,
+  hrefValue: BlockPropertyValue | undefined
+): BlockCta | null {
+  const label = readString(labelValue);
+  const href = readString(hrefValue);
+  return label && href ? { label, href } : null;
+}
+
+function parseFeatureGridItems(
+  value: BlockPropertyValue | undefined
+): FeatureGridItem[] {
+  const raw = readString(value);
+  if (!raw) return [];
+
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    return parsed
+      .map((item): FeatureGridItem | null => {
+        if (!item || typeof item !== "object") return null;
+        const typed = item as {
+          title?: unknown;
+          description?: unknown;
+          icon?: unknown;
+          href?: unknown;
+        };
+        const title = typeof typed.title === "string" ? typed.title.trim() : "";
+        const description =
+          typeof typed.description === "string" ? typed.description.trim() : "";
+        if (!title || !description) return null;
+        return {
+          title,
+          description,
+          icon: typeof typed.icon === "string" ? typed.icon.trim() : "sparkles",
+          href: typeof typed.href === "string" ? typed.href.trim() : undefined,
+        };
+      })
+      .filter((item): item is FeatureGridItem => Boolean(item));
+  } catch {
+    return [];
+  }
+}
+
+function resolveBlockType(detail: GenericContentDetail, ref: SitePageBlockRef) {
+  const fromRecord = readString(detail.properties.type);
+  return fromRecord || ref.variant || "";
+}
+
+async function resolveStructuredBlock(
+  ref: SitePageBlockRef
+): Promise<StructuredPageBlock | null> {
+  const detail = await getGenericNotionContentBySlug(blocksSource, ref.slug);
+  if (!detail) return fallbackPageBlock(ref);
+
+  return mapGenericBlockToStructuredBlock(detail, ref);
+}
+
+function mapGenericBlockToStructuredBlock(
+  detail: GenericContentDetail,
+  ref: SitePageBlockRef
+): StructuredPageBlock | null {
+  const type = resolveBlockType(detail, ref);
+
+  if (type === "hero") {
+    const headline = readString(detail.properties.headline);
+    if (!headline) return fallbackToLegacyNotionBlocks(detail, ref);
+    return {
+      type: "hero",
+      slug: detail.slug,
+      title: detail.title,
+      description: detail.description,
+      eyebrow: readString(detail.properties.eyebrow),
+      headline,
+      subheadline: readString(detail.properties.subheadline),
+      primaryCta: readCta(
+        detail.properties.primaryCtaLabel,
+        detail.properties.primaryCtaHref
+      ),
+      secondaryCta: readCta(
+        detail.properties.secondaryCtaLabel,
+        detail.properties.secondaryCtaHref
+      ),
+      alignment: normalizeAlignment(readString(detail.properties.alignment)),
+      theme: normalizeTheme(readString(detail.properties.theme)),
+      coverImage: detail.coverImage,
+      editUrl: detail.editUrl,
+    };
+  }
+
+  if (type === "feature-grid") {
+    const headline = readString(detail.properties.headline);
+    const items = parseFeatureGridItems(detail.properties.items);
+    if (!headline || !items.length) return fallbackToLegacyNotionBlocks(detail, ref);
+    return {
+      type: "feature-grid",
+      slug: detail.slug,
+      title: detail.title,
+      description: detail.description,
+      headline,
+      body: readString(detail.properties.body),
+      columns: normalizeColumns(readNumber(detail.properties.columns)),
+      items,
+      coverImage: detail.coverImage,
+      editUrl: detail.editUrl,
+    };
+  }
+
+  if (type === "story") {
+    const headline = readString(detail.properties.headline);
+    const body = readString(detail.properties.body);
+    if (!headline || !body) return fallbackToLegacyNotionBlocks(detail, ref);
+    return {
+      type: "story",
+      slug: detail.slug,
+      title: detail.title,
+      description: detail.description,
+      headline,
+      body,
+      quote: readString(detail.properties.quote),
+      quoteAttribution: readString(detail.properties.quoteAttribution),
+      mediaUrl: readString(detail.properties.mediaUrl) || null,
+      layout: normalizeLayout(readString(detail.properties.layout)),
+      coverImage: detail.coverImage,
+      editUrl: detail.editUrl,
+    };
+  }
+
+  if (type === "latest-posts") {
+    const headline = readString(detail.properties.headline);
+    if (!headline) return fallbackToLegacyNotionBlocks(detail, ref);
+    return {
+      type: "latest-posts",
+      slug: detail.slug,
+      title: detail.title,
+      description: detail.description,
+      headline,
+      body: readString(detail.properties.body),
+      count: normalizeCount(readNumber(detail.properties.count)),
+      primaryCta: readCta(
+        detail.properties.primaryCtaLabel,
+        detail.properties.primaryCtaHref
+      ),
+      coverImage: detail.coverImage,
+      editUrl: detail.editUrl,
+    };
+  }
+
+  return fallbackToLegacyNotionBlocks(detail, ref);
+}
+
+export async function getPageBlocks(page: BaseSitePage | null) {
+  if (!page) return [];
+  const resolved = await Promise.all(
+    (page.structuredBlocks ?? []).map((ref) => resolveStructuredBlock(ref))
+  );
+  return resolved.filter((block): block is StructuredPageBlock => Boolean(block));
+}
+
+async function withStructuredBlocks(page: BaseSitePage | null): Promise<SitePage | null> {
+  if (!page) return null;
+  return {
+    ...page,
+    structuredBlocks: await getPageBlocks(page),
+  };
+}
+
+export async function listSitePages() {
+  const pages = await pagesApi.listSitePages();
+  const resolved = await Promise.all(pages.map((page) => withStructuredBlocks(page)));
+  return resolved.filter((page): page is SitePage => Boolean(page));
+}
+
+export async function getSitePageByKey(key: string) {
+  return withStructuredBlocks(await pagesApi.getSitePageByKey(key));
+}
+
+export async function getSitePageBySlug(slug: string) {
+  return withStructuredBlocks(await pagesApi.getSitePageBySlug(slug));
+}
+export const getSitePageForContentSource = pagesApi.getSitePageForContentSource;
+export const getSiteNavigation = pagesApi.getSiteNavigation;
+export const getSiteFooterGroups = pagesApi.getSiteFooterGroups;
+export type { SitePageFooterGroup, SitePageNavItem } from "@notionx/core/pages";
+
+export function findContentSource(id: string) {
+  return contentSources.find((source) => source.id === id) ?? null;
+}

package/dist/templates/lib/pages/translations.ts.tmpl

@@ -0,0 +1,34 @@
+// Locale-aware page lookup. Uses the strict-missing rule: if a
+// localized page is missing in the target locale, do not pretend the
+// page exists — let the caller render a localized not-found.
+
+import { pickTranslation } from "@notionx/core";
+import { i18n } from "@/lib/i18n";
+import { pagesContract } from "@/lib/locale-contract";
+
+export type PageTranslation = {
+  pageId: string;
+  sourcePageId: string;
+  locale: string;
+  slug: string;
+  title: string;
+  description: string;
+  seoTitle: string;
+  seoDescription: string;
+  navLabel: string;
+  footerLabel: string;
+  published: boolean;
+};
+
+export function pickPageTranslation(
+  rows: readonly PageTranslation[],
+  locale: string
+): PageTranslation | null {
+  return pickTranslation(rows, locale, pagesContract, i18n.defaultLocale);
+}
+
+export function getDefaultLocalePage(
+  rows: readonly PageTranslation[]
+): PageTranslation | null {
+  return pickTranslation(rows, i18n.defaultLocale, pagesContract, i18n.defaultLocale);
+}

package/dist/templates/lib/search/config.fallback.ts.tmpl

@@ -0,0 +1,11 @@
+// Search is disabled in this project (scaffolded with `--no-search`
+// or `notionx remove search`). This stub exports `undefined` so the
+// worker entry point can skip passing `searchAdapter` to
+// `createNotionxWorker`, which in turn skips registering the
+// `/api/search` route.
+
+import type { SearchAdapter } from "@notionx/core/search";
+
+export const searchAdapter: SearchAdapter | undefined = undefined;
+
+export default searchAdapter;

package/dist/templates/lib/search/config.ts.tmpl

@@ -0,0 +1,25 @@
+// Search adapter configuration. Exports a `D1SearchAdapter` instance
+// backed by the project's D1 database. The worker entry point passes
+// this to `createNotionxWorker`, which registers the `/api/search`
+// route automatically.
+//
+// To switch to a different backend (e.g. Cloudflare Vectorize), replace
+// the adapter factory below. The `SearchAdapter` interface in
+// `@notionx/core/search` defines the contract.
+
+import { createD1SearchAdapter } from "@notionx/core/search";
+import type { SearchAdapter } from "@notionx/core/search";
+import { getRequestEnv } from "../site/request-env";
+
+/**
+ * Lazily resolve the D1 database binding from the request environment.
+ * The adapter is created once and reused across requests.
+ */
+function getDatabase() {
+  const env = getRequestEnv();
+  return env.DB;
+}
+
+export const searchAdapter: SearchAdapter = createD1SearchAdapter(getDatabase);
+
+export default searchAdapter;