@depup/graphql-middleware 6.1.35-depup.0

package/dist/fragments.js

@@ -0,0 +1,82 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const graphql = require('graphql');
+
+function extractFragmentReplacements(resolvers) {
+  const allFragmentReplacements = [];
+  for (const typeName in resolvers) {
+    const fieldResolvers = resolvers[typeName];
+    for (const fieldName in fieldResolvers) {
+      const fieldResolver = fieldResolvers[fieldName];
+      if (typeof fieldResolver === "object" && fieldResolver.fragment) {
+        allFragmentReplacements.push({
+          field: fieldName,
+          fragment: fieldResolver.fragment
+        });
+      }
+      if (typeof fieldResolver === "object" && fieldResolver.fragments) {
+        for (const fragment of fieldResolver.fragments) {
+          allFragmentReplacements.push({
+            field: fieldName,
+            fragment
+          });
+        }
+      }
+    }
+  }
+  const fragmentReplacements = allFragmentReplacements.filter((fragment) => Boolean(fragment)).map((fragmentReplacement) => {
+    const fragment = parseFragmentToInlineFragment(fragmentReplacement.fragment);
+    const newSelections = fragment.selectionSet.selections.filter((node) => {
+      switch (node.kind) {
+        case graphql.Kind.FIELD: {
+          return node.name.value !== fragmentReplacement.field;
+        }
+        default: {
+          return true;
+        }
+      }
+    });
+    if (newSelections.length === 0) {
+      return null;
+    }
+    const newFragment = {
+      ...fragment,
+      selectionSet: {
+        kind: fragment.selectionSet.kind,
+        loc: fragment.selectionSet.loc,
+        selections: newSelections
+      }
+    };
+    const parsedFragment = graphql.print(newFragment);
+    return {
+      field: fragmentReplacement.field,
+      fragment: parsedFragment
+    };
+  }).filter((fr) => fr !== null);
+  return fragmentReplacements;
+  function parseFragmentToInlineFragment(definitions) {
+    if (definitions.trim().startsWith("fragment")) {
+      const document = graphql.parse(definitions);
+      for (const definition of document.definitions) {
+        if (definition.kind === graphql.Kind.FRAGMENT_DEFINITION) {
+          return {
+            kind: graphql.Kind.INLINE_FRAGMENT,
+            typeCondition: definition.typeCondition,
+            selectionSet: definition.selectionSet
+          };
+        }
+      }
+    }
+    const query = graphql.parse(`{${definitions}}`).definitions[0];
+    for (const selection of query.selectionSet.selections) {
+      if (selection.kind === graphql.Kind.INLINE_FRAGMENT) {
+        return selection;
+      }
+    }
+    throw new Error("Could not parse fragment");
+  }
+}
+
+exports.extractFragmentReplacements = extractFragmentReplacements;

package/dist/fragments.mjs

@@ -0,0 +1,78 @@
+import { Kind, print, parse } from 'graphql';
+
+function extractFragmentReplacements(resolvers) {
+  const allFragmentReplacements = [];
+  for (const typeName in resolvers) {
+    const fieldResolvers = resolvers[typeName];
+    for (const fieldName in fieldResolvers) {
+      const fieldResolver = fieldResolvers[fieldName];
+      if (typeof fieldResolver === "object" && fieldResolver.fragment) {
+        allFragmentReplacements.push({
+          field: fieldName,
+          fragment: fieldResolver.fragment
+        });
+      }
+      if (typeof fieldResolver === "object" && fieldResolver.fragments) {
+        for (const fragment of fieldResolver.fragments) {
+          allFragmentReplacements.push({
+            field: fieldName,
+            fragment
+          });
+        }
+      }
+    }
+  }
+  const fragmentReplacements = allFragmentReplacements.filter((fragment) => Boolean(fragment)).map((fragmentReplacement) => {
+    const fragment = parseFragmentToInlineFragment(fragmentReplacement.fragment);
+    const newSelections = fragment.selectionSet.selections.filter((node) => {
+      switch (node.kind) {
+        case Kind.FIELD: {
+          return node.name.value !== fragmentReplacement.field;
+        }
+        default: {
+          return true;
+        }
+      }
+    });
+    if (newSelections.length === 0) {
+      return null;
+    }
+    const newFragment = {
+      ...fragment,
+      selectionSet: {
+        kind: fragment.selectionSet.kind,
+        loc: fragment.selectionSet.loc,
+        selections: newSelections
+      }
+    };
+    const parsedFragment = print(newFragment);
+    return {
+      field: fragmentReplacement.field,
+      fragment: parsedFragment
+    };
+  }).filter((fr) => fr !== null);
+  return fragmentReplacements;
+  function parseFragmentToInlineFragment(definitions) {
+    if (definitions.trim().startsWith("fragment")) {
+      const document = parse(definitions);
+      for (const definition of document.definitions) {
+        if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+          return {
+            kind: Kind.INLINE_FRAGMENT,
+            typeCondition: definition.typeCondition,
+            selectionSet: definition.selectionSet
+          };
+        }
+      }
+    }
+    const query = parse(`{${definitions}}`).definitions[0];
+    for (const selection of query.selectionSet.selections) {
+      if (selection.kind === Kind.INLINE_FRAGMENT) {
+        return selection;
+      }
+    }
+    throw new Error("Could not parse fragment");
+  }
+}
+
+export { extractFragmentReplacements };

package/dist/generator.d.ts

@@ -0,0 +1,7 @@
+import { IMiddlewareGeneratorConstructor, IMiddleware, IMiddlewareGenerator } from './types';
+import { GraphQLSchema } from 'graphql';
+export declare class MiddlewareGenerator<TSource, TContext, TArgs> implements IMiddlewareGenerator<TSource, TContext, TArgs> {
+    private generator;
+    constructor(generator: IMiddlewareGeneratorConstructor<TSource, TContext, TArgs>);
+    generate(schema: GraphQLSchema): IMiddleware<TSource, TContext, TArgs>;
+}

package/dist/generator.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+class MiddlewareGenerator {
+  constructor(generator) {
+    this.generator = generator;
+  }
+  generate(schema) {
+    return this.generator(schema);
+  }
+}
+
+exports.MiddlewareGenerator = MiddlewareGenerator;

package/dist/generator.mjs

@@ -0,0 +1,10 @@
+class MiddlewareGenerator {
+  constructor(generator) {
+    this.generator = generator;
+  }
+  generate(schema) {
+    return this.generator(schema);
+  }
+}
+
+export { MiddlewareGenerator };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export type { FragmentReplacement, IMiddleware, IMiddlewareTypeMap, IMiddlewareFieldMap, IMiddlewareFunction, IMiddlewareGenerator, IMiddlewareGeneratorConstructor, } from './types';
+export { applyMiddleware, applyMiddlewareToDeclaredResolvers, } from './middleware';
+export { middleware } from './constructors';
+export { MiddlewareError } from './validation';

package/dist/index.js

@@ -0,0 +1,14 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const middleware = require('./middleware.js');
+const constructors = require('./constructors.js');
+const validation = require('./validation.js');
+
+
+
+exports.applyMiddleware = middleware.applyMiddleware;
+exports.applyMiddlewareToDeclaredResolvers = middleware.applyMiddlewareToDeclaredResolvers;
+exports.middleware = constructors.middleware;
+exports.MiddlewareError = validation.MiddlewareError;

package/dist/index.mjs

@@ -0,0 +1,3 @@
+export { applyMiddleware, applyMiddlewareToDeclaredResolvers } from './middleware.mjs';
+export { middleware } from './constructors.mjs';
+export { MiddlewareError } from './validation.mjs';

package/dist/middleware.d.ts

@@ -0,0 +1,34 @@
+import { GraphQLSchema } from 'graphql';
+import { IApplyOptions, IMiddleware, FragmentReplacement, IMiddlewareGenerator, GraphQLSchemaWithFragmentReplacements } from './types';
+/**
+ *
+ * @param schema
+ * @param options
+ * @param middleware
+ *
+ * Validates middleware and generates resolvers map for provided middleware.
+ * Applies middleware to the current schema and returns the modified one.
+ *
+ */
+export declare function addMiddlewareToSchema<TSource, TContext, TArgs>(schema: GraphQLSchema, options: IApplyOptions, middleware: IMiddleware<TSource, TContext, TArgs>): {
+    schema: GraphQLSchema;
+    fragmentReplacements: FragmentReplacement[];
+};
+/**
+ *
+ * @param schema
+ * @param middlewares
+ *
+ * Apply middleware to resolvers and return generated schema.
+ *
+ */
+export declare function applyMiddleware<TSource = any, TContext = any, TArgs = any>(schema: GraphQLSchema, ...middlewares: (IMiddleware<TSource, TContext, TArgs> | IMiddlewareGenerator<TSource, TContext, TArgs>)[]): GraphQLSchemaWithFragmentReplacements;
+/**
+ *
+ * @param schema
+ * @param middlewares
+ *
+ * Apply middleware to declared resolvers and return new schema.
+ *
+ */
+export declare function applyMiddlewareToDeclaredResolvers<TSource = any, TContext = any, TArgs = any>(schema: GraphQLSchema, ...middlewares: (IMiddleware<TSource, TContext, TArgs> | IMiddlewareGenerator<TSource, TContext, TArgs>)[]): GraphQLSchemaWithFragmentReplacements;

package/dist/middleware.js

@@ -0,0 +1,63 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const schema = require('@graphql-tools/schema');
+const applicator = require('./applicator.js');
+const validation = require('./validation.js');
+const fragments = require('./fragments.js');
+const utils = require('./utils.js');
+
+function addMiddlewareToSchema(schema$1, options, middleware) {
+  const validMiddleware = validation.validateMiddleware(schema$1, middleware);
+  const resolvers = applicator.generateResolverFromSchemaAndMiddleware(schema$1, options, validMiddleware);
+  const fragmentReplacements = fragments.extractFragmentReplacements(resolvers);
+  const newSchema = schema.addResolversToSchema({
+    schema: schema$1,
+    resolvers,
+    updateResolversInPlace: false,
+    resolverValidationOptions: {
+      requireResolversForResolveType: "ignore"
+    }
+  });
+  return { schema: newSchema, fragmentReplacements };
+}
+function applyMiddlewareWithOptions(schema, options, ...middlewares) {
+  const normalisedMiddlewares = middlewares.map((middleware) => {
+    if (utils.isMiddlewareGenerator(middleware)) {
+      return middleware.generate(schema);
+    } else {
+      return middleware;
+    }
+  });
+  const schemaWithMiddlewareAndFragmentReplacements = normalisedMiddlewares.reduceRight(({
+    schema: currentSchema,
+    fragmentReplacements: currentFragmentReplacements
+  }, middleware) => {
+    const {
+      schema: newSchema,
+      fragmentReplacements: newFragmentReplacements
+    } = addMiddlewareToSchema(currentSchema, options, middleware);
+    return {
+      schema: newSchema,
+      fragmentReplacements: [
+        ...currentFragmentReplacements,
+        ...newFragmentReplacements
+      ]
+    };
+  }, { schema, fragmentReplacements: [] });
+  const schemaWithMiddleware = schemaWithMiddlewareAndFragmentReplacements.schema;
+  schemaWithMiddleware.schema = schemaWithMiddlewareAndFragmentReplacements.schema;
+  schemaWithMiddleware.fragmentReplacements = schemaWithMiddlewareAndFragmentReplacements.fragmentReplacements;
+  return schemaWithMiddleware;
+}
+function applyMiddleware(schema, ...middlewares) {
+  return applyMiddlewareWithOptions(schema, { onlyDeclaredResolvers: false }, ...middlewares);
+}
+function applyMiddlewareToDeclaredResolvers(schema, ...middlewares) {
+  return applyMiddlewareWithOptions(schema, { onlyDeclaredResolvers: true }, ...middlewares);
+}
+
+exports.addMiddlewareToSchema = addMiddlewareToSchema;
+exports.applyMiddleware = applyMiddleware;
+exports.applyMiddlewareToDeclaredResolvers = applyMiddlewareToDeclaredResolvers;

package/dist/middleware.mjs

@@ -0,0 +1,57 @@
+import { addResolversToSchema } from '@graphql-tools/schema';
+import { generateResolverFromSchemaAndMiddleware } from './applicator.mjs';
+import { validateMiddleware } from './validation.mjs';
+import { extractFragmentReplacements } from './fragments.mjs';
+import { isMiddlewareGenerator } from './utils.mjs';
+
+function addMiddlewareToSchema(schema, options, middleware) {
+  const validMiddleware = validateMiddleware(schema, middleware);
+  const resolvers = generateResolverFromSchemaAndMiddleware(schema, options, validMiddleware);
+  const fragmentReplacements = extractFragmentReplacements(resolvers);
+  const newSchema = addResolversToSchema({
+    schema,
+    resolvers,
+    updateResolversInPlace: false,
+    resolverValidationOptions: {
+      requireResolversForResolveType: "ignore"
+    }
+  });
+  return { schema: newSchema, fragmentReplacements };
+}
+function applyMiddlewareWithOptions(schema, options, ...middlewares) {
+  const normalisedMiddlewares = middlewares.map((middleware) => {
+    if (isMiddlewareGenerator(middleware)) {
+      return middleware.generate(schema);
+    } else {
+      return middleware;
+    }
+  });
+  const schemaWithMiddlewareAndFragmentReplacements = normalisedMiddlewares.reduceRight(({
+    schema: currentSchema,
+    fragmentReplacements: currentFragmentReplacements
+  }, middleware) => {
+    const {
+      schema: newSchema,
+      fragmentReplacements: newFragmentReplacements
+    } = addMiddlewareToSchema(currentSchema, options, middleware);
+    return {
+      schema: newSchema,
+      fragmentReplacements: [
+        ...currentFragmentReplacements,
+        ...newFragmentReplacements
+      ]
+    };
+  }, { schema, fragmentReplacements: [] });
+  const schemaWithMiddleware = schemaWithMiddlewareAndFragmentReplacements.schema;
+  schemaWithMiddleware.schema = schemaWithMiddlewareAndFragmentReplacements.schema;
+  schemaWithMiddleware.fragmentReplacements = schemaWithMiddlewareAndFragmentReplacements.fragmentReplacements;
+  return schemaWithMiddleware;
+}
+function applyMiddleware(schema, ...middlewares) {
+  return applyMiddlewareWithOptions(schema, { onlyDeclaredResolvers: false }, ...middlewares);
+}
+function applyMiddlewareToDeclaredResolvers(schema, ...middlewares) {
+  return applyMiddlewareWithOptions(schema, { onlyDeclaredResolvers: true }, ...middlewares);
+}
+
+export { addMiddlewareToSchema, applyMiddleware, applyMiddlewareToDeclaredResolvers };

package/dist/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "graphql-middleware",
+  "version": "6.1.35",
+  "description": "GraphQL Middleware done right!",
+  "peerDependencies": {
+    "graphql": "^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@graphql-tools/delegate": "^8.8.1",
+    "@graphql-tools/schema": "^8.5.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/maticzav/graphql-middleware.git"
+  },
+  "homepage": "https://github.com/maticzav/graphql-middleware",
+  "keywords": [
+    "graphql",
+    "middleware",
+    "schema",
+    "resolvers",
+    "server",
+    "yoga"
+  ],
+  "author": "Matic Zavadlal <matic.zavadlal@gmail.com>",
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "types": "index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    },
+    "./package.json": "./package.json"
+  }
+}

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+import { GraphQLResolveInfo, GraphQLSchema, GraphQLTypeResolver, GraphQLIsTypeOfFn } from 'graphql';
+import { StitchingInfo } from '@graphql-tools/delegate';
+export declare type IMiddlewareFragment = string;
+export declare type IMiddlewareResolver<TSource = any, TContext = any, TArgs = any> = (resolve: (source?: TSource, args?: TArgs, context?: TContext, info?: GraphQLResolveInfo & {
+    stitchingInfo?: StitchingInfo;
+}) => any, parent: TSource, args: TArgs, context: TContext, info: GraphQLResolveInfo) => Promise<any>;
+export interface IMiddlewareWithOptions<TSource = any, TContext = any, TArgs = any> {
+    fragment?: IMiddlewareFragment;
+    fragments?: IMiddlewareFragment[];
+    resolve?: IMiddlewareResolver<TSource, TContext, TArgs>;
+}
+export declare type IMiddlewareFunction<TSource = any, TContext = any, TArgs = any> = IMiddlewareWithOptions<TSource, TContext, TArgs> | IMiddlewareResolver<TSource, TContext, TArgs>;
+export interface IMiddlewareTypeMap<TSource = any, TContext = any, TArgs = any> {
+    [key: string]: IMiddlewareFunction<TSource, TContext, TArgs> | IMiddlewareFieldMap<TSource, TContext, TArgs>;
+}
+export interface IMiddlewareFieldMap<TSource = any, TContext = any, TArgs = any> {
+    [key: string]: IMiddlewareFunction<TSource, TContext, TArgs>;
+}
+export declare class IMiddlewareGenerator<TSource, TContext, TArgs> {
+    constructor(generator: IMiddlewareGeneratorConstructor<TSource, TContext, TArgs>);
+    generate(schema: GraphQLSchema): IMiddleware<TSource, TContext, TArgs>;
+}
+export declare type IMiddlewareGeneratorConstructor<TSource = any, TContext = any, TArgs = any> = (schema: GraphQLSchema) => IMiddleware<TSource, TContext, TArgs>;
+export declare type IMiddleware<TSource = any, TContext = any, TArgs = any> = IMiddlewareFunction<TSource, TContext, TArgs> | IMiddlewareTypeMap<TSource, TContext, TArgs>;
+export declare type IApplyOptions = {
+    onlyDeclaredResolvers: boolean;
+};
+export declare type GraphQLSchemaWithFragmentReplacements = GraphQLSchema & {
+    schema?: GraphQLSchema;
+    fragmentReplacements?: FragmentReplacement[];
+};
+export interface FragmentReplacement {
+    field: string;
+    fragment: string;
+}
+export interface IResolvers<TSource = any, TContext = any> {
+    [key: string]: IResolverObject<TSource, TContext>;
+}
+export interface IResolverObject<TSource = any, TContext = any> {
+    [key: string]: IFieldResolver<TSource, TContext> | IResolverOptions<TSource, TContext>;
+}
+export interface IResolverOptions<TSource = any, TContext = any> {
+    fragment?: string;
+    fragments?: string[];
+    resolve?: IFieldResolver<TSource, TContext>;
+    subscribe?: IFieldResolver<TSource, TContext>;
+    __resolveType?: GraphQLTypeResolver<TSource, TContext>;
+    __isTypeOf?: GraphQLIsTypeOfFn<TSource, TContext>;
+}
+export declare type IFieldResolver<TSource, TContext> = (source: TSource, args: {
+    [argument: string]: any;
+}, context: TContext, info: GraphQLResolveInfo & {
+    stitchingInfo?: StitchingInfo;
+}) => any;

package/dist/types.js

@@ -0,0 +1,2 @@
+'use strict';
+

package/dist/types.mjs

@@ -0,0 +1 @@
+

package/dist/utils.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLObjectType, GraphQLInterfaceType } from 'graphql';
+import { IMiddlewareResolver, IMiddlewareWithOptions, IMiddlewareFunction, IMiddlewareGenerator } from './types';
+export declare function isMiddlewareResolver<TSource, TContext, TArgs>(obj: any): obj is IMiddlewareResolver<TSource, TContext, TArgs>;
+export declare function isMiddlewareWithFragment<TSource, TContext, TArgs>(obj: any): obj is IMiddlewareWithOptions<TSource, TContext, TArgs>;
+export declare function isMiddlewareFunction<TSource, TContext, TArgs>(obj: any): obj is IMiddlewareFunction<TSource, TContext, TArgs>;
+export declare function isMiddlewareGenerator<TSource, TContext, TArgs>(x: any): x is IMiddlewareGenerator<TSource, TContext, TArgs>;
+export declare function isGraphQLObjectType(obj: any): obj is GraphQLObjectType | GraphQLInterfaceType;

package/dist/utils.js

@@ -0,0 +1,28 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const graphql = require('graphql');
+const generator = require('./generator.js');
+
+function isMiddlewareResolver(obj) {
+  return typeof obj === "function" || typeof obj === "object" && obj.then !== void 0;
+}
+function isMiddlewareWithFragment(obj) {
+  return (typeof obj.fragment === "string" || typeof obj.fragments === "object") && isMiddlewareResolver(obj.resolve);
+}
+function isMiddlewareFunction(obj) {
+  return isMiddlewareWithFragment(obj) || isMiddlewareResolver(obj);
+}
+function isMiddlewareGenerator(x) {
+  return x instanceof generator.MiddlewareGenerator;
+}
+function isGraphQLObjectType(obj) {
+  return obj instanceof graphql.GraphQLObjectType || obj instanceof graphql.GraphQLInterfaceType;
+}
+
+exports.isGraphQLObjectType = isGraphQLObjectType;
+exports.isMiddlewareFunction = isMiddlewareFunction;
+exports.isMiddlewareGenerator = isMiddlewareGenerator;
+exports.isMiddlewareResolver = isMiddlewareResolver;
+exports.isMiddlewareWithFragment = isMiddlewareWithFragment;

package/dist/utils.mjs

@@ -0,0 +1,20 @@
+import { GraphQLObjectType, GraphQLInterfaceType } from 'graphql';
+import { MiddlewareGenerator } from './generator.mjs';
+
+function isMiddlewareResolver(obj) {
+  return typeof obj === "function" || typeof obj === "object" && obj.then !== void 0;
+}
+function isMiddlewareWithFragment(obj) {
+  return (typeof obj.fragment === "string" || typeof obj.fragments === "object") && isMiddlewareResolver(obj.resolve);
+}
+function isMiddlewareFunction(obj) {
+  return isMiddlewareWithFragment(obj) || isMiddlewareResolver(obj);
+}
+function isMiddlewareGenerator(x) {
+  return x instanceof MiddlewareGenerator;
+}
+function isGraphQLObjectType(obj) {
+  return obj instanceof GraphQLObjectType || obj instanceof GraphQLInterfaceType;
+}
+
+export { isGraphQLObjectType, isMiddlewareFunction, isMiddlewareGenerator, isMiddlewareResolver, isMiddlewareWithFragment };

package/dist/validation.d.ts

@@ -0,0 +1,5 @@
+import { GraphQLSchema } from 'graphql';
+import { IMiddleware } from './types';
+export declare function validateMiddleware<TSource, TContext, TArgs>(schema: GraphQLSchema, middleware: IMiddleware<TSource, TContext, TArgs>): IMiddleware<TSource, TContext, TArgs>;
+export declare class MiddlewareError extends Error {
+}

package/dist/validation.js

@@ -0,0 +1,34 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const utils = require('./utils.js');
+
+function validateMiddleware(schema, middleware) {
+  if (utils.isMiddlewareFunction(middleware)) {
+    return middleware;
+  }
+  const types = schema.getTypeMap();
+  Object.keys(middleware).forEach((type) => {
+    if (!Object.keys(types).includes(type)) {
+      throw new MiddlewareError(`Type ${type} exists in middleware but is missing in Schema.`);
+    }
+    if (!utils.isMiddlewareFunction(middleware[type])) {
+      const fields = types[type].getFields();
+      Object.keys(middleware[type]).forEach((field) => {
+        if (!Object.keys(fields).includes(field)) {
+          throw new MiddlewareError(`Field ${type}.${field} exists in middleware but is missing in Schema.`);
+        }
+        if (!utils.isMiddlewareFunction(middleware[type][field])) {
+          throw new MiddlewareError(`Expected ${type}.${field} to be a function but found ` + typeof middleware[type][field]);
+        }
+      });
+    }
+  });
+  return middleware;
+}
+class MiddlewareError extends Error {
+}
+
+exports.MiddlewareError = MiddlewareError;
+exports.validateMiddleware = validateMiddleware;

package/dist/validation.mjs

@@ -0,0 +1,29 @@
+import { isMiddlewareFunction } from './utils.mjs';
+
+function validateMiddleware(schema, middleware) {
+  if (isMiddlewareFunction(middleware)) {
+    return middleware;
+  }
+  const types = schema.getTypeMap();
+  Object.keys(middleware).forEach((type) => {
+    if (!Object.keys(types).includes(type)) {
+      throw new MiddlewareError(`Type ${type} exists in middleware but is missing in Schema.`);
+    }
+    if (!isMiddlewareFunction(middleware[type])) {
+      const fields = types[type].getFields();
+      Object.keys(middleware[type]).forEach((field) => {
+        if (!Object.keys(fields).includes(field)) {
+          throw new MiddlewareError(`Field ${type}.${field} exists in middleware but is missing in Schema.`);
+        }
+        if (!isMiddlewareFunction(middleware[type][field])) {
+          throw new MiddlewareError(`Expected ${type}.${field} to be a function but found ` + typeof middleware[type][field]);
+        }
+      });
+    }
+  });
+  return middleware;
+}
+class MiddlewareError extends Error {
+}
+
+export { MiddlewareError, validateMiddleware };