@mvriu5/payload-ai 1.6.2 → 1.6.4

package/dist/handlers/proposalDiffHandler.js

@@ -1,128 +1,63 @@
-import { verifyActionProposal } from "../ai/proposalSigning.js";
-import { redactSensitiveData } from "../ai/sensitiveData.js";
-import { getSchemaFields } from "../payload/normalizeData.js";
-import { applyLocalizedRequiredFallbackToPreparedData, prepareProposalWriteData } from "../payload/proposalData.js";
-import { isCollectionActionAllowed } from "../payload/collectionPermissions.js";
-import { getDefaultLocale, hasLocalizedData, isActionProposal, mergeData } from "../payload/shared.js";
-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
-        });
+import { redactSensitiveData } from "../features/sensitiveData.js";
+import { validateSignedProposal } from "../features/proposals/validation.js";
+import { prepareLocalizedTargetUpdates, prepareProposalTargetData, resolveProposalTarget } from "../features/proposals/target.js";
+import { applyLocalizedRequiredFallbackToPreparedData } from "../features/proposals/data.js";
+import { isCollectionActionAllowed } from "../features/collectionPermissions.js";
+import { getDefaultLocale, hasLocalizedData, mergeData } from "../utils/data.js";
+import { jsonError, logHandlerError, readJSONBody, withAuthenticatedHandler } from "./http.js";
+export const createProposalDiffHandler = (options = {})=>withAuthenticatedHandler(async (req)=>{
+        const body = await readJSONBody(req);
+        const proposalValidation = validateSignedProposal(body?.proposal);
+        if (!proposalValidation.ok) {
+            if (proposalValidation.error === "missing") return jsonError("Proposal is required");
+            if (proposalValidation.error === "invalid_signature") return jsonError("Proposal signature is invalid or expired.");
+            return jsonError("Proposal is invalid.");
+        }
+        const proposal = proposalValidation.proposal;
         try {
             const inferenceText = body?.prompt;
             const defaultLocale = getDefaultLocale(req);
+            const target = resolveProposalTarget({
+                proposal,
+                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 (!target || target.type !== "global") return jsonError("Unknown global");
                 if (hasLocalizedData(proposal)) {
-                    const beforeByLocale = {};
-                    const afterByLocale = {};
-                    const globalFields = getSchemaFields({
-                        fields: globalConfig.fields || [],
-                        slug: proposal.slug
-                    });
-                    const preparedData = prepareProposalWriteData({
-                        collectionConfig: {
-                            fields: globalConfig.fields || [],
-                            slug: proposal.slug
-                        },
+                    const preparedData = prepareProposalTargetData({
                         inferenceText,
-                        label: proposal.label,
-                        localizedData: proposal.localizedData,
-                        mode: "update"
+                        proposal,
+                        target
                     });
                     if (preparedData.issues.length > 0 || !preparedData.localizedData) {
-                        return Response.json({
-                            error: "Proposal is invalid."
-                        }, {
-                            status: 400
-                        });
+                        return jsonError("Proposal is invalid.");
                     }
-                    const defaultLocaleDoc = defaultLocale ? await req.payload.findGlobal({
-                        depth: 2,
-                        fallbackLocale: false,
-                        locale: defaultLocale,
-                        overrideAccess: false,
-                        req,
-                        slug: proposal.slug
-                    }) : null;
-                    const localizedResults = await Promise.all(Object.entries(preparedData.localizedData).map(async ([locale, localeData])=>{
-                        const doc = await req.payload.findGlobal({
-                            depth: 2,
-                            fallbackLocale: false,
-                            locale,
-                            overrideAccess: false,
-                            req,
-                            slug: proposal.slug
-                        });
-                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
-                            fallbackSource: locale === defaultLocale ? doc : defaultLocaleDoc || doc,
-                            fields: globalFields,
-                            preparedData: localeData
-                        });
-                        return {
-                            completedData,
-                            doc,
-                            locale
-                        };
-                    }));
-                    localizedResults.forEach(({ completedData, doc, locale })=>{
-                        beforeByLocale[locale] = redactSensitiveData(doc);
-                        afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
+                    const localizedResults = await prepareLocalizedTargetUpdates({
+                        defaultLocale: defaultLocale || undefined,
+                        localizedData: preparedData.localizedData,
+                        target
                     });
                     return Response.json({
-                        after: afterByLocale,
-                        before: beforeByLocale
+                        after: Object.fromEntries(localizedResults.map(({ after, locale })=>[
+                                locale,
+                                redactSensitiveData(after)
+                            ])),
+                        before: Object.fromEntries(localizedResults.map(({ before, locale })=>[
+                                locale,
+                                redactSensitiveData(before)
+                            ]))
                     });
                 }
-                const preparedData = prepareProposalWriteData({
-                    collectionConfig: {
-                        fields: globalConfig.fields || [],
-                        slug: proposal.slug
-                    },
-                    data: proposal.data,
+                const preparedData = prepareProposalTargetData({
                     inferenceText,
-                    label: proposal.label,
-                    mode: "update"
+                    proposal,
+                    target
                 });
                 if (preparedData.issues.length > 0 || !preparedData.data) {
-                    return Response.json({
-                        error: "Proposal is invalid."
-                    }, {
-                        status: 400
-                    });
+                    return jsonError("Proposal is invalid.");
                 }
-                const doc = await req.payload.findGlobal({
-                    depth: 2,
-                    ...proposal.locale ? {
-                        locale: proposal.locale
-                    } : {},
-                    overrideAccess: false,
-                    req,
-                    slug: proposal.slug
+                const doc = await target.read({
+                    locale: proposal.locale
                 });
                 return Response.json({
                     after: redactSensitiveData(mergeData(doc, preparedData.data)),
@@ -134,61 +69,34 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                 permissions: options.collections,
                 req,
                 slug: proposal.collection
-            })) return Response.json({
-                error: "Unknown collection"
-            }, {
-                status: 400
-            });
+            })) return jsonError("Unknown collection");
+            if (!target || target.type !== "collection") return jsonError("Unknown collection");
             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
+                const doc = await target.read({
+                    locale: proposal.locale
                 });
                 return Response.json({
                     after: {},
                     before: redactSensitiveData(doc)
                 });
             }
-            const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === proposal.collection);
-            const collectionFields = getSchemaFields(collectionConfig);
             if (hasLocalizedData(proposal)) {
-                const preparedData = prepareProposalWriteData({
-                    collectionConfig,
+                const preparedData = prepareProposalTargetData({
                     inferenceText,
-                    label: proposal.label,
-                    localizedData: proposal.localizedData,
-                    mode: proposal.action
+                    proposal,
+                    target
                 });
                 if (preparedData.issues.length > 0 || !preparedData.localizedData) {
-                    return Response.json({
-                        error: "Proposal is invalid."
-                    }, {
-                        status: 400
-                    });
+                    return jsonError("Proposal is invalid.");
                 }
                 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;
                 if (proposal.action === "create") {
                     for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
                         const completedData = applyLocalizedRequiredFallbackToPreparedData({
                             fallbackSource: createFallbackSource || {},
-                            fields: collectionFields,
+                            fields: target.fields,
                             preparedData: localeData
                         });
                         beforeByLocale[locale] = {};
@@ -196,30 +104,14 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                         createFallbackSource = mergeData(createFallbackSource || {}, completedData);
                     }
                 } else {
-                    const localizedResults = await Promise.all(Object.entries(preparedData.localizedData).map(async ([locale, localeData])=>{
-                        const doc = await req.payload.findByID({
-                            collection: proposal.collection,
-                            depth: 2,
-                            fallbackLocale: false,
-                            id: proposal.id,
-                            locale,
-                            overrideAccess: false,
-                            req
-                        });
-                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
-                            fallbackSource: locale === defaultLocale ? doc : defaultLocaleDoc || {},
-                            fields: collectionFields,
-                            preparedData: localeData
-                        });
-                        return {
-                            completedData,
-                            doc,
-                            locale
-                        };
-                    }));
-                    localizedResults.forEach(({ completedData, doc, locale })=>{
-                        beforeByLocale[locale] = redactSensitiveData(doc);
-                        afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
+                    const localizedResults = await prepareLocalizedTargetUpdates({
+                        defaultLocale: defaultLocale || undefined,
+                        localizedData: preparedData.localizedData,
+                        target
+                    });
+                    localizedResults.forEach(({ after, before, locale })=>{
+                        beforeByLocale[locale] = redactSensitiveData(before);
+                        afterByLocale[locale] = redactSensitiveData(after);
                     });
                 }
                 return Response.json({
@@ -227,19 +119,13 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                     before: beforeByLocale
                 });
             }
-            const preparedData = prepareProposalWriteData({
-                collectionConfig,
-                data: proposal.data,
+            const preparedData = prepareProposalTargetData({
                 inferenceText,
-                label: proposal.label,
-                mode: proposal.action
+                proposal,
+                target
             });
             if (preparedData.issues.length > 0 || !preparedData.data) {
-                return Response.json({
-                    error: "Proposal is invalid."
-                }, {
-                    status: 400
-                });
+                return jsonError("Proposal is invalid.");
             }
             if (proposal.action === "create") {
                 return Response.json({
@@ -247,29 +133,20 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                     before: {}
                 });
             }
-            const doc = await req.payload.findByID({
-                collection: proposal.collection,
-                depth: 2,
-                id: proposal.id,
-                ...proposal.locale ? {
-                    locale: proposal.locale
-                } : {},
-                overrideAccess: false,
-                req
+            const doc = await target.read({
+                locale: proposal.locale
             });
             return Response.json({
                 after: redactSensitiveData(mergeData(doc, preparedData.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."
-            }, {
+            return logHandlerError({
+                error: err,
+                logMessage: "AI proposal diff failed",
+                publicMessage: "Could not load proposal diff.",
+                req,
                 status: 400
             });
         }
-    };
+    });

package/dist/handlers/translateDocumentHandler.d.ts

@@ -1,14 +1,9 @@
 import type { PayloadHandler } from "payload";
-import { type AIModelConfig, type ResolvedAIProviderConfig } from "../ai/providerOptions.js";
-import { type ResolvedMaxTokenUsageOptions } from "../ai/tokenUsage.js";
-import { type TranslationPageContext } from "../payload/documentTranslation.js";
-type TranslateDocumentOptions = {
-    allowUserApiKeys?: boolean;
+import { type AIRequestOptions } from "../features/providers/requestContext.js";
+import { type TranslationPageContext } from "../features/content/documentTranslation.js";
+type TranslateDocumentOptions = AIRequestOptions & {
     maxOutputTokens?: number;
-    maxTokenUsage?: ResolvedMaxTokenUsageOptions;
-    models?: AIModelConfig;
     pageContexts: Map<string, TranslationPageContext>;
-    providers?: ResolvedAIProviderConfig[];
 };
 export declare const createTranslateDocumentHandler: (options: TranslateDocumentOptions) => PayloadHandler;
 export {};

package/dist/handlers/translateDocumentHandler.js

@@ -1,9 +1,8 @@
 import { isDeepStrictEqual } from "node:util";
 import { generateText } from "ai";
-import { isAIProvider } from "../ai/providerOptions.js";
-import { getModel, getProviderConfig } from "../ai/providerRuntime.js";
-import { getExceededTokenUsageLimit, recordTokenUsage } from "../ai/tokenUsage.js";
-import { getTranslationValues } from "../payload/documentTranslation.js";
+import { resolveAIRequestContext } from "../features/providers/requestContext.js";
+import { getTranslationValues } from "../features/content/documentTranslation.js";
+import { jsonError, logHandlerError, readJSONBody, withAuthenticatedHandler } from "./http.js";
 const getDefaultLocale = (req)=>{
     const localization = req.payload.config.localization;
     if (!localization) return null;
@@ -39,22 +38,13 @@ const parseTranslations = (text, sourceCount)=>{
         length: sourceCount
     }, (_, index)=>parsed.translations?.[String(index)]);
 };
-export const createTranslateDocumentHandler = (options)=>async (req)=>{
-        if (!req.user) return Response.json({
-            error: "Unauthorized"
-        }, {
-            status: 401
-        });
-        const body = req.json ? await req.json().catch(()=>null) : null;
+export const createTranslateDocumentHandler = (options)=>withAuthenticatedHandler(async (req)=>{
+        const body = await readJSONBody(req);
         const locale = body?.locale?.trim();
         const scopeSlug = body?.scope?.slug?.trim();
         const scopeType = body?.scope?.type;
         if (!body?.action || !locale || !scopeSlug || !scopeType) {
-            return Response.json({
-                error: "Action, locale, and page scope are required."
-            }, {
-                status: 400
-            });
+            return jsonError("Action, locale, and page scope are required.");
         }
         const pageContext = options.pageContexts.get(`${scopeType}:${scopeSlug}`);
         const defaultLocale = getDefaultLocale(req);
@@ -93,55 +83,18 @@ export const createTranslateDocumentHandler = (options)=>async (req)=>{
             if (body.action === "status" || !available) return Response.json({
                 available
             });
-            const user = req.user;
-            const exceededLimit = await getExceededTokenUsageLimit({
-                maxTokenUsage: options.maxTokenUsage,
+            const aiRequestResolution = await resolveAIRequestContext({
+                options,
                 req,
-                userID: user.id
-            });
-            if (exceededLimit) return Response.json({
-                error: "AI token usage limit reached."
-            }, {
-                status: 429
+                requestedModel: body.model,
+                requestedProvider: body.provider,
+                user: req.user
             });
-            const managedProviders = options.providers?.length ? options.providers : null;
-            const requestedProvider = body.provider || (managedProviders ? managedProviders[0].id : user.aiProvider || "openai");
-            const managedProvider = managedProviders?.find((provider)=>provider.id === requestedProvider);
-            if (managedProviders && !managedProvider) {
-                return Response.json({
-                    error: `Unsupported AI provider: ${requestedProvider}`
-                }, {
-                    status: 400
-                });
+            if (!aiRequestResolution.ok) {
+                return jsonError(aiRequestResolution.error.message, aiRequestResolution.error.code === "token_limit" ? 429 : 400);
             }
-            if (!managedProvider && !isAIProvider(requestedProvider)) {
-                return Response.json({
-                    error: `Unsupported AI provider: ${requestedProvider}`
-                }, {
-                    status: 400
-                });
-            }
-            const provider = managedProvider?.provider || requestedProvider;
-            const requestedModel = body.model || managedProvider?.defaultModel;
-            const providerConfig = getProviderConfig({
-                apiKey: managedProvider ? managedProvider.apiKey : options.allowUserApiKeys === false ? null : user.aiApiKey,
-                defaultModels: options.models?.defaults,
-                model: requestedModel,
-                provider
-            });
-            if (!providerConfig.apiKey) return Response.json({
-                error: "Configure an AI provider API key first."
-            }, {
-                status: 400
-            });
-            const model = await getModel({
-                apiKey: providerConfig.apiKey,
-                ...managedProvider?.baseURL ? {
-                    baseURL: managedProvider.baseURL
-                } : {},
-                model: providerConfig.modelID,
-                provider
-            });
+            const aiRequest = aiRequestResolution.context;
+            const model = await aiRequest.loadModel();
             const result = await generateText({
                 maxOutputTokens: options.maxOutputTokens || 700,
                 model,
@@ -162,15 +115,7 @@ export const createTranslateDocumentHandler = (options)=>async (req)=>{
             });
             const translatedValues = parseTranslations(result.text, translationSourceValues.length);
             if (translatedValues.some((value)=>value === undefined)) throw new Error("Translation response is incomplete.");
-            if (result.usage && options.maxTokenUsage) {
-                await recordTokenUsage({
-                    model: providerConfig.modelID,
-                    provider: managedProvider?.id || provider,
-                    req,
-                    usage: result.usage,
-                    userID: user.id
-                });
-            }
+            if (result.usage) await aiRequest.recordUsage(result.usage);
             return Response.json({
                 available: true,
                 values: translationSourceValues.map((entry, index)=>({
@@ -180,16 +125,15 @@ export const createTranslateDocumentHandler = (options)=>async (req)=>{
                     }))
             });
         } catch (error) {
-            req.payload.logger.error({
-                err: error,
-                msg: "AI document translation failed",
-                scopeSlug,
-                scopeType
-            });
-            return Response.json({
-                error: "AI document translation failed."
-            }, {
-                status: 500
+            return logHandlerError({
+                details: {
+                    scopeSlug,
+                    scopeType
+                },
+                error,
+                logMessage: "AI document translation failed",
+                publicMessage: "AI document translation failed.",
+                req
             });
         }
-    };
+    });

package/dist/index.d.ts

@@ -1,32 +1,6 @@
 import type { Config } from "payload";
-import { type AIModelConfig, type AIProviderConfig } from "./ai/providerOptions.js";
-import { type MaxTokenUsageOptions } from "./ai/tokenUsage.js";
-import { type CollectionPermissionMap } from "./payload/collectionPermissions.js";
-export type { AIModelConfig, AIProviderConfig, AIProviderModelOption } from "./ai/providerOptions.js";
-export type { MaxTokenUsageOptions } from "./ai/tokenUsage.js";
-export type CollectionTypeAIOptions = {
-    aiInput?: boolean;
-    generateFields?: boolean;
-};
-export type PayloadAIPluginOptions = {
-    aiInput?: boolean;
-    allowUserApiKeys?: boolean;
-    authCollections?: CollectionTypeAIOptions;
-    collections?: CollectionPermissionMap;
-    disabled?: boolean;
-    generateFields?: boolean;
-    maxOutputTokens?: number;
-    media?: {
-        acceptedMimeTypes?: string[];
-        collectionSlug?: string;
-        enabled?: boolean;
-        maxFileSize?: number;
-    };
-    models?: AIModelConfig;
-    maxTokenUsage?: MaxTokenUsageOptions;
-    promptCaching?: boolean;
-    providers?: AIProviderConfig[];
-    translate?: boolean;
-    uploadCollections?: CollectionTypeAIOptions;
-};
+import type { PayloadAIPluginOptions } from "./plugin/types.js";
+export type { AIModelConfig, AIProviderConfig, AIProviderModelOption } from "./features/providers/options.js";
+export type { MaxTokenUsageOptions } from "./features/tokenUsage.js";
+export type { CollectionTypeAIOptions, PayloadAIPluginOptions } from "./plugin/types.js";
 export declare const payloadAiPlugin: (pluginOptions: PayloadAIPluginOptions) => (config: Config) => Config;