@mvriu5/payload-ai 1.4.0 → 1.6.0

package/dist/payload/documentTranslation.js

@@ -0,0 +1,120 @@
+const hasValue = (value)=>{
+    if (value === null || value === undefined || value === "") return false;
+    if (Array.isArray(value)) return value.some(hasValue);
+    if (typeof value === "object") return Object.values(value).some(hasValue);
+    return true;
+};
+const hasRichTextValue = (value)=>{
+    if (!value || typeof value !== "object") return false;
+    if (Array.isArray(value)) return value.some(hasRichTextValue);
+    const node = value;
+    if (node.type === "text") return typeof node.text === "string" && node.text.trim().length > 0;
+    if ([
+        "block",
+        "inlineBlock",
+        "relationship",
+        "upload"
+    ].includes(String(node.type))) return true;
+    if (node.root) return hasRichTextValue(node.root);
+    return Array.isArray(node.children) && node.children.some(hasRichTextValue);
+};
+const getFieldType = (field)=>[
+        "json",
+        "richText",
+        "text",
+        "textarea"
+    ].includes(field.type) ? field.type : "unknown";
+const collectFields = ({ data, fields, parentPath = "", result })=>{
+    for (const field of fields){
+        if (field.type === "tabs") {
+            for (const tab of field.tabs){
+                const tabData = "name" in tab && tab.name ? data[tab.name] || {} : data;
+                collectFields({
+                    data: tabData,
+                    fields: tab.fields,
+                    parentPath: "name" in tab && tab.name ? parentPath ? `${parentPath}.${tab.name}` : tab.name : parentPath,
+                    result
+                });
+            }
+            continue;
+        }
+        if (!("name" in field) || !field.name) {
+            if ("fields" in field && Array.isArray(field.fields)) collectFields({
+                data,
+                fields: field.fields,
+                parentPath,
+                result
+            });
+            continue;
+        }
+        const path = parentPath ? `${parentPath}.${field.name}` : field.name;
+        const value = data[field.name];
+        if ("localized" in field && field.localized) {
+            const valueExists = field.type === "richText" ? hasRichTextValue(value) : hasValue(value);
+            if (valueExists) {
+                result.push({
+                    fieldType: getFieldType(field),
+                    path,
+                    value
+                });
+            }
+            continue;
+        }
+        if (field.type === "array" && Array.isArray(value)) {
+            value.forEach((row, index)=>{
+                if (row && typeof row === "object") {
+                    collectFields({
+                        data: row,
+                        fields: field.fields,
+                        parentPath: `${path}.${index}`,
+                        result
+                    });
+                }
+            });
+            continue;
+        }
+        if (field.type === "blocks" && Array.isArray(value)) {
+            value.forEach((row, index)=>{
+                if (!row || typeof row !== "object") return;
+                const rowData = row;
+                const block = field.blocks.find((candidate)=>typeof candidate === "object" && candidate.slug === rowData.blockType);
+                if (block && typeof block === "object") {
+                    collectFields({
+                        data: rowData,
+                        fields: block.fields,
+                        parentPath: `${path}.${index}`,
+                        result
+                    });
+                }
+            });
+            continue;
+        }
+        if ("fields" in field && Array.isArray(field.fields) && value && typeof value === "object") {
+            collectFields({
+                data: value,
+                fields: field.fields,
+                parentPath: path,
+                result
+            });
+        }
+    }
+};
+export const getTranslationValues = (fields, data)=>{
+    if (!data || typeof data !== "object") return [];
+    const result = [];
+    collectFields({
+        data: data,
+        fields,
+        result
+    });
+    return result;
+};
+export const hasLocalizedFields = (fields)=>{
+    for (const field of fields){
+        if ("localized" in field && field.localized) return true;
+        if (field.type === "tabs" && field.tabs.some((tab)=>hasLocalizedFields(tab.fields))) return true;
+        if (field.type === "blocks" && field.blocks.some((block)=>typeof block === "object" && hasLocalizedFields(block.fields))) return true;
+        if ("fields" in field && Array.isArray(field.fields) && hasLocalizedFields(field.fields)) return true;
+    }
+    return false;
+};

package/dist/payload/textFieldGeneration.d.ts

@@ -0,0 +1,26 @@
+import type { Field } from "payload";
+type GeneratableField = Extract<Field, {
+    type: "json" | "richText" | "text" | "textarea";
+}>;
+export type TextGenerationFieldContext = {
+    description?: string;
+    fieldType: GeneratableField["type"];
+    hasMany: boolean;
+    key: string;
+    label: string;
+    maxLength?: number;
+    name: string;
+};
+export type TextGenerationPageContext = {
+    fields: TextGenerationFieldContext[];
+    label: string;
+    slug: string;
+    type: "collection" | "global";
+};
+export declare const addTextGenerationFields: ({ fields, label, slug, type, }: {
+    fields: Field[];
+    label: string;
+    slug: string;
+    type: TextGenerationPageContext["type"];
+}) => TextGenerationPageContext;
+export {};

package/dist/payload/textFieldGeneration.js

@@ -0,0 +1,99 @@
+const generateFieldComponent = "@mvriu5/payload-ai/client#GenerateField";
+const getLabel = (field)=>{
+    if (typeof field.label === "string") return field.label;
+    if (field.label && typeof field.label === "object") {
+        const label = Object.values(field.label).find((value)=>typeof value === "string");
+        if (typeof label === "string") return label;
+    }
+    return field.name;
+};
+const getDescription = (field)=>{
+    const description = field.admin?.description;
+    return typeof description === "string" ? description : undefined;
+};
+const addGenerateComponent = (field, key)=>{
+    field.admin = field.admin || {};
+    field.admin.components = field.admin.components || {};
+    const current = field.admin.components.afterInput || [];
+    const alreadyAdded = current.some((component)=>{
+        if (typeof component === "string") return component === generateFieldComponent;
+        return component && typeof component === "object" && "path" in component && component.path === generateFieldComponent;
+    });
+    if (alreadyAdded) return;
+    field.admin.components.afterInput = [
+        ...current,
+        {
+            clientProps: {
+                generationFieldKey: key,
+                generationFieldType: field.type
+            },
+            path: generateFieldComponent
+        }
+    ];
+};
+const visitFields = ({ fields, parentKey, result })=>{
+    for (const field of fields){
+        if (field.type === "tabs") {
+            for (const tab of field.tabs){
+                visitFields({
+                    fields: tab.fields,
+                    parentKey: "name" in tab ? `${parentKey}.${tab.name}` : parentKey,
+                    result
+                });
+            }
+            continue;
+        }
+        if (field.type === "blocks") {
+            for (const block of field.blocks){
+                if (typeof block !== "object") continue;
+                visitFields({
+                    fields: block.fields,
+                    parentKey: `${parentKey}.${field.name}.${block.slug}`,
+                    result
+                });
+            }
+            continue;
+        }
+        if ("fields" in field && Array.isArray(field.fields)) {
+            const nextParent = "name" in field && field.name ? `${parentKey}.${field.name}` : parentKey;
+            visitFields({
+                fields: field.fields,
+                parentKey: nextParent,
+                result
+            });
+        }
+        if (![
+            "json",
+            "richText",
+            "text",
+            "textarea"
+        ].includes(field.type) || !("name" in field) || !field.name) continue;
+        const key = `${parentKey}.${field.name}`;
+        const generatableField = field;
+        if (generatableField.admin?.hidden) continue;
+        addGenerateComponent(generatableField, key);
+        result.push({
+            description: getDescription(generatableField),
+            fieldType: generatableField.type,
+            hasMany: "hasMany" in generatableField ? Boolean(generatableField.hasMany) : false,
+            key,
+            label: getLabel(generatableField),
+            maxLength: "maxLength" in generatableField ? generatableField.maxLength : undefined,
+            name: generatableField.name
+        });
+    }
+};
+export const addTextGenerationFields = ({ fields, label, slug, type })=>{
+    const result = [];
+    visitFields({
+        fields,
+        parentKey: slug,
+        result
+    });
+    return {
+        fields: result,
+        label,
+        slug,
+        type
+    };
+};

package/dist/payload/toolFieldSelection.d.ts

@@ -0,0 +1,25 @@
+import { z } from "zod";
+import { type CollectionConfig } from "./normalizeData.js";
+export declare const maxToolSelectedFields = 12;
+export type ReadCollectionConfig = CollectionConfig & {
+    admin?: {
+        useAsTitle?: string;
+    };
+    timestamps?: boolean;
+    upload?: boolean | Record<string, unknown>;
+};
+export declare const getToolSelectableFieldNames: (config: ReadCollectionConfig) => string[];
+export declare const createToolFieldNamesSchema: (configs: ReadCollectionConfig[]) => z.ZodOptional<z.ZodArray<z.ZodString | z.ZodEnum<{
+    [x: string]: string;
+}>>>;
+export declare const resolveToolFieldSelection: ({ config, mode, requestedFields, }: {
+    config: ReadCollectionConfig;
+    mode?: "document" | "search";
+    requestedFields?: string[];
+}) => {
+    allowedFields: string[];
+    depth: number;
+    fields: string[];
+    invalidFields: string[];
+    select: Record<string, true>;
+};

package/dist/payload/toolFieldSelection.js

@@ -0,0 +1,118 @@
+import { z } from "zod";
+import { isSensitiveKey } from "../ai/sensitiveData.js";
+import { getSchemaFields } from "./normalizeData.js";
+export const maxToolSelectedFields = 12;
+const cheapFieldTypes = new Set([
+    "checkbox",
+    "date",
+    "email",
+    "number",
+    "point",
+    "radio",
+    "select",
+    "text"
+]);
+const populatedFieldTypes = new Set([
+    "relationship",
+    "upload"
+]);
+const systemFieldNames = [
+    "id",
+    "createdAt",
+    "updatedAt"
+];
+const uploadFieldNames = [
+    "filename",
+    "mimeType",
+    "filesize",
+    "width",
+    "height",
+    "url",
+    "thumbnailURL"
+];
+const getSelectableFields = (config)=>{
+    return getSchemaFields(config).filter((field)=>{
+        return Boolean(field.name && field.type !== "ui" && !isSensitiveKey(field.name));
+    });
+};
+export const getToolSelectableFieldNames = (config)=>{
+    const names = getSelectableFields(config).flatMap((field)=>field.name ? [
+            field.name
+        ] : []);
+    names.push("id");
+    if (config.timestamps !== false) names.push("createdAt", "updatedAt");
+    if (config.upload) names.push(...uploadFieldNames);
+    return [
+        ...new Set(names)
+    ];
+};
+const getDefaultFieldNames = (config, mode)=>{
+    const selectableFields = getSelectableFields(config);
+    const selectableNames = new Set(getToolSelectableFieldNames(config));
+    const candidates = [
+        config.admin?.useAsTitle,
+        "title",
+        "name",
+        "label",
+        "headline",
+        "slug",
+        "_status",
+        ...config.upload ? selectableFields.flatMap((field)=>field.name && cheapFieldTypes.has(field.type || "") ? [
+                field.name
+            ] : []).slice(0, 2) : [],
+        ...mode === "document" ? [
+            "updatedAt"
+        ] : [],
+        ...config.upload ? [
+            "filename",
+            "mimeType",
+            "filesize",
+            "url"
+        ] : []
+    ];
+    const defaults = candidates.filter((name)=>Boolean(name && (selectableNames.has(name) || systemFieldNames.includes(name))));
+    if (!defaults.some((fieldName)=>!systemFieldNames.includes(fieldName) && !uploadFieldNames.includes(fieldName))) {
+        const firstCheapField = selectableFields.find((field)=>field.name && cheapFieldTypes.has(field.type || ""));
+        const firstSelectableField = firstCheapField || selectableFields[0];
+        defaults.unshift(firstSelectableField?.name || "id");
+    }
+    return [
+        ...new Set(defaults)
+    ].slice(0, mode === "search" ? 4 : 6);
+};
+export const createToolFieldNamesSchema = (configs)=>{
+    const names = [
+        ...new Set(configs.flatMap(getToolSelectableFieldNames))
+    ];
+    const fieldNameSchema = names.length > 0 ? z.enum(names) : z.string().refine(()=>false, "No fields are selectable.");
+    return z.array(fieldNameSchema).max(maxToolSelectedFields).optional();
+};
+export const resolveToolFieldSelection = ({ config, mode = "document", requestedFields })=>{
+    const allowedNames = new Set(getToolSelectableFieldNames(config));
+    const normalizedRequestedFields = [
+        ...new Set((requestedFields || []).slice(0, maxToolSelectedFields).map((field)=>field.trim()).filter(Boolean))
+    ];
+    const invalidFields = normalizedRequestedFields.filter((field)=>!allowedNames.has(field));
+    const selectedFields = [
+        ...new Set((requestedFields?.length ? requestedFields : getDefaultFieldNames(config, mode)).map((field)=>field.trim()).filter((field)=>allowedNames.has(field)))
+    ].slice(0, maxToolSelectedFields);
+    const fields = selectedFields.length > 0 ? selectedFields : getDefaultFieldNames(config, mode);
+    const fieldTypesByName = new Map(getSelectableFields(config).flatMap((field)=>field.name ? [
+            [
+                field.name,
+                field.type
+            ]
+        ] : []));
+    return {
+        allowedFields: [
+            ...allowedNames
+        ],
+        depth: fields.some((field)=>populatedFieldTypes.has(fieldTypesByName.get(field) || "")) ? 1 : 0,
+        fields,
+        invalidFields,
+        select: Object.fromEntries(fields.map((field)=>[
+                field,
+                true
+            ]))
+    };
+};

package/dist/payload/toolSchemas.d.ts

@@ -0,0 +1,7 @@
+import { z } from "zod";
+import { type CollectionConfig } from "./normalizeData.js";
+export declare const genericPayloadDataSchema: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+export declare const createPayloadDataSchema: (config?: CollectionConfig | null) => z.ZodRecord<z.ZodString, z.ZodUnknown> | z.ZodObject<{
+    [x: string]: z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>;
+}, z.core.$strict>;
+export declare const createLocalizedPayloadDataSchema: (dataSchema: z.ZodType) => z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;

package/dist/payload/toolSchemas.js

@@ -0,0 +1,117 @@
+import { z } from "zod";
+import { getSchemaFields } from "./normalizeData.js";
+const relationshipIDSchema = z.union([
+    z.string().min(1),
+    z.number()
+]);
+const getOptionValues = (field)=>{
+    return (field.options || []).flatMap((option)=>{
+        const value = typeof option === "string" ? option : option.value;
+        return value ? [
+            value
+        ] : [];
+    });
+};
+const createSelectSchema = (field)=>{
+    const values = getOptionValues(field);
+    const valueSchema = values.length > 0 ? z.enum(values) : z.string();
+    return field.hasMany ? z.array(valueSchema) : valueSchema;
+};
+const createRelationshipSchema = (field)=>{
+    const polymorphicValueSchema = Array.isArray(field.relationTo) ? z.union([
+        relationshipIDSchema,
+        z.object({
+            relationTo: z.enum(field.relationTo),
+            value: relationshipIDSchema
+        }).strict()
+    ]) : relationshipIDSchema;
+    return field.hasMany ? z.array(polymorphicValueSchema) : polymorphicValueSchema;
+};
+const createObjectSchema = (fields)=>{
+    const shape = {};
+    const addFields = (nestedFields)=>{
+        for (const field of nestedFields){
+            if (field.type === "ui") continue;
+            if (!field.name) {
+                if (field.fields?.length) addFields(field.fields);
+                if (field.tabs?.length) {
+                    for (const tab of field.tabs){
+                        if (tab.name) {
+                            shape[tab.name] = createObjectSchema(tab.fields || []).nullable().optional();
+                        } else {
+                            addFields(tab.fields || []);
+                        }
+                    }
+                }
+                continue;
+            }
+            shape[field.name] = createFieldValueSchema(field).nullable().optional();
+        }
+    };
+    addFields(fields);
+    return z.object(shape).strict();
+};
+const createBlocksSchema = (field)=>{
+    const blockSchemas = (field.blocks || []).map((block)=>createObjectSchema(block.fields || []).extend({
+            blockType: z.literal(block.slug)
+        }));
+    if (blockSchemas.length === 0) return z.array(z.record(z.string(), z.unknown()));
+    if (blockSchemas.length === 1) return z.array(blockSchemas[0]);
+    return z.array(z.union(blockSchemas));
+};
+const createFieldValueSchema = (field)=>{
+    switch(field.type){
+        case "array":
+            return z.array(createObjectSchema(field.fields || []));
+        case "blocks":
+            return createBlocksSchema(field);
+        case "checkbox":
+            return z.boolean();
+        case "date":
+            return z.string().min(1);
+        case "email":
+            return z.string();
+        case "group":
+            return createObjectSchema(field.fields || []);
+        case "number":
+            return z.number();
+        case "point":
+            return z.tuple([
+                z.number(),
+                z.number()
+            ]);
+        case "radio":
+        case "select":
+            return createSelectSchema(field);
+        case "relationship":
+        case "upload":
+            return createRelationshipSchema(field);
+        case "richText":
+            return z.union([
+                z.string(),
+                z.record(z.string(), z.unknown())
+            ]);
+        case "code":
+        case "text":
+        case "textarea":
+            return z.string();
+        case "json":
+        default:
+            return z.unknown();
+    }
+};
+export const genericPayloadDataSchema = z.record(z.string(), z.unknown());
+const payloadDataSchemaCache = new WeakMap();
+export const createPayloadDataSchema = (config)=>{
+    if (!config) return genericPayloadDataSchema;
+    const cached = payloadDataSchemaCache.get(config);
+    if (cached) return cached;
+    const schema = createObjectSchema(getSchemaFields(config));
+    payloadDataSchemaCache.set(config, schema);
+    return schema;
+};
+export const createLocalizedPayloadDataSchema = (dataSchema)=>{
+    return z.record(z.string(), dataSchema).refine((value)=>Object.keys(value).length > 0, {
+        message: "localizedData must include at least one locale entry."
+    });
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@mvriu5/payload-ai",
-    "version": "1.4.0",
+    "version": "1.6.0",
     "description": "AI assistant plugin for Payload CMS with provider selection, CMS mentions, and signed action proposals.",
     "keywords": [
         "payload",
@@ -84,10 +84,10 @@
         "copyfiles": "2.4.1",
         "cross-env": "^10.1.0",
         "eslint": "^10.5.0",
-        "graphql": "^17.0.1",
+        "graphql": "^16.8.1",
         "jsdom": "^29.1.1",
         "knip": "^6.18.0",
-        "next": "16.2.10",
+        "next": "16.2.11",
         "payload": "3.86.0",
         "prettier": "^3.8.4",
         "react": "19.2.7",