create-smoodly-app 0.0.6 → 0.0.8

package/templates/next-intl/smoodly/shared.ts

@@ -0,0 +1,22 @@
+// Shared content (spec 2026-09-07): code-declared singletons stored as
+// entries. `footer` is visual — the layout renders it; `contact` is an
+// object the layout reads; `testimonials` is visual and placed on pages.
+import { f, smoodly } from "smoodly";
+import { Footer } from "@/components/sections/Footer";
+import { Testimonials } from "@/components/sections/Testimonials";
+
+export const footer = smoodly.shared({ name: "footer", title: "Footer", section: Footer, versions: true });
+
+export const contact = smoodly.shared({
+  name: "contact",
+  title: "Contact details",
+  fields: {
+    email: f.text(),
+    phone: f.text().optional(),
+    address: f.text().localized(),
+  },
+});
+
+export const testimonials = smoodly.shared({ name: "testimonials", title: "Testimonials", section: Testimonials });
+
+export const shared = [footer, contact, testimonials];

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

@@ -12,28 +12,34 @@ 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',
   "parent_id" uuid references "pages" ("id") on delete restrict,
-  "slug" text not null,
-  "title" text not null,
-  "i18n" jsonb,
   "template" text,
-  "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()
 );
 
--- The tree is the URL (spec 2026-09-05 §1): a node stores its own segment
--- and its parent. Siblings are unique per segment; NULLS NOT DISTINCT so
--- two root nodes cannot share one either. template null = folder.
-create unique index if not exists "pages_sibling_slug_key"
-  on "pages" ("space_id", "parent_id", "slug") nulls not distinct;
-
+-- The tree is the URL (spec 2026-09-05 §1): a node stores its parent and
+-- its position; template null = folder. Everything a locale owns — the
+-- node's own segment, title, publish state and version pointers — lives
+-- in page_locales, one row per locale the page exists in (spec 2026-09-06
+-- §2). There is no sibling-slug index: URL uniqueness per locale is the
+-- primary key of "paths", which the stores write inside the same operation.
 create index if not exists "pages_parent_idx"
   on "pages" ("space_id", "parent_id", "sort");
 
+create table if not exists "page_locales" (
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "page_id" uuid not null references "pages" ("id") on delete cascade,
+  "locale" text not null,
+  "slug" text not null,
+  "title" text not null,
+  "status" text not null default 'draft',
+  "draft_version_id" uuid,
+  "published_version_id" uuid,
+  "updated_at" timestamptz not null default now(),
+  primary key ("page_id", "locale")
+);
+
 -- Sibling reorder for pages: same shape as smoodly_reorder for entries.
 create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void language sql as $$
   update "pages" pg set "sort" = u.ord
@@ -42,30 +48,20 @@ create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void la
     and pg."space_id" = "smoodly_current_space"();
 $$;
 
+-- A version belongs to ONE locale of one page: each locale has its own
+-- draft, its own publish and its own history.
 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,
+  "locale" text not null,
   "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 index if not exists "page_versions_page_locale_idx"
+  on "page_versions" ("page_id", "locale", "created_at");
 
 create table if not exists "entries" (
   "id" uuid primary key default gen_random_uuid(),
@@ -73,40 +69,58 @@ create table if not exists "entries" (
   "collection" text not null,
   "parent_id" uuid references "entries" ("id") on delete restrict,
   "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()
 );
 
--- Entry slugs are unique among SIBLINGS, like pages: one rule for every
--- node in the tree, and the URL is the tree. NULLS NOT DISTINCT so two
--- ROOT entries (parent_id null) cannot share a slug either. The partial
--- predicate keeps absent, null, empty or non-string slugs out of the
--- index entirely: with NULLS NOT DISTINCT a null slug would otherwise
--- collide with the next null slug, and a collection with no slug field
--- at all could hold only one entry per parent. jsonb_typeof(...) =
--- 'string' is required because ->> renders ANY JSON scalar as text —
--- a number, boolean or null slug would otherwise print as non-empty
--- text and claim the index; only a non-empty string slug claims a URL,
--- absent, null, empty or non-string slugs never conflict — the same
--- rule as slugOf in paths.ts. A flat collection (every entry a root)
--- therefore behaves exactly as per-collection uniqueness did.
-create unique index if not exists "entries_sibling_slug_key"
-  on "entries" ("space_id", "collection", "parent_id", ("fields"->>'slug')) nulls not distinct
-  where (jsonb_typeof("fields"->'slug') = 'string' and "fields"->>'slug' <> '');
-
-create index if not exists "entries_collection_status_idx"
-  on "entries" ("space_id", "collection", "status");
-
+-- The node holds identity, tree position and the SHARED fields — every
+-- field without .localized() (spec 2026-09-06 §7): a Person's photo is
+-- the same in every language. Everything a locale owns — its segment,
+-- publish state, the .localized() fields and the version pointers —
+-- lives in entry_locales, one row per locale the entry exists in. There
+-- is no sibling-slug index any more: URL uniqueness per locale is the
+-- primary key of "paths", which the stores write inside the same
+-- operation, and both adapters pre-check siblings per locale in code.
 create index if not exists "entries_collection_sort_idx"
   on "entries" ("space_id", "collection", "sort");
 
 create index if not exists "entries_parent_idx"
   on "entries" ("space_id", "collection", "parent_id");
 
+create table if not exists "entry_locales" (
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "entry_id" uuid not null references "entries" ("id") on delete cascade,
+  "locale" text not null,
+  "slug" text,
+  "status" text not null default 'draft',
+  "fields" jsonb not null default '{}'::jsonb,
+  "draft_version_id" uuid,
+  "published_version_id" uuid,
+  "updated_at" timestamptz not null default now(),
+  primary key ("entry_id", "locale")
+);
+
+create index if not exists "entry_locales_status_idx"
+  on "entry_locales" ("space_id", "locale", "status");
+
+-- A version belongs to ONE locale of one entry and stores the MERGED
+-- fields (shared + localized + slug) as they were at that save, so
+-- restoring an old Finnish version restores the shared fields too.
+-- Rows exist only for collections registered with `versions: true`.
+create table if not exists "entry_versions" (
+  "id" uuid primary key default gen_random_uuid(),
+  "space_id" uuid not null default '00000000-0000-0000-0000-000000000000',
+  "entry_id" uuid not null references "entries" ("id") on delete cascade,
+  "locale" text not null,
+  "fields" jsonb not null,
+  "created_by" text,
+  "created_at" timestamptz not null default now()
+);
+
+create index if not exists "entry_versions_entry_locale_idx"
+  on "entry_versions" ("entry_id", "locale", "created_at");
+
 -- 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
@@ -172,10 +186,11 @@ $$;
 -- (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_locales" 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 "entry_locales" enable row level security;
+alter table "entry_versions" enable row level security;
 alter table "refs" enable row level security;
 alter table "paths" enable row level security;
 
@@ -272,11 +287,13 @@ begin
 end;
 $$;
 
+create index if not exists "page_locales_space_idx" on "page_locales" ("space_id");
+
 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 "entry_locales_space_idx" on "entry_locales" ("space_id");
 
-create index if not exists "global_sections_space_idx" on "global_sections" ("space_id");
+create index if not exists "entry_versions_space_idx" on "entry_versions" ("space_id");
 
 create index if not exists "refs_space_idx" on "refs" ("space_id");
 
@@ -284,20 +301,24 @@ 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_locales";
+create trigger "smoodly_a_set_space" before insert on "page_locales"
+  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"
+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 "global_sections";
-create trigger "smoodly_a_set_space" before insert on "global_sections"
+drop trigger if exists "smoodly_a_set_space" on "entry_locales";
+create trigger "smoodly_a_set_space" before insert on "entry_locales"
   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"
+drop trigger if exists "smoodly_a_set_space" on "entry_versions";
+create trigger "smoodly_a_set_space" before insert on "entry_versions"
   for each row execute function "smoodly_set_space"();
 
 drop trigger if exists "smoodly_a_set_space" on "refs";
@@ -316,20 +337,24 @@ 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_locales";
+create trigger "smoodly_b_row_cap" before insert on "page_locales"
+  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"
+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 "global_sections";
-create trigger "smoodly_b_row_cap" before insert on "global_sections"
+drop trigger if exists "smoodly_b_row_cap" on "entry_locales";
+create trigger "smoodly_b_row_cap" before insert on "entry_locales"
   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"
+drop trigger if exists "smoodly_b_row_cap" on "entry_versions";
+create trigger "smoodly_b_row_cap" before insert on "entry_versions"
   for each row execute function "smoodly_enforce_row_cap"();
 
 drop trigger if exists "smoodly_b_row_cap" on "refs";
@@ -347,6 +372,15 @@ create policy "smoodly_write" on "pages" for all
 
 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 exists (select 1 from "page_locales" l where l."page_id" = "pages"."id" and l."status" = 'published'));
+
+drop policy if exists "smoodly_write" on "page_locales";
+create policy "smoodly_write" on "page_locales" 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_locales";
+create policy "smoodly_read" on "page_locales" 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";
@@ -356,30 +390,34 @@ create policy "smoodly_write" on "page_versions" for all
 
 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"));
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and exists (select 1 from "page_locales" l where l."published_version_id" = "page_versions"."id"));
 
-drop policy if exists "smoodly_write" on "saved_sections";
-create policy "smoodly_write" on "saved_sections" for all
+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_write" on "global_sections";
-create policy "smoodly_write" on "global_sections" for all
+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 exists (select 1 from "entry_locales" l where l."entry_id" = "entries"."id" and l."status" = 'published'));
+
+drop policy if exists "smoodly_write" on "entry_locales";
+create policy "smoodly_write" on "entry_locales" 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_read" on "entry_locales";
+create policy "smoodly_read" on "entry_locales" 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 "entries";
-create policy "smoodly_write" on "entries" for all
+drop policy if exists "smoodly_write" on "entry_versions";
+create policy "smoodly_write" on "entry_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 "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_read" on "entry_versions";
+create policy "smoodly_read" on "entry_versions" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and exists (select 1 from "entry_locales" l where l."published_version_id" = "entry_versions"."id"));
 
 drop policy if exists "smoodly_write" on "refs";
 create policy "smoodly_write" on "refs" for all
@@ -393,7 +431,7 @@ create policy "smoodly_write" on "paths" for all
 
 drop policy if exists "smoodly_read" on "paths";
 create policy "smoodly_read" on "paths" for select
-  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (("kind" = 'page' and exists (select 1 from "pages" p where p."id" = "paths"."target_id" and p."status" = 'published')) or ("kind" = 'entry' and exists (select 1 from "entries" e where e."id" = "paths"."target_id" and e."status" = 'published'))));
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (("kind" = 'page' and exists (select 1 from "page_locales" l where l."page_id" = "paths"."target_id" and l."locale" = "paths"."locale" and l."status" = 'published')) or ("kind" = 'entry' and exists (select 1 from "entry_locales" l where l."entry_id" = "paths"."target_id" and l."locale" = "paths"."locale" and l."status" = 'published'))));
 
 drop policy if exists "smoodly_write" on "editors";
 create policy "smoodly_write" on "editors" for all
@@ -402,26 +440,30 @@ create policy "smoodly_write" on "editors" for all
 
 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';
+  e."id",
+  l."locale",
+  l."slug",
+  e."sort",
+  e."created_at",
+  l."updated_at",
+  e."fields"->>'name' as "name",
+  l."fields"->>'role' as "role"
+from "entries" e
+join "entry_locales" l on l."entry_id" = e."id"
+where e."collection" = 'people' and l."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';
+  e."id",
+  l."locale",
+  l."slug",
+  e."sort",
+  e."created_at",
+  l."updated_at",
+  v."fields"->>'title' as "title",
+  v."fields"->>'excerpt' as "excerpt",
+  v."fields"->>'author' as "author"
+from "entries" e
+join "entry_locales" l on l."entry_id" = e."id"
+join "entry_versions" v on v."id" = l."published_version_id"
+where e."collection" = 'articles' and l."status" = 'published';