minutework 0.1.26 → 0.1.27

package/assets/templates/next-tenant-app/src/app/sitemap.ts

@@ -2,9 +2,23 @@ import type { MetadataRoute } from "next";
 
 import { listEntries } from "@/lib/content/adapter.server";
 import { appRoutes } from "@/lib/app-routes";
-import { resolvePublicSiteUrl } from "@/lib/public-site";
+import { isPublicContentDisabled, resolvePublicSiteUrl } from "@/lib/public-site";
+
+function buildSitemapUrl(pathname: string) {
+  const url = resolvePublicSiteUrl(pathname);
+
+  if (!url) {
+    throw new Error("MW_PUBLIC_BASE_URL is required to build a public sitemap.");
+  }
+
+  return url.toString();
+}
 
 export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  if (isPublicContentDisabled()) {
+    return [];
+  }
+
   const [docsEntries, blogEntries] = await Promise.all([
     listEntries("docs"),
     listEntries("blog"),
@@ -12,22 +26,22 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
 
   const entries: MetadataRoute.Sitemap = [
     {
-      url: resolvePublicSiteUrl(appRoutes.publicHome).toString(),
+      url: buildSitemapUrl(appRoutes.publicHome),
       changeFrequency: "weekly",
       priority: 1,
     },
     {
-      url: resolvePublicSiteUrl(appRoutes.pricing).toString(),
+      url: buildSitemapUrl(appRoutes.pricing),
       changeFrequency: "monthly",
       priority: 0.8,
     },
     {
-      url: resolvePublicSiteUrl(appRoutes.docsIndex).toString(),
+      url: buildSitemapUrl(appRoutes.docsIndex),
       changeFrequency: "weekly",
       priority: 0.8,
     },
     {
-      url: resolvePublicSiteUrl(appRoutes.blogIndex).toString(),
+      url: buildSitemapUrl(appRoutes.blogIndex),
       changeFrequency: "weekly",
       priority: 0.8,
     },
@@ -35,7 +49,7 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
 
   entries.push(
     ...docsEntries.map((entry) => ({
-      url: resolvePublicSiteUrl(appRoutes.docsPage(entry.slug)).toString(),
+      url: buildSitemapUrl(appRoutes.docsPage(entry.slug)),
       changeFrequency: "weekly" as const,
       priority: 0.7,
     })),
@@ -43,7 +57,7 @@ export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
 
   entries.push(
     ...blogEntries.map((entry) => ({
-      url: resolvePublicSiteUrl(appRoutes.blogPost(entry.slug)).toString(),
+      url: buildSitemapUrl(appRoutes.blogPost(entry.slug)),
       changeFrequency: "monthly" as const,
       priority: 0.7,
       ...(entry.publishedAt ? { lastModified: new Date(entry.publishedAt) } : {}),

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

@@ -1,3 +1,7 @@
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 import type {
@@ -128,6 +132,7 @@ function restoreProcessEnv() {
 function applyServerEnv(overrides: Record<string, string | undefined>) {
   restoreProcessEnv();
   process.env.MW_PLATFORM_BASE_URL = "http://127.0.0.1:8000";
+  process.env.MW_PUBLIC_CONTENT_SOURCE = "minutework_cms";
   process.env.MW_CONTENT_API_TOKEN = "test-content-token";
   process.env.MW_PUBLIC_BASE_URL = "http://127.0.0.1:3000";
   process.env.MW_PUBLIC_SITE_PROPERTY_KEY = "main-site";
@@ -276,6 +281,11 @@ describe("public content adapter", () => {
   });
 
   it("accepts valid custom adapter output through the shared contract wrapper", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "custom",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+    });
     vi.doMock("@/lib/content/custom-adapter", () => ({
       resolveCustomPublicContentAdapter: () => createCustomAdapter(),
     }));
@@ -290,7 +300,94 @@ describe("public content adapter", () => {
     );
   });
 
+  it("requires an explicit adapter when MW_PUBLIC_CONTENT_SOURCE=custom", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "custom",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+    });
+    vi.doMock("@/lib/content/custom-adapter", () => ({
+      resolveCustomPublicContentAdapter: () => null,
+    }));
+
+    const adapterModule = await import("./adapter.server");
+
+    expect(() => adapterModule.getPublicContentAdapter()).toThrow(
+      "MW_PUBLIC_CONTENT_SOURCE=custom requires resolveCustomPublicContentAdapter()",
+    );
+  });
+
+  it("loads valid static JSON public content", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "mw-public-content-"));
+    const contentPath = join(tempRoot, "public-site.json");
+
+    try {
+      await writeFile(
+        contentPath,
+        JSON.stringify(publicSiteFixtureSnapshot),
+        "utf8",
+      );
+      applyServerEnv({
+        MW_PUBLIC_CONTENT_SOURCE: "static_json",
+        MW_CONTENT_API_TOKEN: undefined,
+        MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+        MW_STATIC_PUBLIC_CONTENT_PATH: contentPath,
+      });
+
+      const adapterModule = await import("./adapter.server");
+
+      await expect(adapterModule.getMarketingPage("home")).resolves.toEqual(
+        getFixtureMarketingPage("home"),
+      );
+    } finally {
+      await rm(tempRoot, { force: true, recursive: true });
+    }
+  });
+
+  it("rejects invalid static JSON public content", async () => {
+    const tempRoot = await mkdtemp(join(tmpdir(), "mw-public-content-"));
+    const contentPath = join(tempRoot, "public-site.json");
+
+    try {
+      await writeFile(contentPath, JSON.stringify({ site: {} }), "utf8");
+      applyServerEnv({
+        MW_PUBLIC_CONTENT_SOURCE: "static_json",
+        MW_CONTENT_API_TOKEN: undefined,
+        MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+        MW_STATIC_PUBLIC_CONTENT_PATH: contentPath,
+      });
+
+      const adapterModule = await import("./adapter.server");
+
+      await expect(adapterModule.getSiteConfig()).rejects.toThrow(
+        "Static public content is invalid",
+      );
+    } finally {
+      await rm(tempRoot, { force: true, recursive: true });
+    }
+  });
+
+  it("keeps public content disabled for private-only mode", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "none",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_BASE_URL: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+    });
+
+    const adapterModule = await import("./adapter.server");
+
+    await expect(adapterModule.getSiteConfig()).rejects.toThrow(
+      "Public content is disabled",
+    );
+  });
+
   it("rejects a custom adapter when a marketing page violates the canonical route contract", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "custom",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+    });
     vi.doMock("@/lib/content/custom-adapter", () => ({
       resolveCustomPublicContentAdapter: () =>
         createCustomAdapter({
@@ -317,6 +414,11 @@ describe("public content adapter", () => {
   });
 
   it("rejects a custom adapter when blog summaries use multi-segment slugs", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "custom",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+    });
     vi.doMock("@/lib/content/custom-adapter", () => ({
       resolveCustomPublicContentAdapter: () =>
         createCustomAdapter({

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

@@ -9,6 +9,7 @@ import type {
   MarketingPageKey,
   PublicContentAdapter,
   PublicContentKind,
+  PublicContentSnapshot,
   PublicEntry,
   PublicEntrySummary,
   PublicSiteSnapshotEnvelope,
@@ -19,6 +20,7 @@ import {
   marketingPageResultSchema,
   publicEntryResultSchema,
   publicEntrySummaryListSchema,
+  publicContentSnapshotSchema,
   publicSiteSnapshotEnvelopeSchema,
   siteConfigSchema,
 } from "@/lib/content/contracts";
@@ -71,6 +73,14 @@ function validateAdapterResult<T>(
   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,
@@ -134,6 +144,49 @@ export class ValidatedPublicContentAdapter implements PublicContentAdapter {
   }
 }
 
+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";
@@ -181,59 +234,92 @@ export async function fetchPublicSiteSnapshotEnvelope(input: {
 
 const loadPublicSiteSnapshotEnvelope = cache(async () =>
   fetchPublicSiteSnapshotEnvelope({
-    contentApiToken: env.MW_CONTENT_API_TOKEN,
+    contentApiToken: requirePublicContentEnv(
+      "MW_CONTENT_API_TOKEN",
+      env.MW_CONTENT_API_TOKEN,
+    ),
     environment: env.MW_PUBLIC_SITE_ENV,
     platformBaseUrl: env.MW_PLATFORM_BASE_URL,
-    propertyKey: env.MW_PUBLIC_SITE_PROPERTY_KEY,
+    propertyKey: requirePublicContentEnv(
+      "MW_PUBLIC_SITE_PROPERTY_KEY",
+      env.MW_PUBLIC_SITE_PROPERTY_KEY,
+    ),
   }),
 );
 
-export class MinuteWorkPublicSiteContentAdapter implements PublicContentAdapter {
+export class MinuteWorkPublicSiteContentAdapter extends PublicSiteSnapshotContentAdapter {
   constructor(
-    private readonly loadEnvelope: () => Promise<PublicSiteSnapshotEnvelope> = loadPublicSiteSnapshotEnvelope,
-  ) {}
+    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;
 
-  private async loadSnapshot() {
-    return (await this.loadEnvelope()).snapshot;
+  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> {
-    return (await this.loadSnapshot()).site;
+    this.throwDisabled();
   }
 
-  async getMarketingPage(pageKey: MarketingPageKey): Promise<MarketingPage | null> {
-    return (
-      (await this.loadSnapshot()).marketingPages.find((page) => page.pageKey === pageKey) ??
-      null
-    );
+  async getMarketingPage(): Promise<MarketingPage | null> {
+    this.throwDisabled();
   }
 
-  async listEntries(kind: PublicContentKind): Promise<PublicEntrySummary[]> {
-    return sortEntriesByDate((await this.loadSnapshot())[kind]);
+  async listEntries(): Promise<PublicEntrySummary[]> {
+    this.throwDisabled();
   }
 
-  async getEntry(kind: PublicContentKind, slugParts: string[]): Promise<PublicEntry | null> {
-    return (
-      (await this.loadSnapshot())[kind].find((entry) =>
-        compareSlugParts(entry.slug, slugParts),
-      ) ?? null
-    );
+  async getEntry(): Promise<PublicEntry | null> {
+    this.throwDisabled();
   }
 
-  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 getPageByPath(): Promise<ContentStructurePage | null> {
+    this.throwDisabled();
   }
 
-  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;
+  async listPages(): Promise<ContentStructurePage[]> {
+    this.throwDisabled();
   }
 }
 
@@ -241,17 +327,36 @@ 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(() => {
-  const customAdapter = resolveCustomPublicContentAdapter();
+  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.",
+      );
+    }
 
-  if (customAdapter) {
     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;
 });
 

package/assets/templates/next-tenant-app/src/lib/platform/env.server.test.ts

@@ -1,3 +1,5 @@
+import { readFile } from "node:fs/promises";
+
 import { afterEach, describe, expect, it, vi } from "vitest";
 
 const originalEnv = { ...process.env };
@@ -15,6 +17,7 @@ function restoreProcessEnv() {
 function applyServerEnv(overrides: Record<string, string | undefined>) {
   restoreProcessEnv();
   process.env.MW_PLATFORM_BASE_URL = "http://127.0.0.1:8000";
+  process.env.MW_PUBLIC_CONTENT_SOURCE = "minutework_cms";
   process.env.MW_CONTENT_API_TOKEN = "test-content-token";
   process.env.MW_PUBLIC_BASE_URL = "http://127.0.0.1:3000";
   process.env.MW_PUBLIC_SITE_PROPERTY_KEY = "main-site";
@@ -29,6 +32,23 @@ function applyServerEnv(overrides: Record<string, string | undefined>) {
   }
 }
 
+async function readEnvExample() {
+  const contents = await readFile(".env.example", "utf8");
+  return Object.fromEntries(
+    contents
+      .split("\n")
+      .map((line) => line.trim())
+      .filter((line) => line.length > 0 && !line.startsWith("#"))
+      .map((line) => {
+        const separatorIndex = line.indexOf("=");
+        return [
+          line.slice(0, separatorIndex),
+          line.slice(separatorIndex + 1),
+        ] as const;
+      }),
+  );
+}
+
 describe("server env", () => {
   afterEach(() => {
     restoreProcessEnv();
@@ -45,6 +65,26 @@ describe("server env", () => {
     expect(env.MW_PUBLIC_SITE_ENV).toBe("preview");
   });
 
+  it("defaults MW_PUBLIC_CONTENT_SOURCE to minutework_cms", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: undefined,
+    });
+
+    const { env } = await import("./env.server");
+
+    expect(env.MW_PUBLIC_CONTENT_SOURCE).toBe("minutework_cms");
+  });
+
+  it("defaults MW_STATIC_PUBLIC_CONTENT_PATH to content/public-site.json", async () => {
+    applyServerEnv({
+      MW_STATIC_PUBLIC_CONTENT_PATH: undefined,
+    });
+
+    const { env } = await import("./env.server");
+
+    expect(env.MW_STATIC_PUBLIC_CONTENT_PATH).toBe("content/public-site.json");
+  });
+
   it("accepts MW_PUBLIC_SITE_ENV=live", async () => {
     applyServerEnv({
       MW_PUBLIC_SITE_ENV: "live",
@@ -81,6 +121,69 @@ describe("server env", () => {
     );
   });
 
+  it("accepts custom public content without MinuteWork CMS credentials", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "custom",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+    });
+
+    const { env } = await import("./env.server");
+
+    expect(env.MW_PUBLIC_CONTENT_SOURCE).toBe("custom");
+    expect(env.MW_CONTENT_API_TOKEN).toBeUndefined();
+    expect(env.MW_PUBLIC_SITE_PROPERTY_KEY).toBeUndefined();
+  });
+
+  it("requires MW_PUBLIC_BASE_URL for custom public content", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "custom",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_BASE_URL: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+    });
+
+    await expect(import("./env.server")).rejects.toThrow("MW_PUBLIC_BASE_URL");
+  });
+
+  it("accepts static JSON public content without MinuteWork CMS credentials", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "static_json",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+      MW_STATIC_PUBLIC_CONTENT_PATH: "content/site.json",
+    });
+
+    const { env } = await import("./env.server");
+
+    expect(env.MW_PUBLIC_CONTENT_SOURCE).toBe("static_json");
+    expect(env.MW_STATIC_PUBLIC_CONTENT_PATH).toBe("content/site.json");
+  });
+
+  it("accepts private-only mode without public or CMS environment", async () => {
+    applyServerEnv({
+      MW_PUBLIC_CONTENT_SOURCE: "none",
+      MW_CONTENT_API_TOKEN: undefined,
+      MW_PUBLIC_BASE_URL: undefined,
+      MW_PUBLIC_SITE_PROPERTY_KEY: undefined,
+    });
+
+    const { env } = await import("./env.server");
+
+    expect(env.MW_PUBLIC_CONTENT_SOURCE).toBe("none");
+    expect(env.MW_PUBLIC_BASE_URL).toBeUndefined();
+  });
+
+  it("ships .env.example as private-only so generated apps boot without CMS", async () => {
+    await expect(readEnvExample()).resolves.toMatchObject({
+      MW_PUBLIC_CONTENT_SOURCE: "none",
+      MW_CONTENT_API_TOKEN: "",
+      MW_PUBLIC_BASE_URL: "",
+      MW_PUBLIC_SITE_PROPERTY_KEY: "",
+      MW_STATIC_PUBLIC_CONTENT_PATH: "content/public-site.json",
+    });
+  });
+
   it("requires MW_PLATFORM_BASE_URL in production", async () => {
     applyServerEnv({
       MW_PLATFORM_BASE_URL: undefined,