@karixi/payload-ai 0.1.2 → 0.2.0

package/dist/content-generator-BcUxGqga.mjs

@@ -0,0 +1,609 @@
+import { t as __exportAll } from "./rolldown-runtime-wcPFST8Q.mjs";
+//#region src/generate/block-generator.ts
+/**
+* Block generation: turn a Blocks field definition into a JSON-Schema
+* discriminated union + prompt fragment, and validate generated values
+* back into shape.
+*
+* Blocks were previously marked SKIP across the pipeline. This module
+* lets prompt-builder + content-generator include them without forcing
+* any refactor of the existing switch-case: the top-level modules simply
+* call into this file when they see `field.type === 'blocks'`.
+*/
+/** JSON-Schema fragment describing the allowed shape of one blocks field. */
+function blocksOutputSchema(field) {
+	const blocks = field.blocks ?? [];
+	if (blocks.length === 0) return {
+		type: "array",
+		items: {}
+	};
+	return {
+		type: "array",
+		items: {
+			oneOf: blocks.map((block) => ({
+				type: "object",
+				required: ["blockType"],
+				properties: {
+					blockType: {
+						type: "string",
+						const: block.slug
+					},
+					...blockFieldProperties(block)
+				}
+			})),
+			discriminator: { propertyName: "blockType" }
+		}
+	};
+}
+function blockFieldProperties(block) {
+	const out = {};
+	for (const f of block.fields) {
+		if (f.type === "relationship" || f.type === "upload") continue;
+		if (f.type === "richText") {
+			out[f.name] = { type: "string" };
+			continue;
+		}
+		if (f.type === "blocks") {
+			out[f.name] = blocksOutputSchema(f);
+			continue;
+		}
+		if (f.type === "array") {
+			out[f.name] = {
+				type: "array",
+				items: { type: "object" }
+			};
+			continue;
+		}
+		if (f.type === "group") {
+			out[f.name] = { type: "object" };
+			continue;
+		}
+		if (f.type === "select" || f.type === "radio") {
+			const values = (f.options ?? []).map((o) => o.value);
+			out[f.name] = {
+				type: "string",
+				enum: values
+			};
+			continue;
+		}
+		if (f.type === "number") {
+			out[f.name] = { type: "number" };
+			continue;
+		}
+		if (f.type === "checkbox") {
+			out[f.name] = { type: "boolean" };
+			continue;
+		}
+		if (f.type === "date") {
+			out[f.name] = {
+				type: "string",
+				format: "date-time"
+			};
+			continue;
+		}
+		out[f.name] = { type: "string" };
+	}
+	return out;
+}
+/** Prompt fragment describing a blocks field and its available block catalog. */
+function describeBlocksField(field) {
+	const blocks = field.blocks ?? [];
+	if (blocks.length === 0) return `- "${field.name}" (blocks${field.required ? " (required)" : " (optional)"}): empty block catalog — omit`;
+	const lines = [`- "${field.name}" (blocks${field.required ? " (required)" : " (optional)"}): array of block objects. Each object MUST include a "blockType" discriminator string.`, "  Available block types:"];
+	for (const block of blocks) {
+		const label = block.label ? ` (${block.label})` : "";
+		const desc = block.description ? ` — ${block.description}` : "";
+		lines.push(`  • blockType: "${block.slug}"${label}${desc}`);
+		for (const f of block.fields) {
+			const required = f.required ? " (required)" : "";
+			const suffix = describeBlockFieldInline(f);
+			lines.push(`      - ${f.name} (${f.type}${required})${suffix}`);
+		}
+		if (block.requiredFields && block.requiredFields.length > 0) lines.push(`      required: ${block.requiredFields.join(", ")}`);
+	}
+	lines.push(`  Generate 2–5 blocks forming a coherent layout; mix block types if the theme permits.`);
+	return lines.join("\n");
+}
+function describeBlockFieldInline(f) {
+	if (f.type === "select" || f.type === "radio") {
+		const values = (f.options ?? []).map((o) => `"${o.value}"`).join(", ");
+		return values ? ` — one of [${values}]` : "";
+	}
+	if (f.type === "relationship") return " — use an existing ID from related collections";
+	if (f.type === "upload") return " — omit; media is attached separately";
+	if (f.type === "richText") return " — plain text paragraph";
+	if (f.type === "number") return " — numeric value";
+	if (f.type === "checkbox") return " — boolean";
+	if (f.type === "date") return " — ISO 8601 timestamp";
+	if (f.type === "blocks") return " — nested block array";
+	if (f.type === "array") return " — array of sub-objects";
+	if (f.type === "group") return " — object of sub-fields";
+	return "";
+}
+/**
+* Validate a generated blocks array against the schema. Drops blocks with
+* unknown blockType; reports missing required fields per block.
+* Returns { valid, issues } — `valid` is a cleaned array safe to persist.
+*/
+function validateBlocks(value, field) {
+	const issues = [];
+	if (!Array.isArray(value)) {
+		if (value === void 0 || value === null) return {
+			valid: [],
+			issues
+		};
+		return {
+			valid: [],
+			issues: [{
+				path: field.name,
+				message: "expected array of blocks"
+			}]
+		};
+	}
+	const catalog = new Map((field.blocks ?? []).map((b) => [b.slug, b]));
+	const valid = [];
+	value.forEach((item, idx) => {
+		if (typeof item !== "object" || item === null || Array.isArray(item)) {
+			issues.push({
+				path: `${field.name}[${idx}]`,
+				message: "block must be an object"
+			});
+			return;
+		}
+		const obj = item;
+		const blockType = obj.blockType;
+		if (typeof blockType !== "string") {
+			issues.push({
+				path: `${field.name}[${idx}]`,
+				message: "missing blockType discriminator"
+			});
+			return;
+		}
+		const block = catalog.get(blockType);
+		if (!block) {
+			issues.push({
+				path: `${field.name}[${idx}]`,
+				message: `unknown blockType "${blockType}" — valid: ${[...catalog.keys()].join(", ")}`
+			});
+			return;
+		}
+		const missing = (block.requiredFields ?? []).filter((name) => {
+			const v = obj[name];
+			return v === void 0 || v === null || v === "";
+		});
+		if (missing.length > 0) {
+			issues.push({
+				path: `${field.name}[${idx}]`,
+				message: `${blockType} missing required: ${missing.join(", ")}`
+			});
+			return;
+		}
+		valid.push(obj);
+	});
+	return {
+		valid,
+		issues
+	};
+}
+//#endregion
+//#region src/generate/richtext-generator.ts
+function makeTextNode(text, format = 0) {
+	return {
+		detail: 0,
+		format,
+		mode: "normal",
+		style: "",
+		text,
+		type: "text",
+		version: 1
+	};
+}
+function makeParagraph(text) {
+	return {
+		children: text.length > 0 ? [makeTextNode(text)] : [],
+		direction: "ltr",
+		format: "",
+		indent: 0,
+		type: "paragraph",
+		version: 1
+	};
+}
+function makeHeading(text, tag = "h2") {
+	return {
+		children: [makeTextNode(text)],
+		direction: "ltr",
+		format: "",
+		indent: 0,
+		type: "heading",
+		tag,
+		version: 1
+	};
+}
+function makeList(items, listType = "bullet") {
+	return {
+		children: items.map((item, index) => ({
+			children: [makeTextNode(item)],
+			direction: "ltr",
+			format: "",
+			indent: 0,
+			type: "listitem",
+			value: index + 1,
+			version: 1
+		})),
+		direction: "ltr",
+		format: "",
+		indent: 0,
+		type: "list",
+		listType,
+		tag: listType === "bullet" ? "ul" : "ol",
+		version: 1
+	};
+}
+/**
+* Convert plain text to a Lexical root node.
+* Each non-empty line becomes a paragraph.
+*/
+function textToLexical(text) {
+	return { root: {
+		children: text.split("\n").map((line) => makeParagraph(line)),
+		direction: "ltr",
+		format: "",
+		indent: 0,
+		type: "root",
+		version: 1
+	} };
+}
+/**
+* Convert structured content to a Lexical root node.
+* Sections may have an optional heading, paragraphs, and bullet points.
+*/
+function contentToLexical(content) {
+	const children = [];
+	for (const section of content.sections) {
+		if (section.heading) children.push(makeHeading(section.heading, "h2"));
+		for (const paragraph of section.paragraphs) children.push(makeParagraph(paragraph));
+		if (section.bulletPoints && section.bulletPoints.length > 0) children.push(makeList(section.bulletPoints, "bullet"));
+	}
+	return { root: {
+		children,
+		direction: "ltr",
+		format: "",
+		indent: 0,
+		type: "root",
+		version: 1
+	} };
+}
+//#endregion
+//#region src/core/prompt-builder.ts
+function detectHeadingLevels(features) {
+	const levels = /* @__PURE__ */ new Set();
+	for (const f of features) {
+		const m = f.match(/h([1-6])/i);
+		if (m) levels.add(Number.parseInt(m[1], 10));
+	}
+	if (features.some((f) => /heading/i.test(f) && !/h[1-6]/i.test(f))) {
+		levels.add(2);
+		levels.add(3);
+		levels.add(4);
+	}
+	return [...levels].sort((a, b) => a - b);
+}
+function describeField(field, existingIds, includeBlocks = false, adapters, domain) {
+	const lines = [];
+	const required = field.required ? " (required)" : " (optional)";
+	switch (field.type) {
+		case "text":
+		case "textarea":
+		case "email":
+			lines.push(`- "${field.name}" (${field.type}${required}): Generate realistic ${field.type} content`);
+			break;
+		case "number":
+			lines.push(`- "${field.name}" (number${required}): Generate a realistic numeric value (e.g. price 1–999, quantity 1–100, rating 1–5)`);
+			break;
+		case "checkbox":
+			lines.push(`- "${field.name}" (boolean${required}): true or false`);
+			break;
+		case "date":
+			lines.push(`- "${field.name}" (date${required}): ISO 8601 date string (e.g. "2024-06-15T10:00:00.000Z")`);
+			break;
+		case "select": {
+			const values = (field.options ?? []).map((o) => `"${o.value}"`).join(", ");
+			lines.push(`- "${field.name}" (select${required}): Must be one of [${values}]`);
+			break;
+		}
+		case "relationship": {
+			const collections = Array.isArray(field.relationTo) ? field.relationTo : [field.relationTo ?? ""];
+			const idLists = collections.map((col) => {
+				const ids = existingIds?.[col] ?? [];
+				return ids.length > 0 ? `${col}: [${ids.map((id) => `"${id}"`).join(", ")}]` : `${col}: (no existing IDs available — omit this field)`;
+			});
+			if (collections.some((col) => (existingIds?.[col] ?? []).length > 0)) lines.push(`- "${field.name}" (relationship${required}): Pick from existing IDs — ${idLists.join("; ")}${field.hasMany ? " (can be an array of IDs)" : " (single ID string)"}`);
+			else lines.push(`- "${field.name}" (relationship${required}): SKIP — no existing IDs available`);
+			break;
+		}
+		case "richText": {
+			const features = field.lexicalFeatures ?? [];
+			if (features.length > 0) {
+				const headingLevels = detectHeadingLevels(features);
+				const allowLists = features.some((f) => /list|bullet|number|ordered/i.test(f));
+				const capLines = [];
+				if (headingLevels.length > 0) capLines.push(`headings (${headingLevels.map((l) => `h${l}`).join(", ")})`);
+				if (allowLists) capLines.push("bullet/numbered lists");
+				capLines.push("paragraphs");
+				lines.push(`- "${field.name}" (richtext${required}): Return a structured object {"sections":[{"heading":"optional","paragraphs":["..."],"bulletPoints":["..."]}]}. The editor supports: ${capLines.join(", ")}. Keep each section short (1–3 paragraphs).`);
+			} else lines.push(`- "${field.name}" (richtext${required}): Return PLAIN TEXT only (do not wrap in Lexical/JSON — the system will convert it). Write 1–3 sentences of realistic content.`);
+			break;
+		}
+		case "upload":
+			lines.push(`- "${field.name}" (upload${required}): SKIP — handled separately`);
+			break;
+		case "array":
+		case "group":
+			if (field.fields && field.fields.length > 0) {
+				lines.push(`- "${field.name}" (${field.type}${required}):`);
+				for (const subField of field.fields) lines.push(`  ${describeField(subField, existingIds, includeBlocks, adapters, domain)}`);
+			}
+			break;
+		case "blocks":
+			if (includeBlocks) lines.push(describeBlocksField(field));
+			else lines.push(`- "${field.name}" (blocks${required}): SKIP — complex layout field, omit`);
+			break;
+		default: {
+			const adapter = adapters?.get(field.type);
+			if (adapter?.describe) {
+				const fragment = adapter.describe(field, {
+					existingIds,
+					domain
+				});
+				if (fragment !== null) lines.push(fragment);
+				break;
+			}
+			lines.push(`- "${field.name}" (${field.type}${required}): Generate appropriate content`);
+		}
+	}
+	return lines.join("\n");
+}
+function buildGenerationPrompt(schema, context) {
+	const fieldDescriptions = schema.fields.map((f) => describeField(f, context.existingIds, context.includeBlocks ?? false, context.adapters, context.domain)).join("\n");
+	const requiredNote = schema.requiredFields.length > 0 ? `\nRequired fields (must be present): ${schema.requiredFields.map((f) => `"${f}"`).join(", ")}` : "";
+	const themeNote = context.theme ? `\nContent theme/style: ${context.theme}` : "";
+	const localeNote = context.locale && context.locale !== "en" ? `\nGenerate content in locale: ${context.locale}` : "";
+	const domain = context.domain === void 0 ? "an ecommerce platform" : context.domain.trim().length === 0 ? "" : context.domain;
+	const domainNote = domain ? ` appropriate for ${domain}` : "";
+	return `Generate ${context.count} realistic document(s) for the "${schema.slug}" collection.
+${themeNote}${localeNote}${requiredNote}
+
+Fields to generate:
+${fieldDescriptions}
+
+Rules:
+- Return a JSON array with exactly ${context.count} item(s)
+- Each item must be a flat JSON object with field names as keys
+- Skip fields marked as SKIP
+- For richtext fields: return plain text strings only
+- For relationship fields: use the provided existing IDs exactly as shown
+- Do not include extra fields not listed above
+- Generate varied, realistic content${domainNote}`;
+}
+function buildOutputSchema(schema, options) {
+	const properties = {};
+	const required = [];
+	const includeBlocks = options?.includeBlocks === true;
+	const adapters = options?.adapters;
+	for (const field of schema.fields) {
+		if (field.type === "blocks") {
+			if (!includeBlocks) continue;
+			properties[field.name] = blocksOutputSchema(field);
+			if (field.required) required.push(field.name);
+			continue;
+		}
+		if ([
+			"relationship",
+			"richText",
+			"upload"
+		].includes(field.type)) continue;
+		let fieldSchema;
+		switch (field.type) {
+			case "text":
+			case "textarea":
+			case "email":
+			case "date":
+				fieldSchema = { type: "string" };
+				break;
+			case "number":
+				fieldSchema = { type: "number" };
+				break;
+			case "checkbox":
+				fieldSchema = { type: "boolean" };
+				break;
+			case "select":
+				fieldSchema = {
+					type: "string",
+					enum: (field.options ?? []).map((o) => o.value)
+				};
+				break;
+			case "array":
+				fieldSchema = {
+					type: "array",
+					items: { type: "object" }
+				};
+				break;
+			case "group":
+				fieldSchema = { type: "object" };
+				break;
+			default: {
+				const custom = (adapters?.get(field.type))?.outputSchema?.(field);
+				if (custom !== void 0) {
+					if (custom === null) continue;
+					fieldSchema = custom;
+					break;
+				}
+				fieldSchema = { type: "string" };
+			}
+		}
+		properties[field.name] = fieldSchema;
+		if (field.required) required.push(field.name);
+	}
+	return {
+		type: "object",
+		properties: { items: {
+			type: "array",
+			items: {
+				type: "object",
+				properties,
+				required
+			}
+		} }
+	};
+}
+//#endregion
+//#region src/core/content-generator.ts
+var content_generator_exports = /* @__PURE__ */ __exportAll({ generateDocuments: () => generateDocuments });
+function getSelectValues(field) {
+	return (field.options ?? []).map((o) => o.value);
+}
+/**
+* Convert richText values (strings or {sections:[...]} objects) into Lexical
+* JSON. Other values pass through unchanged. This is defensive — if the AI
+* returns something already shaped like Lexical (has `root`), we keep it.
+*/
+function convertRichTextValue(value) {
+	if (value === null || value === void 0) return value;
+	if (typeof value === "string") return textToLexical(value);
+	if (typeof value === "object") {
+		const v = value;
+		if (v.root !== void 0) return v;
+		if (Array.isArray(v.sections)) return contentToLexical(v);
+	}
+	return value;
+}
+/** Walk the generated doc and convert every richText field to Lexical. */
+function applyRichTextPostprocess(doc, fields) {
+	for (const field of fields) {
+		if (!(field.name in doc)) continue;
+		if (field.type === "richText") {
+			doc[field.name] = convertRichTextValue(doc[field.name]);
+			continue;
+		}
+		if (field.type === "group" && field.fields && typeof doc[field.name] === "object") {
+			const sub = doc[field.name];
+			if (sub && !Array.isArray(sub)) applyRichTextPostprocess(sub, field.fields);
+			continue;
+		}
+		if (field.type === "array" && field.fields && Array.isArray(doc[field.name])) {
+			for (const item of doc[field.name]) if (item && typeof item === "object" && !Array.isArray(item)) applyRichTextPostprocess(item, field.fields);
+		}
+	}
+	return doc;
+}
+function validateDocument(doc, schema, options = {}) {
+	const errors = [];
+	if (typeof doc !== "object" || doc === null || Array.isArray(doc)) return [{
+		field: "_root",
+		message: "Document must be a plain object"
+	}];
+	const record = doc;
+	for (const fieldName of schema.requiredFields) {
+		const field = schema.fields.find((f) => f.name === fieldName);
+		if (!field) continue;
+		if ([
+			"relationship",
+			"richText",
+			"upload"
+		].includes(field.type)) continue;
+		if (field.type === "blocks" && !options.includeBlocks) continue;
+		if (record[fieldName] === void 0 || record[fieldName] === null || record[fieldName] === "") errors.push({
+			field: fieldName,
+			message: `Required field "${fieldName}" is missing or empty`
+		});
+	}
+	for (const field of schema.fields) {
+		if (field.type !== "select") continue;
+		const value = record[field.name];
+		if (value === void 0 || value === null) continue;
+		const validValues = getSelectValues(field);
+		if (validValues.length > 0 && !validValues.includes(String(value))) errors.push({
+			field: field.name,
+			message: `Field "${field.name}" has invalid select value "${String(value)}". Must be one of: ${validValues.join(", ")}`
+		});
+	}
+	if (options.includeBlocks) for (const field of schema.fields) {
+		if (field.type !== "blocks") continue;
+		const value = record[field.name];
+		if (value === void 0) continue;
+		const { valid, issues } = validateBlocks(value, field);
+		record[field.name] = valid;
+		for (const issue of issues) errors.push({
+			field: issue.path,
+			message: issue.message
+		});
+	}
+	if (options.adapters) for (const field of schema.fields) {
+		const adapter = options.adapters.get(field.type);
+		if (!adapter?.validate) continue;
+		const value = record[field.name];
+		if (value === void 0) continue;
+		const adapterIssues = adapter.validate(value, field);
+		for (const issue of adapterIssues) errors.push({
+			field: issue.field,
+			message: issue.message
+		});
+	}
+	return errors;
+}
+function buildRetryPrompt(originalPrompt, errors) {
+	return `${originalPrompt}
+
+IMPORTANT: Your previous response had validation errors. Fix these issues:
+${errors.map((e) => `- ${e.field}: ${e.message}`).join("\n")}
+
+Return a corrected JSON array addressing all the errors above.`;
+}
+async function generateDocuments(provider, schema, context, options) {
+	const maxRetries = options?.maxRetries ?? 3;
+	const outputSchema = buildOutputSchema(schema, {
+		includeBlocks: context.includeBlocks === true,
+		adapters: context.adapters
+	});
+	let prompt = buildGenerationPrompt(schema, context);
+	let lastError = null;
+	for (let attempt = 0; attempt <= maxRetries; attempt++) {
+		let rawItems;
+		try {
+			rawItems = await provider.generate(prompt, outputSchema);
+		} catch (err) {
+			lastError = err instanceof Error ? err : new Error(String(err));
+			if (attempt < maxRetries) {
+				prompt = buildRetryPrompt(buildGenerationPrompt(schema, context), [{
+					field: "_generation",
+					message: `API error: ${lastError.message}`
+				}]);
+				continue;
+			}
+			throw lastError;
+		}
+		const allErrors = [];
+		const validDocuments = [];
+		for (const item of rawItems) {
+			const errors = validateDocument(item, schema, {
+				includeBlocks: context.includeBlocks === true,
+				adapters: context.adapters
+			});
+			if (errors.length > 0) allErrors.push(...errors);
+			else validDocuments.push(item);
+		}
+		if (allErrors.length === 0) return { documents: validDocuments.map((d) => applyRichTextPostprocess(d, schema.fields)) };
+		if (attempt < maxRetries) {
+			prompt = buildRetryPrompt(buildGenerationPrompt(schema, context), allErrors);
+			lastError = /* @__PURE__ */ new Error(`Validation failed: ${allErrors.map((e) => e.message).join("; ")}`);
+			continue;
+		}
+		if (validDocuments.length > 0) return { documents: validDocuments.map((d) => applyRichTextPostprocess(d, schema.fields)) };
+		throw new Error(`Content generation failed after ${maxRetries} retries. Last errors: ${allErrors.map((e) => e.message).join("; ")}`);
+	}
+	throw lastError ?? /* @__PURE__ */ new Error("Content generation failed");
+}
+//#endregion
+export { validateBlocks as a, describeBlocksField as i, generateDocuments as n, blocksOutputSchema as r, content_generator_exports as t };
+
+//# sourceMappingURL=content-generator-BcUxGqga.mjs.map