smoodly 0.0.14 → 0.0.16

package/dist/supabase-entry-store.js

@@ -25,6 +25,7 @@ function toLocale(row) {
         draftVersionId: row.draft_version_id,
         publishedVersionId: row.published_version_id,
         updatedAt: Date.parse(row.updated_at),
+        updatedBy: row.updated_by,
     };
 }
 function toRecord(row) {
@@ -40,7 +41,7 @@ function toRecord(row) {
     };
 }
 function toVersion(row) {
-    return { id: row.id, entryId: row.entry_id, locale: row.locale, fields: row.fields, createdAt: Date.parse(row.created_at) };
+    return { id: row.id, entryId: row.entry_id, locale: row.locale, fields: row.fields, savedAt: Date.parse(row.saved_at) };
 }
 export class SupabaseEntryStore {
     constructor(db, collections, options = {}) {
@@ -83,7 +84,15 @@ export class SupabaseEntryStore {
     async fetch(collection, id) {
         if (!UUID_RE.test(id))
             return null;
-        const res = await this.db.from("entries").select(SELECT).eq("collection", collection).eq("id", id).maybeSingle();
+        // Locale rows ordered by locale, as in `list`: the embed otherwise arrives in
+        // physical row order, which shifts with every update to the table.
+        const res = await this.db
+            .from("entries")
+            .select(SELECT)
+            .eq("collection", collection)
+            .eq("id", id)
+            .order("locale", { referencedTable: "entry_locales", ascending: true })
+            .maybeSingle();
         if (res.error)
             this.fail(res.error.message);
         return res.data ? toRecord(res.data) : null;
@@ -223,16 +232,21 @@ export class SupabaseEntryStore {
         if (res.error)
             this.fail(res.error.message);
     }
-    async insertLocale(entryId, locale, row) {
-        const res = await this.db.from("entry_locales").insert({ entry_id: entryId, locale, slug: row.slug, fields: row.fields });
+    async insertLocale(entryId, locale, row, by) {
+        const res = await this.db
+            .from("entry_locales")
+            .insert({ entry_id: entryId, locale, slug: row.slug, fields: row.fields, updated_by: by ?? null });
         if (res.error) {
             if (res.error.code === UNIQUE_VIOLATION)
                 throw entryErrors.alreadyInLocale(entryId, locale);
             this.fail(res.error.message);
         }
     }
+    /** A touch writes the audit pair — `updated_at` and `updated_by` (spec 2026-09-13 history §2). */
     async updateLocale(entryId, locale, patch, options = {}) {
-        const payload = (options.touch ?? true) ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
+        const payload = (options.touch ?? true)
+            ? { ...patch, updated_at: new Date().toISOString(), updated_by: options.by ?? null }
+            : { ...patch };
         const res = await this.db.from("entry_locales").update(payload).eq("entry_id", entryId).eq("locale", locale);
         if (res.error)
             this.fail(res.error.message);
@@ -246,22 +260,36 @@ export class SupabaseEntryStore {
         if (versions.error)
             this.fail(versions.error.message);
     }
-    /** A versioned collection snapshots the merged fields and points the
-     *  locale's draft at the new row; others do nothing here. */
+    /** The draft rule for every collection (spec 2026-09-14 §1), see MemoryEntryStore.recordVersion. */
     async recordVersion(entry, locale) {
-        if (!this.schema(entry.collection).versions)
+        const row = entry.locales[locale];
+        const fields = entryFieldsIn(entry, locale);
+        if (row.draftVersionId && row.draftVersionId !== row.publishedVersionId) {
+            const res = await this.db.from("entry_versions").update({ fields, saved_at: new Date().toISOString() }).eq("id", row.draftVersionId);
+            if (res.error)
+                this.fail(res.error.message);
             return;
-        const res = await this.db
-            .from("entry_versions")
-            .insert({ entry_id: entry.id, locale, fields: entryFieldsIn(entry, locale) })
-            .select("id")
-            .single();
+        }
+        const res = await this.db.from("entry_versions").insert({ entry_id: entry.id, locale, fields }).select("id").single();
         if (res.error)
             this.fail(res.error.message);
         await this.updateLocale(entry.id, locale, { draft_version_id: res.data.id }, { touch: false });
     }
+    /** See MemoryEntryStore.ensureLiveSnapshot: the snapshot of what is live, both pointers on it. */
+    async ensureLiveSnapshot(entry, locale) {
+        const row = entry.locales[locale];
+        if (row.status !== "published" || row.publishedVersionId !== null)
+            return;
+        const res = await this.db.from("entry_versions").insert({ entry_id: entry.id, locale, fields: entryFieldsIn(entry, locale) }).select("id").single();
+        if (res.error)
+            this.fail(res.error.message);
+        const id = res.data.id;
+        await this.updateLocale(entry.id, locale, { draft_version_id: id, published_version_id: id }, { touch: false });
+        row.draftVersionId = id;
+        row.publishedVersionId = id;
+    }
     // ── the contract ──
-    async create(collection, fields, options) {
+    async create(collection, fields, options, by) {
         const schema = this.schema(collection);
         assertSupportedLocale(options.locale, this.locales);
         const parentId = options.parentId ?? null;
@@ -294,7 +322,7 @@ export class SupabaseEntryStore {
         }
         const id = inserted.data.id;
         try {
-            await this.insertLocale(id, options.locale, { slug, fields: localized });
+            await this.insertLocale(id, options.locale, { slug, fields: localized }, by);
             let record = await this.must(collection, id);
             await this.recordVersion(record, options.locale);
             record = await this.must(collection, id);
@@ -389,23 +417,24 @@ export class SupabaseEntryStore {
         }
         return out;
     }
-    async update(collection, id, locale, fields) {
+    async update(collection, id, locale, fields, by) {
         const schema = this.schema(collection);
         const before = await this.must(collection, id);
         const row = entryLocaleRow(before, locale);
+        await this.ensureLiveSnapshot(before, locale);
         const { shared, localized, slug } = splitFields(fields, schema);
         if (isSharedSchema(schema) && slug !== null)
             throw entryErrors.noSlug(collection);
         await this.assertSiblingSlug(collection, before.parentId, locale, slug, id);
         await this.updateNode(id, { fields: shared });
-        await this.updateLocale(id, locale, { slug, fields: localized });
+        await this.updateLocale(id, locale, { slug, fields: localized }, { by });
         const record = await this.must(collection, id);
         try {
             await this.writePaths(record);
         }
         catch (e) {
             await this.updateNode(id, { fields: before.fields, updated_at: new Date(before.updatedAt).toISOString() }, { touch: false });
-            await this.updateLocale(id, locale, { slug: row.slug, fields: row.fields, updated_at: new Date(row.updatedAt).toISOString() }, { touch: false });
+            await this.updateLocale(id, locale, { slug: row.slug, fields: row.fields, updated_at: new Date(row.updatedAt).toISOString(), updated_by: row.updatedBy }, { touch: false });
             throw e;
         }
         await this.recordVersion(record, locale);
@@ -413,27 +442,47 @@ export class SupabaseEntryStore {
         await this.writeRefs(final);
         return final;
     }
-    async setStatus(collection, id, locale, status) {
+    async setStatus(collection, id, locale, status, by) {
         let record = await this.must(collection, id);
         let row = entryLocaleRow(record, locale);
         if (status === "published") {
-            if (this.schema(collection).versions && !row.draftVersionId) {
+            if (!row.draftVersionId) {
                 await this.recordVersion(record, locale);
                 record = await this.must(collection, id);
                 row = entryLocaleRow(record, locale);
             }
-            await this.updateLocale(id, locale, { status, published_version_id: row.draftVersionId });
+            await this.updateLocale(id, locale, { status, published_version_id: row.draftVersionId }, { by });
         }
         else {
             // Unpublish keeps the pointer for a later republish (spec §2).
-            await this.updateLocale(id, locale, { status });
+            await this.updateLocale(id, locale, { status }, { by });
         }
         await this.updateNode(id, {});
         const final = await this.must(collection, id);
         await this.writeRefs(final);
         return final;
     }
-    async addLocale(collection, id, locale, options) {
+    async discardDraft(collection, id, locale, by) {
+        const schema = this.schema(collection);
+        const record = await this.must(collection, id);
+        const row = entryLocaleRow(record, locale);
+        const snapshot = row.publishedVersionId ? (await this.versionFields([row.publishedVersionId])).get(row.publishedVersionId) : undefined;
+        if (!snapshot)
+            throw entryErrors.nothingPublished(collection, id, locale);
+        const { shared, localized } = splitFields(snapshot, schema);
+        await this.updateNode(id, { fields: shared });
+        await this.updateLocale(id, locale, { fields: localized, draft_version_id: row.publishedVersionId }, { by });
+        if (row.draftVersionId && row.draftVersionId !== row.publishedVersionId) {
+            // The pointer moved first, so a failure here leaves a stray row, never a dangling pointer.
+            const gone = await this.db.from("entry_versions").delete().eq("id", row.draftVersionId);
+            if (gone.error)
+                this.fail(gone.error.message);
+        }
+        const final = await this.must(collection, id);
+        await this.writeRefs(final);
+        return final;
+    }
+    async addLocale(collection, id, locale, options, by) {
         assertSupportedLocale(locale, this.locales);
         const entry = await this.must(collection, id);
         // The source is read FIRST (the memory adapter's order): "copy from a
@@ -445,7 +494,7 @@ export class SupabaseEntryStore {
         const parent = entry.parentId === null ? null : await this.fetch(collection, entry.parentId);
         this.assertParentHasLocale(parent, locale);
         await this.assertSiblingSlug(collection, entry.parentId, locale, source.slug, id);
-        await this.insertLocale(id, locale, { slug: source.slug, fields: source.fields });
+        await this.insertLocale(id, locale, { slug: source.slug, fields: source.fields }, by);
         let added;
         try {
             added = await this.must(collection, id);
@@ -492,12 +541,39 @@ export class SupabaseEntryStore {
             .select("*")
             .eq("entry_id", id)
             .eq("locale", locale)
-            .order("created_at", { ascending: false })
+            .order("saved_at", { ascending: false })
             .order("id", { ascending: false });
         if (res.error)
             this.fail(res.error.message);
         return res.data.map(toVersion);
     }
+    async restore(collection, id, locale, versionId, by) {
+        const schema = this.schema(collection);
+        const entry = await this.must(collection, id);
+        const row = entryLocaleRow(entry, locale);
+        const version = await this.getVersion(collection, versionId);
+        if (!version || version.entryId !== id || version.locale !== locale)
+            throw entryErrors.foreignVersion(collection, id, locale, versionId);
+        if (versionId === row.publishedVersionId)
+            return this.discardDraft(collection, id, locale, by);
+        const { shared, localized } = splitFields(version.fields, schema);
+        await this.updateNode(id, { fields: shared });
+        await this.updateLocale(id, locale, { fields: localized }, { by }); // the slug is the row's own and never versioned
+        const record = await this.must(collection, id);
+        await this.recordVersion(record, locale);
+        const final = await this.must(collection, id);
+        await this.writeRefs(final);
+        return final;
+    }
+    async getVersion(collection, versionId) {
+        this.schema(collection);
+        if (!UUID_RE.test(versionId))
+            return null;
+        const res = await this.db.from("entry_versions").select("*").eq("id", versionId).maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data ? toVersion(res.data) : null;
+    }
     async move(collection, id, to) {
         if (isSharedSchema(this.schema(collection)))
             throw entryErrors.owned(collection, "it has no tree position");

package/dist/supabase-store.d.ts

@@ -27,6 +27,7 @@ export declare class SupabasePageStore implements PageStore {
      *  A rollback restoring prior column values passes `{ touch: false }`,
      *  which omits updated_at entirely — undoing a write is not an edit. */
     private updateNode;
+    /** A touch writes the audit pair — `updated_at` and `updated_by` (spec 2026-09-13 history §2). */
     private updateLocale;
     private insertLocale;
     /** The locale's row and versions — the removeLocale and rollback shape.
@@ -35,6 +36,8 @@ export declare class SupabasePageStore implements PageStore {
      *  pointing at an already-deleted version. */
     private deleteLocale;
     private insertVersion;
+    /** The draft rule (spec 2026-09-13 history §1), see MemoryPageStore.writeDraftVersion. */
+    private writeDraftVersion;
     private versionTree;
     /** Every locale's draft and published trees in ONE query. */
     private liveTrees;
@@ -42,25 +45,29 @@ export declare class SupabasePageStore implements PageStore {
     private reorder;
     /** page_locales and page_versions cascade from pages; refs do not. */
     private hardDelete;
-    createPage(input: CreatePageInput): Promise<PageRecord>;
+    createPage(input: CreatePageInput, by?: string): 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>;
+    addLocale(id: string, locale: string, options: AddLocaleOptions, by?: string): Promise<PageRecord>;
     removeLocale(id: string, locale: string): Promise<PageRecord>;
     rename(id: string, patch: {
         locale: string;
         slug?: string;
         title?: string;
-    }): Promise<PageRecord>;
+    }, by?: string): Promise<PageRecord>;
     move(id: string, to: {
         parentId: string | null;
         index?: number;
     }): Promise<PageRecord>;
-    setTemplate(id: string, template: string): Promise<PageRecord>;
-    saveDraft(id: string, locale: string, tree: PageTree): Promise<PageVersion>;
-    publish(id: string, locale: string): Promise<PageRecord>;
+    setTemplate(id: string, template: string, by?: string): Promise<PageRecord>;
+    saveDraft(id: string, locale: string, tree: PageTree, by?: string): Promise<PageVersion>;
+    publish(id: string, locale: string, by?: string): Promise<PageRecord>;
+    discardDraft(id: string, locale: string, by?: string): Promise<PageRecord>;
+    unpublish(id: string, locale: string, by?: string): Promise<PageRecord>;
+    restore(id: string, locale: string, versionId: string, by?: string): Promise<PageRecord>;
+    getVersion(versionId: string): Promise<PageVersion | null>;
     getDraftTree(id: string, locale: string): Promise<PageTree | null>;
     fieldsOf(versionIds: string[]): Promise<Record<string, Record<string, unknown>>>;
     getPublishedTree(id: string, locale: string): Promise<PageTree | null>;

package/dist/supabase-store.js

@@ -21,6 +21,8 @@ function toRecord(row) {
             status: l.status,
             draftVersionId: l.draft_version_id,
             publishedVersionId: l.published_version_id,
+            updatedAt: Date.parse(l.updated_at),
+            updatedBy: l.updated_by,
         };
     }
     return {
@@ -32,7 +34,7 @@ function toRecord(row) {
     };
 }
 function toVersion(row) {
-    return { id: row.id, pageId: row.page_id, locale: row.locale, tree: row.tree, createdAt: Date.parse(row.created_at) };
+    return { id: row.id, pageId: row.page_id, locale: row.locale, tree: row.tree, savedAt: Date.parse(row.saved_at) };
 }
 export class SupabasePageStore {
     constructor(db, options = {}) {
@@ -129,8 +131,11 @@ export class SupabasePageStore {
             this.fail(res.error.message);
         return toRecord(res.data);
     }
+    /** A touch writes the audit pair — `updated_at` and `updated_by` (spec 2026-09-13 history §2). */
     async updateLocale(id, locale, patch, options = {}) {
-        const payload = (options.touch ?? true) ? { ...patch, updated_at: new Date().toISOString() } : { ...patch };
+        const payload = (options.touch ?? true)
+            ? { ...patch, updated_at: new Date().toISOString(), updated_by: options.by ?? null }
+            : { ...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);
@@ -162,6 +167,25 @@ export class SupabasePageStore {
             this.fail(res.error.message);
         return res.data;
     }
+    /** The draft rule (spec 2026-09-13 history §1), see MemoryPageStore.writeDraftVersion. */
+    async writeDraftVersion(page, locale, tree, by) {
+        const row = localeRow(page, locale);
+        if (row.draftVersionId && row.draftVersionId !== row.publishedVersionId) {
+            const res = await this.db
+                .from("page_versions")
+                .update({ tree, saved_at: new Date().toISOString() })
+                .eq("id", row.draftVersionId)
+                .select("*")
+                .single();
+            if (res.error)
+                this.fail(res.error.message);
+            const record = await this.updateLocale(page.id, locale, {}, { by });
+            return { version: res.data, record };
+        }
+        const version = await this.insertVersion(page.id, locale, tree);
+        const record = await this.updateLocale(page.id, locale, { draft_version_id: version.id }, { by });
+        return { version, record };
+    }
     async versionTree(versionId) {
         if (!versionId)
             return null;
@@ -223,7 +247,7 @@ export class SupabasePageStore {
             this.fail(page.error.message);
     }
     // ── contract ──
-    async createPage(input) {
+    async createPage(input, by) {
         assertSupportedLocale(input.locale, this.opts.locales);
         assertSegment(input.slug, "page slug");
         const parentId = input.parentId ?? null;
@@ -249,7 +273,7 @@ export class SupabasePageStore {
         try {
             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,
+                slug: input.slug, title: input.title ?? input.slug, draft_version_id: version?.id ?? null, updated_by: by ?? null,
             });
             const page = await this.must(id);
             await this.writePaths(page);
@@ -280,7 +304,7 @@ export class SupabasePageStore {
     pathsOf(id) {
         return UUID_RE.test(id) ? this.paths.pathsOf({ kind: "page", id }) : Promise.resolve({});
     }
-    async addLocale(id, locale, options) {
+    async addLocale(id, locale, options, by) {
         assertSupportedLocale(locale, this.opts.locales);
         const page = await this.must(id);
         if (page.locales[locale])
@@ -298,7 +322,9 @@ export class SupabasePageStore {
             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 });
+            await this.insertLocale(id, locale, {
+                slug, title: options.title ?? source.title, draft_version_id: version?.id ?? null, updated_by: by ?? null,
+            });
             added = await this.must(id);
             await this.writePaths(added);
         }
@@ -327,7 +353,7 @@ export class SupabasePageStore {
         await this.writeRefs(remaining);
         return remaining;
     }
-    async rename(id, patch) {
+    async rename(id, patch, by) {
         const page = await this.must(id);
         const row = localeRow(page, patch.locale);
         if (patch.slug !== undefined)
@@ -349,12 +375,13 @@ export class SupabasePageStore {
             columns.slug = patch.slug;
         if (patch.title !== undefined)
             columns.title = patch.title;
-        const renamed = await this.updateLocale(id, patch.locale, columns);
+        const renamed = await this.updateLocale(id, patch.locale, columns, { by });
         try {
             await this.writePaths(renamed);
         }
         catch (e) {
-            await this.updateLocale(id, patch.locale, { slug: row.slug, title: row.title }, { touch: false });
+            // The audit pair goes back too: a rejected rename is not an edit.
+            await this.updateLocale(id, patch.locale, { slug: row.slug, title: row.title, updated_at: new Date(row.updatedAt).toISOString(), updated_by: row.updatedBy }, { touch: false });
             throw e;
         }
         return renamed;
@@ -414,27 +441,25 @@ export class SupabasePageStore {
         }
         return { ...moved, sort: index + 1 };
     }
-    async setTemplate(id, template) {
+    async setTemplate(id, template, by) {
         const page = await this.must(id);
         if (page.template !== null)
             throw pageErrors.hasTemplate(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 });
+            await this.updateLocale(id, locale, { draft_version_id: version.id }, { by });
         }
         return this.updateNode(id, { template });
     }
-    async saveDraft(id, locale, tree) {
+    async saveDraft(id, locale, tree, by) {
         const page = await this.must(id);
         if (page.template === null)
             throw pageErrors.folder(id);
-        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);
+        const { version, record } = await this.writeDraftVersion(page, locale, tree, by);
+        await this.writeRefs(record);
         return toVersion(version);
     }
-    async publish(id, locale) {
+    async publish(id, locale, by) {
         const page = await this.must(id);
         if (page.template === null)
             throw pageErrors.folder(id);
@@ -445,10 +470,54 @@ export class SupabasePageStore {
         const draft = (await this.versionTree(row.draftVersionId)) ?? { zones: {} };
         if (sections && entries)
             await assertPublishable(row.slug, draft, sections, entries, locale);
-        const record = await this.updateLocale(id, locale, { published_version_id: row.draftVersionId, status: "published" });
+        const record = await this.updateLocale(id, locale, { published_version_id: row.draftVersionId, status: "published" }, { by });
+        await this.writeRefs(record);
+        return record;
+    }
+    async discardDraft(id, locale, by) {
+        const page = await this.must(id);
+        const row = localeRow(page, locale);
+        if (!row.publishedVersionId)
+            throw pageErrors.nothingPublished(id, locale);
+        const record = await this.updateLocale(id, locale, { draft_version_id: row.publishedVersionId }, { by });
+        if (row.draftVersionId && row.draftVersionId !== row.publishedVersionId) {
+            // The pointer moved first, so a failure here leaves a stray row, never a dangling pointer.
+            const gone = await this.db.from("page_versions").delete().eq("id", row.draftVersionId);
+            if (gone.error)
+                this.fail(gone.error.message);
+        }
         await this.writeRefs(record);
         return record;
     }
+    async unpublish(id, locale, by) {
+        const page = await this.must(id);
+        localeRow(page, locale); // the "does not exist in locale" guard
+        const record = await this.updateLocale(id, locale, { status: "draft" }, { by });
+        await this.writeRefs(record);
+        return record;
+    }
+    async restore(id, locale, versionId, by) {
+        const page = await this.must(id);
+        if (page.template === null)
+            throw pageErrors.folder(id);
+        const row = localeRow(page, locale);
+        const version = await this.getVersion(versionId);
+        if (!version || version.pageId !== id || version.locale !== locale)
+            throw pageErrors.foreignVersion(id, locale, versionId);
+        if (versionId === row.publishedVersionId)
+            return this.discardDraft(id, locale, by);
+        const { record } = await this.writeDraftVersion(page, locale, version.tree, by);
+        await this.writeRefs(record);
+        return record;
+    }
+    async getVersion(versionId) {
+        if (!UUID_RE.test(versionId))
+            return null;
+        const res = await this.db.from("page_versions").select("*").eq("id", versionId).maybeSingle();
+        if (res.error)
+            this.fail(res.error.message);
+        return res.data ? toVersion(res.data) : null;
+    }
     async getDraftTree(id, locale) {
         const page = await this.row(id);
         return page ? this.versionTree(page.locales[locale]?.draftVersionId ?? null) : null;
@@ -478,7 +547,7 @@ export class SupabasePageStore {
             .select("*")
             .eq("page_id", id)
             .eq("locale", locale)
-            .order("created_at", { ascending: false })
+            .order("saved_at", { ascending: false })
             .order("id", { ascending: false });
         if (res.error)
             this.fail(res.error.message);

package/package.json

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