payload 3.0.0-beta.13 → 3.0.0-beta.131

package/dist/fields/hooks/afterRead/promise.js

@@ -1,5 +1,7 @@
-/* eslint-disable no-param-reassign */ import { fieldAffectsData, tabHasName } from '../../config/types.js';
-import getValueWithDefault from '../../getDefaultValue.js';
+import { MissingEditorProp } from '../../../errors/index.js';
+import { fieldAffectsData, tabHasName } from '../../config/types.js';
+import { getDefaultValue } from '../../getDefaultValue.js';
+import { getFieldPaths } from '../../getFieldPaths.js';
 import { relationshipPopulationPromise } from './relationshipPopulationPromise.js';
 import { traverseFields } from './traverseFields.js';
 // This function is responsible for the following actions, in order:
@@ -9,10 +11,33 @@ import { traverseFields } from './traverseFields.js';
 // - Execute field hooks
 // - Execute read access control
 // - Populate relationships
-export const promise = async ({ collection, context, currentDepth, depth, doc, fallbackLocale, field, fieldPromises, findMany, flattenLocales, global, locale, overrideAccess, populationPromises, req, showHiddenFields, siblingDoc, triggerAccessControl = true, triggerHooks = true })=>{
+export const promise = async ({ collection, context, currentDepth, depth, doc, draft, fallbackLocale, field, fieldIndex, fieldPromises, findMany, flattenLocales, global, locale, overrideAccess, parentPath, parentSchemaPath, populate, populationPromises, req, select, selectMode, showHiddenFields, siblingDoc, triggerAccessControl = true, triggerHooks = true })=>{
+    const { path: _fieldPath, schemaPath: _fieldSchemaPath } = getFieldPaths({
+        field,
+        index: fieldIndex,
+        parentIndexPath: '',
+        parentPath: parentPath.join('.'),
+        parentSchemaPath: parentSchemaPath.join('.')
+    });
+    const fieldPath = _fieldPath ? _fieldPath.split('.') : [];
+    const fieldSchemaPath = _fieldSchemaPath ? _fieldSchemaPath.split('.') : [];
     if (fieldAffectsData(field) && field.hidden && typeof siblingDoc[field.name] !== 'undefined' && !showHiddenFields) {
         delete siblingDoc[field.name];
     }
+    if (fieldAffectsData(field) && select && selectMode) {
+        if (selectMode === 'include') {
+            if (!select[field.name]) {
+                delete siblingDoc[field.name];
+                return;
+            }
+        }
+        if (selectMode === 'exclude') {
+            if (select[field.name] === false) {
+                delete siblingDoc[field.name];
+                return;
+            }
+        }
+    }
     const shouldHoistLocalizedValue = flattenLocales && fieldAffectsData(field) && typeof siblingDoc[field.name] === 'object' && siblingDoc[field.name] !== null && field.localized && locale !== 'all' && req.payload.config.localization;
     if (shouldHoistLocalizedValue) {
         // replace actual value with localized value before sanitizing
@@ -55,58 +80,34 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                 }
                 break;
             }
-        case 'tabs':
+        case 'point':
             {
-                field.tabs.forEach((tab)=>{
-                    if (tabHasName(tab) && (typeof siblingDoc[tab.name] === 'undefined' || siblingDoc[tab.name] === null)) {
-                        siblingDoc[tab.name] = {};
-                    }
-                });
+                const pointDoc = siblingDoc[field.name];
+                if (Array.isArray(pointDoc?.coordinates) && pointDoc.coordinates.length === 2) {
+                    siblingDoc[field.name] = pointDoc.coordinates;
+                } else {
+                    siblingDoc[field.name] = undefined;
+                }
                 break;
             }
         case 'richText':
             {
-                const editor = field?.editor;
-                // This is run here AND in the GraphQL Resolver
-                if (editor?.populationPromise) {
-                    const populationPromise = editor.populationPromise({
-                        context,
-                        currentDepth,
-                        depth,
-                        field,
-                        findMany,
-                        flattenLocales,
-                        overrideAccess,
-                        populationPromises,
-                        req,
-                        showHiddenFields,
-                        siblingDoc
-                    });
-                    if (populationPromise) {
-                        populationPromises.push(populationPromise);
-                    }
+                if (!field?.editor) {
+                    throw new MissingEditorProp(field) // while we allow disabling editor functionality, you should not have any richText fields defined if you do not have an editor
+                    ;
                 }
-                // This is only run here, independent of depth
-                if (editor?.afterReadPromise) {
-                    const afterReadPromise = editor?.afterReadPromise({
-                        field,
-                        incomingEditorState: siblingDoc[field.name],
-                        siblingDoc
-                    });
-                    if (afterReadPromise) {
-                        populationPromises.push(afterReadPromise);
-                    }
+                if (typeof field?.editor === 'function') {
+                    throw new Error('Attempted to access unsanitized rich text editor.');
                 }
                 break;
             }
-        case 'point':
+        case 'tabs':
             {
-                const pointDoc = siblingDoc[field.name];
-                if (Array.isArray(pointDoc?.coordinates) && pointDoc.coordinates.length === 2) {
-                    siblingDoc[field.name] = pointDoc.coordinates;
-                } else {
-                    siblingDoc[field.name] = undefined;
-                }
+                field.tabs.forEach((tab)=>{
+                    if (tabHasName(tab) && (typeof siblingDoc[tab.name] === 'undefined' || siblingDoc[tab.name] === null)) {
+                        siblingDoc[tab.name] = {};
+                    }
+                });
                 break;
             }
         default:
@@ -125,12 +126,20 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                             const hookedValue = await currentHook({
                                 collection,
                                 context,
+                                currentDepth,
                                 data: doc,
+                                depth,
+                                draft,
                                 field,
+                                findMany,
                                 global,
                                 operation: 'read',
                                 originalDoc: doc,
+                                overrideAccess,
+                                path: fieldPath,
                                 req,
+                                schemaPath: fieldSchemaPath,
+                                showHiddenFields,
                                 siblingData: siblingDoc,
                                 value
                             });
@@ -143,13 +152,20 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                     const hookedValue = await currentHook({
                         collection,
                         context,
+                        currentDepth,
                         data: doc,
+                        depth,
+                        draft,
                         field,
                         findMany,
                         global,
                         operation: 'read',
                         originalDoc: doc,
+                        overrideAccess,
+                        path: fieldPath,
                         req,
+                        schemaPath: fieldSchemaPath,
+                        showHiddenFields,
                         siblingData: siblingDoc,
                         value: siblingDoc[field.name]
                     });
@@ -177,21 +193,23 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
         // Set defaultValue on the field for globals being returned without being first created
         // or collection documents created prior to having a default
         if (allowDefaultValue && typeof siblingDoc[field.name] === 'undefined' && typeof field.defaultValue !== 'undefined') {
-            siblingDoc[field.name] = await getValueWithDefault({
+            siblingDoc[field.name] = await getDefaultValue({
                 defaultValue: field.defaultValue,
                 locale,
                 user: req.user,
                 value: siblingDoc[field.name]
             });
         }
-        if (field.type === 'relationship' || field.type === 'upload') {
+        if (field.type === 'relationship' || field.type === 'upload' || field.type === 'join') {
             populationPromises.push(relationshipPopulationPromise({
                 currentDepth,
                 depth,
+                draft,
                 fallbackLocale,
                 field,
                 locale,
                 overrideAccess,
+                populate,
                 req,
                 showHiddenFields,
                 siblingDoc
@@ -199,44 +217,22 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
         }
     }
     switch(field.type){
-        case 'group':
-            {
-                let groupDoc = siblingDoc[field.name];
-                if (typeof siblingDoc[field.name] !== 'object') groupDoc = {};
-                traverseFields({
-                    collection,
-                    context,
-                    currentDepth,
-                    depth,
-                    doc,
-                    fallbackLocale,
-                    fieldPromises,
-                    fields: field.fields,
-                    findMany,
-                    flattenLocales,
-                    global,
-                    locale,
-                    overrideAccess,
-                    populationPromises,
-                    req,
-                    showHiddenFields,
-                    siblingDoc: groupDoc,
-                    triggerAccessControl,
-                    triggerHooks
-                });
-                break;
-            }
         case 'array':
             {
                 const rows = siblingDoc[field.name];
+                const arraySelect = select?.[field.name];
+                if (selectMode === 'include' && typeof arraySelect === 'object') {
+                    arraySelect.id = true;
+                }
                 if (Array.isArray(rows)) {
-                    rows.forEach((row)=>{
+                    rows.forEach((row, i)=>{
                         traverseFields({
                             collection,
                             context,
                             currentDepth,
                             depth,
                             doc,
+                            draft,
                             fallbackLocale,
                             fieldPromises,
                             fields: field.fields,
@@ -245,8 +241,16 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                             global,
                             locale,
                             overrideAccess,
+                            path: [
+                                ...fieldPath,
+                                i
+                            ],
+                            populate,
                             populationPromises,
                             req,
+                            schemaPath: fieldSchemaPath,
+                            select: typeof arraySelect === 'object' ? arraySelect : undefined,
+                            selectMode,
                             showHiddenFields,
                             siblingDoc: row || {},
                             triggerAccessControl,
@@ -256,13 +260,14 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                 } else if (!shouldHoistLocalizedValue && typeof rows === 'object' && rows !== null) {
                     Object.values(rows).forEach((localeRows)=>{
                         if (Array.isArray(localeRows)) {
-                            localeRows.forEach((row)=>{
+                            localeRows.forEach((row, i)=>{
                                 traverseFields({
                                     collection,
                                     context,
                                     currentDepth,
                                     depth,
                                     doc,
+                                    draft,
                                     fallbackLocale,
                                     fieldPromises,
                                     fields: field.fields,
@@ -271,8 +276,14 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                                     global,
                                     locale,
                                     overrideAccess,
+                                    path: [
+                                        ...fieldPath,
+                                        i
+                                    ],
+                                    populate,
                                     populationPromises,
                                     req,
+                                    schemaPath: fieldSchemaPath,
                                     showHiddenFields,
                                     siblingDoc: row || {},
                                     triggerAccessControl,
@@ -289,9 +300,30 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
         case 'blocks':
             {
                 const rows = siblingDoc[field.name];
+                const blocksSelect = select?.[field.name];
                 if (Array.isArray(rows)) {
-                    rows.forEach((row)=>{
+                    rows.forEach((row, i)=>{
                         const block = field.blocks.find((blockType)=>blockType.slug === row.blockType);
+                        let blockSelectMode = selectMode;
+                        if (typeof blocksSelect === 'object') {
+                            // sanitize blocks: {cta: false} to blocks: {cta: {id: true, blockType: true}}
+                            if (selectMode === 'exclude' && blocksSelect[block.slug] === false) {
+                                blockSelectMode = 'include';
+                                blocksSelect[block.slug] = {
+                                    id: true,
+                                    blockType: true
+                                };
+                            } else if (selectMode === 'include') {
+                                if (!blocksSelect[block.slug]) {
+                                    blocksSelect[block.slug] = {};
+                                }
+                                if (typeof blocksSelect[block.slug] === 'object') {
+                                    blocksSelect[block.slug]['id'] = true;
+                                    blocksSelect[block.slug]['blockType'] = true;
+                                }
+                            }
+                        }
+                        const blockSelect = blocksSelect?.[block.slug];
                         if (block) {
                             traverseFields({
                                 collection,
@@ -299,6 +331,7 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                                 currentDepth,
                                 depth,
                                 doc,
+                                draft,
                                 fallbackLocale,
                                 fieldPromises,
                                 fields: block.fields,
@@ -307,8 +340,16 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                                 global,
                                 locale,
                                 overrideAccess,
+                                path: [
+                                    ...fieldPath,
+                                    i
+                                ],
+                                populate,
                                 populationPromises,
                                 req,
+                                schemaPath: fieldSchemaPath,
+                                select: typeof blockSelect === 'object' ? blockSelect : undefined,
+                                selectMode: blockSelectMode,
                                 showHiddenFields,
                                 siblingDoc: row || {},
                                 triggerAccessControl,
@@ -319,7 +360,7 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                 } else if (!shouldHoistLocalizedValue && typeof rows === 'object' && rows !== null) {
                     Object.values(rows).forEach((localeRows)=>{
                         if (Array.isArray(localeRows)) {
-                            localeRows.forEach((row)=>{
+                            localeRows.forEach((row, i)=>{
                                 const block = field.blocks.find((blockType)=>blockType.slug === row.blockType);
                                 if (block) {
                                     traverseFields({
@@ -328,6 +369,7 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                                         currentDepth,
                                         depth,
                                         doc,
+                                        draft,
                                         fallbackLocale,
                                         fieldPromises,
                                         fields: block.fields,
@@ -336,8 +378,14 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                                         global,
                                         locale,
                                         overrideAccess,
+                                        path: [
+                                            ...fieldPath,
+                                            i
+                                        ],
+                                        populate,
                                         populationPromises,
                                         req,
+                                        schemaPath: fieldSchemaPath,
                                         showHiddenFields,
                                         siblingDoc: row || {},
                                         triggerAccessControl,
@@ -352,8 +400,8 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                 }
                 break;
             }
-        case 'row':
         case 'collapsible':
+        case 'row':
             {
                 traverseFields({
                     collection,
@@ -361,6 +409,7 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                     currentDepth,
                     depth,
                     doc,
+                    draft,
                     fallbackLocale,
                     fieldPromises,
                     fields: field.fields,
@@ -369,8 +418,13 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                     global,
                     locale,
                     overrideAccess,
+                    path: fieldPath,
+                    populate,
                     populationPromises,
                     req,
+                    schemaPath: fieldSchemaPath,
+                    select,
+                    selectMode,
                     showHiddenFields,
                     siblingDoc,
                     triggerAccessControl,
@@ -378,12 +432,142 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                 });
                 break;
             }
+        case 'group':
+            {
+                let groupDoc = siblingDoc[field.name];
+                if (typeof siblingDoc[field.name] !== 'object') {
+                    groupDoc = {};
+                }
+                const groupSelect = select?.[field.name];
+                traverseFields({
+                    collection,
+                    context,
+                    currentDepth,
+                    depth,
+                    doc,
+                    draft,
+                    fallbackLocale,
+                    fieldPromises,
+                    fields: field.fields,
+                    findMany,
+                    flattenLocales,
+                    global,
+                    locale,
+                    overrideAccess,
+                    path: fieldPath,
+                    populate,
+                    populationPromises,
+                    req,
+                    schemaPath: fieldSchemaPath,
+                    select: typeof groupSelect === 'object' ? groupSelect : undefined,
+                    selectMode,
+                    showHiddenFields,
+                    siblingDoc: groupDoc,
+                    triggerAccessControl,
+                    triggerHooks
+                });
+                break;
+            }
+        case 'richText':
+            {
+                if (!field?.editor) {
+                    throw new MissingEditorProp(field) // while we allow disabling editor functionality, you should not have any richText fields defined if you do not have an editor
+                    ;
+                }
+                if (typeof field?.editor === 'function') {
+                    throw new Error('Attempted to access unsanitized rich text editor.');
+                }
+                const editor = field?.editor;
+                if (editor?.hooks?.afterRead?.length) {
+                    await editor.hooks.afterRead.reduce(async (priorHook, currentHook)=>{
+                        await priorHook;
+                        const shouldRunHookOnAllLocales = field.localized && (locale === 'all' || !flattenLocales) && typeof siblingDoc[field.name] === 'object';
+                        if (shouldRunHookOnAllLocales) {
+                            const hookPromises = Object.entries(siblingDoc[field.name]).map(([locale, value])=>(async ()=>{
+                                    const hookedValue = await currentHook({
+                                        collection,
+                                        context,
+                                        currentDepth,
+                                        data: doc,
+                                        depth,
+                                        draft,
+                                        fallbackLocale,
+                                        field,
+                                        fieldPromises,
+                                        findMany,
+                                        flattenLocales,
+                                        global,
+                                        locale,
+                                        operation: 'read',
+                                        originalDoc: doc,
+                                        overrideAccess,
+                                        path: fieldPath,
+                                        populate,
+                                        populationPromises,
+                                        req,
+                                        schemaPath: fieldSchemaPath,
+                                        showHiddenFields,
+                                        siblingData: siblingDoc,
+                                        triggerAccessControl,
+                                        triggerHooks,
+                                        value
+                                    });
+                                    if (hookedValue !== undefined) {
+                                        siblingDoc[field.name][locale] = hookedValue;
+                                    }
+                                })());
+                            await Promise.all(hookPromises);
+                        } else {
+                            const hookedValue = await currentHook({
+                                collection,
+                                context,
+                                currentDepth,
+                                data: doc,
+                                depth,
+                                draft,
+                                fallbackLocale,
+                                field,
+                                fieldPromises,
+                                findMany,
+                                flattenLocales,
+                                global,
+                                locale,
+                                operation: 'read',
+                                originalDoc: doc,
+                                overrideAccess,
+                                path: fieldPath,
+                                populate,
+                                populationPromises,
+                                req,
+                                schemaPath: fieldSchemaPath,
+                                showHiddenFields,
+                                siblingData: siblingDoc,
+                                triggerAccessControl,
+                                triggerHooks,
+                                value: siblingDoc[field.name]
+                            });
+                            if (hookedValue !== undefined) {
+                                siblingDoc[field.name] = hookedValue;
+                            }
+                        }
+                    }, Promise.resolve());
+                }
+                break;
+            }
         case 'tab':
             {
                 let tabDoc = siblingDoc;
+                let tabSelect;
                 if (tabHasName(field)) {
                     tabDoc = siblingDoc[field.name];
-                    if (typeof siblingDoc[field.name] !== 'object') tabDoc = {};
+                    if (typeof siblingDoc[field.name] !== 'object') {
+                        tabDoc = {};
+                    }
+                    if (typeof select?.[field.name] === 'object') {
+                        tabSelect = select?.[field.name];
+                    }
+                } else {
+                    tabSelect = select;
                 }
                 traverseFields({
                     collection,
@@ -391,6 +575,7 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                     currentDepth,
                     depth,
                     doc,
+                    draft,
                     fallbackLocale,
                     fieldPromises,
                     fields: field.fields,
@@ -399,8 +584,13 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                     global,
                     locale,
                     overrideAccess,
+                    path: fieldPath,
+                    populate,
                     populationPromises,
                     req,
+                    schemaPath: fieldSchemaPath,
+                    select: tabSelect,
+                    selectMode,
                     showHiddenFields,
                     siblingDoc: tabDoc,
                     triggerAccessControl,
@@ -416,6 +606,7 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                     currentDepth,
                     depth,
                     doc,
+                    draft,
                     fallbackLocale,
                     fieldPromises,
                     fields: field.tabs.map((tab)=>({
@@ -427,8 +618,13 @@ export const promise = async ({ collection, context, currentDepth, depth, doc, f
                     global,
                     locale,
                     overrideAccess,
+                    path: fieldPath,
+                    populate,
                     populationPromises,
                     req,
+                    schemaPath: fieldSchemaPath,
+                    select,
+                    selectMode,
                     showHiddenFields,
                     siblingDoc,
                     triggerAccessControl,