create-smoodly-app 0.0.45 → 0.0.47

package/templates/astro-blank/supabase/migrations/20260929120000_smoodly_v5.sql

@@ -0,0 +1,56 @@
+-- Smoodly core schema, version 5 (docs/superpowers/specs/2026-09-29-nested-collection-paths-design.md,
+-- docs/superpowers/specs/2026-09-29-anchored-paths-design.md).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 4: `pages.fixed` names the registration that owns a
+-- code-owned record, unique per space; `paths.anchor` names the code address
+-- a URL row hangs under, and the row keeps only the part editors made.
+-- No backfill: a record without `fixed` is an editor's page, a row without
+-- an anchor is the editors' tree.
+
+set client_min_messages = warning;
+
+alter table "pages" add column if not exists "fixed" text;
+
+create unique index if not exists "pages_fixed_idx"
+  on "pages" ("space_id", "fixed") where "fixed" is not null;
+
+alter table "paths" add column if not exists "anchor" text not null default '';
+alter table "paths" drop constraint if exists "paths_pkey";
+alter table "paths" add constraint "paths_pkey" primary key ("space_id", "locale", "anchor", "path");
+
+create or replace function "smoodly_rewrite_paths"(p_targets jsonb, p_rows jsonb) returns void language sql set search_path = public as $$
+  delete from "paths" p
+  using jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid, keys jsonb)
+  where p."redirect" and p."locale" = r.locale
+    and exists (select 1 from jsonb_to_recordset(r.keys) as k(anchor text, path text) where k.anchor = p."anchor" and k.path = p."path")
+    and p."space_id" = "smoodly_current_space"();
+  update "paths" p set "redirect" = true
+  from jsonb_to_recordset(p_targets) as t(kind text, id uuid, redirect_locales text[])
+  where not p."redirect" and p."kind" = t.kind and p."target_id" = t.id
+    and p."locale" = any (coalesce(t.redirect_locales, '{}'::text[]))
+    and not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid, keys jsonb)
+                    cross join lateral jsonb_to_recordset(r.keys) as k(anchor text, path text)
+                    where r.locale = p."locale" and k.anchor = p."anchor" and k.path = p."path")
+    and p."space_id" = "smoodly_current_space"();
+  delete from "paths" p
+  using jsonb_to_recordset(p_targets) as t(kind text, id uuid, redirect_locales text[])
+  where p."kind" = t.kind and p."target_id" = t.id
+    and (not p."redirect" or not exists (select 1 from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid)
+                                          where r.kind = p."kind" and r.id = p."target_id" and r.locale = p."locale"))
+    and p."space_id" = "smoodly_current_space"();
+  insert into "paths" ("locale", "anchor", "path", "kind", "target_id")
+  select r.locale, r.anchor, r.path, r.kind, r.id
+  from jsonb_to_recordset(p_rows) as r(locale text, anchor text, path text, kind text, id uuid);
+$$;
+
+revoke execute on function "smoodly_rewrite_paths"(jsonb, jsonb) from public, anon;
+
+create or replace function "smoodly_resolve_path"(p_locale text, p_keys jsonb) returns setof "paths" language sql stable set search_path = public as $$
+  select p.* from "paths" p
+  join jsonb_to_recordset(p_keys) as k(anchor text, path text) on p."anchor" = k.anchor and p."path" = k.path
+  where p."locale" = p_locale;
+$$;
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '5')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/astro-blank/supabase/migrations/20260929135523_smoodly_v6.sql

@@ -0,0 +1,200 @@
+-- Smoodly core schema, version 6 (docs/superpowers/specs/2026-09-29-pre-install-fixes-design.md §3).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 5: one permissive policy per table and action (the
+-- write key reads through smoodly_read; smoodly_write splits into insert,
+-- update and delete where a public read exists; the media pair the same),
+-- indexes on the foreign keys without one, and no anon call of the row cap.
+-- Access is unchanged.
+
+set client_min_messages = warning;
+
+create index if not exists "page_locales_draft_version_idx" on "page_locales" ("draft_version_id");
+create index if not exists "entry_locales_draft_version_idx" on "entry_locales" ("draft_version_id");
+create index if not exists "page_locales_published_version_idx" on "page_locales" ("published_version_id");
+create index if not exists "entry_locales_published_version_idx" on "entry_locales" ("published_version_id");
+create index if not exists "pages_parent_id_idx" on "pages" ("parent_id");
+create index if not exists "entries_parent_id_idx" on "entries" ("parent_id");
+create index if not exists "assets_poster_idx" on "assets" ("poster_id");
+
+drop policy if exists "smoodly_write" on "pages";
+
+drop policy if exists "smoodly_insert" on "pages";
+create policy "smoodly_insert" on "pages" for insert
+  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_update" on "pages";
+create policy "smoodly_update" on "pages" for update
+  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_delete" on "pages";
+create policy "smoodly_delete" on "pages" for delete
+  using ("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 ((select "smoodly_key_kind"()) = 'write' or 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";
+
+drop policy if exists "smoodly_insert" on "page_locales";
+create policy "smoodly_insert" on "page_locales" for insert
+  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_update" on "page_locales";
+create policy "smoodly_update" on "page_locales" for update
+  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_delete" on "page_locales";
+create policy "smoodly_delete" on "page_locales" for delete
+  using ("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 ((select "smoodly_key_kind"()) = 'write' or "status" = 'published'));
+
+drop policy if exists "smoodly_write" on "page_versions";
+
+drop policy if exists "smoodly_insert" on "page_versions";
+create policy "smoodly_insert" on "page_versions" for insert
+  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_update" on "page_versions";
+create policy "smoodly_update" on "page_versions" for update
+  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_delete" on "page_versions";
+create policy "smoodly_delete" on "page_versions" for delete
+  using ("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 ((select "smoodly_key_kind"()) = 'write' or exists (select 1 from "page_locales" l where l."published_version_id" = "page_versions"."id")));
+
+drop policy if exists "smoodly_write" on "entries";
+
+drop policy if exists "smoodly_insert" on "entries";
+create policy "smoodly_insert" on "entries" for insert
+  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_update" on "entries";
+create policy "smoodly_update" on "entries" for update
+  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_delete" on "entries";
+create policy "smoodly_delete" on "entries" for delete
+  using ("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 ((select "smoodly_key_kind"()) = 'write' or 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";
+
+drop policy if exists "smoodly_insert" on "entry_locales";
+create policy "smoodly_insert" on "entry_locales" for insert
+  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_update" on "entry_locales";
+create policy "smoodly_update" on "entry_locales" for update
+  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_delete" on "entry_locales";
+create policy "smoodly_delete" on "entry_locales" for delete
+  using ("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 "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 ((select "smoodly_key_kind"()) = 'write' or "status" = 'published'));
+
+drop policy if exists "smoodly_write" on "entry_versions";
+
+drop policy if exists "smoodly_insert" on "entry_versions";
+create policy "smoodly_insert" on "entry_versions" for insert
+  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_update" on "entry_versions";
+create policy "smoodly_update" on "entry_versions" for update
+  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_delete" on "entry_versions";
+create policy "smoodly_delete" on "entry_versions" for delete
+  using ("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 "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 ((select "smoodly_key_kind"()) = 'write' or 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
+  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 "paths";
+
+drop policy if exists "smoodly_insert" on "paths";
+create policy "smoodly_insert" on "paths" for insert
+  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_update" on "paths";
+create policy "smoodly_update" on "paths" for update
+  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_delete" on "paths";
+create policy "smoodly_delete" on "paths" for delete
+  using ("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 "paths";
+create policy "smoodly_read" on "paths" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and ((select "smoodly_key_kind"()) = 'write' or (("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 "assets";
+
+drop policy if exists "smoodly_insert" on "assets";
+create policy "smoodly_insert" on "assets" for insert
+  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_update" on "assets";
+create policy "smoodly_update" on "assets" for update
+  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_delete" on "assets";
+create policy "smoodly_delete" on "assets" for delete
+  using ("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 "assets";
+create policy "smoodly_read" on "assets" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and ((select "smoodly_key_kind"()) = 'write' or "status" = 'ready'));
+
+drop policy if exists "smoodly_write" on "members";
+create policy "smoodly_write" on "members" 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_media_write" on storage.objects;
+
+drop policy if exists "smoodly_media_insert" on storage.objects;
+create policy "smoodly_media_insert" on storage.objects for insert
+  with check ("bucket_id" = 'media' and (select public."smoodly_key_kind"()) = 'write' and not (select public."smoodly_space_key_revoked"()) and split_part("name", '/', 1) = (select public."smoodly_current_space"())::text);
+
+drop policy if exists "smoodly_media_update" on storage.objects;
+create policy "smoodly_media_update" on storage.objects for update
+  using ("bucket_id" = 'media' and (select public."smoodly_key_kind"()) = 'write' and not (select public."smoodly_space_key_revoked"()) and split_part("name", '/', 1) = (select public."smoodly_current_space"())::text)
+  with check ("bucket_id" = 'media' and (select public."smoodly_key_kind"()) = 'write' and not (select public."smoodly_space_key_revoked"()) and split_part("name", '/', 1) = (select public."smoodly_current_space"())::text);
+
+drop policy if exists "smoodly_media_delete" on storage.objects;
+create policy "smoodly_media_delete" on storage.objects for delete
+  using ("bucket_id" = 'media' and (select public."smoodly_key_kind"()) = 'write' and not (select public."smoodly_space_key_revoked"()) and split_part("name", '/', 1) = (select public."smoodly_current_space"())::text);
+
+revoke execute on function "smoodly_space_row_cap"() from public, anon;
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '6')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/astro-blank/supabase/migrations/20260930040956_smoodly_v7.sql

@@ -0,0 +1,84 @@
+-- Smoodly core schema, version 7 (docs/superpowers/specs/2026-09-29-content-api-contract-design.md §5).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 6: smoodly_list_entries, which filters, orders and
+-- limits a collection over the snapshot the reader is shown, and the read
+-- policies of every content table admit a write key only (§8).
+
+-- The shown snapshot of one collection's entries in a locale, filtered,
+-- ordered and limited in one query (spec 2026-09-29 content API contract
+-- §5): the published snapshot, or the live merge in preview. Invoker
+-- rights, so RLS decides what a key sees; a preview read needs the
+-- service role or a write key, anything else reads published.
+create or replace function "smoodly_list_entries"(
+  p_collection text, p_locale text, p_draft boolean, p_where jsonb, p_order jsonb,
+  p_limit integer, p_parent uuid, p_has_parent boolean, p_ids uuid[]
+) returns table ("id" uuid, "fields" jsonb) language sql stable set search_path = public as $$
+  with mode as (
+    select p_draft and (current_user = 'service_role' or "smoodly_key_kind"() = 'write') as draft
+  ), shown as (
+    select e."id", e."sort", e."created_at", l."updated_at",
+      case when (select draft from mode) then e."fields" || l."fields" || jsonb_build_object('slug', l."slug")
+           else coalesce(v."fields", e."fields" || l."fields" || jsonb_build_object('slug', l."slug")) end as "fields"
+    from "entries" e
+    join "entry_locales" l on l."entry_id" = e."id" and l."locale" = p_locale
+    left join "entry_versions" v on v."id" = l."published_version_id"
+    where e."collection" = p_collection
+      and ((select draft from mode) or l."status" = 'published')
+      and (not p_has_parent or e."parent_id" is not distinct from p_parent)
+      and (p_ids is null or e."id" = any(p_ids))
+  )
+  select s."id", s."fields" from shown s
+  where not exists (
+    select 1 from jsonb_each(coalesce(p_where, '{}'::jsonb)) w
+    where not (case when w.value ? 'in'
+                    then (s."fields" ->> w.key) = any (select jsonb_array_elements_text(w.value -> 'in'))
+                    else s."fields" @> jsonb_build_object(w.key, w.value -> 'contains') end))
+  order by
+    case when p_order ->> 'by' = 'manual' then s."sort" end asc nulls last,
+    case when p_order ->> 'direction' = 'asc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end asc nulls last,
+    case when p_order ->> 'direction' = 'desc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end desc nulls last,
+    s."created_at" asc, s."id" asc
+  limit p_limit;
+$$;
+
+-- No public content reads (spec 2026-09-29 content API contract §8): the
+-- publishable key and a read key read nothing; a write key reads its own space.
+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 (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 (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 (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 (select "smoodly_key_kind"()) = 'write');
+
+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 (select "smoodly_key_kind"()) = 'write');
+
+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 (select "smoodly_key_kind"()) = 'write');
+
+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 (select "smoodly_key_kind"()) = 'write');
+
+drop policy if exists "smoodly_read" on "assets";
+create policy "smoodly_read" on "assets" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '7')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/astro-blank/supabase/migrations/20261007120000_smoodly_v8.sql

@@ -0,0 +1,154 @@
+-- Smoodly core schema, version 8 (docs/superpowers/specs/2026-10-07-delivery-model-design.md).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 7: the delivery model's two derived tables,
+-- published_pages and published_entries, with the space trigger and the
+-- write-key-only policies every content table has (no row cap: they are
+-- derived), smoodly_list_published over the raw published snapshot, and
+-- the published_routes view, one lookup for any address.
+
+set client_min_messages = warning;
+
+-- The delivery model (spec 2026-10-07): Publish writes the finished document of a page, an entry
+-- or a global here; a live read is one lookup. Derived and rebuildable from the editing tables.
+create table if not exists "published_pages" (
+  "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,
+  "parent_id" uuid,
+  "sort" numeric,
+  "path" text,
+  "title" text not null,
+  "has_page" boolean not null,
+  "link_fields" jsonb not null default '{}'::jsonb,
+  "document" jsonb,
+  "tags" text[] not null default '{}',
+  "model" text not null,
+  "stale" boolean not null default false,
+  "published_at" timestamptz not null default now(),
+  primary key ("page_id", "locale")
+);
+create unique index if not exists "published_pages_address_idx"
+  on "published_pages" ("space_id", "locale", "path") where "path" is not null;
+create index if not exists "published_pages_tree_idx"
+  on "published_pages" ("space_id", "locale", "parent_id", "sort");
+
+create table if not exists "published_entries" (
+  "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,
+  "collection" text not null,
+  "parent_id" uuid,
+  "sort" numeric,
+  "slug" text,
+  "path" text,
+  "created_at" timestamptz not null,
+  "updated_at" timestamptz not null,
+  "fields" jsonb not null,
+  "document" jsonb not null,
+  "tags" text[] not null default '{}',
+  "model" text not null,
+  "stale" boolean not null default false,
+  "published_at" timestamptz not null default now(),
+  primary key ("entry_id", "locale")
+);
+create index if not exists "published_entries_list_idx"
+  on "published_entries" ("space_id", "collection", "locale");
+create unique index if not exists "published_entries_address_idx"
+  on "published_entries" ("space_id", "locale", "path") where "path" is not null;
+create index if not exists "published_entries_fields_idx"
+  on "published_entries" using gin ("fields");
+
+alter table "published_pages" enable row level security;
+alter table "published_entries" enable row level security;
+
+-- smoodly_list_entries without the draft branch, over the delivery table (spec 2026-10-07 §3):
+-- `where` and `order` read the raw published snapshot, the row answers with its document.
+-- Invoker rights, so RLS decides what a key sees.
+create or replace function "smoodly_list_published"(
+  p_collection text, p_locale text, p_where jsonb, p_order jsonb,
+  p_limit integer, p_parent uuid, p_has_parent boolean, p_ids uuid[]
+) returns table ("id" uuid, "document" jsonb, "model" text, "stale" boolean) language sql stable set search_path = public as $$
+  with shown as (
+    select p."entry_id" as "id", p."sort", p."created_at", p."updated_at", p."fields", p."document", p."model", p."stale"
+    from "published_entries" p
+    where p."collection" = p_collection and p."locale" = p_locale
+      and (not p_has_parent or p."parent_id" is not distinct from p_parent)
+      and (p_ids is null or p."entry_id" = any(p_ids))
+  )
+  select s."id", s."document", s."model", s."stale" from shown s
+  where not exists (
+    select 1 from jsonb_each(coalesce(p_where, '{}'::jsonb)) w
+    where not (case when w.value ? 'in'
+                    then (s."fields" ->> w.key) = any (select jsonb_array_elements_text(w.value -> 'in'))
+                    else s."fields" @> jsonb_build_object(w.key, w.value -> 'contains') end))
+  order by
+    case when p_order ->> 'by' = 'manual' then s."sort" end asc nulls last,
+    case when p_order ->> 'direction' = 'asc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end asc nulls last,
+    case when p_order ->> 'direction' = 'desc' then
+      case p_order ->> 'by' when 'createdAt' then to_jsonb(s."created_at") when 'updatedAt' then to_jsonb(s."updated_at")
+           when 'manual' then null else nullif(nullif(s."fields" -> (p_order ->> 'by'), 'null'::jsonb), '""'::jsonb) end end desc nulls last,
+    s."created_at" asc, s."id" asc
+  limit p_limit;
+$$;
+
+-- One lookup for any address (spec 2026-10-07 §3): a page or an entry, under the caller's own policies.
+create or replace view "published_routes" with (security_invoker = true) as
+  select "space_id", "locale", "path", 'page' as "kind", "page_id" as "id", "document", "model", "stale", "tags", null::text as "collection"
+  from "published_pages" where "path" is not null and "has_page"
+  union all
+  select "space_id", "locale", "path", 'entry' as "kind", "entry_id" as "id", "document", "model", "stale", "tags", "collection"
+  from "published_entries" where "path" is not null;
+
+-- Stamped with the caller's space on insert, as every content table.
+drop trigger if exists "smoodly_a_set_space" on "published_pages";
+create trigger "smoodly_a_set_space" before insert on "published_pages"
+  for each row execute function "smoodly_set_space"();
+
+drop trigger if exists "smoodly_a_set_space" on "published_entries";
+create trigger "smoodly_a_set_space" before insert on "published_entries"
+  for each row execute function "smoodly_set_space"();
+
+-- A write key reads and writes its own space; no other key reads (spec 2026-09-29 content API contract §8).
+drop policy if exists "smoodly_write" on "published_pages";
+
+drop policy if exists "smoodly_insert" on "published_pages";
+create policy "smoodly_insert" on "published_pages" for insert
+  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_update" on "published_pages";
+create policy "smoodly_update" on "published_pages" for update
+  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_delete" on "published_pages";
+create policy "smoodly_delete" on "published_pages" for delete
+  using ("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 "published_pages";
+create policy "smoodly_read" on "published_pages" for select
+  using ("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 "published_entries";
+
+drop policy if exists "smoodly_insert" on "published_entries";
+create policy "smoodly_insert" on "published_entries" for insert
+  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_update" on "published_entries";
+create policy "smoodly_update" on "published_entries" for update
+  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_delete" on "published_entries";
+create policy "smoodly_delete" on "published_entries" for delete
+  using ("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 "published_entries";
+create policy "smoodly_read" on "published_entries" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '8')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/astro-blank/supabase/migrations/20261007200000_smoodly_v9.sql

@@ -0,0 +1,30 @@
+-- Smoodly core schema, version 9 (packages/smoodly/MAINTAINERS.md, register 2026-10-07: what the delivery model left).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 8: smoodly_lookup_address, the route row and the
+-- locale's global items in one call, so a live page is one database call
+-- instead of the page then its layout's globals.
+
+set client_min_messages = warning;
+
+-- The address and the locale's global items in one call (schema v9; register 2026-10-07: a miss was two
+-- rounds, the page then the layout's globals). The route row first, kind 'page' or 'entry'; then one row per
+-- named global, kind 'global', the collection its name. A miss answers nothing: the globals ride with a page
+-- only. Invoker rights, so RLS decides what a key sees.
+create or replace function "smoodly_lookup_address"(p_locale text, p_path text, p_globals text[])
+returns table ("kind" text, "id" uuid, "collection" text, "document" jsonb, "model" text, "stale" boolean, "tags" text[])
+language sql stable set search_path = public as $$
+  with route as (
+    select r."kind", r."id", r."collection", r."document", r."model", r."stale", r."tags"
+    from "published_routes" r where r."locale" = p_locale and r."path" = p_path limit 1
+  )
+  select * from route
+  union all
+  select 'global' as "kind", e."entry_id", e."collection", e."document", e."model", e."stale", e."tags"
+  from "published_entries" e
+  where e."locale" = p_locale and e."collection" = any(coalesce(p_globals, '{}'::text[]))
+    and exists (select 1 from route);
+$$;
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '9')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/astro-blank/supabase/migrations/20261008120000_smoodly_v10.sql

@@ -0,0 +1,47 @@
+-- Smoodly core schema, version 10 (DESIGN §3, the document stamp, decided 2026-10-08).
+-- Shipped in the smoodly package; `npx smoodly migrate` copies it into supabase/migrations/.
+-- Never edit a published file: the next change is the next file.
+-- The delta over version 9: published_models, one row per space holding the
+-- document stamp the space recorded as current, so only the deployment at that
+-- stamp rewrites delivery rows (a preview deployment on a newer package serves
+-- assembled documents and writes nothing). Additive: no function changes.
+
+set client_min_messages = warning;
+
+-- The document stamp a space recorded as current: set by `npx smoodly rebuild` and by the first writer
+-- into an empty record; only a reader at this stamp rewrites published_pages and published_entries.
+create table if not exists "published_models" (
+  "space_id" uuid primary key default '00000000-0000-0000-0000-000000000000',
+  "model" text not null,
+  "recorded_at" timestamptz not null default now()
+);
+
+alter table "published_models" enable row level security;
+
+-- Stamped with the caller's space on insert, as every content table.
+drop trigger if exists "smoodly_a_set_space" on "published_models";
+create trigger "smoodly_a_set_space" before insert on "published_models"
+  for each row execute function "smoodly_set_space"();
+
+-- A write key reads and writes its own space's record; no other key reads (spec 2026-09-29 content API contract §8).
+drop policy if exists "smoodly_write" on "published_models";
+
+drop policy if exists "smoodly_insert" on "published_models";
+create policy "smoodly_insert" on "published_models" for insert
+  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_update" on "published_models";
+create policy "smoodly_update" on "published_models" for update
+  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_delete" on "published_models";
+create policy "smoodly_delete" on "published_models" for delete
+  using ("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 "published_models";
+create policy "smoodly_read" on "published_models" for select
+  using ("space_id" = (select "smoodly_current_space"()) and not (select "smoodly_space_key_revoked"()) and (select "smoodly_key_kind"()) = 'write');
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '10')
+  on conflict ("key") do update set "value" = excluded."value";

package/templates/{blank/supabase/migrations/20260930041056_smoodly_views.sql → astro-blank/supabase/migrations/20261008120100_smoodly_views.sql}

@@ -1,5 +1,5 @@
 -- Smoodly: read views for this app's collections, written by `npx smoodly migrate`
--- (2026-09-30T04:10:56.000Z). One block per collection; the marker's hash is the block's SQL, compared on the next run.
+-- (2026-10-08T12:01:00.000Z). One block per collection; the marker's hash is the block's SQL, compared on the next run.
 -- Never edit a written file: change the collection and run migrate again.
 
 -- smoodly:collection posts sha256:38ba2918f83ab367

package/templates/astro-blank/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "astro/tsconfigs/strict",
+  "compilerOptions": {
+    "paths": {
+      "@/*": [
+        "./src/*"
+      ]
+    }
+  },
+  "include": [
+    ".astro/types.d.ts",
+    "**/*"
+  ],
+  "exclude": [
+    "dist"
+  ]
+}