smoodly 0.0.13 → 0.0.14

package/dist/site.js

@@ -1,8 +1,9 @@
-import { entryFieldsIn, schemaOf } from "./entry-store.js";
+import { ARRAY_FIELD_TYPES, entryFieldsIn, localizedKeys, schemaOf } from "./entry-store.js";
 import { buildPageTree, chainOf, entryPathRows, entrySegment, pagePath, } from "./paths.js";
 import { resolveFields, resolveMedia, resolveMediaSets, resolveTree } from "./resolve.js";
 import { elementSchemas } from "./richtext-walk.js";
 import { STYLES_KEY } from "./shared.js";
+import { withDefaults } from "./field-defaults.js";
 /** The `page` prop for a loaded page. `toUrl` is the app's `href` seam
  *  bound to the render locale; the default keeps CMS paths as URLs. */
 export function pageContextOf(hit, toUrl = (p) => p) {
@@ -12,6 +13,7 @@ export function pageContextOf(hit, toUrl = (p) => p) {
         title: hit.title,
         path: hit.path,
         url: toUrl(hit.path),
+        fields: hit.fields,
         ancestors: hit.ancestors.map(withUrl),
         children: hit.children.map(withUrl),
     };
@@ -46,11 +48,43 @@ export function createSmoodlySite(options) {
         const row = node.locales[locale];
         return node.template !== null && row !== undefined && (draft || row.status === "published");
     };
+    const pageFields = (template) => {
+        if (template === null)
+            return {};
+        const p = (options.pages ?? []).find((x) => x.schema.kind === "page" && x.schema.name === template);
+        return p?.schema.fields ?? {};
+    };
+    /** The version whose fields a link shows: the draft's in draft mode, else the published one. */
+    const versionFor = (node, locale, draft) => {
+        const row = node.locales[locale];
+        if (!row || node.template === null)
+            return null;
+        return draft ? row.draftVersionId : row.publishedVersionId;
+    };
+    /** Raw page fields (no asset resolution) of many nodes in ONE store read
+     *  (spec 2026-09-10 page fields §3), defaults applied; `{}` for a folder. */
+    async function linkFields(nodes, locale, draft) {
+        const { pages } = options.stores();
+        const wanted = new Map(); // node id → version id
+        for (const n of nodes) {
+            const v = versionFor(n, locale, draft);
+            if (v)
+                wanted.set(n.id, v);
+        }
+        const byVersion = wanted.size > 0 ? await pages.fieldsOf([...new Set(wanted.values())]) : {};
+        const out = new Map();
+        for (const n of nodes) {
+            const v = wanted.get(n.id);
+            out.set(n.id, n.template === null ? {} : withDefaults(v ? byVersion[v] : undefined, pageFields(n.template)));
+        }
+        return out;
+    }
     /** Only ever called for a node PRESENT in the locale (visible() or an ancestor of one). */
-    const link = (node, byId, locale, draft) => ({
+    const link = (node, byId, locale, draft, fields) => ({
         title: node.locales[locale].title,
         path: pagePath(node, byId, locale, pathOpts),
         hasPage: hasPage(node, locale, draft),
+        fields: fields.get(node.id) ?? {},
     });
     async function loadPage(id, locale, path, draft) {
         const { pages } = options.stores();
@@ -70,15 +104,16 @@ export function createSmoodlySite(options) {
             elements: options.elements,
             fetch: fetcher(draft, locale),
             assets: assetFetcher(),
+            page: { fields: pageFields(record.template) },
         });
         const all = await pages.listPages();
         const index = new Map(all.map((n) => [n.id, n]));
         const byId = (x) => index.get(x);
         const chain = chainOf(record, byId);
-        const ancestors = chain.slice(0, -1).map((n) => link(n, byId, locale, draft));
-        const children = all
-            .filter((n) => n.parentId === id && visible(n, locale, draft))
-            .map((n) => link(n, byId, locale, draft));
+        const kids = all.filter((n) => n.parentId === id && visible(n, locale, draft));
+        const fields = await linkFields([...chain.slice(0, -1), ...kids], locale, draft);
+        const ancestors = chain.slice(0, -1).map((n) => link(n, byId, locale, draft, fields));
+        const children = kids.map((n) => link(n, byId, locale, draft, fields));
         // Alternates advertise PUBLISHED locales only; the editor (draft) sees every present one.
         const paths = Object.fromEntries(Object.entries(await pages.pathsOf(id)).filter(([l]) => draft || record.locales[l]?.status === "published"));
         return {
@@ -88,6 +123,7 @@ export function createSmoodlySite(options) {
             tree,
             title: row.title,
             path,
+            fields: withDefaults(tree.fields, pageFields(record.template)),
             ancestors,
             children,
             paths,
@@ -131,28 +167,55 @@ export function createSmoodlySite(options) {
             path: entryPathRows([record], byId, schema, locales).find((r) => r.locale === locale)?.path ?? null,
         }));
     }
-    /** Public in a locale: its row exists there and is published. */
-    const publicEntry = (e, locale) => e.locales[locale]?.status === "published";
     async function getEntries(collection, o = {}) {
         const schema = schemaOf(options.collections, collection);
         const locale = localeOf(o);
+        const draft = o.draft ?? false;
         const { entries } = options.stores();
-        const all = await entries.list(collection, { order: o.order });
-        const wanted = all.filter((e) => publicEntry(e, locale) && (o.parent === undefined || e.parentId === o.parent));
-        const published = await entries.getMany(collection, wanted.map((e) => e.id), locale, { status: "published" });
+        // A filter that silently matched nothing would be worse than an error (spec 2026-09-11 §3).
+        for (const key of Object.keys(o.where ?? {})) {
+            if (key === "slug" || localizedKeys(schema).includes(key)) {
+                throw new Error(`smoodly: getEntries("${collection}"): "${key}" is localized — where filters shared fields only (spec 2026-09-11 §3).`);
+            }
+            if (!(key in schema.fields))
+                throw new Error(`smoodly: getEntries("${collection}"): "${key}" is not a field of the collection.`);
+            // Any-of reads the text form of the whole field (PostgREST's `->>`), which for
+            // an array is its JSON — `["a"]` never matches "a" — so refuse rather than match nothing.
+            if (Array.isArray(o.where[key]) && ARRAY_FIELD_TYPES.has(schema.fields[key].type ?? "")) {
+                throw new Error(`smoodly: getEntries("${collection}"): "${key}" is array-valued — any-of is for scalar fields; pass one value to match entries containing it.`);
+            }
+        }
+        if (o.limit !== undefined && (!Number.isInteger(o.limit) || o.limit < 0)) {
+            throw new Error(`smoodly: getEntries("${collection}"): limit must be a non-negative integer.`);
+        }
+        // The store filters, orders and limits (spec 2026-09-11 §3): the locale
+        // gate — presence in draft mode, published otherwise — is part of the
+        // query, so `limit` counts rows that are really there.
+        const inLocale = await entries.list(collection, {
+            order: o.order, where: o.where, limit: o.limit,
+            ...(o.parent !== undefined ? { parent: o.parent } : {}),
+            ...(draft ? { locale } : { status: "published", locale }),
+        });
+        // Paths need every ancestor: a tree collection reads the whole collection for that, a flat one does not.
+        const all = schema.tree ? await entries.list(collection) : inLocale;
+        const fieldsById = draft
+            ? Object.fromEntries(inLocale.map((e) => [e.id, entryFieldsIn(e, locale)]))
+            : await entries.getMany(collection, inLocale.map((e) => e.id), locale, { status: "published" });
         // Refs stay ids on the content API; media resolves (one asset round for
         // the whole list), because a list page's cards need their image URLs.
         const fetchAssets = assetFetcher();
         if (fetchAssets)
-            await resolveMediaSets(Object.values(published).map((values) => ({ values, descriptors: schema.fields })), fetchAssets, elements);
-        return entryItems(schema, wanted, all, locale, published);
+            await resolveMediaSets(Object.values(fieldsById).map((values) => ({ values, descriptors: schema.fields })), fetchAssets, elements);
+        return entryItems(schema, inLocale, all, locale, fieldsById);
     }
     const api = {
         async getPagesTree(o) {
             const locale = localeOf(o);
+            const draft = o?.draft ?? false;
             const all = await options.stores().pages.listPages();
-            const shown = all.filter((n) => visible(n, locale, false));
+            const shown = all.filter((n) => visible(n, locale, draft));
             const index = new Map(shown.map((n) => [n.id, n]));
+            const fields = await linkFields(shown, locale, draft);
             const toItem = (node) => ({
                 id: node.record.id,
                 title: node.record.locales[locale].title,
@@ -160,7 +223,8 @@ export function createSmoodlySite(options) {
                 // buildPageTree's nullable path is never null here; pagePath is
                 // the same derivation and keeps the type honest.
                 path: node.path ?? pagePath(node.record, (x) => index.get(x), locale, pathOpts),
-                hasPage: hasPage(node.record, locale, false),
+                hasPage: hasPage(node.record, locale, draft),
+                fields: fields.get(node.record.id) ?? {},
                 children: node.children.map(toItem),
             });
             return buildPageTree(shown, locale, pathOpts).map(toItem);
@@ -170,7 +234,7 @@ export function createSmoodlySite(options) {
             const path = pathOrId.startsWith("/") ? pathOrId : (await options.stores().pages.pathsOf(pathOrId))[locale];
             if (!path)
                 return null;
-            const hit = await site.resolve(locale, path);
+            const hit = await site.resolve(locale, path, { draft: o?.draft ?? false });
             return hit?.kind === "page" ? hit : null;
         },
         getEntries,
@@ -178,10 +242,10 @@ export function createSmoodlySite(options) {
             schemaOf(options.collections, collection); // an unknown collection is a wiring error on every branch
             const locale = localeOf(o);
             if (idOrPath.startsWith("/")) {
-                const hit = await site.resolve(locale, idOrPath);
+                const hit = await site.resolve(locale, idOrPath, { draft: o?.draft ?? false });
                 return hit?.kind === "entry" && hit.collection === collection ? { entry: hit.entry, path: hit.path } : null;
             }
-            const items = await getEntries(collection, { locale });
+            const items = await getEntries(collection, { locale, draft: o?.draft ?? false });
             const byId = items.find((i) => i.entry.id === idOrPath);
             if (byId)
                 return byId;
@@ -191,7 +255,7 @@ export function createSmoodlySite(options) {
             return items.find((i) => i.entry.parentId === null && entrySegment(i.entry, locale) === idOrPath) ?? null;
         },
         async getEntriesTree(collection, o) {
-            const items = await getEntries(collection, { locale: localeOf(o) });
+            const items = await getEntries(collection, { locale: localeOf(o), draft: o?.draft ?? false });
             const build = (parentId) => items.filter((i) => i.entry.parentId === parentId).map((i) => ({ ...i, children: build(i.entry.id) }));
             return build(null);
         },

package/dist/store.d.ts

@@ -78,6 +78,9 @@ export interface PageStore {
     publish(id: string, locale: string): Promise<PageRecord>;
     getDraftTree(id: string, locale: string): Promise<PageTree | null>;
     getPublishedTree(id: string, locale: string): Promise<PageTree | null>;
+    /** The page fields of many versions in ONE read (spec 2026-09-10 page fields §3):
+     *  versionId → `tree.fields ?? {}`; ids that do not exist are absent. */
+    fieldsOf(versionIds: string[]): Promise<Record<string, Record<string, unknown>>>;
     listVersions(id: string, locale: string): Promise<PageVersion[]>;
     deletePage(id: string): Promise<void>;
 }
@@ -179,6 +182,7 @@ export declare class MemoryPageStore implements PageStore {
     saveDraft(id: string, locale: string, tree: PageTree): Promise<PageVersion>;
     publish(id: string, locale: string): Promise<PageRecord>;
     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>;
     listVersions(id: string, locale: string): Promise<PageVersion[]>;
     deletePage(id: string): Promise<void>;

package/dist/store.js

@@ -410,6 +410,15 @@ export class MemoryPageStore {
             return null;
         return structuredClone(this.versions.get(row.draftVersionId)?.tree ?? null);
     }
+    async fieldsOf(versionIds) {
+        const out = {};
+        for (const id of versionIds) {
+            const v = this.versions.get(id);
+            if (v)
+                out[id] = structuredClone(v.tree.fields ?? {});
+        }
+        return out;
+    }
     async getPublishedTree(id, locale) {
         const row = this.pages.get(id)?.locales[locale];
         if (!row?.publishedVersionId)

package/dist/supabase-entry-store.js

@@ -7,7 +7,7 @@
 // calls the smoodly_reorder SQL function: one statement, updated_at
 // untouched.
 import { collectionDepth, collectionOrder } from "./collections.js";
-import { DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isSharedSchema, schemaOf, splitFields, } from "./entry-store.js";
+import { ARRAY_FIELD_TYPES, DEFAULT_ENTRY_LOCALES, entryErrors, entryFieldsIn, entryLocaleRow, entryRefEdges, entryTitleIn, isSharedSchema, schemaOf, splitFields, } from "./entry-store.js";
 import { sharedEntryId } from "./shared-id.js";
 import { SupabasePathIndex } from "./supabase-path-index.js";
 import { assertDepth, assertSupportedLocale, entryPathRows, slugOf } from "./paths.js";
@@ -316,10 +316,37 @@ export class SupabaseEntryStore {
     }
     async list(collection, options) {
         const schema = this.schema(collection);
-        let query = this.db.from("entries").select(SELECT).eq("collection", collection);
+        // A second, aliased embed of entry_locales carries the locale gate as an
+        // inner join — presence in the locale, and its status when asked — so
+        // `limit` counts rows that are really there; the first embed still returns
+        // EVERY locale row of each record (spec 2026-09-11 §3), ordered by locale
+        // so a record's key order never depends on physical row order.
+        const gate = options?.status !== undefined || options?.locale !== undefined;
+        let query = this.db
+            .from("entries")
+            .select(gate ? `${SELECT}, gate:entry_locales!inner(locale)` : SELECT)
+            .eq("collection", collection)
+            .order("locale", { referencedTable: "entry_locales", ascending: true });
+        if (gate) {
+            query = query.eq("gate.locale", options.locale ?? this.locales.default);
+            if (options.status !== undefined)
+                query = query.eq("gate.status", options.status);
+        }
         if (options?.parent !== undefined) {
             query = options.parent === null ? query.is("parent_id", null) : query.eq("parent_id", options.parent);
         }
+        for (const [key, want] of Object.entries(options?.where ?? {})) {
+            // Any-of compares the text form (`->>`). A scalar is JSONB containment;
+            // an array-valued field (checkboxes, refList, list) contains `[value]`,
+            // a scalar field `value` — the memory adapter's matchesWhere agrees.
+            if (Array.isArray(want)) {
+                query = query.in(`fields->>${key}`, want.map(String));
+            }
+            else {
+                const inArray = ARRAY_FIELD_TYPES.has(schema.fields[key]?.type ?? "");
+                query = query.contains("fields", { [key]: inArray ? [want] : want });
+            }
+        }
         const order = options?.order ?? collectionOrder(schema);
         if (order === "manual") {
             query = query.order("sort", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true });
@@ -330,17 +357,12 @@ export class SupabaseEntryStore {
             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 });
         }
+        if (typeof options?.limit === "number")
+            query = query.limit(options.limit);
         const res = await query;
         if (res.error)
             this.fail(res.error.message);
-        let rows = res.data.map(toRecord);
-        // The status filter reads the locale row; collections are small enough
-        // to filter here rather than lose the other rows to an !inner embed.
-        if (options?.status) {
-            const locale = options.locale ?? this.locales.default;
-            rows = rows.filter((e) => e.locales[locale]?.status === options.status);
-        }
-        return rows;
+        return res.data.map(({ gate: _gate, ...row }) => toRecord(row));
     }
     async getMany(collection, ids, locale, options) {
         this.schema(collection);

package/dist/supabase-store.d.ts

@@ -62,6 +62,7 @@ export declare class SupabasePageStore implements PageStore {
     saveDraft(id: string, locale: string, tree: PageTree): Promise<PageVersion>;
     publish(id: string, locale: string): Promise<PageRecord>;
     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>;
     listVersions(id: string, locale: string): Promise<PageVersion[]>;
     deletePage(id: string): Promise<void>;

package/dist/supabase-store.js

@@ -453,6 +453,19 @@ export class SupabasePageStore {
         const page = await this.row(id);
         return page ? this.versionTree(page.locales[locale]?.draftVersionId ?? null) : null;
     }
+    async fieldsOf(versionIds) {
+        const ids = versionIds.filter((id) => UUID_RE.test(id));
+        if (ids.length === 0)
+            return {};
+        // PostgREST's JSON arrow selects the `fields` key alone — the rest of the tree never leaves the database.
+        const res = await this.db.from("page_versions").select("id, fields:tree->fields").in("id", ids);
+        if (res.error)
+            this.fail(res.error.message);
+        const out = {};
+        for (const row of res.data)
+            out[row.id] = row.fields ?? {};
+        return out;
+    }
     async getPublishedTree(id, locale) {
         const page = await this.row(id);
         return page ? this.versionTree(page.locales[locale]?.publishedVersionId ?? null) : null;

package/package.json

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