@anthusai/papyrus 0.0.0 → 1.0.0-next.10

package/amplify/storage/resource.js

@@ -0,0 +1,21 @@
+import { defineStorage } from "@aws-amplify/backend";
+export const storage = defineStorage({
+    name: "papyrusMedia",
+    isDefault: true,
+    access: (allow) => ({
+        "media/*": [
+            allow.guest.to(["read"]),
+            allow.authenticated.to(["read"]),
+            allow.groups(["editor", "admin"]).to(["read", "write", "delete"]),
+        ],
+        "corpora/*": [
+            allow.groups(["editor", "admin"]).to(["read"]),
+        ],
+        "preview/*": [
+            allow.groups(["editor", "admin"]).to(["read"]),
+        ],
+        "newsroom/*": [
+            allow.groups(["editor", "admin"]).to(["read", "write", "delete"]),
+        ],
+    }),
+});

package/amplify/storage/resource.ts

@@ -0,0 +1,22 @@
+import { defineStorage } from "@aws-amplify/backend";
+
+export const storage = defineStorage({
+  name: "papyrusMedia",
+  isDefault: true,
+  access: (allow) => ({
+    "media/*": [
+      allow.guest.to(["read"]),
+      allow.authenticated.to(["read"]),
+      allow.groups(["editor", "admin"]).to(["read", "write", "delete"]),
+    ],
+    "corpora/*": [
+      allow.groups(["editor", "admin"]).to(["read"]),
+    ],
+    "preview/*": [
+      allow.groups(["editor", "admin"]).to(["read"]),
+    ],
+    "newsroom/*": [
+      allow.groups(["editor", "admin"]).to(["read", "write", "delete"]),
+    ],
+  }),
+});

package/app/%5F_preview/[[...path]]/route.ts

@@ -0,0 +1,8 @@
+import type { NextRequest } from "next/server";
+import { streamPreviewObject } from "../../../lib/staging-preview-object";
+
+export const dynamic = "force-dynamic";
+
+export async function GET(request: NextRequest): Promise<Response> {
+  return streamPreviewObject(request.nextUrl.pathname);
+}

package/app/[year]/[month]/[day]/[articleSlug]/page.tsx

@@ -0,0 +1,62 @@
+import { notFound, redirect } from "next/navigation";
+import { getSiteRenderer } from "../../../../../lib/site-renderer";
+import { getCachedEditionItem, loadCachedEditionContent } from "../../../../../lib/cached-content-repository";
+import { getEditionDatePath, parseEditionArticleRoute } from "../../../../../lib/edition-routes";
+import { buildPresentationFooterEntries } from "../../../../../lib/presentation-footer";
+import { SITE_BRAND } from "../../../../../lib/site-brand";
+// Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
+export const revalidate = 3600;
+
+type DateScopedArticlePageProps = {
+  params: Promise<{
+    year: string;
+    month: string;
+    day: string;
+    articleSlug: string;
+  }>;
+};
+
+export async function generateMetadata({ params }: DateScopedArticlePageProps) {
+  const { year, month, day, articleSlug } = await params;
+  const route = parseEditionArticleRoute({ year, month, day, articleSlug });
+  if (!route) return {};
+
+  const item = await getCachedEditionItem({
+    editionDate: route.editionDate,
+    itemSlug: route.articleSlug,
+  });
+  if (!item) return {};
+
+  return {
+    title: `${item.type === "article" ? item.headline : item.title} | ${SITE_BRAND.articleTitleSuffix}`,
+    description: item.deck,
+  };
+}
+
+export default async function DateScopedArticlePage({ params }: DateScopedArticlePageProps) {
+  const { year, month, day, articleSlug } = await params;
+  const route = parseEditionArticleRoute({ year, month, day, articleSlug });
+  if (!route) notFound();
+  if (!route.isCanonical) redirect(route.canonicalPath);
+
+  const content = await loadCachedEditionContent({ editionDate: route.editionDate });
+  const item = content.items.find((candidate) => candidate.slug === route.articleSlug);
+  if (!item) notFound();
+  const editionBasePath = getEditionDatePath(route.editionDate);
+
+  const siteRenderer = getSiteRenderer();
+
+  return (
+    <siteRenderer.renderItem
+      editionDate={content.editionDate}
+      editionFooter={{
+        editionBasePath,
+        entries: buildPresentationFooterEntries(content),
+        subtitle: SITE_BRAND.footerSubtitleOverride ?? (content.description?.trim() || "Inside Papyrus"),
+        title: SITE_BRAND.footerTitle,
+      }}
+      item={item}
+      backHref={`${editionBasePath}#${item.slug}`}
+    />
+  );
+}

package/app/[year]/[month]/[day]/edition-route-page.tsx

@@ -0,0 +1,53 @@
+import { notFound, redirect } from "next/navigation";
+import { getSiteRenderer } from "../../../../lib/site-renderer";
+import type { PresentationTarget } from "../../../../renderers/pretext";
+import { loadCachedEditionContent } from "../../../../lib/cached-content-repository";
+import { parseEditionDateRoute } from "../../../../lib/edition-routes";
+import type { PretextLayout } from "../../../../lib/renderer-config";
+
+type EditionRoutePageProps = {
+  year: string;
+  month: string;
+  day: string;
+  initialPageNumber?: number;
+  lockedPresentation?: PretextLayout;
+  target?: PresentationTarget;
+};
+
+export async function EditionRoutePage({
+  year,
+  month,
+  day,
+  initialPageNumber = 1,
+  lockedPresentation,
+  target = { kind: "edition" },
+}: EditionRoutePageProps) {
+  const route = parseEditionDateRoute({ year, month, day });
+  if (!route) notFound();
+  if (!route.isCanonical) redirect(route.canonicalPath);
+
+  try {
+    const content = await loadCachedEditionContent({
+      editionDate: route.editionDate,
+    });
+    if (initialPageNumber < 1 || initialPageNumber > content.layoutPlan.pages.length) notFound();
+    if (target.kind === "section" && !content.sections.some((section) => section.key === target.sectionKey)) notFound();
+    const siteRenderer = getSiteRenderer();
+    return (
+      <siteRenderer.renderEdition
+        content={content}
+        editionBasePath={route.canonicalPath}
+        initialPageNumber={initialPageNumber}
+        lockedPresentation={lockedPresentation}
+        target={target}
+      />
+    );
+  } catch (error) {
+    if (isMissingGraphQLEditionError(error)) notFound();
+    throw error;
+  }
+}
+
+function isMissingGraphQLEditionError(error: unknown): boolean {
+  return error instanceof Error && error.message.includes("No published GraphQL edition found");
+}

package/app/[year]/[month]/[day]/page/[pageNumber]/page.tsx

@@ -0,0 +1,32 @@
+import { notFound, redirect } from "next/navigation";
+import { EditionRoutePage } from "../../edition-route-page";
+import { parseEditionPageRoute } from "../../../../../../lib/edition-routes";
+import { getDefaultPretextLayout, getForcedPresentation } from "../../../../../../lib/site-brand";
+// Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
+export const revalidate = 3600;
+
+type EditionPageRouteProps = {
+  params: Promise<{
+    year: string;
+    month: string;
+    day: string;
+    pageNumber: string;
+  }>;
+};
+
+export default async function EditionPageRoute({ params }: EditionPageRouteProps) {
+  const { year, month, day, pageNumber } = await params;
+  const route = parseEditionPageRoute({ year, month, day, pageNumber });
+  if (!route) notFound();
+  if (!route.isCanonical) redirect(route.canonicalPath);
+
+  return (
+    <EditionRoutePage
+      day={day}
+      initialPageNumber={route.pageNumber}
+      lockedPresentation={getForcedPresentation() ?? getDefaultPretextLayout()}
+      month={month}
+      year={year}
+    />
+  );
+}

package/app/[year]/[month]/[day]/page.tsx

@@ -0,0 +1,22 @@
+import { EditionRoutePage } from "./edition-route-page";
+import { generateEditionDateStaticParams } from "../../../../lib/reader-static-params";
+
+// Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
+export const revalidate = 3600;
+
+export async function generateStaticParams() {
+  return generateEditionDateStaticParams();
+}
+
+type DateEditionPageProps = {
+  params: Promise<{
+    year: string;
+    month: string;
+    day: string;
+  }>;
+};
+
+export default async function DateEditionPage({ params }: DateEditionPageProps) {
+  const { year, month, day } = await params;
+  return <EditionRoutePage day={day} month={month} year={year} />;
+}

package/app/[year]/[month]/[day]/section/[sectionKey]/page.tsx

@@ -0,0 +1,32 @@
+import { notFound, redirect } from "next/navigation";
+import { EditionRoutePage } from "../../edition-route-page";
+import { createSectionKey } from "../../../../../../lib/edition-sections";
+import { parseEditionSectionRoute } from "../../../../../../lib/edition-routes";
+// Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
+export const revalidate = 3600;
+
+type EditionSectionRouteProps = {
+  params: Promise<{
+    year: string;
+    month: string;
+    day: string;
+    sectionKey: string;
+  }>;
+};
+
+export default async function EditionSectionRoute({ params }: EditionSectionRouteProps) {
+  const { year, month, day, sectionKey } = await params;
+  const normalizedSectionKey = createSectionKey(sectionKey);
+  const route = parseEditionSectionRoute({ year, month, day, sectionKey: normalizedSectionKey });
+  if (!route) notFound();
+  if (!route.isCanonical) redirect(route.canonicalPath);
+
+  return (
+    <EditionRoutePage
+      day={day}
+      month={month}
+      target={{ kind: "section", sectionKey: route.sectionKey }}
+      year={year}
+    />
+  );
+}

package/app/api/archive/editions/route.ts

@@ -0,0 +1,18 @@
+import { NextResponse } from "next/server";
+import { loadArchiveEditionPreviews, clampArchiveLimit } from "../../../../lib/archive-data";
+import { ARCHIVE_BATCH_SIZE } from "../../../../lib/archive-types";
+
+// Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
+export const revalidate = 3600;
+
+export async function GET(request: Request) {
+  const url = new URL(request.url);
+  const cursor = url.searchParams.get("cursor");
+  const requestedLimit = Number(url.searchParams.get("limit") ?? ARCHIVE_BATCH_SIZE);
+  const payload = await loadArchiveEditionPreviews({
+    limit: clampArchiveLimit(requestedLimit),
+    nextToken: cursor,
+  });
+
+  return NextResponse.json(payload);
+}

package/app/api/media/[...path]/route.ts

@@ -0,0 +1,35 @@
+import { NextResponse } from "next/server";
+import { isGuestReadableStoragePath, signStorageUrl } from "../../../../lib/reader-storage-url";
+
+export const dynamic = "force-dynamic";
+
+type MediaRouteContext = {
+  params: Promise<{
+    path: string[];
+  }>;
+};
+
+export async function GET(_request: Request, context: MediaRouteContext) {
+  const { path } = await context.params;
+  const storagePath = path.map((segment) => decodeURIComponent(segment)).join("/");
+  if (!isGuestReadableStoragePath(storagePath)) {
+    return NextResponse.json({ error: "Forbidden storage path." }, { status: 403 });
+  }
+
+  const signedUrl = await signStorageUrl(storagePath);
+  const upstream = await fetch(signedUrl, { cache: "no-store" });
+  if (!upstream.ok) {
+    return NextResponse.json(
+      { error: `Upstream media fetch failed (${upstream.status}).` },
+      { status: upstream.status === 404 ? 404 : 502 },
+    );
+  }
+
+  const headers = new Headers();
+  const contentType = upstream.headers.get("content-type");
+  if (contentType) {
+    headers.set("content-type", contentType);
+  }
+  headers.set("cache-control", "public, max-age=3600, stale-while-revalidate=86400");
+  return new NextResponse(upstream.body, { status: 200, headers });
+}

package/app/api/revalidate/route.ts

@@ -0,0 +1,94 @@
+import { revalidatePath, revalidateTag } from "next/cache";
+import { NextResponse } from "next/server";
+import {
+  ARCHIVE_CACHE_TAG,
+  ARTICLES_CACHE_TAG,
+  EDITIONS_CACHE_TAG,
+  articleCacheTag,
+  editionContentCacheTag,
+  editionItemCacheTag,
+} from "../../../lib/cached-content-repository";
+import { getEditionArticlePath, getEditionDatePath } from "../../../lib/edition-routes";
+
+export const dynamic = "force-dynamic";
+
+type RevalidateRequestBody = {
+  editionDate?: string;
+  articleSlugs?: string[];
+  itemSlugs?: string[];
+  paths?: string[];
+  tags?: string[];
+};
+
+export async function POST(request: Request) {
+  const configuredSecret = process.env.PAPYRUS_REVALIDATE_SECRET?.trim();
+  const providedSecret = request.headers.get("x-papyrus-revalidate-secret")?.trim();
+  if (!configuredSecret || providedSecret !== configuredSecret) {
+    return NextResponse.json({ ok: false, error: "Unauthorized." }, { status: 401 });
+  }
+
+  const body = (await request.json()) as RevalidateRequestBody;
+  const revalidatedTags = new Set<string>();
+  const revalidatedPaths = new Set<string>();
+
+  const editionDate = body.editionDate?.trim();
+  if (editionDate) {
+    revalidateTag(editionContentCacheTag(editionDate));
+    revalidatedTags.add(editionContentCacheTag(editionDate));
+    revalidatePath(getEditionDatePath(editionDate));
+    revalidatedPaths.add(getEditionDatePath(editionDate));
+  }
+
+  for (const slug of body.articleSlugs ?? []) {
+    const normalized = slug.trim();
+    if (!normalized) continue;
+    revalidateTag(articleCacheTag(normalized));
+    revalidatedTags.add(articleCacheTag(normalized));
+    revalidatePath(`/articles/${encodeURIComponent(normalized)}`);
+    revalidatedPaths.add(`/articles/${encodeURIComponent(normalized)}`);
+    if (editionDate) {
+      revalidateTag(editionItemCacheTag(editionDate, normalized));
+      revalidatedTags.add(editionItemCacheTag(editionDate, normalized));
+      revalidatePath(getEditionArticlePath(editionDate, normalized));
+      revalidatedPaths.add(getEditionArticlePath(editionDate, normalized));
+    }
+  }
+
+  for (const slug of body.itemSlugs ?? []) {
+    const normalized = slug.trim();
+    if (!normalized || !editionDate) continue;
+    revalidateTag(editionItemCacheTag(editionDate, normalized));
+    revalidatedTags.add(editionItemCacheTag(editionDate, normalized));
+    revalidatePath(getEditionArticlePath(editionDate, normalized));
+    revalidatedPaths.add(getEditionArticlePath(editionDate, normalized));
+  }
+
+  for (const tag of body.tags ?? []) {
+    const normalized = tag.trim();
+    if (!normalized) continue;
+    revalidateTag(normalized);
+    revalidatedTags.add(normalized);
+  }
+
+  revalidateTag(EDITIONS_CACHE_TAG);
+  revalidatedTags.add(EDITIONS_CACHE_TAG);
+  revalidateTag(ARCHIVE_CACHE_TAG);
+  revalidatedTags.add(ARCHIVE_CACHE_TAG);
+  revalidateTag(ARTICLES_CACHE_TAG);
+  revalidatedTags.add(ARTICLES_CACHE_TAG);
+  revalidatePath("/archive");
+  revalidatedPaths.add("/archive");
+
+  for (const path of body.paths ?? []) {
+    const normalized = path.trim();
+    if (!normalized.startsWith("/")) continue;
+    revalidatePath(normalized);
+    revalidatedPaths.add(normalized);
+  }
+
+  return NextResponse.json({
+    ok: true,
+    revalidatedTags: [...revalidatedTags],
+    revalidatedPaths: [...revalidatedPaths],
+  });
+}

package/app/archive/page.tsx

@@ -0,0 +1,24 @@
+import { ArchiveShell } from "../../components/archive-shell";
+import { ArchiveGrid } from "../../components/archive-grid";
+import { loadArchiveEditionPreviews } from "../../lib/archive-data";
+import { ARCHIVE_BATCH_SIZE } from "../../lib/archive-types";
+
+// Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
+export const revalidate = 3600;
+
+export default async function ArchivePage() {
+  const initialBatch = await loadArchiveEditionPreviews({ limit: ARCHIVE_BATCH_SIZE });
+
+  return (
+    <ArchiveShell>
+      <header className="masthead archive-header" aria-describedby="archive-description" aria-labelledby="archive-title">
+        <div className="masthead__rule archive-header__rule" />
+        <h1 id="archive-title">
+          <span>ARCHIVE</span>
+        </h1>
+        <p className="archive-description" id="archive-description">Previous editions</p>
+      </header>
+      <ArchiveGrid initialNextCursor={initialBatch.nextCursor ?? null} initialPreviews={initialBatch.previews} />
+    </ArchiveShell>
+  );
+}

package/app/articles/[slug]/page.tsx

@@ -0,0 +1,35 @@
+import { notFound } from "next/navigation";
+import { getSiteRenderer } from "../../../lib/site-renderer";
+import { getCachedArticle } from "../../../lib/cached-content-repository";
+import { generateArticleStaticParams } from "../../../lib/reader-static-params";
+import { SITE_BRAND } from "../../../lib/site-brand";
+
+// Keep in sync with READER_REVALIDATE_SECONDS in lib/reader-route-config.ts
+export const revalidate = 3600;
+
+export async function generateStaticParams() {
+  return generateArticleStaticParams();
+}
+
+type ArticlePageProps = {
+  params: Promise<{ slug: string }>;
+};
+
+export async function generateMetadata({ params }: ArticlePageProps) {
+  const { slug } = await params;
+  const article = await getCachedArticle(slug);
+  if (!article) return {};
+  return {
+    title: `${article.headline} | ${SITE_BRAND.articleTitleSuffix}`,
+    description: article.deck,
+  };
+}
+
+export default async function ArticlePage({ params }: ArticlePageProps) {
+  const { slug } = await params;
+  const article = await getCachedArticle(slug);
+  if (!article) notFound();
+
+  const siteRenderer = getSiteRenderer();
+  return <siteRenderer.renderArticle article={article} backHref="/" />;
+}