create-smoodly-app 0.0.1

package/templates/next/collections.ts

@@ -0,0 +1,25 @@
+import { f, smoodly } from "smoodly";
+
+export const people = smoodly.collection({
+  name: "people",
+  title: "People",
+  titleField: "name",
+  fields: {
+    name: f.text(),
+    role: f.text().optional(),
+  },
+});
+
+export const articles = smoodly.collection({
+  name: "articles",
+  title: "Articles",
+  titleField: "title",
+  fields: {
+    title: f.text(),
+    slug: f.slug({ from: "title" }),
+    excerpt: f.text().optional(),
+    author: f.ref(() => people),
+  },
+});
+
+export const collections = [people, articles];

package/templates/next/components/sections/ArticleList.tsx

@@ -0,0 +1,31 @@
+import { f, smoodly, type Props } from "smoodly";
+import { articles } from "../../collections";
+
+export const articleListSchema = smoodly.schema.section({
+  name: "articleList",
+  title: "Article list",
+  fields: {
+    title: f.text(),
+    // .resolve("author") — hydrate each article AND follow its author ref
+    // one level (article → person), all in resolveTree's batched pass.
+    items: f.refList(() => articles).resolve("author"),
+  },
+});
+
+function ArticleListView({ title, items, styles }: Props<typeof articleListSchema>) {
+  return (
+    <smoodly.Section styles={styles}>
+      <h2>{title}</h2>
+      <ul>
+        {/* an item demoted/deleted after publish resolves to null — skip it */}
+        {items.filter(Boolean).map((article, i) => (
+          <li key={i}>
+            <strong>{article.title}</strong> — {article.author?.name ?? "unknown author"}
+          </li>
+        ))}
+      </ul>
+    </smoodly.Section>
+  );
+}
+
+export const ArticleList = smoodly.section(articleListSchema, ArticleListView);

package/templates/next/components/sections/CtaBanner.tsx

@@ -0,0 +1,35 @@
+import { f, smoodly, type Props } from "smoodly";
+
+// The locked-zone section: every page renders exactly one of these in its
+// `prefooter` zone. Editors change the words, never the structure — no
+// add, remove, move or duplicate. The editor materializes the node from
+// `sample` the first time it opens a page whose prefooter is empty.
+export const ctaBannerSchema = smoodly.schema.section({
+  name: "ctaBanner",
+  title: "CTA banner",
+  description: "The closing call to action under every page.",
+  fields: {
+    heading: f.text(),
+    buttonLabel: f.text(),
+    buttonHref: f.text(),
+  },
+  styles: {
+    tone: f.select(["light", "dark"]).default("dark"),
+  },
+  sample: {
+    heading: "Ready to try Smoodly?",
+    buttonLabel: "Read the docs",
+    buttonHref: "/docs/intro",
+  },
+});
+
+function CtaBannerView({ heading, buttonLabel, buttonHref, styles }: Props<typeof ctaBannerSchema>) {
+  return (
+    <smoodly.Section styles={styles}>
+      <h2>{heading}</h2>
+      <a href={buttonHref}>{buttonLabel}</a>
+    </smoodly.Section>
+  );
+}
+
+export const CtaBanner = smoodly.section(ctaBannerSchema, CtaBannerView);

package/templates/next/components/sections/Hero.tsx

@@ -0,0 +1,24 @@
+import { f, smoodly, type Props } from "smoodly";
+
+export const heroSchema = smoodly.schema.section({
+  name: "hero",
+  title: "Hero",
+  fields: {
+    heading: f.text(),
+    kicker: f.text().optional(),
+  },
+  styles: {
+    tone: f.select(["light", "dark"]).default("light"),
+  },
+});
+
+function HeroView({ heading, kicker, styles }: Props<typeof heroSchema>) {
+  return (
+    <smoodly.Section styles={styles}>
+      {kicker ? <p>{kicker}</p> : null}
+      <h1>{heading}</h1>
+    </smoodly.Section>
+  );
+}
+
+export const Hero = smoodly.section(heroSchema, HeroView);

package/templates/next/lib/smoodly/admin.tsx

@@ -0,0 +1,6 @@
+import { createSmoodlyAdmin } from "smoodly/admin/next";
+import { config } from "../../smoodly.config";
+import { publicAuth } from "../smoodly";
+import { smoodlyOp } from "./ops";
+
+export const { AdminPage, AdminLayout } = createSmoodlyAdmin({ config, op: smoodlyOp, auth: publicAuth });

package/templates/next/lib/smoodly/index.ts

@@ -0,0 +1,64 @@
+// Server-only glue: the client and both stores, constructed lazily so
+// `next build` doesn't need env vars at import time. The env shape is
+// the package's (SMOODLY_*); whether the secret is a service-role key or
+// a cloud write key is invisible here.
+import { createSmoodlyClient, resolveTree, smoodlyEnv, SupabaseEntryStore, SupabasePageStore, type PageTree } from "smoodly";
+import { supabaseAdminAuth, type AdminAuth, type AuthConfig } from "smoodly/admin/next";
+import { createPageRenderer } from "smoodly/next";
+import type { SupabaseClient } from "@supabase/supabase-js";
+import { collections } from "../../collections";
+import { sections } from "../../sections";
+
+let cached: { db: SupabaseClient; pages: SupabasePageStore; entries: SupabaseEntryStore; auth: AdminAuth } | null = null;
+
+function bound() {
+  if (cached) return cached;
+  const env = smoodlyEnv();
+  const db = createSmoodlyClient(env);
+  const entries = new SupabaseEntryStore(db, collections);
+  const pages = new SupabasePageStore(db, { sections, entries });
+  const auth = supabaseAdminAuth({ authUrl: env.authUrl, authKey: env.authKey, db });
+  cached = { db, pages, entries, auth };
+  return cached;
+}
+
+export function stores() {
+  const { pages, entries } = bound();
+  return { pages, entries };
+}
+
+/** The server-side client (seed script, one-off admin tasks). */
+export const client = () => bound().db;
+
+/** The admin gate: session verified against the auth project, editors row read with the write key. */
+export const adminAuth = () => bound().auth;
+
+/** What the browser needs to sign in — public values only. */
+export function publicAuth(): AuthConfig {
+  const env = smoodlyEnv();
+  return { url: env.authUrl, key: env.authKey };
+}
+
+export const pageTag = (slug: string) => `page:${slug}`;
+
+/** One batched pass hydrates every ref in the tree (smoodly's resolveTree);
+ * the store's getMany IS the EntryFetcher. The published route passes
+ * { status: "published" } so an entry demoted after publish resolves to
+ * null on the next revalidation instead of leaking draft fields (OQ #16);
+ * the draft-preview path reads unfiltered. */
+export function resolvedTree(tree: PageTree, options?: { status?: "published" }): Promise<PageTree> {
+  return resolveTree(tree, {
+    sections,
+    collections,
+    fetch: (collection, ids) => stores().entries.getMany(collection, ids, options),
+  });
+}
+
+/** The site-route seam: draft branch, tag-cached published read, ref
+ * resolution, 404 and editor bridge, bound once for the whole app. */
+export const { renderSmoodlyPage, smoodlyMetadata } = createPageRenderer({
+  stores,
+  sections,
+  collections,
+  tag: pageTag,
+});

package/templates/next/lib/smoodly/ops.ts

@@ -0,0 +1,11 @@
+"use server";
+// The app's entire write surface for the admin: ONE exported action,
+// gated by the editors table. ('use server' modules may only export
+// async functions — hence the shape.)
+import { createAdminOpHandler, type AdminOpCall } from "smoodly/admin/next";
+import { config } from "../../smoodly.config";
+import { adminAuth, stores } from "../smoodly";
+
+export async function smoodlyOp(call: AdminOpCall) {
+  return createAdminOpHandler({ config, ...stores(), auth: adminAuth() })(call);
+}

package/templates/next/next.config.ts

@@ -0,0 +1,5 @@
+import type { NextConfig } from "next";
+
+const config: NextConfig = {};
+
+export default config;

package/templates/next/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "smoodly-site",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "next": "^16.3.4",
+    "react": "^19",
+    "react-dom": "^19",
+    "@supabase/supabase-js": "^2.113.0",
+    "smoodly": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.4.1",
+    "@types/react": "^19",
+    "@types/react-dom": "^19.2.5",
+    "typescript": "^5"
+  }
+}

package/templates/next/sections.ts

@@ -0,0 +1,8 @@
+// The registry arrays live in their own modules so lib/smoodly can import
+// them WITHOUT importing smoodly.config.ts — the config imports the page
+// registrations out of app/, and those route files import lib/smoodly.
+import { Hero } from "./components/sections/Hero";
+import { ArticleList } from "./components/sections/ArticleList";
+import { CtaBanner } from "./components/sections/CtaBanner";
+
+export const sections = [Hero, ArticleList, CtaBanner];

package/templates/next/smoodly.config.ts

@@ -0,0 +1,19 @@
+import { defineConfig, f } from "smoodly";
+import { collections } from "./collections";
+import { sections } from "./sections";
+import { HomePage } from "./app/page";
+import { StandardPage } from "./app/[slug]/page";
+
+export { collections, sections };
+
+export const config = defineConfig({
+  registry: {
+    sections,
+    collections,
+    pages: [HomePage, StandardPage],
+  },
+  locales: { default: "en", supported: ["en"] },
+  styles: {
+    sections: { spacing: f.select(["sm", "md", "lg"]).default("md") },
+  },
+});

package/templates/next/supabase/migrations/00000000000000_smoodly.sql

@@ -0,0 +1,338 @@
+-- The space a request acts in: the key's claim in Smoodly Cloud, the
+-- default space in self-host (service role, anon key). Policies, the
+-- insert trigger and the reorder RPC all read this ONE function.
+create or replace function "smoodly_current_space"() returns uuid
+language sql stable as $$
+  select coalesce((auth.jwt() ->> 'space_id')::uuid, '00000000-0000-0000-0000-000000000000');
+$$;
+
+create table if not exists "pages" (
+  "id" uuid primary key default gen_random_uuid(),
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "slug" text not null,
+  "template" text not null,
+  "status" text not null default 'draft',
+  "sort" numeric,
+  "locales" text[],
+  "draft_version_id" uuid,
+  "published_version_id" uuid,
+  "created_at" timestamptz not null default now(),
+  "updated_at" timestamptz not null default now(),
+  unique ("space_id", "slug")
+);
+
+create table if not exists "page_versions" (
+  "id" uuid primary key default gen_random_uuid(),
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "page_id" uuid not null references "pages" ("id") on delete cascade,
+  "tree" jsonb not null,
+  "created_by" text,
+  "created_at" timestamptz not null default now()
+);
+
+create table if not exists "saved_sections" (
+  "id" uuid primary key default gen_random_uuid(),
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "title" text not null,
+  "fragment" jsonb not null,
+  "created_at" timestamptz not null default now()
+);
+
+create table if not exists "global_sections" (
+  "id" uuid primary key default gen_random_uuid(),
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "type" text not null,
+  "content" jsonb not null,
+  "updated_at" timestamptz not null default now()
+);
+
+create table if not exists "entries" (
+  "id" uuid primary key default gen_random_uuid(),
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "collection" text not null,
+  "fields" jsonb not null default '{}'::jsonb,
+  "i18n" jsonb,
+  "status" text not null default 'draft',
+  "sort" numeric,
+  "locales" text[],
+  "created_at" timestamptz not null default now(),
+  "updated_at" timestamptz not null default now()
+);
+
+create unique index if not exists "entries_slug_key"
+  on "entries" ("space_id", "collection", ("fields"->>'slug'));
+
+create index if not exists "entries_collection_status_idx"
+  on "entries" ("space_id", "collection", "status");
+
+create index if not exists "entries_collection_sort_idx"
+  on "entries" ("space_id", "collection", "sort");
+
+-- v1 reorder (DESIGN.md §3 Manual ordering): rewrite sort 1..N in ONE
+-- statement. Deliberately does not touch updated_at — a drag must not
+-- make the whole collection look freshly edited. Scoped to the current
+-- space by the same function the policies use.
+create or replace function "smoodly_reorder"(
+  p_collection text,
+  p_ids uuid[]
+) returns void language sql as $$
+  update "entries" e set "sort" = u.ord
+  from unnest(p_ids) with ordinality as u(id, ord)
+  where e."id" = u.id
+    and e."collection" = p_collection
+    and e."space_id" = "smoodly_current_space"();
+$$;
+
+create table if not exists "refs" (
+  "source_kind" text not null,
+  "source_id" uuid not null,
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "source_field" text not null,
+  "target_collection" text not null,
+  "target_id" uuid not null,
+  primary key ("source_kind", "source_id", "source_field", "target_id")
+);
+
+-- RLS on every core table. The service role bypasses it (self-host
+-- adapters untouched). The policy set that follows (space layer) admits
+-- a key to its own space: everything for a write key, published rows for
+-- a read key or the anon key (default space). Drafts stay unreachable
+-- to anything but a write key. The generated per-collection views
+-- (collectionSQL) run with security_invoker = true, so they are subject
+-- to this same smoodly_read policy rather than their owner's privileges.
+alter table "pages" enable row level security;
+alter table "page_versions" enable row level security;
+alter table "saved_sections" enable row level security;
+alter table "global_sections" enable row level security;
+alter table "entries" enable row level security;
+alter table "refs" enable row level security;
+
+-- ── Cloud state (spec 2026-09-04 §1): three ordinary tables, shipped
+-- for everyone with ONE definition. Self-host fills them by hand or
+-- leaves them empty; smoodly.io writes rows with the service role.
+-- There is never cloud-only SQL on a content database.
+create table if not exists "editors" (
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "user_id" uuid not null,
+  "role" text not null default 'editor',
+  primary key ("space_id", "user_id")
+);
+
+create table if not exists "space_keys" (
+  "id" uuid primary key,
+  "space_id" uuid not null,
+  "kind" text not null check ("kind" in ('read', 'write')),
+  "revoked_at" timestamptz
+);
+
+create table if not exists "space_caps" (
+  "space_id" uuid primary key,
+  "row_cap" integer not null
+);
+
+alter table "editors" enable row level security;
+alter table "space_keys" enable row level security;
+alter table "space_caps" enable row level security;
+
+-- ── Claim readers. The two lookups run as definer so they can read the
+-- service-role-only tables from inside a policy; search_path is pinned.
+create or replace function "smoodly_key_kind"() returns text
+language sql stable as $$
+  select auth.jwt() ->> 'kind';
+$$;
+
+create or replace function "smoodly_space_key_revoked"() returns boolean
+language sql stable security definer set search_path = public as $$
+  select coalesce(
+    (select k."revoked_at" is not null from "space_keys" k
+      where k."id" = (auth.jwt() ->> 'key_id')::uuid),
+    false);
+$$;
+
+create or replace function "smoodly_space_row_cap"() returns integer
+language sql stable security definer set search_path = public as $$
+  select c."row_cap" from "space_caps" c where c."space_id" = "smoodly_current_space"();
+$$;
+
+-- ── Triggers. A key's claim wins over whatever the insert said, so an
+-- adapter never has to know its space and cannot write into another.
+-- No claim (service role, anon) leaves the given or default value —
+-- that is how smoodly.io writes cloud-state rows for a chosen space.
+create or replace function "smoodly_set_space"() returns trigger
+language plpgsql as $$
+begin
+  if auth.jwt() ->> 'space_id' is not null then
+    new."space_id" := (auth.jwt() ->> 'space_id')::uuid;
+  end if;
+  return new;
+end;
+$$;
+
+-- Per table, per space. No space_caps row = no cap (self-host). Trigger
+-- a_ (smoodly_set_space) runs first, so new.space_id already equals the
+-- current space for a keyed insert; smoodly_space_row_cap() reads the
+-- current space itself, so this never needs the row's space_id as an
+-- argument (which would let one space's insert probe another's cap).
+-- A service-role insert that names another space explicitly is a
+-- different case: there is no JWT claim, so smoodly_current_space()
+-- still resolves to the default space, and the cap read is the default
+-- space's (none) — the service role is never capped by another space's row.
+-- search_path is pinned empty, so every reference below is schema-qualified.
+create or replace function "smoodly_enforce_row_cap"() returns trigger
+language plpgsql set search_path = '' as $$
+declare
+  cap integer;
+  n bigint;
+begin
+  cap := public."smoodly_space_row_cap"();
+  if cap is null then
+    return new;
+  end if;
+  -- Advisory only (free-tier abuse guard), not a hard invariant: two
+  -- concurrent inserts can both observe n = cap - 1 and both pass.
+  execute format('select count(*) from %I.%I where "space_id" = $1', tg_table_schema, tg_table_name)
+    into n using new."space_id";
+  if n >= cap then
+    raise exception 'smoodly: row cap (%) reached for this space in %', cap, tg_table_name
+      using errcode = 'check_violation';
+  end if;
+  return new;
+end;
+$$;
+
+create index if not exists "page_versions_space_idx" on "page_versions" ("space_id");
+
+create index if not exists "saved_sections_space_idx" on "saved_sections" ("space_id");
+
+create index if not exists "global_sections_space_idx" on "global_sections" ("space_id");
+
+create index if not exists "refs_space_idx" on "refs" ("space_id");
+
+drop trigger if exists "smoodly_a_set_space" on "pages";
+create trigger "smoodly_a_set_space" before insert on "pages"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "page_versions";
+create trigger "smoodly_a_set_space" before insert on "page_versions"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "saved_sections";
+create trigger "smoodly_a_set_space" before insert on "saved_sections"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "global_sections";
+create trigger "smoodly_a_set_space" before insert on "global_sections"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "entries";
+create trigger "smoodly_a_set_space" before insert on "entries"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "refs";
+create trigger "smoodly_a_set_space" before insert on "refs"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "editors";
+create trigger "smoodly_a_set_space" before insert on "editors"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_b_row_cap" on "pages";
+create trigger "smoodly_b_row_cap" before insert on "pages"
+  for each row execute function "smoodly_enforce_row_cap"();
+
+drop trigger if exists "smoodly_b_row_cap" on "page_versions";
+create trigger "smoodly_b_row_cap" before insert on "page_versions"
+  for each row execute function "smoodly_enforce_row_cap"();
+
+drop trigger if exists "smoodly_b_row_cap" on "saved_sections";
+create trigger "smoodly_b_row_cap" before insert on "saved_sections"
+  for each row execute function "smoodly_enforce_row_cap"();
+
+drop trigger if exists "smoodly_b_row_cap" on "global_sections";
+create trigger "smoodly_b_row_cap" before insert on "global_sections"
+  for each row execute function "smoodly_enforce_row_cap"();
+
+drop trigger if exists "smoodly_b_row_cap" on "entries";
+create trigger "smoodly_b_row_cap" before insert on "entries"
+  for each row execute function "smoodly_enforce_row_cap"();
+
+drop trigger if exists "smoodly_b_row_cap" on "refs";
+create trigger "smoodly_b_row_cap" before insert on "refs"
+  for each row execute function "smoodly_enforce_row_cap"();
+
+drop policy if exists "smoodly_write" on "pages";
+create policy "smoodly_write" on "pages" for all
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "pages";
+create policy "smoodly_read" on "pages" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and "status" = 'published');
+
+drop policy if exists "smoodly_write" on "page_versions";
+create policy "smoodly_write" on "page_versions" for all
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "page_versions";
+create policy "smoodly_read" on "page_versions" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and exists (select 1 from "pages" p where p."published_version_id" = "page_versions"."id"));
+
+drop policy if exists "smoodly_write" on "saved_sections";
+create policy "smoodly_write" on "saved_sections" for all
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_write" on "global_sections";
+create policy "smoodly_write" on "global_sections" for all
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "global_sections";
+create policy "smoodly_read" on "global_sections" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()));
+
+drop policy if exists "smoodly_write" on "entries";
+create policy "smoodly_write" on "entries" for all
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "entries";
+create policy "smoodly_read" on "entries" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and "status" = 'published');
+
+drop policy if exists "smoodly_write" on "refs";
+create policy "smoodly_write" on "refs" for all
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_write" on "editors";
+create policy "smoodly_write" on "editors" for all
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write')
+  with check ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+create or replace view "people" with (security_invoker = true) as
+select
+  "id",
+  "sort",
+  "locales",
+  "created_at",
+  "updated_at",
+  "fields"->>'name' as "name",
+  "fields"->>'role' as "role"
+from "entries"
+where "collection" = 'people' and "status" = 'published';
+
+create or replace view "articles" with (security_invoker = true) as
+select
+  "id",
+  "sort",
+  "locales",
+  "created_at",
+  "updated_at",
+  "fields"->>'title' as "title",
+  "fields"->>'slug' as "slug",
+  "fields"->>'excerpt' as "excerpt",
+  "fields"->>'author' as "author"
+from "entries"
+where "collection" = 'articles' and "status" = 'published';

package/templates/next/tsconfig.json

@@ -0,0 +1,36 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": [
+      "dom",
+      "dom.iterable",
+      "esnext"
+    ],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ]
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}