@xleddyl/nuxt-cms 0.4.1 → 0.4.3

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

@@ -0,0 +1,67 @@
+import { createError, defineEventHandler, getValidatedQuery, setResponseHeader } from "h3";
+import { z } from "zod";
+import { cmsDialect, useDb } from "#cms-db";
+import { isCollectionKind } from "../../shared/index.js";
+import {
+  canTransferCsv,
+  entryRowsToCsv,
+  exportFileName,
+  exportRow,
+  TRANSFER_FORMATS
+} from "../../shared/transfer.js";
+import { listOrderBy, listWhere, readListFilters } from "../utils/list-query.js";
+import { decodeRows, getContentI18n, getRegistryEntry } from "../utils/registry.js";
+import { attachManyToMany } from "../utils/relations.js";
+import { requireAdmin } from "../utils/require-admin.js";
+import { chunks, KEY_CHUNK } from "../utils/write-statements.js";
+const querySchema = z.object({
+  format: z.enum(TRANSFER_FORMATS).default("json"),
+  search: z.string().trim().max(200).optional(),
+  sort: z.string().trim().max(64).optional(),
+  order: z.enum(["asc", "desc"]).default("desc")
+});
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { name, entry, table } = getRegistryEntry(event);
+  if (!isCollectionKind(entry)) {
+    throw createError({ statusCode: 405, statusMessage: "Only collections can be exported" });
+  }
+  const { format, search, sort, order } = await getValidatedQuery(event, querySchema.parse);
+  if (format === "csv" && !canTransferCsv(entry)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "CSV needs an entry without blocks and many-to-many fields"
+    });
+  }
+  const db = useDb();
+  const where = listWhere(cmsDialect, entry, table, {
+    search,
+    filters: readListFilters(event, entry)
+  });
+  const base = db.select().from(table);
+  const rows = await (where ? base.where(where) : base).orderBy(
+    ...listOrderBy(table, sort, order)
+  );
+  for (const chunk of chunks(rows, KEY_CHUNK)) await attachManyToMany(db, name, entry, chunk);
+  decodeRows(entry, rows);
+  const items = rows.map((row) => exportRow(entry, row));
+  const now = /* @__PURE__ */ new Date();
+  setResponseHeader(event, "cache-control", "no-store");
+  setResponseHeader(
+    event,
+    "content-disposition",
+    `attachment; filename="${exportFileName(name, format, now)}"`
+  );
+  if (format === "csv") {
+    setResponseHeader(event, "content-type", "text/csv; charset=utf-8");
+    return entryRowsToCsv(entry, items, getContentI18n());
+  }
+  setResponseHeader(event, "content-type", "application/json; charset=utf-8");
+  const file = {
+    collection: name,
+    exportedAt: now.toISOString(),
+    total: items.length,
+    items
+  };
+  return JSON.stringify(file, null, 2);
+});

package/dist/runtime/server/api/collection-import.post.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("h3").EventHandler<import("h3").EventHandlerRequest, Promise<import("../../shared/transfer.js").CmsImportPreview>>;
+export default _default;

package/dist/runtime/server/api/collection-import.post.js

@@ -0,0 +1,85 @@
+import {
+  createError,
+  defineEventHandler,
+  getRequestHeader,
+  getValidatedQuery,
+  readRawBody
+} from "h3";
+import { z } from "zod";
+import { runBatch, useDb } from "#cms-db";
+import { isCollectionKind } from "../../shared/index.js";
+import {
+  canTransferCsv,
+  IMPORT_MAX_BYTES,
+  IMPORT_MODES,
+  importSource,
+  TRANSFER_FORMATS
+} from "../../shared/transfer.js";
+import { mapConstraintErrors } from "../utils/db-errors.js";
+import {
+  checkImportRows,
+  importPreview,
+  importWriteStatements,
+  validateImportRows
+} from "../utils/import.js";
+import { mediaLookup } from "../utils/media-check.js";
+import { getContentI18n, getRegistryEntry } from "../utils/registry.js";
+import { requireAdmin } from "../utils/require-admin.js";
+const querySchema = z.object({
+  format: z.enum(TRANSFER_FORMATS),
+  mode: z.enum(IMPORT_MODES).default("create"),
+  dryRun: z.stringbool().default(true)
+});
+function tooLarge() {
+  throw createError({
+    statusCode: 413,
+    statusMessage: `The file is larger than ${IMPORT_MAX_BYTES / 1024 / 1024} MB`
+  });
+}
+export default defineEventHandler(async (event) => {
+  await requireAdmin(event);
+  const { name, entry, table } = getRegistryEntry(event);
+  if (!isCollectionKind(entry)) {
+    throw createError({ statusCode: 405, statusMessage: "Only collections can be imported" });
+  }
+  const { format, mode, dryRun } = await getValidatedQuery(event, querySchema.parse);
+  if (format === "csv" && !canTransferCsv(entry)) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "CSV needs an entry without blocks and many-to-many fields"
+    });
+  }
+  if (Number(getRequestHeader(event, "content-length") ?? 0) > IMPORT_MAX_BYTES) tooLarge();
+  const text = await readRawBody(event, "utf8") ?? "";
+  if (new TextEncoder().encode(text).length > IMPORT_MAX_BYTES) tooLarge();
+  if (!text.trim()) throw createError({ statusCode: 400, statusMessage: "The file is empty" });
+  const i18n = getContentI18n();
+  const source = importSource(entry, format, text, i18n);
+  const db = useDb();
+  const rows = await checkImportRows(validateImportRows(entry, source.rows, i18n), {
+    db,
+    name,
+    entry,
+    table,
+    mode,
+    media: source.errors.length ? null : await mediaLookup()
+  });
+  const preview = importPreview(entry, rows, {
+    format,
+    mode,
+    defaultLocale: i18n.defaultLocale,
+    errors: source.errors
+  });
+  if (dryRun) return preview;
+  if (preview.errors.length || preview.valid !== preview.total || !preview.total) {
+    throw createError({
+      statusCode: 400,
+      statusMessage: "The file has errors: check it again and fix them before importing",
+      data: preview
+    });
+  }
+  await mapConstraintErrors(
+    () => runBatch((tx) => importWriteStatements(tx, name, entry, table, rows))
+  );
+  return { ...preview, imported: true };
+});

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

@@ -1,10 +1,10 @@
-import { asc, count, desc, sql } from "drizzle-orm";
+import { count } from "drizzle-orm";
 import { defineEventHandler, getValidatedQuery } from "h3";
 import { z } from "zod";
 import { cmsDialect, useDb } from "#cms-db";
 import { pageRoutes } from "../../shared/index.js";
-import { searchLikePattern } from "../../shared/search.js";
 import { decodeRows, getRegistryEntry, idColumn, tableColumns } from "../utils/registry.js";
+import { listOrderBy, listWhere, readListFilters } from "../utils/list-query.js";
 import { readPages } from "../utils/page-storage.js";
 import { attachManyToMany, relationTitles } from "../utils/relations.js";
 import { requireAdmin } from "../utils/require-admin.js";
@@ -49,25 +49,17 @@ export default defineEventHandler(async (event) => {
   }
   const columns = tableColumns(table);
   const titleColumn = entry.titleField && Object.hasOwn(columns, entry.titleField) ? columns[entry.titleField] : void 0;
-  let where;
-  if (search) {
-    const column = titleColumn ?? idColumn(table);
-    const text = cmsDialect === "postgres" ? sql`cast(${column} as text)` : sql`${column}`;
-    where = sql`lower(${text}) like ${searchLikePattern(search.toLowerCase())} escape '\\'`;
-  }
+  const where = listWhere(cmsDialect, entry, table, {
+    search,
+    filters: readListFilters(event, entry)
+  });
   const selection = light ? Object.fromEntries([
     ["id", idColumn(table)],
     ...entry.titleField && titleColumn ? [[entry.titleField, titleColumn]] : [],
     ...entry.drafts && Object.hasOwn(columns, "status") ? [["status", columns.status]] : []
   ]) : void 0;
-  const sortColumn = sort && Object.hasOwn(columns, sort) ? columns[sort] : void 0;
-  const orderBy = sortColumn ?? columns.createdAt ?? idColumn(table);
-  const direction = sortColumn && order === "asc" ? asc : desc;
-  const tiebreaker = idColumn(table);
   const base = selection ? db.select(selection).from(table) : db.select().from(table);
-  const items = await (where ? base.where(where) : base).orderBy(
-    ...orderBy === tiebreaker ? [direction(orderBy)] : [direction(orderBy), desc(tiebreaker)]
-  ).limit(limit).offset(offset);
+  const items = await (where ? base.where(where) : base).orderBy(...listOrderBy(table, sort, order)).limit(limit).offset(offset);
   const [counted] = await (where ? db.select({ total: count() }).from(table).where(where) : db.select({ total: count() }).from(table));
   if (light) return { items, total: counted?.total ?? 0, relations: {} };
   await attachManyToMany(db, name, entry, items);

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

@@ -0,0 +1,31 @@
+import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { CmsDb } from '#cms-db';
+import type { CmsEntry, CmsI18n } from '../../shared/index.js';
+import type { CmsImportAction, CmsImportIssue, CmsImportMode, CmsImportPreview, CmsImportSourceRow, CmsTransferFormat } from '../../shared/transfer.js';
+import type { MediaLookup } from './media-references.js';
+type Row = Record<string, unknown>;
+export interface PreparedImportRow {
+    index: number;
+    id: string | null;
+    values: Row | null;
+    action: CmsImportAction;
+    errors: CmsImportIssue[];
+}
+export interface ImportContext {
+    db: CmsDb;
+    name: string;
+    entry: CmsEntry;
+    table: SQLiteTable;
+    mode: CmsImportMode;
+    media: MediaLookup | null;
+}
+export declare function validateImportRows(entry: CmsEntry, rows: CmsImportSourceRow[], i18n: CmsI18n): PreparedImportRow[];
+export declare function checkImportRows(rows: PreparedImportRow[], context: ImportContext): Promise<PreparedImportRow[]>;
+export declare function importPreview(entry: CmsEntry, rows: PreparedImportRow[], options: {
+    format: CmsTransferFormat;
+    mode: CmsImportMode;
+    defaultLocale: string;
+    errors?: string[];
+}): CmsImportPreview;
+export declare function importWriteStatements(db: CmsDb, name: string, entry: CmsEntry, table: SQLiteTable, rows: PreparedImportRow[]): PromiseLike<unknown>[];
+export {};

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

@@ -0,0 +1,202 @@
+import { eq, inArray } from "drizzle-orm";
+import { uniqueFieldKeys } from "../../shared/duplicate.js";
+import { IMPORT_ID_PATTERN, importIssuePath, importRowTitle } from "../../shared/transfer.js";
+import { buildEntrySchema } from "../../shared/validation.js";
+import { customId } from "./custom-id.js";
+import { mediaReferences } from "./media-references.js";
+import {
+  encodeColumnValues,
+  resolveTable,
+  withContentDefaults,
+  withTimestamps,
+  withUpdatedAt
+} from "./registry.js";
+import { manyToManyStatements, splitRelationValues } from "./relations.js";
+import { chunks, KEY_CHUNK } from "./write-statements.js";
+const META_KEYS = /* @__PURE__ */ new Set(["id", "createdAt", "updatedAt"]);
+export function validateImportRows(entry, rows, i18n) {
+  const schema = buildEntrySchema(entry, i18n);
+  return rows.map((row) => {
+    const errors = [...row.errors];
+    const rawId = row.values.id;
+    let id = null;
+    if (rawId !== void 0 && rawId !== null && rawId !== "") {
+      if (typeof rawId === "string" && IMPORT_ID_PATTERN.test(rawId)) id = rawId;
+      else
+        errors.push({
+          path: "id",
+          message: "Invalid id: use letters, numbers, _ and -, up to 128 characters"
+        });
+    }
+    const input = Object.fromEntries(
+      Object.entries(row.values).filter(([key]) => !META_KEYS.has(key))
+    );
+    const result = schema.safeParse(input);
+    if (!result.success) {
+      const reported = new Set(errors.map((issue) => issue.path));
+      for (const issue of result.error.issues) {
+        const path = importIssuePath(issue.path);
+        if (!reported.has(path)) errors.push({ path, message: issue.message });
+      }
+    }
+    return {
+      index: row.index,
+      id,
+      values: result.success ? result.data : null,
+      action: "create",
+      errors
+    };
+  });
+}
+async function existingIds(db, table, ids) {
+  const column = table.id;
+  const found = /* @__PURE__ */ new Set();
+  for (const chunk of chunks([...new Set(ids)], KEY_CHUNK)) {
+    const rows = await db.select({ id: column }).from(table).where(inArray(column, chunk));
+    for (const row of rows) found.add(String(row.id));
+  }
+  return found;
+}
+function relationIds(value) {
+  if (Array.isArray(value)) return value.filter((id) => typeof id === "string");
+  return typeof value === "string" && value ? [value] : [];
+}
+function addError(row, path, message) {
+  row.errors.push({ path, message });
+}
+async function checkIds(rows, context) {
+  const first = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (!row.id) continue;
+    const seen = first.get(row.id);
+    if (seen !== void 0) addError(row, "id", `Same id as row ${seen}`);
+    else first.set(row.id, row.index);
+  }
+  const existing = await existingIds(context.db, context.table, [...first.keys()]);
+  for (const row of rows) {
+    if (!row.id || !existing.has(row.id)) continue;
+    if (context.mode === "create") addError(row, "id", "An entry with this id already exists");
+    else row.action = "update";
+  }
+}
+async function checkRelations(rows, context) {
+  const fileIds = new Set(rows.flatMap((row) => row.id ? [row.id] : []));
+  for (const [key, field] of Object.entries(context.entry.fields)) {
+    if (field.type !== "relation" || !field.to) continue;
+    const target = resolveTable(field.to);
+    if (!target) continue;
+    const wanted = rows.flatMap((row) => relationIds(row.values?.[key]));
+    if (!wanted.length) continue;
+    const found = await existingIds(context.db, target, wanted);
+    if (field.to === context.name) for (const id of fileIds) found.add(id);
+    for (const row of rows) {
+      const missing = relationIds(row.values?.[key]).filter((id) => !found.has(id));
+      if (missing.length) addError(row, key, `Unknown ${field.to} id: ${missing.join(", ")}`);
+    }
+  }
+}
+async function checkUnique(rows, context) {
+  const columns = context.table;
+  for (const key of uniqueFieldKeys(context.entry)) {
+    const column = columns[key];
+    if (!column) continue;
+    const owners = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const value = row.values?.[key];
+      if (typeof value !== "string" || !value) continue;
+      const owner = owners.get(value);
+      if (owner) addError(row, key, `Same value as row ${owner.index}`);
+      else owners.set(value, row);
+    }
+    for (const chunk of chunks([...owners.keys()], KEY_CHUNK)) {
+      const found = await context.db.select({ id: columns.id, value: column }).from(context.table).where(inArray(column, chunk));
+      for (const match of found) {
+        const row = owners.get(String(match.value));
+        if (row && row.id !== String(match.id))
+          addError(row, key, "This value is already used by another entry");
+      }
+    }
+  }
+}
+async function checkMedia(rows, context) {
+  if (!context.media) return;
+  const references = new Map(
+    rows.map((row) => [row, row.values ? mediaReferences(context.entry.fields, row.values) : []])
+  );
+  const keys = [...new Set([...references.values()].flat().map((reference) => reference.key))];
+  if (!keys.length) return;
+  const known = await context.media(keys);
+  for (const [row, list] of references) {
+    for (const reference of list) {
+      if (!known.has(reference.key))
+        addError(row, reference.field, `Media not found in the library: ${reference.key}`);
+    }
+  }
+}
+export async function checkImportRows(rows, context) {
+  await checkIds(rows, context);
+  await checkRelations(rows, context);
+  await checkUnique(rows, context);
+  await checkMedia(rows, context);
+  return rows;
+}
+export function importPreview(entry, rows, options) {
+  const valid = rows.filter((row) => !row.errors.length);
+  return {
+    format: options.format,
+    mode: options.mode,
+    total: rows.length,
+    valid: valid.length,
+    create: valid.filter((row) => row.action === "create").length,
+    update: valid.filter((row) => row.action === "update").length,
+    errors: options.errors ?? [],
+    rows: rows.map((row) => ({
+      index: row.index,
+      id: row.id,
+      action: row.action,
+      title: row.values ? importRowTitle(entry, row.values, options.defaultLocale) : null,
+      errors: row.errors
+    })),
+    imported: false
+  };
+}
+function deferredSelfRelations(entry, name) {
+  return Object.entries(entry.fields).filter(
+    ([, field]) => field.type === "relation" && field.to === name && field.cardinality !== "many-to-many" && !field.required
+  ).map(([key]) => key);
+}
+export function importWriteStatements(db, name, entry, table, rows) {
+  const idCol = table.id;
+  const created = new Set(
+    rows.flatMap((row) => row.action === "create" && row.id ? [row.id] : [])
+  );
+  const selfKeys = deferredSelfRelations(entry, name);
+  const main = [];
+  const later = [];
+  for (const row of rows) {
+    if (!row.values) continue;
+    const { values, lists } = splitRelationValues(entry, encodeColumnValues(entry, row.values));
+    const deferred = {};
+    for (const key of selfKeys) {
+      const target = values[key];
+      if (typeof target === "string" && created.has(target)) {
+        deferred[key] = target;
+        values[key] = null;
+      }
+    }
+    const id = row.id ?? customId(entry.id);
+    if (row.action === "update") {
+      main.push(
+        db.update(table).set(withUpdatedAt(table, withContentDefaults(entry, values))).where(eq(idCol, id))
+      );
+    } else {
+      if (entry.drafts) values.status ??= "draft";
+      withContentDefaults(entry, values);
+      main.push(db.insert(table).values(withTimestamps(table, { ...values, id })));
+    }
+    if (Object.keys(deferred).length)
+      later.push(db.update(table).set(deferred).where(eq(idCol, id)));
+    later.push(...manyToManyStatements(db, name, id, lists));
+  }
+  return [...main, ...later];
+}

package/dist/runtime/server/utils/list-query.d.ts

@@ -0,0 +1,15 @@
+import type { SQL } from 'drizzle-orm';
+import type { SQLiteTable } from 'drizzle-orm/sqlite-core';
+import type { H3Event } from 'h3';
+import type { CmsEntry } from '../../shared/index.js';
+import type { CmsListFilters } from '../../shared/list-filters.js';
+export type ListDialect = 'sqlite' | 'postgres';
+export interface ListQueryInput {
+    search?: string;
+    filters?: CmsListFilters;
+}
+export declare function readListFilters(event: H3Event, entry: CmsEntry): CmsListFilters;
+export declare function listSearchCondition(dialect: ListDialect, entry: CmsEntry, table: SQLiteTable, search: string): SQL;
+export declare function listFilterConditions(entry: CmsEntry, table: SQLiteTable, filters: CmsListFilters): SQL[];
+export declare function listWhere(dialect: ListDialect, entry: CmsEntry, table: SQLiteTable, { search, filters }: ListQueryInput): SQL | undefined;
+export declare function listOrderBy(table: SQLiteTable, sort?: string, order?: 'asc' | 'desc'): SQL<unknown>[];

package/dist/runtime/server/utils/list-query.js

@@ -0,0 +1,54 @@
+import { and, asc, desc, eq, inArray, isNull, or, sql } from "drizzle-orm";
+import { createError, getQuery } from "h3";
+import { selectValuesMatching } from "../../shared/index.js";
+import { parseListFilters } from "../../shared/list-filters.js";
+import { searchLikePattern } from "../../shared/search.js";
+export function readListFilters(event, entry) {
+  const { filters, errors } = parseListFilters(entry, getQuery(event));
+  if (errors.length) throw createError({ statusCode: 400, statusMessage: errors.join("; ") });
+  return filters;
+}
+export function listSearchCondition(dialect, entry, table, search) {
+  const columns = table;
+  const titleColumn = entry.titleField && Object.hasOwn(columns, entry.titleField) ? columns[entry.titleField] : void 0;
+  const column = titleColumn ?? columns.id;
+  const text = dialect === "postgres" ? sql`cast(${column} as text)` : sql`${column}`;
+  const like = sql`lower(${text}) like ${searchLikePattern(search.toLowerCase())} escape '\\'`;
+  const titleField = entry.titleField ? entry.fields[entry.titleField] : void 0;
+  const labelled = titleColumn && titleField?.type === "select" ? selectValuesMatching(titleField, search) : [];
+  return labelled.length ? or(like, inArray(column, labelled)) : like;
+}
+export function listFilterConditions(entry, table, filters) {
+  const columns = table;
+  const conditions = [];
+  for (const [key, value] of Object.entries(filters)) {
+    if (!Object.hasOwn(columns, key)) {
+      throw createError({ statusCode: 400, statusMessage: `Unknown filter '${key}'` });
+    }
+    const column = columns[key];
+    if (entry.fields[key]?.type === "boolean") {
+      conditions.push(
+        value === "true" ? eq(column, true) : or(eq(column, false), isNull(column))
+      );
+      continue;
+    }
+    conditions.push(eq(column, value));
+  }
+  return conditions;
+}
+export function listWhere(dialect, entry, table, { search, filters = {} }) {
+  const conditions = [
+    ...search ? [listSearchCondition(dialect, entry, table, search)] : [],
+    ...listFilterConditions(entry, table, filters)
+  ];
+  if (!conditions.length) return void 0;
+  return conditions.length === 1 ? conditions[0] : and(...conditions);
+}
+export function listOrderBy(table, sort, order = "desc") {
+  const columns = table;
+  const tiebreaker = columns.id;
+  const sortColumn = sort && Object.hasOwn(columns, sort) ? columns[sort] : void 0;
+  const orderBy = sortColumn ?? columns.createdAt ?? tiebreaker;
+  const direction = sortColumn && order === "asc" ? asc : desc;
+  return orderBy === tiebreaker ? [direction(orderBy)] : [direction(orderBy), desc(tiebreaker)];
+}

package/dist/runtime/server/utils/media-check.d.ts

@@ -1,2 +1,4 @@
 import type { FieldConfig } from '../../shared/index.js';
+import type { MediaLookup } from './media-references.js';
+export declare function mediaLookup(): Promise<MediaLookup | null>;
 export declare function assertMediaExists(fields: Record<string, FieldConfig>, values: Record<string, unknown>): Promise<void>;

package/dist/runtime/server/utils/media-check.js

@@ -3,7 +3,7 @@ import { cms_media } from "#cms-tables";
 import { useRuntimeConfig } from "#imports";
 import { useMediaIndex } from "./media-index.js";
 import { assertKnownMedia, mediaKeysInTable, mediaReferences } from "./media-references.js";
-async function mediaLookup() {
+export async function mediaLookup() {
   const { media } = useRuntimeConfig().cms;
   if (media.storage !== "local") {
     return (keys) => mediaKeysInTable(useDb(), cms_media, keys);

package/dist/runtime/server/utils/media-references.js

@@ -1,6 +1,6 @@
 import { inArray } from "drizzle-orm";
 import { createError } from "h3";
-import { PAGE_PATH_FIELD, pageFields, pageRouteOf } from "../../shared/index.js";
+import { PAGE_PATH_FIELD, pageFields, pageRouteOf, selectOptionLabel } from "../../shared/index.js";
 const LOOKUP_CHUNK = 90;
 function mediaKeysOf(value) {
   if (typeof value === "string") return value ? [value] : [];
@@ -36,6 +36,9 @@ function titleOf(entry, row) {
     return pageRouteOf(entry, String(row.id))?.label ?? (typeof path === "string" ? path : null);
   }
   const value = entry.titleField ? row[entry.titleField] : void 0;
+  const titleField = entry.titleField ? entry.fields[entry.titleField] : void 0;
+  if (typeof value === "string" && titleField?.type === "select")
+    return selectOptionLabel(titleField, value) || null;
   if (typeof value === "string") return value || null;
   if (value && typeof value === "object") {
     const first = Object.values(value).find(

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

@@ -56,7 +56,7 @@ export function getRegistryEntry(event) {
 }
 export function buildValidator(entry, path) {
   const fields = path ? pageFields(entry, path) : entry.fields;
-  return buildEntrySchema({ ...entry, fields }, getContentI18n());
+  return buildEntrySchema({ ...entry, fields, path }, getContentI18n());
 }
 export function requirePageRoute(entry, key) {
   const route = pageRouteOf(entry, key);

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

@@ -8,7 +8,9 @@ import {
   pageFields,
   pageFieldsTableName,
   pageMediaTableName,
-  pageRouteOf
+  pageRouteOf,
+  selectOptionLabel,
+  selectValuesMatching
 } from "../../shared/index.js";
 import {
   CMS_SEARCH_HITS_PER_ROW,
@@ -47,8 +49,13 @@ function fieldTexts(field, value, defaultLocale) {
   if (isTranslatableField(field)) {
     return Object.entries(decodeTranslatableValue(value, defaultLocale) ?? {}).filter((pair) => typeof pair[1] === "string" && !!pair[1]).map(([locale, text]) => ({ locale, text: plainText(field, text) }));
   }
-  if (isMultiSelect(field) && Array.isArray(value)) {
-    return [{ locale: null, text: value.map(String).join(", ") }];
+  if (field.type === "select") {
+    const values = Array.isArray(value) ? value : [value];
+    const text = values.map((item) => {
+      const label = selectOptionLabel(field, item);
+      return label === String(item) ? label : `${label} (${String(item)})`;
+    }).join(", ");
+    return [{ locale: null, text }];
   }
   if (typeof value === "string") return [{ locale: null, text: plainText(field, value) }];
   return [{ locale: null, text: JSON.stringify(value) }];
@@ -90,6 +97,8 @@ function titleOf(entry, row, defaultLocale) {
   if (entry.kind === "single" || !entry.titleField) return null;
   const value = row[entry.titleField];
   if (value == null) return null;
+  const titleField = entry.fields[entry.titleField];
+  if (titleField?.type === "select") return selectOptionLabel(titleField, value) || null;
   if (typeof value === "object") {
     const values = value;
     const text = [values[defaultLocale], ...Object.values(values)].find(
@@ -101,7 +110,17 @@ function titleOf(entry, row, defaultLocale) {
 }
 async function tableRows(context, entry, table) {
   const columns = columnsOf(table);
-  const conditions = Object.entries(entry.fields).filter(([key, field]) => isSearchableField(field) && Object.hasOwn(columns, key)).map(([key]) => searchLikeCondition(context.dialect, columns[key], context.pattern));
+  const searchable = Object.entries(entry.fields).filter(
+    ([key, field]) => isSearchableField(field) && Object.hasOwn(columns, key)
+  );
+  const conditions = searchable.map(
+    ([key]) => searchLikeCondition(context.dialect, columns[key], context.pattern)
+  );
+  for (const [key, field] of searchable) {
+    if (field.type !== "select" || isMultiSelect(field)) continue;
+    const values = selectValuesMatching(field, context.term);
+    if (values.length) conditions.push(inArray(columns[key], values));
+  }
   if (!conditions.length) return [];
   const query = context.db.select().from(table).where(or(...conditions));
   const ordered = columns.updatedAt ? query.orderBy(desc(columns.updatedAt)) : query;

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

@@ -0,0 +1,10 @@
+import type { CmsEntry, FieldConfig } from './index.js';
+export declare const DUPLICATE_TITLE_SUFFIX = " (copy)";
+type DuplicatedEntry = Pick<CmsEntry, 'kind' | 'fields' | 'drafts' | 'titleField'>;
+export declare function isUniqueField(field: FieldConfig): boolean;
+export declare function uniqueFieldKeys(entry: Pick<CmsEntry, 'fields'>): string[];
+export declare function duplicateToken(): string;
+export declare function duplicateSlug(value: string, token: string): string;
+export declare function duplicateFormKeys(entry: DuplicatedEntry): string[];
+export declare function duplicateEntryValues(entry: DuplicatedEntry, source: Record<string, unknown>, token?: string): Record<string, unknown>;
+export {};