emdash 0.32.0 → 0.34.0

package/src/schema/types.ts

@@ -48,6 +48,23 @@ export const FIELD_TYPES: readonly FieldType[] = [
 	"repeater",
 ] as const;
 
+/** Scalar field types that can be backed by a content-list query index. */
+export const INDEXABLE_FIELD_TYPES: ReadonlySet<FieldType> = new Set([
+	"string",
+	"url",
+	"number",
+	"integer",
+	"boolean",
+	"datetime",
+	"select",
+	"reference",
+	"slug",
+]);
+
+export function isIndexableFieldType(type: FieldType): boolean {
+	return INDEXABLE_FIELD_TYPES.has(type);
+}
+
 /**
  * SQLite column types that map from field types
  */
@@ -155,6 +172,14 @@ export interface FieldWidgetOptions {
 	[key: string]: unknown;
 }
 
+export const MAX_COLLECTION_LIST_COLUMNS = 4;
+
+/** Collection-level admin presentation options. */
+export interface CollectionAdminConfig {
+	/** Custom field slugs to show in the content list. */
+	listColumns?: string[];
+}
+
 /**
  * A collection definition
  */
@@ -165,12 +190,32 @@ export interface Collection {
 	labelSingular?: string;
 	description?: string;
 	icon?: string;
+	admin?: CollectionAdminConfig;
 	supports: CollectionSupport[];
 	source?: CollectionSource;
 	/** Whether this collection has SEO metadata fields enabled */
 	hasSeo: boolean;
+	/** Field slug powering the admin list Title column. Defaults to the standard title display. */
+	titleField?: string;
+	/** Field slug powering the admin list Date column. Must be a `datetime` field. Defaults to last-updated. */
+	dateField?: string;
 	/** URL pattern with {slug} placeholder (e.g. "/{slug}", "/blog/{slug}") */
 	urlPattern?: string;
+	/** Whether published entries require a public slug. Defaults to true. */
+	routable?: boolean;
+	/**
+	 * Omit this collection's auto-generated entry from the admin sidebar.
+	 * The collection stays fully functional everywhere else (API, MCP, hooks,
+	 * direct `/content/:collection` URLs) — this only hides the nav link, so a
+	 * plugin that owns the collection can point editors at its own admin UI.
+	 */
+	hidden: boolean;
+	/**
+	 * Explicit position in the admin sidebar. Collections with a `sortOrder`
+	 * come first, in ascending order; the rest keep the alphabetical-by-slug
+	 * order and follow. `undefined` means "no explicit position".
+	 */
+	sortOrder?: number;
 	/** Whether comments are enabled for this collection */
 	commentsEnabled: boolean;
 	/** Moderation strategy: "all" | "first_time" | "none" */
@@ -201,6 +246,8 @@ export interface Field {
 	options?: FieldWidgetOptions;
 	sortOrder: number;
 	searchable: boolean;
+	/** Whether this field has a physical index for structured list queries. */
+	indexed: boolean;
 	/** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
 	translatable: boolean;
 	createdAt: string;
@@ -215,10 +262,16 @@ export interface CreateCollectionInput {
 	labelSingular?: string;
 	description?: string;
 	icon?: string;
+	admin?: CollectionAdminConfig;
 	supports?: CollectionSupport[];
 	source?: CollectionSource;
 	urlPattern?: string;
+	routable?: boolean;
 	hasSeo?: boolean;
+	/** Omit the auto-generated admin sidebar entry (defaults to false) */
+	hidden?: boolean;
+	/** Explicit admin sidebar position (omit for the alphabetical fallback) */
+	sortOrder?: number | null;
 	commentsEnabled?: boolean;
 }
 
@@ -230,13 +283,23 @@ export interface UpdateCollectionInput {
 	labelSingular?: string;
 	description?: string;
 	icon?: string;
+	admin?: CollectionAdminConfig;
 	supports?: CollectionSupport[];
-	urlPattern?: string;
+	urlPattern?: string | null;
+	routable?: boolean;
 	hasSeo?: boolean;
+	/** Omit the auto-generated admin sidebar entry */
+	hidden?: boolean;
+	/** Explicit admin sidebar position; `null` clears it back to alphabetical */
+	sortOrder?: number | null;
 	commentsEnabled?: boolean;
 	commentsModeration?: "all" | "first_time" | "none";
 	commentsClosedAfterDays?: number;
 	commentsAutoApproveUsers?: boolean;
+	/** Field slug for the Title column; `null`/`""` clears back to the default. */
+	titleField?: string | null;
+	/** Datetime field slug for the Date column; `null`/`""` clears back to the default. */
+	dateField?: string | null;
 }
 
 /**
@@ -255,6 +318,8 @@ export interface CreateFieldInput {
 	sortOrder?: number;
 	/** Whether this field should be indexed for search */
 	searchable?: boolean;
+	/** Create a physical index for structured sorting. */
+	indexed?: boolean;
 	/** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
 	translatable?: boolean;
 }
@@ -265,13 +330,9 @@ export interface CreateFieldInput {
 export interface UpdateFieldInput {
 	label?: string;
 	/**
-	 * Change the field's type. Only type changes that keep the same underlying
-	 * column type (per `FIELD_TYPE_TO_COLUMN`) are allowed — e.g. `string` to
-	 * `slug` (both TEXT). A change that would alter the column affinity (e.g.
-	 * `text` TEXT to `portableText` JSON) is rejected, because there is no
-	 * in-place column migration and silently rewriting the metadata would
-	 * desync `column_type` from the real `ec_*` column. Omit to keep the
-	 * current type.
+	 * Change the field's type. Only storage-compatible text aliases (`string`,
+	 * `text`, and `slug`) can be changed in place. Other changes require an
+	 * explicit content migration. Omit to keep the current type.
 	 */
 	type?: FieldType;
 	required?: boolean;
@@ -283,6 +344,8 @@ export interface UpdateFieldInput {
 	sortOrder?: number;
 	/** Whether this field should be indexed for search */
 	searchable?: boolean;
+	/** Create or remove the physical index used by structured sorting. */
+	indexed?: boolean;
 	/** Whether this field is translatable (default true). Non-translatable fields are synced across locales. */
 	translatable?: boolean;
 }
@@ -331,6 +394,9 @@ export const RESERVED_COLLECTION_SLUGS = [
 	"taxonomies",
 	"options",
 	"audit_logs",
+	// Shadowed by the static POST /schema/collections/reorder route: a
+	// collection with this slug could never be addressed at its own URL.
+	"reorder",
 ];
 
 /**

package/src/schema/url-pattern.ts

@@ -0,0 +1,33 @@
+const URL_PARAM_PATTERN = /\{(\w+)\}/g;
+const REGEX_SPECIAL_CHARACTERS = /[.*+?^${}()|[\]\\]/g;
+const INVALID_LITERAL_PATTERN = /[{}]/;
+
+function escapeRegex(literal: string): string {
+	return literal.replace(REGEX_SPECIAL_CHARACTERS, "\\$&");
+}
+
+export function compileUrlPattern(pattern: string): { regex: RegExp; paramNames: string[] } {
+	const paramNames: string[] = [];
+	let regexSource = "";
+	let previousIndex = 0;
+
+	for (const match of pattern.matchAll(URL_PARAM_PATTERN)) {
+		const matchIndex = match.index;
+		const literal = pattern.slice(previousIndex, matchIndex);
+		if (INVALID_LITERAL_PATTERN.test(literal)) throw new Error("Invalid URL pattern placeholder");
+		regexSource += escapeRegex(literal);
+
+		const name = match[1];
+		paramNames.push(name);
+		regexSource += "([^/]+)";
+		previousIndex = matchIndex + match[0].length;
+	}
+
+	const trailingLiteral = pattern.slice(previousIndex);
+	if (INVALID_LITERAL_PATTERN.test(trailingLiteral)) {
+		throw new Error("Invalid URL pattern placeholder");
+	}
+	regexSource += escapeRegex(trailingLiteral);
+
+	return { regex: new RegExp(`^${regexSource}$`), paramNames };
+}

package/src/schema/zod-generator.ts

@@ -1,7 +1,7 @@
 import { z, type ZodTypeAny } from "zod";
 
 import { hashString } from "../utils/hash.js";
-import type { Field, FieldType, CollectionWithFields } from "./types.js";
+import type { CollectionWithFields, Field, FieldType, RepeaterSubField } from "./types.js";
 
 /** Pattern to split on underscores, hyphens, and spaces for PascalCase conversion */
 const PASCAL_CASE_SPLIT_PATTERN = /[_\-\s]+/;
@@ -58,7 +58,7 @@ export function generateFieldSchema(field: Field): ZodTypeAny {
 /**
  * Get base Zod schema for a field type
  */
-function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
+function getBaseSchema(type: FieldType, field: Pick<Field, "validation">): ZodTypeAny {
 	switch (type) {
 		case "url":
 			return z.string().url();
@@ -114,6 +114,9 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 			return z.array(z.string());
 		}
 
+		case "repeater":
+			return z.array(generateRepeaterRowSchema(field.validation?.subFields ?? []));
+
 		case "portableText":
 			// Portable Text is an array of blocks. We require `_type` because
 			// renderers dispatch on it, but `_key` is intentionally optional:
@@ -139,6 +142,10 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 				alt: z.string().optional(),
 				width: z.number().optional(),
 				height: z.number().optional(),
+				filename: z.string().optional(),
+				mimeType: z.string().optional(),
+				blurhash: z.string().optional(),
+				dominantColor: z.string().optional(),
 				/** Provider ID (e.g. "local", "cloudflare-images") */
 				provider: z.string().optional(),
 				/** Admin-side preview URL for external providers (not persisted by plugins) */
@@ -150,6 +157,7 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 		case "file":
 			return z.object({
 				id: z.string(),
+				url: z.string().optional(),
 				src: z.string().optional(),
 				filename: z.string().optional(),
 				mimeType: z.string().optional(),
@@ -171,6 +179,29 @@ function getBaseSchema(type: FieldType, field: Field): ZodTypeAny {
 	}
 }
 
+function generateRepeaterRowSchema(
+	subFields: readonly RepeaterSubField[],
+): z.ZodObject<Record<string, ZodTypeAny>> {
+	const shape: Record<string, ZodTypeAny> = {};
+
+	for (const subField of subFields) {
+		let schema = getBaseSchema(subField.type, {
+			validation: subField.options ? { options: subField.options } : undefined,
+		});
+
+		if (subField.required && schema instanceof z.ZodString) {
+			schema = schema.min(1, "required (empty value not allowed)");
+		}
+		if (!subField.required) {
+			schema = schema.nullish();
+		}
+
+		shape[subField.slug] = schema;
+	}
+
+	return z.object(shape).passthrough();
+}
+
 /**
  * Apply validation rules to a schema
  */
@@ -205,6 +236,17 @@ function applyValidation(schema: ZodTypeAny, field: Field): ZodTypeAny {
 		return numSchema;
 	}
 
+	if (field.type === "repeater" && schema instanceof z.ZodArray) {
+		let arraySchema = schema;
+		if (validation.minItems !== undefined) {
+			arraySchema = arraySchema.min(validation.minItems);
+		}
+		if (validation.maxItems !== undefined) {
+			arraySchema = arraySchema.max(validation.maxItems);
+		}
+		return arraySchema;
+	}
+
 	return schema;
 }
 
@@ -378,7 +420,10 @@ export async function generateSchemaHash(collections: CollectionWithFields[]): P
 /**
  * Map field type to TypeScript type
  */
-function fieldTypeToTypeScript(field: Field): string {
+function fieldTypeToTypeScript(field: {
+	type: Field["type"];
+	validation?: Field["validation"];
+}): string {
 	switch (field.type) {
 		case "string":
 		case "text":
@@ -408,14 +453,41 @@ function fieldTypeToTypeScript(field: Field): string {
 			}
 			return "string[]";
 
+		case "repeater": {
+			const subFields = field.validation?.subFields;
+			// `validation` is unvalidated JSON on the seed and registry paths.
+			if (!Array.isArray(subFields) || subFields.length === 0) return "unknown";
+
+			// A duplicated slug keeps its first position and last declaration, as
+			// `generateRepeaterRowSchema`'s `shape[subField.slug]` does.
+			const members = new Map<string, string>();
+
+			for (const subField of subFields) {
+				const type = fieldTypeToTypeScript({
+					type: subField.type,
+					validation: subField.options ? { options: subField.options } : undefined,
+				});
+				// A sub-field slug is not guaranteed to be a valid identifier, so it is
+				// quoted rather than emitted bare.
+				const name = JSON.stringify(subField.slug);
+				// A sub-field that is not required may be null at runtime.
+				members.set(
+					subField.slug,
+					subField.required ? `${name}: ${type}` : `${name}?: ${type} | null`,
+				);
+			}
+
+			return `{ ${[...members.values()].join("; ")} }[]`;
+		}
+
 		case "portableText":
 			return "PortableTextBlock[]";
 
 		case "image":
-			return "{ id: string; src?: string; alt?: string; width?: number; height?: number; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
+			return "{ id: string; src?: string; alt?: string; width?: number; height?: number; filename?: string; mimeType?: string; blurhash?: string; dominantColor?: string; provider?: string; previewUrl?: string; meta?: Record<string, unknown> }";
 
 		case "file":
-			return "{ id: string; src?: string; filename?: string; mimeType?: string; size?: number; provider?: string; meta?: Record<string, unknown> }";
+			return "{ id: string; url?: string; src?: string; filename?: string; mimeType?: string; size?: number; provider?: string; meta?: Record<string, unknown> }";
 
 		case "reference":
 			// Could be enhanced to include the referenced collection type