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

package/bin.js

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const useSwc = process.argv.includes('--use-swc')
+const disableTranspile = process.argv.includes('--disable-transpile')
+
+if (disableTranspile) {
+  // Remove --disable-transpile from arguments
+  process.argv = process.argv.filter((arg) => arg !== '--disable-transpile')
+
+  const start = async () => {
+    const { bin } = await import('./dist/bin/index.js')
+    await bin()
+  }
+
+  void start()
+} else {
+  const filename = fileURLToPath(import.meta.url)
+  const dirname = path.dirname(filename)
+  const url = pathToFileURL(dirname).toString() + '/'
+
+  if (!useSwc) {
+    const start = async () => {
+      // Use tsx
+      let tsImport = (await import('tsx/esm/api')).tsImport
+
+      const { bin } = await tsImport('./dist/bin/index.js', url)
+      await bin()
+    }
+
+    void start()
+  } else if (useSwc) {
+    const { register } = await import('node:module')
+    // Remove --use-swc from arguments
+    process.argv = process.argv.filter((arg) => arg !== '--use-swc')
+
+    try {
+      register('@swc-node/register/esm', url)
+    } catch (_) {
+      console.error(
+        '@swc-node/register is not installed. Please install @swc-node/register in your project, if you want to use swc in payload run.',
+      )
+    }
+
+    const start = async () => {
+      const { bin } = await import('./dist/bin/index.js')
+      await bin()
+    }
+
+    void start()
+  }
+}

package/dist/bin/generateSchema.d.ts

@@ -0,0 +1,3 @@
+import type { SanitizedConfig } from 'payload';
+export declare function generateSchema(config: SanitizedConfig): void;
+//# sourceMappingURL=generateSchema.d.ts.map

package/dist/bin/generateSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateSchema.d.ts","sourceRoot":"","sources":["../../src/bin/generateSchema.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAA;AAM9C,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,IAAI,CAM5D"}

package/dist/bin/generateSchema.js

@@ -0,0 +1,10 @@
+import fs from 'fs';
+import { printSchema } from 'graphql';
+import { configToSchema } from '../index.js';
+export function generateSchema(config) {
+    const outputFile = process.env.PAYLOAD_GRAPHQL_SCHEMA_PATH || config.graphQL.schemaOutputFile;
+    const { schema } = configToSchema(config);
+    fs.writeFileSync(outputFile, printSchema(schema));
+}
+
+//# sourceMappingURL=generateSchema.js.map

package/dist/bin/generateSchema.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bin/generateSchema.ts"],"sourcesContent":["import type { SanitizedConfig } from 'payload'\n\nimport fs from 'fs'\nimport { printSchema } from 'graphql'\n\nimport { configToSchema } from '../index.js'\nexport function generateSchema(config: SanitizedConfig): void {\n  const outputFile = process.env.PAYLOAD_GRAPHQL_SCHEMA_PATH || config.graphQL.schemaOutputFile\n\n  const { schema } = configToSchema(config)\n\n  fs.writeFileSync(outputFile, printSchema(schema))\n}\n"],"names":["fs","printSchema","configToSchema","generateSchema","config","outputFile","process","env","PAYLOAD_GRAPHQL_SCHEMA_PATH","graphQL","schemaOutputFile","schema","writeFileSync"],"mappings":"AAEA,OAAOA,QAAQ,KAAI;AACnB,SAASC,WAAW,QAAQ,UAAS;AAErC,SAASC,cAAc,QAAQ,cAAa;AAC5C,OAAO,SAASC,eAAeC,MAAuB;IACpD,MAAMC,aAAaC,QAAQC,GAAG,CAACC,2BAA2B,IAAIJ,OAAOK,OAAO,CAACC,gBAAgB;IAE7F,MAAM,EAAEC,MAAM,EAAE,GAAGT,eAAeE;IAElCJ,GAAGY,aAAa,CAACP,YAAYJ,YAAYU;AAC3C"}

package/dist/bin/index.d.ts

@@ -0,0 +1,2 @@
+export declare const bin: () => Promise<void>;
+//# sourceMappingURL=index.d.ts.map

package/dist/bin/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/bin/index.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,GAAG,qBAcf,CAAA"}

package/dist/bin/index.js

@@ -0,0 +1,17 @@
+/* eslint-disable no-console */ import minimist from 'minimist';
+import { findConfig, loadEnv } from 'payload/node';
+import { generateSchema } from './generateSchema.js';
+export const bin = async ()=>{
+    loadEnv();
+    const configPath = findConfig();
+    const config = await (await import(configPath)).default;
+    const args = minimist(process.argv.slice(2));
+    const script = (typeof args._[0] === 'string' ? args._[0] : '').toLowerCase();
+    if (script === 'generate:schema') {
+        return generateSchema(config);
+    }
+    console.log(`Unknown script: "${script}".`);
+    process.exit(1);
+};
+
+//# sourceMappingURL=index.js.map

package/dist/bin/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/bin/index.ts"],"sourcesContent":["/* eslint-disable no-console */\nimport minimist from 'minimist'\nimport { findConfig, loadEnv } from 'payload/node'\n\nimport { generateSchema } from './generateSchema.js'\n\nexport const bin = async () => {\n  loadEnv()\n  const configPath = findConfig()\n  const config = await (await import(configPath)).default\n\n  const args = minimist(process.argv.slice(2))\n  const script = (typeof args._[0] === 'string' ? args._[0] : '').toLowerCase()\n\n  if (script === 'generate:schema') {\n    return generateSchema(config)\n  }\n\n  console.log(`Unknown script: \"${script}\".`)\n  process.exit(1)\n}\n"],"names":["minimist","findConfig","loadEnv","generateSchema","bin","configPath","config","default","args","process","argv","slice","script","_","toLowerCase","console","log","exit"],"mappings":"AAAA,6BAA6B,GAC7B,OAAOA,cAAc,WAAU;AAC/B,SAASC,UAAU,EAAEC,OAAO,QAAQ,eAAc;AAElD,SAASC,cAAc,QAAQ,sBAAqB;AAEpD,OAAO,MAAMC,MAAM;IACjBF;IACA,MAAMG,aAAaJ;IACnB,MAAMK,SAAS,MAAM,AAAC,CAAA,MAAM,MAAM,CAACD,WAAU,EAAGE,OAAO;IAEvD,MAAMC,OAAOR,SAASS,QAAQC,IAAI,CAACC,KAAK,CAAC;IACzC,MAAMC,SAAS,AAAC,CAAA,OAAOJ,KAAKK,CAAC,CAAC,EAAE,KAAK,WAAWL,KAAKK,CAAC,CAAC,EAAE,GAAG,EAAC,EAAGC,WAAW;IAE3E,IAAIF,WAAW,mBAAmB;QAChC,OAAOT,eAAeG;IACxB;IAEAS,QAAQC,GAAG,CAAC,CAAC,iBAAiB,EAAEJ,OAAO,EAAE,CAAC;IAC1CH,QAAQQ,IAAI,CAAC;AACf,EAAC"}

package/dist/exports/types.d.ts

@@ -0,0 +1,4 @@
+export { GraphQLJSON, GraphQLJSONObject } from '../packages/graphql-type-json/index.js';
+export { buildPaginatedListType } from '../schema/buildPaginatedListType.js';
+export * as GraphQL from 'graphql';
+//# sourceMappingURL=types.d.ts.map

package/dist/exports/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/exports/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAA;AACvF,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAA;AAC5E,OAAO,KAAK,OAAO,MAAM,SAAS,CAAA"}

package/dist/exports/types.js

@@ -0,0 +1,5 @@
+export { GraphQLJSON, GraphQLJSONObject } from '../packages/graphql-type-json/index.js';
+export { buildPaginatedListType } from '../schema/buildPaginatedListType.js';
+export * as GraphQL from 'graphql';
+
+//# sourceMappingURL=types.js.map

package/dist/exports/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/types.ts"],"sourcesContent":["export { GraphQLJSON, GraphQLJSONObject } from '../packages/graphql-type-json/index.js'\nexport { buildPaginatedListType } from '../schema/buildPaginatedListType.js'\nexport * as GraphQL from 'graphql'\n"],"names":["GraphQLJSON","GraphQLJSONObject","buildPaginatedListType","GraphQL"],"mappings":"AAAA,SAASA,WAAW,EAAEC,iBAAiB,QAAQ,yCAAwC;AACvF,SAASC,sBAAsB,QAAQ,sCAAqC;AAC5E,OAAO,KAAKC,OAAO,MAAM,UAAS"}

package/dist/exports/utilities.d.ts

@@ -0,0 +1,3 @@
+export { generateSchema } from '../bin/generateSchema.js';
+export { buildObjectType } from '../schema/buildObjectType.js';
+//# sourceMappingURL=utilities.d.ts.map

package/dist/exports/utilities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utilities.d.ts","sourceRoot":"","sources":["../../src/exports/utilities.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,0BAA0B,CAAA;AACzD,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/exports/utilities.js

@@ -0,0 +1,4 @@
+export { generateSchema } from '../bin/generateSchema.js';
+export { buildObjectType } from '../schema/buildObjectType.js';
+
+//# sourceMappingURL=utilities.js.map

package/dist/exports/utilities.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/exports/utilities.ts"],"sourcesContent":["export { generateSchema } from '../bin/generateSchema.js'\nexport { buildObjectType } from '../schema/buildObjectType.js'\n"],"names":["generateSchema","buildObjectType"],"mappings":"AAAA,SAASA,cAAc,QAAQ,2BAA0B;AACzD,SAASC,eAAe,QAAQ,+BAA8B"}

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import type { OperationArgs } from 'graphql-http';
-import type { SanitizedConfig } from 'payload/types';
+import type { SanitizedConfig } from 'payload';
 import * as GraphQL from 'graphql';
-export declare function configToSchema(config: SanitizedConfig): Promise<{
+export declare function configToSchema(config: SanitizedConfig): {
     schema: GraphQL.GraphQLSchema;
     validationRules: (args: OperationArgs<any>) => GraphQL.ValidationRule[];
-}>;
+};
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AAEjD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,OAAO,KAAK,OAAO,MAAM,SAAS,CAAA;AAelC,wBAAsB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC;IACrE,MAAM,EAAE,OAAO,CAAC,aAAa,CAAA;IAC7B,eAAe,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,cAAc,EAAE,CAAA;CACxE,CAAC,CAsGD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACjD,OAAO,KAAK,EAAe,eAAe,EAAE,MAAM,SAAS,CAAA;AAE3D,OAAO,KAAK,OAAO,MAAM,SAAS,CAAA;AAelC,wBAAgB,cAAc,CAAC,MAAM,EAAE,eAAe,GAAG;IACvD,MAAM,EAAE,OAAO,CAAC,aAAa,CAAA;IAC7B,eAAe,EAAE,CAAC,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC,KAAK,OAAO,CAAC,cAAc,EAAE,CAAA;CACxE,CAsGA"}

package/dist/index.js

@@ -1,13 +1,13 @@
-/* eslint-disable no-param-reassign */ import * as GraphQL from 'graphql';
-import { createComplexityRule, fieldExtensionsEstimator, simpleEstimator } from 'graphql-query-complexity';
-import accessResolver from './resolvers/auth/access.js';
-import buildFallbackLocaleInputType from './schema/buildFallbackLocaleInputType.js';
-import buildLocaleInputType from './schema/buildLocaleInputType.js';
-import buildPoliciesType from './schema/buildPoliciesType.js';
-import initCollections from './schema/initCollections.js';
-import initGlobals from './schema/initGlobals.js';
+import * as GraphQL from 'graphql';
+import { createComplexityRule, fieldExtensionsEstimator, simpleEstimator } from './packages/graphql-query-complexity/index.js';
+import { accessResolver } from './resolvers/auth/access.js';
+import { buildFallbackLocaleInputType } from './schema/buildFallbackLocaleInputType.js';
+import { buildLocaleInputType } from './schema/buildLocaleInputType.js';
+import { buildPoliciesType } from './schema/buildPoliciesType.js';
+import { initCollections } from './schema/initCollections.js';
+import { initGlobals } from './schema/initGlobals.js';
 import { wrapCustomFields } from './utilities/wrapCustomResolver.js';
-export async function configToSchema(config) {
+export function configToSchema(config) {
     const collections = config.collections.reduce((acc, collection)=>{
         acc[collection.slug] = {
             config: collection
@@ -18,6 +18,8 @@ export async function configToSchema(config) {
         config: config.globals
     };
     const graphqlResult = {
+        collections,
+        globals,
         Mutation: {
             name: 'Mutation',
             fields: {}
@@ -26,8 +28,6 @@ export async function configToSchema(config) {
             name: 'Query',
             fields: {}
         },
-        collections,
-        globals,
         types: {
             arrayTypes: {},
             blockInputTypes: {},

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/index.ts"],"sourcesContent":["/* eslint-disable no-param-reassign */\nimport type { OperationArgs } from 'graphql-http'\nimport type { GraphQLInfo } from 'payload/config'\nimport type { SanitizedConfig } from 'payload/types'\n\nimport * as GraphQL from 'graphql'\nimport {\n  createComplexityRule,\n  fieldExtensionsEstimator,\n  simpleEstimator,\n} from 'graphql-query-complexity'\n\nimport accessResolver from './resolvers/auth/access.js'\nimport buildFallbackLocaleInputType from './schema/buildFallbackLocaleInputType.js'\nimport buildLocaleInputType from './schema/buildLocaleInputType.js'\nimport buildPoliciesType from './schema/buildPoliciesType.js'\nimport initCollections from './schema/initCollections.js'\nimport initGlobals from './schema/initGlobals.js'\nimport { wrapCustomFields } from './utilities/wrapCustomResolver.js'\n\nexport async function configToSchema(config: SanitizedConfig): Promise<{\n  schema: GraphQL.GraphQLSchema\n  validationRules: (args: OperationArgs<any>) => GraphQL.ValidationRule[]\n}> {\n  const collections = config.collections.reduce((acc, collection) => {\n    acc[collection.slug] = {\n      config: collection,\n    }\n\n    return acc\n  }, {})\n\n  const globals = {\n    config: config.globals,\n  }\n\n  const graphqlResult: GraphQLInfo = {\n    Mutation: {\n      name: 'Mutation',\n      fields: {},\n    },\n    Query: {\n      name: 'Query',\n      fields: {},\n    },\n    collections,\n    globals,\n    types: {\n      arrayTypes: {},\n      blockInputTypes: {},\n      blockTypes: {},\n      groupTypes: {},\n      tabTypes: {},\n    },\n  }\n\n  if (config.localization) {\n    graphqlResult.types['localeInputType'] = buildLocaleInputType(config.localization)\n    graphqlResult.types['fallbackLocaleInputType'] = buildFallbackLocaleInputType(\n      config.localization,\n    )\n  }\n\n  initCollections({ config, graphqlResult })\n  initGlobals({ config, graphqlResult })\n\n  graphqlResult.Query.fields['Access'] = {\n    type: buildPoliciesType(config),\n    resolve: accessResolver(config),\n  }\n\n  if (typeof config.graphQL.queries === 'function') {\n    const customQueries = config.graphQL.queries(GraphQL, {\n      ...graphqlResult,\n      config,\n    })\n    graphqlResult.Query = {\n      ...graphqlResult.Query,\n      fields: {\n        ...graphqlResult.Query.fields,\n        ...wrapCustomFields((customQueries || {}) as never),\n      },\n    }\n  }\n\n  if (typeof config.graphQL.mutations === 'function') {\n    const customMutations = config.graphQL.mutations(GraphQL, {\n      ...graphqlResult,\n      config,\n    })\n    graphqlResult.Mutation = {\n      ...graphqlResult.Mutation,\n      fields: {\n        ...graphqlResult.Mutation.fields,\n        ...wrapCustomFields((customMutations || {}) as never),\n      },\n    }\n  }\n\n  const query = new GraphQL.GraphQLObjectType(graphqlResult.Query)\n  const mutation = new GraphQL.GraphQLObjectType(graphqlResult.Mutation)\n\n  const schemaToCreate = {\n    mutation,\n    query,\n  }\n\n  const schema = new GraphQL.GraphQLSchema(schemaToCreate)\n\n  const validationRules = (args) => [\n    createComplexityRule({\n      estimators: [\n        fieldExtensionsEstimator(),\n        simpleEstimator({ defaultComplexity: 1 }), // Fallback if complexity not set\n      ],\n      maximumComplexity: config.graphQL.maxComplexity,\n      variables: args.variableValues,\n      // onComplete: (complexity) => { console.log('Query Complexity:', complexity); },\n    }),\n  ]\n\n  return {\n    schema,\n    validationRules,\n  }\n}\n"],"names":["GraphQL","createComplexityRule","fieldExtensionsEstimator","simpleEstimator","accessResolver","buildFallbackLocaleInputType","buildLocaleInputType","buildPoliciesType","initCollections","initGlobals","wrapCustomFields","configToSchema","config","collections","reduce","acc","collection","slug","globals","graphqlResult","Mutation","name","fields","Query","types","arrayTypes","blockInputTypes","blockTypes","groupTypes","tabTypes","localization","type","resolve","graphQL","queries","customQueries","mutations","customMutations","query","GraphQLObjectType","mutation","schemaToCreate","schema","GraphQLSchema","validationRules","args","estimators","defaultComplexity","maximumComplexity","maxComplexity","variables","variableValues"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"AAAA,oCAAoC,GAKpC,YAAYA,aAAa,UAAS;AAClC,SACEC,oBAAoB,EACpBC,wBAAwB,EACxBC,eAAe,QACV,2BAA0B;AAEjC,OAAOC,oBAAoB,6BAA4B;AACvD,OAAOC,kCAAkC,2CAA0C;AACnF,OAAOC,0BAA0B,mCAAkC;AACnE,OAAOC,uBAAuB,gCAA+B;AAC7D,OAAOC,qBAAqB,8BAA6B;AACzD,OAAOC,iBAAiB,0BAAyB;AACjD,SAASC,gBAAgB,QAAQ,oCAAmC;AAEpE,OAAO,eAAeC,eAAeC,MAAuB;IAI1D,MAAMC,cAAcD,OAAOC,WAAW,CAACC,MAAM,CAAC,CAACC,KAAKC;QAClDD,GAAG,CAACC,WAAWC,IAAI,CAAC,GAAG;YACrBL,QAAQI;QACV;QAEA,OAAOD;IACT,GAAG,CAAC;IAEJ,MAAMG,UAAU;QACdN,QAAQA,OAAOM,OAAO;IACxB;IAEA,MAAMC,gBAA6B;QACjCC,UAAU;YACRC,MAAM;YACNC,QAAQ,CAAC;QACX;QACAC,OAAO;YACLF,MAAM;YACNC,QAAQ,CAAC;QACX;QACAT;QACAK;QACAM,OAAO;YACLC,YAAY,CAAC;YACbC,iBAAiB,CAAC;YAClBC,YAAY,CAAC;YACbC,YAAY,CAAC;YACbC,UAAU,CAAC;QACb;IACF;IAEA,IAAIjB,OAAOkB,YAAY,EAAE;QACvBX,cAAcK,KAAK,CAAC,kBAAkB,GAAGlB,qBAAqBM,OAAOkB,YAAY;QACjFX,cAAcK,KAAK,CAAC,0BAA0B,GAAGnB,6BAC/CO,OAAOkB,YAAY;IAEvB;IAEAtB,gBAAgB;QAAEI;QAAQO;IAAc;IACxCV,YAAY;QAAEG;QAAQO;IAAc;IAEpCA,cAAcI,KAAK,CAACD,MAAM,CAAC,SAAS,GAAG;QACrCS,MAAMxB,kBAAkBK;QACxBoB,SAAS5B,eAAeQ;IAC1B;IAEA,IAAI,OAAOA,OAAOqB,OAAO,CAACC,OAAO,KAAK,YAAY;QAChD,MAAMC,gBAAgBvB,OAAOqB,OAAO,CAACC,OAAO,CAAClC,SAAS;YACpD,GAAGmB,aAAa;YAChBP;QACF;QACAO,cAAcI,KAAK,GAAG;YACpB,GAAGJ,cAAcI,KAAK;YACtBD,QAAQ;gBACN,GAAGH,cAAcI,KAAK,CAACD,MAAM;gBAC7B,GAAGZ,iBAAkByB,iBAAiB,CAAC,EAAY;YACrD;QACF;IACF;IAEA,IAAI,OAAOvB,OAAOqB,OAAO,CAACG,SAAS,KAAK,YAAY;QAClD,MAAMC,kBAAkBzB,OAAOqB,OAAO,CAACG,SAAS,CAACpC,SAAS;YACxD,GAAGmB,aAAa;YAChBP;QACF;QACAO,cAAcC,QAAQ,GAAG;YACvB,GAAGD,cAAcC,QAAQ;YACzBE,QAAQ;gBACN,GAAGH,cAAcC,QAAQ,CAACE,MAAM;gBAChC,GAAGZ,iBAAkB2B,mBAAmB,CAAC,EAAY;YACvD;QACF;IACF;IAEA,MAAMC,QAAQ,IAAItC,QAAQuC,iBAAiB,CAACpB,cAAcI,KAAK;IAC/D,MAAMiB,WAAW,IAAIxC,QAAQuC,iBAAiB,CAACpB,cAAcC,QAAQ;IAErE,MAAMqB,iBAAiB;QACrBD;QACAF;IACF;IAEA,MAAMI,SAAS,IAAI1C,QAAQ2C,aAAa,CAACF;IAEzC,MAAMG,kBAAkB,CAACC,OAAS;YAChC5C,qBAAqB;gBACnB6C,YAAY;oBACV5C;oBACAC,gBAAgB;wBAAE4C,mBAAmB;oBAAE;iBACxC;gBACDC,mBAAmBpC,OAAOqB,OAAO,CAACgB,aAAa;gBAC/CC,WAAWL,KAAKM,cAAc;YAEhC;SACD;IAED,OAAO;QACLT;QACAE;IACF;AACF"}
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import type { OperationArgs } from 'graphql-http'\nimport type { GraphQLInfo, SanitizedConfig } from 'payload'\n\nimport * as GraphQL from 'graphql'\n\nimport {\n  createComplexityRule,\n  fieldExtensionsEstimator,\n  simpleEstimator,\n} from './packages/graphql-query-complexity/index.js'\nimport { accessResolver } from './resolvers/auth/access.js'\nimport { buildFallbackLocaleInputType } from './schema/buildFallbackLocaleInputType.js'\nimport { buildLocaleInputType } from './schema/buildLocaleInputType.js'\nimport { buildPoliciesType } from './schema/buildPoliciesType.js'\nimport { initCollections } from './schema/initCollections.js'\nimport { initGlobals } from './schema/initGlobals.js'\nimport { wrapCustomFields } from './utilities/wrapCustomResolver.js'\n\nexport function configToSchema(config: SanitizedConfig): {\n  schema: GraphQL.GraphQLSchema\n  validationRules: (args: OperationArgs<any>) => GraphQL.ValidationRule[]\n} {\n  const collections = config.collections.reduce((acc, collection) => {\n    acc[collection.slug] = {\n      config: collection,\n    }\n\n    return acc\n  }, {})\n\n  const globals = {\n    config: config.globals,\n  }\n\n  const graphqlResult: GraphQLInfo = {\n    collections,\n    globals,\n    Mutation: {\n      name: 'Mutation',\n      fields: {},\n    },\n    Query: {\n      name: 'Query',\n      fields: {},\n    },\n    types: {\n      arrayTypes: {},\n      blockInputTypes: {},\n      blockTypes: {},\n      groupTypes: {},\n      tabTypes: {},\n    },\n  }\n\n  if (config.localization) {\n    graphqlResult.types['localeInputType'] = buildLocaleInputType(config.localization)\n    graphqlResult.types['fallbackLocaleInputType'] = buildFallbackLocaleInputType(\n      config.localization,\n    )\n  }\n\n  initCollections({ config, graphqlResult })\n  initGlobals({ config, graphqlResult })\n\n  graphqlResult.Query.fields['Access'] = {\n    type: buildPoliciesType(config),\n    resolve: accessResolver(config),\n  }\n\n  if (typeof config.graphQL.queries === 'function') {\n    const customQueries = config.graphQL.queries(GraphQL, {\n      ...graphqlResult,\n      config,\n    })\n    graphqlResult.Query = {\n      ...graphqlResult.Query,\n      fields: {\n        ...graphqlResult.Query.fields,\n        ...wrapCustomFields((customQueries || {}) as never),\n      },\n    }\n  }\n\n  if (typeof config.graphQL.mutations === 'function') {\n    const customMutations = config.graphQL.mutations(GraphQL, {\n      ...graphqlResult,\n      config,\n    })\n    graphqlResult.Mutation = {\n      ...graphqlResult.Mutation,\n      fields: {\n        ...graphqlResult.Mutation.fields,\n        ...wrapCustomFields((customMutations || {}) as never),\n      },\n    }\n  }\n\n  const query = new GraphQL.GraphQLObjectType(graphqlResult.Query)\n  const mutation = new GraphQL.GraphQLObjectType(graphqlResult.Mutation)\n\n  const schemaToCreate = {\n    mutation,\n    query,\n  }\n\n  const schema = new GraphQL.GraphQLSchema(schemaToCreate)\n\n  const validationRules = (args) => [\n    createComplexityRule({\n      estimators: [\n        fieldExtensionsEstimator(),\n        simpleEstimator({ defaultComplexity: 1 }), // Fallback if complexity not set\n      ],\n      maximumComplexity: config.graphQL.maxComplexity,\n      variables: args.variableValues,\n      // onComplete: (complexity) => { console.log('Query Complexity:', complexity); },\n    }),\n  ]\n\n  return {\n    schema,\n    validationRules,\n  }\n}\n"],"names":["GraphQL","createComplexityRule","fieldExtensionsEstimator","simpleEstimator","accessResolver","buildFallbackLocaleInputType","buildLocaleInputType","buildPoliciesType","initCollections","initGlobals","wrapCustomFields","configToSchema","config","collections","reduce","acc","collection","slug","globals","graphqlResult","Mutation","name","fields","Query","types","arrayTypes","blockInputTypes","blockTypes","groupTypes","tabTypes","localization","type","resolve","graphQL","queries","customQueries","mutations","customMutations","query","GraphQLObjectType","mutation","schemaToCreate","schema","GraphQLSchema","validationRules","args","estimators","defaultComplexity","maximumComplexity","maxComplexity","variables","variableValues"],"mappings":"AAGA,YAAYA,aAAa,UAAS;AAElC,SACEC,oBAAoB,EACpBC,wBAAwB,EACxBC,eAAe,QACV,+CAA8C;AACrD,SAASC,cAAc,QAAQ,6BAA4B;AAC3D,SAASC,4BAA4B,QAAQ,2CAA0C;AACvF,SAASC,oBAAoB,QAAQ,mCAAkC;AACvE,SAASC,iBAAiB,QAAQ,gCAA+B;AACjE,SAASC,eAAe,QAAQ,8BAA6B;AAC7D,SAASC,WAAW,QAAQ,0BAAyB;AACrD,SAASC,gBAAgB,QAAQ,oCAAmC;AAEpE,OAAO,SAASC,eAAeC,MAAuB;IAIpD,MAAMC,cAAcD,OAAOC,WAAW,CAACC,MAAM,CAAC,CAACC,KAAKC;QAClDD,GAAG,CAACC,WAAWC,IAAI,CAAC,GAAG;YACrBL,QAAQI;QACV;QAEA,OAAOD;IACT,GAAG,CAAC;IAEJ,MAAMG,UAAU;QACdN,QAAQA,OAAOM,OAAO;IACxB;IAEA,MAAMC,gBAA6B;QACjCN;QACAK;QACAE,UAAU;YACRC,MAAM;YACNC,QAAQ,CAAC;QACX;QACAC,OAAO;YACLF,MAAM;YACNC,QAAQ,CAAC;QACX;QACAE,OAAO;YACLC,YAAY,CAAC;YACbC,iBAAiB,CAAC;YAClBC,YAAY,CAAC;YACbC,YAAY,CAAC;YACbC,UAAU,CAAC;QACb;IACF;IAEA,IAAIjB,OAAOkB,YAAY,EAAE;QACvBX,cAAcK,KAAK,CAAC,kBAAkB,GAAGlB,qBAAqBM,OAAOkB,YAAY;QACjFX,cAAcK,KAAK,CAAC,0BAA0B,GAAGnB,6BAC/CO,OAAOkB,YAAY;IAEvB;IAEAtB,gBAAgB;QAAEI;QAAQO;IAAc;IACxCV,YAAY;QAAEG;QAAQO;IAAc;IAEpCA,cAAcI,KAAK,CAACD,MAAM,CAAC,SAAS,GAAG;QACrCS,MAAMxB,kBAAkBK;QACxBoB,SAAS5B,eAAeQ;IAC1B;IAEA,IAAI,OAAOA,OAAOqB,OAAO,CAACC,OAAO,KAAK,YAAY;QAChD,MAAMC,gBAAgBvB,OAAOqB,OAAO,CAACC,OAAO,CAAClC,SAAS;YACpD,GAAGmB,aAAa;YAChBP;QACF;QACAO,cAAcI,KAAK,GAAG;YACpB,GAAGJ,cAAcI,KAAK;YACtBD,QAAQ;gBACN,GAAGH,cAAcI,KAAK,CAACD,MAAM;gBAC7B,GAAGZ,iBAAkByB,iBAAiB,CAAC,EAAY;YACrD;QACF;IACF;IAEA,IAAI,OAAOvB,OAAOqB,OAAO,CAACG,SAAS,KAAK,YAAY;QAClD,MAAMC,kBAAkBzB,OAAOqB,OAAO,CAACG,SAAS,CAACpC,SAAS;YACxD,GAAGmB,aAAa;YAChBP;QACF;QACAO,cAAcC,QAAQ,GAAG;YACvB,GAAGD,cAAcC,QAAQ;YACzBE,QAAQ;gBACN,GAAGH,cAAcC,QAAQ,CAACE,MAAM;gBAChC,GAAGZ,iBAAkB2B,mBAAmB,CAAC,EAAY;YACvD;QACF;IACF;IAEA,MAAMC,QAAQ,IAAItC,QAAQuC,iBAAiB,CAACpB,cAAcI,KAAK;IAC/D,MAAMiB,WAAW,IAAIxC,QAAQuC,iBAAiB,CAACpB,cAAcC,QAAQ;IAErE,MAAMqB,iBAAiB;QACrBD;QACAF;IACF;IAEA,MAAMI,SAAS,IAAI1C,QAAQ2C,aAAa,CAACF;IAEzC,MAAMG,kBAAkB,CAACC,OAAS;YAChC5C,qBAAqB;gBACnB6C,YAAY;oBACV5C;oBACAC,gBAAgB;wBAAE4C,mBAAmB;oBAAE;iBACxC;gBACDC,mBAAmBpC,OAAOqB,OAAO,CAACgB,aAAa;gBAC/CC,WAAWL,KAAKM,cAAc;YAEhC;SACD;IAED,OAAO;QACLT;QACAE;IACF;AACF"}

package/dist/packages/graphql-query-complexity/QueryComplexity.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Created by Ivo Meißner on 28.07.17.
+ */
+import type { DocumentNode, FieldNode, FragmentDefinitionNode, GraphQLCompositeType, GraphQLDirective, GraphQLField, GraphQLSchema, GraphQLUnionType, InlineFragmentNode, OperationDefinitionNode } from 'graphql';
+import { GraphQLError, GraphQLInterfaceType, GraphQLObjectType, ValidationContext } from 'graphql';
+export type ComplexityEstimatorArgs = {
+    args: {
+        [key: string]: any;
+    };
+    childComplexity: number;
+    context?: Record<string, any>;
+    field: GraphQLField<any, any>;
+    node: FieldNode;
+    type: GraphQLCompositeType;
+};
+export type ComplexityEstimator = (options: ComplexityEstimatorArgs) => number | void;
+export type Complexity = any;
+export interface QueryComplexityOptions {
+    context?: Record<string, any>;
+    createError?: (max: number, actual: number) => GraphQLError;
+    estimators: Array<ComplexityEstimator>;
+    maximumComplexity: number;
+    onComplete?: (complexity: number) => void;
+    operationName?: string;
+    variables?: Record<string, any>;
+}
+export declare function getComplexity(options: {
+    context?: Record<string, any>;
+    estimators: ComplexityEstimator[];
+    operationName?: string;
+    query: DocumentNode;
+    schema: GraphQLSchema;
+    variables?: Record<string, any>;
+}): number;
+export declare class QueryComplexity {
+    complexity: number;
+    context: ValidationContext;
+    estimators: Array<ComplexityEstimator>;
+    includeDirectiveDef: GraphQLDirective;
+    OperationDefinition: Record<string, any>;
+    options: QueryComplexityOptions;
+    requestContext?: Record<string, any>;
+    skipDirectiveDef: GraphQLDirective;
+    variableValues: Record<string, any>;
+    constructor(context: ValidationContext, options: QueryComplexityOptions);
+    createError(): GraphQLError;
+    nodeComplexity(node: FieldNode | FragmentDefinitionNode | InlineFragmentNode | OperationDefinitionNode, typeDef: GraphQLInterfaceType | GraphQLObjectType | GraphQLUnionType): number;
+    onOperationDefinitionEnter(operation: OperationDefinitionNode): void;
+    onOperationDefinitionLeave(operation: OperationDefinitionNode): GraphQLError | void;
+}
+//# sourceMappingURL=QueryComplexity.d.ts.map

package/dist/packages/graphql-query-complexity/QueryComplexity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"QueryComplexity.d.ts","sourceRoot":"","sources":["../../../src/packages/graphql-query-complexity/QueryComplexity.ts"],"names":[],"mappings":"AAGA;;GAEG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EACT,sBAAsB,EAEtB,oBAAoB,EACpB,gBAAgB,EAChB,YAAY,EAGZ,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,uBAAuB,EACxB,MAAM,SAAS,CAAA;AAEhB,OAAO,EAEL,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EAKjB,iBAAiB,EAGlB,MAAM,SAAS,CAAA;AAOhB,MAAM,MAAM,uBAAuB,GAAG;IACpC,IAAI,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;KAAE,CAAA;IAC5B,eAAe,EAAE,MAAM,CAAA;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC7B,KAAK,EAAE,YAAY,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IAC7B,IAAI,EAAE,SAAS,CAAA;IACf,IAAI,EAAE,oBAAoB,CAAA;CAC3B,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,EAAE,uBAAuB,KAAK,MAAM,GAAG,IAAI,CAAA;AAGrF,MAAM,MAAM,UAAU,GAAG,GAAG,CAAA;AAO5B,MAAM,WAAW,sBAAsB;IAErC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAI7B,WAAW,CAAC,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,KAAK,YAAY,CAAA;IAG3D,UAAU,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAA;IAKtC,iBAAiB,EAAE,MAAM,CAAA;IAGzB,UAAU,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,IAAI,CAAA;IAGzC,aAAa,CAAC,EAAE,MAAM,CAAA;IAGtB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAChC;AAMD,wBAAgB,aAAa,CAAC,OAAO,EAAE;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IAC7B,UAAU,EAAE,mBAAmB,EAAE,CAAA;IACjC,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,KAAK,EAAE,YAAY,CAAA;IACnB,MAAM,EAAE,aAAa,CAAA;IACrB,SAAS,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;CAChC,GAAG,MAAM,CAwBT;AAED,qBAAa,eAAe;IAC1B,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,iBAAiB,CAAA;IAC1B,UAAU,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAA;IACtC,mBAAmB,EAAE,gBAAgB,CAAA;IACrC,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACxC,OAAO,EAAE,sBAAsB,CAAA;IAC/B,cAAc,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACpC,gBAAgB,EAAE,gBAAgB,CAAA;IAClC,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;gBAEvB,OAAO,EAAE,iBAAiB,EAAE,OAAO,EAAE,sBAAsB;IAqBvE,WAAW,IAAI,YAAY;IAO3B,cAAc,CACZ,IAAI,EAAE,SAAS,GAAG,sBAAsB,GAAG,kBAAkB,GAAG,uBAAuB,EACvF,OAAO,EAAE,oBAAoB,GAAG,iBAAiB,GAAG,gBAAgB,GACnE,MAAM;IA8MT,0BAA0B,CAAC,SAAS,EAAE,uBAAuB,GAAG,IAAI;IA8CpE,0BAA0B,CAAC,SAAS,EAAE,uBAAuB,GAAG,YAAY,GAAG,IAAI;CAgBpF"}

package/dist/packages/graphql-query-complexity/QueryComplexity.js

@@ -0,0 +1,270 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */ /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */ /**
+ * Created by Ivo Meißner on 28.07.17.
+ */ import { getNamedType, GraphQLError, GraphQLInterfaceType, GraphQLObjectType, isAbstractType, isCompositeType, Kind, TypeInfo, ValidationContext, visit, visitWithTypeInfo } from 'graphql';
+import { getArgumentValues, getDirectiveValues, getVariableValues } from 'graphql/execution/values.js';
+function queryComplexityMessage(max, actual) {
+    return `The query exceeds the maximum complexity of ${max}. ` + `Actual complexity is ${actual}`;
+}
+export function getComplexity(options) {
+    const typeInfo = new TypeInfo(options.schema);
+    const errors = [];
+    const context = new ValidationContext(options.schema, options.query, typeInfo, (error)=>errors.push(error));
+    const visitor = new QueryComplexity(context, {
+        // Maximum complexity does not matter since we're only interested in the calculated complexity.
+        context: options.context,
+        estimators: options.estimators,
+        maximumComplexity: Infinity,
+        operationName: options.operationName,
+        variables: options.variables
+    });
+    visit(options.query, visitWithTypeInfo(typeInfo, visitor));
+    // Throw first error if any
+    if (errors.length) {
+        throw errors.pop();
+    }
+    return visitor.complexity;
+}
+export class QueryComplexity {
+    complexity;
+    context;
+    estimators;
+    includeDirectiveDef;
+    OperationDefinition;
+    options;
+    requestContext;
+    skipDirectiveDef;
+    variableValues;
+    constructor(context, options){
+        if (!(typeof options.maximumComplexity === 'number' && options.maximumComplexity > 0)) {
+            throw new Error('Maximum query complexity must be a positive number');
+        }
+        this.context = context;
+        this.complexity = 0;
+        this.options = options;
+        this.includeDirectiveDef = this.context.getSchema().getDirective('include');
+        this.skipDirectiveDef = this.context.getSchema().getDirective('skip');
+        this.estimators = options.estimators;
+        this.variableValues = {};
+        this.requestContext = options.context;
+        this.OperationDefinition = {
+            enter: this.onOperationDefinitionEnter,
+            leave: this.onOperationDefinitionLeave
+        };
+    }
+    createError() {
+        if (typeof this.options.createError === 'function') {
+            return this.options.createError(this.options.maximumComplexity, this.complexity);
+        }
+        return new GraphQLError(queryComplexityMessage(this.options.maximumComplexity, this.complexity));
+    }
+    nodeComplexity(node, typeDef) {
+        if (node.selectionSet) {
+            let fields = {};
+            if (typeDef instanceof GraphQLObjectType || typeDef instanceof GraphQLInterfaceType) {
+                fields = typeDef.getFields();
+            }
+            // Determine all possible types of the current node
+            let possibleTypeNames;
+            if (isAbstractType(typeDef)) {
+                possibleTypeNames = this.context.getSchema().getPossibleTypes(typeDef).map((t)=>t.name);
+            } else {
+                possibleTypeNames = [
+                    typeDef.name
+                ];
+            }
+            // Collect complexities for all possible types individually
+            const selectionSetComplexities = node.selectionSet.selections.reduce((complexities, childNode)=>{
+                // let nodeComplexity = 0;
+                let innerComplexities = complexities;
+                let includeNode = true;
+                let skipNode = false;
+                for (const directive of childNode.directives ?? []){
+                    const directiveName = directive.name.value;
+                    switch(directiveName){
+                        case 'include':
+                            {
+                                const values = getDirectiveValues(this.includeDirectiveDef, childNode, this.variableValues || {});
+                                if (typeof values.if === 'boolean') {
+                                    includeNode = values.if;
+                                }
+                                break;
+                            }
+                        case 'skip':
+                            {
+                                const values = getDirectiveValues(this.skipDirectiveDef, childNode, this.variableValues || {});
+                                if (typeof values.if === 'boolean') {
+                                    skipNode = values.if;
+                                }
+                                break;
+                            }
+                    }
+                }
+                if (!includeNode || skipNode) {
+                    return complexities;
+                }
+                switch(childNode.kind){
+                    case Kind.FIELD:
+                        {
+                            const field = fields[childNode.name.value];
+                            // Invalid field, should be caught by other validation rules
+                            if (!field) {
+                                break;
+                            }
+                            const fieldType = getNamedType(field.type);
+                            // Get arguments
+                            let args;
+                            try {
+                                args = getArgumentValues(field, childNode, this.variableValues || {});
+                            } catch (e) {
+                                this.context.reportError(e);
+                                return complexities;
+                            }
+                            // Check if we have child complexity
+                            let childComplexity = 0;
+                            if (isCompositeType(fieldType)) {
+                                childComplexity = this.nodeComplexity(childNode, fieldType);
+                            }
+                            // Run estimators one after another and return first valid complexity
+                            // score
+                            const estimatorArgs = {
+                                type: typeDef,
+                                args,
+                                childComplexity,
+                                context: this.requestContext,
+                                field,
+                                node: childNode
+                            };
+                            const validScore = this.estimators.find((estimator)=>{
+                                const tmpComplexity = estimator(estimatorArgs);
+                                if (typeof tmpComplexity === 'number' && !isNaN(tmpComplexity)) {
+                                    innerComplexities = addComplexities(tmpComplexity, complexities, possibleTypeNames);
+                                    return true;
+                                }
+                                return false;
+                            });
+                            if (!validScore) {
+                                this.context.reportError(new GraphQLError(`No complexity could be calculated for field ${typeDef.name}.${field.name}. ` + 'At least one complexity estimator has to return a complexity score.'));
+                                return complexities;
+                            }
+                            break;
+                        }
+                    case Kind.FRAGMENT_SPREAD:
+                        {
+                            const fragment = this.context.getFragment(childNode.name.value);
+                            // Unknown fragment, should be caught by other validation rules
+                            if (!fragment) {
+                                break;
+                            }
+                            const fragmentType = this.context.getSchema().getType(fragment.typeCondition.name.value);
+                            // Invalid fragment type, ignore. Should be caught by other validation rules
+                            if (!isCompositeType(fragmentType)) {
+                                break;
+                            }
+                            const nodeComplexity = this.nodeComplexity(fragment, fragmentType);
+                            if (isAbstractType(fragmentType)) {
+                                // Add fragment complexity for all possible types
+                                innerComplexities = addComplexities(nodeComplexity, complexities, this.context.getSchema().getPossibleTypes(fragmentType).map((t)=>t.name));
+                            } else {
+                                // Add complexity for object type
+                                innerComplexities = addComplexities(nodeComplexity, complexities, [
+                                    fragmentType.name
+                                ]);
+                            }
+                            break;
+                        }
+                    case Kind.INLINE_FRAGMENT:
+                        {
+                            let inlineFragmentType = typeDef;
+                            if (childNode.typeCondition && childNode.typeCondition.name) {
+                                inlineFragmentType = this.context.getSchema().getType(childNode.typeCondition.name.value);
+                                if (!isCompositeType(inlineFragmentType)) {
+                                    break;
+                                }
+                            }
+                            const nodeComplexity = this.nodeComplexity(childNode, inlineFragmentType);
+                            if (isAbstractType(inlineFragmentType)) {
+                                // Add fragment complexity for all possible types
+                                innerComplexities = addComplexities(nodeComplexity, complexities, this.context.getSchema().getPossibleTypes(inlineFragmentType).map((t)=>t.name));
+                            } else {
+                                // Add complexity for object type
+                                innerComplexities = addComplexities(nodeComplexity, complexities, [
+                                    inlineFragmentType.name
+                                ]);
+                            }
+                            break;
+                        }
+                    default:
+                        {
+                            innerComplexities = addComplexities(this.nodeComplexity(childNode, typeDef), complexities, possibleTypeNames);
+                            break;
+                        }
+                }
+                return innerComplexities;
+            }, {});
+            // Only return max complexity of all possible types
+            if (!selectionSetComplexities) {
+                return NaN;
+            }
+            return Math.max(...Object.values(selectionSetComplexities), 0);
+        }
+        return 0;
+    }
+    onOperationDefinitionEnter(operation) {
+        if (typeof this.options.operationName === 'string' && this.options.operationName !== operation.name.value) {
+            return;
+        }
+        // Get variable values from variables that are passed from options, merged
+        // with default values defined in the operation
+        const { coerced, errors } = getVariableValues(this.context.getSchema(), // We have to create a new array here because input argument is not readonly in graphql ~14.6.0
+        operation.variableDefinitions ? [
+            ...operation.variableDefinitions
+        ] : [], this.options.variables ?? {});
+        if (errors && errors.length) {
+            // We have input validation errors, report errors and abort
+            errors.forEach((error)=>this.context.reportError(error));
+            return;
+        }
+        this.variableValues = coerced;
+        switch(operation.operation){
+            case 'query':
+                this.complexity += this.nodeComplexity(operation, this.context.getSchema().getQueryType());
+                break;
+            case 'mutation':
+                this.complexity += this.nodeComplexity(operation, this.context.getSchema().getMutationType());
+                break;
+            case 'subscription':
+                this.complexity += this.nodeComplexity(operation, this.context.getSchema().getSubscriptionType());
+                break;
+            default:
+                throw new Error(`Query complexity could not be calculated for operation of type ${operation.operation}`);
+        }
+    }
+    onOperationDefinitionLeave(operation) {
+        if (typeof this.options.operationName === 'string' && this.options.operationName !== operation.name.value) {
+            return;
+        }
+        if (this.options.onComplete) {
+            this.options.onComplete(this.complexity);
+        }
+        if (this.complexity > this.options.maximumComplexity) {
+            return this.context.reportError(this.createError());
+        }
+    }
+}
+/**
+ * Adds a complexity to the complexity map for all possible types
+ * @param complexity
+ * @param complexityMap
+ * @param possibleTypes
+ */ function addComplexities(complexity, complexityMap, possibleTypes) {
+    for (const type of possibleTypes){
+        if (Object.prototype.hasOwnProperty.call(complexityMap, type)) {
+            complexityMap[type] += complexity;
+        } else {
+            complexityMap[type] = complexity;
+        }
+    }
+    return complexityMap;
+}
+
+//# sourceMappingURL=QueryComplexity.js.map