@xleddyl/nuxt-cms 0.1.41 → 0.1.43

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

@@ -0,0 +1,23 @@
+import type { AsyncData } from 'nuxt/app';
+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>;
+    direction?: 'asc' | 'desc';
+}
+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>;
+    sort?: CmsSortInput<Entry>[];
+    limit?: number;
+    offset?: number;
+}
+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

@@ -0,0 +1,23 @@
+import { useAsyncData } from "#imports";
+export function useCmsSingle(name, options = {}) {
+  const { locale, key, default: fallback } = options;
+  return useAsyncData(
+    key ?? `cms-single:${String(name)}:${locale ?? ""}`,
+    async () => fallback ? fallback() : null
+  );
+}
+export function useCmsCollection(name, options = {}) {
+  const { locale, filters, sort, limit, offset, key, default: fallback } = options;
+  const variables = { locale, filters, sort, limit, offset };
+  return useAsyncData(
+    key ?? `cms-collection:${String(name)}:${JSON.stringify(variables)}`,
+    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

@@ -0,0 +1,23 @@
+import type { AsyncData } from 'nuxt/app';
+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>;
+    direction?: 'asc' | 'desc';
+}
+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>;
+    sort?: CmsSortInput<Entry>[];
+    limit?: number;
+    offset?: number;
+}
+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

@@ -0,0 +1,67 @@
+import { cmsCollectionQueries, cmsPageQueries, cmsSingleQueries } from "#cms-queries";
+import { useAsyncData } from "#imports";
+import { $cmsQuery } from "./cms-query.js";
+function unknownEntry(name) {
+  throw new Error(`[nuxt-cms] no generated query for "${name}"; check cms.config.ts`);
+}
+export function useCmsSingle(name, options = {}) {
+  const { locale, key, default: fallback, ...asyncDataOptions } = options;
+  const entryName = String(name);
+  const query = cmsSingleQueries[entryName];
+  return useAsyncData(
+    key ?? `cms-single:${entryName}:${locale ?? ""}`,
+    async () => {
+      if (!query) unknownEntry(entryName);
+      const result = await $cmsQuery(query, { locale });
+      return result?.[entryName] ?? null;
+    },
+    {
+      default: fallback ?? (() => null),
+      ...asyncDataOptions
+    }
+  );
+}
+export function useCmsCollection(name, options = {}) {
+  const {
+    locale,
+    filters,
+    sort,
+    limit,
+    offset,
+    key,
+    default: fallback,
+    ...asyncDataOptions
+  } = options;
+  const entryName = String(name);
+  const query = cmsCollectionQueries[entryName];
+  const variables = { locale, filters, sort, limit, offset };
+  return useAsyncData(
+    key ?? `cms-collection:${entryName}:${JSON.stringify(variables)}`,
+    async () => {
+      if (!query) unknownEntry(entryName);
+      const result = await $cmsQuery(query, variables);
+      return result?.[entryName] ?? [];
+    },
+    {
+      default: fallback ?? (() => []),
+      ...asyncDataOptions
+    }
+  );
+}
+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>>;
+    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>;
+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>>;
+}
+export type CmsEntryInput = CmsCollectionInput | CmsSingleInput | CmsPageInput;
 export type CmsConfigInput = Record<string, CmsEntryInput>;
 export declare function defineCmsConfig<T extends CmsConfigInput>(config: T): T;
 export {};