@mvriu5/payload-ai 0.5.6 → 0.5.9

package/dist/endpoints/aiProposalDiffEndpointHandler.js

@@ -0,0 +1,138 @@
+import { verifyAIActionProposal } from "../ai/proposals.js";
+import { redactSensitiveData } from "../ai/sensitiveData.js";
+import { getCollectionFields, normalizeAuthData, normalizeDataForFields } from "../payload/normalizeData.js";
+import { isCollectionActionAllowed } from "../payload/collectionPermissions.js";
+const isRecord = (value)=>{
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+};
+const isActionProposal = (proposal)=>{
+    if (!isRecord(proposal) || typeof proposal.label !== "string") return false;
+    if (proposal.action === "create") {
+        return typeof proposal.collection === "string" && isRecord(proposal.data);
+    }
+    if (proposal.action === "update") {
+        return typeof proposal.collection === "string" && typeof proposal.id === "string" && isRecord(proposal.data);
+    }
+    if (proposal.action === "delete") {
+        return typeof proposal.collection === "string" && typeof proposal.id === "string";
+    }
+    if (proposal.action === "updateGlobal") {
+        return typeof proposal.slug === "string" && isRecord(proposal.data);
+    }
+    return false;
+};
+const mergeData = (current, next)=>{
+    return Object.fromEntries(Object.entries({
+        ...current,
+        ...next
+    }).map(([key, value])=>{
+        const currentValue = current[key];
+        if (isRecord(currentValue) && isRecord(value)) {
+            return [
+                key,
+                mergeData(currentValue, value)
+            ];
+        }
+        return [
+            key,
+            value
+        ];
+    }));
+};
+export const createAIProposalDiffEndpointHandler = (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 (!verifyAIActionProposal(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 {
+            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
+                });
+                const normalized = normalizeDataForFields(globalConfig.fields || [], proposal.data);
+                const doc = await req.payload.findGlobal({
+                    depth: 2,
+                    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,
+                    overrideAccess: false,
+                    req
+                });
+                return Response.json({
+                    after: {},
+                    before: redactSensitiveData(doc)
+                });
+            }
+            const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === proposal.collection);
+            const normalized = normalizeAuthData(collectionConfig, normalizeDataForFields(getCollectionFields(collectionConfig), 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,
+                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/endpoints/aiRecentChangesEndpointHandler.d.ts

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

package/dist/endpoints/aiRecentChangesEndpointHandler.js

@@ -0,0 +1,35 @@
+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)=>{
+        if (!req.user) return Response.json({
+            error: "Unauthorized"
+        }, {
+            status: 401
+        });
+        const result = await req.payload.find({
+            collection: options.changeLogCollection,
+            depth: 0,
+            limit: 12,
+            overrideAccess: false,
+            req,
+            sort: "-createdAt"
+        });
+        return Response.json({
+            changes: result.docs.map((doc)=>({
+                    action: getString(doc.action),
+                    additions: getNumber(doc.additions),
+                    after: doc.after,
+                    before: doc.before,
+                    collection: getString(doc.collection),
+                    documentID: getString(doc.documentID),
+                    removals: getNumber(doc.removals),
+                    slug: getString(doc.slug),
+                    title: getString(doc.title) || "AI change",
+                    url: getString(doc.targetURL)
+                }))
+        });
+    };

package/dist/index.d.ts

@@ -1,7 +1,9 @@
 import type { CollectionSlug, Config } from "payload";
 import { type AIModelConfig } from "./ai/providerOptions.js";
+import { type AICollectionPermissionConfig } from "./payload/collectionPermissions.js";
 export type PayloadAiPluginOptions = {
-    collections?: Partial<Record<CollectionSlug, true>>;
+    allowUserApiKeys?: boolean;
+    collections?: Partial<Record<CollectionSlug, AICollectionPermissionConfig>>;
     disabled?: boolean;
     models?: AIModelConfig;
 };

package/dist/index.js

@@ -2,11 +2,102 @@ 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";
-const getEnabledCollections = (collections)=>{
-    if (!collections) return undefined;
-    return Object.entries(collections).filter(([, enabled])=>enabled).map(([slug])=>slug);
-};
-const addAccountFields = (config)=>{
+import { createAIProposalDiffEndpointHandler } from "./endpoints/aiProposalDiffEndpointHandler.js";
+import { createAIRecentChangesEndpointHandler } from "./endpoints/aiRecentChangesEndpointHandler.js";
+import { resolveCollectionPermissions } from "./payload/collectionPermissions.js";
+import { isInternalCollection } from "./payload/shared.js";
+const aiChangesCollectionSlug = "payload-ai-changes";
+const createAIChangesCollection = ()=>({
+        slug: aiChangesCollectionSlug,
+        access: {
+            create: ()=>false,
+            delete: ()=>false,
+            read: ({ req })=>Boolean(req.user),
+            update: ()=>false
+        },
+        admin: {
+            defaultColumns: [
+                "title",
+                "action",
+                "additions",
+                "removals",
+                "createdAt"
+            ],
+            group: "AI",
+            useAsTitle: "title"
+        },
+        fields: [
+            {
+                name: "title",
+                type: "text",
+                required: true
+            },
+            {
+                name: "action",
+                type: "select",
+                options: [
+                    "create",
+                    "update",
+                    "delete",
+                    "updateGlobal"
+                ],
+                required: true
+            },
+            {
+                name: "targetType",
+                type: "select",
+                options: [
+                    "collection",
+                    "global"
+                ],
+                required: true
+            },
+            {
+                name: "collection",
+                type: "text"
+            },
+            {
+                name: "slug",
+                type: "text"
+            },
+            {
+                name: "documentID",
+                type: "text"
+            },
+            {
+                name: "targetURL",
+                type: "text"
+            },
+            {
+                name: "additions",
+                type: "number",
+                defaultValue: 0
+            },
+            {
+                name: "removals",
+                type: "number",
+                defaultValue: 0
+            },
+            {
+                name: "before",
+                type: "json"
+            },
+            {
+                name: "after",
+                type: "json"
+            },
+            {
+                name: "proposal",
+                type: "json"
+            },
+            {
+                name: "userID",
+                type: "text"
+            }
+        ],
+        timestamps: true
+    });
+const addAccountFields = ({ allowUserApiKeys, config })=>{
     const adminUserSlug = config.admin?.user;
     if (!adminUserSlug || !config.collections) return;
     const userCollection = config.collections.find((c)=>c.slug === adminUserSlug);
@@ -16,29 +107,43 @@ const addAccountFields = (config)=>{
         type: "select",
         defaultValue: "openai",
         options: aiProviders
-    }, {
-        name: "aiApiKey",
-        type: "text",
-        admin: {
-            components: {
-                Field: "payload-ai-plugin/client#AIApiKeyField"
-            }
-        }
     });
+    if (allowUserApiKeys) {
+        userCollection.fields.push({
+            name: "aiApiKey",
+            type: "text",
+            admin: {
+                components: {
+                    Field: "payload-ai-plugin/client#AIApiKeyField"
+                },
+                description: "Optional. If empty, the plugin uses the provider API key from environment variables."
+            }
+        });
+    }
 };
 export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         const incomingOnInit = config.onInit;
-        const enabledCollections = getEnabledCollections(pluginOptions.collections);
+        const collectionPermissions = resolveCollectionPermissions(pluginOptions.collections);
+        const allowUserApiKeys = pluginOptions.allowUserApiKeys !== false;
         const modelConfig = getResolvedAIModelConfig(pluginOptions.models);
         if (!config.collections) config.collections = [];
-        addAccountFields(config);
+        if (!config.collections.some((collection)=>collection.slug === aiChangesCollectionSlug)) {
+            config.collections.push(createAIChangesCollection());
+        }
+        addAccountFields({
+            allowUserApiKeys,
+            config
+        });
         if (pluginOptions.disabled) return config;
+        const mentionCollectionSlugs = config.collections.filter((collection)=>!isInternalCollection(collection.slug)).filter((collection)=>collectionPermissions ? Boolean(collectionPermissions[collection.slug]?.read) : true).map((collection)=>collection.slug);
         if (!config.endpoints) config.endpoints = [];
         if (!config.admin) config.admin = {};
         config.admin.custom = {
             ...config.admin.custom || {},
             payloadAiPlugin: {
                 ...config.admin.custom?.payloadAiPlugin || {},
+                collectionSlugs: mentionCollectionSlugs,
+                allowUserApiKeys,
                 models: modelConfig
             }
         };
@@ -47,21 +152,38 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         config.admin.components.beforeDashboard.push(`payload-ai-plugin/client#AIInput`);
         config.endpoints.push({
             handler: createAIChatEndpointHandler({
-                collections: enabledCollections
+                allowUserApiKeys,
+                collections: collectionPermissions,
+                models: modelConfig
             }),
             method: "post",
             path: "/ai-chat"
         });
         config.endpoints.push({
             handler: createAIApplyActionEndpointHandler({
-                collections: enabledCollections
+                changeLogCollection: aiChangesCollectionSlug,
+                collections: collectionPermissions
             }),
             method: "post",
             path: "/ai-apply-action"
         });
+        config.endpoints.push({
+            handler: createAIRecentChangesEndpointHandler({
+                changeLogCollection: aiChangesCollectionSlug
+            }),
+            method: "get",
+            path: "/ai-recent-changes"
+        });
+        config.endpoints.push({
+            handler: createAIProposalDiffEndpointHandler({
+                collections: collectionPermissions
+            }),
+            method: "post",
+            path: "/ai-proposal-diff"
+        });
         config.endpoints.push({
             handler: createAIMentionSuggestionsEndpointHandler({
-                collections: enabledCollections
+                collections: collectionPermissions
             }),
             method: "post",
             path: "/ai-mention-suggestions"

package/dist/payload/collectionPermissions.d.ts

@@ -0,0 +1,22 @@
+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 declare const getCollectionSlugsForAction: ({ action, permissions, req, }: {
+    action: AICollectionAction;
+    permissions?: ResolvedAICollectionPermissionMap;
+    req: Parameters<PayloadHandler>[0];
+}) => string[];
+export declare const isCollectionActionAllowed: ({ action, permissions, req, slug, }: {
+    action: AICollectionAction;
+    permissions?: ResolvedAICollectionPermissionMap;
+    req: Parameters<PayloadHandler>[0];
+    slug: string;
+}) => boolean;
+export declare const getCollectionPermissions: ({ permissions, slug, }: {
+    permissions?: ResolvedAICollectionPermissionMap;
+    slug: string;
+}) => Record<AICollectionAction, boolean>;

package/dist/payload/collectionPermissions.js

@@ -0,0 +1,68 @@
+import { isInternalCollection } from "./shared.js";
+const allActions = [
+    "create",
+    "delete",
+    "read",
+    "update"
+];
+const getKnownCollectionSlugs = (req)=>{
+    return req.payload.config.collections.map((collection)=>collection.slug).filter((slug)=>!isInternalCollection(slug));
+};
+export const resolveCollectionPermissions = (collections)=>{
+    if (!collections) return undefined;
+    return Object.fromEntries(Object.entries(collections).map(([slug, config])=>{
+        if (config === true) {
+            return [
+                slug,
+                {
+                    create: true,
+                    delete: true,
+                    read: true,
+                    update: true
+                }
+            ];
+        }
+        if (!config) {
+            return [
+                slug,
+                {
+                    create: false,
+                    delete: false,
+                    read: false,
+                    update: false
+                }
+            ];
+        }
+        return [
+            slug,
+            {
+                create: Boolean(config.create),
+                delete: Boolean(config.delete),
+                read: Boolean(config.read),
+                update: Boolean(config.update)
+            }
+        ];
+    }));
+};
+export const getCollectionSlugsForAction = ({ action, permissions, req })=>{
+    const knownSlugs = getKnownCollectionSlugs(req);
+    if (!permissions) return knownSlugs;
+    return knownSlugs.filter((slug)=>Boolean(permissions[slug]?.[action]));
+};
+export const isCollectionActionAllowed = ({ action, permissions, req, slug })=>{
+    if (!getKnownCollectionSlugs(req).includes(slug)) return false;
+    if (!permissions) return true;
+    return Boolean(permissions[slug]?.[action]);
+};
+export const getCollectionPermissions = ({ permissions, slug })=>{
+    if (!permissions) {
+        return Object.fromEntries(allActions.map((action)=>[
+                action,
+                true
+            ]));
+    }
+    return permissions[slug] || Object.fromEntries(allActions.map((action)=>[
+            action,
+            false
+        ]));
+};

package/dist/payload/schemaContext.d.ts

@@ -1,4 +1,5 @@
 import type { PayloadHandler } from "payload";
+import { type ResolvedAICollectionPermissionMap } from "./collectionPermissions.js";
 export type AIChatMention = {
     collection?: string;
     id?: string;
@@ -8,11 +9,19 @@ export type AIChatMention = {
     type?: "block" | "collection" | "doc" | "global";
 };
 export type FieldConfig = {
+    admin?: {
+        condition?: unknown;
+    };
     blocks?: BlockConfig[];
     fields?: FieldConfig[];
     hasMany?: boolean;
     label?: unknown;
+    localized?: boolean;
     name?: string;
+    options?: (string | {
+        label?: unknown;
+        value?: string;
+    })[];
     relationTo?: unknown;
     required?: boolean;
     type?: string;
@@ -25,16 +34,51 @@ type BlockConfig = {
     };
     slug: string;
 };
+type VersionConfig = boolean | {
+    drafts?: boolean | Record<string, unknown>;
+};
+type CollectionLikeConfig = {
+    access?: Record<string, unknown>;
+    auth?: unknown;
+    fields?: FieldConfig[];
+    label?: unknown;
+    labels?: {
+        plural?: unknown;
+        singular?: unknown;
+    };
+    slug: string;
+    versions?: VersionConfig;
+};
 type MentionContext = {
     blockContexts: (Record<string, unknown> & {
         parent: string;
         slug: string;
     })[];
     collectionSlugs: string[];
+    collections?: ResolvedAICollectionPermissionMap;
     globalSlugs: string[];
     mentions?: AIChatMention[];
     req: Parameters<PayloadHandler>[0];
 };
+export declare const describeCollectionLikeConfig: ({ config, permissions, type, }: {
+    config: CollectionLikeConfig;
+    permissions?: ResolvedAICollectionPermissionMap;
+    type: "collection" | "global";
+}) => {
+    access: {
+        aiPermissions: Record<import("./collectionPermissions.js").AICollectionAction, boolean> | {
+            read: boolean;
+            update: boolean;
+        };
+        hasPayloadAccessControl: boolean;
+    };
+    fields: Record<string, unknown>[];
+    hasAuth: true | undefined;
+    hasDrafts: true | undefined;
+    label: {};
+    slug: string;
+    type: "collection" | "global";
+};
 export declare const describeField: (field: FieldConfig) => Record<string, unknown>;
 export declare const collectBlocks: ({ fields, parent, }: {
     fields: FieldConfig[];
@@ -43,8 +87,8 @@ export declare const collectBlocks: ({ fields, parent, }: {
     parent: string;
     slug: string;
 })[];
-export declare const getAllowedCollectionSlugs: (req: Parameters<PayloadHandler>[0], collections?: string[]) => string[];
-export declare const getMentionContext: ({ blockContexts, collectionSlugs, globalSlugs, mentions, req, }: MentionContext) => Promise<Record<string, unknown>[]>;
+export declare const getAllowedCollectionSlugs: (req: Parameters<PayloadHandler>[0], collections?: ResolvedAICollectionPermissionMap) => string[];
+export declare const getMentionContext: ({ blockContexts, collectionSlugs, collections, globalSlugs, mentions, req, }: MentionContext) => Promise<Record<string, unknown>[]>;
 export declare const buildPromptWithMentionContext: ({ mentionContext, prompt, }: {
     mentionContext: Record<string, unknown>[];
     prompt: string;