@mvriu5/payload-ai 1.1.1 → 1.2.0

package/dist/handlers/applyActionHandler.js

@@ -1,8 +1,21 @@
 import { verifyActionProposal } from "../ai/proposalSigning.js";
 import { containsSensitiveData, redactSensitiveData } from "../ai/sensitiveData.js";
-import { getCollectionFields, getLocalizedRequiredFallbackData, isAuthCollection, normalizeAuthData, normalizeDataForFields } from "../payload/normalizeData.js";
+import { getSchemaFields } from "../payload/normalizeData.js";
+import { applyLocalizedRequiredFallbackToPreparedData, prepareProposalWriteData } from "../payload/proposalData.js";
 import { isCollectionActionAllowed } from "../payload/collectionPermissions.js";
-import { getDefaultLocale, getJSONLineKey, getOptionalNumber, hasLocalizedData, isActionProposal, isKnownGlobal, mergeData } from "../payload/shared.js";
+import { getDefaultLocale, getJSONLineKey, getOptionalNumber, hasLocalizedData, isActionProposal, isKnownGlobal, isRecord, mergeData } from "../payload/shared.js";
+import { getLogPreview, logHandlerEvent } from "../payload/logging.js";
+const getProposalLogSummary = (proposal)=>({
+        action: proposal.action,
+        collection: "collection" in proposal ? proposal.collection : undefined,
+        hasData: "data" in proposal && Boolean(proposal.data),
+        hasLocalizedData: "localizedData" in proposal && Boolean(proposal.localizedData),
+        id: "id" in proposal ? proposal.id : undefined,
+        label: proposal.label,
+        locale: proposal.locale,
+        locales: "localizedData" in proposal && proposal.localizedData ? Object.keys(proposal.localizedData) : undefined,
+        slug: "slug" in proposal ? proposal.slug : undefined
+    });
 const getProposalMeta = (proposal)=>{
     if (!proposal) return {};
     return {
@@ -12,6 +25,12 @@ const getProposalMeta = (proposal)=>{
         slug: "slug" in proposal ? proposal.slug : undefined
     };
 };
+const createApplyDebugPayload = ({ details, phase, proposal, reason })=>({
+        ...getProposalMeta(proposal),
+        details,
+        phase,
+        reason
+    });
 const getAppliedDocReference = (doc)=>{
     return doc?.id === undefined ? undefined : {
         id: doc.id
@@ -25,13 +44,6 @@ const isAllowedCollection = (req, collection, collections, action = "read")=>{
         slug: collection
     });
 };
-const applyLocalizedRequiredFallback = ({ data, fallbackSource, fields })=>{
-    return mergeData(getLocalizedRequiredFallbackData({
-        fields,
-        source: fallbackSource,
-        target: data
-    }), data);
-};
 const countDiffChanges = ({ after, before })=>{
     const beforeLines = JSON.stringify(before, null, 2).split("\n");
     const afterLines = JSON.stringify(after, null, 2).split("\n");
@@ -175,39 +187,90 @@ const logAIChange = async ({ changeLogCollection, context, target, proposal, req
     }
 };
 export const createApplyActionHandler = (options = {})=>async (req)=>{
-        if (!req.user) return Response.json({
-            error: "Unauthorized"
-        }, {
-            status: 401
-        });
+        const failApply = ({ debug, error, logMessage, proposal, status = 400 })=>{
+            logHandlerEvent(req, "warn", {
+                debug,
+                msg: logMessage,
+                proposal: getProposalMeta(proposal)
+            });
+            return Response.json({
+                debug,
+                error
+            }, {
+                status
+            });
+        };
+        if (!req.user) {
+            return failApply({
+                debug: createApplyDebugPayload({
+                    phase: "authorization",
+                    reason: "unauthorized"
+                }),
+                error: "Unauthorized",
+                logMessage: "AI apply blocked: unauthorized request",
+                status: 401
+            });
+        }
         const body = req.json ? await req.json().catch(()=>null) : null;
         const proposal = body?.proposal;
-        if (!proposal) return Response.json({
-            error: "Proposal is required"
-        }, {
-            status: 400
-        });
-        if (!verifyActionProposal(proposal)) return Response.json({
-            error: "Proposal signature is invalid or expired."
-        }, {
-            status: 400
-        });
-        if (!isActionProposal(proposal)) return Response.json({
-            error: "Proposal is invalid."
-        }, {
-            status: 400
-        });
-        if ("data" in proposal && proposal.data && containsSensitiveData(proposal.data)) return Response.json({
-            error: "Proposal contains sensitive fields and cannot be applied."
-        }, {
-            status: 400
-        });
-        if (hasLocalizedData(proposal) && Object.values(proposal.localizedData).some((value)=>containsSensitiveData(value))) return Response.json({
-            error: "Proposal contains sensitive fields and cannot be applied."
-        }, {
-            status: 400
-        });
-        let normalized;
+        if (!proposal) {
+            return failApply({
+                debug: createApplyDebugPayload({
+                    phase: "apply_validation",
+                    reason: "missing_proposal"
+                }),
+                error: "Proposal is required",
+                logMessage: "AI apply blocked: missing proposal payload"
+            });
+        }
+        if (!verifyActionProposal(proposal)) {
+            return failApply({
+                debug: createApplyDebugPayload({
+                    phase: "apply_validation",
+                    proposal,
+                    reason: "invalid_signature"
+                }),
+                error: "Proposal signature is invalid or expired.",
+                logMessage: "AI apply blocked: invalid proposal signature",
+                proposal
+            });
+        }
+        if (!isActionProposal(proposal)) {
+            return failApply({
+                debug: createApplyDebugPayload({
+                    phase: "apply_validation",
+                    proposal,
+                    reason: "invalid_proposal_shape"
+                }),
+                error: "Proposal is invalid.",
+                logMessage: "AI apply blocked: invalid proposal shape",
+                proposal
+            });
+        }
+        if ("data" in proposal && proposal.data && containsSensitiveData(proposal.data)) {
+            return failApply({
+                debug: createApplyDebugPayload({
+                    phase: "apply_validation",
+                    proposal,
+                    reason: "sensitive_data_in_data"
+                }),
+                error: "Proposal contains sensitive fields and cannot be applied.",
+                logMessage: "AI apply blocked: sensitive data detected in proposal data",
+                proposal
+            });
+        }
+        if (hasLocalizedData(proposal) && Object.values(proposal.localizedData).some((value)=>containsSensitiveData(value))) {
+            return failApply({
+                debug: createApplyDebugPayload({
+                    phase: "apply_validation",
+                    proposal,
+                    reason: "sensitive_data_in_localized_data"
+                }),
+                error: "Proposal contains sensitive fields and cannot be applied.",
+                logMessage: "AI apply blocked: sensitive data detected in localized proposal data",
+                proposal
+            });
+        }
         const logContext = {
             aiResponse: typeof body?.aiResponse === "string" && body.aiResponse.trim() ? body.aiResponse.trim() : undefined,
             prompt: typeof body?.prompt === "string" && body.prompt.trim() ? body.prompt.trim() : undefined,
@@ -217,19 +280,61 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                 totalTokens: getOptionalNumber(body.tokenUsage.totalTokens)
             } : undefined
         };
+        logHandlerEvent(req, "info", {
+            msg: "AI apply started",
+            promptPreview: getLogPreview(logContext.prompt),
+            proposal: getProposalLogSummary(proposal),
+            tokenUsage: logContext.tokenUsage
+        });
         try {
+            const inferenceText = logContext.prompt;
             const defaultLocale = getDefaultLocale(req);
             if (proposal.action === "updateGlobal") {
-                if (!isKnownGlobal(req, proposal.slug)) return Response.json({
-                    error: "Unknown global"
-                }, {
-                    status: 400
-                });
+                if (!isKnownGlobal(req, proposal.slug)) {
+                    return failApply({
+                        debug: createApplyDebugPayload({
+                            phase: "apply_validation",
+                            proposal,
+                            reason: "unknown_global"
+                        }),
+                        error: "Unknown global",
+                        logMessage: "AI apply blocked: unknown global",
+                        proposal
+                    });
+                }
                 const globalConfig = req.payload.config.globals?.find((global)=>global.slug === proposal.slug);
                 if (hasLocalizedData(proposal)) {
                     const beforeByLocale = {};
                     const afterByLocale = {};
-                    const globalFields = globalConfig?.fields || [];
+                    const globalFields = getSchemaFields({
+                        fields: globalConfig?.fields || [],
+                        slug: proposal.slug
+                    });
+                    const preparedData = prepareProposalWriteData({
+                        collectionConfig: {
+                            fields: globalConfig?.fields || [],
+                            slug: proposal.slug
+                        },
+                        inferenceText,
+                        label: proposal.label,
+                        localizedData: proposal.localizedData,
+                        mode: "update"
+                    });
+                    if (preparedData.issues.length > 0 || !preparedData.localizedData) {
+                        return failApply({
+                            debug: createApplyDebugPayload({
+                                details: {
+                                    issues: preparedData.issues
+                                },
+                                phase: "apply_validation",
+                                proposal,
+                                reason: "invalid_global_write_shape"
+                            }),
+                            error: "Proposal is invalid.",
+                            logMessage: "AI apply blocked: invalid global proposal data",
+                            proposal
+                        });
+                    }
                     const defaultLocaleDoc = defaultLocale ? await req.payload.findGlobal({
                         depth: 2,
                         fallbackLocale: false,
@@ -237,8 +342,7 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                         req,
                         slug: proposal.slug
                     }) : null;
-                    for (const [locale, localeData] of Object.entries(proposal.localizedData)){
-                        const localeNormalized = normalizeDataForFields(globalFields, localeData);
+                    for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
                         const before = await req.payload.findGlobal({
                             depth: 2,
                             fallbackLocale: false,
@@ -246,10 +350,10 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                             req,
                             slug: proposal.slug
                         });
-                        const completedData = applyLocalizedRequiredFallback({
-                            data: localeNormalized.data,
+                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
                             fallbackSource: locale === defaultLocale ? before : defaultLocaleDoc || before,
-                            fields: globalFields
+                            fields: globalFields,
+                            preparedData: localeData
                         });
                         await req.payload.updateGlobal({
                             data: completedData,
@@ -271,13 +375,43 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                             before: beforeByLocale
                         }
                     });
+                    logHandlerEvent(req, "info", {
+                        changeLogged: Boolean(change),
+                        locales: Object.keys(proposal.localizedData),
+                        msg: "AI apply succeeded",
+                        proposal: getProposalLogSummary(proposal)
+                    });
                     return Response.json({
                         change,
                         doc: undefined,
                         status: "applied"
                     });
                 }
-                normalized = normalizeDataForFields(globalConfig?.fields || [], proposal.data);
+                const preparedData = prepareProposalWriteData({
+                    collectionConfig: {
+                        fields: globalConfig?.fields || [],
+                        slug: proposal.slug
+                    },
+                    data: proposal.data,
+                    inferenceText,
+                    label: proposal.label,
+                    mode: "update"
+                });
+                if (preparedData.issues.length > 0 || !preparedData.data) {
+                    return failApply({
+                        debug: createApplyDebugPayload({
+                            details: {
+                                issues: preparedData.issues
+                            },
+                            phase: "apply_validation",
+                            proposal,
+                            reason: "invalid_global_write_shape"
+                        }),
+                        error: "Proposal is invalid.",
+                        logMessage: "AI apply blocked: invalid global proposal data",
+                        proposal
+                    });
+                }
                 const before = await req.payload.findGlobal({
                     depth: 2,
                     ...proposal.locale ? {
@@ -287,7 +421,7 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                     slug: proposal.slug
                 });
                 const doc = await req.payload.updateGlobal({
-                    data: normalized.data,
+                    data: preparedData.data,
                     ...proposal.locale ? {
                         locale: proposal.locale
                     } : {},
@@ -301,21 +435,34 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                     proposal,
                     req,
                     target: {
-                        after: mergeData(before, normalized.data),
+                        after: mergeData(before, preparedData.data),
                         before
                     }
                 });
+                logHandlerEvent(req, "info", {
+                    changeLogged: Boolean(change),
+                    locale: proposal.locale,
+                    msg: "AI apply succeeded",
+                    proposal: getProposalLogSummary(proposal)
+                });
                 return Response.json({
                     change,
                     doc: getAppliedDocReference(doc),
                     status: "applied"
                 });
             }
-            if (!isAllowedCollection(req, proposal.collection, options.collections, proposal.action)) return Response.json({
-                error: "Unknown collection"
-            }, {
-                status: 400
-            });
+            if (!isAllowedCollection(req, proposal.collection, options.collections, proposal.action)) {
+                return failApply({
+                    debug: createApplyDebugPayload({
+                        phase: "authorization",
+                        proposal,
+                        reason: "unknown_or_disallowed_collection"
+                    }),
+                    error: "Unknown collection",
+                    logMessage: "AI apply blocked: unknown or disallowed collection",
+                    proposal
+                });
+            }
             if (proposal.action === "delete") {
                 const doc = await req.payload.delete({
                     collection: proposal.collection,
@@ -334,6 +481,12 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                         documentID: proposal.id
                     }
                 });
+                logHandlerEvent(req, "info", {
+                    changeLogged: Boolean(change),
+                    documentID: proposal.id,
+                    msg: "AI apply succeeded",
+                    proposal: getProposalLogSummary(proposal)
+                });
                 return Response.json({
                     change,
                     doc: getAppliedDocReference(doc),
@@ -341,35 +494,48 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                 });
             }
             const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === proposal.collection);
-            const collectionFields = getCollectionFields(collectionConfig);
-            const normalizeCollectionData = (data)=>normalizeAuthData(collectionConfig, normalizeDataForFields(collectionFields, data));
+            const collectionFields = getSchemaFields(collectionConfig);
             if (hasLocalizedData(proposal)) {
+                const preparedData = prepareProposalWriteData({
+                    collectionConfig,
+                    inferenceText,
+                    label: proposal.label,
+                    localizedData: proposal.localizedData,
+                    mode: proposal.action
+                });
+                if (preparedData.issues.length > 0 || !preparedData.localizedData) {
+                    return failApply({
+                        debug: createApplyDebugPayload({
+                            details: {
+                                issues: preparedData.issues
+                            },
+                            phase: "apply_validation",
+                            proposal,
+                            reason: "invalid_collection_write_shape"
+                        }),
+                        error: "Proposal is invalid.",
+                        logMessage: "AI apply blocked: invalid collection proposal data",
+                        proposal
+                    });
+                }
                 if (proposal.action === "create") {
-                    const localeEntries = Object.entries(proposal.localizedData);
+                    const localeEntries = Object.entries(preparedData.localizedData);
                     const [firstLocale, firstLocaleData] = localeEntries[0] || [];
-                    if (!firstLocale) return Response.json({
-                        error: "Proposal is invalid."
-                    }, {
-                        status: 400
-                    });
-                    const firstNormalized = normalizeCollectionData(firstLocaleData);
-                    if (isAuthCollection(collectionConfig) && !firstNormalized.data.password) {
-                        return Response.json({
-                            error: "Password is required when creating a user."
-                        }, {
-                            status: 400
-                        });
-                    }
-                    if (isAuthCollection(collectionConfig) && !firstNormalized.data.email) {
-                        return Response.json({
-                            error: "Email is required when creating a user."
-                        }, {
-                            status: 400
+                    if (!firstLocale) {
+                        return failApply({
+                            debug: createApplyDebugPayload({
+                                phase: "apply_validation",
+                                proposal,
+                                reason: "localized_create_without_locales"
+                            }),
+                            error: "Proposal is invalid.",
+                            logMessage: "AI apply blocked: localized create proposal has no locales",
+                            proposal
                         });
                     }
                     const doc = await req.payload.create({
                         collection: proposal.collection,
-                        data: firstNormalized.data,
+                        data: firstLocaleData,
                         locale: firstLocale,
                         overrideAccess: false,
                         req
@@ -382,11 +548,10 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                     };
                     let fallbackSource = doc;
                     for (const [locale, localeData] of localeEntries.slice(1)){
-                        const localeNormalized = normalizeCollectionData(localeData);
-                        const completedData = applyLocalizedRequiredFallback({
-                            data: localeNormalized.data,
+                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
                             fallbackSource,
-                            fields: collectionFields
+                            fields: collectionFields,
+                            preparedData: localeData
                         });
                         await req.payload.update({
                             collection: proposal.collection,
@@ -410,6 +575,13 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                             documentID: doc.id
                         }
                     });
+                    logHandlerEvent(req, "info", {
+                        changeLogged: Boolean(change),
+                        documentID: doc.id,
+                        locales: localeEntries.map(([locale])=>locale),
+                        msg: "AI apply succeeded",
+                        proposal: getProposalLogSummary(proposal)
+                    });
                     return Response.json({
                         change,
                         doc: getAppliedDocReference(doc),
@@ -426,8 +598,7 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                     locale: defaultLocale,
                     req
                 }) : null;
-                for (const [locale, localeData] of Object.entries(proposal.localizedData)){
-                    const localeNormalized = normalizeCollectionData(localeData);
+                for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
                     const before = await req.payload.findByID({
                         collection: proposal.collection,
                         depth: 2,
@@ -436,10 +607,10 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                         locale,
                         req
                     });
-                    const completedData = applyLocalizedRequiredFallback({
-                        data: localeNormalized.data,
+                    const completedData = applyLocalizedRequiredFallbackToPreparedData({
                         fallbackSource: locale === defaultLocale ? before : defaultLocaleDoc || before,
-                        fields: collectionFields
+                        fields: collectionFields,
+                        preparedData: localeData
                     });
                     await req.payload.update({
                         collection: proposal.collection,
@@ -463,6 +634,13 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                         documentID: proposal.id
                     }
                 });
+                logHandlerEvent(req, "info", {
+                    changeLogged: Boolean(change),
+                    documentID: proposal.id,
+                    locales: Object.keys(proposal.localizedData),
+                    msg: "AI apply succeeded",
+                    proposal: getProposalLogSummary(proposal)
+                });
                 return Response.json({
                     change,
                     doc: {
@@ -471,25 +649,32 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                     status: "applied"
                 });
             }
-            normalized = normalizeCollectionData(proposal.data);
-            if (proposal.action === "create" && isAuthCollection(collectionConfig) && !normalized.data.password) {
-                return Response.json({
-                    error: "Password is required when creating a user."
-                }, {
-                    status: 400
-                });
-            }
-            if (proposal.action === "create" && isAuthCollection(collectionConfig) && !normalized.data.email) {
-                return Response.json({
-                    error: "Email is required when creating a user."
-                }, {
-                    status: 400
+            const preparedData = prepareProposalWriteData({
+                collectionConfig,
+                data: proposal.data,
+                inferenceText,
+                label: proposal.label,
+                mode: proposal.action
+            });
+            if (preparedData.issues.length > 0 || !preparedData.data) {
+                return failApply({
+                    debug: createApplyDebugPayload({
+                        details: {
+                            issues: preparedData.issues
+                        },
+                        phase: "apply_validation",
+                        proposal,
+                        reason: "invalid_collection_write_shape"
+                    }),
+                    error: "Proposal is invalid.",
+                    logMessage: "AI apply blocked: invalid collection proposal data",
+                    proposal
                 });
             }
             if (proposal.action === "create") {
                 const doc = await req.payload.create({
                     collection: proposal.collection,
-                    data: normalized.data,
+                    data: preparedData.data,
                     ...proposal.locale ? {
                         locale: proposal.locale
                     } : {},
@@ -507,6 +692,12 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                         documentID: doc.id
                     }
                 });
+                logHandlerEvent(req, "info", {
+                    changeLogged: Boolean(change),
+                    documentID: doc.id,
+                    msg: "AI apply succeeded",
+                    proposal: getProposalLogSummary(proposal)
+                });
                 return Response.json({
                     change,
                     doc: getAppliedDocReference(doc),
@@ -524,7 +715,7 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
             });
             const doc = await req.payload.update({
                 collection: proposal.collection,
-                data: normalized.data,
+                data: preparedData.data,
                 id: proposal.id,
                 ...proposal.locale ? {
                     locale: proposal.locale
@@ -538,23 +729,41 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
                 proposal,
                 req,
                 target: {
-                    after: mergeData(before, normalized.data),
+                    after: mergeData(before, preparedData.data),
                     before,
                     documentID: proposal.id
                 }
             });
+            logHandlerEvent(req, "info", {
+                changeLogged: Boolean(change),
+                documentID: proposal.id,
+                msg: "AI apply succeeded",
+                proposal: getProposalLogSummary(proposal)
+            });
             return Response.json({
                 change,
                 doc: getAppliedDocReference(doc),
                 status: "applied"
             });
         } catch (err) {
+            const debug = createApplyDebugPayload({
+                details: err && typeof err === "object" && "data" in err && isRecord(err.data) ? {
+                    payloadError: err.data
+                } : undefined,
+                phase: "payload_operation",
+                proposal,
+                reason: "payload_operation_failed"
+            });
             req.payload.logger.error({
+                debug,
                 err,
                 msg: "AI apply action failed",
-                proposal: getProposalMeta(proposal)
+                promptPreview: getLogPreview(logContext.prompt),
+                proposal: getProposalMeta(proposal),
+                tokenUsage: logContext.tokenUsage
             });
             return Response.json({
+                debug,
                 error: "Could not apply proposal."
             }, {
                 status: 400