@xleddyl/nuxt-cms 0.1.42 → 0.1.44

package/README.md

@@ -97,8 +97,8 @@ Full documentation lives in [`docs/`](docs/README.md):
 - [Getting started](docs/getting-started.md) — install, configure, first content type, run.
 - [Configuration](docs/configuration.md) — every `cms.*` option and the `NUXT_CMS_*` env vars.
 - [Database](docs/database.md) — SQLite, Postgres, libSQL/Turso and D1 drivers, migrations, studio.
-- [Schema](docs/schema.md) — `defineCmsConfig`, entries, field types, relations, blocks, i18n.
-- [Querying content](docs/querying.md) — GraphQL API, `useCmsSingle` / `useCmsCollection` / `useCms` / `$cmsQuery`, filters, sorting, pagination.
+- [Schema](docs/schema.md) — `defineCmsConfig`, entries, pages, field types, relations, blocks, i18n.
+- [Querying content](docs/querying.md) — GraphQL API, `useCmsSingle` / `useCmsCollection` / `useCmsPage` / `useCms` / `$cmsQuery`, filters, sorting, pagination.
 - [Admin panel & security](docs/admin.md) — pages, authentication, sessions, admin REST API.
 - [Media](docs/media.md) — S3-compatible storage or local mode backed by your `public/` folder, upload flow, allowed file types.
 - [Deployment](docs/deployment.md) — host/driver matrix, migrations on serverless, horizontal scaling, Cloudflare Workers.

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@xleddyl/nuxt-cms",
   "configKey": "cms",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,5 +1,5 @@
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
+import { existsSync, readdirSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { join, isAbsolute, resolve, relative, dirname } from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -10,7 +10,7 @@ import { introspectionFromSchema, buildSchema } from 'graphql';
 import { minifyIntrospection, outputIntrospectionFile } from 'gql.tada/internal';
 import { createJiti } from 'jiti';
 import { typeName, blockTypeName, blocksFieldTypeName, renderGraphqlSdl } from '../dist/runtime/shared/graphql-sdl.js';
-import { isTranslatableField, isTranslatableMediaField, isMultiSelect, fieldConditions, isRequiredField, isPrivateField, mediaTypeFilter, DEFAULT_MEDIA_MAX_FILE_SIZE } from '../dist/runtime/shared/index.js';
+import { isTranslatableField, isTranslatableMediaField, isMultiSelect, pageAllFields, PAGE_PATH_FIELD, pageRoutes, fieldConditions, isRequiredField, pageFields, isPrivateField, entryFieldsFor, pageLabelFromPath, pageKeyFromPath, mediaTypeFilter, DEFAULT_MEDIA_MAX_FILE_SIZE } from '../dist/runtime/shared/index.js';
 import { scanMediaDirectory, readMediaFileMeta } from '../dist/runtime/server/utils/media-sync.js';
 import { createHash } from 'node:crypto';
 import { readFile } from 'node:fs/promises';
@@ -105,6 +105,7 @@ function validateConfig(config, i18n) {
       )}]`
     );
   }
+  let pageEntry;
   const entryIds = /* @__PURE__ */ new Map();
   const typeNames = /* @__PURE__ */ new Map();
   for (const [name, entry] of Object.entries(config)) {
@@ -130,8 +131,57 @@ function validateConfig(config, i18n) {
     } else {
       entryIds.set(entry.id, name);
     }
-    if (entry.kind !== "collection" && entry.kind !== "single")
-      errors.push(`${at}: kind must be 'collection' or 'single'`);
+    if (entry.kind !== "collection" && entry.kind !== "single" && entry.kind !== "page")
+      errors.push(`${at}: kind must be 'collection', 'single' or 'page'`);
+    if (entry.kind === "page") {
+      if (pageEntry) {
+        errors.push(
+          `${at}: only one page entry is allowed (already declared as '${pageEntry}')`
+        );
+      } else {
+        pageEntry = name;
+      }
+      if (entry.titleField) errors.push(`${at}: pages have no titleField`);
+      if (Object.hasOwn(entry.fields ?? {}, PAGE_PATH_FIELD))
+        errors.push(`${at}: '${PAGE_PATH_FIELD}' is a reserved field name on pages`);
+      const known = new Set(pageRoutes(entry).map((route) => route.path));
+      const keys = /* @__PURE__ */ new Map();
+      for (const route of pageRoutes(entry)) {
+        const clash = keys.get(route.key);
+        if (clash) errors.push(`${at}: paths '${clash}' and '${route.path}' give the same key`);
+        else keys.set(route.key, route.path);
+      }
+      for (const [path, override] of Object.entries(entry.overrides ?? {})) {
+        const oat = `${at}, override '${path}'`;
+        if (known.size && !known.has(path)) errors.push(`${oat}: '${path}' is not a page path`);
+        for (const [key, field] of Object.entries(override)) {
+          const shared = Object.hasOwn(entry.fields ?? {}, key);
+          if (field && shared)
+            errors.push(`${oat}: field '${key}' is already declared for every page`);
+          if (!field && !shared)
+            errors.push(
+              `${oat}: field '${key}' is not declared for every page, nothing to remove`
+            );
+          if (key === PAGE_PATH_FIELD)
+            errors.push(`${oat}: '${PAGE_PATH_FIELD}' is a reserved field name on pages`);
+        }
+      }
+      const declared = /* @__PURE__ */ new Map();
+      for (const override of Object.values(entry.overrides ?? {})) {
+        for (const [key, field] of Object.entries(override)) {
+          if (!field) continue;
+          const seen = declared.get(key);
+          if (seen && seen !== field.type) {
+            errors.push(
+              `${at}: field '${key}' is declared as '${seen}' and '${field.type}' by different pages`
+            );
+          }
+          declared.set(key, field.type);
+        }
+      }
+    } else if (entry.overrides || entry.routes || entry.include || entry.exclude) {
+      errors.push(`${at}: routes, include, exclude and overrides need kind 'page'`);
+    }
     if (entry.drafts && entry.kind !== "collection")
       errors.push(`${at}: drafts are only supported on collections`);
     if (!entry.fields || !Object.keys(entry.fields).length)
@@ -150,8 +200,9 @@ function validateConfig(config, i18n) {
         );
       }
     }
+    const allFields = entry.kind === "page" ? pageAllFields(entry) : entry.fields ?? {};
     const columnNames = /* @__PURE__ */ new Set();
-    for (const [key, field] of Object.entries(entry.fields ?? {})) {
+    for (const [key, field] of Object.entries(allFields)) {
       const fat = `${at}, field '${key}'`;
       if (!IDENTIFIER.test(key)) errors.push(`${fat}: key must be a valid identifier`);
       const column = snakeCase(key);
@@ -181,7 +232,7 @@ function validateConfig(config, i18n) {
           errors.push(`${fat}: the titleField cannot be conditional`);
         for (const condition of fieldConditions(field)) {
           const cat = `${fat}, showIf on '${condition.field}'`;
-          const target = entry.fields?.[condition.field];
+          const target = allFields[condition.field];
           if (!condition.field || !target) {
             errors.push(`${cat}: '${condition.field}' is not a declared field`);
             continue;
@@ -380,7 +431,10 @@ function tableExpr(name, entry, dialect) {
   const tableFn = pg ? "pgTable" : "sqliteTable";
   const lines = [];
   lines.push(`  id: text('id').primaryKey(),`);
-  for (const [key, field] of Object.entries(entry.fields)) {
+  if (entry.kind === "page") lines.push(`  path: text('path').notNull().unique(),`);
+  for (const [key, field] of Object.entries(
+    entry.kind === "page" ? pageAllFields(entry) : entry.fields
+  )) {
     if (isManyToMany(field)) continue;
     lines.push(columnExpr(key, field, dialect));
   }
@@ -440,7 +494,7 @@ function renderSchemaFile(config, dialect, resolveImport = (s) => s) {
   ];
   const tables = derived.map(([name, entry]) => tableExpr(name, entry, dialect));
   const joins = derived.flatMap(
-    ([name, entry]) => Object.entries(entry.fields).filter(([, field]) => isManyToMany(field)).map(([key, field]) => joinTableExpr(name, key, field, dialect))
+    ([name, entry]) => Object.entries(entry.kind === "page" ? pageAllFields(entry) : entry.fields).filter(([, field]) => isManyToMany(field)).map(([key, field]) => joinTableExpr(name, key, field, dialect))
   );
   return `${imports.join("\n")}
 
@@ -462,9 +516,10 @@ function blocksSelection(entryName, key, field) {
   }
   return parts.join(" ");
 }
-function entrySelection(config, name, entry, withRelations) {
+function entrySelection(config, name, entry, withRelations, fields = entryFieldsFor(entry)) {
   const parts = ["id"];
-  for (const [key, field] of Object.entries(entry.fields)) {
+  if (entry.kind === "page") parts.push("path");
+  for (const [key, field] of Object.entries(fields)) {
     if (isPrivateField(field)) continue;
     if (field.type === "relation") {
       const target = config[field.to];
@@ -502,10 +557,25 @@ function collectionQuery(config, name, entry) {
   ].join(", ");
   return `query CmsCollection(${args}) { ${name}(locale: $locale, filters: $filters, sort: $sort, limit: $limit, offset: $offset) { ${selection} } }`;
 }
+function pageQuery(config, name, entry, path) {
+  const selection = entrySelection(config, name, entry, true, pageFields(entry, path));
+  return `query CmsPage($path: String!, $locale: String) { page: ${name}ByPath(path: $path, locale: $locale) { ${selection} } }`;
+}
 function renderQueriesFile(config) {
   const singles = [];
   const collections = [];
+  const pages = [];
   for (const [name, entry] of Object.entries(config)) {
+    if (entry.kind === "page") {
+      for (const route of pageRoutes(entry)) {
+        pages.push(
+          `   ${JSON.stringify(route.path)}: ${JSON.stringify(
+            pageQuery(config, name, entry, route.path)
+          )},`
+        );
+      }
+      continue;
+    }
     const line = `   ${JSON.stringify(name)}: ${JSON.stringify(
       entry.kind === "single" ? singleQuery(config, name, entry) : collectionQuery(config, name, entry)
     )},`;
@@ -520,10 +590,53 @@ function renderQueriesFile(config) {
     `export const cmsCollectionQueries: Record<string, string> = {`,
     ...collections,
     `}`,
+    ``,
+    `export const cmsPageQueries: Record<string, string> = {`,
+    ...pages,
+    `}`,
     ``
   ].join("\n");
 }
 
+const DYNAMIC = /[[\]]/;
+function vueFiles(dir, prefix = "") {
+  if (!existsSync(dir)) return [];
+  const files = [];
+  for (const item of readdirSync(dir, { withFileTypes: true })) {
+    const name = `${prefix}${item.name}`;
+    if (item.isDirectory()) files.push(...vueFiles(join(dir, item.name), `${name}/`));
+    else if (item.name.endsWith(".vue")) files.push(name);
+  }
+  return files;
+}
+function routePathFromFile(file) {
+  if (DYNAMIC.test(file)) return null;
+  const segments = file.replace(/\.vue$/, "").split("/").filter((segment) => !/^\(.+\)$/.test(segment));
+  if (segments.at(-1) === "index") segments.pop();
+  const path = `/${segments.join("/")}`.replace(/\/$/, "");
+  return path || "/";
+}
+function routePathsFromDir(pagesDir) {
+  const paths = /* @__PURE__ */ new Set();
+  for (const file of vueFiles(pagesDir)) {
+    const path = routePathFromFile(file);
+    if (path) paths.add(path);
+  }
+  return [...paths];
+}
+function resolvePageRoutes(entry, discovered) {
+  const declared = Array.isArray(entry.routes) ? entry.routes : discovered;
+  const paths = /* @__PURE__ */ new Set([...declared, ...entry.include ?? []]);
+  for (const path of entry.exclude ?? []) paths.delete(path);
+  const rank = new Map((entry.order ?? []).map((path, index) => [path, index]));
+  const order = entry.order?.length ?? 0;
+  return [...paths].sort((a, b) => (rank.get(a) ?? order) - (rank.get(b) ?? order) || a.localeCompare(b)).map((path) => ({
+    path,
+    key: pageKeyFromPath(path),
+    label: entry.labels?.[path] ?? pageLabelFromPath(path)
+  }));
+}
+
 function mediaTsType(field) {
   const types = mediaTypeFilter(field.mediaType);
   return types ? `CmsMedia<${types.map((type) => `'${type}'`).join(" | ")}>` : "CmsMedia";
@@ -586,7 +699,8 @@ ${lines.join("\n")}
 }
 function entryTs(config, name, entry) {
   const lines = ["  id: string"];
-  for (const [key, field] of Object.entries(entry.fields)) {
+  if (entry.kind === "page") lines.push("  path: string");
+  for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
     if (isPrivateField(field)) continue;
     lines.push(`  ${key}: ${fieldTsType(config, name, key, field)}`);
   }
@@ -597,7 +711,7 @@ ${lines.join("\n")}
 }`;
 }
 function relationKeys(entry) {
-  return Object.entries(entry.fields).filter(([, field]) => field.type === "relation" && !isPrivateField(field)).map(([key]) => key);
+  return Object.entries(entryFieldsFor(entry)).filter(([, field]) => field.type === "relation" && !isPrivateField(field)).map(([key]) => key);
 }
 function quotedKeys(keys) {
   return keys.map((key) => `'${key}'`).join(" | ");
@@ -625,14 +739,37 @@ ${lines.join(
   )}
 }`;
 }
+function pageTypesTs(name, entry) {
+  const auto = `${typeName(name)}Auto`;
+  const lines = pageRoutes(entry).map((route) => {
+    const keys = ["id", "path", "updatedAt", ...Object.keys(pageFields(entry, route.path))];
+    return `  ${JSON.stringify(route.path)}: Pick<${auto}, ${quotedKeys(keys)}>`;
+  });
+  return [
+    `export interface CmsPageTypes {
+${lines.join("\n")}
+}`,
+    `export type CmsPagePath = keyof CmsPageTypes`
+  ];
+}
 function entryMapsTs(config) {
   const singles = [];
   const collections = [];
+  const pages = [];
   for (const [name, entry] of Object.entries(config)) {
     const line = `  ${JSON.stringify(name)}: ${typeName(name)}Auto`;
     if (entry.kind === "single") singles.push(line);
+    else if (entry.kind === "page") pages.push(...pageTypesTs(name, entry));
     else collections.push(line);
   }
+  if (!pages.length) {
+    pages.push(
+      `export interface CmsPageTypes {
+  [path: string]: never
+}`,
+      `export type CmsPagePath = keyof CmsPageTypes`
+    );
+  }
   return [
     `export interface CmsSingleTypes {
 ${singles.join("\n")}
@@ -641,7 +778,8 @@ ${singles.join("\n")}
 ${collections.join("\n")}
 }`,
     `export type CmsSingleName = keyof CmsSingleTypes`,
-    `export type CmsCollectionName = keyof CmsCollectionTypes`
+    `export type CmsCollectionName = keyof CmsCollectionTypes`,
+    ...pages
   ];
 }
 function renderTypesFile(config) {
@@ -660,7 +798,7 @@ function renderTypesFile(config) {
 }`
   ];
   for (const [name, entry] of Object.entries(config)) {
-    for (const [key, field] of Object.entries(entry.fields)) {
+    for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
       if (field.type === "blocks" && !isPrivateField(field))
         parts.push(...blockTypesTs(name, key, field));
     }
@@ -782,6 +920,38 @@ async function loadCmsConfig(nuxt, resolver, configPathOption, i18n, logger) {
     );
     nuxt.options.alias["#cms-config"] = resolver.resolve("./runtime/shared/empty-config");
   }
+  const pagesDir = join(
+    nuxt.options.srcDir ?? nuxt.options.rootDir,
+    nuxt.options.dir?.pages ?? "pages"
+  );
+  const discoveredRoutes = routePathsFromDir(pagesDir);
+  const routesByEntry = {};
+  for (const [name, entry] of Object.entries(cmsConfig)) {
+    if (entry.kind !== "page") continue;
+    entry.pages = resolvePageRoutes(entry, discoveredRoutes);
+    routesByEntry[name] = entry.pages;
+  }
+  if (Object.keys(routesByEntry).length) {
+    const source = (nuxt.options.alias["#cms-config"] ?? "").replace(/\\/g, "/").replace(/\.[cm]?[jt]s$/, "");
+    const wrapper = addTemplate({
+      filename: "cms/config.ts",
+      write: true,
+      getContents: () => [
+        `import config from '${source}'`,
+        ``,
+        `const pageRoutes = ${JSON.stringify(routesByEntry, null, 3)}`,
+        ``,
+        `for (const [name, routes] of Object.entries(pageRoutes)) {`,
+        `   const entry = (config as Record<string, { pages?: unknown }>)[name]`,
+        `   if (entry) entry.pages = routes`,
+        `}`,
+        ``,
+        `export default config`,
+        ``
+      ].join("\n")
+    });
+    nuxt.options.alias["#cms-config"] = wrapper.dst;
+  }
   const configErrors = validateConfig(cmsConfig, i18n);
   if (configErrors.length) {
     for (const error of configErrors) logger.error(error);
@@ -904,7 +1074,8 @@ const module$1 = defineNuxtModule({
         { name: "useCms", from: queryStub },
         { name: "$cmsQuery", from: queryStub },
         { name: "useCmsSingle", from: entryStub },
-        { name: "useCmsCollection", from: entryStub }
+        { name: "useCmsCollection", from: entryStub },
+        { name: "useCmsPage", from: entryStub }
       ]);
       addCmsTypeTemplates(
         nuxt,
@@ -966,7 +1137,8 @@ const module$1 = defineNuxtModule({
       { name: "useCms", from: queryComposables },
       { name: "$cmsQuery", from: queryComposables },
       { name: "useCmsSingle", from: entryComposables },
-      { name: "useCmsCollection", from: entryComposables }
+      { name: "useCmsCollection", from: entryComposables },
+      { name: "useCmsPage", from: entryComposables }
     ]);
     const {
       driver,

package/dist/runtime/app/composables/cms-entry-disabled.d.ts

@@ -1,5 +1,5 @@
 import type { AsyncData } from 'nuxt/app';
-import type { CmsCollectionName, CmsCollectionTypes, CmsSingleName, CmsSingleTypes } from '#cms-types';
+import type { CmsCollectionName, CmsCollectionTypes, CmsPagePath, CmsPageTypes, CmsSingleName, CmsSingleTypes } from '#cms-types';
 import type { CmsAsyncDataOptions } from './cms-query-disabled.js';
 export interface CmsSortInput<Entry> {
     field: Extract<keyof Entry, string>;
@@ -8,6 +8,9 @@ export interface CmsSortInput<Entry> {
 export interface CmsSingleOptions<ResT, DefaultT> extends CmsAsyncDataOptions<ResT, DefaultT> {
     locale?: string;
 }
+export interface CmsPageOptions<ResT, DefaultT> extends CmsAsyncDataOptions<ResT, DefaultT> {
+    locale?: string;
+}
 export interface CmsCollectionOptions<ResT, DefaultT, Entry> extends CmsAsyncDataOptions<ResT, DefaultT> {
     locale?: string;
     filters?: Record<string, unknown>;
@@ -17,3 +20,4 @@ export interface CmsCollectionOptions<ResT, DefaultT, Entry> extends CmsAsyncDat
 }
 export declare function useCmsSingle<K extends CmsSingleName, DefaultT = null>(name: K, options?: CmsSingleOptions<CmsSingleTypes[K] | null, DefaultT>): AsyncData<CmsSingleTypes[K] | DefaultT | null, Error | undefined>;
 export declare function useCmsCollection<K extends CmsCollectionName, DefaultT = CmsCollectionTypes[K][]>(name: K, options?: CmsCollectionOptions<CmsCollectionTypes[K][], DefaultT, CmsCollectionTypes[K]>): AsyncData<CmsCollectionTypes[K][] | DefaultT, Error | undefined>;
+export declare function useCmsPage<P extends CmsPagePath, DefaultT = null>(path: P, options?: CmsPageOptions<CmsPageTypes[P] | null, DefaultT>): AsyncData<CmsPageTypes[P] | DefaultT | null, Error | undefined>;

package/dist/runtime/app/composables/cms-entry-disabled.js

@@ -14,3 +14,10 @@ export function useCmsCollection(name, options = {}) {
     async () => fallback ? fallback() : []
   );
 }
+export function useCmsPage(path, options = {}) {
+  const { locale, key, default: fallback } = options;
+  return useAsyncData(
+    `cms-page:${String(path)}:${locale ?? ""}`,
+    async () => fallback ? fallback() : null
+  );
+}

package/dist/runtime/app/composables/cms-entry.d.ts

@@ -1,5 +1,5 @@
 import type { AsyncData } from 'nuxt/app';
-import type { CmsCollectionName, CmsCollectionTypes, CmsSingleName, CmsSingleTypes } from '#cms-types';
+import type { CmsCollectionName, CmsCollectionTypes, CmsPagePath, CmsPageTypes, CmsSingleName, CmsSingleTypes } from '#cms-types';
 import type { CmsAsyncDataOptions } from './cms-query.js';
 export interface CmsSortInput<Entry> {
     field: Extract<keyof Entry, string>;
@@ -8,6 +8,9 @@ export interface CmsSortInput<Entry> {
 export interface CmsSingleOptions<ResT, DefaultT> extends CmsAsyncDataOptions<ResT, DefaultT> {
     locale?: string;
 }
+export interface CmsPageOptions<ResT, DefaultT> extends CmsAsyncDataOptions<ResT, DefaultT> {
+    locale?: string;
+}
 export interface CmsCollectionOptions<ResT, DefaultT, Entry> extends CmsAsyncDataOptions<ResT, DefaultT> {
     locale?: string;
     filters?: Record<string, unknown>;
@@ -17,3 +20,4 @@ export interface CmsCollectionOptions<ResT, DefaultT, Entry> extends CmsAsyncDat
 }
 export declare function useCmsSingle<K extends CmsSingleName, DefaultT = null>(name: K, options?: CmsSingleOptions<CmsSingleTypes[K] | null, DefaultT>): AsyncData<CmsSingleTypes[K] | DefaultT | null, Error | undefined>;
 export declare function useCmsCollection<K extends CmsCollectionName, DefaultT = CmsCollectionTypes[K][]>(name: K, options?: CmsCollectionOptions<CmsCollectionTypes[K][], DefaultT, CmsCollectionTypes[K]>): AsyncData<CmsCollectionTypes[K][] | DefaultT, Error | undefined>;
+export declare function useCmsPage<P extends CmsPagePath, DefaultT = null>(path: P, options?: CmsPageOptions<CmsPageTypes[P] | null, DefaultT>): AsyncData<CmsPageTypes[P] | DefaultT | null, Error | undefined>;

package/dist/runtime/app/composables/cms-entry.js

@@ -1,4 +1,4 @@
-import { cmsCollectionQueries, cmsSingleQueries } from "#cms-queries";
+import { cmsCollectionQueries, cmsPageQueries, cmsSingleQueries } from "#cms-queries";
 import { useAsyncData } from "#imports";
 import { $cmsQuery } from "./cms-query.js";
 function unknownEntry(name) {
@@ -48,3 +48,20 @@ export function useCmsCollection(name, options = {}) {
     }
   );
 }
+export function useCmsPage(path, options = {}) {
+  const { locale, key, default: fallback, ...asyncDataOptions } = options;
+  const pagePath = String(path);
+  const query = cmsPageQueries[pagePath];
+  return useAsyncData(
+    key ?? `cms-page:${pagePath}:${locale ?? ""}`,
+    async () => {
+      if (!query) unknownEntry(pagePath);
+      const result = await $cmsQuery(query, { path: pagePath, locale });
+      return result?.page ?? null;
+    },
+    {
+      default: fallback ?? (() => null),
+      ...asyncDataOptions
+    }
+  );
+}

package/dist/runtime/app/layouts/cms-admin.vue

@@ -71,6 +71,11 @@ const groups = computed(
       icon: "document-text",
       links: links.filter((l) => l.kind === "single")
     },
+    {
+      title: "Pages",
+      icon: "window",
+      links: links.filter((l) => l.kind === "page")
+    },
     {
       title: "Library",
       icon: "photo",

package/dist/runtime/app/pages/admin-collection.vue

@@ -30,6 +30,49 @@
          />
       </div>
 
+      <template v-else-if="config.kind === 'page'">
+         <div class="cms-toolbar">
+            <CmsInput
+               v-if="total || searchTerm"
+               v-model="search"
+               icon="magnifying-glass"
+               placeholder="Search…"
+               class="flex-1"
+            />
+         </div>
+
+         <div v-if="rows.length" class="cms-card divide-y divide-(--cms-line)">
+            <NuxtLink
+               v-for="row in rows"
+               :key="String(row.id)"
+               :to="`/cms/${name}/${row.id}`"
+               class="flex items-center gap-4 px-4 py-3 transition-colors hover:bg-(--ui-bg-elevated)"
+            >
+               <div class="min-w-0 flex-1">
+                  <div class="truncate font-medium text-(--ui-text-highlighted)">
+                     {{ row.label }}
+                  </div>
+                  <div class="cms-label truncate">{{ row.path }}</div>
+               </div>
+               <span class="cms-label shrink-0">{{ row.updatedAt ? "edited" : "empty" }}</span>
+               <CmsIcon name="chevron-right" class="size-4 shrink-0 text-(--ui-text-dimmed)" />
+            </NuxtLink>
+         </div>
+
+         <CmsSpinner v-else-if="status === 'pending'" />
+
+         <CmsEmptyState v-else-if="searchTerm" icon="magnifying-glass" title="No matching pages" />
+
+         <CmsEmptyState
+            v-else
+            icon="document-text"
+            title="No pages yet"
+            body="Pages come from the routes of the app."
+         />
+
+         <CmsPagination v-model:page="page" :total="total" :items-per-page="PAGE_SIZE" />
+      </template>
+
       <template v-else>
          <div class="cms-toolbar">
             <CmsInput
@@ -168,7 +211,7 @@ const listQuery = computed(() => ({
   ...sort.value ? { sort: sort.value.key, order: sort.value.order } : {}
 }));
 const { data, refresh, error, status } = await useFetch(endpoint, {
-  query: config.kind === "collection" ? listQuery : void 0
+  query: config.kind === "single" ? void 0 : listQuery
 });
 function isList(value) {
   return !!value && Array.isArray(value.items);

package/dist/runtime/app/pages/admin-entry.vue

@@ -1,6 +1,6 @@
 <template>
    <div class="cms-page">
-      <CmsPageHeader :title="isNew ? 'New entry' : 'Edit entry'">
+      <CmsPageHeader :title="headerTitle">
          <template v-if="drafts" #badge>
             <CmsStatusBadge :published="published" />
          </template>
@@ -21,7 +21,7 @@
       <div class="cms-card cms-panel">
          <CmsEntryForm
             v-model="formState"
-            :fields="config.fields"
+            :fields="fields"
             :drafts="drafts"
             :form-id="FORM_ID"
             :loading="saving"
@@ -33,6 +33,7 @@
 </template>
 
 <script setup>
+import { pageFields, pageRouteOf } from "#nuxt-cms";
 import {
   computed,
   createError,
@@ -61,13 +62,20 @@ const route = useRoute();
 const toast = useCmsToast();
 const name = route.params.collection;
 const config = cmsConfig[name];
-if (!config || config.kind !== "collection") {
+if (!config || config.kind !== "collection" && config.kind !== "page") {
   throw createError({ statusCode: 404, statusMessage: "Unknown collection", fatal: true });
 }
 const id = route.params.id;
-const isNew = id === void 0;
-const drafts = !!config.drafts;
-const fieldKeys = Object.keys(config.fields);
+const isPage = config.kind === "page";
+const pageRoute = isPage && id ? pageRouteOf(config, id) : void 0;
+if (isPage && !pageRoute) {
+  throw createError({ statusCode: 404, statusMessage: "Unknown page", fatal: true });
+}
+const isNew = !isPage && id === void 0;
+const drafts = !isPage && !!config.drafts;
+const fields = pageRoute ? pageFields(config, pageRoute.path) : config.fields;
+const headerTitle = pageRoute ? pageRoute.label : isNew ? "New entry" : "Edit entry";
+const fieldKeys = Object.keys(fields);
 const formKeys = drafts ? [...fieldKeys, "status"] : fieldKeys;
 const endpoint = `/api/cms/admin/${name}`;
 function emptyState() {

package/dist/runtime/server/api/collection.get.js

@@ -2,6 +2,7 @@ import { asc, count, desc, sql } from "drizzle-orm";
 import { defineEventHandler, getValidatedQuery } from "h3";
 import { z } from "zod";
 import { useDb } from "#cms-db";
+import { pageRoutes } from "../../shared/index.js";
 import { decodeRows, getRegistryEntry, idColumn, tableColumns } from "../utils/registry.js";
 import { attachManyToMany, relationTitles } from "../utils/relations.js";
 import { requireAdmin } from "../utils/require-admin.js";
@@ -29,6 +30,24 @@ export default defineEventHandler(async (event) => {
     event,
     querySchema.parse
   );
+  if (entry.kind === "page") {
+    const rows = await db.select().from(table);
+    decodeRows(entry, rows);
+    const saved = new Map(rows.map((row) => [row.id, row]));
+    const items2 = pageRoutes(entry).map((route) => {
+      const row = saved.get(route.key) ?? {};
+      return { ...row, id: route.key, path: route.path, label: route.label };
+    });
+    const term = search?.toLowerCase();
+    const matching = term ? items2.filter(
+      (item) => item.path.toLowerCase().includes(term) || item.label.toLowerCase().includes(term)
+    ) : items2;
+    return {
+      items: matching.slice(offset, offset + limit),
+      total: matching.length,
+      relations: {}
+    };
+  }
   const columns = tableColumns(table);
   const titleColumn = entry.titleField && Object.hasOwn(columns, entry.titleField) ? columns[entry.titleField] : void 0;
   let where;

package/dist/runtime/server/api/item.delete.js

@@ -8,7 +8,10 @@ export default defineEventHandler(async (event) => {
   await requireAdmin(event);
   const { entry, table } = getRegistryEntry(event);
   if (entry.kind !== "collection") {
-    throw createError({ statusCode: 405, statusMessage: "Single objects cannot be deleted" });
+    throw createError({
+      statusCode: 405,
+      statusMessage: "Only collection entries can be deleted"
+    });
   }
   const id = parseId(event);
   return mapConstraintErrors(async () => {

package/dist/runtime/server/api/item.get.js

@@ -1,18 +1,29 @@
 import { eq } from "drizzle-orm";
 import { createError, defineEventHandler } from "h3";
 import { useDb } from "#cms-db";
-import { decodeRows, getRegistryEntry, idColumn, parseId } from "../utils/registry.js";
+import {
+  decodeRows,
+  getRegistryEntry,
+  idColumn,
+  parseId,
+  requirePageRoute
+} from "../utils/registry.js";
 import { attachManyToMany } from "../utils/relations.js";
 import { requireAdmin } from "../utils/require-admin.js";
 export default defineEventHandler(async (event) => {
   await requireAdmin(event);
   const { name, entry, table } = getRegistryEntry(event);
-  if (entry.kind !== "collection") {
+  if (entry.kind === "single") {
     throw createError({ statusCode: 404, statusMessage: "Single objects have no items" });
   }
   const id = parseId(event);
   const db = useDb();
   const rows = await db.select().from(table).where(eq(idColumn(table), id)).limit(1);
+  if (entry.kind === "page") {
+    const route = requirePageRoute(entry, id);
+    if (!rows[0]) return { id: route.key, path: route.path };
+    return decodeRows(entry, [rows[0]])[0];
+  }
   if (!rows[0]) throw createError({ statusCode: 404, statusMessage: "Row not found" });
   const [attached] = await attachManyToMany(db, name, entry, [rows[0]]);
   return decodeRows(entry, [attached])[0];

package/dist/runtime/server/api/item.put.js

@@ -8,6 +8,7 @@ import {
   getRegistryEntry,
   idColumn,
   parseId,
+  requirePageRoute,
   withUpdatedAt
 } from "../utils/registry.js";
 import {
@@ -21,13 +22,25 @@ import { mapConstraintErrors } from "../utils/db-errors.js";
 export default defineEventHandler(async (event) => {
   await requireAdmin(event);
   const { name, entry, table } = getRegistryEntry(event);
-  if (entry.kind !== "collection") {
+  if (entry.kind === "single") {
     throw createError({
       statusCode: 405,
       statusMessage: "Single objects are updated with PUT without id"
     });
   }
   const id = parseId(event);
+  if (entry.kind === "page") {
+    const route = requirePageRoute(entry, id);
+    const body2 = await readValidatedBody(event, buildValidator(entry, route.path).parse);
+    const values2 = encodeColumnValues(entry, body2);
+    const set2 = withUpdatedAt(table, values2);
+    return mapConstraintErrors(
+      () => withTransaction(async (db) => {
+        const [row] = await db.insert(table).values({ id: route.key, path: route.path, ...set2 }).onConflictDoUpdate({ target: idColumn(table), set: set2 }).returning();
+        return decodeRows(entry, [row])[0];
+      })
+    );
+  }
   const body = await readValidatedBody(event, buildValidator(entry).parse);
   const { values, lists } = splitRelationValues(
     entry,

package/dist/runtime/server/utils/graphql.js

@@ -21,6 +21,7 @@ import * as cmsTables from "#cms-tables";
 import { useRuntimeConfig } from "#imports";
 import {
   decodeTranslatableMedia,
+  entryFieldsFor,
   hasTranslatableBlockFields,
   isPrivateField,
   isTranslatableMediaField,
@@ -102,8 +103,9 @@ function resolveLocaleArg(locale) {
 function localizeRow(entry, row, locale) {
   const { defaultLocale } = getContentI18n();
   const result = { ...row, [LOCALE]: locale };
+  const fields = entryFieldsFor(entry);
   for (const key of translatableFieldKeys(entry)) {
-    if (isTranslatableMediaField(entry.fields[key])) {
+    if (isTranslatableMediaField(fields[key])) {
       const media = decodeTranslatableMedia(row[key], defaultLocale);
       result[key] = pickTranslatedMedia(media, locale, defaultLocale);
       continue;
@@ -111,7 +113,7 @@ function localizeRow(entry, row, locale) {
     const value = row[key];
     result[key] = value?.[locale] ?? value?.[defaultLocale] ?? null;
   }
-  for (const [key, field] of Object.entries(entry.fields)) {
+  for (const [key, field] of Object.entries(fields)) {
     if (isPrivateField(field) || !hasTranslatableBlockFields(field)) continue;
     result[key] = localizeBlocks(field, result[key], locale, defaultLocale);
   }
@@ -268,7 +270,7 @@ function mediaObject(key, row) {
 }
 function entryResolvers(config, name, entry) {
   const resolvers = {};
-  for (const [key, field] of Object.entries(entry.fields)) {
+  for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
     if (isPrivateField(field)) continue;
     if (field.type === "relation" && field.cardinality === "many-to-many") {
       resolvers[key] = async (parent, _args, ctx) => {
@@ -313,10 +315,25 @@ export function buildCmsSchema() {
     const gqlType = typeName(name);
     const fieldLevel = entryResolvers(config, name, entry);
     if (Object.keys(fieldLevel).length) typeResolvers[gqlType] = fieldLevel;
-    for (const [key, field] of Object.entries(entry.fields)) {
+    for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
       if (field.type === "blocks" && !isPrivateField(field))
         Object.assign(typeResolvers, blockResolvers(name, key, field));
     }
+    if (entry.kind === "page") {
+      queryResolvers[name] = async (_, args) => {
+        const locale = resolveLocaleArg(args.locale);
+        const table = tableFor(name);
+        const rows = await useDb().select().from(table).orderBy(asc(tableColumns(table).path));
+        return rows.map((row) => localizeRow(entry, row, locale));
+      };
+      queryResolvers[`${name}ByPath`] = async (_, args) => {
+        const locale = resolveLocaleArg(args.locale);
+        const table = tableFor(name);
+        const [row] = await useDb().select().from(table).where(eq(tableColumns(table).path, args.path)).limit(1);
+        return row ? localizeRow(entry, row, locale) : null;
+      };
+      continue;
+    }
     if (entry.kind === "single") {
       queryResolvers[name] = async (_, args) => {
         const locale = resolveLocaleArg(args.locale);

package/dist/runtime/server/utils/registry.d.ts

@@ -1,7 +1,7 @@
 import type { AnySQLiteColumn, SQLiteTable } from 'drizzle-orm/sqlite-core';
 import type { H3Event } from 'h3';
 import { z } from 'zod';
-import type { CmsEntry, CmsI18n } from '../../shared/index.js';
+import type { CmsEntry, CmsI18n, CmsPageRoute } from '../../shared/index.js';
 export declare function getContentI18n(): CmsI18n;
 export declare function resolveTable(name: string): SQLiteTable | undefined;
 export declare function tableColumns(table: SQLiteTable): Record<string, AnySQLiteColumn>;
@@ -14,9 +14,10 @@ export declare function getRegistryEntry(event: H3Event): {
     entry: CmsEntry;
     table: SQLiteTable;
 };
-export declare function buildValidator(entry: CmsEntry): z.ZodObject<{
+export declare function buildValidator(entry: CmsEntry, path?: string): z.ZodObject<{
     [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
 }, z.core.$strip>;
+export declare function requirePageRoute(entry: CmsEntry, key: string): CmsPageRoute;
 export declare function encodeColumnValues(entry: CmsEntry, values: Record<string, unknown>): Record<string, unknown>;
 export declare function decodeRows<T extends Record<string, unknown>>(entry: CmsEntry, rows: T[]): T[];
 export declare function parseId(event: H3Event): string;

package/dist/runtime/server/utils/registry.js

@@ -3,7 +3,12 @@ import { z } from "zod";
 import cmsConfig from "#cms-config";
 import * as cmsTables from "#cms-tables";
 import { useRuntimeConfig } from "#imports";
-import { decodeEntryTranslatableMedia, encodeEntryTranslatableMedia } from "../../shared/index.js";
+import {
+  decodeEntryTranslatableMedia,
+  encodeEntryTranslatableMedia,
+  pageFields,
+  pageRouteOf
+} from "../../shared/index.js";
 import { buildEntrySchema } from "../../shared/validation.js";
 let contentI18n;
 export function getContentI18n() {
@@ -40,8 +45,14 @@ export function getRegistryEntry(event) {
   }
   return { name, entry: config[name], table };
 }
-export function buildValidator(entry) {
-  return buildEntrySchema(entry, getContentI18n());
+export function buildValidator(entry, path) {
+  const fields = path ? pageFields(entry, path) : entry.fields;
+  return buildEntrySchema({ ...entry, fields }, getContentI18n());
+}
+export function requirePageRoute(entry, key) {
+  const route = pageRouteOf(entry, key);
+  if (!route) throw createError({ statusCode: 404, statusMessage: `Unknown page: ${key}` });
+  return route;
 }
 export function encodeColumnValues(entry, values) {
   return encodeEntryTranslatableMedia(entry, values);

package/dist/runtime/server/utils/relations.js

@@ -3,9 +3,10 @@ import { createError } from "h3";
 import cmsConfig from "#cms-config";
 import { useDb } from "#cms-db";
 import * as cmsTables from "#cms-tables";
+import { entryFieldsFor } from "../../shared/index.js";
 import { resolveTable, tableColumns } from "./registry.js";
 function manyToManyKeys(entry) {
-  return Object.entries(entry.fields).filter(([, field]) => field.type === "relation" && field.cardinality === "many-to-many").map(([key]) => key);
+  return Object.entries(entryFieldsFor(entry)).filter(([, field]) => field.type === "relation" && field.cardinality === "many-to-many").map(([key]) => key);
 }
 function joinTable(name, key) {
   const table = cmsTables[`${name}_${key}`];
@@ -34,7 +35,7 @@ export async function assertRelationTargets(entry, lists) {
   const db = useDb();
   for (const [key, ids] of Object.entries(lists)) {
     if (!ids.length) continue;
-    const field = entry.fields[key];
+    const field = entryFieldsFor(entry)[key];
     const target = resolveTable(field.to);
     if (!target) continue;
     const idCol = tableColumns(target).id;
@@ -61,7 +62,7 @@ export async function saveManyToMany(db, name, sourceId, lists) {
 export async function relationTitles(db, entry, rows) {
   const config = cmsConfig;
   const titles = {};
-  for (const [key, field] of Object.entries(entry.fields)) {
+  for (const [key, field] of Object.entries(entryFieldsFor(entry))) {
     if (field.type !== "relation" || !field.to) continue;
     const targetEntry = config[field.to];
     const target = resolveTable(field.to);

package/dist/runtime/shared/graphql-sdl.js

@@ -1,12 +1,17 @@
 import {
+  PAGE_PATH_FIELD,
   blockTypeName,
   blocksFieldTypeName,
   isPrivateField,
   isRequiredField,
   isTranslatableField,
+  pageAllFields,
   typeName
 } from "./index.js";
 export { blockTypeName, blocksFieldTypeName, typeName };
+function entryFields(entry) {
+  return entry.kind === "page" ? pageAllFields(entry) : entry.fields;
+}
 function scalarFor(field) {
   switch (field.type) {
     case "number":
@@ -62,7 +67,8 @@ function fieldSdl(config, entryName, key, field) {
 }
 function entrySdl(config, name, entry) {
   const lines = ["  id: ID!"];
-  for (const [key, field] of Object.entries(entry.fields)) {
+  if (entry.kind === "page") lines.push(`  ${PAGE_PATH_FIELD}: String!`);
+  for (const [key, field] of Object.entries(entryFields(entry))) {
     if (isPrivateField(field)) continue;
     lines.push(fieldSdl(config, name, key, field));
   }
@@ -146,7 +152,7 @@ export function renderGraphqlSdl(config) {
   for (const [name, entry] of Object.entries(config)) {
     const gqlType = typeName(name);
     types.push(entrySdl(config, name, entry));
-    for (const [key, field] of Object.entries(entry.fields)) {
+    for (const [key, field] of Object.entries(entryFields(entry))) {
       if (field.type === "blocks" && !isPrivateField(field))
         types.push(...blocksSdl(name, key, field));
     }
@@ -154,6 +160,11 @@ export function renderGraphqlSdl(config) {
       queryLines.push(`  ${name}(locale: String): ${gqlType}`);
       continue;
     }
+    if (entry.kind === "page") {
+      queryLines.push(`  ${name}(locale: String): [${gqlType}!]!`);
+      queryLines.push(`  ${name}ByPath(path: String!, locale: String): ${gqlType}`);
+      continue;
+    }
     types.push(filterSdl(name, entry));
     queryLines.push(
       `  ${name}(filters: ${gqlType}Filters, sort: [${gqlType}Sort!], limit: Int, offset: Int, locale: String): [${gqlType}!]!`

package/dist/runtime/shared/index.d.ts

@@ -79,25 +79,51 @@ export declare function decodeTranslatableValue(value: unknown, defaultLocale: s
 export declare const decodeTranslatableMedia: typeof decodeTranslatableValue;
 export declare function encodeTranslatableMedia(value: unknown): string | null;
 export declare function pickTranslatedMedia(values: Record<string, string> | null | undefined, locale: string, defaultLocale: string): string | null;
-export declare function translatableMediaKeys(entry: Pick<CmsEntry, 'fields'>): string[];
-export declare function encodeEntryTranslatableMedia(entry: Pick<CmsEntry, 'fields'>, values: Record<string, unknown>): Record<string, unknown>;
-export declare function decodeEntryTranslatableMedia<T extends Record<string, unknown>>(entry: Pick<CmsEntry, 'fields'>, rows: T[], defaultLocale: string): T[];
+export declare function translatableMediaKeys(entry: EntryLike): string[];
+export declare function encodeEntryTranslatableMedia(entry: EntryLike, values: Record<string, unknown>): Record<string, unknown>;
+export declare function decodeEntryTranslatableMedia<T extends Record<string, unknown>>(entry: EntryLike, rows: T[], defaultLocale: string): T[];
 export declare function isMultiSelect(field: FieldConfig): boolean;
-export declare function translatableFieldKeys(entry: CmsEntry): string[];
+export declare function translatableFieldKeys(entry: EntryLike): string[];
 export declare function translatableBlockFieldKeys(block: BlockConfig): string[];
 export declare function hasTranslatableBlockFields(field: FieldConfig): boolean;
 export declare function localizeBlock(field: FieldConfig, item: unknown, locale: string, defaultLocale: string): unknown;
 export declare function localizeBlocks(field: FieldConfig, value: unknown, locale: string, defaultLocale: string): unknown;
+export type CmsEntryKind = 'collection' | 'single' | 'page';
+export interface CmsPageRoute {
+    path: string;
+    key: string;
+    label: string;
+}
 export interface CmsEntry {
     id: string;
     label: string;
-    kind: 'collection' | 'single';
+    kind: CmsEntryKind;
     titleField?: string;
     drafts?: boolean;
     fields: Record<string, FieldConfig>;
+    routes?: 'auto' | string[];
+    include?: string[];
+    exclude?: string[];
+    order?: string[];
+    labels?: Record<string, string>;
+    overrides?: Record<string, Record<string, FieldConfig | null>>;
+    pages?: CmsPageRoute[];
     table?: CmsTable;
 }
 export type CmsConfig = Record<string, CmsEntry>;
+export declare const PAGE_PATH_FIELD = "path";
+export declare function isPageEntry(entry: CmsEntry): boolean;
+export declare function pageSegments(path: string): string[];
+export declare function pageKeyFromPath(path: string): string;
+export declare function pageLabelFromPath(path: string): string;
+export declare function pageParentPath(path: string): string | undefined;
+export declare function pageRoutes(entry: CmsEntry): CmsPageRoute[];
+export declare function pageRouteOf(entry: CmsEntry, key: string): CmsPageRoute | undefined;
+export declare function pageOverrideFields(entry: CmsEntry, path: string): Record<string, FieldConfig | null>;
+export declare function pageFields(entry: CmsEntry, path: string): Record<string, FieldConfig>;
+export declare function pageAllFields(entry: CmsEntry): Record<string, FieldConfig>;
+type EntryLike = Pick<CmsEntry, 'fields'> & Partial<Pick<CmsEntry, 'kind' | 'overrides'>>;
+export declare function entryFieldsFor(entry: EntryLike, path?: string): Record<string, FieldConfig>;
 export declare function typeName(name: string): string;
 export declare function blocksFieldTypeName(entryName: string, fieldKey: string): string;
 export declare function blockTypeName(entryName: string, fieldKey: string, blockName: string): string;
@@ -178,7 +204,18 @@ export interface CmsSingleInput extends CmsEntryInputBase {
     kind: 'single';
     titleField?: never;
 }
-export type CmsEntryInput = CmsCollectionInput | CmsSingleInput;
+export interface CmsPageInput extends CmsEntryInputBase {
+    kind: 'page';
+    titleField?: never;
+    drafts?: never;
+    routes?: 'auto' | string[];
+    include?: string[];
+    exclude?: string[];
+    order?: string[];
+    labels?: Record<string, string>;
+    overrides?: Record<string, Record<string, CmsFieldInput | null>>;
+}
+export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput;
 export type CmsConfigInput = Record<string, CmsEntryInput>;
 export declare function defineCmsConfig<T extends CmsConfigInput>(config: T): T;
 export {};

package/dist/runtime/shared/index.js

@@ -129,7 +129,7 @@ export function pickTranslatedMedia(values, locale, defaultLocale) {
   return values[locale] || values[defaultLocale] || Object.values(values).find(Boolean) || null;
 }
 export function translatableMediaKeys(entry) {
-  return Object.entries(entry.fields).filter(([, field]) => isTranslatableMediaField(field)).map(([key]) => key);
+  return Object.entries(entryFieldsFor(entry)).filter(([, field]) => isTranslatableMediaField(field)).map(([key]) => key);
 }
 export function encodeEntryTranslatableMedia(entry, values) {
   const keys = translatableMediaKeys(entry);
@@ -156,7 +156,7 @@ export function isMultiSelect(field) {
   return field.type === "select" && !!field.multiple;
 }
 export function translatableFieldKeys(entry) {
-  return Object.entries(entry.fields).filter(([, field]) => isTranslatableField(field)).map(([key]) => key);
+  return Object.entries(entryFieldsFor(entry)).filter(([, field]) => isTranslatableField(field)).map(([key]) => key);
 }
 export function translatableBlockFieldKeys(block) {
   return Object.entries(block.fields).filter(([, field]) => isTranslatableField(field)).map(([key]) => key);
@@ -184,6 +184,58 @@ export function localizeBlocks(field, value, locale, defaultLocale) {
   if (!Array.isArray(value)) return value;
   return value.map((item) => localizeBlock(field, item, locale, defaultLocale));
 }
+export const PAGE_PATH_FIELD = "path";
+export function isPageEntry(entry) {
+  return entry.kind === "page";
+}
+export function pageSegments(path) {
+  return path.split("/").filter(Boolean);
+}
+export function pageKeyFromPath(path) {
+  const words = pageSegments(path).flatMap((segment) => segment.split("-"));
+  if (!words.length) return "home";
+  return words.map((word, index) => index === 0 ? word : word.charAt(0).toUpperCase() + word.slice(1)).join("");
+}
+export function pageLabelFromPath(path) {
+  const last = pageSegments(path).pop();
+  if (!last) return "Home";
+  return last.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+export function pageParentPath(path) {
+  const segments = pageSegments(path);
+  if (segments.length < 2) return void 0;
+  return `/${segments.slice(0, -1).join("/")}`;
+}
+export function pageRoutes(entry) {
+  return entry.pages ?? [];
+}
+export function pageRouteOf(entry, key) {
+  return pageRoutes(entry).find((route) => route.key === key);
+}
+export function pageOverrideFields(entry, path) {
+  return entry.overrides?.[path] ?? {};
+}
+export function pageFields(entry, path) {
+  const fields = { ...entry.fields };
+  for (const [key, field] of Object.entries(pageOverrideFields(entry, path))) {
+    if (field) fields[key] = field;
+    else delete fields[key];
+  }
+  return fields;
+}
+export function pageAllFields(entry) {
+  const fields = { ...entry.fields };
+  for (const override of Object.values(entry.overrides ?? {})) {
+    for (const [key, field] of Object.entries(override)) {
+      if (field && !fields[key]) fields[key] = field;
+    }
+  }
+  return fields;
+}
+export function entryFieldsFor(entry, path) {
+  if (entry.kind !== "page") return entry.fields;
+  return path ? pageFields(entry, path) : pageAllFields(entry);
+}
 export function typeName(name) {
   return name.replace(/(?:^|_)([a-z0-9])/gi, (_, c) => c.toUpperCase());
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xleddyl/nuxt-cms",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "Lightweight CMS that ships with your Nuxt app: runs on the Nitro server, content types defined in code, /cms admin panel, GraphQL API, SQLite or Postgres. No external CMS needed!",
   "license": "MIT",
   "author": "Edoardo Alberti (https://github.com/xleddyl)",