@payloadcms/graphql 3.0.0-beta.11 → 3.0.0-beta.111

package/dist/schema/buildObjectType.js

@@ -1,15 +1,14 @@
-/* eslint-disable @typescript-eslint/no-use-before-define */ /* eslint-disable no-await-in-loop */ /* eslint-disable no-restricted-syntax */ import { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, GraphQLUnionType } from 'graphql';
+import { GraphQLBoolean, GraphQLEnumType, GraphQLFloat, GraphQLInt, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLString, GraphQLUnionType } from 'graphql';
 import { DateTimeResolver, EmailAddressResolver } from 'graphql-scalars';
-/* eslint-disable no-use-before-define */ import { GraphQLJSON } from 'graphql-type-json';
-import { tabHasName } from 'payload/types';
-import { toWords } from 'payload/utilities';
-import combineParentName from '../utilities/combineParentName.js';
-import formatName from '../utilities/formatName.js';
-import formatOptions from '../utilities/formatOptions.js';
-import buildWhereInputType from './buildWhereInputType.js';
-import isFieldNullable from './isFieldNullable.js';
-import withNullableType from './withNullableType.js';
-function buildObjectType({ name, baseFields = {}, config, fields, forceNullable, graphqlResult, parentName }) {
+import { combineQueries, createDataloaderCacheKey, MissingEditorProp, toWords } from 'payload';
+import { tabHasName } from 'payload/shared';
+import { GraphQLJSON } from '../packages/graphql-type-json/index.js';
+import { combineParentName } from '../utilities/combineParentName.js';
+import { formatName } from '../utilities/formatName.js';
+import { formatOptions } from '../utilities/formatOptions.js';
+import { isFieldNullable } from './isFieldNullable.js';
+import { withNullableType } from './withNullableType.js';
+export function buildObjectType({ name, baseFields = {}, config, fields, forceNullable, graphqlResult, parentName }) {
     const fieldToSchemaMap = {
         array: (objectTypeConfig, field)=>{
             const interfaceName = field?.interfaceName || combineParentName(parentName, toWords(field.name, true));
@@ -94,7 +93,9 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
             }),
         collapsible: (objectTypeConfig, field)=>field.fields.reduce((objectTypeConfigWithCollapsibleFields, subField)=>{
                 const addSubField = fieldToSchemaMap[subField.type];
-                if (addSubField) return addSubField(objectTypeConfigWithCollapsibleFields, subField);
+                if (addSubField) {
+                    return addSubField(objectTypeConfigWithCollapsibleFields, subField);
+                }
                 return objectTypeConfigWithCollapsibleFields;
             }, objectTypeConfig),
         date: (objectTypeConfig, field)=>({
@@ -130,10 +131,71 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
             return {
                 ...objectTypeConfig,
                 [field.name]: {
-                    type: graphqlResult.types.groupTypes[interfaceName]
+                    type: graphqlResult.types.groupTypes[interfaceName],
+                    resolve: (parent, args, context)=>{
+                        return {
+                            ...parent[field.name],
+                            _id: parent._id ?? parent.id
+                        };
+                    }
                 }
             };
         },
+        join: (objectTypeConfig, field)=>{
+            const joinName = combineParentName(parentName, toWords(field.name, true));
+            const joinType = {
+                type: new GraphQLObjectType({
+                    name: joinName,
+                    fields: {
+                        docs: {
+                            type: new GraphQLList(graphqlResult.collections[field.collection].graphQL.type)
+                        },
+                        hasNextPage: {
+                            type: GraphQLBoolean
+                        }
+                    }
+                }),
+                args: {
+                    limit: {
+                        type: GraphQLInt
+                    },
+                    sort: {
+                        type: GraphQLString
+                    },
+                    where: {
+                        type: graphqlResult.collections[field.collection].graphQL.whereInputType
+                    }
+                },
+                extensions: {
+                    complexity: 10
+                },
+                async resolve (parent, args, context) {
+                    const { collection } = field;
+                    const { limit, sort, where } = args;
+                    const { req } = context;
+                    const fullWhere = combineQueries(where, {
+                        [field.on]: {
+                            equals: parent._id ?? parent.id
+                        }
+                    });
+                    const results = await req.payload.find({
+                        collection,
+                        depth: 0,
+                        fallbackLocale: req.fallbackLocale,
+                        limit,
+                        locale: req.locale,
+                        req,
+                        sort,
+                        where: fullWhere
+                    });
+                    return results;
+                }
+            };
+            return {
+                ...objectTypeConfig,
+                [field.name]: joinType
+            };
+        },
         json: (objectTypeConfig, field)=>({
                 ...objectTypeConfig,
                 [field.name]: {
@@ -171,17 +233,19 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
             const relationshipName = combineParentName(parentName, toWords(field.name, true));
             let type;
             let relationToType = null;
+            const graphQLCollections = config.collections.filter((collectionConfig)=>collectionConfig.graphQL !== false);
             if (Array.isArray(relationTo)) {
                 relationToType = new GraphQLEnumType({
                     name: `${relationshipName}_RelationTo`,
-                    values: relationTo.reduce((relations, relation)=>({
+                    values: relationTo.filter((relation)=>graphQLCollections.some((collection)=>collection.slug === relation)).reduce((relations, relation)=>({
                             ...relations,
                             [formatName(relation)]: {
                                 value: relation
                             }
                         }), {})
                 });
-                const types = relationTo.map((relation)=>graphqlResult.collections[relation].graphQL.type);
+                // Only pass collections that are GraphQL enabled
+                const types = relationTo.filter((relation)=>graphQLCollections.some((collection)=>collection.slug === relation)).map((relation)=>graphqlResult.collections[relation]?.graphQL.type);
                 type = new GraphQLObjectType({
                     name: `${relationshipName}_Relationship`,
                     fields: {
@@ -191,7 +255,7 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
                         value: {
                             type: new GraphQLUnionType({
                                 name: relationshipName,
-                                async resolveType (data, { req }) {
+                                resolveType (data) {
                                     return graphqlResult.collections[data.collection].graphQL.type.name;
                                 },
                                 types
@@ -208,6 +272,14 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
             // that is currently being created.
             type = type || newlyCreatedBlockType;
             const relationshipArgs = {};
+            const relationsUseDrafts = (Array.isArray(relationTo) ? relationTo : [
+                relationTo
+            ]).filter((relation)=>graphQLCollections.some((collection)=>collection.slug === relation)).some((relation)=>graphqlResult.collections[relation].config.versions?.drafts);
+            if (relationsUseDrafts) {
+                relationshipArgs.draft = {
+                    type: GraphQLBoolean
+                };
+            }
             if (config.localization) {
                 relationshipArgs.locale = {
                     type: graphqlResult.types.localeInputType
@@ -227,38 +299,42 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
                     const locale = args.locale || context.req.locale;
                     const fallbackLocale = args.fallbackLocale || context.req.fallbackLocale;
                     let relatedCollectionSlug = field.relationTo;
+                    const draft = Boolean(args.draft ?? context.req.query?.draft);
                     if (hasManyValues) {
                         const results = [];
                         const resultPromises = [];
                         const createPopulationPromise = async (relatedDoc, i)=>{
                             let id = relatedDoc;
                             let collectionSlug = field.relationTo;
-                            if (isRelatedToManyCollections) {
-                                collectionSlug = relatedDoc.relationTo;
-                                id = relatedDoc.value;
-                            }
-                            const result = await context.req.payloadDataLoader.load(JSON.stringify([
-                                context.req.transactionID,
-                                collectionSlug,
-                                id,
-                                0,
-                                0,
-                                locale,
-                                fallbackLocale,
-                                false,
-                                false
-                            ]));
-                            if (result) {
+                            if (graphQLCollections.some((collection)=>collection.slug === collectionSlug)) {
                                 if (isRelatedToManyCollections) {
-                                    results[i] = {
-                                        relationTo: collectionSlug,
-                                        value: {
-                                            ...result,
-                                            collection: collectionSlug
-                                        }
-                                    };
-                                } else {
-                                    results[i] = result;
+                                    collectionSlug = relatedDoc.relationTo;
+                                    id = relatedDoc.value;
+                                }
+                                const result = await context.req.payloadDataLoader.load(createDataloaderCacheKey({
+                                    collectionSlug: collectionSlug,
+                                    currentDepth: 0,
+                                    depth: 0,
+                                    docID: id,
+                                    draft,
+                                    fallbackLocale,
+                                    locale,
+                                    overrideAccess: false,
+                                    showHiddenFields: false,
+                                    transactionID: context.req.transactionID
+                                }));
+                                if (result) {
+                                    if (isRelatedToManyCollections) {
+                                        results[i] = {
+                                            relationTo: collectionSlug,
+                                            value: {
+                                                ...result,
+                                                collection: collectionSlug
+                                            }
+                                        };
+                                    } else {
+                                        results[i] = result;
+                                    }
                                 }
                             }
                         };
@@ -276,28 +352,31 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
                         relatedCollectionSlug = value.relationTo;
                     }
                     if (id) {
-                        const relatedDocument = await context.req.payloadDataLoader.load(JSON.stringify([
-                            context.req.transactionID,
-                            relatedCollectionSlug,
-                            id,
-                            0,
-                            0,
-                            locale,
-                            fallbackLocale,
-                            false,
-                            false
-                        ]));
-                        if (relatedDocument) {
-                            if (isRelatedToManyCollections) {
-                                return {
-                                    relationTo: relatedCollectionSlug,
-                                    value: {
-                                        ...relatedDocument,
-                                        collection: relatedCollectionSlug
-                                    }
-                                };
+                        if (graphQLCollections.some((collection)=>collection.slug === relatedCollectionSlug)) {
+                            const relatedDocument = await context.req.payloadDataLoader.load(createDataloaderCacheKey({
+                                collectionSlug: relatedCollectionSlug,
+                                currentDepth: 0,
+                                depth: 0,
+                                docID: id,
+                                draft,
+                                fallbackLocale,
+                                locale,
+                                overrideAccess: false,
+                                showHiddenFields: false,
+                                transactionID: context.req.transactionID
+                            }));
+                            if (relatedDocument) {
+                                if (isRelatedToManyCollections) {
+                                    return {
+                                        relationTo: relatedCollectionSlug,
+                                        value: {
+                                            ...relatedDocument,
+                                            collection: relatedCollectionSlug
+                                        }
+                                    };
+                                }
+                                return relatedDocument;
                             }
-                            return relatedDocument;
                         }
                         return null;
                     }
@@ -320,26 +399,42 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
                     },
                     async resolve (parent, args, context) {
                         let depth = config.defaultDepth;
-                        if (typeof args.depth !== 'undefined') depth = args.depth;
+                        if (typeof args.depth !== 'undefined') {
+                            depth = args.depth;
+                        }
+                        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;
                         // RichText fields have their own depth argument in GraphQL.
                         // This is why the populationPromise (which populates richtext fields like uploads and relationships)
                         // is run here again, with the provided depth.
                         // In the graphql find.ts resolver, the depth is then hard-coded to 0.
                         // Effectively, this means that the populationPromise for GraphQL is only run here, and not in the find.ts resolver / normal population promise.
-                        if (editor?.populationPromise) {
-                            await editor?.populationPromise({
+                        if (editor?.graphQLPopulationPromises) {
+                            const fieldPromises = [];
+                            const populationPromises = [];
+                            const populateDepth = field?.maxDepth !== undefined && field?.maxDepth < depth ? field?.maxDepth : depth;
+                            editor?.graphQLPopulationPromises({
                                 context,
-                                depth,
+                                depth: populateDepth,
+                                draft: args.draft,
                                 field,
+                                fieldPromises,
                                 findMany: false,
                                 flattenLocales: false,
                                 overrideAccess: false,
-                                populationPromises: [],
+                                populationPromises,
                                 req: context.req,
                                 showHiddenFields: false,
                                 siblingDoc: parent
                             });
+                            await Promise.all(fieldPromises);
+                            await Promise.all(populationPromises);
                         }
                         return parent[field.name];
                     }
@@ -347,7 +442,9 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
             }),
         row: (objectTypeConfig, field)=>field.fields.reduce((objectTypeConfigWithRowFields, subField)=>{
                 const addSubField = fieldToSchemaMap[subField.type];
-                if (addSubField) return addSubField(objectTypeConfigWithRowFields, subField);
+                if (addSubField) {
+                    return addSubField(objectTypeConfigWithRowFields, subField);
+                }
                 return objectTypeConfigWithRowFields;
             }, objectTypeConfig),
         select: (objectTypeConfig, field)=>{
@@ -387,7 +484,13 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
                     return {
                         ...tabSchema,
                         [tab.name]: {
-                            type: graphqlResult.types.groupTypes[interfaceName]
+                            type: graphqlResult.types.groupTypes[interfaceName],
+                            resolve (parent, args, context) {
+                                return {
+                                    ...parent[tab.name],
+                                    _id: parent._id ?? parent.id
+                                };
+                            }
                         }
                     };
                 }
@@ -395,7 +498,9 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
                     ...tabSchema,
                     ...tab.fields.reduce((subFieldSchema, subField)=>{
                         const addSubField = fieldToSchemaMap[subField.type];
-                        if (addSubField) return addSubField(subFieldSchema, subField);
+                        if (addSubField) {
+                            return addSubField(subFieldSchema, subField);
+                        }
                         return subFieldSchema;
                     }, tabSchema)
                 };
@@ -414,61 +519,158 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
             }),
         upload: (objectTypeConfig, field)=>{
             const { relationTo } = field;
-            const uploadName = combineParentName(parentName, toWords(field.name, true));
+            const isRelatedToManyCollections = Array.isArray(relationTo);
+            const hasManyValues = field.hasMany;
+            const relationshipName = combineParentName(parentName, toWords(field.name, true));
+            let type;
+            let relationToType = null;
+            if (Array.isArray(relationTo)) {
+                relationToType = new GraphQLEnumType({
+                    name: `${relationshipName}_RelationTo`,
+                    values: relationTo.reduce((relations, relation)=>({
+                            ...relations,
+                            [formatName(relation)]: {
+                                value: relation
+                            }
+                        }), {})
+                });
+                const types = relationTo.map((relation)=>graphqlResult.collections[relation].graphQL.type);
+                type = new GraphQLObjectType({
+                    name: `${relationshipName}_Relationship`,
+                    fields: {
+                        relationTo: {
+                            type: relationToType
+                        },
+                        value: {
+                            type: new GraphQLUnionType({
+                                name: relationshipName,
+                                resolveType (data) {
+                                    return graphqlResult.collections[data.collection].graphQL.type.name;
+                                },
+                                types
+                            })
+                        }
+                    }
+                });
+            } else {
+                ({ type } = graphqlResult.collections[relationTo].graphQL);
+            }
             // If the relationshipType is undefined at this point,
             // it can be assumed that this blockType can have a relationship
             // to itself. Therefore, we set the relationshipType equal to the blockType
             // that is currently being created.
-            const type = withNullableType(field, graphqlResult.collections[relationTo].graphQL.type || newlyCreatedBlockType, forceNullable);
-            const uploadArgs = {};
+            type = type || newlyCreatedBlockType;
+            const relationshipArgs = {};
+            const relationsUseDrafts = (Array.isArray(relationTo) ? relationTo : [
+                relationTo
+            ]).some((relation)=>graphqlResult.collections[relation].config.versions?.drafts);
+            if (relationsUseDrafts) {
+                relationshipArgs.draft = {
+                    type: GraphQLBoolean
+                };
+            }
             if (config.localization) {
-                uploadArgs.locale = {
+                relationshipArgs.locale = {
                     type: graphqlResult.types.localeInputType
                 };
-                uploadArgs.fallbackLocale = {
+                relationshipArgs.fallbackLocale = {
                     type: graphqlResult.types.fallbackLocaleInputType
                 };
             }
-            const relatedCollectionSlug = field.relationTo;
-            const upload = {
-                type,
-                args: uploadArgs,
+            const relationship = {
+                type: withNullableType(field, hasManyValues ? new GraphQLList(new GraphQLNonNull(type)) : type, forceNullable),
+                args: relationshipArgs,
                 extensions: {
-                    complexity: 20
+                    complexity: 10
                 },
                 async resolve (parent, args, context) {
                     const value = parent[field.name];
                     const locale = args.locale || context.req.locale;
                     const fallbackLocale = args.fallbackLocale || context.req.fallbackLocale;
-                    const id = value;
+                    let relatedCollectionSlug = field.relationTo;
+                    const draft = Boolean(args.draft ?? context.req.query?.draft);
+                    if (hasManyValues) {
+                        const results = [];
+                        const resultPromises = [];
+                        const createPopulationPromise = async (relatedDoc, i)=>{
+                            let id = relatedDoc;
+                            let collectionSlug = field.relationTo;
+                            if (isRelatedToManyCollections) {
+                                collectionSlug = relatedDoc.relationTo;
+                                id = relatedDoc.value;
+                            }
+                            const result = await context.req.payloadDataLoader.load(createDataloaderCacheKey({
+                                collectionSlug,
+                                currentDepth: 0,
+                                depth: 0,
+                                docID: id,
+                                draft,
+                                fallbackLocale,
+                                locale,
+                                overrideAccess: false,
+                                showHiddenFields: false,
+                                transactionID: context.req.transactionID
+                            }));
+                            if (result) {
+                                if (isRelatedToManyCollections) {
+                                    results[i] = {
+                                        relationTo: collectionSlug,
+                                        value: {
+                                            ...result,
+                                            collection: collectionSlug
+                                        }
+                                    };
+                                } else {
+                                    results[i] = result;
+                                }
+                            }
+                        };
+                        if (value) {
+                            value.forEach((relatedDoc, i)=>{
+                                resultPromises.push(createPopulationPromise(relatedDoc, i));
+                            });
+                        }
+                        await Promise.all(resultPromises);
+                        return results;
+                    }
+                    let id = value;
+                    if (isRelatedToManyCollections && value) {
+                        id = value.value;
+                        relatedCollectionSlug = value.relationTo;
+                    }
                     if (id) {
-                        const relatedDocument = await context.req.payloadDataLoader.load(JSON.stringify([
-                            context.req.transactionID,
-                            relatedCollectionSlug,
-                            id,
-                            0,
-                            0,
-                            locale,
+                        const relatedDocument = await context.req.payloadDataLoader.load(createDataloaderCacheKey({
+                            collectionSlug: relatedCollectionSlug,
+                            currentDepth: 0,
+                            depth: 0,
+                            docID: id,
+                            draft,
                             fallbackLocale,
-                            false,
-                            false
-                        ]));
-                        return relatedDocument || null;
+                            locale,
+                            overrideAccess: false,
+                            showHiddenFields: false,
+                            transactionID: context.req.transactionID
+                        }));
+                        if (relatedDocument) {
+                            if (isRelatedToManyCollections) {
+                                return {
+                                    relationTo: relatedCollectionSlug,
+                                    value: {
+                                        ...relatedDocument,
+                                        collection: relatedCollectionSlug
+                                    }
+                                };
+                            }
+                            return relatedDocument;
+                        }
+                        return null;
                     }
                     return null;
                 }
             };
-            const whereFields = graphqlResult.collections[relationTo].config.fields;
-            upload.args.where = {
-                type: buildWhereInputType({
-                    name: uploadName,
-                    fields: whereFields,
-                    parentName: uploadName
-                })
-            };
             return {
                 ...objectTypeConfig,
-                [field.name]: upload
+                [field.name]: relationship
             };
         }
     };
@@ -488,6 +690,5 @@ function buildObjectType({ name, baseFields = {}, config, fields, forceNullable,
     const newlyCreatedBlockType = new GraphQLObjectType(objectSchema);
     return newlyCreatedBlockType;
 }
-export default buildObjectType;
 
 //# sourceMappingURL=buildObjectType.js.map