@mvriu5/payload-ai 1.1.1 → 1.2.0

package/dist/payload/proposalData.js

@@ -0,0 +1,575 @@
+import { getSafeProposalLabel, getOptionValue, isRecord } from "./shared.js";
+import { createLexicalText, getSchemaFields, normalizeAuthData, normalizeDataForFields } from "./normalizeData.js";
+const isTitleLikeField = (field, titleFieldName)=>{
+    const normalizedName = field.name?.toLowerCase();
+    return Boolean(field.name && (field.name === titleFieldName || normalizedName === "title" || normalizedName === "name" || normalizedName === "label" || normalizedName === "headline"));
+};
+const getFieldOptionValues = (field)=>{
+    return (field.options || []).map((option)=>getOptionValue(option)).filter((option)=>Boolean(option));
+};
+const escapeRegExp = (value)=>value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const getFieldNameVariants = (fieldName)=>{
+    if (!fieldName) return [];
+    const spacedName = fieldName.replace(/([a-z0-9])([A-Z])/g, "$1 $2").replace(/[_-]+/g, " ").toLowerCase();
+    return Array.from(new Set([
+        fieldName.toLowerCase(),
+        spacedName
+    ])).filter(Boolean);
+};
+const inferOptionValueFromText = ({ field, requireFieldMention = false, text })=>{
+    const normalizedText = text?.trim().toLowerCase();
+    if (!normalizedText) return undefined;
+    if (requireFieldMention) {
+        const fieldMentioned = getFieldNameVariants(field.name).some((variant)=>{
+            const pattern = new RegExp(`\\b${escapeRegExp(variant)}\\b`, "i");
+            return pattern.test(normalizedText);
+        });
+        if (!fieldMentioned) return undefined;
+    }
+    const optionValues = getFieldOptionValues(field).sort((left, right)=>right.length - left.length);
+    return optionValues.find((optionValue)=>{
+        const pattern = new RegExp(`\\b${escapeRegExp(optionValue.toLowerCase())}\\b`, "i");
+        return pattern.test(normalizedText);
+    });
+};
+const getDefaultFieldValue = ({ field, inferenceText, label, titleFieldName })=>{
+    if (field.name === "_status") return "draft";
+    if (field.type === "checkbox") return false;
+    if (field.type === "select" || field.type === "radio") {
+        const inferredOptionValue = inferOptionValueFromText({
+            field,
+            requireFieldMention: true,
+            text: inferenceText || label
+        });
+        if (inferredOptionValue !== undefined) {
+            return inferredOptionValue;
+        }
+        if (field.defaultValue !== undefined) {
+            return field.defaultValue;
+        }
+        return getOptionValue(field.options?.[0]);
+    }
+    if (field.defaultValue !== undefined) return field.defaultValue;
+    if ([
+        "email",
+        "text",
+        "textarea"
+    ].includes(field.type || "") && isTitleLikeField(field, titleFieldName)) {
+        return getSafeProposalLabel(label);
+    }
+    return undefined;
+};
+const addIssue = (issues, issue)=>{
+    issues.push(issue);
+};
+const normalizeRelationshipScalar = (value)=>{
+    if (typeof value === "number") {
+        if (!Number.isInteger(value) || value <= 0) return undefined;
+        return value;
+    }
+    const trimmedValue = value.trim();
+    if (!trimmedValue || /\s/.test(trimmedValue)) return undefined;
+    if (/^\d+$/.test(trimmedValue) && Number(trimmedValue) <= 0) return undefined;
+    return trimmedValue;
+};
+const normalizeRelationshipValue = ({ field, issues, path, value })=>{
+    const allowedRelationTargets = Array.isArray(field.relationTo) ? field.relationTo.filter((item)=>typeof item === "string") : typeof field.relationTo === "string" ? [
+        field.relationTo
+    ] : [];
+    const normalizeSingle = (item, itemPath)=>{
+        if (typeof item === "number") {
+            const normalizedValue = normalizeRelationshipScalar(item);
+            if (normalizedValue !== undefined) {
+                return normalizedValue;
+            }
+            addIssue(issues, {
+                code: "invalid_relationship",
+                message: "Relationship and upload fields must use a valid document ID.",
+                path: itemPath
+            });
+            return undefined;
+        }
+        if (typeof item === "string") {
+            const normalizedValue = normalizeRelationshipScalar(item);
+            if (normalizedValue !== undefined) {
+                return normalizedValue;
+            }
+            addIssue(issues, {
+                code: "invalid_relationship",
+                message: "Relationship and upload fields must use a valid document ID, not free text.",
+                path: itemPath
+            });
+            return undefined;
+        }
+        if (!isRecord(item)) {
+            addIssue(issues, {
+                code: "invalid_relationship",
+                message: "Relationship and upload fields must use a document ID or an object with id/value.",
+                path: itemPath
+            });
+            return undefined;
+        }
+        if (typeof item.id === "string" || typeof item.id === "number") {
+            const normalizedValue = normalizeRelationshipScalar(item.id);
+            if (normalizedValue !== undefined) {
+                return normalizedValue;
+            }
+            addIssue(issues, {
+                code: "invalid_relationship",
+                message: "Relationship and upload fields must use a valid document ID.",
+                path: itemPath
+            });
+            return undefined;
+        }
+        if (typeof item.value === "string" || typeof item.value === "number") {
+            const normalizedValue = normalizeRelationshipScalar(item.value);
+            if (normalizedValue === undefined) {
+                addIssue(issues, {
+                    code: "invalid_relationship",
+                    message: "Relationship and upload fields must use a valid document ID.",
+                    path: itemPath
+                });
+                return undefined;
+            }
+            if (allowedRelationTargets.length > 1) {
+                const relationTo = typeof item.relationTo === "string" ? item.relationTo : null;
+                if (!relationTo || !allowedRelationTargets.includes(relationTo)) {
+                    addIssue(issues, {
+                        code: "invalid_relationship",
+                        message: `Relationship must include one of: ${allowedRelationTargets.join(", ")}.`,
+                        path: itemPath
+                    });
+                    return undefined;
+                }
+                return {
+                    relationTo,
+                    value: normalizedValue
+                };
+            }
+            return normalizedValue;
+        }
+        addIssue(issues, {
+            code: "invalid_relationship",
+            message: "Relationship and upload fields must use a document ID or an object with id/value.",
+            path: itemPath
+        });
+        return undefined;
+    };
+    if (field.hasMany) {
+        if (!Array.isArray(value)) {
+            addIssue(issues, {
+                code: "invalid_relationship",
+                message: "Relationship field expects an array of document IDs.",
+                path
+            });
+            return undefined;
+        }
+        const normalizedValues = value.map((item, index)=>normalizeSingle(item, `${path}.${index}`)).filter((item)=>item !== undefined);
+        return normalizedValues;
+    }
+    return normalizeSingle(value, path);
+};
+const normalizeFieldValue = ({ coercedFields, enforceRequiredChildren, field, inferenceText, issues, label, mode, path, titleFieldName, value })=>{
+    if (field.type === "group") {
+        if (!isRecord(value)) {
+            addIssue(issues, {
+                code: "invalid_container",
+                message: "Group fields must be objects.",
+                path
+            });
+            return undefined;
+        }
+        return normalizeRecordForFields({
+            allowSafeFallback: false,
+            coercedFields,
+            enforceRequiredChildren: mode === "create" || enforceRequiredChildren,
+            fields: field.fields || [],
+            inferenceText,
+            issues,
+            label,
+            mode,
+            path,
+            titleFieldName,
+            value
+        });
+    }
+    if (field.type === "array") {
+        if (!Array.isArray(value)) {
+            addIssue(issues, {
+                code: "invalid_array",
+                message: "Array fields must use an array value.",
+                path
+            });
+            return undefined;
+        }
+        const childFields = (field.fields || []).filter((childField)=>Boolean(childField.name));
+        const itemLabelField = childFields.find((childField)=>childField.name === "label") || childFields.find((childField)=>childField.name === "title") || childFields.find((childField)=>childField.name === "name") || childFields.find((childField)=>childField.name === "value") || childFields[0];
+        return value.map((item, index)=>{
+            const itemPath = `${path}.${index}`;
+            if (!isRecord(item)) {
+                if (!itemLabelField) {
+                    addIssue(issues, {
+                        code: "invalid_array",
+                        message: "Array items must be objects for this field.",
+                        path: itemPath
+                    });
+                    return undefined;
+                }
+                const wrappedItem = {
+                    [itemLabelField.name]: item
+                };
+                return normalizeRecordForFields({
+                    allowSafeFallback: false,
+                    coercedFields,
+                    enforceRequiredChildren: true,
+                    fields: field.fields || [],
+                    inferenceText,
+                    issues,
+                    label,
+                    mode,
+                    path: itemPath,
+                    titleFieldName,
+                    value: wrappedItem
+                });
+            }
+            return normalizeRecordForFields({
+                allowSafeFallback: false,
+                coercedFields,
+                enforceRequiredChildren: true,
+                fields: field.fields || [],
+                inferenceText,
+                issues,
+                label,
+                mode,
+                path: itemPath,
+                titleFieldName,
+                value: item
+            });
+        });
+    }
+    if (field.type === "blocks") {
+        if (!Array.isArray(value)) {
+            addIssue(issues, {
+                code: "invalid_blocks",
+                message: "Blocks fields must use an array value.",
+                path
+            });
+            return undefined;
+        }
+        return value.map((item, index)=>{
+            const itemPath = `${path}.${index}`;
+            if (!isRecord(item)) {
+                addIssue(issues, {
+                    code: "invalid_blocks",
+                    message: "Each block entry must be an object.",
+                    path: itemPath
+                });
+                return undefined;
+            }
+            const blockType = typeof item.blockType === "string" ? item.blockType : typeof item.type === "string" ? item.type : typeof item.slug === "string" ? item.slug : null;
+            if (!blockType) {
+                addIssue(issues, {
+                    code: "invalid_block_type",
+                    message: "Each block entry must include blockType.",
+                    path: itemPath
+                });
+                return undefined;
+            }
+            const block = field.blocks?.find((candidate)=>candidate.slug === blockType);
+            if (!block) {
+                addIssue(issues, {
+                    code: "invalid_block_type",
+                    message: `Unknown block type "${blockType}".`,
+                    path: `${itemPath}.blockType`
+                });
+                return undefined;
+            }
+            const { blockType: _blockType, slug: _slug, type: _type, ...blockData } = item;
+            const normalizedBlock = normalizeRecordForFields({
+                allowSafeFallback: false,
+                coercedFields,
+                enforceRequiredChildren: true,
+                fields: block.fields || [],
+                inferenceText,
+                issues,
+                label,
+                mode,
+                path: itemPath,
+                titleFieldName,
+                value: blockData
+            });
+            return {
+                ...normalizedBlock,
+                blockType
+            };
+        });
+    }
+    if (field.type === "checkbox") {
+        if (typeof value === "boolean") return value;
+        if (value === "true") return true;
+        if (value === "false") return false;
+        addIssue(issues, {
+            code: "invalid_checkbox",
+            message: "Checkbox fields must use true or false.",
+            path
+        });
+        return undefined;
+    }
+    if (field.type === "relationship" || field.type === "upload") {
+        return normalizeRelationshipValue({
+            field,
+            issues,
+            path,
+            value
+        });
+    }
+    if (field.type === "richText") return createLexicalText(value);
+    if (field.type === "select" || field.type === "radio") {
+        const optionValues = getFieldOptionValues(field);
+        const stringValue = value === null ? "" : String(value);
+        const inferredOptionValue = inferOptionValueFromText({
+            field,
+            requireFieldMention: true,
+            text: inferenceText || label
+        });
+        if (inferredOptionValue && optionValues.includes(inferredOptionValue)) {
+            if (stringValue !== inferredOptionValue) {
+                coercedFields.push(path);
+            }
+            return inferredOptionValue;
+        }
+        if (stringValue && optionValues.includes(stringValue)) return stringValue;
+        addIssue(issues, {
+            code: "invalid_option",
+            message: `Field must use one of: ${optionValues.join(", ")}.`,
+            path
+        });
+        return undefined;
+    }
+    if ([
+        "email",
+        "text",
+        "textarea"
+    ].includes(field.type || "")) {
+        return value === null ? value : String(value);
+    }
+    if (field.type === "date") {
+        const date = new Date(String(value));
+        if (Number.isNaN(date.getTime())) {
+            addIssue(issues, {
+                code: "invalid_date",
+                message: "Date fields must use a valid date value.",
+                path
+            });
+            return undefined;
+        }
+        return date.toISOString();
+    }
+    return value;
+};
+const normalizeRecordForFields = ({ allowSafeFallback, coercedFields, enforceRequiredChildren, fields, inferenceText, issues, label, mode, path, titleFieldName, value })=>{
+    const normalizedData = {};
+    const fieldsByName = new Map(fields.filter((field)=>Boolean(field.name)).map((field)=>[
+            field.name,
+            field
+        ]));
+    for (const [key, fieldValue] of Object.entries(value)){
+        const field = fieldsByName.get(key);
+        const fieldPath = path ? `${path}.${key}` : key;
+        if (!field) {
+            addIssue(issues, {
+                code: "unknown_field",
+                message: "Field does not exist in the schema.",
+                path: fieldPath
+            });
+            continue;
+        }
+        const normalizedValue = normalizeFieldValue({
+            coercedFields,
+            enforceRequiredChildren,
+            field,
+            inferenceText,
+            issues,
+            label,
+            mode,
+            path: fieldPath,
+            titleFieldName,
+            value: fieldValue
+        });
+        if (normalizedValue !== undefined) {
+            normalizedData[key] = normalizedValue;
+        }
+    }
+    if (mode === "create" || enforceRequiredChildren) {
+        for (const field of fields.filter((candidate)=>Boolean(candidate.name) && candidate.required === true)){
+            const fieldPath = path ? `${path}.${field.name}` : field.name;
+            if (normalizedData[field.name] === undefined) {
+                if (allowSafeFallback) {
+                    const fallbackValue = getDefaultFieldValue({
+                        field,
+                        inferenceText,
+                        label,
+                        titleFieldName
+                    });
+                    if (fallbackValue !== undefined) {
+                        normalizedData[field.name] = fallbackValue;
+                        continue;
+                    }
+                }
+                addIssue(issues, {
+                    code: "missing_required_field",
+                    message: "Required field is missing.",
+                    path: fieldPath
+                });
+            }
+        }
+    }
+    for (const field of fields.filter((candidate)=>Boolean(candidate.name))){
+        if (normalizedData[field.name] !== undefined) continue;
+        if (field.type !== "select" && field.type !== "radio") continue;
+        const inferredOptionValue = inferOptionValueFromText({
+            field,
+            requireFieldMention: true,
+            text: inferenceText || label
+        });
+        if (inferredOptionValue !== undefined) {
+            normalizedData[field.name] = inferredOptionValue;
+            coercedFields.push(path ? `${path}.${field.name}` : field.name);
+        }
+    }
+    return normalizedData;
+};
+const prepareSingleLocaleData = ({ coercedFields, data, fields, inferenceText, issues, label, mode, titleFieldName })=>{
+    const normalizedData = normalizeRecordForFields({
+        allowSafeFallback: true,
+        coercedFields,
+        enforceRequiredChildren: false,
+        fields,
+        inferenceText,
+        issues,
+        label,
+        mode,
+        path: "",
+        titleFieldName,
+        value: data
+    });
+    return normalizeDataForFields(fields, normalizedData).data;
+};
+export const prepareProposalWriteData = ({ collectionConfig, data, inferenceText, label, localizedData, mode })=>{
+    const schemaFields = getSchemaFields(collectionConfig);
+    const titleFieldName = typeof collectionConfig?.admin?.useAsTitle === "string" ? collectionConfig.admin.useAsTitle : undefined;
+    const issues = [];
+    const coercedFields = [];
+    if (localizedData) {
+        const localeEntries = Object.entries(localizedData);
+        if (localeEntries.length === 0) {
+            addIssue(issues, {
+                code: "empty_localized_data",
+                message: "localizedData must contain at least one locale entry.",
+                path: "localizedData"
+            });
+            return {
+                coercedFields,
+                issues,
+                localizedData: {}
+            };
+        }
+        const normalizedLocalizedData = {};
+        for (const [locale, localeValue] of localeEntries){
+            if (!isRecord(localeValue)) {
+                addIssue(issues, {
+                    code: "invalid_container",
+                    message: "Each locale entry must be an object.",
+                    path: `localizedData.${locale}`
+                });
+                continue;
+            }
+            const normalizedLocaleData = prepareSingleLocaleData({
+                coercedFields,
+                data: localeValue,
+                fields: schemaFields,
+                inferenceText,
+                issues,
+                label,
+                mode,
+                titleFieldName
+            });
+            normalizedLocalizedData[locale] = normalizedLocaleData;
+        }
+        const [firstLocale] = localeEntries[0] || [];
+        if (firstLocale) {
+            for (const field of schemaFields.filter((candidate)=>Boolean(candidate.name))){
+                if (!field.localized) {
+                    for (const [locale, localeValue] of Object.entries(normalizedLocalizedData)){
+                        if (locale === firstLocale) continue;
+                        if (localeValue[field.name] !== undefined) {
+                            addIssue(issues, {
+                                code: "non_localized_field_in_secondary_locale",
+                                message: "Non-localized fields may only be set in the first locale entry.",
+                                path: `localizedData.${locale}.${field.name}`
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        const normalizedResult = {};
+        for (const [locale, localeValue] of Object.entries(normalizedLocalizedData)){
+            normalizedResult[locale] = normalizeAuthData(collectionConfig, {
+                coercedFields: [],
+                data: localeValue,
+                droppedFields: []
+            }).data;
+        }
+        return {
+            coercedFields,
+            issues,
+            localizedData: normalizedResult
+        };
+    }
+    const sourceData = data || {};
+    const normalizedData = prepareSingleLocaleData({
+        coercedFields,
+        data: sourceData,
+        fields: schemaFields,
+        inferenceText,
+        issues,
+        label,
+        mode,
+        titleFieldName
+    });
+    const authNormalized = normalizeAuthData(collectionConfig, {
+        coercedFields: [],
+        data: normalizedData,
+        droppedFields: []
+    });
+    coercedFields.push(...authNormalized.coercedFields);
+    return {
+        coercedFields,
+        data: authNormalized.data,
+        issues
+    };
+};
+export const applyLocalizedRequiredFallbackToPreparedData = ({ fallbackSource, fields, preparedData })=>{
+    const mergedData = {
+        ...preparedData
+    };
+    for (const field of fields.filter((candidate)=>Boolean(candidate.name))){
+        if (field.localized && field.required && mergedData[field.name] === undefined && fallbackSource[field.name] !== undefined) {
+            mergedData[field.name] = fallbackSource[field.name];
+            continue;
+        }
+        if (field.type === "group" && field.fields?.length && isRecord(fallbackSource[field.name])) {
+            const currentValue = isRecord(mergedData[field.name]) ? mergedData[field.name] : {};
+            const nestedValue = applyLocalizedRequiredFallbackToPreparedData({
+                fallbackSource: fallbackSource[field.name],
+                fields: field.fields,
+                preparedData: currentValue
+            });
+            if (Object.keys(nestedValue).length > 0) {
+                mergedData[field.name] = nestedValue;
+            }
+        }
+    }
+    return mergedData;
+};

package/dist/payload/schemaContext.d.ts

@@ -1,5 +1,6 @@
 import type { PayloadHandler } from "payload";
 import { type ResolvedCollectionPermissionMap } from "./collectionPermissions.js";
+import { type CollectionConfig as NormalizeCollectionConfig } from "./normalizeData.js";
 export type ChatMention = {
     collection?: string;
     id?: string;
@@ -9,9 +10,7 @@ export type ChatMention = {
     type?: "block" | "collection" | "doc" | "global" | "locale";
 };
 export type FieldConfig = {
-    admin?: {
-        condition?: unknown;
-    };
+    admin?: Record<string, unknown>;
     blocks?: BlockConfig[];
     defaultValue?: unknown;
     fields?: FieldConfig[];
@@ -35,9 +34,6 @@ type BlockConfig = {
     };
     slug: string;
 };
-type VersionConfig = boolean | {
-    drafts?: boolean | Record<string, unknown>;
-};
 type CollectionLikeConfig = {
     admin?: {
         useAsTitle?: string;
@@ -51,7 +47,7 @@ type CollectionLikeConfig = {
         singular?: unknown;
     };
     slug: string;
-    versions?: VersionConfig;
+    versions?: NormalizeCollectionConfig["versions"];
 };
 type MentionContext = {
     blockContexts: (Record<string, unknown> & {