smoodly 0.0.4 → 0.0.6

package/dist/supabase-entry-store.js

@@ -2,33 +2,53 @@
 // Service-role client, server-side only (writes bypass RLS by design —
 // DESIGN.md §1). Reorder calls the smoodly_reorder SQL function: one
 // statement for the whole collection, updated_at untouched.
-import { schemaOf } from "./entry-store.js";
+import { collectionDepth, collectionOrder } from "./collections.js";
+import { DEFAULT_ENTRY_LOCALES, entryErrors, schemaOf } from "./entry-store.js";
 import { collectEntryRefs } from "./refs.js";
+import { SupabasePathIndex } from "./supabase-path-index.js";
+import { assertDepth, entryPathRows, 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 — getMany silently omits
 // it, patch raises the contract's "no entry" error — rather than letting
 // the cast error leak through.
 const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const UNIQUE_VIOLATION = "23505";
 function toRecord(row) {
     return {
         id: row.id,
         collection: row.collection,
+        parentId: row.parent_id,
         fields: row.fields,
+        i18n: row.i18n,
         status: row.status,
         sort: row.sort,
+        locales: row.locales,
         createdAt: Date.parse(row.created_at),
         updatedAt: Date.parse(row.updated_at),
     };
 }
 export class SupabaseEntryStore {
-    constructor(db, collections) {
+    constructor(db, collections, options = {}) {
         this.db = db;
         this.collections = collections;
+        this.paths = options.paths ?? new SupabasePathIndex(db);
+        this.locales = options.locales ?? DEFAULT_ENTRY_LOCALES;
     }
     fail(message) {
         throw new Error(`smoodly: ${message}`);
     }
+    // entries_sibling_slug_key (space_id, collection, parent_id,
+    // fields->>'slug') enforces slug uniqueness among SIBLINGS at the DB
+    // level, ahead of the paths rewrite — a collision here never reaches
+    // writePaths, so the insert, the update and move's re-parent all need
+    // this translation. The text comes from entryErrors so the memory
+    // adapter's pre-check and this one read identically.
+    failWriteError(error, collection) {
+        if (error.code === UNIQUE_VIOLATION)
+            throw entryErrors.slugTaken(collection);
+        this.fail(error.message);
+    }
     async writeRefs(collection, id, fields) {
         const schema = schemaOf(this.collections, collection);
         const deleted = await this.db
@@ -55,16 +75,85 @@ export class SupabaseEntryStore {
                 this.fail(inserted.error.message);
         }
     }
-    async create(collection, fields) {
-        schemaOf(this.collections, collection);
-        const res = await this.db.from("entries").insert({ collection, fields }).select("*").single();
+    byIdMap(rows) {
+        const map = new Map(rows.map((r) => [r.id, r]));
+        return (id) => map.get(id);
+    }
+    async chain(entry) {
+        const chain = [entry];
+        let current = entry;
+        while (current.parentId !== null) {
+            const parent = await this.get(current.collection, current.parentId);
+            if (!parent)
+                this.fail(`broken parent chain at "${entry.id}".`);
+            chain.unshift(parent);
+            current = parent;
+        }
+        return chain;
+    }
+    async subtree(entry) {
+        const out = [entry];
+        let frontier = [entry.id];
+        while (frontier.length > 0) {
+            const res = await this.db.from("entries").select("*").eq("collection", entry.collection).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;
+    }
+    async writePaths(top) {
+        const schema = schemaOf(this.collections, 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));
+    }
+    async assertParent(collection, parentId, subtreeHeight) {
+        if (parentId === null)
+            return;
+        if (!UUID_RE.test(parentId))
+            throw entryErrors.notFound(collection, parentId);
+        const res = await this.db.from("entries").select("*").eq("id", parentId).maybeSingle();
         if (res.error)
             this.fail(res.error.message);
-        const row = res.data;
+        if (!res.data)
+            throw entryErrors.notFound(collection, parentId);
+        const parent = toRecord(res.data);
+        if (parent.collection !== collection)
+            throw entryErrors.foreignParent();
+        assertDepth((await this.chain(parent)).length + subtreeHeight, collectionDepth(schemaOf(this.collections, collection)), "the entry");
+    }
+    async create(collection, fields, options = {}) {
+        schemaOf(this.collections, collection);
+        const parentId = options.parentId ?? null;
+        await this.assertParent(collection, parentId, 1);
+        const res = await this.db
+            .from("entries")
+            .insert({ collection, fields, parent_id: parentId, locales: options.locales ?? null })
+            .select("*")
+            .single();
+        if (res.error)
+            this.failWriteError(res.error, collection);
+        const row = toRecord(res.data);
+        try {
+            await this.writePaths(row);
+        }
+        catch (e) {
+            await this.db.from("entries").delete().eq("id", row.id);
+            throw e;
+        }
         await this.writeRefs(collection, row.id, fields);
-        return toRecord(row);
+        return row;
     }
     async get(collection, id) {
+        // Same short-circuit as UUID_RE elsewhere: a non-UUID id can't exist
+        // in the table, and querying it as one throws invalid_text_representation
+        // instead of returning "not found" (which `update`'s rollback read and
+        // `chain`'s parent walk both rely on).
+        if (!UUID_RE.test(id))
+            return null;
         const res = await this.db
             .from("entries")
             .select("*")
@@ -76,19 +165,24 @@ export class SupabaseEntryStore {
         return res.data ? toRecord(res.data) : null;
     }
     async list(collection, options) {
-        schemaOf(this.collections, collection);
+        const schema = schemaOf(this.collections, collection);
         let query = this.db.from("entries").select("*").eq("collection", collection);
         if (options?.status)
             query = query.eq("status", options.status);
-        const order = options?.order ?? "created";
-        if (order === "updated")
-            query = query.order("updated_at", { ascending: false });
-        else if (order === "manual")
-            query = query
-                .order("sort", { ascending: true, nullsFirst: false })
-                .order("created_at", { ascending: true });
-        else
-            query = query.order("created_at", { ascending: true }).order("id", { ascending: true });
+        if (options?.parent !== undefined) {
+            query = options.parent === null ? query.is("parent_id", null) : query.eq("parent_id", options.parent);
+        }
+        const order = options?.order ?? collectionOrder(schema);
+        if (order === "manual") {
+            query = query.order("sort", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true });
+        }
+        else {
+            // `fields->x`, not `->>x`: ordering by the jsonb VALUE, so numbers
+            // compare numerically (rank 10 after rank 2) and strings — ISO dates
+            // included — alphabetically, matching the memory comparator.
+            const column = order.by === "createdAt" ? "created_at" : order.by === "updatedAt" ? "updated_at" : `fields->${order.by}`;
+            query = query.order(column, { ascending: order.direction === "asc", nullsFirst: false }).order("id", { ascending: true });
+        }
         const res = await query;
         if (res.error)
             this.fail(res.error.message);
@@ -115,35 +209,111 @@ export class SupabaseEntryStore {
         }
         return out;
     }
-    async patch(collection, id, patch) {
+    // `touch` defaults to true (the normal edit path always bumps
+    // updated_at). Callers that must leave the timestamp alone — a
+    // rollback restoring a prior value, or move's re-parent, which the
+    // contract says must not count as an edit — pass `{ touch: false }`,
+    // which omits updated_at from the payload entirely so the column is
+    // left untouched (or keeps whatever value the caller put in `patch`).
+    async patch(collection, id, patch, options = {}) {
         if (!UUID_RE.test(id))
-            this.fail(`no entry "${id}" in "${collection}".`);
+            throw entryErrors.notFound(collection, id);
+        const touch = options.touch ?? true;
+        const payload = touch ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
         const res = await this.db
             .from("entries")
-            .update({ ...patch, updated_at: new Date().toISOString() })
+            .update(payload)
             .eq("collection", collection)
             .eq("id", id)
             .select("*")
             .maybeSingle();
         if (res.error)
-            this.fail(res.error.message);
+            this.failWriteError(res.error, collection);
         if (!res.data)
-            this.fail(`no entry "${id}" in "${collection}".`);
+            throw entryErrors.notFound(collection, id);
         return toRecord(res.data);
     }
     async update(collection, id, fields) {
+        const before = await this.get(collection, id);
+        if (!before)
+            throw entryErrors.notFound(collection, id);
         const record = await this.patch(collection, id, { fields });
+        try {
+            await this.writePaths(record);
+        }
+        catch (e) {
+            await this.patch(collection, id, { fields: before.fields, updated_at: new Date(before.updatedAt).toISOString() }, { touch: false });
+            throw e;
+        }
         await this.writeRefs(collection, id, fields);
         return record;
     }
     async setStatus(collection, id, status) {
         return this.patch(collection, id, { status });
     }
+    async move(collection, id, to) {
+        const entry = await this.get(collection, id);
+        if (!entry)
+            throw entryErrors.notFound(collection, id);
+        const subtree = await this.subtree(entry);
+        if (to.parentId !== null && (to.parentId === id || subtree.some((e) => e.id === to.parentId)))
+            throw entryErrors.cycle();
+        const byId = this.byIdMap(subtree);
+        // chainOf walks all the way to a null parentId, but `entry`'s own
+        // parentId still points OUTSIDE this subtree map (its pre-move
+        // parent) — so it can't be used here directly (page store's `move`
+        // hits the same shape and solves it the same way): stop at `entry`
+        // itself instead, since that's the map's root for this computation.
+        const heightOf = (e) => (e.id === entry.id ? 1 : 1 + heightOf(byId(e.parentId)));
+        const height = Math.max(...subtree.map(heightOf));
+        await this.assertParent(collection, to.parentId, height);
+        const siblings = (await this.list(collection, { parent: to.parentId, order: "manual" })).filter((s) => s.id !== id);
+        // Mirror of the memory adapter's pre-check. The index below would
+        // catch it on the parent_id update anyway, but raising here keeps the
+        // error identical across adapters and leaves the destination
+        // siblings' sorts untouched.
+        if (to.parentId !== entry.parentId) {
+            const slug = slugOf(entry.fields);
+            if (slug !== null && siblings.some((s) => slugOf(s.fields) === slug)) {
+                throw entryErrors.slugTaken(collection);
+            }
+        }
+        // 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.patch(collection, id, { parent_id: to.parentId }, { touch: false });
+        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);
+        try {
+            await this.writePaths(moved);
+        }
+        catch (e) {
+            await this.patch(collection, id, { parent_id: entry.parentId, sort: entry.sort }, { touch: false });
+            for (const s of previousSorts)
+                await this.patch(collection, s.id, { sort: s.sort }, { touch: false });
+            throw e;
+        }
+        return (await this.get(collection, id));
+    }
     async delete(collection, id) {
+        if (!UUID_RE.test(id))
+            return;
+        const entry = await this.get(collection, id);
+        if (!entry)
+            return;
+        const children = await this.db.from("entries").select("id").eq("parent_id", id).limit(1);
+        if (children.error)
+            this.fail(children.error.message);
+        if (children.data.length > 0)
+            throw entryErrors.hasChildren(collection, id);
         const usage = await this.referencesTo(collection, id);
         if (usage.length > 0) {
             this.fail(`"${collection}/${id}" is referenced by ${usage.length} document(s) — remove those references first.`);
         }
+        await this.paths.remove([{ kind: "entry", id }]);
         const refs = await this.db.from("refs").delete().eq("source_kind", "entry").eq("source_id", id);
         if (refs.error)
             this.fail(refs.error.message);
@@ -151,6 +321,12 @@ export class SupabaseEntryStore {
         if (res.error)
             this.fail(res.error.message);
     }
+    resolvePath(locale, path) {
+        return this.paths.resolve(locale, path);
+    }
+    async pathsOf(collection, id) {
+        return (await this.get(collection, id)) ? this.paths.pathsOf({ kind: "entry", id }) : {};
+    }
     async reorder(collection, orderedIds) {
         schemaOf(this.collections, collection);
         const res = await this.db.rpc("smoodly_reorder", {

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

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

package/dist/supabase-path-index.js

@@ -0,0 +1,52 @@
+import { pathTakenError } from "./path-index.js";
+const UNIQUE_VIOLATION = "23505";
+export class SupabasePathIndex {
+    constructor(db) {
+        this.db = db;
+    }
+    fail(message) {
+        throw new Error(`smoodly: ${message}`);
+    }
+    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_rows: rows.map((r) => ({ locale: r.locale, path: r.path, kind: r.kind, id: r.id })),
+        });
+        if (res.error) {
+            if (res.error.code === UNIQUE_VIOLATION) {
+                // details: Key (space_id, locale, path)=(…, fi, /yritys) already exists.
+                const m = /\(space_id, locale, path\)=\([^,]+, ([^,]+), (.+)\) already exists/.exec(res.error.details ?? "");
+                throw m ? pathTakenError(m[1], m[2]) : pathTakenError("?", "?");
+            }
+            this.fail(res.error.message);
+        }
+    }
+    async remove(targets) {
+        await this.rewrite(targets, []);
+    }
+    async resolve(locale, path) {
+        const res = await this.db
+            .from("paths")
+            .select("kind, target_id")
+            .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;
+    }
+    async pathsOf(target) {
+        const res = await this.db
+            .from("paths")
+            .select("locale, path")
+            .eq("kind", target.kind)
+            .eq("target_id", target.id);
+        if (res.error)
+            this.fail(res.error.message);
+        const out = {};
+        for (const r of res.data)
+            out[r.locale] = r.path;
+        return out;
+    }
+}

package/dist/supabase-store.d.ts

@@ -1,26 +1,56 @@
 import type { SupabaseClient } from "@supabase/supabase-js";
-import { type PageRecord, type PageStore, type PageStoreOptions, type PageVersion } from "./store.ts";
+import { 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 {
     private db;
     private options;
+    private paths;
+    private opts;
     constructor(db: SupabaseClient, options?: PageStoreOptions);
-    private writeRefs;
-    private pageRow;
+    private fail;
+    private isHome;
+    private row;
+    private must;
+    /** A one-row existence check — the shape `deletePage` needs too. */
+    private hasChildren;
+    private siblings;
+    /** The node's ancestors (root first, node last), by walking parent_id. */
+    private chain;
+    /** The node and every descendant, breadth-first. */
+    private subtree;
+    /** 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. */
+    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;
     private insertVersion;
-    private setPointers;
-    createPage({ slug, template }: {
-        slug: string;
-        template: string;
-    }): Promise<PageRecord>;
-    getPage(slug: string): Promise<PageRecord | null>;
-    getPageById(id: string): Promise<PageRecord | null>;
-    saveDraft(slug: string, tree: PageTree): Promise<PageVersion>;
-    publish(slug: string): Promise<PageRecord>;
     private versionTree;
-    getDraftTree(slug: string): Promise<PageTree | null>;
-    getPublishedTree(slug: string): Promise<PageTree | null>;
-    listVersions(slug: string): Promise<PageVersion[]>;
+    private writeRefs;
+    private reorder;
+    private hardDelete;
+    createPage(input: CreatePageInput): Promise<PageRecord>;
+    getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
-    deletePage(slug: string): Promise<void>;
+    resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    pathsOf(id: string): Promise<{}>;
+    rename(id: string, patch: {
+        locale: string;
+        slug?: string;
+        title?: string;
+    }): Promise<PageRecord>;
+    move(id: string, to: {
+        parentId: string | null;
+        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[]>;
+    deletePage(id: string): Promise<void>;
 }