smoodly 0.0.27 → 0.0.28

package/dist/supabase-entry-store.js

@@ -10,8 +10,9 @@ import { collectionDepth, collectionOrder } from "./collections.js";
 import { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isGlobalSchema, schemaOf, splitFields, } from "./entry-store.js";
 import { globalEntryId } from "./global-id.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
+import { groupRedirects } from "./store.js";
 import { assertFresh, draftToken, StaleDraftError } from "./draft-token.js";
-import { assertDepth, assertSupportedLocale, entryPathRows, slugOf } from "./paths.js";
+import { assertDepth, assertSupportedLocale, entryPathRows, rewriteTargets, slugOf } from "./paths.js";
 // entries.id is a Postgres uuid column: filtering on a non-UUID string
 // throws invalid_text_representation. A non-UUID id can't exist in the
 // table, so treat it the same as a missing one.
@@ -151,11 +152,11 @@ export class SupabaseEntryStore {
         return new Map(res.data.map((r) => [r.id, r.fields]));
     }
     // ── the derived indexes ──
-    async writePaths(top) {
+    async writePaths(top, redirect = true) {
         const schema = this.schema(top.collection);
         const ancestors = await this.chain(top);
         const nodes = await this.subtree(top);
-        await this.paths.rewrite(nodes.map((n) => ({ kind: "entry", id: n.id })), entryPathRows(nodes, this.byIdMap([...ancestors, ...nodes]), schema, this.locales));
+        await this.paths.rewrite(rewriteTargets("entry", nodes, redirect), entryPathRows(nodes, this.byIdMap([...ancestors, ...nodes]), schema, this.locales));
     }
     /** Every field set the site can render: each locale's live view, plus a
      *  published snapshot the draft has moved past (see entryRefEdges). */
@@ -462,7 +463,7 @@ export class SupabaseEntryStore {
         }
         return out;
     }
-    async update(collection, id, locale, fields, by, expected) {
+    async update(collection, id, locale, fields, by, expected, options) {
         const schema = this.schema(collection);
         const before = await this.must(collection, id);
         const row = entryLocaleRow(before, locale);
@@ -480,7 +481,7 @@ export class SupabaseEntryStore {
         await this.updateLocale(id, locale, { slug, fields: localized }, { by });
         const record = await this.must(collection, id);
         try {
-            await this.writePaths(record);
+            await this.writePaths(record, options?.redirect ?? true);
         }
         catch (e) {
             await this.updateNode(id, { fields: before.fields, updated_at: new Date(before.updatedAt).toISOString() }, { touch: false });
@@ -591,7 +592,7 @@ export class SupabaseEntryStore {
         // locale until the next write, never leaked content.
         await this.deleteLocale(id, locale);
         const remaining = await this.must(collection, id);
-        await this.writePaths(remaining);
+        await this.writePaths(remaining, false);
         await this.updateNode(id, {});
         const final = await this.must(collection, id);
         await this.writeRefs(final);
@@ -639,7 +640,7 @@ export class SupabaseEntryStore {
             this.fail(res.error.message);
         return res.data ? toVersion(res.data) : null;
     }
-    async move(collection, id, to) {
+    async move(collection, id, to, options) {
         if (isGlobalSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "it has no tree position");
         const entry = await this.must(collection, id);
@@ -671,7 +672,7 @@ export class SupabaseEntryStore {
             const ordered = siblings.map((s) => s.id);
             ordered.splice(Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length), 0, id);
             await this.reorder(collection, ordered);
-            await this.writePaths(await this.must(collection, id));
+            await this.writePaths(await this.must(collection, id), options?.redirect ?? true);
         }
         catch (e) {
             await this.updateNode(id, { parent_id: entry.parentId, sort: entry.sort }, { touch: false });
@@ -713,6 +714,9 @@ export class SupabaseEntryStore {
     async pathsOf(collection, id) {
         return (await this.fetch(collection, id)) ? this.paths.pathsOf({ kind: "entry", id }) : {};
     }
+    async redirectsOf(collection, id) {
+        return (await this.fetch(collection, id)) ? groupRedirects(await this.paths.redirectsOf({ kind: "entry", id })) : {};
+    }
     async reorder(collection, orderedIds) {
         if (isGlobalSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "it has no order");

package/dist/supabase-path-index.d.ts

@@ -1,11 +1,18 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { type PathIndex, type PathRow, type PathTarget } from "./path-index.ts";
+import { type PathHit, type PathIndex, type PathRow, type PathTarget, type RewriteTarget } from "./path-index.ts";
 export declare class SupabasePathIndex implements PathIndex {
     private db;
     constructor(db: SupabaseClient);
     private fail;
-    rewrite(targets: PathTarget[], rows: PathRow[]): Promise<void>;
+    rewrite(targets: RewriteTarget[], rows: PathRow[]): Promise<void>;
     remove(targets: PathTarget[]): Promise<void>;
-    resolve(locale: string, path: string): Promise<PathTarget | null>;
+    resolve(locale: string, path: string): Promise<PathHit | null>;
+    private rowsOf;
+    private rowsIn;
     pathsOf(target: PathTarget): Promise<Record<string, string>>;
+    redirectsOf(target: PathTarget): Promise<PathRow[]>;
+    listLive(locale: string): Promise<PathRow[]>;
+    listRedirects(locale: string): Promise<PathRow[]>;
+    addRedirect(row: PathRow): Promise<void>;
+    removeRedirect(locale: string, path: string): Promise<void>;
 }

package/dist/supabase-path-index.js

@@ -1,5 +1,6 @@
-import { pathTakenError } from "./path-index.js";
+import { pathLiveError, pathTakenError } from "./path-index.js";
 const UNIQUE_VIOLATION = "23505";
+const toRow = (r) => ({ kind: r.kind, id: r.target_id, locale: r.locale, path: r.path });
 export class SupabasePathIndex {
     constructor(db) {
         this.db = db;
@@ -9,7 +10,7 @@ export class SupabasePathIndex {
     }
     async rewrite(targets, rows) {
         const res = await this.db.rpc("smoodly_rewrite_paths", {
-            p_targets: targets.map((t) => ({ kind: t.kind, id: t.id })),
+            p_targets: targets.map((t) => ({ kind: t.kind, id: t.id, ...(t.redirectLocales ? { redirect_locales: [...t.redirectLocales] } : {}) })),
             p_rows: rows.map((r) => ({ locale: r.locale, path: r.path, kind: r.kind, id: r.id })),
         });
         if (res.error) {
@@ -22,31 +23,63 @@ export class SupabasePathIndex {
         }
     }
     async remove(targets) {
-        await this.rewrite(targets, []);
+        // Every row of the targets, redirects included: a delete on the target index, not the RPC (which spares redirect rows).
+        for (const t of targets) {
+            const res = await this.db.from("paths").delete().eq("kind", t.kind).eq("target_id", t.id);
+            if (res.error)
+                this.fail(res.error.message);
+        }
     }
     async resolve(locale, path) {
-        const res = await this.db
-            .from("paths")
-            .select("kind, target_id")
-            .eq("locale", locale)
-            .eq("path", path)
-            .maybeSingle();
+        const res = await this.db.from("paths").select("kind, target_id, redirect").eq("locale", locale).eq("path", path).maybeSingle();
         if (res.error)
             this.fail(res.error.message);
         const row = res.data;
-        return row ? { kind: row.kind, id: row.target_id } : null;
+        return row ? { kind: row.kind, id: row.target_id, redirect: row.redirect } : null;
     }
-    async pathsOf(target) {
-        const res = await this.db
-            .from("paths")
-            .select("locale, path")
-            .eq("kind", target.kind)
-            .eq("target_id", target.id);
+    async rowsOf(target, redirect) {
+        const res = await this.db.from("paths").select("locale, path, kind, target_id").eq("kind", target.kind).eq("target_id", target.id).eq("redirect", redirect);
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.map(toRow);
+    }
+    async rowsIn(locale, redirect) {
+        const res = await this.db.from("paths").select("locale, path, kind, target_id").eq("locale", locale).eq("redirect", redirect).order("path");
         if (res.error)
             this.fail(res.error.message);
+        return res.data.map(toRow);
+    }
+    async pathsOf(target) {
         const out = {};
-        for (const r of res.data)
+        for (const r of await this.rowsOf(target, false))
             out[r.locale] = r.path;
         return out;
     }
+    redirectsOf(target) {
+        return this.rowsOf(target, true);
+    }
+    listLive(locale) {
+        return this.rowsIn(locale, false);
+    }
+    listRedirects(locale) {
+        return this.rowsIn(locale, true);
+    }
+    async addRedirect(row) {
+        const existing = await this.resolve(row.locale, row.path);
+        if (existing && !existing.redirect)
+            throw pathLiveError(row.locale, row.path);
+        if (existing)
+            await this.removeRedirect(row.locale, row.path);
+        const res = await this.db.from("paths").insert({ locale: row.locale, path: row.path, kind: row.kind, target_id: row.id, redirect: true });
+        if (res.error) {
+            if (res.error.code === UNIQUE_VIOLATION)
+                throw pathLiveError(row.locale, row.path);
+            this.fail(res.error.message);
+        }
+    }
+    async removeRedirect(locale, path) {
+        const res = await this.db.from("paths").delete().eq("locale", locale).eq("path", path).eq("redirect", true);
+        if (res.error)
+            this.fail(res.error.message);
+    }
 }

package/dist/supabase-store.d.ts

@@ -1,6 +1,7 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 import { type AddLocaleOptions, type CreatePageInput, type PageRecord, type PageStore, type PageStoreOptions, type PageVersion } from "./store.ts";
 import type { PageTree } from "./render.tsx";
+import type { PathRow } from "./path-index.ts";
 import { type DraftToken } from "./draft-token.ts";
 import { type PathTarget } from "./paths.ts";
 export declare class SupabasePageStore implements PageStore {
@@ -60,19 +61,29 @@ export declare class SupabasePageStore implements PageStore {
     listPages(): Promise<PageRecord[]>;
     /** The site's one warning per process (spec 2026-09-26 §5): fired by the first locate, never blocking. */
     private schemaChecked;
-    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    resolvePath(locale: string, path: string): Promise<import("./path-index.ts").PathHit | null>;
     schemaVersion(): Promise<number | null>;
     pathsOf(id: string): Promise<{}>;
+    targetPaths(target: PathTarget): Promise<Record<string, string>>;
+    redirectsOf(id: string): Promise<Record<string, string[]>>;
+    listLive(locale: string): Promise<PathRow[]>;
+    listRedirects(locale: string): Promise<PathRow[]>;
+    addRedirect(row: PathRow): Promise<void>;
+    removeRedirect(locale: string, path: string): Promise<void>;
     addLocale(id: string, locale: string, options: AddLocaleOptions, by?: string): Promise<PageRecord>;
     removeLocale(id: string, locale: string): Promise<PageRecord>;
     rename(id: string, patch: {
         locale: string;
         slug?: string;
         title?: string;
-    }, by?: string): Promise<PageRecord>;
+    }, by?: string, options?: {
+        redirect?: boolean;
+    }): Promise<PageRecord>;
     move(id: string, to: {
         parentId: string | null;
         index?: number;
+    }, options?: {
+        redirect?: boolean;
     }): Promise<PageRecord>;
     setTemplate(id: string, template: string, by?: string): Promise<PageRecord>;
     saveDraft(id: string, locale: string, tree: PageTree, by?: string, expected?: DraftToken | null): Promise<PageVersion>;

package/dist/supabase-store.js

@@ -9,8 +9,9 @@
 import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, refSections, } from "./store.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
 import { SCHEMA_VERSION_KEY, schemaBehind, schemaBehindMessage } from "./schema-version.js";
+import { groupRedirects } from "./store.js";
 import { assertFresh, draftToken, StaleDraftError } from "./draft-token.js";
-import { assertDepth, assertSegment, isHomeNode, pagePathRows } from "./paths.js";
+import { assertDepth, assertSegment, isHomeNode, pagePathRows, rewriteTargets } from "./paths.js";
 const SELECT = "*, page_locales(*, draft:page_versions!page_locales_draft_version_fkey(saved_at))";
 const UNIQUE_VIOLATION = "23505";
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
@@ -121,11 +122,11 @@ export class SupabasePageStore {
     }
     /** Rewrite path rows for a subtree: ancestors are loaded once so the
      *  chain lookup is a map, then ONE RPC replaces every target's rows. */
-    async writePaths(top) {
+    async writePaths(top, redirect = true) {
         const ancestors = await this.chain(top);
         const nodes = await this.subtree(top);
         const byId = new Map([...ancestors, ...nodes].map((n) => [n.id, n]));
-        await this.paths.rewrite(nodes.map((n) => ({ kind: "page", id: n.id })), pagePathRows(nodes, (id) => byId.get(id), this.opts));
+        await this.paths.rewrite(rewriteTargets("page", nodes, redirect), pagePathRows(nodes, (id) => byId.get(id), this.opts));
     }
     /** `touch` defaults to true (the normal edit path bumps updated_at).
      *  A rollback restoring prior column values passes `{ touch: false }`,
@@ -358,6 +359,12 @@ export class SupabasePageStore {
     pathsOf(id) {
         return UUID_RE.test(id) ? this.paths.pathsOf({ kind: "page", id }) : Promise.resolve({});
     }
+    targetPaths(target) { return this.paths.pathsOf(target); }
+    async redirectsOf(id) { return UUID_RE.test(id) ? groupRedirects(await this.paths.redirectsOf({ kind: "page", id })) : {}; }
+    listLive(locale) { return this.paths.listLive(locale); }
+    listRedirects(locale) { return this.paths.listRedirects(locale); }
+    addRedirect(row) { return this.paths.addRedirect(row); }
+    removeRedirect(locale, path) { return this.paths.removeRedirect(locale, path); }
     async addLocale(id, locale, options, by) {
         assertSupportedLocale(locale, this.opts.locales);
         const page = await this.must(id);
@@ -403,11 +410,11 @@ export class SupabasePageStore {
         // content — until the next write of this node fixes it.
         await this.deleteLocale(id, locale);
         const remaining = await this.must(id);
-        await this.writePaths(remaining);
+        await this.writePaths(remaining, false);
         await this.writeRefs(remaining);
         return remaining;
     }
-    async rename(id, patch, by) {
+    async rename(id, patch, by, options) {
         const page = await this.must(id);
         const row = localeRow(page, patch.locale);
         if (patch.slug !== undefined)
@@ -431,7 +438,7 @@ export class SupabasePageStore {
             columns.title = patch.title;
         const renamed = await this.updateLocale(id, patch.locale, columns, { by });
         try {
-            await this.writePaths(renamed);
+            await this.writePaths(renamed, options?.redirect ?? true);
         }
         catch (e) {
             // The audit pair goes back too: a rejected rename is not an edit.
@@ -440,7 +447,7 @@ export class SupabasePageStore {
         }
         return renamed;
     }
-    async move(id, to) {
+    async move(id, to, options) {
         const page = await this.must(id);
         const subtree = await this.subtree(page);
         if (to.parentId !== null) {
@@ -485,7 +492,7 @@ export class SupabasePageStore {
         ordered.splice(index, 0, id);
         try {
             await this.reorder(ordered);
-            await this.writePaths(moved);
+            await this.writePaths(moved, options?.redirect ?? true);
         }
         catch (e) {
             await this.updateNode(id, { parent_id: page.parentId, sort: page.sort }, { touch: false });

package/migrations/20260926150000_smoodly_v4.sql

@@ -0,0 +1,41 @@
+-- Smoodly core schema, version 4 (docs/superpowers/specs/2026-09-26-redirects-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 3: a `redirect` flag on the paths index — a row
+-- with it set is an old address of its target — and the rewrite function
+-- keeps the published old rows as redirects when a target names their
+-- locales. The read policy is unchanged: a redirect row is visible when
+-- its target is published in that locale.
+
+set client_min_messages = warning;
+
+alter table "paths" add column if not exists "redirect" boolean not null default false;
+
+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, path text, kind text, id uuid)
+  where p."redirect" and p."locale" = r.locale and p."path" = r.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, path text, kind text, id uuid)
+                    where r.locale = p."locale" and r.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, 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", "path", "kind", "target_id")
+  select r.locale, r.path, r.kind, r.id
+  from jsonb_to_recordset(p_rows) as r(locale text, path text, kind text, id uuid);
+$$;
+
+alter function "smoodly_rewrite_paths"(jsonb, jsonb) set search_path = public;
+revoke execute on function "smoodly_rewrite_paths"(jsonb, jsonb) from public, anon;
+
+insert into "smoodly_meta" ("key", "value") values ('schema_version', '4')
+  on conflict ("key") do update set "value" = excluded."value";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.27",
+  "version": "0.0.28",
   "description": "Open-source, code-first CMS for Next.js on Supabase: define a component once, it becomes a typed, editable building block.",
   "license": "MIT",
   "repository": {