create-smoodly-app 0.0.45 → 0.0.47

package/templates/astro-blank-intl/AGENTS.md

@@ -0,0 +1,55 @@
+# Working in this Smoodly site
+
+This is an Astro site with Smoodly installed: content lives in Supabase, the admin is mounted at /admin by the `smoodly/astro` integration in `astro.config.ts`, and the site reads content through live collections (`src/live.config.ts`). Read README.md first: it says where things are.
+
+## Rules
+
+- **Register schemas in the config; views are files by name.** A section's view is
+  `src/sections/<name>.astro`, an element's `src/elements/<name>.astro`, a page
+  type's `src/page-types/<name>.astro`, an entry page's
+  `src/entry-pages/<collection>.astro`, where <name> is the schema's `name`.
+  The schema is listed in its barrel (`src/smoodly/sections.ts`, `elements.ts`,
+  the config's `pages`; collections and global items in `collections.ts`,
+  `globals.ts`) and `src/smoodly/config.ts` is the one registry. The server
+  names a schema with no file, and a file with no schema, at the first request.
+- **A `.schema.ts` file imports no component.** Zones, toolsets, global items and
+  `node()` take schemas (`z.locked(heroSchema)`), never views.
+- **After a new collection or a `smoodly` upgrade, run `npx smoodly migrate`**
+  and apply what it writes (`supabase db push` hosted, `supabase migration up`
+  local). It copies the core schema files the package ships and writes a
+  read view and order index per collection. Never edit a file it wrote.
+  The admin reads the base tables, so it lists a collection either way;
+  the view is for SQL and PostgREST readers, the index for `order`.
+- **Content from code goes through `createContent(config)`** from `smoodly/astro`:
+  `scripts/seed.ts` is starter content written with it — the admin's own
+  operations, so validation and publish checks apply and a failure throws. Never
+  write rows or call the stores directly. The seed is idempotent; `npm run seed`.
+- **Reads are live collections.** `src/live.config.ts` names one loader per
+  collection, global item, the pages and the page tree; a view reads with
+  `getLiveCollection("articles", { locale })` or `getLiveEntry("footer", { locale })`
+  from `astro:content`. Every read tags the response, and a publish expires it.
+- **The admin, the preview address and the page shell are injected** by
+  `smoodly()` in `astro.config.ts`; the project has no route file for them. A page
+  file of your own under `src/pages` wins its address. `site` in `astro.config.ts`
+  is the site's own address (from `SITE_URL`).
+- **A link an editor typed goes through `safeHref`** from "smoodly" in an `.astro`
+  view: `<a href={safeHref(link.href)}>`. Astro writes attributes as given, so a
+  `javascript:` URL would reach the page; the template build refuses a shipped
+  view that skips it.
+- **Section styles are inline.** `<Section>` from `smoodly/astro/components` renders
+  the root element with Smoodly's styles set and the node id; marks
+  (`smoodly.marks(schema)`) tie rendered elements to fields.
+- **Multilingual sites.** The locale set is `locales` in `src/smoodly/config.ts`
+  and `i18n` in `astro.config.ts`; the two must agree. UI strings of the site's
+  own go through `src/strings.ts` and `src/messages/<locale>.json`.
+- **Fixed versus open pages.** A page type with a `slug` is fixed: one
+  record, created for you, never deleted. Without one it is open: editors
+  create as many as they like.
+
+## Commands
+
+    npm run dev          # http://localhost:4321, /admin is the editor
+    npm run build        # checks the schema files (smoodly migrate --check), then astro build
+    npm run start        # the built server (dist/server/entry.mjs)
+    npm run seed         # starter content, idempotent
+    npm run typecheck    # astro check

package/templates/astro-blank-intl/CLAUDE.md

@@ -0,0 +1 @@
+@AGENTS.md

package/templates/astro-blank-intl/README.md

@@ -0,0 +1,89 @@
+# Smoodly site
+
+Created by `create-smoodly-app`. Content lives in Supabase; the admin is
+mounted at `/admin` by the `smoodly/astro` integration. AGENTS.md holds the
+rules for an agent (or a person) building the site.
+
+    npm run dev          # http://localhost:4321 — /admin is the editor
+
+## Where things are
+
+- `astro.config.ts` — the `smoodly()` integration (it mounts the admin, the preview address and the page shell), the node adapter, the cache and `site` (from `SITE_URL`).
+- `astro.config.ts` also carries `i18n`: the same locales as `src/smoodly/config.ts`, which must agree with it. The default locale is served at the root, the others under their prefix.
+- `src/page-types/` — one view per page type: `home.astro` (fixed at /, one freeform zone) and `page.astro` (open, editors create many).
+- `src/entry-pages/posts.astro` — the entry page of the posts collection, at /posts/<slug>.
+- `src/sections/text.astro` and `src/components/sections/Text.schema.ts` — the one section: a title and a richtext body.
+- `src/elements/button.astro` and `src/components/elements/Button.schema.ts` — the one element: a link styled as a button, embedded in richtext through `src/smoodly/toolsets.ts`.
+- `src/components/LocaleNav.astro` — the language links every page view renders from its `locales` map; nothing with one locale.
+- `src/layouts/Layout.astro` — the document every view renders: the head, the footer line from the `site` global item, `src/styles/global.css`.
+- `src/smoodly/` — the wiring: `config.ts` (the registry of schemas and the settings), `collections.ts` (posts), `globals.ts` (the site item), `sections.ts` and `elements.ts` (the schemas the config registers), `toolsets.ts`.
+- `src/live.config.ts` — the live collections the views read with `getLiveCollection` and `getLiveEntry`.
+- `scripts/seed.ts` — the home page and the site item, written through `createContent(config)`. `npm run seed` is idempotent.
+- `src/styles/global.css` — a reset, a container, the two tones. Replace it.
+- `.env` — `SMOODLY_URL`, `SMOODLY_SECRET_KEY`, `SMOODLY_PUBLISHABLE_KEY`.
+
+## Add a section
+
+Copy `src/components/sections/Text.schema.ts`, give the schema a new
+`name` and `title` and declare its fields. List it in `sections` in
+`src/smoodly/sections.ts` and in the `sections` of every zone that may
+hold it in `src/components/pages/*.schema.ts`. Then write its view,
+`src/sections/<name>.astro`, by copying `text.astro`: render the fields
+inside `<Section>` with marks on each. It appears in the editor's "+"
+picker. A schema with no view, and a view with no schema, are named at
+the first request.
+
+## Add an element
+
+Copy `src/components/elements/Button.schema.ts` (relative imports only).
+Add the schema to `elements` in `src/smoodly/elements.ts` and to the
+`elements` of the toolset in `src/smoodly/toolsets.ts` that may embed
+it, and write `src/elements/<name>.astro`. A link an editor types goes
+through `safeHref`, as in `button.astro`. It appears in the richtext
+editor's "/" menu.
+
+## Add a collection
+
+Copy the `posts` block in `src/smoodly/collections.ts`, add the new
+collection to `collections` and a loader for it in `src/live.config.ts`,
+and write its entry page, `src/entry-pages/<collection>.astro`, by
+copying `posts.astro`. Then write its read view and order index and
+apply them:
+
+    npx smoodly migrate
+    supabase db push        # hosted; `supabase migration up` for the local stack (keeps the content)
+
+The same command brings the core schema forward after a `smoodly` upgrade.
+
+## Add a global item
+
+Copy the `site` block in `src/smoodly/globals.ts`, add it to `globals`
+and give it a loader in `src/live.config.ts`. A view reads it with
+`getLiveEntry("name", { locale })`. Edit it under Globals in the admin.
+
+Reseed an empty database any time with `npm run seed`.
+
+## Moving the admin
+
+The admin is at `/admin`. To serve it somewhere else, say `/studio`:
+
+1. set `smoodly({ adminPath: "/studio" })` in `astro.config.ts`,
+2. set `admin: { path: "/studio" }` in `src/smoodly/config.ts`.
+
+The two must agree; the admin says so when they do not.
+
+## Editors
+
+Anyone who may open `/admin` is a Supabase Auth user with a row in the
+`editors` table. To add one: create the user in Supabase Studio
+(Authentication → Users), then in the SQL editor:
+
+    insert into editors (user_id, role) values ('<the user id>', 'editor');
+
+## Hosted Supabase
+
+    supabase init        # if the CLI has not been set up here yet
+    supabase link        # pick the project
+    supabase db push     # applies supabase/migrations/
+
+Then put the project's URL and keys in `.env`.

package/templates/astro-blank-intl/_gitignore

@@ -0,0 +1,5 @@
+node_modules/
+dist/
+.astro/
+.env
+smoodly-export-*

package/templates/astro-blank-intl/astro.config.ts

@@ -0,0 +1,17 @@
+import { defineConfig, memoryCache } from "astro/config";
+import node from "@astrojs/node";
+import smoodly from "smoodly/astro";
+
+export default defineConfig({
+  output: "server",
+  adapter: node({ mode: "standalone" }),
+  // Pages are cached whole and expire by tag when an editor publishes (one process, one cache).
+  cache: { provider: memoryCache() },
+  // The site's own address: canonical, hreflang and social links are absolute on it. Astro reads astro.config
+  // before .env, so this sees only a SITE_URL set in the shell; when it is unset, smoodly() sets `site` from
+  // SITE_URL in .env. Set SITE_URL where you deploy: `site` is fixed at `astro build`.
+  site: process.env.SITE_URL,
+  // The same locales as src/smoodly/config.ts (the adapter checks): the default at the root, the others under their prefix.
+  i18n: { locales: ["en", "fi"], defaultLocale: "en" },
+  integrations: [smoodly({ config: "src/smoodly/config.ts" })],
+});

package/templates/astro-blank-intl/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "smoodly-site",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "astro dev",
+    "build": "smoodly migrate --check && astro build",
+    "start": "node --env-file-if-exists=.env dist/server/entry.mjs",
+    "seed": "tsx scripts/seed.ts",
+    "typecheck": "astro check"
+  },
+  "dependencies": {
+    "@astrojs/node": "^11.1.6",
+    "@supabase/supabase-js": "^2.113.0",
+    "astro": "^7.3.5",
+    "smoodly": "0.0.47"
+  },
+  "devDependencies": {
+    "@astrojs/check": "^0.9.10",
+    "@types/node": "^26.4.1",
+    "typescript": "^5",
+    "tsx": "^4"
+  }
+}

package/templates/astro-blank-intl/scripts/seed.ts

@@ -0,0 +1,80 @@
+// The starter's content, written through the content API (`createContent(config)`
+// from smoodly/astro): the admin's own operations, so validation and
+// the publish checks apply and a failure throws. It is also the example
+// of writing content from code. Ships in the scaffold; create-smoodly-app
+// runs `npm run seed` after the first editor. Idempotent: exits once the
+// home page has content 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 and a Supabase stack).
+import type { PageTree, TreeNode } from "smoodly";
+
+const { config } = await import("../src/smoodly/config");
+const { node } = await import("smoodly");
+const { createContent } = await import("smoodly/astro");
+const { content } = createContent(config);
+const { textSchema } = await import("../src/components/sections/Text.schema");
+const c = content;
+
+const DEFAULT = config.locales.default;
+const OTHERS = config.locales.supported.filter((l) => l !== DEFAULT);
+
+// The home page is code-owned: `find` returns its record, creating it when
+// the database is new. It is seeded once somebody has given it sections.
+const home = (await c.pages.find(DEFAULT, "/"))!;
+if (Object.values((await c.pages.getTree(home.id, DEFAULT))?.zones ?? {}).some((nodes) => nodes.length > 0)) {
+  console.log(`Already seeded — the home page has content 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 }, settings: {} } });
+const doc = (...content: Node[]) => ({ type: "doc", content });
+
+// --- the site item: name and tagline, published in every locale ------
+
+for (const locale of [DEFAULT, ...OTHERS]) {
+  await c.globals.set("site", locale, { name: "My site", tagline: "Built with Smoodly" });
+  await c.globals.publish("site", locale);
+}
+
+// --- the home page: one Text section and one custom section ----------
+
+// The custom section is not a registered section, so it is a plain node object.
+const custom: TreeNode = {
+  id: "node-custom",
+  type: "custom",
+  fields: { rows: [
+    { spans: [6, 6], gap: "md", align: "top", reverse: false, columns: [
+      doc(p("A custom section holds rows of columns. Drag the width bar in the inspector to resize them.")),
+      doc(p("Each column is richtext. Columns stack on small screens; the developer's stylesheet needs nothing.")),
+    ] },
+  ] },
+};
+
+const tree: PageTree = {
+  meta: { description: "A new site, built with Smoodly." },
+  zones: {
+    body: [
+      node(textSchema, {
+        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"),
+        ),
+      }, { id: "node-hello", settings: { background: "paper" } }),
+      // The custom section: the editor's own rows of columns, rendered by Smoodly.
+      custom,
+    ],
+  },
+};
+
+// The home page exists in every locale already (its registration says so): write the tree and publish.
+for (const locale of [DEFAULT, ...OTHERS]) {
+  await c.pages.setTree(home.id, locale, tree);
+  await c.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/astro-blank-intl/src/components/LocaleNav.astro

@@ -0,0 +1,15 @@
+---
+// src/components/LocaleNav.astro — the language links, rendered by every page view from its own `locales` map:
+// the same page in the other language where it is published there, that language's home otherwise. Nothing
+// with one locale, so the single-language scaffold shares the file.
+import { href } from "smoodly/astro/runtime";
+
+type Props = { locale: string; locales: Record<string, { path: string | null } | null> };
+const { locale, locales } = Astro.props;
+const codes = Object.keys(locales);
+---
+{codes.length > 1 && (
+  <nav class="container locales" aria-label="Language">
+    {codes.map((code) => <a href={href(locales[code]?.path ?? "/", code)} aria-current={code === locale ? "page" : undefined}>{code}</a>)}
+  </nav>
+)}

package/templates/astro-blank-intl/src/components/elements/Button.schema.ts

@@ -0,0 +1,22 @@
+import { f, smoodly } from "smoodly";
+
+// An Element: a small registered block editors insert inside richtext
+// (the `richtext` context). This one is a link styled as a button;
+// src/elements/button.astro is its view. To add another element, copy
+// both files, name the view after the schema, and list the schema in
+// src/smoodly/elements.ts and in the toolsets that may embed it
+// (src/smoodly/toolsets.ts).
+// Relative imports only in this file and in smoodly/toolsets.ts: the
+// template build imports them outside the app, where `@/` has no mapping.
+export const buttonSchema = smoodly.schema.element({
+  name: "button",
+  title: "Button",
+  icon: "→",
+  description: "A link styled as a button.",
+  contexts: ["richtext"],
+  fields: {
+    label: f.text().max(60),
+    href: f.link(),
+  },
+  sample: { label: "Read more", href: "/" },
+});

package/templates/astro-blank-intl/src/components/pages/Home.schema.ts

@@ -0,0 +1,17 @@
+import { smoodly, z } from "smoodly";
+import { textSchema } from "../sections/Text.schema";
+
+// A page type's schema: its zones and what each allows. Its view,
+// src/page-types/home.astro, places them with <Zone />. `slug` makes it fixed — one record
+// editors can neither delete nor duplicate — and the config's
+// homePageSlug maps that record to "/". The body is a freeform zone over
+// the section schemas listed here.
+export const homeSchema = smoodly.schema.page({
+  name: "home",
+  title: "Home",
+  slug: "home",
+  zones: {
+    body: z.freeform({ sections: [textSchema], custom: true }),
+  },
+  seo: true,
+});

package/templates/astro-blank-intl/src/components/pages/Page.schema.ts

@@ -0,0 +1,14 @@
+import { smoodly, z } from "smoodly";
+import { textSchema } from "../sections/Text.schema";
+
+// An open page type: no `slug`, so editors create as many as they like,
+// anywhere in the tree the config allows. src/page-types/page.astro is the view;
+// its `page` prop is where the page sits (title, path, ancestors, children).
+export const pageSchema = smoodly.schema.page({
+  name: "page",
+  title: "Page",
+  zones: {
+    body: z.freeform({ sections: [textSchema], custom: true }),
+  },
+  seo: true,
+});

package/templates/astro-blank-intl/src/components/sections/Text.schema.ts

@@ -0,0 +1,24 @@
+import { f, smoodly } from "smoodly";
+import { text } from "@/smoodly/toolsets";
+
+// A section's schema: a title and a richtext body. Its view is
+// src/sections/text.astro. To add another section, copy both files, name the
+// view after the new schema, list the schema in src/smoodly/sections.ts
+// and allow it in a page type's zone (src/components/pages/*.schema.ts).
+// This file imports no component.
+export const textSchema = smoodly.schema.section({
+  name: "text",
+  title: "Text",
+  description: "A title and a body of text.",
+  fields: {
+    title: f.text(),
+    body: f.richtext({ toolset: text }),
+  },
+  settings: {
+    background: f.radio([{ value: "paper", label: "Paper" }, { value: "ink", label: "Ink" }]).default("paper"),
+  },
+  sample: {
+    title: "Hello",
+    body: { type: "doc", content: [{ type: "paragraph", content: [{ type: "text", text: "Write something here." }] }] },
+  },
+});

package/templates/astro-blank-intl/src/elements/button.astro

@@ -0,0 +1,10 @@
+---
+// src/elements/button.astro — the view of the element named "button": a link styled as a button, inserted inside
+// richtext. An editor typed the href, so it goes through safeHref: a scheme the page must not carry renders no link.
+import { safeHref, type Props as SmoodlyProps } from "smoodly";
+import { buttonSchema } from "@/components/elements/Button.schema";
+
+type Props = SmoodlyProps<typeof buttonSchema>;
+const { label, href } = Astro.props;
+---
+<a class="button" href={safeHref(href)}>{label}</a>

package/templates/astro-blank-intl/src/entry-pages/posts.astro

@@ -0,0 +1,23 @@
+---
+// src/entry-pages/posts.astro — the entry page of the collection "posts", served at /posts/<slug>. An entry page
+// is a file by the collection's name; it receives the entry as a read returns it, with its locale alternates.
+import type { EntryFields, EntryItem } from "smoodly";
+import { RichText } from "smoodly/astro/components";
+import type { PageHead } from "smoodly/astro/runtime";
+import type { posts } from "@/smoodly/collections";
+import Layout from "../layouts/Layout.astro";
+import LocaleNav from "../components/LocaleNav.astro";
+
+type Props = { entry: EntryItem<EntryFields<typeof posts>>; head: PageHead };
+const { entry, head } = Astro.props;
+const { locale, locales } = entry;
+const post = entry.fields;
+---
+<Layout head={head} locale={locale}>
+  <LocaleNav locale={locale} locales={locales} />
+  <article class="container prose">
+    <h1>{post.title}</h1>
+    {post.date && <p><time datetime={post.date}>{post.date.slice(0, 10)}</time></p>}
+    <RichText doc={post.body} />
+  </article>
+</Layout>

package/templates/astro-blank-intl/src/layouts/Layout.astro

@@ -0,0 +1,25 @@
+---
+// src/layouts/Layout.astro — the site's own document: every page type and entry page renders inside it. The
+// `site` global item (src/smoodly/globals.ts) gives the title and the footer line, read as a live entry per
+// locale, null until published there. In a preview the integration adds what the editor needs to the response.
+import { getLiveEntry } from "astro:content";
+import { Head } from "smoodly/astro/components";
+import type { PageHead } from "smoodly/astro/runtime";
+import "../styles/global.css";
+
+type Props = { head: PageHead; locale: string };
+const { head, locale } = Astro.props;
+const { entry: site } = await getLiveEntry("site", { locale });
+---
+<!doctype html>
+<html lang={locale}>
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <Head of={head} fallback={site?.data.fields.name ?? "Smoodly site"} />
+  </head>
+  <body>
+    <main><slot /></main>
+    {site && <footer class="container site-footer">{site.data.fields.name} · {site.data.fields.tagline}</footer>}
+  </body>
+</html>

package/templates/astro-blank-intl/src/live.config.ts

@@ -0,0 +1,13 @@
+// src/live.config.ts — Smoodly's content as live collections: one loader per collection, global item and the pages,
+// from the package; this file only names them. A view reads with getLiveCollection / getLiveEntry from astro:content.
+import { defineLiveCollection } from "astro:content";
+import { entriesLoader, globalLoader, pageLoader, pageTreeLoader } from "smoodly/astro/content";
+import { posts } from "@/smoodly/collections";
+import { site } from "@/smoodly/globals";
+
+export const collections = {
+  pages: defineLiveCollection({ loader: pageLoader() }),
+  pageTree: defineLiveCollection({ loader: pageTreeLoader() }),
+  posts: defineLiveCollection({ loader: entriesLoader(posts) }),
+  site: defineLiveCollection({ loader: globalLoader(site) }),
+};

package/templates/astro-blank-intl/src/page-types/home.astro

@@ -0,0 +1,15 @@
+---
+// src/page-types/home.astro — the view of the page type named "home", fixed at "/": one freeform body zone inside the layout.
+import type { PageContext } from "smoodly";
+import { Zone } from "smoodly/astro/components";
+import type { PageHead, ZoneContent } from "smoodly/astro/runtime";
+import Layout from "../layouts/Layout.astro";
+import LocaleNav from "../components/LocaleNav.astro";
+
+type Props = { page: PageContext; zones: Record<string, ZoneContent>; head: PageHead };
+const { page, zones, head } = Astro.props;
+---
+<Layout head={head} locale={page.locale}>
+  <LocaleNav locale={page.locale} locales={page.locales} />
+  <Zone of={zones.body} />
+</Layout>

package/templates/astro-blank-intl/src/page-types/page.astro

@@ -0,0 +1,15 @@
+---
+// src/page-types/page.astro — the view of the page type named "page", which editors create many of: one freeform body zone inside the layout.
+import type { PageContext } from "smoodly";
+import { Zone } from "smoodly/astro/components";
+import type { PageHead, ZoneContent } from "smoodly/astro/runtime";
+import Layout from "../layouts/Layout.astro";
+import LocaleNav from "../components/LocaleNav.astro";
+
+type Props = { page: PageContext; zones: Record<string, ZoneContent>; head: PageHead };
+const { page, zones, head } = Astro.props;
+---
+<Layout head={head} locale={page.locale}>
+  <LocaleNav locale={page.locale} locales={page.locales} />
+  <Zone of={zones.body} />
+</Layout>

package/templates/astro-blank-intl/src/pages/404.astro

@@ -0,0 +1,7 @@
+---
+// src/pages/404.astro — the site's own "not found" page: the shell rewrites here.
+import Layout from "../layouts/Layout.astro";
+---
+<Layout head={{ title: "Not found", noindex: true, languages: {} }} locale="en">
+  <div class="container"><h1>Page not found</h1></div>
+</Layout>

package/templates/astro-blank-intl/src/sections/text.astro

@@ -0,0 +1,18 @@
+---
+// src/sections/text.astro — the view of the section named "text". <Section> renders the root element, Smoodly's
+// styles set inline and the node id; a setting the CSS reads — here `background` — is the view's own data
+// attribute. Marks tie the rendered elements to their fields, so the editor can select and edit them in place.
+import { smoodly, type Props as SmoodlyProps } from "smoodly";
+import { RichText, Section } from "smoodly/astro/components";
+import { textSchema } from "@/components/sections/Text.schema";
+
+type Props = SmoodlyProps<typeof textSchema>;
+const { title, body, settings, styles } = Astro.props;
+const m = smoodly.marks(textSchema);
+---
+<Section styles={styles} class="text" data-background={settings.background}>
+  <div class="container prose">
+    <h2 {...m.field("title")}>{title}</h2>
+    <div {...m.field("body")}><RichText doc={body} /></div>
+  </div>
+</Section>

package/templates/astro-blank-intl/src/smoodly/collections.ts

@@ -0,0 +1,24 @@
+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 (src/entry-pages/posts.astro). Fields marked
+// .localized() are stored per locale; the rest are shared across
+// locales. To add a collection: copy this block, add it to
+// `collections`, run `npx smoodly migrate` and apply the file it writes
+// (supabase db push, or supabase migration up locally).
+export const posts = smoodly.collection({
+  name: "posts",
+  title: "Posts",
+  titleField: "title",
+  path: "posts",
+  order: { by: "date", direction: "desc" },
+  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/astro-blank-intl/src/smoodly/config.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from "smoodly";
+import { collections } from "./collections";
+import { sections } from "./sections";
+import { globals } from "./globals";
+import { elements } from "./elements";
+import { homeSchema } from "@/components/pages/Home.schema";
+import { pageSchema } from "@/components/pages/Page.schema";
+
+export { collections, sections, globals, elements };
+
+// The registry of schemas and the plain settings, one file. It imports
+// no component and no route file, so a script and the CLI can load it
+// outside the app; the views are files by name under src/.
+// The locale set is below; astro.config.ts declares the same set.
+export const config = defineConfig({
+  registry: {
+    sections,
+    elements,
+    collections,
+    globals,
+    // Page types. The entry page is a view: src/entry-pages/posts.astro.
+    pages: [homeSchema, pageSchema],
+  },
+  locales: { default: "en", supported: ["en", "fi"] },
+  // The record the site root serves.
+  homePageSlug: "home",
+  // Editors can nest pages three deep.
+  pages: { tree: { depth: 3 } },
+});

package/templates/astro-blank-intl/src/smoodly/elements.ts

@@ -0,0 +1,5 @@
+// The element schemas a richtext body may embed; their views are
+// src/elements/<name>.astro files.
+import { buttonSchema } from "@/components/elements/Button.schema";
+
+export const elements = [buttonSchema];

package/templates/astro-blank-intl/src/smoodly/globals.ts

@@ -0,0 +1,18 @@
+// Global content: code-declared singletons, edited once under Globals
+// and read anywhere. `site` is an object item — fields code consumes;
+// the layout reads it as a live entry, getLiveEntry("site"): a layout
+// global: it comes with the page's own read. A visual item
+// (`section: someSectionSchema`) renders through a section instead.
+import { f, smoodly } from "smoodly";
+
+export const site = smoodly.global({
+  name: "site",
+  title: "Site",
+  fields: {
+    name: f.text(),
+    tagline: f.text().localized(),
+  },
+  layout: true,
+});
+
+export const globals = [site];

package/templates/astro-blank-intl/src/smoodly/sections.ts

@@ -0,0 +1,5 @@
+// The section schemas the config registers; the views are
+// src/sections/<name>.astro files.
+import { textSchema } from "@/components/sections/Text.schema";
+
+export const sections = [textSchema];

package/templates/astro-blank-intl/src/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 { buttonSchema } from "../components/elements/Button.schema";
+
+export const text = smoodly.toolset({
+  marks: ["bold", "italic", "link"],
+  nodes: ["h2", "h3", "bulletList", "orderedList", "blockquote"],
+  elements: [buttonSchema],
+});