@mvriu5/payload-ai 0.5.9 → 1.1.1

package/dist/handlers/applyActionHandler.js

@@ -0,0 +1,563 @@
+import { verifyActionProposal } from "../ai/proposalSigning.js";
+import { containsSensitiveData, redactSensitiveData } from "../ai/sensitiveData.js";
+import { getCollectionFields, getLocalizedRequiredFallbackData, isAuthCollection, normalizeAuthData, normalizeDataForFields } from "../payload/normalizeData.js";
+import { isCollectionActionAllowed } from "../payload/collectionPermissions.js";
+import { getDefaultLocale, getJSONLineKey, getOptionalNumber, hasLocalizedData, isActionProposal, isKnownGlobal, mergeData } from "../payload/shared.js";
+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 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 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");
+    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;
+    }
+};
+export const createApplyActionHandler = (options = {})=>async (req)=>{
+        if (!req.user) return Response.json({
+            error: "Unauthorized"
+        }, {
+            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;
+        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
+        };
+        try {
+            const defaultLocale = getDefaultLocale(req);
+            if (proposal.action === "updateGlobal") {
+                if (!isKnownGlobal(req, proposal.slug)) return Response.json({
+                    error: "Unknown global"
+                }, {
+                    status: 400
+                });
+                const globalConfig = req.payload.config.globals?.find((global)=>global.slug === proposal.slug);
+                if (hasLocalizedData(proposal)) {
+                    const beforeByLocale = {};
+                    const afterByLocale = {};
+                    const globalFields = globalConfig?.fields || [];
+                    const defaultLocaleDoc = defaultLocale ? await req.payload.findGlobal({
+                        depth: 2,
+                        fallbackLocale: false,
+                        locale: defaultLocale,
+                        req,
+                        slug: proposal.slug
+                    }) : null;
+                    for (const [locale, localeData] of Object.entries(proposal.localizedData)){
+                        const localeNormalized = normalizeDataForFields(globalFields, localeData);
+                        const before = await req.payload.findGlobal({
+                            depth: 2,
+                            fallbackLocale: false,
+                            locale,
+                            req,
+                            slug: proposal.slug
+                        });
+                        const completedData = applyLocalizedRequiredFallback({
+                            data: localeNormalized.data,
+                            fallbackSource: locale === defaultLocale ? before : defaultLocaleDoc || before,
+                            fields: globalFields
+                        });
+                        await req.payload.updateGlobal({
+                            data: completedData,
+                            locale,
+                            overrideAccess: false,
+                            req,
+                            slug: proposal.slug
+                        });
+                        beforeByLocale[locale] = before;
+                        afterByLocale[locale] = mergeData(before, completedData);
+                    }
+                    const change = await logAIChange({
+                        changeLogCollection: options.changeLogCollection,
+                        context: logContext,
+                        proposal,
+                        req,
+                        target: {
+                            after: afterByLocale,
+                            before: beforeByLocale
+                        }
+                    });
+                    return Response.json({
+                        change,
+                        doc: undefined,
+                        status: "applied"
+                    });
+                }
+                normalized = normalizeDataForFields(globalConfig?.fields || [], proposal.data);
+                const before = await req.payload.findGlobal({
+                    depth: 2,
+                    ...proposal.locale ? {
+                        locale: proposal.locale
+                    } : {},
+                    req,
+                    slug: proposal.slug
+                });
+                const doc = await req.payload.updateGlobal({
+                    data: normalized.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, normalized.data),
+                        before
+                    }
+                });
+                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 (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
+                    }
+                });
+                return Response.json({
+                    change,
+                    doc: getAppliedDocReference(doc),
+                    status: "applied"
+                });
+            }
+            const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === proposal.collection);
+            const collectionFields = getCollectionFields(collectionConfig);
+            const normalizeCollectionData = (data)=>normalizeAuthData(collectionConfig, normalizeDataForFields(collectionFields, data));
+            if (hasLocalizedData(proposal)) {
+                if (proposal.action === "create") {
+                    const localeEntries = Object.entries(proposal.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
+                        });
+                    }
+                    const doc = await req.payload.create({
+                        collection: proposal.collection,
+                        data: firstNormalized.data,
+                        locale: firstLocale,
+                        overrideAccess: false,
+                        req
+                    });
+                    const beforeByLocale = {
+                        [firstLocale]: {}
+                    };
+                    const afterByLocale = {
+                        [firstLocale]: doc
+                    };
+                    let fallbackSource = doc;
+                    for (const [locale, localeData] of localeEntries.slice(1)){
+                        const localeNormalized = normalizeCollectionData(localeData);
+                        const completedData = applyLocalizedRequiredFallback({
+                            data: localeNormalized.data,
+                            fallbackSource,
+                            fields: collectionFields
+                        });
+                        await req.payload.update({
+                            collection: proposal.collection,
+                            data: completedData,
+                            id: String(doc.id),
+                            locale,
+                            overrideAccess: false,
+                            req
+                        });
+                        beforeByLocale[locale] = {};
+                        afterByLocale[locale] = completedData;
+                    }
+                    const change = await logAIChange({
+                        changeLogCollection: options.changeLogCollection,
+                        context: logContext,
+                        proposal,
+                        req,
+                        target: {
+                            after: afterByLocale,
+                            before: beforeByLocale,
+                            documentID: doc.id
+                        }
+                    });
+                    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;
+                for (const [locale, localeData] of Object.entries(proposal.localizedData)){
+                    const localeNormalized = normalizeCollectionData(localeData);
+                    const before = await req.payload.findByID({
+                        collection: proposal.collection,
+                        depth: 2,
+                        fallbackLocale: false,
+                        id: proposal.id,
+                        locale,
+                        req
+                    });
+                    const completedData = applyLocalizedRequiredFallback({
+                        data: localeNormalized.data,
+                        fallbackSource: locale === defaultLocale ? before : defaultLocaleDoc || before,
+                        fields: collectionFields
+                    });
+                    await req.payload.update({
+                        collection: proposal.collection,
+                        data: completedData,
+                        id: proposal.id,
+                        locale,
+                        overrideAccess: false,
+                        req
+                    });
+                    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
+                    }
+                });
+                return Response.json({
+                    change,
+                    doc: {
+                        id: proposal.id
+                    },
+                    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
+                });
+            }
+            if (proposal.action === "create") {
+                const doc = await req.payload.create({
+                    collection: proposal.collection,
+                    data: normalized.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
+                    }
+                });
+                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: normalized.data,
+                id: proposal.id,
+                ...proposal.locale ? {
+                    locale: proposal.locale
+                } : {},
+                overrideAccess: false,
+                req
+            });
+            const change = await logAIChange({
+                changeLogCollection: options.changeLogCollection,
+                context: logContext,
+                proposal,
+                req,
+                target: {
+                    after: mergeData(before, normalized.data),
+                    before,
+                    documentID: proposal.id
+                }
+            });
+            return Response.json({
+                change,
+                doc: getAppliedDocReference(doc),
+                status: "applied"
+            });
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: "AI apply action failed",
+                proposal: getProposalMeta(proposal)
+            });
+            return Response.json({
+                error: "Could not apply proposal."
+            }, {
+                status: 400
+            });
+        }
+    };

package/dist/handlers/auditLogHandler.d.ts

@@ -0,0 +1,6 @@
+import type { PayloadHandler } from "payload";
+type AuditLogOptions = {
+    changeLogCollection: string;
+};
+export declare const createAuditLogHandler: (options: AuditLogOptions) => PayloadHandler;
+export {};

package/dist/{endpoints/aiRecentChangesEndpointHandler.js → handlers/auditLogHandler.js}

@@ -1,10 +1,5 @@
-const getNumber = (value)=>{
-    return typeof value === "number" && Number.isFinite(value) ? value : 0;
-};
-const getString = (value)=>{
-    return typeof value === "string" ? value : null;
-};
-export const createAIRecentChangesEndpointHandler = (options)=>async (req)=>{
+import { getNumber, getString } from "../payload/shared.js";
+export const createAuditLogHandler = (options)=>async (req)=>{
         if (!req.user) return Response.json({
             error: "Unauthorized"
         }, {
@@ -13,7 +8,7 @@ export const createAIRecentChangesEndpointHandler = (options)=>async (req)=>{
         const result = await req.payload.find({
             collection: options.changeLogCollection,
             depth: 0,
-            limit: 12,
+            limit: 10,
             overrideAccess: false,
             req,
             sort: "-createdAt"
@@ -23,12 +18,21 @@ export const createAIRecentChangesEndpointHandler = (options)=>async (req)=>{
                     action: getString(doc.action),
                     additions: getNumber(doc.additions),
                     after: doc.after,
+                    aiResponse: getString(doc.aiResponse),
                     before: doc.before,
                     collection: getString(doc.collection),
+                    createdAt: getString(doc.createdAt),
                     documentID: getString(doc.documentID),
+                    inputTokens: getNumber(doc.inputTokens),
+                    outputTokens: getNumber(doc.outputTokens),
+                    prompt: getString(doc.prompt),
                     removals: getNumber(doc.removals),
                     slug: getString(doc.slug),
+                    targetType: getString(doc.targetType),
+                    totalTokens: getNumber(doc.totalTokens),
                     title: getString(doc.title) || "AI change",
+                    userID: getString(doc.userID),
+                    userLabel: getString(doc.userLabel),
                     url: getString(doc.targetURL)
                 }))
         });

package/dist/handlers/chatHandler.d.ts

@@ -0,0 +1,42 @@
+import type { PayloadHandler } from "payload";
+import { type AIActionSignature } from "../ai/proposalSigning.js";
+import { type AIModelConfig } from "../ai/providerOptions.js";
+import { type ResolvedCollectionPermissionMap } from "../payload/collectionPermissions.js";
+type LocalizedDataInput = Record<string, Record<string, unknown>>;
+type ProposalWritePayload = {
+    data: Record<string, unknown>;
+    localizedData?: never;
+} | {
+    data?: never;
+    localizedData: LocalizedDataInput;
+};
+export type ActionProposal = (({
+    action: "create";
+    collection: string;
+    label: string;
+} & ProposalWritePayload) | {
+    action: "delete";
+    collection: string;
+    id: string;
+    label: string;
+} | ({
+    action: "update";
+    collection: string;
+    id: string;
+    label: string;
+} & ProposalWritePayload) | ({
+    action: "updateGlobal";
+    label: string;
+    slug: string;
+} & ProposalWritePayload)) & {
+    _aiSignature?: AIActionSignature;
+    locale?: string;
+};
+type ChatOptions = {
+    allowUserApiKeys?: boolean;
+    collections?: ResolvedCollectionPermissionMap;
+    maxOutputTokens?: number;
+    models?: AIModelConfig;
+};
+export declare const createChatHandler: (options?: ChatOptions) => PayloadHandler;
+export {};