@pramen/cms 0.0.53 → 0.0.55

package/dist/index.d.ts

@@ -925,7 +925,15 @@ export declare function createCmsHandlers(opts?: CmsHandlerOpts): {
     getContentType: import("@pramen/server").Handler<{
         id: string;
     }, Record<string, unknown>>;
-    listPages: import("@pramen/server").Handler<unknown, Record<string, unknown>[]>;
+    /** List pages, newest first. `contentType` (a content-type SLUG) narrows the list to one
+     * type — what an editor that gives each type its own tab needs, and the only way to stay
+     * correct once a deployment has more than `limit` entries in total: filtering the full
+     * list client-side would silently drop the tail of every type. Omitted ⇒ all types, the
+     * historical behaviour. An unknown slug returns nothing rather than everything, so a
+     * typo can never read as "here is the whole CMS". */
+    listPages: import("@pramen/server").Handler<{
+        contentType?: string;
+    }, Record<string, unknown>[]>;
     /** Public: list published pages (slug, locale, updatedAt) for sitemap generation. The
      * anonymous ACL scopes cms_pages reads to status=published, so this is safe to expose. */
     listPublishedPages: import("@pramen/server").Handler<unknown, {
@@ -1293,7 +1301,15 @@ export declare const cmsHandlers: {
     getContentType: import("@pramen/server").Handler<{
         id: string;
     }, Record<string, unknown>>;
-    listPages: import("@pramen/server").Handler<unknown, Record<string, unknown>[]>;
+    /** List pages, newest first. `contentType` (a content-type SLUG) narrows the list to one
+     * type — what an editor that gives each type its own tab needs, and the only way to stay
+     * correct once a deployment has more than `limit` entries in total: filtering the full
+     * list client-side would silently drop the tail of every type. Omitted ⇒ all types, the
+     * historical behaviour. An unknown slug returns nothing rather than everything, so a
+     * typo can never read as "here is the whole CMS". */
+    listPages: import("@pramen/server").Handler<{
+        contentType?: string;
+    }, Record<string, unknown>[]>;
     /** Public: list published pages (slug, locale, updatedAt) for sitemap generation. The
      * anonymous ACL scopes cms_pages reads to status=published, so this is safe to expose. */
     listPublishedPages: import("@pramen/server").Handler<unknown, {

package/dist/index.js

@@ -1300,7 +1300,32 @@ export function createCmsHandlers(opts = {}) {
             },
         }),
         // ---- pages ----
-        listPages: query((ctx) => cdb(ctx).find({ from: "cms_pages", orderBy: { column: "createdAt", dir: "desc" }, limit: 100 })),
+        /** List pages, newest first. `contentType` (a content-type SLUG) narrows the list to one
+         * type — what an editor that gives each type its own tab needs, and the only way to stay
+         * correct once a deployment has more than `limit` entries in total: filtering the full
+         * list client-side would silently drop the tail of every type. Omitted ⇒ all types, the
+         * historical behaviour. An unknown slug returns nothing rather than everything, so a
+         * typo can never read as "here is the whole CMS". */
+        listPages: query(async (ctx, input) => {
+            const db = cdb(ctx);
+            const order = { column: "createdAt", dir: "desc" };
+            if (!input?.contentType)
+                return db.find({ from: "cms_pages", orderBy: order, limit: 100 });
+            const types = await db.find({ from: "cms_content_types", where: { slug: input.contentType }, limit: 1 });
+            const typeId = types[0]?.id;
+            if (typeId == null)
+                return [];
+            return db.find({ from: "cms_pages", where: { typeId }, orderBy: order, limit: 100 });
+        }, {
+            input: (raw) => {
+                const o = asObj(raw);
+                if (o.contentType === undefined || o.contentType === null)
+                    return {};
+                if (typeof o.contentType !== "string")
+                    throw new BadRequest("contentType must be a string");
+                return { contentType: o.contentType };
+            },
+        }),
         /** Public: list published pages (slug, locale, updatedAt) for sitemap generation. The
          * anonymous ACL scopes cms_pages reads to status=published, so this is safe to expose. */
         listPublishedPages: query(async (ctx) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pramen/cms",
-  "version": "0.0.53",
+  "version": "0.0.55",
   "description": "Optional block/page builder for pramen — Drupal-Paragraphs-style typed blocks in named regions, reusable blocks, scheduled publishing, built entirely from pramen primitives.",
   "license": "MIT",
   "repository": {
@@ -41,7 +41,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pramen/server": "0.0.53"
+    "@pramen/server": "0.0.55"
   },
   "peerDependencies": {
     "react": ">=18"

package/src/index.ts

@@ -1752,7 +1752,31 @@ export function createCmsHandlers(opts: CmsHandlerOpts = {}) {
     }),
 
     // ---- pages ----
-    listPages: query((ctx) => cdb(ctx).find({ from: "cms_pages", orderBy: { column: "createdAt", dir: "desc" }, limit: 100 })),
+    /** List pages, newest first. `contentType` (a content-type SLUG) narrows the list to one
+     * type — what an editor that gives each type its own tab needs, and the only way to stay
+     * correct once a deployment has more than `limit` entries in total: filtering the full
+     * list client-side would silently drop the tail of every type. Omitted ⇒ all types, the
+     * historical behaviour. An unknown slug returns nothing rather than everything, so a
+     * typo can never read as "here is the whole CMS". */
+    listPages: query(
+      async (ctx, input: { contentType?: string }) => {
+        const db = cdb(ctx);
+        const order = { column: "createdAt", dir: "desc" } as const;
+        if (!input?.contentType) return db.find({ from: "cms_pages", orderBy: order, limit: 100 });
+        const types = await db.find({ from: "cms_content_types", where: { slug: input.contentType }, limit: 1 });
+        const typeId = types[0]?.id;
+        if (typeId == null) return [];
+        return db.find({ from: "cms_pages", where: { typeId }, orderBy: order, limit: 100 });
+      },
+      {
+        input: (raw): { contentType?: string } => {
+          const o = asObj(raw);
+          if (o.contentType === undefined || o.contentType === null) return {};
+          if (typeof o.contentType !== "string") throw new BadRequest("contentType must be a string");
+          return { contentType: o.contentType };
+        },
+      },
+    ),
 
     /** Public: list published pages (slug, locale, updatedAt) for sitemap generation. The
      * anonymous ACL scopes cms_pages reads to status=published, so this is safe to expose. */