emdash 0.40.0 → 0.41.0

package/src/schema/zod-generator.ts

@@ -2,7 +2,13 @@ import { z, type ZodType } from "zod";
 
 import { hashString } from "../utils/hash.js";
 import type { BlockFieldDefinition } from "./block-types.js";
-import type { CollectionWithFields, Field, FieldType, RepeaterSubField } from "./types.js";
+import {
+	isStoragelessField,
+	type CollectionWithFields,
+	type Field,
+	type FieldType,
+	type RepeaterSubField,
+} from "./types.js";
 
 /** Pattern to split on underscores, hyphens, and spaces for PascalCase conversion */
 const PASCAL_CASE_SPLIT_PATTERN = /[_\-\s]+/;
@@ -19,6 +25,7 @@ export function generateZodSchema(
 	const shape: Record<string, ZodType> = {};
 
 	for (const field of collection.fields) {
+		if (isStoragelessField(field)) continue;
 		shape[field.slug] = generateFieldSchema(field);
 	}
 
@@ -349,6 +356,10 @@ export function generateTypeScript(
 	lines.push(`  status: string;`);
 
 	for (const field of collection.fields) {
+		// A storage-less field holds no value in `data`; a reference field bound to
+		// a relation resolves through `references` instead. One that predates
+		// relations still owns its column, so it stays an entry id string.
+		if (isStoragelessField(field)) continue;
 		const tsType = blockFieldTypes.get(field.slug) ?? fieldTypeToTypeScript(field);
 		const optional = field.required ? "" : "?";
 		lines.push(`  ${field.slug}${optional}: ${tsType};`);
@@ -443,12 +454,17 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 		),
 	);
 
+	const withReferences = collections.filter((c) => c.fields.some(isStoragelessField));
+
 	// Build imports - BylineSummary, ContentBylineCredit and TaxonomyTerm are always needed
 	// for the hydrated bylines/terms fields
 	const imports = ["BylineSummary", "ContentBylineCredit", "TaxonomyTerm"];
 	if (needsPortableText) {
 		imports.push("PortableTextBlock");
 	}
+	if (withReferences.length > 0) {
+		imports.push("ReferencePage");
+	}
 	lines.push(`import type { ${imports.join(", ")} } from "emdash";`);
 	lines.push(``);
 
@@ -456,6 +472,14 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 	// (e.g. `book` and `books` both -> `Book`), so resolve collisions up front
 	// to keep every interface identifier unique within the file.
 	const interfaceNames = uniqueInterfaceNames(collections);
+	// `{Collection}References`, built on an already-unique name. No slug can
+	// produce a data interface name ending in `References` -- `singularize`
+	// always strips the trailing `s` of a final `references` segment -- so the
+	// suffix cannot collide with one.
+	const referenceInterfaces: [CollectionWithFields, string][] = withReferences.map((c) => [
+		c,
+		`${interfaceNames.get(c.slug)}References`,
+	]);
 
 	// Generate individual interfaces
 	for (const collection of collections) {
@@ -466,6 +490,11 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 		lines.push(``);
 	}
 
+	for (const [collection, name] of referenceInterfaces) {
+		lines.push(generateReferencesTypeScript(collection, name, interfaceNames));
+		lines.push(``);
+	}
+
 	// Generate the Collections interface for module augmentation
 	lines.push(`declare module "emdash" {`);
 	lines.push(`  interface EmDashCollections {`);
@@ -473,11 +502,48 @@ export function generateTypesFile(collections: CollectionWithFields[]): string {
 		lines.push(`    ${collection.slug}: ${interfaceNames.get(collection.slug)};`);
 	}
 	lines.push(`  }`);
+	if (referenceInterfaces.length > 0) {
+		lines.push(`  interface EmDashCollectionReferences {`);
+		for (const [collection, name] of referenceInterfaces) {
+			lines.push(`    ${collection.slug}: ${name};`);
+		}
+		lines.push(`  }`);
+	}
 	lines.push(`}`);
 
 	return lines.join("\n");
 }
 
+/**
+ * Generate the references interface for one collection: a page per reference
+ * field bound to a relation, keyed by field slug, which is how
+ * `getEmDashEntry({ references })` both asks for and returns them.
+ *
+ * A field is always present on the interface, not optional -- a selection that
+ * names it always yields a page, empty when nothing is linked. The narrowing in
+ * `getEmDashEntry` picks out the fields the caller asked for.
+ */
+function generateReferencesTypeScript(
+	collection: CollectionWithFields,
+	interfaceName: string,
+	interfaceNames: Map<string, string>,
+): string {
+	const lines: string[] = [`export interface ${interfaceName} {`];
+
+	for (const field of collection.fields) {
+		if (!isStoragelessField(field)) continue;
+		// A target outside this file (dropped collection, or a relation whose
+		// other end has not been created) leaves the page's data un-narrowed
+		// rather than referring to an identifier that does not exist.
+		const target = field.validation?.targetCollection;
+		const targetName = target ? interfaceNames.get(target) : undefined;
+		lines.push(`  ${field.slug}: ReferencePage${targetName ? `<${targetName}>` : ""};`);
+	}
+
+	lines.push(`}`);
+	return lines.join("\n");
+}
+
 /**
  * Generate schema hash for cache invalidation
  */