create-astroid 0.9.1 → 0.10.0

package/index.mjs

@@ -4,7 +4,7 @@
 // `create-astroid`—scaffold a new Astroid site in one command:
 //
 //   pnpm create astroid@latest my-site
-//   pnpm create astroid@latest my-site --key coracle --name "Coracle Coffee" --color "#1f6f78" --host coracle.coffee
+//   pnpm create astroid@latest my-site --key example --name "Example Organization" --color "#5b4bff" --host example.com
 //
 // It writes the floor: the `defineAstroid` config, the generated
 // schema/worker/middleware trio + wrangler.jsonc (via astroidjs), the Better Auth

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-astroid",
-  "version": "0.9.1",
+  "version": "0.10.0",
   "description": "Scaffold a new Astroid site — an editable, multi-editor Astro app on Cloudflare Workers — in one command.",
   "keywords": [
     "astro",
@@ -32,10 +32,10 @@
   },
   "dependencies": {
     "@better-auth/passkey": "^1.7.2",
-    "@louise-toolkit/astro": "^0.3.0",
-    "astroidjs": "0.17.0",
+    "@louise-toolkit/astro": "^0.5.0",
+    "astroidjs": "0.19.0",
     "better-auth": "^1.7.2",
-    "louise-toolkit": "^0.34.0"
+    "louise-toolkit": "^0.36.0"
   },
   "engines": {
     "node": ">=26.0.0"

package/template/README.md

@@ -84,15 +84,17 @@ There are no passwords and no editor list in env to keep in sync.
    bar** appears with **Settings** and **Done**.
 3. The home page's **title and body are editable in place**—click into them and
    type. Edits stage a **draft**; **Publish** (in the edit bar) promotes it live.
-   **Settings** opens the drawer: **Pages** (create/edit other pages), **Media**,
+   **Settings** opens the drawer: **Pages** (create/edit other pages, each served
+   at its slug once published, such as `/about`), **Media**,
    **Settings** (brand, nav, contact, SEO), and **Users** (invite/remove editors).
    **Done** leaves edit mode.
 
 Inline editing uses Astroid's [`<Editable>`](https://github.com/bowenlabs/louise-toolkit)
-primitive (`src/pages/index.astro`): it stamps the `data-louise-*` markers only in
-edit mode, so the public HTML stays clean. Wrap any page field in `<Editable
-collection="pages" key={page.id} field="…">` and pass `versionedPageId` to make it
-editable. Body HTML is sanitized on every save.
+primitive (`src/pages/index.astro` for the home page, `src/pages/[...slug].astro`
+for every other page, both reading through `src/lib/pages.ts`): it stamps the
+`data-louise-*` markers only in edit mode, so the public HTML stays clean. Wrap
+any page field in `<Editable collection="pages" key={page.row.id} field="…">` and
+pass `versionedPageId` to make it editable. Body HTML is sanitized on every save.
 
 ## Redeploy
 

package/template/docs/RUNBOOK.md

@@ -56,6 +56,19 @@ wrangler deploy
 <!-- Who deploys, from where, and what gates it? If deploys are automatic on push
      to main, say so here—that is the first thing a new person asks. -->
 
+## Is it up?
+
+```sh
+curl -i https://<your-host>/api/louise/status
+```
+
+200 means D1 answers and the home page has content; 503 names the check that
+failed, as a boolean, in the JSON body. Point an uptime monitor at this URL.
+Add your own checks in `src/status-checks.ts` (turn it on with
+`status: { checks: true }` in `astroid.config.ts`).
+
+<!-- Which monitor watches this URL, and who it alerts. -->
+
 ## D1 migrations
 
 ```sh

package/template/src/env.d.ts

@@ -17,6 +17,9 @@ type CloudflareEnv = {
    *  health scan to know what to crawl, and by anything else that needs an
    *  absolute URL from inside the Worker. */
   SITE_URL: string;
+  /** AI Gateway id for the editor's AI assists—declared in wrangler.jsonc
+   *  `vars`. Empty calls Workers AI directly (see `astroidAiGateway`). */
+  AI_GATEWAY_ID?: string;
   /**
    * Edge caching for published pages — `"true"` to enable (ADR 0004). A string,
    * not a boolean, because wrangler `vars` are strings.

package/template/src/lib/pages.ts

@@ -0,0 +1,118 @@
+// Read one `pages` row for rendering. The home page and the catch-all page route
+// both call this, so every page renders the same way: a visitor sees the live
+// row, and an editor in edit mode sees the latest pending draft laid over it, so
+// in-progress edits resume across reloads.
+import { isPageLive } from "louise-toolkit/content";
+
+/** The columns a page render reads. */
+export interface PageRow {
+  id: number;
+  slug: string;
+  /** The on-page H1. The head's <title> comes from `seo_title`, else this. */
+  title: string;
+  body: string | null;
+  /** The page-builder array, stored as a JSON string in D1. */
+  sections: string | null;
+  status: string | null;
+  seo_title: string | null;
+  seo_description: string | null;
+  og_image: string | null;
+  noindex: number | null;
+}
+
+/** What a page renders: its row, plus the title, body, and sections to show. */
+export interface RenderedPage {
+  row: PageRow;
+  title: string;
+  body: string;
+  sections: unknown[];
+}
+
+interface ReadPageOptions {
+  /** Edit mode shows every page, live or not, with its pending draft. */
+  editMode: boolean;
+  /**
+   * Show a visitor only a live page (`status = 'published'`). Default `true`.
+   * The home page passes `false`, so an unpublished home keeps rendering
+   * rather than turning the site's front door into a 404.
+   */
+  requireLive?: boolean;
+}
+
+// `sections` is a JSON string in D1. Bad JSON is a render-time non-event: the
+// page falls back to its prose body rather than failing on one malformed row.
+function parseSections(raw: unknown): unknown[] {
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw !== "string" || !raw) return [];
+  try {
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * The page at `slug`, or `null` when there's none a visitor may see (or no
+ * database yet, before provisioning). A `null` is a 404, and the middleware's
+ * `redirectFor` then answers a renamed page's old URL with a redirect.
+ */
+export async function readPage(
+  db: D1Database,
+  slug: string,
+  { editMode, requireLive = true }: ReadPageOptions,
+): Promise<RenderedPage | null> {
+  let row: PageRow | null = null;
+  try {
+    row = await db
+      .prepare(
+        "SELECT id, slug, title, body, sections, status, seo_title, seo_description, og_image, noindex FROM pages WHERE slug = ?",
+      )
+      .bind(slug)
+      .first<PageRow>();
+  } catch {
+    // No DB binding yet (pre-provision).
+    return null;
+  }
+  if (!row) return null;
+  // The toolkit's one definition of "a visitor can see it" (ADR 0021).
+  if (!editMode && requireLive && !isPageLive({ status: row.status ?? undefined })) return null;
+
+  const page: RenderedPage = {
+    row,
+    title: row.title,
+    body: row.body ?? "",
+    sections: parseSections(row.sections),
+  };
+  if (!editMode) return page;
+
+  // The latest PENDING draft: newer than every version ever published. An
+  // older draft is superseded, since a publish already moved past it, so it
+  // must not come back just because it's the newest row marked `draft`.
+  try {
+    const draft = await db
+      .prepare(
+        "SELECT version_data FROM pages_versions WHERE parent_id = ?1 AND status = 'draft'" +
+          " AND id > COALESCE((SELECT MAX(id) FROM pages_versions WHERE parent_id = ?1 AND status = 'published'), 0)" +
+          " ORDER BY id DESC LIMIT 1",
+      )
+      .bind(row.id)
+      .first<{ version_data: string }>();
+    if (draft?.version_data) {
+      const d = JSON.parse(draft.version_data) as {
+        title?: unknown;
+        body?: unknown;
+        sections?: unknown;
+      };
+      if (typeof d.title === "string") page.title = d.title;
+      if (typeof d.body === "string") page.body = d.body;
+      // Sections stage as drafts like any other field, so edit mode renders the
+      // draft's array; otherwise section edits would vanish on reload while
+      // title edits survive.
+      if (d.sections !== undefined) page.sections = parseSections(d.sections);
+    }
+  } catch {
+    // Non-fatal: fall back to the live row.
+  }
+  return page;
+}

package/template/src/pages/[...slug].astro

@@ -0,0 +1,76 @@
+---
+// Every page an owner makes in the Pages panel, served at its slug: `about` at
+// /about. The same render as the home page (src/lib/pages.ts): a visitor sees
+// the live row, and an editor in edit mode sees the latest pending draft, with
+// the same inline editing and Publish.
+//
+// A file route always wins over this one, so /contact and /login stay theirs.
+// `pagesRoute` refuses those slugs (ASTROID_RESERVED_SLUGS), so a page can't be
+// saved where it would never be reached.
+//
+// Anything else that matches nothing answers 404 here. That includes a hidden or
+// never-published page, and a renamed page's old path, which the middleware's
+// `redirectFor` then answers with a 301 to the new one.
+import Editable from "astroidjs/components/Editable.astro";
+import Sections from "astroidjs/components/Sections.astro";
+import { env } from "cloudflare:workers";
+import Site from "../layouts/Site.astro";
+import { readPage } from "../lib/pages";
+
+export const prerender = false;
+
+const { editMode } = Astro.locals;
+const slug = Astro.params.slug ?? "";
+
+// `home` is served at "/", never at "/home".
+if (slug === "home") return Astro.redirect("/", 301);
+
+const page = slug ? await readPage(env.DB, slug, { editMode }) : null;
+
+// Edge caching (ADR 0004), gated exactly as on the home page: never in edit
+// mode, only when ASTROID_EDGE_CACHE is "true", and never for a 404, so a page
+// published a minute later isn't hidden behind a cached miss.
+if (!page || editMode || env.ASTROID_EDGE_CACHE !== "true") {
+  Astro.cache.set(false);
+} else {
+  Astro.cache.set({ maxAge: 60 });
+}
+
+if (!page) Astro.response.status = 404;
+---
+
+{
+  page ? (
+    <Site
+      title={page.row.seo_title ?? page.title}
+      description={page.row.seo_description ?? undefined}
+      ogImage={page.row.og_image ?? undefined}
+      noindex={Boolean(page.row.noindex)}
+      versionedPageId={page.row.id}
+      sections={page.sections}
+    >
+      <main>
+        <Sections items={page.sections} db={env.DB} mediaBase={env.MEDIA_URL} />
+
+        <div class="mx-auto max-w-3xl px-6 py-16">
+          <Editable as="h1" collection="pages" key={page.row.id} field="title" class="text-5xl font-bold">
+            {page.title}
+          </Editable>
+          <Editable as="div" collection="pages" key={page.row.id} field="body" type="richtext" class="prose mt-6 max-w-none">
+            <Fragment set:html={page.body} />
+          </Editable>
+        </div>
+      </main>
+    </Site>
+  ) : (
+    <Site title="Page not found" noindex>
+      <main class="mx-auto max-w-3xl px-6 py-24 text-center">
+        <h1 class="text-4xl font-bold">Page not found</h1>
+        <p class="mt-4">This page doesn't exist, or it has moved.</p>
+        <p class="mt-8">
+          <a class="link" href="/">Go to the home page</a>
+        </p>
+      </main>
+    </Site>
+  )
+}

package/template/src/pages/index.astro

@@ -9,6 +9,7 @@ import Sections from "astroidjs/components/Sections.astro";
 import { env } from "cloudflare:workers";
 import Hero from "../components/Hero.astro";
 import Site from "../layouts/Site.astro";
+import { readPage } from "../lib/pages";
 
 export const prerender = false;
 
@@ -37,75 +38,21 @@ if (editMode || env.ASTROID_EDGE_CACHE !== "true") {
 // is the on-page H1. The home page passes NO title to <Site>, so <title>
 // is the site-wide default ("Acme Coffee", not "Acme Coffee | Acme Coffee");
 // set `seo_title` on the row to override just the head.
-interface HomeRow {
-  id: number;
-  title: string;
-  body: string | null;
-  /** The page-builder array, stored as a JSON string in D1. */
-  sections: string | null;
-  seo_title: string | null;
-  seo_description: string | null;
-  og_image: string | null;
-  noindex: number | null;
-}
-let page: HomeRow | null = null;
-try {
-  page = await env.DB.prepare(
-    "SELECT id, title, body, sections, seo_title, seo_description, og_image, noindex FROM pages WHERE slug = 'home'",
-  ).first<HomeRow>();
-} catch {
-  // No DB binding yet (pre-provision)—fall through to the seed-me prompt.
-}
-
-let title = page?.title ?? "__BRAND_NAME__";
-let body = page?.body ?? "";
-// `sections` is a JSON string in D1. Bad JSON is a render-time non-event—the
-// page falls back to its prose body rather than 500ing on one malformed row.
-function parseSections(raw: string | null | undefined): unknown[] {
-  if (!raw) return [];
-  try {
-    const parsed = JSON.parse(raw);
-    return Array.isArray(parsed) ? parsed : [];
-  } catch {
-    return [];
-  }
-}
-let sections = parseSections(page?.sections);
-
-// In edit mode, prefer the latest unpublished draft so edits resume across reloads.
-if (editMode && page) {
-  try {
-    const draft = await env.DB.prepare(
-      "SELECT version_data FROM pages_versions WHERE parent_id = ? AND status = 'draft' ORDER BY created_at DESC LIMIT 1",
-    )
-      .bind(page.id)
-      .first<{ version_data: string }>();
-    if (draft?.version_data) {
-      const d = JSON.parse(draft.version_data) as {
-        title?: string;
-        body?: string;
-        sections?: unknown;
-      };
-      if (typeof d.title === "string") title = d.title;
-      if (typeof d.body === "string") body = d.body;
-      // Sections stage as drafts like any other field, so edit mode must render
-      // the draft's array—otherwise an editor's in-progress section edits
-      // vanish on reload while their title edits survive.
-      if (Array.isArray(d.sections)) sections = d.sections;
-      else if (typeof d.sections === "string") sections = parseSections(d.sections);
-    }
-  } catch {
-    // Non-fatal—fall back to the live row.
-  }
-}
+//
+// `requireLive: false`: an unpublished home keeps rendering rather than turning
+// the site's front door into a 404. Every other page is visitor-visible only
+// while it's live (src/pages/[...slug].astro).
+const page = await readPage(env.DB, "home", { editMode, requireLive: false });
+const title = page?.title ?? "__BRAND_NAME__";
+const sections = page?.sections ?? [];
 ---
 
 <Site
-  title={page?.seo_title ?? undefined}
-  description={page?.seo_description ?? undefined}
-  ogImage={page?.og_image ?? undefined}
-  noindex={Boolean(page?.noindex)}
-  versionedPageId={page?.id}
+  title={page?.row.seo_title ?? undefined}
+  description={page?.row.seo_description ?? undefined}
+  ogImage={page?.row.og_image ?? undefined}
+  noindex={Boolean(page?.row.noindex)}
+  versionedPageId={page?.row.id}
   sections={sections}
 >
   {
@@ -118,11 +65,11 @@ if (editMode && page) {
         <Sections items={sections} db={env.DB} mediaBase={env.MEDIA_URL} />
 
         <div class="mx-auto max-w-3xl px-6 py-16">
-        <Editable as="h1" collection="pages" key={page.id} field="title" class="text-5xl font-bold">
+        <Editable as="h1" collection="pages" key={page.row.id} field="title" class="text-5xl font-bold">
           {title}
         </Editable>
-        <Editable as="div" collection="pages" key={page.id} field="body" type="richtext" class="prose mt-6 max-w-none">
-          <Fragment set:html={body} />
+        <Editable as="div" collection="pages" key={page.row.id} field="body" type="richtext" class="prose mt-6 max-w-none">
+          <Fragment set:html={page.body} />
         </Editable>
         </div>
       </main>