smoodly 0.0.6 → 0.0.7

package/dist/supabase-store.d.ts

@@ -1,5 +1,5 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { type CreatePageInput, type PageRecord, type PageStore, type PageStoreOptions, type PageVersion } from "./store.ts";
+import { type AddLocaleOptions, type CreatePageInput, type PageRecord, type PageStore, type PageStoreOptions, type PageVersion } from "./store.ts";
 import type { PageTree } from "./render.tsx";
 import { type PathTarget } from "./paths.ts";
 export declare class SupabasePageStore implements PageStore {
@@ -15,6 +15,7 @@ export declare class SupabasePageStore implements PageStore {
     /** A one-row existence check — the shape `deletePage` needs too. */
     private hasChildren;
     private siblings;
+    private assertSlugFree;
     /** The node's ancestors (root first, node last), by walking parent_id. */
     private chain;
     /** The node and every descendant, breadth-first. */
@@ -24,19 +25,30 @@ export declare class SupabasePageStore implements PageStore {
     private writePaths;
     /** `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`). */
-    private update;
+     *  which omits updated_at entirely — undoing a write is not an edit. */
+    private updateNode;
+    private updateLocale;
+    private insertLocale;
+    /** The locale's row and versions — the removeLocale and rollback shape.
+     *  The row goes first: it is what makes the page exist in that locale,
+     *  so a failure between the two statements leaves no locale row
+     *  pointing at an already-deleted version. */
+    private deleteLocale;
     private insertVersion;
     private versionTree;
+    /** Every locale's draft and published trees in ONE query. */
+    private liveTrees;
     private writeRefs;
     private reorder;
+    /** page_locales and page_versions cascade from pages; refs do not. */
     private hardDelete;
     createPage(input: CreatePageInput): Promise<PageRecord>;
     getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
     resolvePath(locale: string, path: string): Promise<PathTarget | null>;
     pathsOf(id: string): Promise<{}>;
+    addLocale(id: string, locale: string, options: AddLocaleOptions): Promise<PageRecord>;
+    removeLocale(id: string, locale: string): Promise<PageRecord>;
     rename(id: string, patch: {
         locale: string;
         slug?: string;
@@ -47,10 +59,10 @@ export declare class SupabasePageStore implements PageStore {
         index?: number;
     }): Promise<PageRecord>;
     setTemplate(id: string, template: string): Promise<PageRecord>;
-    saveDraft(id: string, tree: PageTree): Promise<PageVersion>;
-    publish(id: string): Promise<PageRecord>;
-    getDraftTree(id: string): Promise<PageTree | null>;
-    getPublishedTree(id: string): Promise<PageTree | null>;
-    listVersions(id: string): Promise<PageVersion[]>;
+    saveDraft(id: string, locale: string, tree: PageTree): Promise<PageVersion>;
+    publish(id: string, locale: string): Promise<PageRecord>;
+    getDraftTree(id: string, locale: string): Promise<PageTree | null>;
+    getPublishedTree(id: string, locale: string): Promise<PageTree | null>;
+    listVersions(id: string, locale: string): Promise<PageVersion[]>;
     deletePage(id: string): Promise<void>;
 }

package/dist/supabase-store.js

@@ -1,31 +1,38 @@
 // The Supabase adapter for the PageStore contract, over pages +
-// 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";
+// page_locales + 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 the locale rows'
+// version pointers to page_versions (they'd be circular), so tree reads
+// are two indexed lookups. Every read embeds the locale rows
+// (`*, page_locales(*)`) so a record arrives whole. Path rows are
+// rewritten through ONE RPC per write, so a collision rolls back.
+import { assertPublishable, assertSupportedLocale, localeRow, pageErrors, pageRefEdges, pathOptions, } from "./store.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
-import { assertDepth, assertSegment, pagePathRows } from "./paths.js";
+import { assertDepth, assertSegment, isHomeNode, pagePathRows } from "./paths.js";
+const SELECT = "*, page_locales(*)";
 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) {
+    const locales = {};
+    for (const l of row.page_locales ?? []) {
+        locales[l.locale] = {
+            slug: l.slug,
+            title: l.title,
+            status: l.status,
+            draftVersionId: l.draft_version_id,
+            publishedVersionId: l.published_version_id,
+        };
+    }
     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,
+        locales,
     };
 }
 function toVersion(row) {
-    return { id: row.id, pageId: row.page_id, tree: row.tree, createdAt: Date.parse(row.created_at) };
+    return { id: row.id, pageId: row.page_id, locale: row.locale, tree: row.tree, createdAt: Date.parse(row.created_at) };
 }
 export class SupabasePageStore {
     constructor(db, options = {}) {
@@ -37,15 +44,14 @@ export class SupabasePageStore {
     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;
+        return isHomeNode(page, this.opts);
     }
     // ── rows ──
     async row(id) {
         if (!UUID_RE.test(id))
             return null;
-        const res = await this.db.from("pages").select("*").eq("id", id).maybeSingle();
+        const res = await this.db.from("pages").select(SELECT).eq("id", id).maybeSingle();
         if (res.error)
             this.fail(res.error.message);
         return res.data ? toRecord(res.data) : null;
@@ -64,7 +70,7 @@ export class SupabasePageStore {
         return res.data.length > 0;
     }
     async siblings(parentId, except) {
-        let query = this.db.from("pages").select("*");
+        let query = this.db.from("pages").select(SELECT);
         query = parentId === null ? query.is("parent_id", null) : query.eq("parent_id", parentId);
         const res = await query
             .order("sort", { ascending: true, nullsFirst: false })
@@ -74,6 +80,10 @@ export class SupabasePageStore {
             this.fail(res.error.message);
         return res.data.map(toRecord).filter((p) => p.id !== except);
     }
+    async assertSlugFree(parentId, locale, slug, except) {
+        if ((await this.siblings(parentId, except)).some((s) => s.locales[locale]?.slug === slug))
+            throw pageErrors.slugTaken(slug);
+    }
     /** The node's ancestors (root first, node last), by walking parent_id. */
     async chain(page) {
         const chain = [page];
@@ -92,7 +102,7 @@ export class SupabasePageStore {
         const out = [page];
         let frontier = [page.id];
         while (frontier.length > 0) {
-            const res = await this.db.from("pages").select("*").in("parent_id", frontier);
+            const res = await this.db.from("pages").select(SELECT).in("parent_id", frontier);
             if (res.error)
                 this.fail(res.error.message);
             const rows = res.data.map(toRecord);
@@ -111,25 +121,43 @@ export class SupabasePageStore {
     }
     /** `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 = {}) {
+     *  which omits updated_at entirely — undoing a write is not an edit. */
+    async updateNode(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();
+        const res = await this.db.from("pages").update(payload).eq("id", id).select(SELECT).single();
+        if (res.error)
+            this.fail(res.error.message);
+        return toRecord(res.data);
+    }
+    async updateLocale(id, locale, patch, options = {}) {
+        const payload = (options.touch ?? true) ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
+        const res = await this.db.from("page_locales").update(payload).eq("page_id", id).eq("locale", locale).select("page_id").single();
+        if (res.error)
+            this.fail(res.error.message);
+        return this.must(id);
+    }
+    async insertLocale(id, locale, values) {
+        const res = await this.db.from("page_locales").insert({ page_id: id, locale, ...values });
         if (res.error) {
             if (res.error.code === UNIQUE_VIOLATION)
-                throw pageErrors.slugTaken(String(patch.slug ?? ""));
+                throw pageErrors.alreadyInLocale(id, locale);
             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();
+    /** The locale's row and versions — the removeLocale and rollback shape.
+     *  The row goes first: it is what makes the page exist in that locale,
+     *  so a failure between the two statements leaves no locale row
+     *  pointing at an already-deleted version. */
+    async deleteLocale(id, locale) {
+        const row = await this.db.from("page_locales").delete().eq("page_id", id).eq("locale", locale);
+        if (row.error)
+            this.fail(row.error.message);
+        const versions = await this.db.from("page_versions").delete().eq("page_id", id).eq("locale", locale);
+        if (versions.error)
+            this.fail(versions.error.message);
+    }
+    async insertVersion(pageId, locale, tree) {
+        const res = await this.db.from("page_versions").insert({ page_id: pageId, locale, tree }).select("*").single();
         if (res.error)
             this.fail(res.error.message);
         return res.data;
@@ -142,14 +170,33 @@ export class SupabasePageStore {
             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);
+    /** Every locale's draft and published trees in ONE query. */
+    async liveTrees(page) {
+        const ids = new Set();
+        for (const row of Object.values(page.locales)) {
+            if (row.draftVersionId)
+                ids.add(row.draftVersionId);
+            if (row.publishedVersionId)
+                ids.add(row.publishedVersionId);
+        }
+        if (ids.size === 0)
+            return [];
+        const res = await this.db.from("page_versions").select("tree").in("id", [...ids]);
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data.map((r) => r.tree);
+    }
+    async writeRefs(page) {
+        if (!this.options.sections)
+            return;
+        const edges = pageRefEdges(await this.liveTrees(page), this.options.sections);
+        const deleted = await this.db.from("refs").delete().eq("source_kind", "page").eq("source_id", page.id);
         if (deleted.error)
             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,
+                source_kind: "page", source_id: page.id, source_field: edge.field,
                 target_collection: edge.targetCollection, target_id: edge.targetId,
             });
         }
@@ -166,58 +213,52 @@ export class SupabasePageStore {
         if (res.error)
             this.fail(res.error.message);
     }
+    /** page_locales and page_versions cascade from pages; refs do not. */
     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);
-        }
+        const refs = await this.db.from("refs").delete().eq("source_kind", "page").eq("source_id", id);
+        if (refs.error)
+            this.fail(refs.error.message);
+        const page = await this.db.from("pages").delete().eq("id", id);
+        if (page.error)
+            this.fail(page.error.message);
     }
     // ── contract ──
     async createPage(input) {
+        assertSupportedLocale(input.locale, this.opts.locales);
         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();
+            if (!parent.locales[input.locale])
+                throw pageErrors.parentNotInLocale(input.locale);
             assertDepth((await this.chain(parent)).length + 1, this.opts.depth, "the page");
         }
         const siblings = await this.siblings(parentId);
+        if (siblings.some((s) => s.locales[input.locale]?.slug === input.slug))
+            throw pageErrors.slugTaken(input.slug);
         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("*")
+            .insert({ parent_id: parentId, template: input.template, sort: siblings.length + 1 })
+            .select("id")
             .single();
-        if (inserted.error) {
-            if (inserted.error.code === UNIQUE_VIOLATION)
-                throw pageErrors.slugTaken(input.slug);
+        if (inserted.error)
             this.fail(inserted.error.message);
-        }
-        let page = toRecord(inserted.data);
+        const id = inserted.data.id;
         try {
-            if (input.template !== null) {
-                const version = await this.insertVersion(page.id, { zones: {} });
-                page = await this.update(page.id, { draft_version_id: version.id });
-            }
+            const version = input.template === null ? null : await this.insertVersion(id, input.locale, { zones: {} });
+            await this.insertLocale(id, input.locale, {
+                slug: input.slug, title: input.title ?? input.slug, draft_version_id: version?.id ?? null,
+            });
+            const page = await this.must(id);
             await this.writePaths(page);
+            return page;
         }
         catch (e) {
-            await this.hardDelete(page.id);
+            await this.hardDelete(id);
             throw e;
         }
-        return page;
     }
     getPage(id) {
         return this.row(id);
@@ -225,7 +266,7 @@ export class SupabasePageStore {
     async listPages() {
         const res = await this.db
             .from("pages")
-            .select("*")
+            .select(SELECT)
             .order("sort", { ascending: true, nullsFirst: false })
             .order("created_at", { ascending: true })
             .order("id", { ascending: true });
@@ -239,8 +280,56 @@ export class SupabasePageStore {
     pathsOf(id) {
         return UUID_RE.test(id) ? this.paths.pathsOf({ kind: "page", id }) : Promise.resolve({});
     }
+    async addLocale(id, locale, options) {
+        assertSupportedLocale(locale, this.opts.locales);
+        const page = await this.must(id);
+        if (page.locales[locale])
+            throw pageErrors.alreadyInLocale(id, locale);
+        const source = localeRow(page, options.from);
+        const slug = options.slug ?? source.slug;
+        if (options.slug !== undefined)
+            assertSegment(slug, `page slug (${locale})`);
+        if (page.parentId !== null && !(await this.must(page.parentId)).locales[locale])
+            throw pageErrors.parentNotInLocale(locale);
+        await this.assertSlugFree(page.parentId, locale, slug, id);
+        let added;
+        try {
+            // The SOURCE'S DRAFT is the copy (spec §3); a folder has no tree.
+            const version = page.template === null
+                ? null
+                : await this.insertVersion(id, locale, (await this.versionTree(source.draftVersionId)) ?? { zones: {} });
+            await this.insertLocale(id, locale, { slug, title: options.title ?? source.title, draft_version_id: version?.id ?? null });
+            added = await this.must(id);
+            await this.writePaths(added);
+        }
+        catch (e) {
+            await this.deleteLocale(id, locale);
+            throw e;
+        }
+        await this.writeRefs(added);
+        return added;
+    }
+    async removeLocale(id, locale) {
+        const page = await this.must(id);
+        localeRow(page, locale);
+        if (Object.keys(page.locales).length === 1)
+            throw pageErrors.lastLocale(id);
+        const blockers = (await this.subtree(page)).filter((n) => n.id !== id && n.locales[locale]);
+        if (blockers.length > 0)
+            throw pageErrors.localeInUse(locale, blockers.map((b) => b.locales[locale].title));
+        // Fewer path rows can never collide, so the row goes first and a
+        // network failure on the rewrite leaves a stale path row that
+        // resolves to a page absent in that locale — a 404, never leaked
+        // 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.writeRefs(remaining);
+        return remaining;
+    }
     async rename(id, patch) {
         const page = await this.must(id);
+        const row = localeRow(page, patch.locale);
         if (patch.slug !== undefined)
             assertSegment(patch.slug, `page slug (${patch.locale})`);
         // A rename that turns this node INTO the home node (root, default-locale
@@ -253,28 +342,19 @@ export class SupabasePageStore {
             (await this.hasChildren(id))) {
             throw pageErrors.homeChildren();
         }
+        if (patch.slug !== undefined)
+            await this.assertSlugFree(page.parentId, patch.locale, patch.slug, 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);
+        if (patch.slug !== undefined)
+            columns.slug = patch.slug;
+        if (patch.title !== undefined)
+            columns.title = patch.title;
+        const renamed = await this.updateLocale(id, patch.locale, columns);
         try {
             await this.writePaths(renamed);
         }
         catch (e) {
-            await this.update(id, { slug: page.slug, title: page.title, i18n: page.i18n }, { touch: false });
+            await this.updateLocale(id, patch.locale, { slug: row.slug, title: row.title }, { touch: false });
             throw e;
         }
         return renamed;
@@ -288,6 +368,9 @@ export class SupabasePageStore {
             const parent = await this.must(to.parentId);
             if (this.isHome(parent))
                 throw pageErrors.homeChildren();
+            for (const locale of Object.keys(page.locales))
+                if (!parent.locales[locale])
+                    throw pageErrors.moveLocales(locale);
             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
@@ -297,32 +380,36 @@ export class SupabasePageStore {
             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))) {
+        else if (page.locales[this.opts.locales.default]?.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);
+        if (to.parentId !== page.parentId) {
+            for (const [locale, row] of Object.entries(page.locales)) {
+                if (siblings.some((s) => s.locales[locale]?.slug === row.slug))
+                    throw pageErrors.slugTaken(row.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 moved = await this.updateNode(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.reorder(ordered);
             await this.writePaths(moved);
         }
         catch (e) {
-            await this.update(id, { parent_id: page.parentId, sort: page.sort }, { touch: false });
+            await this.updateNode(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 });
+                await this.updateNode(s.id, { sort: s.sort }, { touch: false });
             throw e;
         }
         return { ...moved, sort: index + 1 };
@@ -331,49 +418,53 @@ export class SupabasePageStore {
         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 });
+        for (const locale of Object.keys(page.locales)) {
+            const version = await this.insertVersion(id, locale, { zones: {} });
+            await this.updateLocale(id, locale, { draft_version_id: version.id });
+        }
+        return this.updateNode(id, { template });
     }
-    async saveDraft(id, tree) {
+    async saveDraft(id, locale, 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.publishedVersionId);
-            await this.writeRefs(id, pageRefEdges(tree, published, this.options.sections));
-        }
+        localeRow(page, locale);
+        const version = await this.insertVersion(id, locale, tree);
+        const saved = await this.updateLocale(id, locale, { draft_version_id: version.id });
+        await this.writeRefs(saved);
         return toVersion(version);
     }
-    async publish(id) {
+    async publish(id, locale) {
         const page = await this.must(id);
-        if (page.template === null || !page.draftVersionId)
+        if (page.template === null)
+            throw pageErrors.folder(id);
+        const row = localeRow(page, locale);
+        if (!row.draftVersionId)
             throw pageErrors.folder(id);
         const { sections, entries } = this.options;
-        const draft = (await this.versionTree(page.draftVersionId)) ?? { zones: {} };
+        const draft = (await this.versionTree(row.draftVersionId)) ?? { zones: {} };
         if (sections && entries)
-            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(id, pageRefEdges(draft, null, sections));
+            await assertPublishable(row.slug, draft, sections, entries, locale);
+        const record = await this.updateLocale(id, locale, { published_version_id: row.draftVersionId, status: "published" });
+        await this.writeRefs(record);
         return record;
     }
-    async getDraftTree(id) {
+    async getDraftTree(id, locale) {
         const page = await this.row(id);
-        return page ? this.versionTree(page.draftVersionId) : null;
+        return page ? this.versionTree(page.locales[locale]?.draftVersionId ?? null) : null;
     }
-    async getPublishedTree(id) {
+    async getPublishedTree(id, locale) {
         const page = await this.row(id);
-        return page ? this.versionTree(page.publishedVersionId) : null;
+        return page ? this.versionTree(page.locales[locale]?.publishedVersionId ?? null) : null;
     }
-    async listVersions(id) {
+    async listVersions(id, locale) {
         if (!UUID_RE.test(id))
             return [];
         const res = await this.db
             .from("page_versions")
             .select("*")
             .eq("page_id", id)
+            .eq("locale", locale)
             .order("created_at", { ascending: false })
             .order("id", { ascending: false });
         if (res.error)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoodly",
-  "version": "0.0.6",
+  "version": "0.0.7",
   "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": {