minutework 0.1.32 → 0.1.34

package/assets/templates/next-tenant-app/src/lib/content/adapter.server.ts

@@ -1,383 +0,0 @@
-import "server-only";
-
-import { cache } from "react";
-import { z, type ZodType } from "zod";
-
-import type {
-  ContentStructurePage,
-  MarketingPage,
-  MarketingPageKey,
-  PublicContentAdapter,
-  PublicContentKind,
-  PublicContentSnapshot,
-  PublicEntry,
-  PublicEntrySummary,
-  PublicSiteSnapshotEnvelope,
-  SiteConfig,
-} from "@/lib/content/contracts";
-import {
-  contentStructurePageSchema,
-  marketingPageResultSchema,
-  publicEntryResultSchema,
-  publicEntrySummaryListSchema,
-  publicContentSnapshotSchema,
-  publicSiteSnapshotEnvelopeSchema,
-  siteConfigSchema,
-} from "@/lib/content/contracts";
-import { resolveCustomPublicContentAdapter } from "@/lib/content/custom-adapter";
-import { env } from "@/lib/platform/env.server";
-
-export const PUBLIC_CONTENT_REVALIDATE_SECONDS = 300;
-
-function normalizeSlugParts(slugParts: readonly string[]) {
-  return slugParts.map((part) => part.trim().toLowerCase()).filter(Boolean).join("/");
-}
-
-function compareSlugParts(left: readonly string[], right: readonly string[]) {
-  return normalizeSlugParts(left) === normalizeSlugParts(right);
-}
-
-function sortEntriesByDate(entries: readonly PublicEntrySummary[]) {
-  return [...entries].sort((left, right) => {
-    const leftTime = left.publishedAt ? Date.parse(left.publishedAt) : 0;
-    const rightTime = right.publishedAt ? Date.parse(right.publishedAt) : 0;
-    return rightTime - leftTime;
-  });
-}
-
-function formatZodIssues(
-  issues: readonly { message: string; path: readonly (string | number)[] }[],
-) {
-  return issues
-    .map((issue) => {
-      const path = issue.path.length > 0 ? issue.path.join(".") : "root";
-      return `${path}: ${issue.message}`;
-    })
-    .join("; ");
-}
-
-function validateAdapterResult<T>(
-  adapterLabel: string,
-  methodLabel: string,
-  schema: ZodType<T>,
-  value: unknown,
-) {
-  const parsedValue = schema.safeParse(value);
-
-  if (!parsedValue.success) {
-    throw new Error(
-      `${adapterLabel} returned invalid ${methodLabel}: ${formatZodIssues(parsedValue.error.issues)}`,
-    );
-  }
-
-  return parsedValue.data;
-}
-
-function requirePublicContentEnv(key: string, value: string | undefined) {
-  if (!value) {
-    throw new Error(`${key} is required for MW_PUBLIC_CONTENT_SOURCE=minutework_cms.`);
-  }
-
-  return value;
-}
-
-export class ValidatedPublicContentAdapter implements PublicContentAdapter {
-  constructor(
-    private readonly adapter: PublicContentAdapter,
-    private readonly adapterLabel: string,
-  ) {}
-
-  async getSiteConfig(): Promise<SiteConfig> {
-    return validateAdapterResult(
-      this.adapterLabel,
-      "site config",
-      siteConfigSchema,
-      await this.adapter.getSiteConfig(),
-    );
-  }
-
-  async getMarketingPage(pageKey: MarketingPageKey): Promise<MarketingPage | null> {
-    return validateAdapterResult(
-      this.adapterLabel,
-      `marketing page for "${pageKey}"`,
-      marketingPageResultSchema(pageKey),
-      await this.adapter.getMarketingPage(pageKey),
-    );
-  }
-
-  async listEntries(kind: PublicContentKind): Promise<PublicEntrySummary[]> {
-    return validateAdapterResult(
-      this.adapterLabel,
-      `${kind} entry summaries`,
-      publicEntrySummaryListSchema(kind),
-      await this.adapter.listEntries(kind),
-    );
-  }
-
-  async getEntry(kind: PublicContentKind, slugParts: string[]): Promise<PublicEntry | null> {
-    return validateAdapterResult(
-      this.adapterLabel,
-      `${kind} entry for "${normalizeSlugParts(slugParts)}"`,
-      publicEntryResultSchema(kind, slugParts),
-      await this.adapter.getEntry(kind, slugParts),
-    );
-  }
-
-  async getPageByPath(path: string): Promise<ContentStructurePage | null> {
-    if (!this.adapter.getPageByPath) return null;
-    return validateAdapterResult(
-      this.adapterLabel,
-      `CMS page for path "${path}"`,
-      contentStructurePageSchema.nullable(),
-      await this.adapter.getPageByPath(path),
-    );
-  }
-
-  async listPages(status?: string): Promise<ContentStructurePage[]> {
-    if (!this.adapter.listPages) return [];
-    return validateAdapterResult(
-      this.adapterLabel,
-      "CMS page list",
-      z.array(contentStructurePageSchema),
-      await this.adapter.listPages(status),
-    );
-  }
-}
-
-export class PublicSiteSnapshotContentAdapter implements PublicContentAdapter {
-  constructor(private readonly loadSnapshot: () => Promise<PublicContentSnapshot>) {}
-
-  async getSiteConfig(): Promise<SiteConfig> {
-    return (await this.loadSnapshot()).site;
-  }
-
-  async getMarketingPage(pageKey: MarketingPageKey): Promise<MarketingPage | null> {
-    return (
-      (await this.loadSnapshot()).marketingPages.find((page) => page.pageKey === pageKey) ??
-      null
-    );
-  }
-
-  async listEntries(kind: PublicContentKind): Promise<PublicEntrySummary[]> {
-    return sortEntriesByDate((await this.loadSnapshot())[kind]);
-  }
-
-  async getEntry(kind: PublicContentKind, slugParts: string[]): Promise<PublicEntry | null> {
-    return (
-      (await this.loadSnapshot())[kind].find((entry) =>
-        compareSlugParts(entry.slug, slugParts),
-      ) ?? null
-    );
-  }
-
-  async getPageByPath(path: string): Promise<ContentStructurePage | null> {
-    const snapshot = await this.loadSnapshot();
-    const pages = snapshot.pages ?? [];
-    const normalizedPath = path.replace(/\/+$/, "") || "/";
-    return pages.find((p) => p.path === normalizedPath) ?? null;
-  }
-
-  async listPages(status?: string): Promise<ContentStructurePage[]> {
-    const snapshot = await this.loadSnapshot();
-    const pages = snapshot.pages ?? [];
-    if (status) {
-      return pages.filter((p) => p.status === status);
-    }
-    return pages;
-  }
-}
-
-export async function fetchPublicSiteSnapshotEnvelope(input: {
-  contentApiToken: string;
-  environment: "preview" | "live";
-  platformBaseUrl: string;
-  propertyKey: string;
-}): Promise<PublicSiteSnapshotEnvelope> {
-  const requestUrl = new URL(
-    `/api/v1/developer/public-site/snapshots/${encodeURIComponent(input.propertyKey)}/`,
-    `${input.platformBaseUrl.replace(/\/$/, "")}/`,
-  );
-  requestUrl.searchParams.set("environment", input.environment);
-
-  const response = await fetch(requestUrl.toString(), {
-    headers: {
-      accept: "application/json",
-      authorization: `Bearer ${input.contentApiToken}`,
-    },
-    next: {
-      revalidate: PUBLIC_CONTENT_REVALIDATE_SECONDS,
-      tags: [
-        "public-site-content",
-        `public-site-content:${input.propertyKey}`,
-        `public-site-content:${input.environment}`,
-      ],
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(
-      `Unable to load public-site ${input.environment} snapshot for "${input.propertyKey}" (${response.status}).`,
-    );
-  }
-
-  const payload = await response.json();
-  const parsedEnvelope = publicSiteSnapshotEnvelopeSchema.safeParse(payload);
-
-  if (!parsedEnvelope.success) {
-    throw new Error(
-      `Public-site snapshot envelope is invalid: ${formatZodIssues(parsedEnvelope.error.issues)}`,
-    );
-  }
-
-  return parsedEnvelope.data;
-}
-
-const loadPublicSiteSnapshotEnvelope = cache(async () =>
-  fetchPublicSiteSnapshotEnvelope({
-    contentApiToken: requirePublicContentEnv(
-      "MW_CONTENT_API_TOKEN",
-      env.MW_CONTENT_API_TOKEN,
-    ),
-    environment: env.MW_PUBLIC_SITE_ENV,
-    platformBaseUrl: env.MW_PLATFORM_BASE_URL,
-    propertyKey: requirePublicContentEnv(
-      "MW_PUBLIC_SITE_PROPERTY_KEY",
-      env.MW_PUBLIC_SITE_PROPERTY_KEY,
-    ),
-  }),
-);
-
-export class MinuteWorkPublicSiteContentAdapter extends PublicSiteSnapshotContentAdapter {
-  constructor(
-    loadEnvelope: () => Promise<PublicSiteSnapshotEnvelope> = loadPublicSiteSnapshotEnvelope,
-  ) {
-    super(async () => (await loadEnvelope()).snapshot);
-  }
-}
-
-const loadStaticPublicContentSnapshot = cache(async () => {
-  const [{ readFile }, { resolve }] = await Promise.all([
-    import("node:fs/promises"),
-    import("node:path"),
-  ]);
-  const contentPath = resolve(
-    /* turbopackIgnore: true */ process.cwd(),
-    env.MW_STATIC_PUBLIC_CONTENT_PATH,
-  );
-  let payload: unknown;
-
-  try {
-    payload = JSON.parse(await readFile(contentPath, "utf8"));
-  } catch (error) {
-    throw new Error(
-      `Unable to load static public content from "${env.MW_STATIC_PUBLIC_CONTENT_PATH}": ${error instanceof Error ? error.message : String(error)}`,
-    );
-  }
-
-  const parsedSnapshot = publicContentSnapshotSchema.safeParse(payload);
-
-  if (!parsedSnapshot.success) {
-    throw new Error(
-      `Static public content is invalid: ${formatZodIssues(parsedSnapshot.error.issues)}`,
-    );
-  }
-
-  return parsedSnapshot.data;
-});
-
-export class StaticJsonPublicContentAdapter extends PublicSiteSnapshotContentAdapter {
-  constructor(
-    loadSnapshot: () => Promise<PublicContentSnapshot> = loadStaticPublicContentSnapshot,
-  ) {
-    super(loadSnapshot);
-  }
-}
-
-class DisabledPublicContentAdapter implements PublicContentAdapter {
-  private throwDisabled(): never {
-    throw new Error("Public content is disabled by MW_PUBLIC_CONTENT_SOURCE=none.");
-  }
-
-  async getSiteConfig(): Promise<SiteConfig> {
-    this.throwDisabled();
-  }
-
-  async getMarketingPage(): Promise<MarketingPage | null> {
-    this.throwDisabled();
-  }
-
-  async listEntries(): Promise<PublicEntrySummary[]> {
-    this.throwDisabled();
-  }
-
-  async getEntry(): Promise<PublicEntry | null> {
-    this.throwDisabled();
-  }
-
-  async getPageByPath(): Promise<ContentStructurePage | null> {
-    this.throwDisabled();
-  }
-
-  async listPages(): Promise<ContentStructurePage[]> {
-    this.throwDisabled();
-  }
-}
-
-const defaultPublicContentAdapter = new ValidatedPublicContentAdapter(
-  new MinuteWorkPublicSiteContentAdapter(),
-  "MinuteWork public-site content adapter",
-);
-const staticJsonPublicContentAdapter = new ValidatedPublicContentAdapter(
-  new StaticJsonPublicContentAdapter(),
-  "Static JSON public content adapter",
-);
-const disabledPublicContentAdapter = new DisabledPublicContentAdapter();
-
-export const getPublicContentAdapter = cache(() => {
-  if (env.MW_PUBLIC_CONTENT_SOURCE === "custom") {
-    const customAdapter = resolveCustomPublicContentAdapter();
-
-    if (!customAdapter) {
-      throw new Error(
-        "MW_PUBLIC_CONTENT_SOURCE=custom requires resolveCustomPublicContentAdapter() to return a PublicContentAdapter.",
-      );
-    }
-
-    return new ValidatedPublicContentAdapter(
-      customAdapter,
-      "Custom public content adapter",
-    );
-  }
-
-  if (env.MW_PUBLIC_CONTENT_SOURCE === "static_json") {
-    return staticJsonPublicContentAdapter;
-  }
-
-  if (env.MW_PUBLIC_CONTENT_SOURCE === "none") {
-    return disabledPublicContentAdapter;
-  }
-
-  return defaultPublicContentAdapter;
-});
-
-export const getSiteConfig = cache(async () => getPublicContentAdapter().getSiteConfig());
-
-export const getMarketingPage = cache(async (pageKey: MarketingPageKey) =>
-  getPublicContentAdapter().getMarketingPage(pageKey),
-);
-
-export const listEntries = cache(async (kind: PublicContentKind) =>
-  getPublicContentAdapter().listEntries(kind),
-);
-
-export const getEntry = cache(async (kind: PublicContentKind, slugParts: string[]) =>
-  getPublicContentAdapter().getEntry(kind, slugParts),
-);
-
-export const getPageByPath = cache(async (path: string) =>
-  getPublicContentAdapter().getPageByPath(path),
-);
-
-export const listPages = cache(async (status?: string) =>
-  getPublicContentAdapter().listPages(status),
-);

package/assets/templates/next-tenant-app/src/lib/content/contracts.test.ts

@@ -1,138 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  contentSectionSchema,
-  contentStructurePageSchema,
-  publicContentSnapshotSchema,
-} from "./contracts";
-
-describe("content_structure contracts", () => {
-  it("validates a page with arbitrary section types", () => {
-    const page = {
-      page_key: "landing",
-      path: "/landing",
-      title: "Landing Page",
-      status: "published",
-      sort_order: 0,
-      content_structure: {
-        sections: [
-          {
-            section_key: "hero",
-            section_type: "hero_banner",
-            sort_order: 0,
-            data: { heading: "Welcome", subheading: "To our site" },
-          },
-          {
-            section_key: "features",
-            section_type: "custom_feature_grid",
-            sort_order: 1,
-            data: {
-              columns: 3,
-              items: [
-                { title: "Fast", icon: "bolt" },
-                { title: "Secure", icon: "lock" },
-              ],
-            },
-          },
-          {
-            section_key: "tenant_custom",
-            section_type: "my_custom_widget",
-            sort_order: 2,
-            data: { arbitrary: "tenant-defined", nested: { deep: true } },
-          },
-        ],
-      },
-      seo_metadata: {
-        title: "Landing Page",
-        description: "A landing page with arbitrary sections",
-      },
-    };
-
-    const result = contentStructurePageSchema.safeParse(page);
-    expect(result.success).toBe(true);
-    if (result.success) {
-      expect(result.data.content_structure.sections).toHaveLength(3);
-      expect(result.data.content_structure.sections[2]!.section_type).toBe(
-        "my_custom_widget",
-      );
-    }
-  });
-
-  it("rejects a section without section_key", () => {
-    const section = {
-      section_type: "text",
-      data: { heading: "Heading" },
-    };
-    const result = contentSectionSchema.safeParse(section);
-    expect(result.success).toBe(false);
-  });
-
-  it("allows empty sections array", () => {
-    const page = {
-      page_key: "empty",
-      path: "/empty",
-      title: "Empty Page",
-      status: "draft",
-      content_structure: { sections: [] },
-    };
-    const result = contentStructurePageSchema.safeParse(page);
-    expect(result.success).toBe(true);
-  });
-
-  it("snapshot schema accepts optional pages array", () => {
-    const snapshot = {
-      site: {
-        siteName: "Test",
-        siteDescription: "Test site",
-        organizationName: "Org",
-        footerBlurb: "Footer",
-        primaryCta: { label: "CTA", href: "/" },
-        secondaryCta: { label: "CTA2", href: "/docs" },
-        primaryNavigation: [{ label: "Home", href: "/" }],
-        collections: {
-          docs: { eyebrow: "Docs", title: "Docs", description: "Documentation" },
-          blog: { eyebrow: "Blog", title: "Blog", description: "Updates" },
-        },
-      },
-      marketingPages: [],
-      docs: [],
-      blog: [],
-      pages: [
-        {
-          page_key: "about",
-          path: "/about",
-          title: "About",
-          status: "published",
-          content_structure: { sections: [] },
-        },
-      ],
-    };
-
-    const result = publicContentSnapshotSchema.safeParse(snapshot);
-    expect(result.success).toBe(true);
-  });
-
-  it("snapshot schema works without pages field (backward compat)", () => {
-    const snapshot = {
-      site: {
-        siteName: "Test",
-        siteDescription: "Test site",
-        organizationName: "Org",
-        footerBlurb: "Footer",
-        primaryCta: { label: "CTA", href: "/" },
-        secondaryCta: { label: "CTA2", href: "/docs" },
-        primaryNavigation: [{ label: "Home", href: "/" }],
-        collections: {
-          docs: { eyebrow: "Docs", title: "Docs", description: "Documentation" },
-          blog: { eyebrow: "Blog", title: "Blog", description: "Updates" },
-        },
-      },
-      marketingPages: [],
-      docs: [],
-      blog: [],
-    };
-
-    const result = publicContentSnapshotSchema.safeParse(snapshot);
-    expect(result.success).toBe(true);
-  });
-});