smoodly 0.0.4 → 0.0.6

package/dist/supabase-store.js

@@ -1,16 +1,25 @@
 // The Supabase adapter for the PageStore contract, over pages +
-// page_versions. Server-side only, service-role client — writes bypass
-// RLS by design because they flow through Smoodly's API (DESIGN.md §1).
-// No FK links pages' version pointers to page_versions (they'd be
-// circular), so tree reads are two indexed lookups, not embeds.
-import { assertPublishable, pageRefEdges } from "./store.js";
+// page_versions + paths. Server-side only (the service role in self-host,
+// a write key in the cloud); writes flow through Smoodly's API by design
+// (DESIGN.md §1). No FK links pages' version pointers to page_versions
+// (they'd be circular), so tree reads are two indexed lookups. Path rows
+// are rewritten through ONE RPC per write, so a collision rolls back.
+import { assertPageI18n, assertPublishable, pageErrors, pageRefEdges, pathOptions, } from "./store.js";
+import { SupabasePathIndex } from "./supabase-path-index.js";
+import { assertDepth, assertSegment, pagePathRows } from "./paths.js";
 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;
 function toRecord(row) {
     return {
         id: row.id,
+        parentId: row.parent_id,
         slug: row.slug,
+        title: row.title,
+        i18n: row.i18n,
         template: row.template,
         status: row.status,
+        sort: row.sort === null ? null : Number(row.sort),
+        locales: row.locales,
         draftVersionId: row.draft_version_id,
         publishedVersionId: row.published_version_id,
     };
@@ -22,159 +31,362 @@ export class SupabasePageStore {
     constructor(db, options = {}) {
         this.db = db;
         this.options = options;
+        this.paths = options.paths ?? new SupabasePathIndex(db);
+        this.opts = pathOptions(options);
+    }
+    fail(message) {
+        throw new Error(`smoodly: ${message}`);
+    }
+    // Callers always pass a PageRecord (camelCase), never a raw row.
+    isHome(page) {
+        return page.parentId === null && page.slug === this.opts.homePageSlug;
+    }
+    // ── rows ──
+    async row(id) {
+        if (!UUID_RE.test(id))
+            return null;
+        const res = await this.db.from("pages").select("*").eq("id", id).maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data ? toRecord(res.data) : null;
+    }
+    async must(id) {
+        const page = await this.row(id);
+        if (!page)
+            throw pageErrors.notFound(id);
+        return page;
+    }
+    /** A one-row existence check — the shape `deletePage` needs too. */
+    async hasChildren(id) {
+        const res = await this.db.from("pages").select("id").eq("parent_id", id).limit(1);
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.length > 0;
+    }
+    async siblings(parentId, except) {
+        let query = this.db.from("pages").select("*");
+        query = parentId === null ? query.is("parent_id", null) : query.eq("parent_id", parentId);
+        const res = await query
+            .order("sort", { ascending: true, nullsFirst: false })
+            .order("created_at", { ascending: true })
+            .order("id", { ascending: true });
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.map(toRecord).filter((p) => p.id !== except);
+    }
+    /** The node's ancestors (root first, node last), by walking parent_id. */
+    async chain(page) {
+        const chain = [page];
+        let current = page;
+        while (current.parentId !== null) {
+            const parent = await this.row(current.parentId);
+            if (!parent)
+                this.fail(`broken parent chain at "${page.id}".`);
+            chain.unshift(parent);
+            current = parent;
+        }
+        return chain;
+    }
+    /** The node and every descendant, breadth-first. */
+    async subtree(page) {
+        const out = [page];
+        let frontier = [page.id];
+        while (frontier.length > 0) {
+            const res = await this.db.from("pages").select("*").in("parent_id", frontier);
+            if (res.error)
+                this.fail(res.error.message);
+            const rows = res.data.map(toRecord);
+            out.push(...rows);
+            frontier = rows.map((r) => r.id);
+        }
+        return out;
+    }
+    /** 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) {
+        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));
+    }
+    /** `touch` defaults to true (the normal edit path bumps updated_at).
+     *  A rollback restoring prior column values passes `{ touch: false }`,
+     *  which omits updated_at entirely — undoing a write is not an edit
+     *  (same pattern as SupabaseEntryStore's `patch`). */
+    async update(id, patch, options = {}) {
+        const payload = (options.touch ?? true) ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
+        const res = await this.db
+            .from("pages")
+            .update(payload)
+            .eq("id", id)
+            .select("*")
+            .single();
+        if (res.error) {
+            if (res.error.code === UNIQUE_VIOLATION)
+                throw pageErrors.slugTaken(String(patch.slug ?? ""));
+            this.fail(res.error.message);
+        }
+        return toRecord(res.data);
+    }
+    async insertVersion(pageId, tree) {
+        const res = await this.db.from("page_versions").insert({ page_id: pageId, tree }).select("*").single();
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data;
+    }
+    async versionTree(versionId) {
+        if (!versionId)
+            return null;
+        const res = await this.db.from("page_versions").select("tree").eq("id", versionId).maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data?.tree ?? null;
     }
     async writeRefs(pageId, edges) {
-        const deleted = await this.db
-            .from("refs")
-            .delete()
-            .eq("source_kind", "page")
-            .eq("source_id", pageId);
+        const deleted = await this.db.from("refs").delete().eq("source_kind", "page").eq("source_id", pageId);
         if (deleted.error)
-            throw new Error(`smoodly: ${deleted.error.message}`);
-        // dedupe: the refs PK is (source_kind, source_id, source_field, target_id)
+            this.fail(deleted.error.message);
         const rows = new Map();
         for (const edge of edges) {
             rows.set(`${edge.field} ${edge.targetId}`, {
-                source_kind: "page",
-                source_id: pageId,
-                source_field: edge.field,
-                target_collection: edge.targetCollection,
-                target_id: edge.targetId,
+                source_kind: "page", source_id: pageId, source_field: edge.field,
+                target_collection: edge.targetCollection, target_id: edge.targetId,
             });
         }
         if (rows.size > 0) {
             const inserted = await this.db.from("refs").insert([...rows.values()]);
             if (inserted.error)
-                throw new Error(`smoodly: ${inserted.error.message}`);
+                this.fail(inserted.error.message);
         }
     }
-    async pageRow(slug) {
-        const res = await this.db.from("pages").select("*").eq("slug", slug).maybeSingle();
+    async reorder(ids) {
+        if (ids.length === 0)
+            return;
+        const res = await this.db.rpc("smoodly_reorder_pages", { p_ids: ids });
         if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return res.data ?? null;
+            this.fail(res.error.message);
     }
-    async insertVersion(pageId, tree) {
-        const res = await this.db
-            .from("page_versions")
-            .insert({ page_id: pageId, tree })
+    async hardDelete(id) {
+        for (const [table, col] of [["refs", "source_id"], ["page_versions", "page_id"], ["pages", "id"]]) {
+            const res = table === "refs"
+                ? await this.db.from(table).delete().eq("source_kind", "page").eq(col, id)
+                : await this.db.from(table).delete().eq(col, id);
+            if (res.error)
+                this.fail(res.error.message);
+        }
+    }
+    // ── contract ──
+    async createPage(input) {
+        assertSegment(input.slug, "page slug");
+        assertPageI18n(input.i18n);
+        const parentId = input.parentId ?? null;
+        if (parentId !== null) {
+            const parent = await this.must(parentId);
+            if (this.isHome(parent))
+                throw pageErrors.homeChildren();
+            assertDepth((await this.chain(parent)).length + 1, this.opts.depth, "the page");
+        }
+        const siblings = await this.siblings(parentId);
+        const inserted = await this.db
+            .from("pages")
+            .insert({
+            parent_id: parentId,
+            slug: input.slug,
+            title: input.title ?? input.slug,
+            i18n: input.i18n ?? null,
+            template: input.template,
+            sort: siblings.length + 1,
+            locales: input.locales ?? null,
+        })
             .select("*")
             .single();
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return res.data;
+        if (inserted.error) {
+            if (inserted.error.code === UNIQUE_VIOLATION)
+                throw pageErrors.slugTaken(input.slug);
+            this.fail(inserted.error.message);
+        }
+        let page = toRecord(inserted.data);
+        try {
+            if (input.template !== null) {
+                const version = await this.insertVersion(page.id, { zones: {} });
+                page = await this.update(page.id, { draft_version_id: version.id });
+            }
+            await this.writePaths(page);
+        }
+        catch (e) {
+            await this.hardDelete(page.id);
+            throw e;
+        }
+        return page;
+    }
+    getPage(id) {
+        return this.row(id);
     }
-    async setPointers(id, patch) {
+    async listPages() {
         const res = await this.db
             .from("pages")
-            .update({ ...patch, updated_at: new Date().toISOString() })
-            .eq("id", id)
             .select("*")
-            .single();
+            .order("sort", { ascending: true, nullsFirst: false })
+            .order("created_at", { ascending: true })
+            .order("id", { ascending: true });
         if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return res.data;
+            this.fail(res.error.message);
+        return res.data.map(toRecord);
     }
-    async createPage({ slug, template }) {
-        const inserted = await this.db.from("pages").insert({ slug, template }).select("*").single();
-        if (inserted.error) {
-            if (inserted.error.code === UNIQUE_VIOLATION)
-                throw new Error(`smoodly: a page with slug "${slug}" already exists.`);
-            throw new Error(`smoodly: ${inserted.error.message}`);
+    resolvePath(locale, path) {
+        return this.paths.resolve(locale, path);
+    }
+    pathsOf(id) {
+        return UUID_RE.test(id) ? this.paths.pathsOf({ kind: "page", id }) : Promise.resolve({});
+    }
+    async rename(id, patch) {
+        const page = await this.must(id);
+        if (patch.slug !== undefined)
+            assertSegment(patch.slug, `page slug (${patch.locale})`);
+        // A rename that turns this node INTO the home node (root, default-locale
+        // slug === homePageSlug) is subject to the same invariant as createPage:
+        // the home page cannot have child pages.
+        if (patch.locale === this.opts.locales.default &&
+            patch.slug !== undefined &&
+            page.parentId === null &&
+            patch.slug === this.opts.homePageSlug &&
+            (await this.hasChildren(id))) {
+            throw pageErrors.homeChildren();
         }
-        const page = inserted.data;
-        const version = await this.insertVersion(page.id, { zones: {} });
-        return toRecord(await this.setPointers(page.id, { draft_version_id: version.id }));
+        const columns = {};
+        if (patch.locale === this.opts.locales.default) {
+            if (patch.slug !== undefined)
+                columns.slug = patch.slug;
+            if (patch.title !== undefined)
+                columns.title = patch.title;
+        }
+        else {
+            const i18n = { ...(page.i18n ?? {}) };
+            i18n[patch.locale] = {
+                ...(i18n[patch.locale] ?? {}),
+                ...(patch.slug !== undefined ? { slug: patch.slug } : {}),
+                ...(patch.title !== undefined ? { title: patch.title } : {}),
+            };
+            columns.i18n = i18n;
+        }
+        const renamed = await this.update(id, columns);
+        try {
+            await this.writePaths(renamed);
+        }
+        catch (e) {
+            await this.update(id, { slug: page.slug, title: page.title, i18n: page.i18n }, { touch: false });
+            throw e;
+        }
+        return renamed;
     }
-    async getPage(slug) {
-        const row = await this.pageRow(slug);
-        return row ? toRecord(row) : null;
+    async move(id, to) {
+        const page = await this.must(id);
+        const subtree = await this.subtree(page);
+        if (to.parentId !== null) {
+            if (to.parentId === id || subtree.some((n) => n.id === to.parentId))
+                throw pageErrors.cycle();
+            const parent = await this.must(to.parentId);
+            if (this.isHome(parent))
+                throw pageErrors.homeChildren();
+            const byId = new Map(subtree.map((n) => [n.id, n]));
+            // The subtree's own height: walk each node up to the moved node
+            // itself (not to the tree root — its parentId points OUTSIDE this
+            // subtree map, at its current, pre-move parent, so chainOf would
+            // throw "broken parent chain" there instead of stopping).
+            const heightOf = (n) => (n.id === page.id ? 1 : 1 + heightOf(byId.get(n.parentId)));
+            const height = Math.max(...subtree.map(heightOf));
+            assertDepth((await this.chain(parent)).length + height, this.opts.depth, "the page");
+        }
+        else if (page.slug === this.opts.homePageSlug && (await this.hasChildren(id))) {
+            // Moving a home-slugged node TO the root is the mirror case of the
+            // rename guard above: it would make it the home node while it still
+            // has children.
+            throw pageErrors.homeChildren();
+        }
+        const siblings = await this.siblings(to.parentId, id);
+        if (to.parentId !== page.parentId && siblings.some((s) => s.slug === page.slug))
+            throw pageErrors.slugTaken(page.slug);
+        // The destination siblings' sorts as they stood BEFORE the reorder.
+        // A rollback restores these exact values rather than re-running the
+        // reorder RPC, which renumbers 1..N and would silently close gaps
+        // left by earlier deletes and moves.
+        const previousSorts = siblings.map((s) => ({ id: s.id, sort: s.sort }));
+        const moved = await this.update(id, { parent_id: to.parentId });
+        const index = Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length);
+        const ordered = siblings.map((s) => s.id);
+        ordered.splice(index, 0, id);
+        await this.reorder(ordered);
+        try {
+            await this.writePaths(moved);
+        }
+        catch (e) {
+            await this.update(id, { parent_id: page.parentId, sort: page.sort }, { touch: false });
+            for (const s of previousSorts)
+                await this.update(s.id, { sort: s.sort }, { touch: false });
+            throw e;
+        }
+        return { ...moved, sort: index + 1 };
     }
-    async getPageById(id) {
-        const res = await this.db.from("pages").select("*").eq("id", id).maybeSingle();
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return res.data ? toRecord(res.data) : null;
+    async setTemplate(id, template) {
+        const page = await this.must(id);
+        if (page.template !== null)
+            throw pageErrors.hasTemplate(id);
+        const version = await this.insertVersion(id, { zones: {} });
+        return this.update(id, { template, draft_version_id: version.id });
     }
-    async saveDraft(slug, tree) {
-        const page = await this.pageRow(slug);
-        if (!page)
-            throw new Error(`smoodly: no page with slug "${slug}".`);
-        const version = await this.insertVersion(page.id, tree);
-        await this.setPointers(page.id, { draft_version_id: version.id });
+    async saveDraft(id, tree) {
+        const page = await this.must(id);
+        if (page.template === null)
+            throw pageErrors.folder(id);
+        const version = await this.insertVersion(id, tree);
+        await this.update(id, { draft_version_id: version.id });
         if (this.options.sections) {
-            const published = await this.versionTree(page.published_version_id);
-            await this.writeRefs(page.id, pageRefEdges(tree, published, this.options.sections));
+            const published = await this.versionTree(page.publishedVersionId);
+            await this.writeRefs(id, pageRefEdges(tree, published, this.options.sections));
         }
         return toVersion(version);
     }
-    async publish(slug) {
-        const page = await this.pageRow(slug);
-        if (!page)
-            throw new Error(`smoodly: no page with slug "${slug}".`);
+    async publish(id) {
+        const page = await this.must(id);
+        if (page.template === null || !page.draftVersionId)
+            throw pageErrors.folder(id);
         const { sections, entries } = this.options;
-        const draft = (await this.versionTree(page.draft_version_id)) ?? { zones: {} };
+        const draft = (await this.versionTree(page.draftVersionId)) ?? { zones: {} };
         if (sections && entries)
-            await assertPublishable(slug, draft, sections, entries);
-        const record = toRecord(await this.setPointers(page.id, {
-            published_version_id: page.draft_version_id,
-            status: "published",
-        }));
-        // draft IS published now — one tree
+            await assertPublishable(page.slug, draft, sections, entries);
+        const record = await this.update(id, { published_version_id: page.draftVersionId, status: "published" });
         if (sections)
-            await this.writeRefs(page.id, pageRefEdges(draft, null, sections));
+            await this.writeRefs(id, pageRefEdges(draft, null, sections));
         return record;
     }
-    async versionTree(versionId) {
-        if (!versionId)
-            return null;
-        const res = await this.db.from("page_versions").select("tree").eq("id", versionId).maybeSingle();
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return res.data?.tree ?? null;
-    }
-    async getDraftTree(slug) {
-        const page = await this.pageRow(slug);
-        return page ? this.versionTree(page.draft_version_id) : null;
+    async getDraftTree(id) {
+        const page = await this.row(id);
+        return page ? this.versionTree(page.draftVersionId) : null;
     }
-    async getPublishedTree(slug) {
-        const page = await this.pageRow(slug);
-        return page ? this.versionTree(page.published_version_id) : null;
+    async getPublishedTree(id) {
+        const page = await this.row(id);
+        return page ? this.versionTree(page.publishedVersionId) : null;
     }
-    async listVersions(slug) {
-        const page = await this.pageRow(slug);
-        if (!page)
+    async listVersions(id) {
+        if (!UUID_RE.test(id))
             return [];
         const res = await this.db
             .from("page_versions")
             .select("*")
-            .eq("page_id", page.id)
+            .eq("page_id", id)
             .order("created_at", { ascending: false })
             .order("id", { ascending: false });
         if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
+            this.fail(res.error.message);
         return res.data.map(toVersion);
     }
-    async listPages() {
-        const res = await this.db.from("pages").select("*").order("slug", { ascending: true });
-        if (res.error)
-            throw new Error(`smoodly: ${res.error.message}`);
-        return res.data.map(toRecord);
-    }
-    async deletePage(slug) {
-        const page = await this.pageRow(slug);
+    async deletePage(id) {
+        const page = await this.row(id);
         if (!page)
             return;
-        for (const [table, col, val] of [
-            ["refs", "source_id", page.id],
-            ["page_versions", "page_id", page.id],
-            ["pages", "id", page.id],
-        ]) {
-            const res = table === "refs"
-                ? await this.db.from(table).delete().eq("source_kind", "page").eq(col, val)
-                : await this.db.from(table).delete().eq(col, val);
-            if (res.error)
-                throw new Error(`smoodly: ${res.error.message}`);
-        }
+        if (await this.hasChildren(id))
+            throw pageErrors.hasChildren(id);
+        await this.paths.remove([{ kind: "page", id }]);
+        await this.hardDelete(id);
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "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": {
@@ -45,8 +45,8 @@
     "test:supabase": "bash scripts/test-supabase.sh"
   },
   "peerDependencies": {
-    "react": "^18 || ^19",
-    "next": ">=15"
+    "next": ">=16",
+    "react": "^18 || ^19"
   },
   "peerDependenciesMeta": {
     "next": {
@@ -64,6 +64,7 @@
     "vitest": "^3"
   },
   "dependencies": {
-    "@supabase/supabase-js": "^2.113.0"
+    "@supabase/supabase-js": "^2.113.0",
+    "lucide-react": "^1.41.0"
   }
 }

package/dist/admin/page-path.d.ts

@@ -1 +0,0 @@
-export declare function pagePath(slug: string, homePageSlug: string): string;

package/dist/admin/page-path.js

@@ -1,6 +0,0 @@
-// The one place the admin turns a page slug into the site URL that serves
-// it. The root's slug is config (`homePageSlug`), not a convention the
-// package guesses at; a registration-declared path is the logged follow-up.
-export function pagePath(slug, homePageSlug) {
-    return slug === homePageSlug ? "/" : `/${slug}`;
-}

package/dist/admin/shell/pages-list.d.ts

@@ -1,22 +0,0 @@
-import type { PageRecord } from "../../store.ts";
-import type { AdminPageTemplate } from "../serialize.ts";
-/** Registrations editors may create pages against. A fixed-slug
- * registration is a singleton owned by one route file, so it is never
- * offered — and with exactly one open template left, the New Page flow
- * needs no template prompt at all. */
-export declare function openTemplates(templates: AdminPageTemplate[]): AdminPageTemplate[];
-export type PagesRow = {
-    kind: "record";
-    record: PageRecord;
-    templateTitle: string;
-    fixed: boolean;
-} | {
-    kind: "missing";
-    slug: string;
-    template: string;
-    templateTitle: string;
-};
-/** Fixed registrations always get a row, even before their record
- * exists: otherwise a fresh install's "/" is a 404 the admin offers no
- * way to fix, since New Page filters singletons out. */
-export declare function pagesRows(records: PageRecord[], templates: AdminPageTemplate[]): PagesRow[];

package/dist/admin/shell/pages-list.js

@@ -1,31 +0,0 @@
-/** Registrations editors may create pages against. A fixed-slug
- * registration is a singleton owned by one route file, so it is never
- * offered — and with exactly one open template left, the New Page flow
- * needs no template prompt at all. */
-export function openTemplates(templates) {
-    return templates.filter((t) => t.slug === undefined);
-}
-/** Fixed registrations always get a row, even before their record
- * exists: otherwise a fresh install's "/" is a 404 the admin offers no
- * way to fix, since New Page filters singletons out. */
-export function pagesRows(records, templates) {
-    const titleOf = (name) => templates.find((t) => t.name === name)?.title ?? name;
-    const bySlug = new Map(records.map((r) => [r.slug, r]));
-    const fixedSlugs = new Set();
-    const rows = [];
-    for (const t of templates) {
-        if (t.slug === undefined)
-            continue;
-        fixedSlugs.add(t.slug);
-        const record = bySlug.get(t.slug);
-        rows.push(record
-            ? { kind: "record", record, templateTitle: titleOf(record.template), fixed: true }
-            : { kind: "missing", slug: t.slug, template: t.name, templateTitle: t.title });
-    }
-    for (const record of records) {
-        if (fixedSlugs.has(record.slug))
-            continue;
-        rows.push({ kind: "record", record, templateTitle: titleOf(record.template), fixed: false });
-    }
-    return rows;
-}