@mvriu5/payload-ai 1.1.1 → 1.2.0

package/dist/handlers/proposalDiffHandler.js

@@ -1,15 +1,9 @@
 import { verifyActionProposal } from "../ai/proposalSigning.js";
 import { redactSensitiveData } from "../ai/sensitiveData.js";
-import { getCollectionFields, getLocalizedRequiredFallbackData, normalizeAuthData, normalizeDataForFields } from "../payload/normalizeData.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";
-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"
@@ -34,6 +28,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
             status: 400
         });
         try {
+            const inferenceText = body?.prompt;
             const defaultLocale = getDefaultLocale(req);
             if (proposal.action === "updateGlobal") {
                 const globalConfig = req.payload.config.globals?.find((global)=>global.slug === proposal.slug);
@@ -45,7 +40,27 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                 if (hasLocalizedData(proposal)) {
                     const beforeByLocale = {};
                     const afterByLocale = {};
-                    const globalFields = globalConfig.fields || [];
+                    const globalFields = getSchemaFields({
+                        fields: globalConfig.fields || [],
+                        slug: proposal.slug
+                    });
+                    const preparedData = prepareProposalWriteData({
+                        collectionConfig: {
+                            fields: globalConfig.fields || [],
+                            slug: proposal.slug
+                        },
+                        inferenceText,
+                        label: proposal.label,
+                        localizedData: proposal.localizedData,
+                        mode: "update"
+                    });
+                    if (preparedData.issues.length > 0 || !preparedData.localizedData) {
+                        return Response.json({
+                            error: "Proposal is invalid."
+                        }, {
+                            status: 400
+                        });
+                    }
                     const defaultLocaleDoc = defaultLocale ? await req.payload.findGlobal({
                         depth: 2,
                         fallbackLocale: false,
@@ -54,8 +69,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                         req,
                         slug: proposal.slug
                     }) : null;
-                    for (const [locale, localeData] of Object.entries(proposal.localizedData)){
-                        const normalized = normalizeDataForFields(globalFields, localeData);
+                    for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
                         const doc = await req.payload.findGlobal({
                             depth: 2,
                             fallbackLocale: false,
@@ -64,10 +78,10 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                             req,
                             slug: proposal.slug
                         });
-                        const completedData = applyLocalizedRequiredFallback({
-                            data: normalized.data,
+                        const completedData = applyLocalizedRequiredFallbackToPreparedData({
                             fallbackSource: locale === defaultLocale ? doc : defaultLocaleDoc || doc,
-                            fields: globalFields
+                            fields: globalFields,
+                            preparedData: localeData
                         });
                         beforeByLocale[locale] = redactSensitiveData(doc);
                         afterByLocale[locale] = redactSensitiveData(mergeData(doc, completedData));
@@ -77,7 +91,23 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                         before: beforeByLocale
                     });
                 }
-                const normalized = normalizeDataForFields(globalConfig.fields || [], proposal.data);
+                const preparedData = prepareProposalWriteData({
+                    collectionConfig: {
+                        fields: globalConfig.fields || [],
+                        slug: proposal.slug
+                    },
+                    data: proposal.data,
+                    inferenceText,
+                    label: proposal.label,
+                    mode: "update"
+                });
+                if (preparedData.issues.length > 0 || !preparedData.data) {
+                    return Response.json({
+                        error: "Proposal is invalid."
+                    }, {
+                        status: 400
+                    });
+                }
                 const doc = await req.payload.findGlobal({
                     depth: 2,
                     ...proposal.locale ? {
@@ -88,7 +118,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                     slug: proposal.slug
                 });
                 return Response.json({
-                    after: redactSensitiveData(mergeData(doc, normalized.data)),
+                    after: redactSensitiveData(mergeData(doc, preparedData.data)),
                     before: redactSensitiveData(doc)
                 });
             }
@@ -119,9 +149,22 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                 });
             }
             const collectionConfig = req.payload.config.collections.find((collection)=>collection.slug === proposal.collection);
-            const collectionFields = getCollectionFields(collectionConfig);
-            const normalizeCollectionData = (data)=>normalizeAuthData(collectionConfig, normalizeDataForFields(collectionFields, data));
+            const collectionFields = getSchemaFields(collectionConfig);
             if (hasLocalizedData(proposal)) {
+                const preparedData = prepareProposalWriteData({
+                    collectionConfig,
+                    inferenceText,
+                    label: proposal.label,
+                    localizedData: proposal.localizedData,
+                    mode: proposal.action
+                });
+                if (preparedData.issues.length > 0 || !preparedData.localizedData) {
+                    return Response.json({
+                        error: "Proposal is invalid."
+                    }, {
+                        status: 400
+                    });
+                }
                 const afterByLocale = {};
                 const beforeByLocale = {};
                 const defaultLocaleDoc = proposal.action === "update" && defaultLocale ? await req.payload.findByID({
@@ -134,8 +177,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                     req
                 }) : null;
                 let createFallbackSource = null;
-                for (const [locale, localeData] of Object.entries(proposal.localizedData)){
-                    const normalized = normalizeCollectionData(localeData);
+                for (const [locale, localeData] of Object.entries(preparedData.localizedData)){
                     const fallbackSource = proposal.action === "create" ? createFallbackSource || {} : locale === defaultLocale ? await req.payload.findByID({
                         collection: proposal.collection,
                         depth: 2,
@@ -145,10 +187,10 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                         overrideAccess: false,
                         req
                     }) : defaultLocaleDoc || {};
-                    const completedData = applyLocalizedRequiredFallback({
-                        data: normalized.data,
+                    const completedData = applyLocalizedRequiredFallbackToPreparedData({
                         fallbackSource,
-                        fields: collectionFields
+                        fields: collectionFields,
+                        preparedData: localeData
                     });
                     if (proposal.action === "create") {
                         beforeByLocale[locale] = {};
@@ -173,10 +215,23 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                     before: beforeByLocale
                 });
             }
-            const normalized = normalizeCollectionData(proposal.data);
+            const preparedData = prepareProposalWriteData({
+                collectionConfig,
+                data: proposal.data,
+                inferenceText,
+                label: proposal.label,
+                mode: proposal.action
+            });
+            if (preparedData.issues.length > 0 || !preparedData.data) {
+                return Response.json({
+                    error: "Proposal is invalid."
+                }, {
+                    status: 400
+                });
+            }
             if (proposal.action === "create") {
                 return Response.json({
-                    after: redactSensitiveData(normalized.data),
+                    after: redactSensitiveData(preparedData.data),
                     before: {}
                 });
             }
@@ -191,7 +246,7 @@ export const createProposalDiffHandler = (options = {})=>async (req)=>{
                 req
             });
             return Response.json({
-                after: redactSensitiveData(mergeData(doc, normalized.data)),
+                after: redactSensitiveData(mergeData(doc, preparedData.data)),
                 before: redactSensitiveData(doc)
             });
         } catch (err) {

package/dist/payload/logging.d.ts

@@ -0,0 +1,9 @@
+import type { PayloadHandler } from "payload";
+type LogLevel = "error" | "info" | "warn";
+type LogEntry = {
+    [key: string]: unknown;
+    msg: string;
+};
+export declare const getLogPreview: (value?: string | null) => string | null;
+export declare const logHandlerEvent: (req: Parameters<PayloadHandler>[0], level: LogLevel, entry: LogEntry) => void;
+export {};

package/dist/payload/logging.js

@@ -0,0 +1,14 @@
+const maxPreviewLength = 180;
+export const getLogPreview = (value)=>{
+    if (!value) return null;
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    if (trimmed.length <= maxPreviewLength) return trimmed;
+    return `${trimmed.slice(0, maxPreviewLength).trim()}...`;
+};
+export const logHandlerEvent = (req, level, entry)=>{
+    const logger = req.payload?.logger;
+    const log = logger?.[level];
+    if (typeof log !== "function") return;
+    log.call(logger, entry);
+};

package/dist/payload/normalizeData.d.ts

@@ -1,24 +1,31 @@
 export type FieldConfig = {
-    blocks?: BlockConfig[];
+    admin?: Record<string, unknown>;
+    blocks?: readonly BlockConfig[];
     defaultValue?: unknown;
-    fields?: FieldConfig[];
+    fields?: readonly FieldConfig[];
+    hasMany?: boolean;
     label?: unknown;
     localized?: boolean;
     name?: string;
-    options?: (string | {
+    options?: readonly (string | {
         value?: string;
     })[];
+    relationTo?: unknown;
     required?: boolean;
     type?: string;
 };
 type BlockConfig = {
-    fields?: FieldConfig[];
+    fields?: readonly FieldConfig[];
     slug: string;
 };
 export type CollectionConfig = {
+    admin?: Record<string, unknown>;
     auth?: unknown;
-    fields: FieldConfig[];
+    fields?: readonly FieldConfig[];
     slug: string;
+    versions?: boolean | {
+        drafts?: boolean | Record<string, unknown>;
+    };
 };
 export type NormalizedData = {
     coercedFields: string[];
@@ -27,10 +34,13 @@ export type NormalizedData = {
 };
 export declare const isAuthCollection: (collectionConfig?: CollectionConfig | null) => boolean;
 export declare const getCollectionFields: (collectionConfig?: CollectionConfig | null) => FieldConfig[];
+export declare const hasDrafts: (collectionConfig?: CollectionConfig | null) => boolean;
+export declare const getSchemaFields: (collectionConfig?: CollectionConfig | null) => FieldConfig[];
+export declare const createLexicalText: (value: unknown) => Record<string, unknown>;
 export declare const normalizeAuthData: (collectionConfig: CollectionConfig | undefined, normalized: NormalizedData) => NormalizedData;
-export declare const normalizeDataForFields: (fields: FieldConfig[], data: Record<string, unknown>) => NormalizedData;
+export declare const normalizeDataForFields: (fields: readonly FieldConfig[], data: Record<string, unknown>) => NormalizedData;
 export declare const getLocalizedRequiredFallbackData: ({ fields, source, target, }: {
-    fields: FieldConfig[];
+    fields: readonly FieldConfig[];
     source: Record<string, unknown>;
     target: Record<string, unknown>;
 }) => Record<string, unknown>;

package/dist/payload/normalizeData.js

@@ -21,7 +21,28 @@ export const getCollectionFields = (collectionConfig)=>{
     }
     return fields;
 };
-const createLexicalText = (value)=>{
+export const hasDrafts = (collectionConfig)=>{
+    const versions = collectionConfig?.versions;
+    if (!versions || versions === true || !isRecord(versions)) return false;
+    return Boolean(versions.drafts);
+};
+export const getSchemaFields = (collectionConfig)=>{
+    const fields = getCollectionFields(collectionConfig);
+    if (hasDrafts(collectionConfig)) {
+        fields.push({
+            defaultValue: "draft",
+            name: "_status",
+            options: [
+                "draft",
+                "published"
+            ],
+            required: true,
+            type: "select"
+        });
+    }
+    return fields;
+};
+export const createLexicalText = (value)=>{
     if (isRecord(value) && isRecord(value.root)) return value;
     const text = Array.isArray(value) ? value.join("\n") : String(value || "");
     const lines = text.split("\n").map((line)=>line.trim()).filter(Boolean);

package/dist/payload/proposalData.d.ts

@@ -0,0 +1,31 @@
+import { type LocalizedDataInput } from "./shared.js";
+import { type CollectionConfig, type FieldConfig } from "./normalizeData.js";
+type ProposalMode = "create" | "update";
+export type ProposalValidationIssue = {
+    code: "empty_localized_data" | "invalid_array" | "invalid_block_type" | "invalid_blocks" | "invalid_checkbox" | "invalid_container" | "invalid_date" | "invalid_option" | "invalid_relationship" | "missing_required_field" | "non_localized_field_in_secondary_locale" | "unknown_field";
+    message: string;
+    path: string;
+};
+export type PreparedProposalData = {
+    coercedFields: string[];
+    data?: Record<string, unknown>;
+    issues: ProposalValidationIssue[];
+    localizedData?: LocalizedDataInput;
+};
+type PrepareProposalDataArgs = {
+    collectionConfig?: CollectionConfig;
+    data?: Record<string, unknown>;
+    inferenceText?: string;
+    label: string;
+    localizedData?: LocalizedDataInput;
+    mode: ProposalMode;
+};
+export declare const prepareProposalWriteData: ({ collectionConfig, data, inferenceText, label, localizedData, mode }: PrepareProposalDataArgs) => PreparedProposalData;
+export declare const applyLocalizedRequiredFallbackToPreparedData: ({ fallbackSource, fields, preparedData, }: {
+    fallbackSource: Record<string, unknown>;
+    fields: readonly FieldConfig[];
+    preparedData: Record<string, unknown>;
+}) => {
+    [x: string]: unknown;
+};
+export {};