@mvriu5/payload-ai 1.6.2 → 1.6.4

package/dist/handlers/applyActionHandler.js

@@ -1,285 +1,12 @@
-import { verifyActionProposal } from "../ai/proposalSigning.js";
-import { containsSensitiveData, redactSensitiveData } from "../ai/sensitiveData.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, 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 {
-        action: proposal.action,
-        collection: "collection" in proposal ? proposal.collection : undefined,
-        id: "id" in proposal ? proposal.id : undefined,
-        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
-    };
-};
-const isAllowedCollection = (req, collection, collections, action = "read")=>{
-    return isCollectionActionAllowed({
-        action,
-        permissions: collections,
-        req,
-        slug: collection
-    });
-};
-const countDiffChanges = ({ after, before })=>{
-    const beforeLines = JSON.stringify(before, null, 2).split("\n");
-    const afterLines = JSON.stringify(after, null, 2).split("\n");
-    const dp = Array.from({
-        length: beforeLines.length + 1
-    }, ()=>Array(afterLines.length + 1).fill(0));
-    let additions = 0;
-    let removals = 0;
-    for(let i = beforeLines.length - 1; i >= 0; i -= 1){
-        for(let j = afterLines.length - 1; j >= 0; j -= 1){
-            dp[i][j] = beforeLines[i] === afterLines[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
-        }
-    }
-    let beforeIndex = 0;
-    let afterIndex = 0;
-    while(beforeIndex < beforeLines.length && afterIndex < afterLines.length){
-        if (beforeLines[beforeIndex] === afterLines[afterIndex]) {
-            beforeIndex += 1;
-            afterIndex += 1;
-            continue;
-        }
-        const beforeKey = getJSONLineKey(beforeLines[beforeIndex]);
-        const afterKey = getJSONLineKey(afterLines[afterIndex]);
-        if (beforeKey && beforeKey === afterKey) {
-            removals += 1;
-            additions += 1;
-            beforeIndex += 1;
-            afterIndex += 1;
-            continue;
-        }
-        if (dp[beforeIndex + 1][afterIndex] >= dp[beforeIndex][afterIndex + 1]) {
-            removals += 1;
-            beforeIndex += 1;
-        } else {
-            additions += 1;
-            afterIndex += 1;
-        }
-    }
-    removals += beforeLines.length - beforeIndex;
-    additions += afterLines.length - afterIndex;
-    return {
-        additions,
-        removals
-    };
-};
-const getTargetURL = ({ documentID, proposal, req })=>{
-    const adminRoute = req.payload.config.routes.admin || "/admin";
-    if (proposal.action === "updateGlobal") return `${adminRoute}/globals/${proposal.slug}`;
-    if (proposal.action === "delete") return null;
-    const id = proposal.action === "create" ? documentID : proposal.id;
-    if (!id) return null;
-    return `${adminRoute}/collections/${proposal.collection}/${id}`;
-};
-const getUserID = (req)=>{
-    const user = req.user;
-    return user?.id === undefined ? undefined : String(user.id);
-};
-const getUserLabel = (req)=>{
-    const user = req.user;
-    if (typeof user?.email === "string" && user.email) return user.email;
-    if (typeof user?.name === "string" && user.name) return user.name;
-    if (typeof user?.username === "string" && user.username) return user.username;
-    if (user?.id !== undefined) return String(user.id);
-    return null;
-};
-const logAIChange = async ({ changeLogCollection, context, target, proposal, req })=>{
-    if (!changeLogCollection) return null;
-    const before = redactSensitiveData(target.before);
-    const after = redactSensitiveData(target.after);
-    const { additions, removals } = countDiffChanges({
-        after,
-        before
-    });
-    const proposalForLog = {
-        ...proposal
-    };
-    delete proposalForLog._aiSignature;
-    try {
-        await req.payload.create({
-            collection: changeLogCollection,
-            data: {
-                action: proposal.action,
-                additions,
-                after,
-                aiResponse: context?.aiResponse,
-                before,
-                collection: "collection" in proposal ? proposal.collection : undefined,
-                documentID: target.documentID === undefined ? undefined : String(target.documentID),
-                inputTokens: context?.tokenUsage?.inputTokens,
-                outputTokens: context?.tokenUsage?.outputTokens,
-                prompt: context?.prompt,
-                proposal: redactSensitiveData(proposalForLog),
-                removals,
-                slug: "slug" in proposal ? proposal.slug : undefined,
-                totalTokens: context?.tokenUsage?.totalTokens,
-                targetType: proposal.action === "updateGlobal" ? "global" : "collection",
-                targetURL: getTargetURL({
-                    documentID: target.documentID,
-                    proposal,
-                    req
-                }),
-                title: proposal.label,
-                userID: getUserID(req),
-                userLabel: getUserLabel(req)
-            },
-            overrideAccess: true,
-            req
-        });
-        return {
-            action: proposal.action,
-            additions,
-            after,
-            aiResponse: context?.aiResponse || null,
-            before,
-            collection: "collection" in proposal ? proposal.collection : null,
-            createdAt: new Date().toISOString(),
-            documentID: target.documentID === undefined ? null : String(target.documentID),
-            inputTokens: context?.tokenUsage?.inputTokens ?? null,
-            outputTokens: context?.tokenUsage?.outputTokens ?? null,
-            prompt: context?.prompt || null,
-            removals,
-            slug: "slug" in proposal ? proposal.slug : null,
-            totalTokens: context?.tokenUsage?.totalTokens ?? null,
-            targetType: proposal.action === "updateGlobal" ? "global" : "collection",
-            title: proposal.label,
-            userID: getUserID(req) || null,
-            userLabel: getUserLabel(req),
-            url: getTargetURL({
-                documentID: target.documentID,
-                proposal,
-                req
-            })
-        };
-    } catch (err) {
-        req.payload.logger.error({
-            err,
-            msg: "AI change log entry could not be written",
-            proposal: getProposalMeta(proposal)
-        });
-        return null;
-    }
-};
+import { getLogPreview, logHandlerEvent } from "../utils/logging.js";
+import { isRecord } from "../utils/data.js";
+import { applyActionProposal } from "./apply/operations.js";
+import { createApplyDebugPayload, createApplyFailureResponse, getProposalLogSummary, getProposalMeta, resolveApplyRequest } from "./apply/validation.js";
 export const createApplyActionHandler = (options = {})=>async (req)=>{
-        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 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,
-            tokenUsage: body?.tokenUsage ? {
-                inputTokens: getOptionalNumber(body.tokenUsage.inputTokens),
-                outputTokens: getOptionalNumber(body.tokenUsage.outputTokens),
-                totalTokens: getOptionalNumber(body.tokenUsage.totalTokens)
-            } : undefined
-        };
+        const resolution = await resolveApplyRequest(req);
+        if (!resolution.ok) return createApplyFailureResponse(req, resolution.failure);
+        const { context: logContext, proposal } = resolution;
+        const failApply = (failure)=>createApplyFailureResponse(req, failure);
         logHandlerEvent(req, "info", {
             msg: "AI apply started",
             promptPreview: getLogPreview(logContext.prompt),
@@ -287,483 +14,12 @@ export const createApplyActionHandler = (options = {})=>async (req)=>{
             tokenUsage: logContext.tokenUsage
         });
         try {
-            const inferenceText = logContext.prompt;
-            const defaultLocale = getDefaultLocale(req);
-            if (proposal.action === "updateGlobal") {
-                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 = 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,
-                        locale: defaultLocale,
-                        req,
-                        slug: proposal.slug
-                    }) : null;
-                    const localizedResults = await Promise.all(Object.entries(preparedData.localizedData).map(async ([locale, localeData])=>{
-                        const before = await req.payload.findGlobal({
-                            depth: 2,
-                            fallbackLocale: false,
-                            locale,
-                            req,
-                            slug: proposal.slug
-                        });
-                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
-                            fallbackSource: locale === defaultLocale ? before : defaultLocaleDoc || before,
-                            fields: globalFields,
-                            preparedData: localeData
-                        });
-                        await req.payload.updateGlobal({
-                            data: completedData,
-                            locale,
-                            overrideAccess: false,
-                            req,
-                            slug: proposal.slug
-                        });
-                        return {
-                            before,
-                            completedData,
-                            locale
-                        };
-                    }));
-                    localizedResults.forEach(({ before, completedData, locale })=>{
-                        beforeByLocale[locale] = before;
-                        afterByLocale[locale] = mergeData(before, completedData);
-                    });
-                    const change = await logAIChange({
-                        changeLogCollection: options.changeLogCollection,
-                        context: logContext,
-                        proposal,
-                        req,
-                        target: {
-                            after: afterByLocale,
-                            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"
-                    });
-                }
-                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 ? {
-                        locale: proposal.locale
-                    } : {},
-                    req,
-                    slug: proposal.slug
-                });
-                const doc = await req.payload.updateGlobal({
-                    data: preparedData.data,
-                    ...proposal.locale ? {
-                        locale: proposal.locale
-                    } : {},
-                    overrideAccess: false,
-                    req,
-                    slug: proposal.slug
-                });
-                const change = await logAIChange({
-                    changeLogCollection: options.changeLogCollection,
-                    context: logContext,
-                    proposal,
-                    req,
-                    target: {
-                        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 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,
-                    id: proposal.id,
-                    overrideAccess: false,
-                    req
-                });
-                const change = await logAIChange({
-                    changeLogCollection: options.changeLogCollection,
-                    context: logContext,
-                    proposal,
-                    req,
-                    target: {
-                        after: {},
-                        before: doc,
-                        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"
-                });
-            }
-            const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === proposal.collection);
-            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(preparedData.localizedData);
-                    const [firstLocale, firstLocaleData] = localeEntries[0] || [];
-                    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: firstLocaleData,
-                        locale: firstLocale,
-                        overrideAccess: false,
-                        req
-                    });
-                    const beforeByLocale = {
-                        [firstLocale]: {}
-                    };
-                    const afterByLocale = {
-                        [firstLocale]: doc
-                    };
-                    const fallbackSource = doc;
-                    const localizedResults = await Promise.all(localeEntries.slice(1).map(async ([locale, localeData])=>{
-                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
-                            fallbackSource,
-                            fields: collectionFields,
-                            preparedData: localeData
-                        });
-                        await req.payload.update({
-                            collection: proposal.collection,
-                            data: completedData,
-                            id: String(doc.id),
-                            locale,
-                            overrideAccess: false,
-                            req
-                        });
-                        return {
-                            completedData,
-                            locale
-                        };
-                    }));
-                    localizedResults.forEach(({ completedData, locale })=>{
-                        beforeByLocale[locale] = {};
-                        afterByLocale[locale] = completedData;
-                    });
-                    const change = await logAIChange({
-                        changeLogCollection: options.changeLogCollection,
-                        context: logContext,
-                        proposal,
-                        req,
-                        target: {
-                            after: afterByLocale,
-                            before: beforeByLocale,
-                            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),
-                        status: "applied"
-                    });
-                }
-                const beforeByLocale = {};
-                const afterByLocale = {};
-                const defaultLocaleDoc = defaultLocale ? await req.payload.findByID({
-                    collection: proposal.collection,
-                    depth: 2,
-                    fallbackLocale: false,
-                    id: proposal.id,
-                    locale: defaultLocale,
-                    req
-                }) : null;
-                const localizedResults = await Promise.all(Object.entries(preparedData.localizedData).map(async ([locale, localeData])=>{
-                    const before = await req.payload.findByID({
-                        collection: proposal.collection,
-                        depth: 2,
-                        fallbackLocale: false,
-                        id: proposal.id,
-                        locale,
-                        req
-                    });
-                    const completedData = applyLocalizedRequiredFallbackToPreparedData({
-                        fallbackSource: locale === defaultLocale ? before : defaultLocaleDoc || before,
-                        fields: collectionFields,
-                        preparedData: localeData
-                    });
-                    await req.payload.update({
-                        collection: proposal.collection,
-                        data: completedData,
-                        id: proposal.id,
-                        locale,
-                        overrideAccess: false,
-                        req
-                    });
-                    return {
-                        before,
-                        completedData,
-                        locale
-                    };
-                }));
-                localizedResults.forEach(({ before, completedData, locale })=>{
-                    beforeByLocale[locale] = before;
-                    afterByLocale[locale] = mergeData(before, completedData);
-                });
-                const change = await logAIChange({
-                    changeLogCollection: options.changeLogCollection,
-                    context: logContext,
-                    proposal,
-                    req,
-                    target: {
-                        after: afterByLocale,
-                        before: beforeByLocale,
-                        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: {
-                        id: proposal.id
-                    },
-                    status: "applied"
-                });
-            }
-            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: preparedData.data,
-                    ...proposal.locale ? {
-                        locale: proposal.locale
-                    } : {},
-                    overrideAccess: false,
-                    req
-                });
-                const change = await logAIChange({
-                    changeLogCollection: options.changeLogCollection,
-                    context: logContext,
-                    proposal,
-                    req,
-                    target: {
-                        after: doc,
-                        before: {},
-                        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),
-                    status: "applied"
-                });
-            }
-            const before = await req.payload.findByID({
-                collection: proposal.collection,
-                depth: 2,
-                id: proposal.id,
-                ...proposal.locale ? {
-                    locale: proposal.locale
-                } : {},
-                req
-            });
-            const doc = await req.payload.update({
-                collection: proposal.collection,
-                data: preparedData.data,
-                id: proposal.id,
-                ...proposal.locale ? {
-                    locale: proposal.locale
-                } : {},
-                overrideAccess: false,
-                req
-            });
-            const change = await logAIChange({
-                changeLogCollection: options.changeLogCollection,
-                context: logContext,
+            return await applyActionProposal({
+                failApply,
+                logContext,
+                options,
                 proposal,
-                req,
-                target: {
-                    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"
+                req
             });
         } catch (err) {
             const debug = createApplyDebugPayload({