@payloadcms/graphql 3.0.0-beta.9 → 3.0.0-canary.6041f49

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import type { OperationArgs } from 'graphql-http';
 import type { SanitizedConfig } from 'payload/types';
 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":"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,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,5 +1,5 @@
 /* eslint-disable no-param-reassign */ import * as GraphQL from 'graphql';
-import { createComplexityRule, fieldExtensionsEstimator, simpleEstimator } from 'graphql-query-complexity';
+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';
@@ -7,7 +7,7 @@ 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

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":["/* 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'\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    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;AAElC,SACEC,oBAAoB,EACpBC,wBAAwB,EACxBC,eAAe,QACV,+CAA8C;AACrD,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,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;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"}

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 default class QueryComplexity {
+    OperationDefinition: Record<string, any>;
+    complexity: number;
+    context: ValidationContext;
+    estimators: Array<ComplexityEstimator>;
+    includeDirectiveDef: GraphQLDirective;
+    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,EAAC,MAAM,SAAS,CAAC;AAE1C,OAAO,EACL,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EAGjB,iBAAiB,EAMlB,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,MAAM,CAAC,OAAO,OAAO,eAAe;IAClC,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACxC,UAAU,EAAE,MAAM,CAAA;IAClB,OAAO,EAAE,iBAAiB,CAAA;IAC1B,UAAU,EAAE,KAAK,CAAC,mBAAmB,CAAC,CAAA;IACtC,mBAAmB,EAAE,gBAAgB,CAAA;IACrC,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-use-before-define */ /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */ /**
+ * Created by Ivo Meißner on 28.07.17.
+ */ import { GraphQLError, GraphQLInterfaceType, GraphQLObjectType, Kind, TypeInfo, ValidationContext, getNamedType, isAbstractType, isCompositeType, 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 default class QueryComplexity {
+    OperationDefinition;
+    complexity;
+    context;
+    estimators;
+    includeDirectiveDef;
+    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

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/packages/graphql-query-complexity/QueryComplexity.ts"],"sourcesContent":["/* eslint-disable @typescript-eslint/no-explicit-any */\n/* eslint-disable @typescript-eslint/no-use-before-define */\n/* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */\n/**\n * Created by Ivo Meißner on 28.07.17.\n */\n\nimport type {\n  DocumentNode,\n  FieldNode,\n  FragmentDefinitionNode,\n  FragmentSpreadNode,\n  GraphQLCompositeType,\n  GraphQLDirective,\n  GraphQLField,\n  GraphQLFieldMap,\n  GraphQLNamedType,\n  GraphQLSchema,\n  GraphQLUnionType,\n  InlineFragmentNode,\n  OperationDefinitionNode} from 'graphql';\n\nimport {\n  GraphQLError,\n  GraphQLInterfaceType,\n  GraphQLObjectType,\n  Kind,\n  TypeInfo,\n  ValidationContext,\n  getNamedType,\n  isAbstractType,\n  isCompositeType,\n  visit,\n  visitWithTypeInfo,\n} from 'graphql'\nimport {\n  getArgumentValues,\n  getDirectiveValues,\n  getVariableValues,\n} from 'graphql/execution/values.js'\n\nexport type ComplexityEstimatorArgs = {\n  args: { [key: string]: any }\n  childComplexity: number\n  context?: Record<string, any>\n  field: GraphQLField<any, any>\n  node: FieldNode\n  type: GraphQLCompositeType\n}\n\nexport type ComplexityEstimator = (options: ComplexityEstimatorArgs) => number | void\n\n// Complexity can be anything that is supported by the configured estimators\nexport type Complexity = any\n\n// Map of complexities for possible types (of Union, Interface types)\ntype ComplexityMap = {\n  [typeName: string]: number\n}\n\nexport interface QueryComplexityOptions {\n  // Pass request context to the estimators via estimationContext\n  context?: Record<string, any>\n\n  // The query variables. This is needed because the variables are not available\n  // Optional function to create a custom error\n  createError?: (max: number, actual: number) => GraphQLError\n\n  // An array of complexity estimators to use for estimating the complexity\n  estimators: Array<ComplexityEstimator>\n\n  // Optional callback function to retrieve the determined query complexity\n  // Will be invoked whether the query is rejected or not\n  // The maximum allowed query complexity, queries above this threshold will be rejected\n  maximumComplexity: number\n\n  // This can be used for logging or to implement rate limiting\n  onComplete?: (complexity: number) => void\n\n  // specify operation name only when pass multi-operation documents\n  operationName?: string\n\n  // in the visitor of the graphql-js library\n  variables?: Record<string, any>\n}\n\nfunction queryComplexityMessage(max: number, actual: number): string {\n  return `The query exceeds the maximum complexity of ${max}. ` + `Actual complexity is ${actual}`\n}\n\nexport function getComplexity(options: {\n  context?: Record<string, any>\n  estimators: ComplexityEstimator[]\n  operationName?: string\n  query: DocumentNode\n  schema: GraphQLSchema\n  variables?: Record<string, any>\n}): number {\n  const typeInfo = new TypeInfo(options.schema)\n\n  const errors: GraphQLError[] = []\n  const context = new ValidationContext(options.schema, options.query, typeInfo, (error) =>\n    errors.push(error),\n  )\n  const visitor = new QueryComplexity(context, {\n    // Maximum complexity does not matter since we're only interested in the calculated complexity.\n    context: options.context,\n    estimators: options.estimators,\n    maximumComplexity: Infinity,\n    operationName: options.operationName,\n    variables: options.variables,\n  })\n\n  visit(options.query, visitWithTypeInfo(typeInfo, visitor))\n\n  // Throw first error if any\n  if (errors.length) {\n    throw errors.pop()\n  }\n\n  return visitor.complexity\n}\n\nexport default class QueryComplexity {\n  OperationDefinition: Record<string, any>\n  complexity: number\n  context: ValidationContext\n  estimators: Array<ComplexityEstimator>\n  includeDirectiveDef: GraphQLDirective\n  options: QueryComplexityOptions\n  requestContext?: Record<string, any>\n  skipDirectiveDef: GraphQLDirective\n  variableValues: Record<string, any>\n\n  constructor(context: ValidationContext, options: QueryComplexityOptions) {\n    if (!(typeof options.maximumComplexity === 'number' && options.maximumComplexity > 0)) {\n      throw new Error('Maximum query complexity must be a positive number')\n    }\n\n    this.context = context\n    this.complexity = 0\n    this.options = options\n\n    this.includeDirectiveDef = this.context.getSchema().getDirective('include')\n    this.skipDirectiveDef = this.context.getSchema().getDirective('skip')\n    this.estimators = options.estimators\n    this.variableValues = {}\n    this.requestContext = options.context\n\n    this.OperationDefinition = {\n      enter: this.onOperationDefinitionEnter,\n      leave: this.onOperationDefinitionLeave,\n    }\n  }\n\n  createError(): GraphQLError {\n    if (typeof this.options.createError === 'function') {\n      return this.options.createError(this.options.maximumComplexity, this.complexity)\n    }\n    return new GraphQLError(queryComplexityMessage(this.options.maximumComplexity, this.complexity))\n  }\n\n  nodeComplexity(\n    node: FieldNode | FragmentDefinitionNode | InlineFragmentNode | OperationDefinitionNode,\n    typeDef: GraphQLInterfaceType | GraphQLObjectType | GraphQLUnionType,\n  ): number {\n    if (node.selectionSet) {\n      let fields: GraphQLFieldMap<any, any> = {}\n      if (typeDef instanceof GraphQLObjectType || typeDef instanceof GraphQLInterfaceType) {\n        fields = typeDef.getFields()\n      }\n\n      // Determine all possible types of the current node\n      let possibleTypeNames: string[]\n      if (isAbstractType(typeDef)) {\n        possibleTypeNames = this.context\n          .getSchema()\n          .getPossibleTypes(typeDef)\n          .map((t) => t.name)\n      } else {\n        possibleTypeNames = [typeDef.name]\n      }\n\n      // Collect complexities for all possible types individually\n      const selectionSetComplexities: ComplexityMap = node.selectionSet.selections.reduce(\n        (\n          complexities: ComplexityMap,\n          childNode: FieldNode | FragmentSpreadNode | InlineFragmentNode,\n        ): ComplexityMap => {\n          // let nodeComplexity = 0;\n          let innerComplexities = complexities\n\n          let includeNode = true\n          let skipNode = false\n\n          for (const directive of childNode.directives ?? []) {\n            const directiveName = directive.name.value\n            switch (directiveName) {\n              case 'include': {\n                const values = getDirectiveValues(\n                  this.includeDirectiveDef,\n                  childNode,\n                  this.variableValues || {},\n                )\n                if (typeof values.if === 'boolean') {\n                  includeNode = values.if\n                }\n                break\n              }\n              case 'skip': {\n                const values = getDirectiveValues(\n                  this.skipDirectiveDef,\n                  childNode,\n                  this.variableValues || {},\n                )\n                if (typeof values.if === 'boolean') {\n                  skipNode = values.if\n                }\n                break\n              }\n            }\n          }\n\n          if (!includeNode || skipNode) {\n            return complexities\n          }\n\n          switch (childNode.kind) {\n            case Kind.FIELD: {\n              const field = fields[childNode.name.value]\n              // Invalid field, should be caught by other validation rules\n              if (!field) {\n                break\n              }\n              const fieldType = getNamedType(field.type)\n\n              // Get arguments\n              let args: { [key: string]: any }\n              try {\n                args = getArgumentValues(field, childNode, this.variableValues || {})\n              } catch (e) {\n                this.context.reportError(e)\n                return complexities\n              }\n\n              // Check if we have child complexity\n              let childComplexity = 0\n              if (isCompositeType(fieldType)) {\n                childComplexity = this.nodeComplexity(childNode, fieldType)\n              }\n\n              // Run estimators one after another and return first valid complexity\n              // score\n              const estimatorArgs: ComplexityEstimatorArgs = {\n                type: typeDef,\n                args,\n                childComplexity,\n                context: this.requestContext,\n                field,\n                node: childNode,\n              }\n              const validScore = this.estimators.find((estimator) => {\n                const tmpComplexity = estimator(estimatorArgs)\n\n                if (typeof tmpComplexity === 'number' && !isNaN(tmpComplexity)) {\n                  innerComplexities = addComplexities(\n                    tmpComplexity,\n                    complexities,\n                    possibleTypeNames,\n                  )\n                  return true\n                }\n\n                return false\n              })\n              if (!validScore) {\n                this.context.reportError(\n                  new GraphQLError(\n                    `No complexity could be calculated for field ${typeDef.name}.${field.name}. ` +\n                      'At least one complexity estimator has to return a complexity score.',\n                  ),\n                )\n                return complexities\n              }\n              break\n            }\n            case Kind.FRAGMENT_SPREAD: {\n              const fragment = this.context.getFragment(childNode.name.value)\n              // Unknown fragment, should be caught by other validation rules\n              if (!fragment) {\n                break\n              }\n              const fragmentType = this.context\n                .getSchema()\n                .getType(fragment.typeCondition.name.value)\n              // Invalid fragment type, ignore. Should be caught by other validation rules\n              if (!isCompositeType(fragmentType)) {\n                break\n              }\n              const nodeComplexity = this.nodeComplexity(fragment, fragmentType)\n              if (isAbstractType(fragmentType)) {\n                // Add fragment complexity for all possible types\n                innerComplexities = addComplexities(\n                  nodeComplexity,\n                  complexities,\n                  this.context\n                    .getSchema()\n                    .getPossibleTypes(fragmentType)\n                    .map((t) => t.name),\n                )\n              } else {\n                // Add complexity for object type\n                innerComplexities = addComplexities(nodeComplexity, complexities, [\n                  fragmentType.name,\n                ])\n              }\n              break\n            }\n            case Kind.INLINE_FRAGMENT: {\n              let inlineFragmentType: GraphQLNamedType = typeDef\n              if (childNode.typeCondition && childNode.typeCondition.name) {\n                inlineFragmentType = this.context\n                  .getSchema()\n                  .getType(childNode.typeCondition.name.value)\n                if (!isCompositeType(inlineFragmentType)) {\n                  break\n                }\n              }\n\n              const nodeComplexity = this.nodeComplexity(childNode, inlineFragmentType)\n              if (isAbstractType(inlineFragmentType)) {\n                // Add fragment complexity for all possible types\n                innerComplexities = addComplexities(\n                  nodeComplexity,\n                  complexities,\n                  this.context\n                    .getSchema()\n                    .getPossibleTypes(inlineFragmentType)\n                    .map((t) => t.name),\n                )\n              } else {\n                // Add complexity for object type\n                innerComplexities = addComplexities(nodeComplexity, complexities, [\n                  inlineFragmentType.name,\n                ])\n              }\n              break\n            }\n            default: {\n              innerComplexities = addComplexities(\n                this.nodeComplexity(childNode, typeDef),\n                complexities,\n                possibleTypeNames,\n              )\n              break\n            }\n          }\n\n          return innerComplexities\n        },\n        {},\n      )\n      // Only return max complexity of all possible types\n      if (!selectionSetComplexities) {\n        return NaN\n      }\n      return Math.max(...Object.values(selectionSetComplexities), 0)\n    }\n    return 0\n  }\n\n  onOperationDefinitionEnter(operation: OperationDefinitionNode): void {\n    if (\n      typeof this.options.operationName === 'string' &&\n      this.options.operationName !== operation.name.value\n    ) {\n      return\n    }\n\n    // Get variable values from variables that are passed from options, merged\n    // with default values defined in the operation\n    const { coerced, errors } = getVariableValues(\n      this.context.getSchema(),\n      // We have to create a new array here because input argument is not readonly in graphql ~14.6.0\n      operation.variableDefinitions ? [...operation.variableDefinitions] : [],\n      this.options.variables ?? {},\n    )\n    if (errors && errors.length) {\n      // We have input validation errors, report errors and abort\n      errors.forEach((error) => this.context.reportError(error))\n      return\n    }\n    this.variableValues = coerced\n\n    switch (operation.operation) {\n      case 'query':\n        this.complexity += this.nodeComplexity(operation, this.context.getSchema().getQueryType())\n        break\n      case 'mutation':\n        this.complexity += this.nodeComplexity(\n          operation,\n          this.context.getSchema().getMutationType(),\n        )\n        break\n      case 'subscription':\n        this.complexity += this.nodeComplexity(\n          operation,\n          this.context.getSchema().getSubscriptionType(),\n        )\n        break\n      default:\n        throw new Error(\n          `Query complexity could not be calculated for operation of type ${operation.operation}`,\n        )\n    }\n  }\n\n  onOperationDefinitionLeave(operation: OperationDefinitionNode): GraphQLError | void {\n    if (\n      typeof this.options.operationName === 'string' &&\n      this.options.operationName !== operation.name.value\n    ) {\n      return\n    }\n\n    if (this.options.onComplete) {\n      this.options.onComplete(this.complexity)\n    }\n\n    if (this.complexity > this.options.maximumComplexity) {\n      return this.context.reportError(this.createError())\n    }\n  }\n}\n\n/**\n * Adds a complexity to the complexity map for all possible types\n * @param complexity\n * @param complexityMap\n * @param possibleTypes\n */\nfunction addComplexities(\n  complexity: number,\n  complexityMap: ComplexityMap,\n  possibleTypes: string[],\n): ComplexityMap {\n  for (const type of possibleTypes) {\n    if (Object.prototype.hasOwnProperty.call(complexityMap, type)) {\n      complexityMap[type] += complexity\n    } else {\n      complexityMap[type] = complexity\n    }\n  }\n  return complexityMap\n}\n"],"names":["GraphQLError","GraphQLInterfaceType","GraphQLObjectType","Kind","TypeInfo","ValidationContext","getNamedType","isAbstractType","isCompositeType","visit","visitWithTypeInfo","getArgumentValues","getDirectiveValues","getVariableValues","queryComplexityMessage","max","actual","getComplexity","options","typeInfo","schema","errors","context","query","error","push","visitor","QueryComplexity","estimators","maximumComplexity","Infinity","operationName","variables","length","pop","complexity","OperationDefinition","includeDirectiveDef","requestContext","skipDirectiveDef","variableValues","constructor","Error","getSchema","getDirective","enter","onOperationDefinitionEnter","leave","onOperationDefinitionLeave","createError","nodeComplexity","node","typeDef","selectionSet","fields","getFields","possibleTypeNames","getPossibleTypes","map","t","name","selectionSetComplexities","selections","reduce","complexities","childNode","innerComplexities","includeNode","skipNode","directive","directives","directiveName","value","values","if","kind","FIELD","field","fieldType","type","args","e","reportError","childComplexity","estimatorArgs","validScore","find","estimator","tmpComplexity","isNaN","addComplexities","FRAGMENT_SPREAD","fragment","getFragment","fragmentType","getType","typeCondition","INLINE_FRAGMENT","inlineFragmentType","NaN","Math","Object","operation","coerced","variableDefinitions","forEach","getQueryType","getMutationType","getSubscriptionType","onComplete","complexityMap","possibleTypes","prototype","hasOwnProperty","call"],"rangeMappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;","mappings":"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"}

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

@@ -0,0 +1,5 @@
+import type { ValidationContext } from 'graphql';
+import type { QueryComplexityOptions } from './QueryComplexity.js';
+import QueryComplexity from './QueryComplexity.js';
+export declare function createComplexityRule(options: QueryComplexityOptions): (context: ValidationContext) => QueryComplexity;
+//# sourceMappingURL=createComplexityRule.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createComplexityRule.d.ts","sourceRoot":"","sources":["../../../src/packages/graphql-query-complexity/createComplexityRule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAEhD,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sBAAsB,CAAA;AAElE,OAAO,eAAe,MAAM,sBAAsB,CAAA;AAElD,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,sBAAsB,GAC9B,CAAC,OAAO,EAAE,iBAAiB,KAAK,eAAe,CAIjD"}

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

@@ -0,0 +1,8 @@
+import QueryComplexity from './QueryComplexity.js';
+export function createComplexityRule(options) {
+    return (context)=>{
+        return new QueryComplexity(context, options);
+    };
+}
+
+//# sourceMappingURL=createComplexityRule.js.map

package/dist/packages/graphql-query-complexity/createComplexityRule.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/packages/graphql-query-complexity/createComplexityRule.ts"],"sourcesContent":["import type { ValidationContext } from 'graphql'\n\nimport type { QueryComplexityOptions } from './QueryComplexity.js'\n\nimport QueryComplexity from './QueryComplexity.js'\n\nexport function createComplexityRule(\n  options: QueryComplexityOptions,\n): (context: ValidationContext) => QueryComplexity {\n  return (context: ValidationContext): QueryComplexity => {\n    return new QueryComplexity(context, options)\n  }\n}\n"],"names":["QueryComplexity","createComplexityRule","options","context"],"rangeMappings":";;;;;","mappings":"AAIA,OAAOA,qBAAqB,uBAAsB;AAElD,OAAO,SAASC,qBACdC,OAA+B;IAE/B,OAAO,CAACC;QACN,OAAO,IAAIH,gBAAgBG,SAASD;IACtC;AACF"}

package/dist/packages/graphql-query-complexity/estimators/fieldExtensions/index.d.ts

@@ -0,0 +1,3 @@
+import type { ComplexityEstimator } from '../../QueryComplexity.js';
+export declare const fieldExtensionsEstimator: () => ComplexityEstimator;
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/graphql-query-complexity/estimators/fieldExtensions/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/packages/graphql-query-complexity/estimators/fieldExtensions/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAA2B,MAAM,0BAA0B,CAAA;AAE5F,eAAO,MAAM,wBAAwB,QAAO,mBAW3C,CAAA"}

package/dist/packages/graphql-query-complexity/estimators/fieldExtensions/index.js

@@ -0,0 +1,14 @@
+export const fieldExtensionsEstimator = ()=>{
+    return (args)=>{
+        if (args.field.extensions) {
+            // Calculate complexity score
+            if (typeof args.field.extensions.complexity === 'number') {
+                return args.childComplexity + args.field.extensions.complexity;
+            } else if (typeof args.field.extensions.complexity === 'function') {
+                return args.field.extensions.complexity(args);
+            }
+        }
+    };
+};
+
+//# sourceMappingURL=index.js.map

package/dist/packages/graphql-query-complexity/estimators/fieldExtensions/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/packages/graphql-query-complexity/estimators/fieldExtensions/index.ts"],"sourcesContent":["import type { ComplexityEstimator, ComplexityEstimatorArgs } from '../../QueryComplexity.js'\n\nexport const fieldExtensionsEstimator = (): ComplexityEstimator => {\n  return (args: ComplexityEstimatorArgs): number | void => {\n    if (args.field.extensions) {\n      // Calculate complexity score\n      if (typeof args.field.extensions.complexity === 'number') {\n        return args.childComplexity + args.field.extensions.complexity\n      } else if (typeof args.field.extensions.complexity === 'function') {\n        return args.field.extensions.complexity(args)\n      }\n    }\n  }\n}\n"],"names":["fieldExtensionsEstimator","args","field","extensions","complexity","childComplexity"],"rangeMappings":";;;;;;;;;;;","mappings":"AAEA,OAAO,MAAMA,2BAA2B;IACtC,OAAO,CAACC;QACN,IAAIA,KAAKC,KAAK,CAACC,UAAU,EAAE;YACzB,6BAA6B;YAC7B,IAAI,OAAOF,KAAKC,KAAK,CAACC,UAAU,CAACC,UAAU,KAAK,UAAU;gBACxD,OAAOH,KAAKI,eAAe,GAAGJ,KAAKC,KAAK,CAACC,UAAU,CAACC,UAAU;YAChE,OAAO,IAAI,OAAOH,KAAKC,KAAK,CAACC,UAAU,CAACC,UAAU,KAAK,YAAY;gBACjE,OAAOH,KAAKC,KAAK,CAACC,UAAU,CAACC,UAAU,CAACH;YAC1C;QACF;IACF;AACF,EAAC"}

package/dist/packages/graphql-query-complexity/estimators/simple/index.d.ts

@@ -0,0 +1,5 @@
+import type { ComplexityEstimator } from '../../QueryComplexity.js';
+export declare const simpleEstimator: (options?: {
+    defaultComplexity?: number;
+}) => ComplexityEstimator;
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/graphql-query-complexity/estimators/simple/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/packages/graphql-query-complexity/estimators/simple/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAA2B,MAAM,0BAA0B,CAAA;AAE5F,eAAO,MAAM,eAAe,aAAc;IAAE,iBAAiB,CAAC,EAAE,MAAM,CAAA;CAAE,KAAG,mBAM1E,CAAA"}

package/dist/packages/graphql-query-complexity/estimators/simple/index.js

@@ -0,0 +1,8 @@
+export const simpleEstimator = (options)=>{
+    const defaultComplexity = options && typeof options.defaultComplexity === 'number' ? options.defaultComplexity : 1;
+    return (args)=>{
+        return defaultComplexity + args.childComplexity;
+    };
+};
+
+//# sourceMappingURL=index.js.map

package/dist/packages/graphql-query-complexity/estimators/simple/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/packages/graphql-query-complexity/estimators/simple/index.ts"],"sourcesContent":["import type { ComplexityEstimator, ComplexityEstimatorArgs } from '../../QueryComplexity.js'\n\nexport const simpleEstimator = (options?: { defaultComplexity?: number }): ComplexityEstimator => {\n  const defaultComplexity =\n    options && typeof options.defaultComplexity === 'number' ? options.defaultComplexity : 1\n  return (args: ComplexityEstimatorArgs): number | void => {\n    return defaultComplexity + args.childComplexity\n  }\n}\n"],"names":["simpleEstimator","options","defaultComplexity","args","childComplexity"],"rangeMappings":";;;;;","mappings":"AAEA,OAAO,MAAMA,kBAAkB,CAACC;IAC9B,MAAMC,oBACJD,WAAW,OAAOA,QAAQC,iBAAiB,KAAK,WAAWD,QAAQC,iBAAiB,GAAG;IACzF,OAAO,CAACC;QACN,OAAOD,oBAAoBC,KAAKC,eAAe;IACjD;AACF,EAAC"}

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

@@ -0,0 +1,4 @@
+export { createComplexityRule } from './createComplexityRule.js';
+export { fieldExtensionsEstimator } from './estimators/fieldExtensions/index.js';
+export { simpleEstimator } from './estimators/simple/index.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/packages/graphql-query-complexity/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,EAAE,wBAAwB,EAAE,MAAM,uCAAuC,CAAA;AAChF,OAAO,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAA"}

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

@@ -0,0 +1,5 @@
+export { createComplexityRule } from './createComplexityRule.js';
+export { fieldExtensionsEstimator } from './estimators/fieldExtensions/index.js';
+export { simpleEstimator } from './estimators/simple/index.js';
+
+//# sourceMappingURL=index.js.map

package/dist/packages/graphql-query-complexity/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/packages/graphql-query-complexity/index.ts"],"sourcesContent":["export { createComplexityRule } from './createComplexityRule.js'\nexport { fieldExtensionsEstimator } from './estimators/fieldExtensions/index.js'\nexport { simpleEstimator } from './estimators/simple/index.js'\n"],"names":["createComplexityRule","fieldExtensionsEstimator","simpleEstimator"],"rangeMappings":";;","mappings":"AAAA,SAASA,oBAAoB,QAAQ,4BAA2B;AAChE,SAASC,wBAAwB,QAAQ,wCAAuC;AAChF,SAASC,eAAe,QAAQ,+BAA8B"}

package/dist/packages/graphql-type-json/index.d.ts

@@ -0,0 +1,4 @@
+import { GraphQLScalarType } from 'graphql';
+export declare const GraphQLJSON: GraphQLScalarType<any, any>;
+export declare const GraphQLJSONObject: GraphQLScalarType<any, any>;
+//# sourceMappingURL=index.d.ts.map

package/dist/packages/graphql-type-json/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/packages/graphql-type-json/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAgD3C,eAAO,MAAM,WAAW,6BAQtB,CAAA;AAEF,eAAO,MAAM,iBAAiB,6BAc5B,CAAA"}