smoodly 0.0.6 → 0.0.7

package/dist/sql.js

@@ -5,9 +5,11 @@
 // security_invoker so it runs under the caller's own RLS policies
 // rather than the view owner's privileges (PostgREST-native reads,
 // SQL-queryable eject story) — and a partial expression index for a
-// declared order field, on the jsonb VALUE (slug uniqueness is a core
-// index, scoped to siblings, not per collection). Views project the
-// default locale; the `i18n` overlay is the resolver/API's business.
+// declared order field, on the jsonb VALUE (sibling slug uniqueness
+// is the `paths` primary key plus the stores' per-locale pre-check,
+// not an index). A view joins the locale rows, one row per published
+// locale (spec 2026-09-06 §7); a versioned collection reads its
+// fields from the published snapshot.
 import { BUILT_IN_ORDER_FIELDS } from "./collections.js";
 import { currentSpaceSQL, SPACE_COL, spaceLayerSQL } from "./sql-space.js";
 const snake = (s) => s.replace(/[A-Z]/g, (c) => "_" + c.toLowerCase());
@@ -16,42 +18,50 @@ const q = (s) => `"${s}"`;
 // immutable — the order field's index stays on the raw jsonb
 // expression: jsonb ordering compares numbers numerically and strings,
 // ISO dates included, alphabetically, matching the memory comparator).
-function fieldExpr(key, d) {
+function fieldExpr(key, d, source) {
     switch (d.type) {
         case "text":
         case "link":
         case "slug":
         case "select":
         case "ref": // stored as the target entry's id string
-            return `"fields"->>'${key}'`;
+            return `${source}->>'${key}'`;
         case "number":
-            return `("fields"->>'${key}')::numeric`;
+            return `(${source}->>'${key}')::numeric`;
         case "date":
-            return `("fields"->>'${key}')::timestamptz`;
+            return `(${source}->>'${key}')::timestamptz`;
         default:
-            return `"fields"->'${key}'`; // image, video, file, object, richtext, dataAttributes, refList
+            return `${source}->'${key}'`; // image, video, file, object, richtext, dataAttributes, refList
     }
 }
 export function collectionSQL(collection) {
     const name = collection.name;
-    const columns = ['"id"', '"sort"', '"locales"', '"created_at"', '"updated_at"'];
+    const versioned = collection.versions === true;
+    // Where a field's value lives: a versioned collection's view reads the
+    // published snapshot (merged at publish time); otherwise shared fields
+    // come from the node and localized ones from the locale row.
+    const sourceOf = (d) => (versioned ? 'v."fields"' : d.localized === true ? 'l."fields"' : 'e."fields"');
+    const columns = ['e."id"', 'l."locale"', 'l."slug"', 'e."sort"', 'e."created_at"', 'l."updated_at"'];
     for (const [key, d] of Object.entries(collection.fields)) {
-        columns.push(`${fieldExpr(key, d)} as ${q(snake(key))}`);
+        if (key === "slug")
+            continue; // the segment is the row's column, never a field
+        columns.push(`${fieldExpr(key, d, sourceOf(d))} as ${q(snake(key))}`);
     }
     const statements = [
         [
             `create or replace view ${q(name)} with (security_invoker = true) as`,
             `select`,
             columns.map((c) => "  " + c).join(",\n"),
-            `from "entries"`,
-            `where "collection" = '${name}' and "status" = 'published';`,
+            `from "entries" e`,
+            `join "entry_locales" l on l."entry_id" = e."id"`,
+            ...(versioned ? [`join "entry_versions" v on v."id" = l."published_version_id"`] : []),
+            `where e."collection" = '${name}' and l."status" = 'published';`,
         ].join("\n"),
     ];
-    // slug uniqueness is the generic core index, scoped to siblings
-    // (space_id, collection, parent_id, slug); only a declared order field
-    // needs a per-collection expression index — the built-in timestamps are
-    // real columns already. The expression is the jsonb value (`->`), the
-    // same one the adapter orders by, so the index actually serves the sort.
+    // Only a declared order field needs a per-collection expression index —
+    // on the node's shared fields (an order field can be neither localized
+    // nor `slug`, which collection() refuses), the jsonb value (`->`) the
+    // adapter orders by, so the index serves the sort.
     const order = collection.order;
     if (order !== undefined && order !== "manual" && !BUILT_IN_ORDER_FIELDS.includes(order.by)) {
         statements.push(`create index if not exists ${q(`entries_${name}_${snake(order.by)}_idx`)}\n` +
@@ -71,28 +81,34 @@ create table if not exists "pages" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
   "parent_id" uuid references "pages" ("id") on delete restrict,
-  "slug" text not null,
-  "title" text not null,
-  "i18n" jsonb,
   "template" text,
-  "status" text not null default 'draft',
   "sort" numeric,
-  "locales" text[],
-  "draft_version_id" uuid,
-  "published_version_id" uuid,
   "created_at" timestamptz not null default now(),
   "updated_at" timestamptz not null default now()
 );
 
--- The tree is the URL (spec 2026-09-05 §1): a node stores its own segment
--- and its parent. Siblings are unique per segment; NULLS NOT DISTINCT so
--- two root nodes cannot share one either. template null = folder.
-create unique index if not exists "pages_sibling_slug_key"
-  on "pages" ("space_id", "parent_id", "slug") nulls not distinct;
-
+-- The tree is the URL (spec 2026-09-05 §1): a node stores its parent and
+-- its position; template null = folder. Everything a locale owns — the
+-- node's own segment, title, publish state and version pointers — lives
+-- in page_locales, one row per locale the page exists in (spec 2026-09-06
+-- §2). There is no sibling-slug index: URL uniqueness per locale is the
+-- primary key of "paths", which the stores write inside the same operation.
 create index if not exists "pages_parent_idx"
   on "pages" ("space_id", "parent_id", "sort");
 
+create table if not exists "page_locales" (
+  ${SPACE_COL},
+  "page_id" uuid not null references "pages" ("id") on delete cascade,
+  "locale" text not null,
+  "slug" text not null,
+  "title" text not null,
+  "status" text not null default 'draft',
+  "draft_version_id" uuid,
+  "published_version_id" uuid,
+  "updated_at" timestamptz not null default now(),
+  primary key ("page_id", "locale")
+);
+
 -- Sibling reorder for pages: same shape as smoodly_reorder for entries.
 create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void language sql as $$
   update "pages" pg set "sort" = u.ord
@@ -101,15 +117,21 @@ create or replace function "smoodly_reorder_pages"(p_ids uuid[]) returns void la
     and pg."space_id" = "smoodly_current_space"();
 $$;
 
+-- A version belongs to ONE locale of one page: each locale has its own
+-- draft, its own publish and its own history.
 create table if not exists "page_versions" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
   "page_id" uuid not null references "pages" ("id") on delete cascade,
+  "locale" text not null,
   "tree" jsonb not null,
   "created_by" text,
   "created_at" timestamptz not null default now()
 );
 
+create index if not exists "page_versions_page_locale_idx"
+  on "page_versions" ("page_id", "locale", "created_at");
+
 create table if not exists "saved_sections" (
   "id" uuid primary key default gen_random_uuid(),
   ${SPACE_COL},
@@ -132,40 +154,58 @@ create table if not exists "entries" (
   "collection" text not null,
   "parent_id" uuid references "entries" ("id") on delete restrict,
   "fields" jsonb not null default '{}'::jsonb,
-  "i18n" jsonb,
-  "status" text not null default 'draft',
   "sort" numeric,
-  "locales" text[],
   "created_at" timestamptz not null default now(),
   "updated_at" timestamptz not null default now()
 );
 
--- Entry slugs are unique among SIBLINGS, like pages: one rule for every
--- node in the tree, and the URL is the tree. NULLS NOT DISTINCT so two
--- ROOT entries (parent_id null) cannot share a slug either. The partial
--- predicate keeps absent, null, empty or non-string slugs out of the
--- index entirely: with NULLS NOT DISTINCT a null slug would otherwise
--- collide with the next null slug, and a collection with no slug field
--- at all could hold only one entry per parent. jsonb_typeof(...) =
--- 'string' is required because ->> renders ANY JSON scalar as text —
--- a number, boolean or null slug would otherwise print as non-empty
--- text and claim the index; only a non-empty string slug claims a URL,
--- absent, null, empty or non-string slugs never conflict — the same
--- rule as slugOf in paths.ts. A flat collection (every entry a root)
--- therefore behaves exactly as per-collection uniqueness did.
-create unique index if not exists "entries_sibling_slug_key"
-  on "entries" ("space_id", "collection", "parent_id", ("fields"->>'slug')) nulls not distinct
-  where (jsonb_typeof("fields"->'slug') = 'string' and "fields"->>'slug' <> '');
-
-create index if not exists "entries_collection_status_idx"
-  on "entries" ("space_id", "collection", "status");
-
+-- The node holds identity, tree position and the SHARED fields — every
+-- field without .localized() (spec 2026-09-06 §7): a Person's photo is
+-- the same in every language. Everything a locale owns — its segment,
+-- publish state, the .localized() fields and the version pointers —
+-- lives in entry_locales, one row per locale the entry exists in. There
+-- is no sibling-slug index any more: URL uniqueness per locale is the
+-- primary key of "paths", which the stores write inside the same
+-- operation, and both adapters pre-check siblings per locale in code.
 create index if not exists "entries_collection_sort_idx"
   on "entries" ("space_id", "collection", "sort");
 
 create index if not exists "entries_parent_idx"
   on "entries" ("space_id", "collection", "parent_id");
 
+create table if not exists "entry_locales" (
+  ${SPACE_COL},
+  "entry_id" uuid not null references "entries" ("id") on delete cascade,
+  "locale" text not null,
+  "slug" text,
+  "status" text not null default 'draft',
+  "fields" jsonb not null default '{}'::jsonb,
+  "draft_version_id" uuid,
+  "published_version_id" uuid,
+  "updated_at" timestamptz not null default now(),
+  primary key ("entry_id", "locale")
+);
+
+create index if not exists "entry_locales_status_idx"
+  on "entry_locales" ("space_id", "locale", "status");
+
+-- A version belongs to ONE locale of one entry and stores the MERGED
+-- fields (shared + localized + slug) as they were at that save, so
+-- restoring an old Finnish version restores the shared fields too.
+-- Rows exist only for collections registered with \`versions: true\`.
+create table if not exists "entry_versions" (
+  "id" uuid primary key default gen_random_uuid(),
+  ${SPACE_COL},
+  "entry_id" uuid not null references "entries" ("id") on delete cascade,
+  "locale" text not null,
+  "fields" jsonb not null,
+  "created_by" text,
+  "created_at" timestamptz not null default now()
+);
+
+create index if not exists "entry_versions_entry_locale_idx"
+  on "entry_versions" ("entry_id", "locale", "created_at");
+
 -- v1 reorder (DESIGN.md §3 Manual ordering): rewrite sort 1..N in ONE
 -- statement. Deliberately does not touch updated_at — a drag must not
 -- make the whole collection look freshly edited. Scoped to the current
@@ -231,10 +271,13 @@ $$;
 -- (collectionSQL) run with security_invoker = true, so they are subject
 -- to this same smoodly_read policy rather than their owner's privileges.
 alter table "pages" enable row level security;
+alter table "page_locales" enable row level security;
 alter table "page_versions" enable row level security;
 alter table "saved_sections" enable row level security;
 alter table "global_sections" enable row level security;
 alter table "entries" enable row level security;
+alter table "entry_locales" enable row level security;
+alter table "entry_versions" enable row level security;
 alter table "refs" enable row level security;
 alter table "paths" enable row level security;
 `.trim(),

package/dist/store.d.ts

@@ -4,36 +4,43 @@ import { type RefEdge, type SectionLike } from "./refs.ts";
 import type { MemoryRefIndex } from "./ref-index.ts";
 import { type PathIndex } from "./path-index.ts";
 import { type LocaleSet, type PagePathOptions, type PathTarget } from "./paths.ts";
-export type PageI18n = Record<string, {
-    slug?: string;
-    title?: string;
-}>;
+export type PageLocale = {
+    /** The node's OWN segment in this locale; the URL is derived (paths.ts). */
+    slug: string;
+    title: string;
+    status: "draft" | "published";
+    draftVersionId: string | null;
+    publishedVersionId: string | null;
+};
 export type PageRecord = {
     id: string;
     parentId: string | null;
-    /** The node's OWN segment in the default locale; the URL is derived (paths.ts). */
-    slug: string;
-    title: string;
-    i18n: PageI18n | null;
     /** null = folder: a node with a title and a position but no page behind it. */
     template: string | null;
-    status: "draft" | "published";
     sort: number | null;
-    locales: string[] | null;
-    draftVersionId: string | null;
-    publishedVersionId: string | null;
+    /** One entry per locale the page exists in. */
+    locales: Record<string, PageLocale>;
 };
 export type CreatePageInput = {
+    /** The one locale the page is created in; others are added with addLocale. */
+    locale: string;
     slug: string;
     template: string | null;
     title?: string;
     parentId?: string | null;
-    i18n?: PageI18n | null;
-    locales?: string[] | null;
+};
+/** `from` names the locale whose draft tree, title and slug are copied;
+ *  `slug` and `title` override the copies (the materializer's per-locale
+ *  segments for fixed pages). */
+export type AddLocaleOptions = {
+    from: string;
+    slug?: string;
+    title?: string;
 };
 export type PageVersion = {
     id: string;
     pageId: string;
+    locale: string;
     tree: PageTree;
     createdAt: number;
 };
@@ -42,7 +49,13 @@ export interface PageStore {
     getPage(id: string): Promise<PageRecord | null>;
     listPages(): Promise<PageRecord[]>;
     resolvePath(locale: string, path: string): Promise<PathTarget | null>;
+    /** locale → path, for the locales the page exists in. */
     pathsOf(id: string): Promise<Record<string, string>>;
+    /** Refused when the page already has the locale or its parent lacks it (the parent rule). */
+    addLocale(id: string, locale: string, options: AddLocaleOptions): Promise<PageRecord>;
+    /** Deletes the row, its versions and its paths. Refused while a
+     *  descendant has the locale, and for the page's last locale. */
+    removeLocale(id: string, locale: string): Promise<PageRecord>;
     rename(id: string, patch: {
         locale: string;
         slug?: string;
@@ -53,17 +66,19 @@ export interface PageStore {
      * final 0-based position among the destination siblings: the node is
      * removed from the sibling list first, then spliced back in at `index`.
      * Omitted, it appends; out-of-range values clamp to [0, siblings.length].
+     * Refused when the destination lacks one of the page's locales.
      */
     move(id: string, to: {
         parentId: string | null;
         index?: number;
     }): Promise<PageRecord>;
+    /** A folder becomes a page: an empty draft version per present locale. */
     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>;
 }
 /** What a PageStore needs beyond its tables to maintain the refs index
@@ -94,16 +109,26 @@ export declare const pageErrors: {
     homeChildren: () => Error;
     cycle: () => Error;
     hasChildren: (id: string) => Error;
+    unsupportedLocale: (locale: string) => Error;
+    notInLocale: (id: string, locale: string) => Error;
+    alreadyInLocale: (id: string, locale: string) => Error;
+    parentNotInLocale: (locale: string) => Error;
+    lastLocale: (id: string) => Error;
+    localeInUse: (locale: string, titles: string[]) => Error;
+    moveLocales: (locale: string) => Error;
 };
-export declare function assertPageI18n(i18n: PageI18n | null | undefined): void;
-/** A page's refs rows cover BOTH live trees — edges(draft) ∪
- * edges(published) — so an entry stays delete-guarded while either tree
+export { assertSupportedLocale } from "./paths.ts";
+/** The page's row for a locale — the "does not exist in locale" guard every per-locale write runs. */
+export declare function localeRow(page: PageRecord, locale: string): PageLocale;
+/** 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 declare function pageRefEdges(draft: PageTree, published: PageTree | null, sections: SectionLike[]): RefEdge[];
-/** 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 declare function assertPublishable(label: string, tree: PageTree, sections: SectionLike[], entries: EntryStore): Promise<void>;
+export declare function pageRefEdges(trees: PageTree[], sections: SectionLike[]): RefEdge[];
+/** 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 declare function assertPublishable(label: string, tree: PageTree, sections: SectionLike[], entries: EntryStore, locale: string): Promise<void>;
 export declare class MemoryPageStore implements PageStore {
     private options;
     private pages;
@@ -118,18 +143,27 @@ export declare class MemoryPageStore implements PageStore {
     private byId;
     private must;
     private isHome;
+    private snapshot;
+    private children;
     private hasChildren;
     private siblings;
+    /** Sibling slugs are unique per parent PER LOCALE — a friendlier error
+     *  than the path index's, which stays the real invariant. */
     private assertSlugFree;
     private subtree;
     private writePaths;
+    /** Every locale's draft and published trees, deduped by version id. */
+    private liveTrees;
     private writeRefs;
     private newVersion;
+    private dropVersions;
     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<Record<string, string>>;
+    addLocale(id: string, locale: string, options: AddLocaleOptions): Promise<PageRecord>;
+    removeLocale(id: string, locale: string): Promise<PageRecord>;
     rename(id: string, patch: {
         locale: string;
         slug?: string;
@@ -140,10 +174,10 @@ export declare class MemoryPageStore 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>;
 }