@payloadcms/graphql 3.0.0-canary.c13f9ba → 3.0.0-canary.c696728

package/dist/schema/buildObjectType.d.ts

@@ -1,6 +1,5 @@
 import type { GraphQLFieldConfig } from 'graphql';
-import type { GraphQLInfo } from 'payload/config';
-import type { Field, SanitizedConfig } from 'payload/types';
+import type { Field, GraphQLInfo, SanitizedConfig } from 'payload';
 import { GraphQLObjectType } from 'graphql';
 export type ObjectTypeConfig = {
     [path: string]: GraphQLFieldConfig<any, any>;

package/dist/schema/buildObjectType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildObjectType.d.ts","sourceRoot":"","sources":["../../src/schema/buildObjectType.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAe,MAAM,SAAS,CAAA;AAC9D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAA;AACjD,OAAO,KAAK,EAQV,KAAK,EAUL,eAAe,EAMhB,MAAM,eAAe,CAAA;AAEtB,OAAO,EAOL,iBAAiB,EAGlB,MAAM,SAAS,CAAA;AA2BhB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;CAC7C,CAAA;AAED,KAAK,IAAI,GAAG;IACV,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAC7B,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,WAAW,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,UAAe,EACf,MAAM,EACN,MAAM,EACN,aAAa,EACb,aAAa,EACb,UAAU,GACX,EAAE,IAAI,GAAG,iBAAiB,CA4lB1B"}
+{"version":3,"file":"buildObjectType.d.ts","sourceRoot":"","sources":["../../src/schema/buildObjectType.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAe,MAAM,SAAS,CAAA;AAC9D,OAAO,KAAK,EAQV,KAAK,EACL,WAAW,EAWX,eAAe,EAMhB,MAAM,SAAS,CAAA;AAEhB,OAAO,EAOL,iBAAiB,EAGlB,MAAM,SAAS,CAAA;AAchB,MAAM,MAAM,gBAAgB,GAAG;IAC7B,CAAC,IAAI,EAAE,MAAM,GAAG,kBAAkB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;CAC7C,CAAA;AAED,KAAK,IAAI,GAAG;IACV,UAAU,CAAC,EAAE,gBAAgB,CAAA;IAC7B,MAAM,EAAE,eAAe,CAAA;IACvB,MAAM,EAAE,KAAK,EAAE,CAAA;IACf,aAAa,CAAC,EAAE,OAAO,CAAA;IACvB,aAAa,EAAE,WAAW,CAAA;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,wBAAgB,eAAe,CAAC,EAC9B,IAAI,EACJ,UAAe,EACf,MAAM,EACN,MAAM,EACN,aAAa,EACb,aAAa,EACb,UAAU,GACX,EAAE,IAAI,GAAG,iBAAiB,CAwzB1B"}

package/dist/schema/buildObjectType.js

@@ -1,14 +1,13 @@
-/* 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';
-import { tabHasName } from 'payload/types';
-import { createDataloaderCacheKey, toWords } from 'payload/utilities';
+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 buildWhereInputType from './buildWhereInputType.js';
-import isFieldNullable from './isFieldNullable.js';
-import withNullableType from './withNullableType.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)=>{
@@ -94,7 +93,9 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
             }),
         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 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
             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 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
             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 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
                         value: {
                             type: new GraphQLUnionType({
                                 name: relationshipName,
-                                resolveType (data, { req }) {
+                                resolveType (data) {
                                     return graphqlResult.collections[data.collection].graphQL.type.name;
                                 },
                                 types
@@ -210,7 +274,7 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
             const relationshipArgs = {};
             const relationsUseDrafts = (Array.isArray(relationTo) ? relationTo : [
                 relationTo
-            ]).some((relation)=>graphqlResult.collections[relation].config.versions?.drafts);
+            ]).filter((relation)=>graphQLCollections.some((collection)=>collection.slug === relation)).some((relation)=>graphqlResult.collections[relation].config.versions?.drafts);
             if (relationsUseDrafts) {
                 relationshipArgs.draft = {
                     type: GraphQLBoolean
@@ -242,33 +306,35 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
                         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: collectionSlug,
-                                currentDepth: 0,
-                                depth: 0,
-                                docID: id,
-                                draft,
-                                fallbackLocale,
-                                locale,
-                                overrideAccess: false,
-                                showHiddenFields: false,
-                                transactionID: context.req.transactionID
-                            }));
-                            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;
+                                    }
                                 }
                             }
                         };
@@ -286,29 +352,31 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
                         relatedCollectionSlug = value.relationTo;
                     }
                     if (id) {
-                        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
-                                    }
-                                };
+                        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;
                     }
@@ -331,7 +399,13 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
                     },
                     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.');
                         }
@@ -368,7 +442,9 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
             }),
         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)=>{
@@ -408,7 +484,13 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
                     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
+                                };
+                            }
                         }
                     };
                 }
@@ -416,7 +498,9 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
                     ...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)
                 };
@@ -435,34 +519,125 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
             }),
         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(createDataloaderCacheKey({
                             collectionSlug: relatedCollectionSlug,
@@ -476,22 +651,26 @@ export function buildObjectType({ name, baseFields = {}, config, fields, forceNu
                             showHiddenFields: false,
                             transactionID: context.req.transactionID
                         }));
-                        return relatedDocument || null;
+                        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
             };
         }
     };