@makerx/graphql-core 2.1.0 → 2.2.0

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.js → logging.cjs}

@@ -1,49 +1,46 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.logSubscriptionOperation = exports.logGraphQLOperation = void 0;
-const node_common_1 = require("@makerx/node-common");
-const graphql_1 = require("graphql");
-const lodash_omitby_1 = __importDefault(require("lodash.omitby"));
-const utils_1 = require("./utils");
+'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 && (0, utils_1.isIntrospectionQuery)(query);
-    if (node_common_1.isLocalDev && isIntrospection)
+    const isIntrospection = query && utils.isIntrospectionQuery(query);
+    if (nodeCommon.isLocalDev && isIntrospection)
         return;
-    logger[logLevel](message, (0, lodash_omitby_1.default)({
+    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 ? (0, lodash_omitby_1.default)(result, utils_1.isNil) : undefined,
+        result: result ? lodash.omitBy(result, utils.isNil) : undefined,
         isIntrospectionQuery: isIntrospection || undefined,
-        ...(0, lodash_omitby_1.default)(rest, utils_1.isNil),
-    }, utils_1.isNil));
+        ...lodash.omitBy(rest, utils.isNil),
+    }, utils.isNil));
 };
-exports.logGraphQLOperation = logGraphQLOperation;
 const logSubscriptionOperation = ({ args, result, message, logLevel, }) => {
     const logger = args.contextValue.logger;
     if (!logger)
         return;
     const { operationName, variableValues, document } = args;
     const { data, ...resultWithoutData } = result ?? {};
-    (0, exports.logGraphQLOperation)({
+    logGraphQLOperation({
         message,
-        type: graphql_1.OperationTypeNode.SUBSCRIPTION,
+        type: graphql.OperationTypeNode.SUBSCRIPTION,
         operationName,
-        query: (0, graphql_1.print)(document),
+        query: graphql.print(document),
         variables: variableValues,
         result: resultWithoutData,
         logger,
         logLevel,
     });
 };
+
+exports.logGraphQLOperation = logGraphQLOperation;
 exports.logSubscriptionOperation = logSubscriptionOperation;
-//# sourceMappingURL=logging.js.map

package/logging.d.ts

@@ -1,6 +1,7 @@
-import { Logger } from '@makerx/node-common';
-import { ExecutionArgs, GraphQLFormattedError, OperationTypeNode } from 'graphql';
-import { ExecutionResult } from 'graphql-ws';
+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;
@@ -76,4 +77,3 @@ export declare const logSubscriptionOperation: <TLogger extends Logger = Logger>
     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.1.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 };

package/{shield.js → shield.cjs}

@@ -1,9 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createShieldSchema = exports.combineRuleWithAll = exports.createRule = void 0;
-const graphql_shield_1 = require("graphql-shield");
-const createRule = (logic, cache = 'strict') => (0, graphql_shield_1.rule)({ cache })(async (parent, args, ctx) => logic(parent, args, ctx));
-exports.createRule = createRule;
+'use strict';
+
+var graphqlShield = require('graphql-shield');
+
+const createRule = (logic, cache = 'strict') => graphqlShield.rule({ cache })(async (parent, args, ctx) => logic(parent, args, ctx));
 /**
  * Combines a given rule with all existing defined rules using the provided combinator
  * @param schema The existing shield schema with rules
@@ -22,7 +21,6 @@ function combineRuleWithAll(schema, rule, combinator) {
         return [key, combineRuleWithAll(value, rule, combinator)];
     }));
 }
-exports.combineRuleWithAll = combineRuleWithAll;
 /**
  * Creates graphql shield middleware making use of generics to type the definition of the rules.
  * @param schema A mapping of schema objects to the shield rules that define the access to that object
@@ -42,11 +40,13 @@ exports.combineRuleWithAll = combineRuleWithAll;
  *
  * schema = applyMiddleware(schema, shieldSchema)
  */
-function createShieldSchema(schema, fallbackRule = graphql_shield_1.allow) {
-    return (0, graphql_shield_1.shield)(schema, {
+function createShieldSchema(schema, fallbackRule = graphqlShield.allow) {
+    return graphqlShield.shield(schema, {
         allowExternalErrors: true,
         fallbackRule: fallbackRule,
     });
 }
+
+exports.combineRuleWithAll = combineRuleWithAll;
+exports.createRule = createRule;
 exports.createShieldSchema = createShieldSchema;
-//# sourceMappingURL=shield.js.map

package/shield.d.ts

@@ -1,6 +1,6 @@
-import { ShieldRule } from 'graphql-shield/typings/types';
-import { Primitive } from './models';
-import { and, chain, or, race } from 'graphql-shield';
+import type { and, chain, or, race } from 'graphql-shield';
+import type { ShieldRule } from 'graphql-shield/typings/types';
+import type { Primitive } from './models';
 type RuleCombinator = typeof chain | typeof race | typeof or | typeof and;
 export declare const createRule: <TContext, TParent = unknown, TArgs = unknown>(logic: (parent: TParent, args: TArgs, ctx: TContext) => boolean | Promise<boolean> | Error, cache?: 'contextual' | 'strict') => import("graphql-shield/typings/rules").Rule;
 /**
@@ -40,4 +40,3 @@ export type ShieldSchema<TResolver> = TResolver extends Primitive ? ShieldRule :
     '*'?: ShieldRule;
 };
 export {};
-//# sourceMappingURL=shield.d.ts.map

package/shield.mjs

@@ -0,0 +1,48 @@
+import { rule, shield, allow } from 'graphql-shield';
+
+const createRule = (logic, cache = 'strict') => rule({ cache })(async (parent, args, ctx) => logic(parent, args, ctx));
+/**
+ * Combines a given rule with all existing defined rules using the provided combinator
+ * @param schema The existing shield schema with rules
+ * @param rule The rule to be combined with existing rules
+ * @param combinator The combinator to use. Eg. and | or | chain | race
+ *
+ * Usage:
+ *
+ * const updatedSchema = combineRuleWithAll(shieldSchema, rules.accountNotBlocked, chain)
+ */
+function combineRuleWithAll(schema, rule, combinator) {
+    return Object.fromEntries(Object.entries(schema).map(([key, value]) => {
+        if (value.constructor.name !== 'Object') {
+            return [key, combinator(rule, value)];
+        }
+        return [key, combineRuleWithAll(value, rule, combinator)];
+    }));
+}
+/**
+ * Creates graphql shield middleware making use of generics to type the definition of the rules.
+ * @param schema A mapping of schema objects to the shield rules that define the access to that object
+ * @param fallbackRule A fallback rule to apply to any object or property which doesn't have a defined rule.
+ *
+ * Usage:
+ * import { Resolvers } from '../generated/types'
+ *
+ * const shieldSchema = createShieldSchema<Resolvers>({
+ *   Query: {
+ *     getThings: allow,
+ *     dontGetThings: deny,
+ *   }
+ * })
+ *
+ * let schema = makeExecutableSchema({...})
+ *
+ * schema = applyMiddleware(schema, shieldSchema)
+ */
+function createShieldSchema(schema, fallbackRule = allow) {
+    return shield(schema, {
+        allowExternalErrors: true,
+        fallbackRule: fallbackRule,
+    });
+}
+
+export { combineRuleWithAll, createRule, createShieldSchema };