@mvriu5/payload-ai 0.5.8 → 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.js

@@ -2,8 +2,101 @@ 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 { 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;
@@ -34,6 +127,9 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         const allowUserApiKeys = pluginOptions.allowUserApiKeys !== false;
         const modelConfig = getResolvedAIModelConfig(pluginOptions.models);
         if (!config.collections) config.collections = [];
+        if (!config.collections.some((collection)=>collection.slug === aiChangesCollectionSlug)) {
+            config.collections.push(createAIChangesCollection());
+        }
         addAccountFields({
             allowUserApiKeys,
             config
@@ -65,11 +161,26 @@ export const payloadAiPlugin = (pluginOptions)=>(config)=>{
         });
         config.endpoints.push({
             handler: createAIApplyActionEndpointHandler({
+                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: collectionPermissions

package/dist/payload/schemaContext.d.ts

@@ -9,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;
@@ -26,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[];
@@ -45,7 +88,7 @@ export declare const collectBlocks: ({ fields, parent, }: {
     slug: string;
 })[];
 export declare const getAllowedCollectionSlugs: (req: Parameters<PayloadHandler>[0], collections?: ResolvedAICollectionPermissionMap) => string[];
-export declare const getMentionContext: ({ blockContexts, collectionSlugs, globalSlugs, mentions, req, }: MentionContext) => Promise<Record<string, unknown>[]>;
+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;

package/dist/payload/schemaContext.js

@@ -1,4 +1,5 @@
-import { getCollectionSlugsForAction } from "./collectionPermissions.js";
+import { getCollectionPermissions, getCollectionSlugsForAction } from "./collectionPermissions.js";
+import { getCollectionFields, isAuthCollection } from "./normalizeData.js";
 import { getSerializableLabel, isInternalCollection } from "./shared.js";
 const getSerializableRelationTo = (relationTo)=>{
     if (typeof relationTo === "string") {
@@ -9,9 +10,88 @@ const getSerializableRelationTo = (relationTo)=>{
     }
     return undefined;
 };
+const getSerializableOptions = (options)=>{
+    if (!Array.isArray(options)) return undefined;
+    const serializedOptions = options.map((option)=>{
+        if (typeof option === "string") {
+            return {
+                label: option,
+                value: option
+            };
+        }
+        if (!option || typeof option !== "object") return null;
+        const label = "label" in option ? getSerializableLabel(option.label) : undefined;
+        const value = "value" in option && typeof option.value === "string" ? option.value : undefined;
+        if (!label && !value) return null;
+        return {
+            ...label ? {
+                label
+            } : {},
+            ...value ? {
+                value
+            } : {}
+        };
+    }).filter(Boolean);
+    return serializedOptions.length > 0 ? serializedOptions : undefined;
+};
+const hasDrafts = (config)=>{
+    const versions = config?.versions;
+    if (!versions || versions === true) return false;
+    if (typeof versions !== "object") return false;
+    return Boolean(versions.drafts);
+};
+const toNormalizeCollectionConfig = (config)=>{
+    if (!config) return undefined;
+    return {
+        auth: config.auth,
+        fields: config.fields || [],
+        slug: config.slug
+    };
+};
+const getSchemaFields = (config)=>{
+    const normalizedConfig = toNormalizeCollectionConfig(config);
+    const fields = isAuthCollection(normalizedConfig) ? getCollectionFields(normalizedConfig) : [
+        ...config?.fields || []
+    ];
+    if (hasDrafts(config)) {
+        fields.push({
+            label: "Status",
+            name: "_status",
+            options: [
+                "draft",
+                "published"
+            ],
+            required: true,
+            type: "select"
+        });
+    }
+    return fields;
+};
+export const describeCollectionLikeConfig = ({ config, permissions, type })=>{
+    const slug = config.slug;
+    return {
+        access: {
+            aiPermissions: type === "collection" ? getCollectionPermissions({
+                permissions,
+                slug
+            }) : {
+                read: true,
+                update: true
+            },
+            hasPayloadAccessControl: Boolean(config.access)
+        },
+        fields: getSchemaFields(config).map(describeField),
+        hasAuth: isAuthCollection(toNormalizeCollectionConfig(config)) || undefined,
+        hasDrafts: hasDrafts(config) || undefined,
+        label: type === "collection" ? config.labels?.plural || config.labels?.singular || slug : getSerializableLabel(config.label) || slug,
+        slug,
+        type
+    };
+};
 export const describeField = (field)=>{
     const label = getSerializableLabel(field.label);
     const relationTo = getSerializableRelationTo(field.relationTo);
+    const options = getSerializableOptions(field.options);
     return {
         ...label ? {
             label
@@ -28,9 +108,18 @@ export const describeField = (field)=>{
         ...field.hasMany ? {
             hasMany: field.hasMany
         } : {},
+        ...field.localized ? {
+            localized: field.localized
+        } : {},
         ...relationTo ? {
             relationTo
         } : {},
+        ...options ? {
+            options
+        } : {},
+        ...field.admin?.condition ? {
+            hasCondition: true
+        } : {},
         ...field.fields ? {
             fields: field.fields.map(describeField)
         } : {},
@@ -78,7 +167,7 @@ export const getAllowedCollectionSlugs = (req, collections)=>{
         req
     });
 };
-export const getMentionContext = async ({ blockContexts, collectionSlugs, globalSlugs, mentions, req })=>{
+export const getMentionContext = async ({ blockContexts, collectionSlugs, collections, globalSlugs, mentions, req })=>{
     if (!mentions || mentions.length === 0) return [];
     const context = [];
     const seen = new Set();
@@ -90,12 +179,11 @@ export const getMentionContext = async ({ blockContexts, collectionSlugs, global
             const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === slug);
             if (!collectionConfig) continue;
             seen.add(key);
-            context.push({
-                fields: collectionConfig.fields.map(describeField),
-                label: collectionConfig.labels?.plural || collectionConfig.labels?.singular || slug,
-                slug,
+            context.push(describeCollectionLikeConfig({
+                config: collectionConfig,
+                permissions: collections,
                 type: "collection"
-            });
+            }));
         }
         if (mention.type === "global" && mention.slug) {
             const slug = mention.slug;
@@ -111,11 +199,11 @@ export const getMentionContext = async ({ blockContexts, collectionSlugs, global
             }).catch(()=>null);
             seen.add(key);
             context.push({
-                doc: globalDoc,
-                fields: globalConfig.fields.map(describeField),
-                label: globalConfig.label || slug,
-                slug,
-                type: "global"
+                ...describeCollectionLikeConfig({
+                    config: globalConfig,
+                    type: "global"
+                }),
+                doc: globalDoc
             });
         }
         if (mention.type === "block" && mention.slug) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mvriu5/payload-ai",
-    "version": "0.5.8",
+    "version": "0.5.9",
     "description": "AI assistant plugin for Payload CMS with provider selection, CMS mentions, and signed action proposals.",
     "keywords": [
         "payload",