create-smoodly-app 0.0.13 → 0.0.15

package/templates/blank/scripts/seed.ts

@@ -0,0 +1,72 @@
+// The starter's content, written through the stores (never raw inserts:
+// the refs index and publish integrity are part of the point). Ships in
+// the scaffold; create-smoodly-app runs `npm run seed` after the first
+// editor. Idempotent: exits once the home page exists in the default
+// locale. Writes the same copy into every configured locale, whatever
+// their codes, so every locale's "/" resolves.
+// Run: npm run seed  (needs .env.local and a Supabase stack).
+import next from "@next/env";
+import type { PageTree } from "smoodly";
+const { loadEnvConfig } = next;
+
+loadEnvConfig(process.cwd());
+
+const { config } = await import("../smoodly/config");
+const { stores } = await import("../smoodly/server");
+const { pages, entries } = stores();
+
+const DEFAULT = config.locales.default;
+const OTHERS = config.locales.supported.filter((l) => l !== DEFAULT);
+
+if (await pages.resolvePath(DEFAULT, "/")) {
+  console.log(`Already seeded — "home" exists in "${DEFAULT}".`);
+  process.exit(0);
+}
+
+// Richtext is TipTap JSON, the stored format; RichText renders it.
+type Node = Record<string, unknown>;
+const p = (s: string): Node => ({ type: "paragraph", content: [{ type: "text", text: s }] });
+const button = (label: string, href: string): Node => ({ type: "element", attrs: { name: "button", fields: { label, href }, styles: {} } });
+const doc = (...content: Node[]) => ({ type: "doc", content });
+
+// --- the site item: name and tagline, published in every locale ------
+
+const site = await entries.create("site", { name: "My site", tagline: "Built with Smoodly" }, { locale: DEFAULT });
+await entries.setStatus("site", site.id, DEFAULT, "published");
+for (const locale of OTHERS) {
+  await entries.addLocale("site", site.id, locale, { from: DEFAULT });
+  await entries.setStatus("site", site.id, locale, "published");
+}
+
+// --- the home page: one Text section ---------------------------------
+
+const tree = {
+  meta: { description: "A new site, built with Smoodly." },
+  zones: {
+    body: [
+      {
+        id: "node-hello",
+        type: "text",
+        fields: {
+          title: "Hello",
+          body: doc(
+            p("This is your home page. Open the admin to edit this text, add sections, create pages and write posts."),
+            p("Everything you see is defined in components/ and registered in smoodly/. The README says where things are."),
+            button("Open the admin", "/admin"),
+          ),
+        },
+      },
+    ],
+  },
+} as unknown as PageTree;
+
+const home = await pages.createPage({ locale: DEFAULT, slug: "home", title: "Home", template: "home" });
+await pages.saveDraft(home.id, DEFAULT, tree);
+await pages.publish(home.id, DEFAULT);
+for (const locale of OTHERS) {
+  await pages.addLocale(home.id, locale, { from: DEFAULT, title: "Home" });
+  await pages.saveDraft(home.id, locale, tree);
+  await pages.publish(home.id, locale);
+}
+
+console.log(`Seeded the blank starter in "${[DEFAULT, ...OTHERS].join('", "')}": the home page and the site item, published.`);

package/templates/blank/smoodly/collections.ts

@@ -0,0 +1,26 @@
+import { f, smoodly } from "smoodly";
+import { text } from "./toolsets";
+
+// A collection: structured content with its own admin list, served at
+// `path` by its entry page (components/pages/Post.tsx). Fields marked
+// .localized() are stored per locale; the rest are shared across
+// locales. `versions: true` keeps a history per locale. To add a
+// collection: copy this block, add it to `collections`, write its view
+// into a new migration with `collectionSQL` from "smoodly", and apply
+// it (supabase db push, or supabase db reset locally).
+export const posts = smoodly.collection({
+  name: "posts",
+  title: "Posts",
+  titleField: "title",
+  path: "posts",
+  order: { by: "date", direction: "desc" },
+  versions: true,
+  fields: {
+    title: f.text().localized(),
+    slug: f.slug({ from: "title" }),
+    date: f.date(),
+    body: f.richtext({ toolset: text }).localized(),
+  },
+});
+
+export const collections = [posts];

package/templates/blank/smoodly/config.ts

@@ -0,0 +1,35 @@
+import { defineConfig, f } from "smoodly";
+import { collections } from "./collections";
+import { sections } from "./sections";
+import { shared } from "./shared";
+import { elements } from "./elements";
+import { HomePage } from "@/components/pages/Home";
+import { StandardPage } from "@/components/pages/Page";
+import { PostPage } from "@/components/pages/Post";
+
+export { collections, sections, shared, elements };
+
+// The registry and the plain settings, one file. Runtime-free: nothing
+// here imports a route file or Next, so a script and the CLI's template
+// build can load it outside the app.
+export const config = defineConfig({
+  registry: {
+    sections,
+    elements,
+    collections,
+    shared,
+    pages: [HomePage, StandardPage, PostPage],
+  },
+  locales: { default: "en", supported: ["en"] },
+  // The record the site root serves.
+  homePageSlug: "home",
+  // Editors can nest pages three deep.
+  pages: { tree: { depth: 3 } },
+  // Every section gets this select beside its own styles; the section
+  // wrapper emits it as data-tone, and app/globals.css styles it.
+  styles: {
+    sections: {
+      tone: f.select(["paper", "ink"]).default("paper"),
+    },
+  },
+});

package/templates/blank/smoodly/elements.ts

@@ -0,0 +1,5 @@
+// The site's element registrations, in one list: the config registers
+// them, toolsets embed them by value, and smoodly/richtext.tsx renders them.
+import { Button } from "@/components/elements/Button";
+
+export const elements = [Button];

package/templates/blank/smoodly/sections.ts

@@ -0,0 +1,5 @@
+// The site's section registrations, in one list. config.ts puts it in
+// the registry; the stores and the renderer share the same array.
+import { Text } from "@/components/sections/Text";
+
+export const sections = [Text];

package/templates/{next → blank}/smoodly/server.ts

@@ -4,21 +4,22 @@
 // secret is a service-role key or a cloud write key is invisible here.
 //
 // Lazy on purpose, the site and renderer included: config.ts imports the
-// page shapes, and a page shape may import this file to fetch through
-// the site (components/pages/Articles.tsx). That is a cycle, and the
+// page shapes, and a page shape may import this file to read through
+// `q` (components/pages/Articles.tsx). That is a cycle, and the
 // admin route enters it from config.ts — so nothing here may read the
 // config at module scope.
 import {
   createSmoodlyClient, createSmoodlySite, smoodlyEnv, SupabaseAssetStore, SupabaseEntryStore, SupabasePageStore, SupabasePathIndex, type SmoodlySite,
 } from "smoodly";
 import { supabaseAdminAuth, type AdminAuth, type AuthConfig } from "smoodly/admin/next";
-import { createPageRenderer, type PageRegistration } from "smoodly/next";
+import { createPageRenderer, createSmoodlyQueries, type PageRegistration } from "smoodly/next";
 import type { SupabaseClient } from "@supabase/supabase-js";
 import { collections, config, elements, sections, shared } from "./config";
 
 type Renderer = ReturnType<typeof createPageRenderer>;
+type Queries = ReturnType<typeof createSmoodlyQueries<typeof collections, typeof shared>>;
 type Bound = {
-  db: SupabaseClient; pages: SupabasePageStore; entries: SupabaseEntryStore; assets: SupabaseAssetStore; auth: AdminAuth; site: SmoodlySite; renderer: Renderer;
+  db: SupabaseClient; pages: SupabasePageStore; entries: SupabaseEntryStore; assets: SupabaseAssetStore; auth: AdminAuth; site: SmoodlySite; renderer: Renderer; q: Queries;
 };
 
 let cached: Bound | null = null;
@@ -43,17 +44,18 @@ function bound(): Bound {
   // takes this local closure, not the export, so it never re-enters `bound()`.
   const stores = () => ({ pages, entries, assets });
   // The site layer: (locale, path) → page or entry, and the content API
-  // (site.getPagesTree for menus, site.getEntries for lists).
-  // Shadows the exported `site` below on purpose: `createPageRenderer`
-  // takes this local value, not the export, so it never re-enters `bound()`.
-  const site = createSmoodlySite({ stores, collections, shared, sections, elements, locales, homePageSlug: config.homePageSlug });
+  // `q` wraps below. Not exported — the app reads through `q`, which adds
+  // draft awareness and the cache.
+  const site = createSmoodlySite({ stores, collections, shared, sections, elements, locales, homePageSlug: config.homePageSlug, pages: config.registry.pages ?? [] });
   const renderer = createPageRenderer({
     site,
     sections,
     pages: (config.registry.pages ?? []) as PageRegistration[],
     href,
   });
-  cached = { db, pages, entries, assets, auth, site, renderer };
+  // The read API (spec 2026-09-11): typed by the registry, draft-aware, cached under tags the admin expires.
+  const q = createSmoodlyQueries({ site, collections, shared });
+  cached = { db, pages, entries, assets, auth, site, renderer, q };
   return cached;
 }
 
@@ -80,13 +82,15 @@ export function publicAuth(): AuthConfig {
  * becomes a locale-prefixing lookup. */
 export const href = (path: string, _locale: string) => path;
 
-/** The content API for page views that fetch (the Articles index, an
- * article's related list): `site().getEntries("articles", { locale })`. */
-export const site = (): SmoodlySite => bound().site;
+/** The read API (spec 2026-09-11) for layouts and page views that fetch:
+ * `q().getEntries("articles", { locale, limit: 3 })`, `q().getShared("header",
+ * { locale })`, `q().getPageTree({ locale })`. Typed by the registry, the
+ * live draft in the editor preview, cached under tags the admin expires.
+ * Rename it if `q` is not to your taste — this file is yours. */
+export const q = (): Queries => bound().q;
 
 /** The two route files call these. */
 export const renderSmoodlyPath: Renderer["renderSmoodlyPath"] = (...args) => bound().renderer.renderSmoodlyPath(...args);
 export const smoodlyMetadata: Renderer["smoodlyMetadata"] = (...args) => bound().renderer.smoodlyMetadata(...args);
 export const renderSmoodlyPage: Renderer["renderSmoodlyPage"] = (...args) => bound().renderer.renderSmoodlyPage(...args);
 export const smoodlyPageMetadata: Renderer["smoodlyPageMetadata"] = (...args) => bound().renderer.smoodlyPageMetadata(...args);
-export const getSmoodlyShared: Renderer["getSmoodlyShared"] = (...args) => bound().renderer.getSmoodlyShared(...args);

package/templates/blank/smoodly/shared.ts

@@ -0,0 +1,16 @@
+// Shared content: code-declared singletons, edited once under Globals
+// and read anywhere. `site` is an object item — fields code consumes;
+// the layout reads it through q().getShared("site"). A visual item
+// (`section: SomeSection`) renders through a section instead.
+import { f, smoodly } from "smoodly";
+
+export const site = smoodly.shared({
+  name: "site",
+  title: "Site",
+  fields: {
+    name: f.text(),
+    tagline: f.text().localized(),
+  },
+});
+
+export const shared = [site];

package/templates/blank/smoodly/toolsets.ts

@@ -0,0 +1,14 @@
+// Toolsets are values, not registrations: a richtext field names one.
+// `text` is the starter's one set — the default marks and block nodes,
+// plus the Button element. Elements are embedded by value; the config
+// must also register them (smoodly/elements.ts; defineConfig checks).
+// Relative imports on purpose: collections.ts pulls this file into
+// create-smoodly-app's template build, which runs outside the app.
+import { smoodly } from "smoodly";
+import { Button } from "../components/elements/Button";
+
+export const text = smoodly.toolset({
+  marks: ["bold", "italic", "link"],
+  nodes: ["h2", "h3", "bulletList", "orderedList", "blockquote"],
+  elements: [Button],
+});