@makerx/graphql-core 2.0.0 → 2.2.0

package/README.md

@@ -119,26 +119,11 @@ const graphqlServer = createServer({
 
 ### logGraphQLOperation
 
-The `logGraphQLOperation` function will log:
+Logs a GraphQL operation in a consistent format with the option of including any additional data. Top level and result level log data with null or undefined values will be omitted for berevity.
 
-- `operationName`: the operation name, if supplied
-- `query`: the formatted graphql query or mutation, or 'IntrospectionQuery'
-- `variables`: the graphql request variables
-- `duration`: the duration of request processing
-- `errors`: the graphql response errors, if any
+Refer to the `GraphQLLogOperationInfo` type for the definition of input.
 
-Notes:
-
-- null or undefined values will be omitted
-- introspection queries will not be logged outside of production
-
-This function can be used across implementations, e.g. in a [GraphQL Envelop plugin](https://www.envelop.dev/docs/plugins) or [ApolloServer plugin](https://www.apollographql.com/docs/apollo-server/integrations/plugins/).
-
-### logGraphQLExecutionArgs
-
-The `logGraphQLExecutionArgs` will log `operationName`, `query` and `variables` params from the GraphQL `ExecutionArgs`.
-
-This can be used when logging from execution callbacks, e.g. graphql-ws Server [onOperation](https://the-guild.dev/graphql/ws/docs/interfaces/server.ServerOptions#onoperation) and [onNext](https://the-guild.dev/graphql/ws/docs/interfaces/server.ServerOptions#onnext).
+This function can be used across implementations, e.g. in a [GraphQL Envelop plugin](https://www.envelop.dev/docs/plugins) or [ApolloServer plugin](https://github.com/MakerXStudio/graphql-apollo-server/blob/main/src/plugins/graphql-operation-logging-plugin.ts).
 
 ## GraphQL subscriptions
 

package/{User.js → User.cjs}

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.User = void 0;
-const utils_1 = require("./utils");
+'use strict';
+
+var utils = require('./utils.cjs');
+
 class User {
     constructor(claims, accessToken) {
         this.claims = claims;
@@ -17,7 +17,7 @@ class User {
     get name() {
         if (this.claims.name)
             return this.claims.name;
-        const otherNames = [this.claims.given_name, this.claims.family_name].filter(utils_1.isNotNil);
+        const otherNames = [this.claims.given_name, this.claims.family_name].filter(utils.isNotNil);
         if (otherNames.length > 0)
             return otherNames.join(' ');
         return undefined;
@@ -45,5 +45,5 @@ class User {
         return first;
     }
 }
+
 exports.User = User;
-//# sourceMappingURL=User.js.map

package/User.d.ts

@@ -1,4 +1,4 @@
-import { JwtPayload } from './context';
+import type { JwtPayload } from './context';
 export declare class User {
     readonly token: string;
     readonly claims: JwtPayload;
@@ -11,4 +11,3 @@ export declare class User {
     private first;
     private firstOrThrow;
 }
-//# sourceMappingURL=User.d.ts.map

package/User.mjs

@@ -0,0 +1,47 @@
+import { isNotNil } from './utils.mjs';
+
+class User {
+    constructor(claims, accessToken) {
+        this.claims = claims;
+        this.token = accessToken;
+    }
+    get email() {
+        return (this.claims.email ??
+            this.claims.emails?.[0] ??
+            this.claims.preferred_username ??
+            this.claims.unique_name ??
+            this.claims.upn);
+    }
+    get name() {
+        if (this.claims.name)
+            return this.claims.name;
+        const otherNames = [this.claims.given_name, this.claims.family_name].filter(isNotNil);
+        if (otherNames.length > 0)
+            return otherNames.join(' ');
+        return undefined;
+    }
+    get id() {
+        return this.firstOrThrow('oid', 'sub');
+    }
+    get scopes() {
+        return this.claims.scp ? this.claims.scp.split(' ') : [];
+    }
+    get roles() {
+        return this.claims.roles ?? [];
+    }
+    first(...claims) {
+        for (const key of claims) {
+            if (this.claims[key])
+                return this.claims[key];
+        }
+        return undefined;
+    }
+    firstOrThrow(...claims) {
+        const first = this.first(...claims);
+        if (!first)
+            throw new Error(`claims do not include any of: ${claims.join(', ')}`);
+        return first;
+    }
+}
+
+export { User };

package/{context.js → context.cjs}

@@ -1,19 +1,16 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.defaultCreateUser = exports.createContextFactory = void 0;
-const crypto_1 = require("crypto");
-const lodash_pick_1 = __importDefault(require("lodash.pick"));
-const User_1 = require("./User");
+'use strict';
+
+var crypto = require('crypto');
+var lodash = require('lodash');
+var User = require('./User.cjs');
+
 const createContextFactory = ({ requestLogger, augmentRequestInfo, claimsToLog, createUser, requestInfoToLog, augmentContext, }) => {
     // the function that creates the GraphQL context
     return async (input) => {
         const { req, claims, context } = input;
         // build base request info from the request
         const baseRequestInfo = {
-            requestId: req.headers['x-request-id']?.toString() ?? (0, crypto_1.randomUUID)(),
+            requestId: req.headers['x-request-id']?.toString() ?? crypto.randomUUID(),
             protocol: req.protocol,
             host: req.hostname ?? '',
             method: req.method ?? '',
@@ -48,10 +45,10 @@ const createContextFactory = ({ requestLogger, augmentRequestInfo, claimsToLog,
             const requestLoggerMetadata = {};
             // add request info to log
             if (requestInfoToLog?.length)
-                requestLoggerMetadata.request = (0, lodash_pick_1.default)(requestInfo, requestInfoToLog);
+                requestLoggerMetadata.request = lodash.pick(requestInfo, requestInfoToLog);
             // add user claims to log
             if (claims && claimsToLog?.length)
-                requestLoggerMetadata.user = (0, lodash_pick_1.default)(claims, claimsToLog);
+                requestLoggerMetadata.user = lodash.pick(claims, claimsToLog);
             // build the request logger
             logger = requestLogger(requestLoggerMetadata);
         }
@@ -69,12 +66,12 @@ const createContextFactory = ({ requestLogger, augmentRequestInfo, claimsToLog,
         return augmentedGraphQLContext;
     };
 };
-exports.createContextFactory = createContextFactory;
 const defaultCreateUser = ({ req, claims }) => {
     if (!claims)
         return Promise.resolve(undefined);
     const accessToken = req.headers.authorization?.startsWith('Bearer') ? req.headers.authorization?.substring(7) ?? '' : '';
-    return Promise.resolve(new User_1.User(claims, accessToken));
+    return Promise.resolve(new User.User(claims, accessToken));
 };
+
+exports.createContextFactory = createContextFactory;
 exports.defaultCreateUser = defaultCreateUser;
-//# sourceMappingURL=context.js.map

package/context.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@makerx/node-common';
+import type { Logger } from '@makerx/node-common';
 import type { Request } from 'express';
 import { User } from './User';
 export interface GraphQLContext<TLogger extends Logger = Logger, TRequestInfo extends BaseRequestInfo = RequestInfo, TUser = User | undefined> {
@@ -68,4 +68,3 @@ export interface CreateContextConfig<TContext extends AnyGraphqlContext = GraphQ
 }
 export declare const createContextFactory: <TContext extends AnyGraphqlContext = GraphQLContext<Logger, RequestInfo, User | undefined>>({ requestLogger, augmentRequestInfo, claimsToLog, createUser, requestInfoToLog, augmentContext, }: CreateContextConfig<TContext>) => CreateContext<TContext>;
 export declare const defaultCreateUser: CreateUser<User | undefined>;
-//# sourceMappingURL=context.d.ts.map

package/context.mjs

@@ -0,0 +1,74 @@
+import { randomUUID } from 'crypto';
+import { pick } from 'lodash';
+import { User } from './User.mjs';
+
+const createContextFactory = ({ requestLogger, augmentRequestInfo, claimsToLog, createUser, requestInfoToLog, augmentContext, }) => {
+    // the function that creates the GraphQL context
+    return async (input) => {
+        const { req, claims, context } = input;
+        // build base request info from the request
+        const baseRequestInfo = {
+            requestId: req.headers['x-request-id']?.toString() ?? randomUUID(),
+            protocol: req.protocol,
+            host: req.hostname ?? '',
+            method: req.method ?? '',
+            url: req.originalUrl,
+            origin: req.get('Origin') ?? '',
+            referer: req.headers.referer?.toString() ?? '',
+            arrLogId: req.headers['x-arr-log-id']?.toString() ?? undefined,
+            clientIp: req.headers['x-forwarded-for']?.toString() ?? req.socket.remoteAddress,
+            correlationId: req.headers['x-correlation-id']?.toString() ?? undefined,
+        };
+        // add lambda info from the context, if present
+        let lambdaRequestInfo;
+        if (context) {
+            const { awsRequestId, functionName } = context;
+            lambdaRequestInfo = {
+                awsRequestId,
+                functionName,
+                ...baseRequestInfo,
+            };
+        }
+        // augment request info with the supplied function, if present
+        let requestInfo = lambdaRequestInfo ?? baseRequestInfo;
+        if (augmentRequestInfo)
+            requestInfo = {
+                ...requestInfo,
+                ...augmentRequestInfo(input),
+            };
+        // create request logger
+        let logger;
+        if (typeof requestLogger === 'function') {
+            // build request logger metadata
+            const requestLoggerMetadata = {};
+            // add request info to log
+            if (requestInfoToLog?.length)
+                requestLoggerMetadata.request = pick(requestInfo, requestInfoToLog);
+            // add user claims to log
+            if (claims && claimsToLog?.length)
+                requestLoggerMetadata.user = pick(claims, claimsToLog);
+            // build the request logger
+            logger = requestLogger(requestLoggerMetadata);
+        }
+        else
+            logger = requestLogger;
+        const graphqlContext = {
+            requestInfo,
+            logger,
+            user: createUser ? await createUser(input) : undefined,
+            started: Date.now(),
+        };
+        const augmentedGraphQLContext = augmentContext
+            ? { ...graphqlContext, ...(await augmentContext(graphqlContext)) }
+            : graphqlContext;
+        return augmentedGraphQLContext;
+    };
+};
+const defaultCreateUser = ({ req, claims }) => {
+    if (!claims)
+        return Promise.resolve(undefined);
+    const accessToken = req.headers.authorization?.startsWith('Bearer') ? req.headers.authorization?.substring(7) ?? '' : '';
+    return Promise.resolve(new User(claims, accessToken));
+};
+
+export { createContextFactory, defaultCreateUser };

package/index.cjs

@@ -0,0 +1,29 @@
+'use strict';
+
+var context = require('./context.cjs');
+var User = require('./User.cjs');
+var utils = require('./utils.cjs');
+var logging = require('./logging.cjs');
+var schemaUtil = require('./schema-util.cjs');
+var shield = require('./shield.cjs');
+var utils$1 = require('./subscriptions/utils.cjs');
+var context$1 = require('./subscriptions/context.cjs');
+var server = require('./subscriptions/server.cjs');
+
+
+
+exports.createContextFactory = context.createContextFactory;
+exports.defaultCreateUser = context.defaultCreateUser;
+exports.User = User.User;
+exports.isIntrospectionQuery = utils.isIntrospectionQuery;
+exports.isNil = utils.isNil;
+exports.isNotNil = utils.isNotNil;
+exports.logGraphQLOperation = logging.logGraphQLOperation;
+exports.logSubscriptionOperation = logging.logSubscriptionOperation;
+exports.requireExplicitResolversForScalars = schemaUtil.requireExplicitResolversForScalars;
+exports.combineRuleWithAll = shield.combineRuleWithAll;
+exports.createRule = shield.createRule;
+exports.createShieldSchema = shield.createShieldSchema;
+exports.extractTokenFromConnectionParams = utils$1.extractTokenFromConnectionParams;
+exports.createSubscriptionContextFactory = context$1.createSubscriptionContextFactory;
+exports.useSubscriptionsServer = server.useSubscriptionsServer;

package/index.d.ts

@@ -6,4 +6,3 @@ export * from './subscriptions';
 export * from './schema-util';
 export * from './shield';
 export * from './models';
-//# sourceMappingURL=index.d.ts.map

package/index.mjs

@@ -0,0 +1,9 @@
+export { createContextFactory, defaultCreateUser } from './context.mjs';
+export { User } from './User.mjs';
+export { isIntrospectionQuery, isNil, isNotNil } from './utils.mjs';
+export { logGraphQLOperation, logSubscriptionOperation } from './logging.mjs';
+export { requireExplicitResolversForScalars } from './schema-util.mjs';
+export { combineRuleWithAll, createRule, createShieldSchema } from './shield.mjs';
+export { extractTokenFromConnectionParams } from './subscriptions/utils.mjs';
+export { createSubscriptionContextFactory } from './subscriptions/context.mjs';
+export { useSubscriptionsServer } from './subscriptions/server.mjs';

package/logging.cjs

@@ -0,0 +1,46 @@
+'use strict';
+
+var nodeCommon = require('@makerx/node-common');
+var graphql = require('graphql');
+var lodash = require('lodash');
+var utils = require('./utils.cjs');
+
+/**
+ * Logs a GraphQL operation in a consistent format with the option of including any additional data.
+ * Top level and result entries with null or undefined values will be omitted.
+ */
+const logGraphQLOperation = ({ message = 'GraphQL operation', started, type, operationName, query, variables, result, logger, logLevel = 'info', ...rest }) => {
+    const isIntrospection = query && utils.isIntrospectionQuery(query);
+    if (nodeCommon.isLocalDev && isIntrospection)
+        return;
+    logger[logLevel](message, lodash.omitBy({
+        type,
+        operationName,
+        query,
+        variables: variables && Object.keys(variables).length > 0 ? variables : undefined,
+        duration: started ? Date.now() - started : undefined,
+        result: result ? lodash.omitBy(result, utils.isNil) : undefined,
+        isIntrospectionQuery: isIntrospection || undefined,
+        ...lodash.omitBy(rest, utils.isNil),
+    }, utils.isNil));
+};
+const logSubscriptionOperation = ({ args, result, message, logLevel, }) => {
+    const logger = args.contextValue.logger;
+    if (!logger)
+        return;
+    const { operationName, variableValues, document } = args;
+    const { data, ...resultWithoutData } = result ?? {};
+    logGraphQLOperation({
+        message,
+        type: graphql.OperationTypeNode.SUBSCRIPTION,
+        operationName,
+        query: graphql.print(document),
+        variables: variableValues,
+        result: resultWithoutData,
+        logger,
+        logLevel,
+    });
+};
+
+exports.logGraphQLOperation = logGraphQLOperation;
+exports.logSubscriptionOperation = logSubscriptionOperation;

package/logging.d.ts

@@ -1,21 +1,79 @@
-import { Logger } from '@makerx/node-common';
-import { ExecutionArgs, GraphQLFormattedError } from 'graphql';
-interface GraphQLLogOperationInfo {
-    started: number;
+import type { Logger } from '@makerx/node-common';
+import type { ExecutionArgs, GraphQLFormattedError } from 'graphql';
+import { OperationTypeNode } from 'graphql';
+import type { ExecutionResult } from 'graphql-ws';
+type LogFunction = Logger['info'];
+export type LoggerLogFunctions<T extends Logger> = {
+    [Property in keyof T]: LogFunction;
+};
+/**
+ * Info for logging a GraphQL operation in a consistent format with the option of including any additional data.
+ */
+export interface GraphQLLogOperationInfo<TLogger extends Logger = Logger> extends Record<string, unknown> {
+    /**
+     * The message to log, defaults to 'GraphQL operation'.
+     */
+    message?: string;
+    /**
+     * The timestamp when the operation started, if supplied, the duration will be logged.
+     */
+    started?: number;
+    /**
+     * The type of GraphQL operation.
+     */
+    type?: OperationTypeNode | null;
+    /**
+     * The name of the GraphQL operation.
+     */
     operationName?: string | null;
+    /**
+     * The formatted GraphQL query.
+     */
     query?: string | null;
+    /**
+     * The GraphQL variables.
+     */
     variables?: Record<string, unknown> | null;
-    result: {
+    /**
+     * The result of the GraphQL operation.
+     * Generally, we don't log the data or extensions, just errors.
+     */
+    result?: {
         data?: Record<string, unknown> | null;
         errors?: readonly GraphQLFormattedError[] | null;
+        extensions?: Record<string, unknown> | null;
+        hasNext?: boolean;
     };
-    logger: Logger;
+    /**
+     * Whether the operation is an introspection query.
+     */
+    isIntrospectionQuery?: boolean;
+    /**
+     * Whether the operation is part of an incremental response.
+     */
+    isIncrementalResponse?: boolean;
+    /**
+     * Whether the operation is a subsequent payload of an incremental response.
+     */
+    isSubsequentPayload?: boolean;
+    /**
+     * The logger to use.
+     */
+    logger: TLogger;
+    /**
+     * The logger function to use, defaults to 'info'.
+     */
+    logLevel?: keyof LoggerLogFunctions<TLogger>;
 }
-export declare const logGraphQLOperation: ({ started, operationName, query, variables, result: { errors }, logger }: GraphQLLogOperationInfo) => void;
 /**
- * Logs `operationName`, `query` and `variables` params from the GraphQL `ExecutionArgs`.
- * If `args.contextValue` has a `logger` property, it will be used, otherwise the `logger` param will be used.
+ * Logs a GraphQL operation in a consistent format with the option of including any additional data.
+ * Top level and result entries with null or undefined values will be omitted.
  */
-export declare const logGraphQLExecutionArgs: (args: ExecutionArgs, message: string, logger?: Logger) => void;
+export declare const logGraphQLOperation: <TLogger extends Logger = Logger>({ message, started, type, operationName, query, variables, result, logger, logLevel, ...rest }: GraphQLLogOperationInfo<TLogger>) => void;
+export declare const logSubscriptionOperation: <TLogger extends Logger = Logger>({ args, result, message, logLevel, }: {
+    args: ExecutionArgs;
+    result?: ExecutionResult<Record<string, unknown>, Record<string, unknown>> | undefined;
+    message?: string | undefined;
+    logLevel?: keyof TLogger | undefined;
+}) => void;
 export {};
-//# sourceMappingURL=logging.d.ts.map

package/logging.mjs

@@ -0,0 +1,43 @@
+import { isLocalDev } from '@makerx/node-common';
+import { OperationTypeNode, print } from 'graphql';
+import { omitBy } from 'lodash';
+import { isIntrospectionQuery, isNil } from './utils.mjs';
+
+/**
+ * Logs a GraphQL operation in a consistent format with the option of including any additional data.
+ * Top level and result entries with null or undefined values will be omitted.
+ */
+const logGraphQLOperation = ({ message = 'GraphQL operation', started, type, operationName, query, variables, result, logger, logLevel = 'info', ...rest }) => {
+    const isIntrospection = query && isIntrospectionQuery(query);
+    if (isLocalDev && isIntrospection)
+        return;
+    logger[logLevel](message, omitBy({
+        type,
+        operationName,
+        query,
+        variables: variables && Object.keys(variables).length > 0 ? variables : undefined,
+        duration: started ? Date.now() - started : undefined,
+        result: result ? omitBy(result, isNil) : undefined,
+        isIntrospectionQuery: isIntrospection || undefined,
+        ...omitBy(rest, isNil),
+    }, isNil));
+};
+const logSubscriptionOperation = ({ args, result, message, logLevel, }) => {
+    const logger = args.contextValue.logger;
+    if (!logger)
+        return;
+    const { operationName, variableValues, document } = args;
+    const { data, ...resultWithoutData } = result ?? {};
+    logGraphQLOperation({
+        message,
+        type: OperationTypeNode.SUBSCRIPTION,
+        operationName,
+        query: print(document),
+        variables: variableValues,
+        result: resultWithoutData,
+        logger,
+        logLevel,
+    });
+};
+
+export { logGraphQLOperation, logSubscriptionOperation };

package/models.d.ts

@@ -2,4 +2,3 @@ export type Primitive = string | number | symbol | bigint | boolean | null | und
 type ScalarPropsInternal<T, TKey extends keyof T, TAdditionalScalars = never> = TKey extends any ? T[TKey] extends Primitive | TAdditionalScalars ? TKey : never : never;
 export type ScalarProps<T, TAdditionalScalars = never> = Pick<T, ScalarPropsInternal<T, keyof T, TAdditionalScalars>>;
 export {};
-//# sourceMappingURL=models.d.ts.map

package/package.json

@@ -2,13 +2,25 @@
   "main": "index.js",
   "types": "index.d.ts",
   "name": "@makerx/graphql-core",
-  "version": "2.0.0",
+  "version": "2.2.0",
   "private": false,
   "description": "A set of core GraphQL utilities that MakerX uses to build GraphQL APIs",
   "author": "MakerX",
   "license": "MIT",
+  "type": "module",
+  "module": "index.mjs",
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "module": "./index.mjs",
+      "import": "./index.mjs",
+      "require": "./index.cjs",
+      "default": "./index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "engines": {
-    "node": ">=16.0"
+    "node": ">=18.0"
   },
   "bugs": {
     "url": "https://github.com/MakerXStudio/graphql-core/issues"
@@ -19,16 +31,15 @@
     "url": "git+https://github.com/MakerXStudio/graphql-core.git"
   },
   "dependencies": {
-    "@makerx/node-common": "^1.2.0",
-    "lodash.omitby": "^4.6.0",
-    "lodash.pick": "^4.4.0"
+    "@makerx/node-common": "^1.4.0"
   },
   "peerDependencies": {
     "@apollo/client": "*",
     "express": "*",
+    "graphql": "*",
     "graphql-shield": "*",
     "graphql-ws": "*",
-    "graphql": "*",
+    "lodash": "*",
     "ws": "*"
   },
   "peerDependenciesMeta": {
@@ -41,9 +52,5 @@
     "ws": {
       "optional": true
     }
-  },
-  "overrides": {
-    "@typescript-eslint/eslint-plugin": "^6.0.0",
-    "@typescript-eslint/parser": "^6.0.0"
   }
 }

package/{schema-util.js → schema-util.cjs}

@@ -1,7 +1,7 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.requireExplicitResolversForScalars = void 0;
-const graphql_1 = require("graphql");
+'use strict';
+
+var graphql = require('graphql');
+
 /**
  * It is possible to register a custom scalar with apollo server without defining an explicit resolver (a default resolver is used in
  * this case), but it is rarely desirable. This function, when provided with your built schema, will ensure any registered scalar types
@@ -11,7 +11,7 @@ const graphql_1 = require("graphql");
  */
 function requireExplicitResolversForScalars(schema, ...scalarsToIgnore) {
     const testSymbol = Symbol('testSymbol');
-    const scalars = Object.values(schema.getTypeMap()).filter((t) => t instanceof graphql_1.GraphQLScalarType);
+    const scalars = Object.values(schema.getTypeMap()).filter((t) => t instanceof graphql.GraphQLScalarType);
     for (const scalar of scalars) {
         if (scalar.name === 'Void' || scalar.name === 'JSON' || scalarsToIgnore.includes(scalar.name))
             continue;
@@ -26,5 +26,5 @@ function requireExplicitResolversForScalars(schema, ...scalarsToIgnore) {
             "If you're satisfied with this scalar you can ignore it in the call to `requireExplicitResolversForScalars`.");
     }
 }
+
 exports.requireExplicitResolversForScalars = requireExplicitResolversForScalars;
-//# sourceMappingURL=schema-util.js.map

package/schema-util.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLSchema } from 'graphql';
+import type { GraphQLSchema } from 'graphql';
 /**
  * It is possible to register a custom scalar with apollo server without defining an explicit resolver (a default resolver is used in
  * this case), but it is rarely desirable. This function, when provided with your built schema, will ensure any registered scalar types
@@ -7,4 +7,3 @@ import { GraphQLSchema } from 'graphql';
  * @param schema A schema object, the result of calling `makeExecutableSchema` from `@graphql-tools/schema`
  */
 export declare function requireExplicitResolversForScalars(schema: GraphQLSchema, ...scalarsToIgnore: string[]): void;
-//# sourceMappingURL=schema-util.d.ts.map

package/schema-util.mjs

@@ -0,0 +1,28 @@
+import { GraphQLScalarType } from 'graphql';
+
+/**
+ * It is possible to register a custom scalar with apollo server without defining an explicit resolver (a default resolver is used in
+ * this case), but it is rarely desirable. This function, when provided with your built schema, will ensure any registered scalar types
+ * provide at least a base level of validation by failing to parse a Symbol instance. The default resolver does not pass this test
+ * meaning any scalars that are falling back to the default resolver will fail.
+ * @param schema A schema object, the result of calling `makeExecutableSchema` from `@graphql-tools/schema`
+ */
+function requireExplicitResolversForScalars(schema, ...scalarsToIgnore) {
+    const testSymbol = Symbol('testSymbol');
+    const scalars = Object.values(schema.getTypeMap()).filter((t) => t instanceof GraphQLScalarType);
+    for (const scalar of scalars) {
+        if (scalar.name === 'Void' || scalar.name === 'JSON' || scalarsToIgnore.includes(scalar.name))
+            continue;
+        try {
+            scalar.parseValue(testSymbol);
+        }
+        catch {
+            // We expect that a good parser should throw when parsing a random symbol
+            continue;
+        }
+        throw new Error(`Scalar ${scalar.name} does not appear to have an explicit resolver, or is not performing sufficient validation when parsing input. ` +
+            "If you're satisfied with this scalar you can ignore it in the call to `requireExplicitResolversForScalars`.");
+    }
+}
+
+export { requireExplicitResolversForScalars };