smoodly 0.0.38 → 0.0.39

package/dist/admin/ops-impl.js

@@ -1,5 +1,5 @@
 import { entryErrors, entryFieldsIn, entryTitleIn } from "../entry-store.js";
-import { chainOf, isSegment, pagePathIn } from "../paths.js";
+import { chainOf, isSegment, pagePathIn, slugify } from "../paths.js";
 import { servedAnchor } from "../anchors.js";
 import { canonicalTags, distinctTags } from "../tags.js";
 import { can, isMemberRole, normalizeRole } from "../permissions.js";
@@ -112,6 +112,18 @@ const classify = (e) => {
         return err("conflict", message);
     return err("internal", message);
 };
+/** A new entry without a slug gets one from the field `f.slug({ from })` follows, as the admin's form
+ *  fills it (spec 2026-09-28 ASCII slugs §5), so a script needs no slug of its own. A given slug stays. */
+function followSlug(fields, descriptors) {
+    const d = descriptors.slug;
+    if (d?.type !== "slug" || d.from === undefined)
+        return fields;
+    if (typeof fields.slug === "string" && fields.slug !== "")
+        return fields;
+    const source = fields[d.from];
+    const slug = typeof source === "string" ? slugify(source) : "";
+    return slug === "" ? fields : { ...fields, slug };
+}
 export function createAdminOps(deps) {
     const { config, pages, entries, effects } = deps;
     const href = deps.href ?? ((path) => path);
@@ -783,7 +795,7 @@ export function createAdminOps(deps) {
                 const descriptors = collectionFields(collection);
                 if (!descriptors)
                     return err("not_found", `smoodly: no collection named "${collection}".`);
-                const created = await entries.create(collection, withDefaults(await foldTags(collection, input.locale, input.fields, descriptors), descriptors), { locale: input.locale, parentId: input.parentId ?? null }, by);
+                const created = await entries.create(collection, withDefaults(await foldTags(collection, input.locale, followSlug(input.fields, descriptors), descriptors), descriptors), { locale: input.locale, parentId: input.parentId ?? null }, by);
                 expireCollection(collection);
                 return ok(created);
             }),

package/dist/content/content-api.d.ts

@@ -54,6 +54,10 @@ export declare function createSmoodlyContent(deps: ContentDeps): {
             fields?: Record<string, unknown>;
         }): Promise<EntryRecord>;
         publish: (collection: string, id: string, locale: string) => Promise<EntryRecord>;
+        list: (collection: string, options?: {
+            where?: Record<string, unknown>;
+            locale?: string;
+        }) => Promise<EntryRecord[]>;
         find(collection: string, match: {
             slug: string;
             locale?: string;

package/dist/content/content-api.js

@@ -65,6 +65,25 @@ export function createSmoodlyContent(deps) {
     async function updateEntry(collection, id, locale, fields) {
         return must(ops.entries.save(collection, id, locale, fields));
     }
+    /** The entries present in `locale` (the default language unless given) whose fields match every `where` key:
+     *  shared and that locale's fields and its slug, equal, or held by an array field (tags, refList). */
+    async function listEntries(collection, options = {}) {
+        if (!deps.config.registry.collections?.some((c) => c.name === collection)) {
+            throw new SmoodlyContentError({ code: "not_found", message: `smoodly: no collection named "${collection}".` });
+        }
+        const locale = options.locale ?? def;
+        const where = Object.entries(options.where ?? {});
+        return (await must(ops.entries.list(collection))).filter((e) => {
+            const row = e.locales[locale];
+            if (!row)
+                return false;
+            const fields = { ...e.fields, ...row.fields, slug: row.slug };
+            return where.every(([key, want]) => {
+                const value = fields[key];
+                return Array.isArray(value) ? value.includes(want) : value === want;
+            });
+        });
+    }
     return {
         pages: {
             create: (input) => must(ops.pages.create(input)),
@@ -105,10 +124,9 @@ export function createSmoodlyContent(deps) {
                 return options.fields ? updateEntry(collection, id, locale, options.fields) : added;
             },
             publish: (collection, id, locale) => must(ops.entries.setStatus(collection, id, locale, "published")),
+            list: listEntries,
             async find(collection, match) {
-                const locale = match.locale ?? def;
-                const all = await must(ops.entries.list(collection));
-                return all.find((e) => e.locales[locale]?.slug === match.slug) ?? null;
+                return (await listEntries(collection, { where: { slug: match.slug }, locale: match.locale }))[0] ?? null;
             },
         },
         globals: {

package/dist/supabase-entry-store.js

@@ -48,6 +48,8 @@ function toRecord(row) {
 function toVersion(row) {
     return { id: row.id, entryId: row.entry_id, locale: row.locale, fields: row.fields, savedAt: Date.parse(row.saved_at) };
 }
+/** Rows per request when `list` reads a whole collection: under PostgREST's default cap. */
+const LIST_PAGE = 1000;
 export class SupabaseEntryStore {
     constructor(db, collections, options = {}) {
         this.db = db;
@@ -391,47 +393,61 @@ export class SupabaseEntryStore {
         // 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, tags) contains `[value]`,
-            // a scalar field `value` — the memory adapter's matchesWhere agrees.
-            if (Array.isArray(want)) {
-                query = query.in(`fields->>${key}`, want.map(String));
+        // Built per request: without a `limit` the list is read in pages, because
+        // PostgREST caps one response (1000 rows by default) without saying so.
+        const build = () => {
+            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, tags) 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") {
+                // `id` last in both orders: a stable order, so no row falls between two pages.
+                query = query.order("sort", { ascending: true, nullsFirst: false }).order("created_at", { ascending: true }).order("id", { ascending: true });
             }
             else {
-                const inArray = ARRAY_FIELD_TYPES.has(schema.fields[key]?.type ?? "");
-                query = query.contains("fields", { [key]: inArray ? [want] : want });
+                // `fields->x`, not `->>x`: ordering by the jsonb VALUE of the SHARED
+                // field (an order field is never localized), 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 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 of the SHARED
-            // field (an order field is never localized), 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 });
-        }
+            return query;
+        };
+        const rows = (res) => {
+            if (res.error)
+                this.fail(res.error.message);
+            return res.data.map(({ gate: _gate, ...row }) => toRecord(row));
+        };
         if (typeof options?.limit === "number")
-            query = query.limit(options.limit);
-        const res = await query;
-        if (res.error)
-            this.fail(res.error.message);
-        return res.data.map(({ gate: _gate, ...row }) => toRecord(row));
+            return rows(await build().limit(options.limit));
+        const all = [];
+        for (let from = 0;; from += LIST_PAGE) {
+            const page = rows(await build().range(from, from + LIST_PAGE - 1));
+            all.push(...page);
+            if (page.length < LIST_PAGE)
+                return all;
+        }
     }
     async query(collection, q) {
         const schema = this.schema(collection);

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const SMOODLY_VERSION = "0.0.38";
+export declare const SMOODLY_VERSION = "0.0.39";

package/dist/version.js

@@ -1,2 +1,2 @@
 // Generated by scripts/write-version.mjs from package.json — do not edit.
-export const SMOODLY_VERSION = "0.0.38";
+export const SMOODLY_VERSION = "0.0.39";

package/package.json

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