smoodly 0.0.6 → 0.0.7

package/dist/store.js

@@ -2,10 +2,16 @@
 // never raw table access — so validation, versioning and publish hooks
 // can't be bypassed (DESIGN.md §1). MemoryPageStore is the reference
 // implementation and the contract-test subject; the Supabase adapter
-// implements the same interface over pages/page_versions.
+// implements the same interface over pages/page_locales/page_versions.
+//
+// The model (spec 2026-09-06): a page is ONE node with ONE row per
+// locale it exists in. The node holds identity and tree position; each
+// locale row owns its slug, title, publish state and version pointers,
+// and each locale has its own history. Nothing falls back to another
+// locale — presence IS the row.
 import { collectTreeRefs } from "./refs.js";
 import { MemoryPathIndex } from "./path-index.js";
-import { assertDepth, assertSegment, chainOf, pagePathRows, } from "./paths.js";
+import { assertDepth, assertSegment, assertSupportedLocale, chainOf, isHomeNode, pagePathRows, unsupportedLocale, } from "./paths.js";
 export const DEFAULT_LOCALES = { default: "en", supported: ["en"] };
 /** The options every adapter resolves the same way. */
 export function pathOptions(options) {
@@ -24,26 +30,36 @@ export const pageErrors = {
     homeChildren: () => new Error("smoodly: the home page cannot have child pages."),
     cycle: () => new Error("smoodly: a page cannot be moved under itself."),
     hasChildren: (id) => new Error(`smoodly: "${id}" has child pages — move or delete them first.`),
+    unsupportedLocale,
+    notInLocale: (id, locale) => new Error(`smoodly: page "${id}" does not exist in locale "${locale}".`),
+    alreadyInLocale: (id, locale) => new Error(`smoodly: page "${id}" already exists in locale "${locale}".`),
+    parentNotInLocale: (locale) => new Error(`smoodly: the parent page does not exist in locale "${locale}" — add it there first.`),
+    lastLocale: (id) => new Error(`smoodly: page "${id}" must exist in at least one locale — delete the page instead.`),
+    localeInUse: (locale, titles) => new Error(`smoodly: child pages still exist in locale "${locale}" — remove it from ${titles.map((t) => `"${t}"`).join(", ")} first.`),
+    moveLocales: (locale) => new Error(`smoodly: the destination parent does not exist in locale "${locale}" — the page cannot move under it.`),
 };
-export function assertPageI18n(i18n) {
-    for (const [locale, v] of Object.entries(i18n ?? {})) {
-        if (v.slug !== undefined)
-            assertSegment(v.slug, `page slug (${locale})`);
-    }
+export { assertSupportedLocale } from "./paths.js";
+/** The page's row for a locale — the "does not exist in locale" guard every per-locale write runs. */
+export function localeRow(page, locale) {
+    const row = page.locales[locale];
+    if (!row)
+        throw pageErrors.notInLocale(page.id, locale);
+    return row;
 }
-/** A page's refs rows cover BOTH live trees — edges(draft) ∪
- * edges(published) — so an entry stays delete-guarded while either tree
+/** A page's refs rows cover EVERY live tree — each locale's draft and
+ * published trees — so an entry stays delete-guarded while any of them
  * shows it. Callers dedupe on write (the SQL PK does it for real). */
-export function pageRefEdges(draft, published, sections) {
-    const edges = collectTreeRefs(draft, sections);
-    if (published)
-        edges.push(...collectTreeRefs(published, sections));
+export function pageRefEdges(trees, sections) {
+    const edges = [];
+    for (const tree of trees)
+        edges.push(...collectTreeRefs(tree, sections));
     return edges;
 }
-/** The publish-integrity gate (DESIGN.md §3): a page must not go live
- * showing entries the published site can't resolve — every referenced
- * entry must exist and be published. Throws naming the offenders. */
-export async function assertPublishable(label, tree, sections, entries) {
+/** The publish-integrity gate (DESIGN.md §3), per locale: a page must not
+ * go live in a locale showing entries the published site cannot resolve
+ * THERE — every referenced entry must exist, have a row in that locale,
+ * and be published in it. Throws naming the offenders. */
+export async function assertPublishable(label, tree, sections, entries, locale) {
     const targets = new Map();
     for (const edge of collectTreeRefs(tree, sections)) {
         if (!targets.has(edge.targetId))
@@ -52,8 +68,11 @@ export async function assertPublishable(label, tree, sections, entries) {
     const offenders = [];
     for (const [id, { collection, field }] of targets) {
         const entry = await entries.get(collection, id);
-        if (entry?.status !== "published")
-            offenders.push(`${collection}/${id} (${field}${entry ? "" : ", missing"})`);
+        const row = entry?.locales[locale];
+        if (row?.status !== "published") {
+            const why = !entry ? ", missing" : !row ? `, not in ${locale}` : "";
+            offenders.push(`${collection}/${id} (${field}${why})`);
+        }
     }
     if (offenders.length > 0) {
         throw new Error(`smoodly: cannot publish "${label}" — it references entries that are not published: ${offenders.join(", ")}.`);
@@ -79,10 +98,16 @@ export class MemoryPageStore {
         return page;
     }
     isHome(page) {
-        return page.parentId === null && page.slug === this.opts.homePageSlug;
+        return isHomeNode(page, this.opts);
+    }
+    snapshot(page) {
+        return { ...page, locales: structuredClone(page.locales) };
+    }
+    children(id) {
+        return [...this.pages.values()].filter((p) => p.parentId === id);
     }
     hasChildren(id) {
-        return [...this.pages.values()].some((p) => p.parentId === id);
+        return this.children(id).length > 0;
     }
     siblings(parentId, except) {
         return [...this.pages.values()]
@@ -90,8 +115,10 @@ export class MemoryPageStore {
             // null sorts last; the SQL equivalent is ORDER BY sort ASC NULLS LAST, created_at ASC.
             .sort((a, b) => (a.sort ?? Infinity) - (b.sort ?? Infinity) || this.seq.get(a.id) - this.seq.get(b.id));
     }
-    assertSlugFree(parentId, slug, except) {
-        if (this.siblings(parentId, except).some((p) => p.slug === slug))
+    /** Sibling slugs are unique per parent PER LOCALE — a friendlier error
+     *  than the path index's, which stays the real invariant. */
+    assertSlugFree(parentId, locale, slug, except) {
+        if (this.siblings(parentId, except).some((p) => p.locales[locale]?.slug === slug))
             throw pageErrors.slugTaken(slug);
     }
     subtree(id) {
@@ -111,44 +138,71 @@ export class MemoryPageStore {
     async writePaths(nodes) {
         await this.paths.rewrite(nodes.map((n) => ({ kind: "page", id: n.id })), pagePathRows(nodes, this.byId, this.opts));
     }
-    writeRefs(pageId, draft, published) {
+    /** Every locale's draft and published trees, deduped by version id. */
+    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);
+        }
+        const trees = [];
+        for (const id of ids) {
+            const tree = this.versions.get(id)?.tree;
+            if (tree)
+                trees.push(tree);
+        }
+        return trees;
+    }
+    writeRefs(page) {
         const { sections, refs } = this.options;
         if (!sections || !refs)
             return;
-        refs.rewrite({ sourceKind: "page", sourceId: pageId }, pageRefEdges(draft, published, sections));
+        refs.rewrite({ sourceKind: "page", sourceId: page.id }, pageRefEdges(this.liveTrees(page), sections));
     }
-    newVersion(pageId, tree) {
-        const version = { id: uid(), pageId, tree: structuredClone(tree), createdAt: Date.now() };
+    newVersion(pageId, locale, tree) {
+        const version = { id: uid(), pageId, locale, tree: structuredClone(tree), createdAt: Date.now() };
         this.versions.set(version.id, version);
         return version;
     }
+    dropVersions(pageId, locale) {
+        for (const [vid, v] of this.versions) {
+            if (v.pageId === pageId && (locale === undefined || v.locale === locale))
+                this.versions.delete(vid);
+        }
+    }
     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 = this.must(parentId);
             if (this.isHome(parent))
                 throw pageErrors.homeChildren();
+            if (!parent.locales[input.locale])
+                throw pageErrors.parentNotInLocale(input.locale);
             assertDepth(chainOf(parent, this.byId).length + 1, this.opts.depth, "the page");
         }
-        this.assertSlugFree(parentId, input.slug);
+        this.assertSlugFree(parentId, input.locale, input.slug);
         const id = uid();
-        const version = input.template === null ? null : this.newVersion(id, { zones: {} });
+        const version = input.template === null ? null : this.newVersion(id, input.locale, { zones: {} });
         const page = {
             id,
             parentId,
-            slug: input.slug,
-            title: input.title ?? input.slug,
-            i18n: input.i18n ?? null,
             template: input.template,
-            status: "draft",
             // An ordering hint, not a unique key: duplicates are possible after
             // moves/deletes, and the creation-order tie-break settles them.
             sort: this.siblings(parentId).length + 1,
-            locales: input.locales ?? null,
-            draftVersionId: version?.id ?? null,
-            publishedVersionId: null,
+            locales: {
+                [input.locale]: {
+                    slug: input.slug,
+                    title: input.title ?? input.slug,
+                    status: "draft",
+                    draftVersionId: version?.id ?? null,
+                    publishedVersionId: null,
+                },
+            },
         };
         this.pages.set(id, page);
         this.seq.set(id, this.seq.size + 1);
@@ -161,17 +215,17 @@ export class MemoryPageStore {
                 this.versions.delete(version.id);
             throw e;
         }
-        return { ...page };
+        return this.snapshot(page);
     }
     async getPage(id) {
         const page = this.pages.get(id);
-        return page ? { ...page } : null;
+        return page ? this.snapshot(page) : null;
     }
     async listPages() {
         return [...this.pages.values()]
             // null sorts last; the SQL equivalent is ORDER BY sort ASC NULLS LAST, created_at ASC.
             .sort((a, b) => (a.sort ?? Infinity) - (b.sort ?? Infinity) || this.seq.get(a.id) - this.seq.get(b.id))
-            .map((p) => ({ ...p }));
+            .map((p) => this.snapshot(p));
     }
     resolvePath(locale, path) {
         return this.paths.resolve(locale, path);
@@ -179,8 +233,67 @@ export class MemoryPageStore {
     pathsOf(id) {
         return this.paths.pathsOf({ kind: "page", id });
     }
+    async addLocale(id, locale, options) {
+        assertSupportedLocale(locale, this.opts.locales);
+        const page = 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 && !this.must(page.parentId).locales[locale])
+            throw pageErrors.parentNotInLocale(locale);
+        this.assertSlugFree(page.parentId, locale, slug, id);
+        // The SOURCE'S DRAFT is the copy: what the editor sees on screen when
+        // they add the locale (spec §3). A folder has no tree to copy.
+        const version = page.template === null
+            ? null
+            : this.newVersion(id, locale, (source.draftVersionId && this.versions.get(source.draftVersionId)?.tree) || { zones: {} });
+        page.locales[locale] = {
+            slug,
+            title: options.title ?? source.title,
+            status: "draft",
+            draftVersionId: version?.id ?? null,
+            publishedVersionId: null,
+        };
+        try {
+            await this.writePaths([page]);
+        }
+        catch (e) {
+            delete page.locales[locale];
+            if (version)
+                this.versions.delete(version.id);
+            throw e;
+        }
+        this.writeRefs(page);
+        return this.snapshot(page);
+    }
+    async removeLocale(id, locale) {
+        const page = this.must(id);
+        const removed = localeRow(page, locale);
+        if (Object.keys(page.locales).length === 1)
+            throw pageErrors.lastLocale(id);
+        // Under the parent rule only direct children can hold the locale, but
+        // the walk is cheap and the message must name every blocker.
+        const blockers = this.subtree(id).filter((n) => n.id !== id && n.locales[locale]);
+        if (blockers.length > 0)
+            throw pageErrors.localeInUse(locale, blockers.map((b) => b.locales[locale].title));
+        delete page.locales[locale];
+        try {
+            await this.writePaths([page]);
+        }
+        catch (e) {
+            page.locales[locale] = removed;
+            throw e;
+        }
+        this.dropVersions(id, locale);
+        this.writeRefs(page);
+        return this.snapshot(page);
+    }
     async rename(id, patch) {
         const page = 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
@@ -193,28 +306,21 @@ export class MemoryPageStore {
             this.hasChildren(id)) {
             throw pageErrors.homeChildren();
         }
-        const before = { ...page, i18n: page.i18n ? structuredClone(page.i18n) : null };
-        if (patch.locale === this.opts.locales.default) {
-            if (patch.slug !== undefined) {
-                this.assertSlugFree(page.parentId, patch.slug, id);
-                page.slug = patch.slug;
-            }
-            if (patch.title !== undefined)
-                page.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 } : {}) };
-            page.i18n = i18n;
-        }
+        if (patch.slug !== undefined)
+            this.assertSlugFree(page.parentId, patch.locale, patch.slug, id);
+        const before = { ...row };
+        if (patch.slug !== undefined)
+            row.slug = patch.slug;
+        if (patch.title !== undefined)
+            row.title = patch.title;
         try {
             await this.writePaths(this.subtree(id));
         }
         catch (e) {
-            Object.assign(page, before);
+            Object.assign(row, before);
             throw e;
         }
-        return { ...page };
+        return this.snapshot(page);
     }
     async move(id, to) {
         const page = this.must(id);
@@ -224,18 +330,25 @@ export class MemoryPageStore {
                 throw pageErrors.cycle();
             if (this.isHome(parent))
                 throw pageErrors.homeChildren();
+            // The parent rule, on the move: every locale the page has must be
+            // present at the destination, or its chain would break there.
+            for (const locale of Object.keys(page.locales))
+                if (!parent.locales[locale])
+                    throw pageErrors.moveLocales(locale);
             const subtreeDepth = Math.max(...this.subtree(id).map((n) => chainOf(n, this.byId).length)) - chainOf(page, this.byId).length + 1;
             assertDepth(chainOf(parent, this.byId).length + subtreeDepth, this.opts.depth, "the page");
         }
-        else if (page.slug === this.opts.homePageSlug && this.hasChildren(id)) {
+        else if (page.locales[this.opts.locales.default]?.slug === this.opts.homePageSlug && 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();
         }
-        if (to.parentId !== page.parentId)
-            this.assertSlugFree(to.parentId, page.slug, id);
-        const before = { ...page };
+        if (to.parentId !== page.parentId) {
+            for (const [locale, row] of Object.entries(page.locales))
+                this.assertSlugFree(to.parentId, locale, row.slug, id);
+        }
+        const before = { parentId: page.parentId, sort: page.sort };
         page.parentId = to.parentId;
         const siblings = this.siblings(to.parentId, id);
         const index = Math.min(Math.max(to.index ?? siblings.length, 0), siblings.length);
@@ -251,54 +364,58 @@ export class MemoryPageStore {
                 s.sort = previousSort.get(s.id) ?? null;
             throw e;
         }
-        return { ...page };
+        return this.snapshot(page);
     }
     async setTemplate(id, template) {
         const page = this.must(id);
         if (page.template !== null)
             throw pageErrors.hasTemplate(id);
         page.template = template;
-        page.draftVersionId = this.newVersion(id, { zones: {} }).id;
-        return { ...page };
+        for (const [locale, row] of Object.entries(page.locales))
+            row.draftVersionId = this.newVersion(id, locale, { zones: {} }).id;
+        return this.snapshot(page);
     }
-    async saveDraft(id, tree) {
+    async saveDraft(id, locale, tree) {
         const page = this.must(id);
         if (page.template === null)
             throw pageErrors.folder(id);
-        const version = this.newVersion(id, tree);
-        page.draftVersionId = version.id;
-        const published = page.publishedVersionId ? (this.versions.get(page.publishedVersionId)?.tree ?? null) : null;
-        this.writeRefs(id, version.tree, published);
-        return { ...version };
+        const row = localeRow(page, locale);
+        const version = this.newVersion(id, locale, tree);
+        row.draftVersionId = version.id;
+        this.writeRefs(page);
+        return { ...version, tree: structuredClone(version.tree) };
     }
-    async publish(id) {
+    async publish(id, locale) {
         const page = 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 = this.versions.get(page.draftVersionId)?.tree ?? { zones: {} };
+        const draft = this.versions.get(row.draftVersionId)?.tree ?? { zones: {} };
         if (sections && entries)
-            await assertPublishable(page.slug, draft, sections, entries);
-        page.publishedVersionId = page.draftVersionId;
-        page.status = "published";
-        this.writeRefs(id, draft, null);
-        return { ...page };
+            await assertPublishable(row.slug, draft, sections, entries, locale);
+        row.publishedVersionId = row.draftVersionId;
+        row.status = "published";
+        this.writeRefs(page);
+        return this.snapshot(page);
     }
-    async getDraftTree(id) {
-        const page = this.pages.get(id);
-        if (!page?.draftVersionId)
+    async getDraftTree(id, locale) {
+        const row = this.pages.get(id)?.locales[locale];
+        if (!row?.draftVersionId)
             return null;
-        return structuredClone(this.versions.get(page.draftVersionId)?.tree ?? null);
+        return structuredClone(this.versions.get(row.draftVersionId)?.tree ?? null);
     }
-    async getPublishedTree(id) {
-        const page = this.pages.get(id);
-        if (!page?.publishedVersionId)
+    async getPublishedTree(id, locale) {
+        const row = this.pages.get(id)?.locales[locale];
+        if (!row?.publishedVersionId)
             return null;
-        return structuredClone(this.versions.get(page.publishedVersionId)?.tree ?? null);
+        return structuredClone(this.versions.get(row.publishedVersionId)?.tree ?? null);
     }
-    async listVersions(id) {
+    async listVersions(id, locale) {
         return [...this.versions.values()]
-            .filter((v) => v.pageId === id)
+            .filter((v) => v.pageId === id && v.locale === locale)
             .sort((a, b) => b.createdAt - a.createdAt || b.id.localeCompare(a.id))
             .map((v) => ({ ...v, tree: structuredClone(v.tree) }));
     }
@@ -312,9 +429,7 @@ export class MemoryPageStore {
         // call that can fail, and a failed rewrite must leave this store's own
         // state (versions, refs, the page map) untouched.
         await this.paths.remove([{ kind: "page", id }]);
-        for (const [vid, v] of this.versions)
-            if (v.pageId === id)
-                this.versions.delete(vid);
+        this.dropVersions(id);
         this.options.refs?.remove({ sourceKind: "page", sourceId: id });
         this.pages.delete(id);
     }

package/dist/supabase-entry-store.d.ts

@@ -1,6 +1,6 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
 import type { CollectionSchema } from "./collections.ts";
-import type { CreateEntryOptions, EntryRecord, EntryStore, EntryStoreOptions, EntryUsage, ListOptions } from "./entry-store.ts";
+import type { AddEntryLocaleOptions, CreateEntryOptions, EntryRecord, EntryStore, EntryStoreOptions, EntryUsage, EntryVersion, ListOptions } from "./entry-store.ts";
 export declare class SupabaseEntryStore implements EntryStore {
     private db;
     private collections;
@@ -8,22 +8,43 @@ export declare class SupabaseEntryStore implements EntryStore {
     private locales;
     constructor(db: SupabaseClient, collections: CollectionSchema<any>[], options?: EntryStoreOptions);
     private fail;
-    private failWriteError;
-    private writeRefs;
+    private schema;
+    private fetch;
+    private must;
+    private siblings;
     private byIdMap;
     private chain;
     private subtree;
+    private versionFields;
     private writePaths;
+    /** Every field set the site can render: each locale's live view, plus a
+     *  published snapshot the draft has moved past (see entryRefEdges). */
+    private liveFieldSets;
+    private writeRefs;
+    /** The friendly pre-check per locale (spec 2026-09-06 §11); the paths
+     *  primary key is the invariant. */
+    private assertSiblingSlug;
     private assertParent;
-    create(collection: string, fields: Record<string, unknown>, options?: CreateEntryOptions): Promise<EntryRecord>;
+    private assertParentHasLocale;
+    private updateNode;
+    private insertLocale;
+    private updateLocale;
+    /** The row goes first (it is what makes the entry exist in the locale), then its versions. */
+    private deleteLocale;
+    /** A versioned collection snapshots the merged fields and points the
+     *  locale's draft at the new row; others do nothing here. */
+    private recordVersion;
+    create(collection: string, fields: Record<string, unknown>, options: CreateEntryOptions): Promise<EntryRecord>;
     get(collection: string, id: string): Promise<EntryRecord | null>;
     list(collection: string, options?: ListOptions): Promise<EntryRecord[]>;
-    getMany(collection: string, ids: string[], options?: {
+    getMany(collection: string, ids: string[], locale: string, options?: {
         status?: "published";
     }): Promise<Record<string, Record<string, unknown>>>;
-    private patch;
-    update(collection: string, id: string, fields: Record<string, unknown>): Promise<EntryRecord>;
-    setStatus(collection: string, id: string, status: "draft" | "published"): Promise<EntryRecord>;
+    update(collection: string, id: string, locale: string, fields: Record<string, unknown>): Promise<EntryRecord>;
+    setStatus(collection: string, id: string, locale: string, status: "draft" | "published"): Promise<EntryRecord>;
+    addLocale(collection: string, id: string, locale: string, options: AddEntryLocaleOptions): Promise<EntryRecord>;
+    removeLocale(collection: string, id: string, locale: string): Promise<EntryRecord>;
+    listVersions(collection: string, id: string, locale: string): Promise<EntryVersion[]>;
     move(collection: string, id: string, to: {
         parentId: string | null;
         index?: number;