@strapi/plugin-graphql 0.0.0-experimental.62ebf57bb35846666febb5ee2078fe02fe990f57 → 0.0.0-experimental.6340da17068c3bed7fb006e7bcc554c71129e282

package/dist/server/services/builders/resolvers/query.mjs

@@ -0,0 +1,60 @@
+import { omit } from 'lodash/fp';
+import { mergePublicationFilterFromGraphQLArgs } from './merge-publication-args.mjs';
+
+/** Merge sanitized query with resolver args so GraphQL-coerced publication args are not dropped. */ const mergeDocumentListParams = (sanitizedQuery, args)=>{
+    const { status, ...rest } = sanitizedQuery;
+    const merged = {
+        ...rest,
+        status: status ?? 'published'
+    };
+    const { publicationFilter } = mergePublicationFilterFromGraphQLArgs(args);
+    if (publicationFilter !== undefined) {
+        merged.publicationFilter = publicationFilter;
+    }
+    return merged;
+};
+var queriesResolvers = (({ strapi })=>({
+        buildQueriesResolvers ({ contentType }) {
+            const { uid } = contentType;
+            return {
+                async findMany (parent, args, ctx) {
+                    await strapi.contentAPI.validate.query(args, contentType, {
+                        auth: ctx?.state?.auth
+                    });
+                    const sanitizedQuery = await strapi.contentAPI.sanitize.query(args, contentType, {
+                        auth: ctx?.state?.auth
+                    });
+                    return strapi.documents(uid).findMany(mergeDocumentListParams(sanitizedQuery, args));
+                },
+                async findFirst (parent, args, ctx) {
+                    await strapi.contentAPI.validate.query(args, contentType, {
+                        auth: ctx?.state?.auth
+                    });
+                    const sanitizedQuery = await strapi.contentAPI.sanitize.query(args, contentType, {
+                        auth: ctx?.state?.auth
+                    });
+                    return strapi.documents(uid).findFirst(mergeDocumentListParams(sanitizedQuery, args));
+                },
+                async findOne (parent, args, ctx) {
+                    const { documentId } = args;
+                    await strapi.contentAPI.validate.query(args, contentType, {
+                        auth: ctx?.state?.auth
+                    });
+                    const sanitizedQuery = await strapi.contentAPI.sanitize.query(args, contentType, {
+                        auth: ctx?.state?.auth
+                    });
+                    const merged = mergeDocumentListParams(omit([
+                        'id',
+                        'documentId'
+                    ], sanitizedQuery), args);
+                    return strapi.documents(uid).findOne({
+                        ...merged,
+                        documentId
+                    });
+                }
+            };
+        }
+    }));
+
+export { queriesResolvers as default };
+//# sourceMappingURL=query.mjs.map

package/dist/server/services/builders/resolvers/query.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.mjs","sources":["../../../../../server/src/services/builders/resolvers/query.ts"],"sourcesContent":["import { omit } from 'lodash/fp';\nimport type { Schema } from '@strapi/types';\nimport type { Context } from '../../types';\n\nimport { mergePublicationFilterFromGraphQLArgs } from './merge-publication-args';\n\n/** Merge sanitized query with resolver args so GraphQL-coerced publication args are not dropped. */\nconst mergeDocumentListParams = (\n  sanitizedQuery: Record<string, unknown>,\n  args: Record<string, unknown>\n) => {\n  const { status, ...rest } = sanitizedQuery;\n\n  const merged: Record<string, unknown> = {\n    ...rest,\n    status: (status as 'draft' | 'published' | undefined) ?? 'published',\n  };\n\n  const { publicationFilter } = mergePublicationFilterFromGraphQLArgs(args);\n  if (publicationFilter !== undefined) {\n    merged.publicationFilter = publicationFilter;\n  }\n\n  return merged;\n};\n\nexport default ({ strapi }: Context) => ({\n  buildQueriesResolvers({ contentType }: { contentType: Schema.ContentType }) {\n    const { uid } = contentType;\n\n    return {\n      async findMany(parent: any, args: any, ctx: any) {\n        await strapi.contentAPI.validate.query(args, contentType, {\n          auth: ctx?.state?.auth,\n        });\n\n        const sanitizedQuery = (await strapi.contentAPI.sanitize.query(args, contentType, {\n          auth: ctx?.state?.auth,\n        })) as Record<string, unknown>;\n\n        return strapi.documents!(uid).findMany(\n          mergeDocumentListParams(sanitizedQuery, args) as any\n        );\n      },\n\n      async findFirst(parent: any, args: any, ctx: any) {\n        await strapi.contentAPI.validate.query(args, contentType, {\n          auth: ctx?.state?.auth,\n        });\n\n        const sanitizedQuery = (await strapi.contentAPI.sanitize.query(args, contentType, {\n          auth: ctx?.state?.auth,\n        })) as Record<string, unknown>;\n\n        return strapi.documents!(uid).findFirst(\n          mergeDocumentListParams(sanitizedQuery, args) as any\n        );\n      },\n\n      async findOne(parent: any, args: any, ctx: any) {\n        const { documentId } = args;\n\n        await strapi.contentAPI.validate.query(args, contentType, {\n          auth: ctx?.state?.auth,\n        });\n\n        const sanitizedQuery = (await strapi.contentAPI.sanitize.query(args, contentType, {\n          auth: ctx?.state?.auth,\n        })) as Record<string, unknown>;\n\n        const merged = mergeDocumentListParams(\n          omit(['id', 'documentId'], sanitizedQuery) as Record<string, unknown>,\n          args\n        );\n\n        return strapi.documents!(uid).findOne({ ...merged, documentId } as any);\n      },\n    };\n  },\n});\n"],"names":["mergeDocumentListParams","sanitizedQuery","args","status","rest","merged","publicationFilter","mergePublicationFilterFromGraphQLArgs","undefined","strapi","buildQueriesResolvers","contentType","uid","findMany","parent","ctx","contentAPI","validate","query","auth","state","sanitize","documents","findFirst","findOne","documentId","omit"],"mappings":"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"}

package/dist/server/services/builders/response-collection.js

@@ -0,0 +1,50 @@
+'use strict';
+
+var nexus = require('nexus');
+var fp = require('lodash/fp');
+
+var responseCollection = (({ strapi })=>{
+    const { service: getService } = strapi.plugin('graphql');
+    const { naming } = getService('utils');
+    const { RESPONSE_COLLECTION_META_TYPE_NAME, PAGINATION_TYPE_NAME } = getService('constants');
+    return {
+        /**
+     * Build a type definition for a content API collection response for a given content type
+     * @param {Schema.ContentType} contentType The content type which will be used to build its content API response definition
+     * @return {NexusObjectTypeDef}
+     */ buildResponseCollectionDefinition (contentType) {
+            const name = naming.getEntityResponseCollectionName(contentType);
+            const typeName = naming.getTypeName(contentType);
+            const { resolvePagination } = getService('builders').get('content-api');
+            return nexus.objectType({
+                name,
+                definition (t) {
+                    // NOTE: add edges & cursor based pagination to support the relay spec in a later version
+                    t.nonNull.list.field('nodes', {
+                        type: nexus.nonNull(typeName),
+                        resolve: fp.pipe(fp.prop('nodes'), fp.defaultTo([]))
+                    });
+                    t.nonNull.field('pageInfo', {
+                        type: PAGINATION_TYPE_NAME,
+                        resolve: resolvePagination
+                    });
+                    if (strapi.plugin('graphql').config('v4CompatibilityMode', false)) {
+                        t.nonNull.list.field('data', {
+                            deprecation: 'Use `nodes` field instead',
+                            type: nexus.nonNull(typeName),
+                            resolve: fp.pipe(fp.prop('nodes'), fp.defaultTo([]))
+                        });
+                        t.nonNull.field('meta', {
+                            deprecation: 'Use the `pageInfo` field instead',
+                            type: RESPONSE_COLLECTION_META_TYPE_NAME,
+                            resolve: fp.identity
+                        });
+                    }
+                }
+            });
+        }
+    };
+});
+
+module.exports = responseCollection;
+//# sourceMappingURL=response-collection.js.map

package/dist/server/services/builders/response-collection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-collection.js","sources":["../../../../server/src/services/builders/response-collection.ts"],"sourcesContent":["import { objectType, nonNull } from 'nexus';\nimport { defaultTo, prop, pipe, identity } from 'lodash/fp';\nimport type { Schema } from '@strapi/types';\nimport type { Context } from '../types';\n\nexport default ({ strapi }: Context) => {\n  const { service: getService } = strapi.plugin('graphql');\n\n  const { naming } = getService('utils');\n  const { RESPONSE_COLLECTION_META_TYPE_NAME, PAGINATION_TYPE_NAME } = getService('constants');\n\n  return {\n    /**\n     * Build a type definition for a content API collection response for a given content type\n     * @param {Schema.ContentType} contentType The content type which will be used to build its content API response definition\n     * @return {NexusObjectTypeDef}\n     */\n    buildResponseCollectionDefinition(contentType: Schema.ContentType) {\n      const name = naming.getEntityResponseCollectionName(contentType);\n      const typeName = naming.getTypeName(contentType);\n      const { resolvePagination } = getService('builders').get('content-api');\n\n      return objectType({\n        name,\n        definition(t) {\n          // NOTE: add edges & cursor based pagination to support the relay spec in a later version\n\n          t.nonNull.list.field('nodes', {\n            type: nonNull(typeName),\n            resolve: pipe(prop('nodes'), defaultTo([])),\n          });\n\n          t.nonNull.field('pageInfo', {\n            type: PAGINATION_TYPE_NAME,\n            resolve: resolvePagination,\n          });\n\n          if (strapi.plugin('graphql').config('v4CompatibilityMode', false)) {\n            t.nonNull.list.field('data', {\n              deprecation: 'Use `nodes` field instead',\n              type: nonNull(typeName),\n              resolve: pipe(prop('nodes'), defaultTo([])),\n            });\n\n            t.nonNull.field('meta', {\n              deprecation: 'Use the `pageInfo` field instead',\n              type: RESPONSE_COLLECTION_META_TYPE_NAME,\n              resolve: identity,\n            });\n          }\n        },\n      });\n    },\n  };\n};\n"],"names":["strapi","service","getService","plugin","naming","RESPONSE_COLLECTION_META_TYPE_NAME","PAGINATION_TYPE_NAME","buildResponseCollectionDefinition","contentType","name","getEntityResponseCollectionName","typeName","getTypeName","resolvePagination","get","objectType","definition","t","nonNull","list","field","type","resolve","pipe","prop","defaultTo","config","deprecation","identity"],"mappings":";;;;;AAKA,yBAAe,CAAA,CAAC,EAAEA,MAAM,EAAW,GAAA;AACjC,IAAA,MAAM,EAAEC,OAAAA,EAASC,UAAU,EAAE,GAAGF,MAAAA,CAAOG,MAAM,CAAC,SAAA,CAAA;AAE9C,IAAA,MAAM,EAAEC,MAAM,EAAE,GAAGF,UAAAA,CAAW,OAAA,CAAA;AAC9B,IAAA,MAAM,EAAEG,kCAAkC,EAAEC,oBAAoB,EAAE,GAAGJ,UAAAA,CAAW,WAAA,CAAA;IAEhF,OAAO;AACL;;;;AAIC,QACDK,mCAAkCC,WAA+B,EAAA;YAC/D,MAAMC,IAAAA,GAAOL,MAAAA,CAAOM,+BAA+B,CAACF,WAAAA,CAAAA;YACpD,MAAMG,QAAAA,GAAWP,MAAAA,CAAOQ,WAAW,CAACJ,WAAAA,CAAAA;AACpC,YAAA,MAAM,EAAEK,iBAAiB,EAAE,GAAGX,UAAAA,CAAW,UAAA,CAAA,CAAYY,GAAG,CAAC,aAAA,CAAA;AAEzD,YAAA,OAAOC,gBAAAA,CAAW;AAChBN,gBAAAA,IAAAA;AACAO,gBAAAA,UAAAA,CAAAA,CAAWC,CAAC,EAAA;;AAGVA,oBAAAA,CAAAA,CAAEC,OAAO,CAACC,IAAI,CAACC,KAAK,CAAC,OAAA,EAAS;AAC5BC,wBAAAA,IAAAA,EAAMH,aAAAA,CAAQP,QAAAA,CAAAA;AACdW,wBAAAA,OAAAA,EAASC,OAAAA,CAAKC,OAAAA,CAAK,OAAA,CAAA,EAAUC,YAAAA,CAAU,EAAE,CAAA;AAC3C,qBAAA,CAAA;AAEAR,oBAAAA,CAAAA,CAAEC,OAAO,CAACE,KAAK,CAAC,UAAA,EAAY;wBAC1BC,IAAAA,EAAMf,oBAAAA;wBACNgB,OAAAA,EAAST;AACX,qBAAA,CAAA;AAEA,oBAAA,IAAIb,OAAOG,MAAM,CAAC,WAAWuB,MAAM,CAAC,uBAAuB,KAAA,CAAA,EAAQ;AACjET,wBAAAA,CAAAA,CAAEC,OAAO,CAACC,IAAI,CAACC,KAAK,CAAC,MAAA,EAAQ;4BAC3BO,WAAAA,EAAa,2BAAA;AACbN,4BAAAA,IAAAA,EAAMH,aAAAA,CAAQP,QAAAA,CAAAA;AACdW,4BAAAA,OAAAA,EAASC,OAAAA,CAAKC,OAAAA,CAAK,OAAA,CAAA,EAAUC,YAAAA,CAAU,EAAE,CAAA;AAC3C,yBAAA,CAAA;AAEAR,wBAAAA,CAAAA,CAAEC,OAAO,CAACE,KAAK,CAAC,MAAA,EAAQ;4BACtBO,WAAAA,EAAa,kCAAA;4BACbN,IAAAA,EAAMhB,kCAAAA;4BACNiB,OAAAA,EAASM;AACX,yBAAA,CAAA;AACF,oBAAA;AACF,gBAAA;AACF,aAAA,CAAA;AACF,QAAA;AACF,KAAA;AACF,CAAA;;;;"}

package/dist/server/services/builders/response-collection.mjs

@@ -0,0 +1,48 @@
+import { objectType, nonNull } from 'nexus';
+import { pipe, prop, defaultTo, identity } from 'lodash/fp';
+
+var responseCollection = (({ strapi })=>{
+    const { service: getService } = strapi.plugin('graphql');
+    const { naming } = getService('utils');
+    const { RESPONSE_COLLECTION_META_TYPE_NAME, PAGINATION_TYPE_NAME } = getService('constants');
+    return {
+        /**
+     * Build a type definition for a content API collection response for a given content type
+     * @param {Schema.ContentType} contentType The content type which will be used to build its content API response definition
+     * @return {NexusObjectTypeDef}
+     */ buildResponseCollectionDefinition (contentType) {
+            const name = naming.getEntityResponseCollectionName(contentType);
+            const typeName = naming.getTypeName(contentType);
+            const { resolvePagination } = getService('builders').get('content-api');
+            return objectType({
+                name,
+                definition (t) {
+                    // NOTE: add edges & cursor based pagination to support the relay spec in a later version
+                    t.nonNull.list.field('nodes', {
+                        type: nonNull(typeName),
+                        resolve: pipe(prop('nodes'), defaultTo([]))
+                    });
+                    t.nonNull.field('pageInfo', {
+                        type: PAGINATION_TYPE_NAME,
+                        resolve: resolvePagination
+                    });
+                    if (strapi.plugin('graphql').config('v4CompatibilityMode', false)) {
+                        t.nonNull.list.field('data', {
+                            deprecation: 'Use `nodes` field instead',
+                            type: nonNull(typeName),
+                            resolve: pipe(prop('nodes'), defaultTo([]))
+                        });
+                        t.nonNull.field('meta', {
+                            deprecation: 'Use the `pageInfo` field instead',
+                            type: RESPONSE_COLLECTION_META_TYPE_NAME,
+                            resolve: identity
+                        });
+                    }
+                }
+            });
+        }
+    };
+});
+
+export { responseCollection as default };
+//# sourceMappingURL=response-collection.mjs.map

package/dist/server/services/builders/response-collection.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-collection.mjs","sources":["../../../../server/src/services/builders/response-collection.ts"],"sourcesContent":["import { objectType, nonNull } from 'nexus';\nimport { defaultTo, prop, pipe, identity } from 'lodash/fp';\nimport type { Schema } from '@strapi/types';\nimport type { Context } from '../types';\n\nexport default ({ strapi }: Context) => {\n  const { service: getService } = strapi.plugin('graphql');\n\n  const { naming } = getService('utils');\n  const { RESPONSE_COLLECTION_META_TYPE_NAME, PAGINATION_TYPE_NAME } = getService('constants');\n\n  return {\n    /**\n     * Build a type definition for a content API collection response for a given content type\n     * @param {Schema.ContentType} contentType The content type which will be used to build its content API response definition\n     * @return {NexusObjectTypeDef}\n     */\n    buildResponseCollectionDefinition(contentType: Schema.ContentType) {\n      const name = naming.getEntityResponseCollectionName(contentType);\n      const typeName = naming.getTypeName(contentType);\n      const { resolvePagination } = getService('builders').get('content-api');\n\n      return objectType({\n        name,\n        definition(t) {\n          // NOTE: add edges & cursor based pagination to support the relay spec in a later version\n\n          t.nonNull.list.field('nodes', {\n            type: nonNull(typeName),\n            resolve: pipe(prop('nodes'), defaultTo([])),\n          });\n\n          t.nonNull.field('pageInfo', {\n            type: PAGINATION_TYPE_NAME,\n            resolve: resolvePagination,\n          });\n\n          if (strapi.plugin('graphql').config('v4CompatibilityMode', false)) {\n            t.nonNull.list.field('data', {\n              deprecation: 'Use `nodes` field instead',\n              type: nonNull(typeName),\n              resolve: pipe(prop('nodes'), defaultTo([])),\n            });\n\n            t.nonNull.field('meta', {\n              deprecation: 'Use the `pageInfo` field instead',\n              type: RESPONSE_COLLECTION_META_TYPE_NAME,\n              resolve: identity,\n            });\n          }\n        },\n      });\n    },\n  };\n};\n"],"names":["strapi","service","getService","plugin","naming","RESPONSE_COLLECTION_META_TYPE_NAME","PAGINATION_TYPE_NAME","buildResponseCollectionDefinition","contentType","name","getEntityResponseCollectionName","typeName","getTypeName","resolvePagination","get","objectType","definition","t","nonNull","list","field","type","resolve","pipe","prop","defaultTo","config","deprecation","identity"],"mappings":";;;AAKA,yBAAe,CAAA,CAAC,EAAEA,MAAM,EAAW,GAAA;AACjC,IAAA,MAAM,EAAEC,OAAAA,EAASC,UAAU,EAAE,GAAGF,MAAAA,CAAOG,MAAM,CAAC,SAAA,CAAA;AAE9C,IAAA,MAAM,EAAEC,MAAM,EAAE,GAAGF,UAAAA,CAAW,OAAA,CAAA;AAC9B,IAAA,MAAM,EAAEG,kCAAkC,EAAEC,oBAAoB,EAAE,GAAGJ,UAAAA,CAAW,WAAA,CAAA;IAEhF,OAAO;AACL;;;;AAIC,QACDK,mCAAkCC,WAA+B,EAAA;YAC/D,MAAMC,IAAAA,GAAOL,MAAAA,CAAOM,+BAA+B,CAACF,WAAAA,CAAAA;YACpD,MAAMG,QAAAA,GAAWP,MAAAA,CAAOQ,WAAW,CAACJ,WAAAA,CAAAA;AACpC,YAAA,MAAM,EAAEK,iBAAiB,EAAE,GAAGX,UAAAA,CAAW,UAAA,CAAA,CAAYY,GAAG,CAAC,aAAA,CAAA;AAEzD,YAAA,OAAOC,UAAAA,CAAW;AAChBN,gBAAAA,IAAAA;AACAO,gBAAAA,UAAAA,CAAAA,CAAWC,CAAC,EAAA;;AAGVA,oBAAAA,CAAAA,CAAEC,OAAO,CAACC,IAAI,CAACC,KAAK,CAAC,OAAA,EAAS;AAC5BC,wBAAAA,IAAAA,EAAMH,OAAAA,CAAQP,QAAAA,CAAAA;AACdW,wBAAAA,OAAAA,EAASC,IAAAA,CAAKC,IAAAA,CAAK,OAAA,CAAA,EAAUC,SAAAA,CAAU,EAAE,CAAA;AAC3C,qBAAA,CAAA;AAEAR,oBAAAA,CAAAA,CAAEC,OAAO,CAACE,KAAK,CAAC,UAAA,EAAY;wBAC1BC,IAAAA,EAAMf,oBAAAA;wBACNgB,OAAAA,EAAST;AACX,qBAAA,CAAA;AAEA,oBAAA,IAAIb,OAAOG,MAAM,CAAC,WAAWuB,MAAM,CAAC,uBAAuB,KAAA,CAAA,EAAQ;AACjET,wBAAAA,CAAAA,CAAEC,OAAO,CAACC,IAAI,CAACC,KAAK,CAAC,MAAA,EAAQ;4BAC3BO,WAAAA,EAAa,2BAAA;AACbN,4BAAAA,IAAAA,EAAMH,OAAAA,CAAQP,QAAAA,CAAAA;AACdW,4BAAAA,OAAAA,EAASC,IAAAA,CAAKC,IAAAA,CAAK,OAAA,CAAA,EAAUC,SAAAA,CAAU,EAAE,CAAA;AAC3C,yBAAA,CAAA;AAEAR,wBAAAA,CAAAA,CAAEC,OAAO,CAACE,KAAK,CAAC,MAAA,EAAQ;4BACtBO,WAAAA,EAAa,kCAAA;4BACbN,IAAAA,EAAMhB,kCAAAA;4BACNiB,OAAAA,EAASM;AACX,yBAAA,CAAA;AACF,oBAAA;AACF,gBAAA;AACF,aAAA,CAAA;AACF,QAAA;AACF,KAAA;AACF,CAAA;;;;"}

package/dist/server/services/builders/response.js

@@ -0,0 +1,28 @@
+'use strict';
+
+var nexus = require('nexus');
+var fp = require('lodash/fp');
+
+var response = (({ strapi })=>{
+    const { naming } = strapi.plugin('graphql').service('utils');
+    return {
+        /**
+     * Build a type definition for a content API response for a given content type
+     */ buildResponseDefinition (contentType) {
+            const name = naming.getEntityResponseName(contentType);
+            const typeName = naming.getTypeName(contentType);
+            return nexus.objectType({
+                name,
+                definition (t) {
+                    t.field('data', {
+                        type: typeName,
+                        resolve: fp.prop('value')
+                    });
+                }
+            });
+        }
+    };
+});
+
+module.exports = response;
+//# sourceMappingURL=response.js.map

package/dist/server/services/builders/response.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.js","sources":["../../../../server/src/services/builders/response.ts"],"sourcesContent":["import { objectType } from 'nexus';\nimport { prop } from 'lodash/fp';\nimport type { Schema } from '@strapi/types';\nimport type { Context } from '../types';\n\nexport default ({ strapi }: Context) => {\n  const { naming } = strapi.plugin('graphql').service('utils');\n\n  return {\n    /**\n     * Build a type definition for a content API response for a given content type\n     */\n    buildResponseDefinition(contentType: Schema.ContentType) {\n      const name = naming.getEntityResponseName(contentType);\n      const typeName = naming.getTypeName(contentType);\n\n      return objectType({\n        name,\n\n        definition(t) {\n          t.field('data', {\n            type: typeName,\n\n            resolve: prop('value'),\n          });\n        },\n      });\n    },\n  };\n};\n"],"names":["strapi","naming","plugin","service","buildResponseDefinition","contentType","name","getEntityResponseName","typeName","getTypeName","objectType","definition","t","field","type","resolve","prop"],"mappings":";;;;;AAKA,eAAe,CAAA,CAAC,EAAEA,MAAM,EAAW,GAAA;IACjC,MAAM,EAAEC,MAAM,EAAE,GAAGD,OAAOE,MAAM,CAAC,SAAA,CAAA,CAAWC,OAAO,CAAC,OAAA,CAAA;IAEpD,OAAO;AACL;;AAEC,QACDC,yBAAwBC,WAA+B,EAAA;YACrD,MAAMC,IAAAA,GAAOL,MAAAA,CAAOM,qBAAqB,CAACF,WAAAA,CAAAA;YAC1C,MAAMG,QAAAA,GAAWP,MAAAA,CAAOQ,WAAW,CAACJ,WAAAA,CAAAA;AAEpC,YAAA,OAAOK,gBAAAA,CAAW;AAChBJ,gBAAAA,IAAAA;AAEAK,gBAAAA,UAAAA,CAAAA,CAAWC,CAAC,EAAA;oBACVA,CAAAA,CAAEC,KAAK,CAAC,MAAA,EAAQ;wBACdC,IAAAA,EAAMN,QAAAA;AAENO,wBAAAA,OAAAA,EAASC,OAAAA,CAAK,OAAA;AAChB,qBAAA,CAAA;AACF,gBAAA;AACF,aAAA,CAAA;AACF,QAAA;AACF,KAAA;AACF,CAAA;;;;"}

package/dist/server/services/builders/response.mjs

@@ -0,0 +1,26 @@
+import { objectType } from 'nexus';
+import { prop } from 'lodash/fp';
+
+var response = (({ strapi })=>{
+    const { naming } = strapi.plugin('graphql').service('utils');
+    return {
+        /**
+     * Build a type definition for a content API response for a given content type
+     */ buildResponseDefinition (contentType) {
+            const name = naming.getEntityResponseName(contentType);
+            const typeName = naming.getTypeName(contentType);
+            return objectType({
+                name,
+                definition (t) {
+                    t.field('data', {
+                        type: typeName,
+                        resolve: prop('value')
+                    });
+                }
+            });
+        }
+    };
+});
+
+export { response as default };
+//# sourceMappingURL=response.mjs.map

package/dist/server/services/builders/response.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"response.mjs","sources":["../../../../server/src/services/builders/response.ts"],"sourcesContent":["import { objectType } from 'nexus';\nimport { prop } from 'lodash/fp';\nimport type { Schema } from '@strapi/types';\nimport type { Context } from '../types';\n\nexport default ({ strapi }: Context) => {\n  const { naming } = strapi.plugin('graphql').service('utils');\n\n  return {\n    /**\n     * Build a type definition for a content API response for a given content type\n     */\n    buildResponseDefinition(contentType: Schema.ContentType) {\n      const name = naming.getEntityResponseName(contentType);\n      const typeName = naming.getTypeName(contentType);\n\n      return objectType({\n        name,\n\n        definition(t) {\n          t.field('data', {\n            type: typeName,\n\n            resolve: prop('value'),\n          });\n        },\n      });\n    },\n  };\n};\n"],"names":["strapi","naming","plugin","service","buildResponseDefinition","contentType","name","getEntityResponseName","typeName","getTypeName","objectType","definition","t","field","type","resolve","prop"],"mappings":";;;AAKA,eAAe,CAAA,CAAC,EAAEA,MAAM,EAAW,GAAA;IACjC,MAAM,EAAEC,MAAM,EAAE,GAAGD,OAAOE,MAAM,CAAC,SAAA,CAAA,CAAWC,OAAO,CAAC,OAAA,CAAA;IAEpD,OAAO;AACL;;AAEC,QACDC,yBAAwBC,WAA+B,EAAA;YACrD,MAAMC,IAAAA,GAAOL,MAAAA,CAAOM,qBAAqB,CAACF,WAAAA,CAAAA;YAC1C,MAAMG,QAAAA,GAAWP,MAAAA,CAAOQ,WAAW,CAACJ,WAAAA,CAAAA;AAEpC,YAAA,OAAOK,UAAAA,CAAW;AAChBJ,gBAAAA,IAAAA;AAEAK,gBAAAA,UAAAA,CAAAA,CAAWC,CAAC,EAAA;oBACVA,CAAAA,CAAEC,KAAK,CAAC,MAAA,EAAQ;wBACdC,IAAAA,EAAMN,QAAAA;AAENO,wBAAAA,OAAAA,EAASC,IAAAA,CAAK,OAAA;AAChB,qBAAA,CAAA;AACF,gBAAA;AACF,aAAA,CAAA;AACF,QAAA;AACF,KAAA;AACF,CAAA;;;;"}

package/dist/server/services/builders/type.js

@@ -0,0 +1,345 @@
+'use strict';
+
+var fp = require('lodash/fp');
+var nexus = require('nexus');
+var utils = require('@strapi/utils');
+
+var typeBuilder = ((context)=>{
+    const { strapi } = context;
+    const getGraphQLService = strapi.plugin('graphql').service;
+    const extension = getGraphQLService('extension');
+    /**
+   * Add a scalar attribute to the type definition
+   *
+   * The attribute is added based on a simple association between a Strapi
+   * type and a GraphQL type (the map is defined in `strapiTypeToGraphQLScalar`)
+   */ const addScalarAttribute = (options)=>{
+        const { builder, attributeName, attribute } = options;
+        const { mappers } = getGraphQLService('utils');
+        const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+        builder.field(attributeName, {
+            type: gqlType
+        });
+    };
+    /**
+   * Add a component attribute to the type definition
+   *
+   * The attribute is added by fetching the component's type
+   * name and using it as the attribute's type
+   */ const addComponentAttribute = (options)=>{
+        const { builder, attributeName, contentType, attribute } = options;
+        let localBuilder = builder;
+        const { naming } = getGraphQLService('utils');
+        const { getContentTypeArgs } = getGraphQLService('builders').utils;
+        const { buildComponentResolver } = getGraphQLService('builders').get('content-api');
+        const type = naming.getComponentNameFromAttribute(attribute);
+        if (attribute.repeatable) {
+            localBuilder = localBuilder.list;
+        }
+        const targetComponent = strapi.getModel(attribute.component);
+        const resolve = buildComponentResolver({
+            contentTypeUID: contentType.uid,
+            attributeName,
+            strapi
+        });
+        const args = getContentTypeArgs(targetComponent, {
+            multiple: !!attribute.repeatable,
+            isNested: true
+        });
+        localBuilder.field(attributeName, {
+            type,
+            resolve,
+            args
+        });
+    };
+    /**
+   * Add a dynamic zone attribute to the type definition
+   *
+   * The attribute is added by fetching the dynamic zone's
+   * type name and using it as the attribute's type
+   */ const addDynamicZoneAttribute = (options)=>{
+        const { builder, attributeName, contentType } = options;
+        const { naming } = getGraphQLService('utils');
+        const { ERROR_CODES } = getGraphQLService('constants');
+        const { buildDynamicZoneResolver } = getGraphQLService('builders').get('content-api');
+        const { components } = contentType.attributes[attributeName];
+        const isEmpty = components.length === 0;
+        const type = naming.getDynamicZoneName(contentType, attributeName);
+        const resolve = isEmpty ? fp.constant({
+            code: ERROR_CODES.emptyDynamicZone,
+            message: `This dynamic zone don't have any component attached to it`
+        }) : buildDynamicZoneResolver({
+            contentTypeUID: contentType.uid,
+            attributeName
+        });
+        builder.list.field(attributeName, {
+            type,
+            resolve
+        });
+    };
+    /**
+   * Add an enum attribute to the type definition
+   *
+   * The attribute is added by fetching the enum's type
+   * name and using it as the attribute's type
+   */ const addEnumAttribute = (options)=>{
+        const { builder, attributeName, contentType } = options;
+        const { naming } = getGraphQLService('utils');
+        const type = naming.getEnumName(contentType, attributeName);
+        builder.field(attributeName, {
+            type
+        });
+    };
+    /**
+   * Add a media attribute to the type definition
+   */ const addMediaAttribute = (options)=>{
+        const { naming } = getGraphQLService('utils');
+        const { getContentTypeArgs } = getGraphQLService('builders').utils;
+        const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+        const extension = getGraphQLService('extension');
+        const { builder } = options;
+        const { attributeName, attribute, contentType } = options;
+        const fileUID = 'plugin::upload.file';
+        if (extension.shadowCRUD(fileUID).isDisabled()) {
+            return;
+        }
+        const fileContentType = strapi.contentTypes[fileUID];
+        const resolve = buildAssociationResolver({
+            contentTypeUID: contentType.uid,
+            attributeName,
+            strapi
+        });
+        const args = attribute.multiple ? getContentTypeArgs(fileContentType, {
+            isNested: true
+        }) : undefined;
+        const typeName = naming.getTypeName(fileContentType);
+        if (attribute.multiple) {
+            builder.field(`${attributeName}_connection`, {
+                type: naming.getRelationResponseCollectionName(fileContentType),
+                resolve,
+                args
+            });
+            builder.field(attributeName, {
+                type: nexus.nonNull(nexus.list(typeName)),
+                async resolve (...args) {
+                    const res = await resolve(...args);
+                    return res.nodes ?? [];
+                },
+                args
+            });
+        } else {
+            builder.field(attributeName, {
+                type: typeName,
+                async resolve (...args) {
+                    const res = await resolve(...args);
+                    return res.value;
+                },
+                args
+            });
+        }
+    };
+    /**
+   * Add a polymorphic relational attribute to the type definition
+   */ const addPolymorphicRelationalAttribute = (options)=>{
+        const { GENERIC_MORPH_TYPENAME } = getGraphQLService('constants');
+        const { naming } = getGraphQLService('utils');
+        const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+        let { builder } = options;
+        const { attributeName, attribute, contentType } = options;
+        const { target } = attribute;
+        const isToManyRelation = attribute.relation.endsWith('Many');
+        if (isToManyRelation) {
+            builder = builder.list;
+        }
+        // todo[v4]: How to handle polymorphic relation w/ entity response collection types?
+        //  -> Currently return raw polymorphic entities
+        const resolve = buildAssociationResolver({
+            contentTypeUID: contentType.uid,
+            attributeName,
+            strapi
+        });
+        // If there is no specific target specified, then use the GenericMorph type
+        if (fp.isUndefined(target)) {
+            builder.field(attributeName, {
+                type: GENERIC_MORPH_TYPENAME,
+                resolve
+            });
+        } else if (fp.isArray(target) && target.every(fp.isString)) {
+            const type = naming.getMorphRelationTypeName(contentType, attributeName);
+            builder.field(attributeName, {
+                type,
+                resolve
+            });
+        }
+    };
+    /**
+   * Add a regular relational attribute to the type definition
+   */ const addRegularRelationalAttribute = (options)=>{
+        const { naming } = getGraphQLService('utils');
+        const { getContentTypeArgs } = getGraphQLService('builders').utils;
+        const { buildAssociationResolver } = getGraphQLService('builders').get('content-api');
+        const extension = getGraphQLService('extension');
+        const { builder } = options;
+        const { attributeName, attribute, contentType } = options;
+        if (extension.shadowCRUD(attribute.target).isDisabled()) {
+            return;
+        }
+        const isToManyRelation = attribute.relation.endsWith('Many');
+        const resolve = buildAssociationResolver({
+            contentTypeUID: contentType.uid,
+            attributeName,
+            strapi
+        });
+        const targetContentType = strapi.getModel(attribute.target);
+        const typeName = naming.getTypeName(targetContentType);
+        const args = isToManyRelation ? getContentTypeArgs(targetContentType, {
+            isNested: true
+        }) : undefined;
+        const resolverScope = `${targetContentType.uid}.find`;
+        const resolverPath = `${naming.getTypeName(contentType)}.${attributeName}`;
+        extension.use({
+            resolversConfig: {
+                [resolverPath]: {
+                    auth: {
+                        scope: [
+                            resolverScope
+                        ]
+                    }
+                }
+            }
+        });
+        if (isToManyRelation) {
+            builder.field(`${attributeName}_connection`, {
+                type: naming.getRelationResponseCollectionName(targetContentType),
+                resolve,
+                args
+            });
+            extension.use({
+                resolversConfig: {
+                    [`${resolverPath}_connection`]: {
+                        auth: {
+                            scope: [
+                                resolverScope
+                            ]
+                        }
+                    }
+                }
+            });
+            builder.field(attributeName, {
+                type: nexus.nonNull(nexus.list(typeName)),
+                async resolve (...args) {
+                    const res = await resolve(...args);
+                    return res.nodes ?? [];
+                },
+                args
+            });
+        } else {
+            builder.field(attributeName, {
+                type: typeName,
+                async resolve (...args) {
+                    const res = await resolve(...args);
+                    return res.value;
+                },
+                args
+            });
+        }
+    };
+    const isNotPrivate = (contentType)=>(attributeName)=>{
+            return !utils.contentTypes.isPrivateAttribute(contentType, attributeName);
+        };
+    const isNotDisabled = (contentType)=>(attributeName)=>{
+            return extension.shadowCRUD(contentType.uid).field(attributeName).hasOutputEnabled();
+        };
+    return {
+        /**
+     * Create a type definition for a given content type
+     * @param contentType - The content type used to created the definition
+     * @return {NexusObjectTypeDef}
+     */ buildTypeDefinition (contentType) {
+            const utils = getGraphQLService('utils');
+            const { getComponentName, getTypeName } = utils.naming;
+            const { isStrapiScalar, isComponent, isDynamicZone, isEnumeration, isMedia, isMorphRelation, isRelation } = utils.attributes;
+            const { attributes, modelType } = contentType;
+            const attributesKey = Object.keys(attributes);
+            const name = (modelType === 'component' ? getComponentName : getTypeName).call(null, contentType);
+            return nexus.objectType({
+                name,
+                definition (t) {
+                    // add back the old id attribute on contentType if v4 compat is enabled
+                    if (modelType !== 'component' && isNotDisabled(contentType)('id') && strapi.plugin('graphql').config('v4CompatibilityMode', false)) {
+                        t.nonNull.id('id', {
+                            deprecation: 'Use `documentId` instead'
+                        });
+                    }
+                    if (modelType === 'component' && isNotDisabled(contentType)('id')) {
+                        t.nonNull.id('id');
+                    }
+                    if (modelType !== 'component' && isNotDisabled(contentType)('documentId')) {
+                        t.nonNull.id('documentId');
+                    }
+                    if (strapi.plugin('graphql').config('v4CompatibilityMode', false)) {
+                        t.nonNull.field('attributes', {
+                            deprecation: 'Use root level fields instead',
+                            type: name,
+                            resolve: (parent)=>parent
+                        });
+                        t.nonNull.field('data', {
+                            deprecation: 'Use root level fields instead',
+                            type: name,
+                            resolve: (parent)=>parent
+                        });
+                    }
+                    /** Attributes
+           *
+           * Attributes can be of 7 different kind:
+           * - Scalar
+           * - Component
+           * - Dynamic Zone
+           * - Enum
+           * - Media
+           * - Polymorphic Relations
+           * - Regular Relations
+           *
+           * Here, we iterate over each non-private attribute
+           * and add it to the type definition based on its type
+           */ attributesKey// Ignore private attributes
+                    .filter(isNotPrivate(contentType))// Ignore disabled fields (from extension service)
+                    .filter(isNotDisabled(contentType))// Add each attribute to the type definition
+                    .forEach((attributeName)=>{
+                        const attribute = attributes[attributeName];
+                        // We create a copy of the builder (t) to apply custom
+                        // rules only on the current attribute (eg: nonNull, list, ...)
+                        let builder = t;
+                        if (attribute.required) {
+                            builder = builder.nonNull;
+                        }
+                        const options = {
+                            builder,
+                            attributeName,
+                            attribute,
+                            contentType};
+                        // Enums
+                        if (isEnumeration(attribute)) {
+                            addEnumAttribute(options);
+                        } else if (isStrapiScalar(attribute)) {
+                            addScalarAttribute(options);
+                        } else if (isComponent(attribute)) {
+                            addComponentAttribute(options);
+                        } else if (isDynamicZone(attribute)) {
+                            addDynamicZoneAttribute(options);
+                        } else if (isMedia(attribute)) {
+                            addMediaAttribute(options);
+                        } else if (isMorphRelation(attribute)) {
+                            addPolymorphicRelationalAttribute(options);
+                        } else if (isRelation(attribute)) {
+                            addRegularRelationalAttribute(options);
+                        }
+                    });
+                }
+            });
+        }
+    };
+});
+
+module.exports = typeBuilder;
+//# sourceMappingURL=type.js.map