@mvriu5/payload-ai 0.5.9 → 0.5.10

package/dist/handlers/mentionSuggestionHandler.js

@@ -0,0 +1,97 @@
+import { isCollectionActionAllowed } from "../payload/collectionPermissions.js";
+import { getDocLabel } from "../payload/shared.js";
+const getLocaleCodes = (req)=>{
+    const localization = req.payload.config.localization;
+    if (!localization) return [];
+    if (Array.isArray(localization.localeCodes)) return localization.localeCodes;
+    const locales = localization.locales || [];
+    return locales.flatMap((locale)=>{
+        if (typeof locale === "string") return [
+            locale
+        ];
+        if (locale && typeof locale === "object" && "code" in locale && typeof locale.code === "string") return [
+            locale.code
+        ];
+        return [];
+    });
+};
+const hasLocalizedFields = (fields)=>{
+    return fields.some((field)=>{
+        return Boolean(field.localized) || Boolean(field.fields?.length && hasLocalizedFields(field.fields)) || Boolean(field.tabs?.some((tab)=>hasLocalizedFields(tab.fields || [])));
+    });
+};
+export const createMentionSuggestionHandler = (options = {})=>async (req)=>{
+        if (!req.user) return Response.json({
+            error: "Unauthorized"
+        }, {
+            status: 401
+        });
+        const body = req.json ? await req.json().catch(()=>null) : null;
+        const query = body?.query?.trim();
+        const collectionSlug = body?.collectionSlug?.trim();
+        if (!query && !collectionSlug) return Response.json({
+            suggestions: []
+        });
+        const suggestions = [];
+        const suggestionKeys = new Set();
+        const normalizedQuery = query?.toLowerCase();
+        const collections = req.payload.config.collections.filter((collection)=>{
+            if (!isCollectionActionAllowed({
+                action: "read",
+                permissions: options.collections,
+                req,
+                slug: collection.slug
+            })) return false;
+            if (collectionSlug) return collection.slug === collectionSlug;
+            return true;
+        });
+        const addSuggestion = ({ collectionSlug, doc, requireLabelMatch = false, useAsTitle })=>{
+            const id = doc.id?.toString();
+            if (!id) return;
+            const key = `${collectionSlug}:${id}`;
+            if (suggestionKeys.has(key)) return;
+            const label = getDocLabel(doc, useAsTitle);
+            if (requireLabelMatch && normalizedQuery && !label.toLowerCase().includes(normalizedQuery)) return;
+            suggestionKeys.add(key);
+            suggestions.push({
+                collection: collectionSlug,
+                id,
+                label,
+                slug: key,
+                type: "doc"
+            });
+        };
+        for (const collection of collections){
+            if (suggestions.length >= 5) break;
+            const collectionFields = collection.fields;
+            const localeCodes = query && hasLocalizedFields(collectionFields) ? getLocaleCodes(req) : [];
+            const localesToSearch = localeCodes.length > 0 ? localeCodes : [
+                null
+            ];
+            for (const locale of localesToSearch){
+                if (suggestions.length >= 5) break;
+                const result = await req.payload.find({
+                    collection: collection.slug,
+                    depth: 0,
+                    limit: query ? 100 : 10,
+                    ...locale ? {
+                        locale
+                    } : {},
+                    overrideAccess: false,
+                    req
+                });
+                for (const doc of result.docs){
+                    if (suggestions.length >= 5) break;
+                    addSuggestion({
+                        collectionSlug: collection.slug,
+                        doc,
+                        requireLabelMatch: Boolean(normalizedQuery),
+                        useAsTitle: collection.admin?.useAsTitle
+                    });
+                }
+            }
+        }
+        return Response.json({
+            suggestions: suggestions.slice(0, 5)
+        });
+    };

package/dist/handlers/proposalDiffHandler.d.ts

@@ -0,0 +1,7 @@
+import type { PayloadHandler } from "payload";
+import { type ResolvedCollectionPermissionMap } from "../payload/collectionPermissions.js";
+type ProposalDiffOptions = {
+    collections?: ResolvedCollectionPermissionMap;
+};
+export declare const createProposalDiffHandler: (options?: ProposalDiffOptions) => PayloadHandler;
+export {};

package/dist/handlers/proposalDiffHandler.js

@@ -0,0 +1,208 @@
+import { verifyActionProposal } from "../ai/proposalSigning.js";
+import { redactSensitiveData } from "../ai/sensitiveData.js";
+import { getCollectionFields, getLocalizedRequiredFallbackData, normalizeAuthData, normalizeDataForFields } from "../payload/normalizeData.js";
+import { isCollectionActionAllowed } from "../payload/collectionPermissions.js";
+import { getDefaultLocale, hasLocalizedData, isActionProposal, mergeData } from "../payload/shared.js";
+const applyLocalizedRequiredFallback = ({ data, fallbackSource, fields })=>{
+    return mergeData(getLocalizedRequiredFallbackData({
+        fields,
+        source: fallbackSource,
+        target: data
+    }), data);
+};
+export const createProposalDiffHandler = (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
+        });
+        try {
+            const defaultLocale = getDefaultLocale(req);
+            if (proposal.action === "updateGlobal") {
+                const globalConfig = req.payload.config.globals?.find((global)=>global.slug === proposal.slug);
+                if (!globalConfig) return Response.json({
+                    error: "Unknown global"
+                }, {
+                    status: 400
+                });
+                if (hasLocalizedData(proposal)) {
+                    const beforeByLocale = {};
+                    const afterByLocale = {};
+                    const globalFields = globalConfig.fields || [];
+                    const defaultLocaleDoc = defaultLocale ? await req.payload.findGlobal({
+                        depth: 2,
+                        fallbackLocale: false,
+                        locale: defaultLocale,
+                        overrideAccess: false,
+                        req,
+                        slug: proposal.slug
+                    }) : null;
+                    for (const [locale, localeData] of Object.entries(proposal.localizedData)){
+                        const normalized = normalizeDataForFields(globalFields, localeData);
+                        const doc = await req.payload.findGlobal({
+                            depth: 2,
+                            fallbackLocale: false,
+                            locale,
+                            overrideAccess: false,
+                            req,
+                            slug: proposal.slug
+                        });
+                        const completedData = applyLocalizedRequiredFallback({
+                            data: normalized.data,
+                            fallbackSource: locale === defaultLocale ? doc : defaultLocaleDoc || doc,
+                            fields: globalFields
+                        });
+                        beforeByLocale[locale] = redactSensitiveData(doc);
+                        afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
+                    }
+                    return Response.json({
+                        after: afterByLocale,
+                        before: beforeByLocale
+                    });
+                }
+                const normalized = normalizeDataForFields(globalConfig.fields || [], proposal.data);
+                const doc = await req.payload.findGlobal({
+                    depth: 2,
+                    ...proposal.locale ? {
+                        locale: proposal.locale
+                    } : {},
+                    overrideAccess: false,
+                    req,
+                    slug: proposal.slug
+                });
+                return Response.json({
+                    after: redactSensitiveData(mergeData(doc, normalized.data)),
+                    before: redactSensitiveData(doc)
+                });
+            }
+            if (!isCollectionActionAllowed({
+                action: proposal.action === "delete" ? "delete" : "read",
+                permissions: options.collections,
+                req,
+                slug: proposal.collection
+            })) return Response.json({
+                error: "Unknown collection"
+            }, {
+                status: 400
+            });
+            if (proposal.action === "delete") {
+                const doc = await req.payload.findByID({
+                    collection: proposal.collection,
+                    depth: 2,
+                    id: proposal.id,
+                    ...proposal.locale ? {
+                        locale: proposal.locale
+                    } : {},
+                    overrideAccess: false,
+                    req
+                });
+                return Response.json({
+                    after: {},
+                    before: redactSensitiveData(doc)
+                });
+            }
+            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)) {
+                const afterByLocale = {};
+                const beforeByLocale = {};
+                const defaultLocaleDoc = proposal.action === "update" && defaultLocale ? await req.payload.findByID({
+                    collection: proposal.collection,
+                    depth: 2,
+                    fallbackLocale: false,
+                    id: proposal.id,
+                    locale: defaultLocale,
+                    overrideAccess: false,
+                    req
+                }) : null;
+                let createFallbackSource = null;
+                for (const [locale, localeData] of Object.entries(proposal.localizedData)){
+                    const normalized = normalizeCollectionData(localeData);
+                    const fallbackSource = proposal.action === "create" ? createFallbackSource || {} : locale === defaultLocale ? await req.payload.findByID({
+                        collection: proposal.collection,
+                        depth: 2,
+                        fallbackLocale: false,
+                        id: proposal.id,
+                        locale,
+                        overrideAccess: false,
+                        req
+                    }) : defaultLocaleDoc || {};
+                    const completedData = applyLocalizedRequiredFallback({
+                        data: normalized.data,
+                        fallbackSource,
+                        fields: collectionFields
+                    });
+                    if (proposal.action === "create") {
+                        beforeByLocale[locale] = {};
+                        afterByLocale[locale] = redactSensitiveData(completedData);
+                        createFallbackSource = mergeData(createFallbackSource || {}, completedData);
+                        continue;
+                    }
+                    const doc = await req.payload.findByID({
+                        collection: proposal.collection,
+                        depth: 2,
+                        fallbackLocale: false,
+                        id: proposal.id,
+                        locale,
+                        overrideAccess: false,
+                        req
+                    });
+                    beforeByLocale[locale] = redactSensitiveData(doc);
+                    afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
+                }
+                return Response.json({
+                    after: afterByLocale,
+                    before: beforeByLocale
+                });
+            }
+            const normalized = normalizeCollectionData(proposal.data);
+            if (proposal.action === "create") {
+                return Response.json({
+                    after: redactSensitiveData(normalized.data),
+                    before: {}
+                });
+            }
+            const doc = await req.payload.findByID({
+                collection: proposal.collection,
+                depth: 2,
+                id: proposal.id,
+                ...proposal.locale ? {
+                    locale: proposal.locale
+                } : {},
+                overrideAccess: false,
+                req
+            });
+            return Response.json({
+                after: redactSensitiveData(mergeData(doc, normalized.data)),
+                before: redactSensitiveData(doc)
+            });
+        } catch (err) {
+            req.payload.logger.error({
+                err,
+                msg: "AI proposal diff failed"
+            });
+            return Response.json({
+                error: "Could not load proposal diff."
+            }, {
+                status: 400
+            });
+        }
+    };

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import type { CollectionSlug, Config } from "payload";
+import type { Config } from "payload";
 import { type AIModelConfig } from "./ai/providerOptions.js";
-import { type AICollectionPermissionConfig } from "./payload/collectionPermissions.js";
-export type PayloadAiPluginOptions = {
+import { type CollectionPermissionMap } from "./payload/collectionPermissions.js";
+export type PayloadAIPluginOptions = {
     allowUserApiKeys?: boolean;
-    collections?: Partial<Record<CollectionSlug, AICollectionPermissionConfig>>;
+    collections?: CollectionPermissionMap;
     disabled?: boolean;
+    maxOutputTokens?: number;
     models?: AIModelConfig;
 };
-export type PayloadAiPluginConfig = PayloadAiPluginOptions;
-export declare const payloadAiPlugin: (pluginOptions: PayloadAiPluginOptions) => (config: Config) => Config;
+export declare const payloadAiPlugin: (pluginOptions: PayloadAIPluginOptions) => (config: Config) => Config;

package/dist/index.js

@@ -1,14 +1,14 @@
 import { aiProviders, getResolvedAIModelConfig } from "./ai/providerOptions.js";
-import { createAIApplyActionEndpointHandler } from "./endpoints/aiApplyActionEndpointHandler.js";
-import { createAIChatEndpointHandler } from "./endpoints/aiChatEndpointHandler.js";
-import { createAIMentionSuggestionsEndpointHandler } from "./endpoints/aiMentionSuggestionsEndpointHandler.js";
-import { createAIProposalDiffEndpointHandler } from "./endpoints/aiProposalDiffEndpointHandler.js";
-import { createAIRecentChangesEndpointHandler } from "./endpoints/aiRecentChangesEndpointHandler.js";
+import { createApplyActionHandler } from "./handlers/applyActionHandler.js";
+import { createChatHandler } from "./handlers/chatHandler.js";
+import { createMentionSuggestionHandler } from "./handlers/mentionSuggestionHandler.js";
+import { createProposalDiffHandler } from "./handlers/proposalDiffHandler.js";
+import { createAuditLogHandler } from "./handlers/auditLogHandler.js";
 import { resolveCollectionPermissions } from "./payload/collectionPermissions.js";
 import { isInternalCollection } from "./payload/shared.js";
-const aiChangesCollectionSlug = "payload-ai-changes";
+const auditLogCollectionSlug = "payload-ai-auditlog";
 const createAIChangesCollection = ()=>({
-        slug: aiChangesCollectionSlug,
+        slug: auditLogCollectionSlug,
         access: {
             create: ()=>false,
             delete: ()=>false,
@@ -26,6 +26,10 @@ const createAIChangesCollection = ()=>({
             group: "AI",
             useAsTitle: "title"
         },
+        labels: {
+            plural: "AI Changes",
+            singular: "AI Change"
+        },
         fields: [
             {
                 name: "title",
@@ -90,9 +94,33 @@ const createAIChangesCollection = ()=>({
                 name: "proposal",
                 type: "json"
             },
+            {
+                name: "prompt",
+                type: "textarea"
+            },
+            {
+                name: "inputTokens",
+                type: "number"
+            },
+            {
+                name: "outputTokens",
+                type: "number"
+            },
+            {
+                name: "totalTokens",
+                type: "number"
+            },
+            {
+                name: "aiResponse",
+                type: "textarea"
+            },
             {
                 name: "userID",
                 type: "text"
+            },
+            {
+                name: "userLabel",
+                type: "text"
             }
         ],
         timestamps: true
@@ -106,6 +134,7 @@ const addAccountFields = ({ allowUserApiKeys, config })=>{
         name: "aiProvider",
         type: "select",
         defaultValue: "openai",
+        label: "AI Provider",
         options: aiProviders
     });
     if (allowUserApiKeys) {
@@ -117,7 +146,8 @@ const addAccountFields = ({ allowUserApiKeys, config })=>{
                     Field: "payload-ai-plugin/client#AIApiKeyField"
                 },
                 description: "Optional. If empty, the plugin uses the provider API key from environment variables."
-            }
+            },
+            label: "AI API Key"
         });
     }
 };
@@ -126,8 +156,9 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         const collectionPermissions = resolveCollectionPermissions(pluginOptions.collections);
         const allowUserApiKeys = pluginOptions.allowUserApiKeys !== false;
         const modelConfig = getResolvedAIModelConfig(pluginOptions.models);
+        const maxOutputTokens = typeof pluginOptions.maxOutputTokens === "number" && Number.isFinite(pluginOptions.maxOutputTokens) && pluginOptions.maxOutputTokens > 0 ? Math.floor(pluginOptions.maxOutputTokens) : undefined;
         if (!config.collections) config.collections = [];
-        if (!config.collections.some((collection)=>collection.slug === aiChangesCollectionSlug)) {
+        if (!config.collections.some((collection)=>collection.slug === auditLogCollectionSlug)) {
             config.collections.push(createAIChangesCollection());
         }
         addAccountFields({
@@ -151,42 +182,43 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         if (!config.admin.components.beforeDashboard) config.admin.components.beforeDashboard = [];
         config.admin.components.beforeDashboard.push(`payload-ai-plugin/client#AIInput`);
         config.endpoints.push({
-            handler: createAIChatEndpointHandler({
+            handler: createChatHandler({
                 allowUserApiKeys,
                 collections: collectionPermissions,
+                maxOutputTokens,
                 models: modelConfig
             }),
             method: "post",
             path: "/ai-chat"
         });
         config.endpoints.push({
-            handler: createAIApplyActionEndpointHandler({
-                changeLogCollection: aiChangesCollectionSlug,
+            handler: createApplyActionHandler({
+                changeLogCollection: auditLogCollectionSlug,
                 collections: collectionPermissions
             }),
             method: "post",
             path: "/ai-apply-action"
         });
         config.endpoints.push({
-            handler: createAIRecentChangesEndpointHandler({
-                changeLogCollection: aiChangesCollectionSlug
+            handler: createAuditLogHandler({
+                changeLogCollection: auditLogCollectionSlug
             }),
             method: "get",
-            path: "/ai-recent-changes"
+            path: "/ai-audit-log"
         });
         config.endpoints.push({
-            handler: createAIProposalDiffEndpointHandler({
+            handler: createProposalDiffHandler({
                 collections: collectionPermissions
             }),
             method: "post",
             path: "/ai-proposal-diff"
         });
         config.endpoints.push({
-            handler: createAIMentionSuggestionsEndpointHandler({
+            handler: createMentionSuggestionHandler({
                 collections: collectionPermissions
             }),
             method: "post",
-            path: "/ai-mention-suggestions"
+            path: "/ai-mention-suggestion"
         });
         if (incomingOnInit) {
             config.onInit = async (payload)=>{

package/dist/payload/collectionPermissions.d.ts

@@ -1,22 +1,23 @@
 import type { PayloadHandler } from "payload";
-export type AICollectionAction = "create" | "delete" | "read" | "update";
-export type AICollectionPermissions = Partial<Record<AICollectionAction, boolean>>;
-export type AICollectionPermissionConfig = true | AICollectionPermissions;
-export type AICollectionPermissionMap = Partial<Record<string, AICollectionPermissionConfig>>;
-export type ResolvedAICollectionPermissionMap = Partial<Record<string, Record<AICollectionAction, boolean>>>;
-export declare const resolveCollectionPermissions: (collections?: AICollectionPermissionMap) => ResolvedAICollectionPermissionMap | undefined;
+export type CollectionAction = "create" | "delete" | "read" | "update";
+type CollectionPermissions = Partial<Record<CollectionAction, boolean>>;
+type CollectionPermissionConfig = true | CollectionPermissions;
+export type CollectionPermissionMap = Partial<Record<string, CollectionPermissionConfig>>;
+export type ResolvedCollectionPermissionMap = Partial<Record<string, Record<CollectionAction, boolean>>>;
+export declare const resolveCollectionPermissions: (collections?: CollectionPermissionMap) => ResolvedCollectionPermissionMap | undefined;
 export declare const getCollectionSlugsForAction: ({ action, permissions, req, }: {
-    action: AICollectionAction;
-    permissions?: ResolvedAICollectionPermissionMap;
+    action: CollectionAction;
+    permissions?: ResolvedCollectionPermissionMap;
     req: Parameters<PayloadHandler>[0];
 }) => string[];
 export declare const isCollectionActionAllowed: ({ action, permissions, req, slug, }: {
-    action: AICollectionAction;
-    permissions?: ResolvedAICollectionPermissionMap;
+    action: CollectionAction;
+    permissions?: ResolvedCollectionPermissionMap;
     req: Parameters<PayloadHandler>[0];
     slug: string;
 }) => boolean;
-export declare const getCollectionPermissions: ({ permissions, slug, }: {
-    permissions?: ResolvedAICollectionPermissionMap;
+export declare const getCollectionPermissions: ({ permissions, slug }: {
+    permissions?: ResolvedCollectionPermissionMap;
     slug: string;
-}) => Record<AICollectionAction, boolean>;
+}) => Record<CollectionAction, boolean>;
+export {};

package/dist/payload/collectionPermissions.js

@@ -10,7 +10,7 @@ const getKnownCollectionSlugs = (req)=>{
 };
 export const resolveCollectionPermissions = (collections)=>{
     if (!collections) return undefined;
-    return Object.fromEntries(Object.entries(collections).map(([slug, config])=>{
+    const entries = Object.entries(collections).map(([slug, config])=>{
         if (config === true) {
             return [
                 slug,
@@ -42,7 +42,8 @@ export const resolveCollectionPermissions = (collections)=>{
                 update: Boolean(config.update)
             }
         ];
-    }));
+    });
+    return Object.fromEntries(entries);
 };
 export const getCollectionSlugsForAction = ({ action, permissions, req })=>{
     const knownSlugs = getKnownCollectionSlugs(req);

package/dist/payload/normalizeData.d.ts

@@ -2,10 +2,13 @@ export type FieldConfig = {
     blocks?: BlockConfig[];
     defaultValue?: unknown;
     fields?: FieldConfig[];
+    label?: unknown;
+    localized?: boolean;
     name?: string;
     options?: (string | {
         value?: string;
     })[];
+    required?: boolean;
     type?: string;
 };
 type BlockConfig = {
@@ -26,4 +29,9 @@ export declare const isAuthCollection: (collectionConfig?: CollectionConfig | nu
 export declare const getCollectionFields: (collectionConfig?: CollectionConfig | null) => FieldConfig[];
 export declare const normalizeAuthData: (collectionConfig: CollectionConfig | undefined, normalized: NormalizedData) => NormalizedData;
 export declare const normalizeDataForFields: (fields: FieldConfig[], data: Record<string, unknown>) => NormalizedData;
+export declare const getLocalizedRequiredFallbackData: ({ fields, source, target, }: {
+    fields: FieldConfig[];
+    source: Record<string, unknown>;
+    target: Record<string, unknown>;
+}) => Record<string, unknown>;
 export {};

package/dist/payload/normalizeData.js

@@ -1,7 +1,5 @@
+import { isRecord } from "./shared.js";
 const SKIP_FIELD = Symbol("skipField");
-const isRecord = (value)=>{
-    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-};
 const getNamedFields = (fields)=>{
     return fields.filter((field)=>Boolean(field.name));
 };
@@ -190,3 +188,27 @@ export const normalizeDataForFields = (fields, data)=>{
         droppedFields
     };
 };
+export const getLocalizedRequiredFallbackData = ({ fields, source, target })=>{
+    const fallbackData = {};
+    for (const field of getNamedFields(fields)){
+        const targetValue = target[field.name];
+        const sourceValue = source[field.name];
+        if (field.localized && field.required) {
+            if (targetValue === undefined && sourceValue !== undefined) {
+                fallbackData[field.name] = sourceValue;
+            }
+            continue;
+        }
+        if (field.type === "group" && field.fields?.length && isRecord(sourceValue)) {
+            const nestedFallback = getLocalizedRequiredFallbackData({
+                fields: field.fields,
+                source: sourceValue,
+                target: isRecord(targetValue) ? targetValue : {}
+            });
+            if (Object.keys(nestedFallback).length > 0) {
+                fallbackData[field.name] = nestedFallback;
+            }
+        }
+    }
+    return fallbackData;
+};