@graphql-mesh/transform-filter-schema 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/cjs/bareFilter.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const minimatch_1 = tslib_1.__importDefault(require("minimatch"));
+const utils_1 = require("@graphql-tools/utils");
+class BareFilter {
+    constructor({ config: { filters } }) {
+        this.noWrap = true;
+        this.typeGlobs = [];
+        this.fieldsMap = new Map();
+        this.argsMap = new Map();
+        for (const filter of filters) {
+            const [typeName, fieldNameOrGlob, argsGlob] = filter.split('.');
+            // TODO: deprecate this in next major release as dscussed in #1605
+            if (!fieldNameOrGlob) {
+                this.typeGlobs.push(typeName);
+                continue;
+            }
+            const rawGlob = argsGlob || fieldNameOrGlob;
+            const fixedGlob = rawGlob.includes('{') && !rawGlob.includes(',')
+                ? rawGlob.replace('{', '').replace('}', '')
+                : rawGlob;
+            const polishedGlob = fixedGlob.split(', ').join(',').trim();
+            if (typeName === 'Type') {
+                this.typeGlobs.push(polishedGlob);
+                continue;
+            }
+            const mapName = argsGlob ? 'argsMap' : 'fieldsMap';
+            const mapKey = argsGlob ? `${typeName}.${fieldNameOrGlob}` : typeName;
+            const currentRules = this[mapName].get(mapKey) || [];
+            this[mapName].set(mapKey, [...currentRules, polishedGlob]);
+        }
+    }
+    matchInArray(rulesArray, value) {
+        for (const rule of rulesArray) {
+            const ruleMatcher = new minimatch_1.default.Minimatch(rule);
+            if (!ruleMatcher.match(value))
+                return null;
+        }
+        return undefined;
+    }
+    transformSchema(schema) {
+        const transformedSchema = (0, utils_1.mapSchema)(schema, {
+            ...(this.typeGlobs.length && {
+                [utils_1.MapperKind.TYPE]: type => this.matchInArray(this.typeGlobs, type.toString()),
+            }),
+            ...((this.fieldsMap.size || this.argsMap.size) && {
+                [utils_1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                    const fieldRules = this.fieldsMap.get(typeName);
+                    const wildcardArgRules = this.argsMap.get(`${typeName}.*`) || [];
+                    const fieldArgRules = this.argsMap.get(`${typeName}.${fieldName}`) || [];
+                    const argRules = wildcardArgRules.concat(fieldArgRules);
+                    const hasFieldRules = Boolean(fieldRules && fieldRules.length);
+                    const hasArgRules = Boolean(argRules && argRules.length);
+                    if (hasFieldRules && this.matchInArray(fieldRules, fieldName) === null)
+                        return null;
+                    if (!hasArgRules)
+                        return undefined;
+                    const fieldArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => this.matchInArray(argRules, argName) === null
+                        ? args
+                        : { ...args, [argName]: argConfig }, {});
+                    return { ...fieldConfig, args: fieldArgs };
+                },
+            }),
+            ...(this.fieldsMap.size && {
+                [utils_1.MapperKind.INPUT_OBJECT_FIELD]: (_, fieldName, typeName) => {
+                    const fieldRules = this.fieldsMap.get(typeName);
+                    const hasFieldRules = Boolean(fieldRules && fieldRules.length);
+                    if (hasFieldRules && this.matchInArray(fieldRules, fieldName) === null)
+                        return null;
+                    return undefined;
+                },
+            }),
+        });
+        return transformedSchema;
+    }
+}
+exports.default = BareFilter;

package/cjs/index.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const bareFilter_js_1 = tslib_1.__importDefault(require("./bareFilter.js"));
+const wrapFilter_js_1 = tslib_1.__importDefault(require("./wrapFilter.js"));
+exports.default = (function FilterTransform(options) {
+    if (Array.isArray(options.config)) {
+        return new wrapFilter_js_1.default({
+            ...options,
+            config: {
+                mode: 'wrap',
+                filters: options.config,
+            },
+        });
+    }
+    return options.config.mode === 'bare' ? new bareFilter_js_1.default(options) : new wrapFilter_js_1.default(options);
+});

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/cjs/wrapFilter.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const minimatch_1 = tslib_1.__importDefault(require("minimatch"));
+const utils_1 = require("@graphql-mesh/utils");
+const wrap_1 = require("@graphql-tools/wrap");
+class WrapFilter {
+    constructor({ config: { filters } }) {
+        this.transforms = [];
+        for (const filter of filters) {
+            const [typeName, fieldNameOrGlob, argsGlob] = filter.split('.');
+            const typeMatcher = new minimatch_1.default.Minimatch(typeName);
+            // TODO: deprecate this in next major release as dscussed in #1605
+            if (!fieldNameOrGlob) {
+                this.transforms.push(new wrap_1.FilterTypes(type => {
+                    return typeMatcher.match(type.name);
+                }));
+                continue;
+            }
+            let fixedFieldGlob = argsGlob || fieldNameOrGlob;
+            if (fixedFieldGlob.includes('{') && !fixedFieldGlob.includes(',')) {
+                fixedFieldGlob = fieldNameOrGlob.replace('{', '').replace('}', '');
+            }
+            fixedFieldGlob = fixedFieldGlob.split(', ').join(',');
+            const globalTypeMatcher = new minimatch_1.default.Minimatch(fixedFieldGlob.trim());
+            if (typeName === 'Type') {
+                this.transforms.push(new wrap_1.FilterTypes(type => {
+                    return globalTypeMatcher.match(type.name);
+                }));
+                continue;
+            }
+            if (argsGlob) {
+                const fieldMatcher = new minimatch_1.default.Minimatch(fieldNameOrGlob);
+                this.transforms.push(new wrap_1.TransformCompositeFields((fieldTypeName, fieldName, fieldConfig) => {
+                    if (typeMatcher.match(fieldTypeName) && fieldMatcher.match(fieldName)) {
+                        const fieldArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => !globalTypeMatcher.match(argName) ? args : { ...args, [argName]: argConfig }, {});
+                        return { ...fieldConfig, args: fieldArgs };
+                    }
+                    return undefined;
+                }));
+                continue;
+            }
+            // If the glob is not for Types nor Args, finally we register Fields filters
+            this.transforms.push(new wrap_1.FilterRootFields((rootTypeName, rootFieldName) => {
+                if (typeMatcher.match(rootTypeName)) {
+                    return globalTypeMatcher.match(rootFieldName);
+                }
+                return true;
+            }));
+            this.transforms.push(new wrap_1.FilterObjectFields((objectTypeName, objectFieldName) => {
+                if (typeMatcher.match(objectTypeName)) {
+                    return globalTypeMatcher.match(objectFieldName);
+                }
+                return true;
+            }));
+            this.transforms.push(new wrap_1.FilterInputObjectFields((inputObjectTypeName, inputObjectFieldName) => {
+                if (typeMatcher.match(inputObjectTypeName)) {
+                    return globalTypeMatcher.match(inputObjectFieldName);
+                }
+                return true;
+            }));
+            this.transforms.push(new wrap_1.FilterInterfaceFields((interfaceTypeName, interfaceFieldName) => {
+                if (typeMatcher.match(interfaceTypeName)) {
+                    return globalTypeMatcher.match(interfaceFieldName);
+                }
+                return true;
+            }));
+        }
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return (0, utils_1.applySchemaTransforms)(originalWrappingSchema, subschemaConfig, transformedSchema, this.transforms);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return (0, utils_1.applyRequestTransforms)(originalRequest, delegationContext, transformationContext, this.transforms);
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        return (0, utils_1.applyResultTransforms)(originalResult, delegationContext, transformationContext, this.transforms);
+    }
+}
+exports.default = WrapFilter;

package/esm/bareFilter.js

@@ -0,0 +1,74 @@
+import minimatch from 'minimatch';
+import { MapperKind, mapSchema } from '@graphql-tools/utils';
+export default class BareFilter {
+    constructor({ config: { filters } }) {
+        this.noWrap = true;
+        this.typeGlobs = [];
+        this.fieldsMap = new Map();
+        this.argsMap = new Map();
+        for (const filter of filters) {
+            const [typeName, fieldNameOrGlob, argsGlob] = filter.split('.');
+            // TODO: deprecate this in next major release as dscussed in #1605
+            if (!fieldNameOrGlob) {
+                this.typeGlobs.push(typeName);
+                continue;
+            }
+            const rawGlob = argsGlob || fieldNameOrGlob;
+            const fixedGlob = rawGlob.includes('{') && !rawGlob.includes(',')
+                ? rawGlob.replace('{', '').replace('}', '')
+                : rawGlob;
+            const polishedGlob = fixedGlob.split(', ').join(',').trim();
+            if (typeName === 'Type') {
+                this.typeGlobs.push(polishedGlob);
+                continue;
+            }
+            const mapName = argsGlob ? 'argsMap' : 'fieldsMap';
+            const mapKey = argsGlob ? `${typeName}.${fieldNameOrGlob}` : typeName;
+            const currentRules = this[mapName].get(mapKey) || [];
+            this[mapName].set(mapKey, [...currentRules, polishedGlob]);
+        }
+    }
+    matchInArray(rulesArray, value) {
+        for (const rule of rulesArray) {
+            const ruleMatcher = new minimatch.Minimatch(rule);
+            if (!ruleMatcher.match(value))
+                return null;
+        }
+        return undefined;
+    }
+    transformSchema(schema) {
+        const transformedSchema = mapSchema(schema, {
+            ...(this.typeGlobs.length && {
+                [MapperKind.TYPE]: type => this.matchInArray(this.typeGlobs, type.toString()),
+            }),
+            ...((this.fieldsMap.size || this.argsMap.size) && {
+                [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                    const fieldRules = this.fieldsMap.get(typeName);
+                    const wildcardArgRules = this.argsMap.get(`${typeName}.*`) || [];
+                    const fieldArgRules = this.argsMap.get(`${typeName}.${fieldName}`) || [];
+                    const argRules = wildcardArgRules.concat(fieldArgRules);
+                    const hasFieldRules = Boolean(fieldRules && fieldRules.length);
+                    const hasArgRules = Boolean(argRules && argRules.length);
+                    if (hasFieldRules && this.matchInArray(fieldRules, fieldName) === null)
+                        return null;
+                    if (!hasArgRules)
+                        return undefined;
+                    const fieldArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => this.matchInArray(argRules, argName) === null
+                        ? args
+                        : { ...args, [argName]: argConfig }, {});
+                    return { ...fieldConfig, args: fieldArgs };
+                },
+            }),
+            ...(this.fieldsMap.size && {
+                [MapperKind.INPUT_OBJECT_FIELD]: (_, fieldName, typeName) => {
+                    const fieldRules = this.fieldsMap.get(typeName);
+                    const hasFieldRules = Boolean(fieldRules && fieldRules.length);
+                    if (hasFieldRules && this.matchInArray(fieldRules, fieldName) === null)
+                        return null;
+                    return undefined;
+                },
+            }),
+        });
+        return transformedSchema;
+    }
+}

package/esm/index.js

@@ -0,0 +1,14 @@
+import BareFilter from './bareFilter.js';
+import WrapFilter from './wrapFilter.js';
+export default (function FilterTransform(options) {
+    if (Array.isArray(options.config)) {
+        return new WrapFilter({
+            ...options,
+            config: {
+                mode: 'wrap',
+                filters: options.config,
+            },
+        });
+    }
+    return options.config.mode === 'bare' ? new BareFilter(options) : new WrapFilter(options);
+});

package/esm/wrapFilter.js

@@ -0,0 +1,76 @@
+import minimatch from 'minimatch';
+import { applyRequestTransforms, applyResultTransforms, applySchemaTransforms, } from '@graphql-mesh/utils';
+import { FilterInputObjectFields, FilterInterfaceFields, FilterObjectFields, FilterRootFields, FilterTypes, TransformCompositeFields, } from '@graphql-tools/wrap';
+export default class WrapFilter {
+    constructor({ config: { filters } }) {
+        this.transforms = [];
+        for (const filter of filters) {
+            const [typeName, fieldNameOrGlob, argsGlob] = filter.split('.');
+            const typeMatcher = new minimatch.Minimatch(typeName);
+            // TODO: deprecate this in next major release as dscussed in #1605
+            if (!fieldNameOrGlob) {
+                this.transforms.push(new FilterTypes(type => {
+                    return typeMatcher.match(type.name);
+                }));
+                continue;
+            }
+            let fixedFieldGlob = argsGlob || fieldNameOrGlob;
+            if (fixedFieldGlob.includes('{') && !fixedFieldGlob.includes(',')) {
+                fixedFieldGlob = fieldNameOrGlob.replace('{', '').replace('}', '');
+            }
+            fixedFieldGlob = fixedFieldGlob.split(', ').join(',');
+            const globalTypeMatcher = new minimatch.Minimatch(fixedFieldGlob.trim());
+            if (typeName === 'Type') {
+                this.transforms.push(new FilterTypes(type => {
+                    return globalTypeMatcher.match(type.name);
+                }));
+                continue;
+            }
+            if (argsGlob) {
+                const fieldMatcher = new minimatch.Minimatch(fieldNameOrGlob);
+                this.transforms.push(new TransformCompositeFields((fieldTypeName, fieldName, fieldConfig) => {
+                    if (typeMatcher.match(fieldTypeName) && fieldMatcher.match(fieldName)) {
+                        const fieldArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => !globalTypeMatcher.match(argName) ? args : { ...args, [argName]: argConfig }, {});
+                        return { ...fieldConfig, args: fieldArgs };
+                    }
+                    return undefined;
+                }));
+                continue;
+            }
+            // If the glob is not for Types nor Args, finally we register Fields filters
+            this.transforms.push(new FilterRootFields((rootTypeName, rootFieldName) => {
+                if (typeMatcher.match(rootTypeName)) {
+                    return globalTypeMatcher.match(rootFieldName);
+                }
+                return true;
+            }));
+            this.transforms.push(new FilterObjectFields((objectTypeName, objectFieldName) => {
+                if (typeMatcher.match(objectTypeName)) {
+                    return globalTypeMatcher.match(objectFieldName);
+                }
+                return true;
+            }));
+            this.transforms.push(new FilterInputObjectFields((inputObjectTypeName, inputObjectFieldName) => {
+                if (typeMatcher.match(inputObjectTypeName)) {
+                    return globalTypeMatcher.match(inputObjectFieldName);
+                }
+                return true;
+            }));
+            this.transforms.push(new FilterInterfaceFields((interfaceTypeName, interfaceFieldName) => {
+                if (typeMatcher.match(interfaceTypeName)) {
+                    return globalTypeMatcher.match(interfaceFieldName);
+                }
+                return true;
+            }));
+        }
+    }
+    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
+        return applySchemaTransforms(originalWrappingSchema, subschemaConfig, transformedSchema, this.transforms);
+    }
+    transformRequest(originalRequest, delegationContext, transformationContext) {
+        return applyRequestTransforms(originalRequest, delegationContext, transformationContext, this.transforms);
+    }
+    transformResult(originalResult, delegationContext, transformationContext) {
+        return applyResultTransforms(originalResult, delegationContext, transformationContext, this.transforms);
+    }
+}

package/package.json

@@ -1,18 +1,18 @@
 {
   "name": "@graphql-mesh/transform-filter-schema",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-3fc47d119.0",
-    "@graphql-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@graphql-tools/delegate": "8.8.0",
-    "@graphql-tools/utils": "8.8.0",
-    "@graphql-tools/wrap": "8.5.0",
-    "minimatch": "5.1.0",
-    "tslib": "^2.4.0"
+    "@graphql-tools/delegate": "9.0.32",
+    "@graphql-tools/wrap": "9.4.2",
+    "minimatch": "8.0.4"
   },
   "repository": {
     "type": "git",
@@ -20,21 +20,28 @@
     "directory": "packages/transforms/filter-schema"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/bareFilter.d.ts

@@ -0,0 +1,13 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshTransform, YamlConfig } from '@graphql-mesh/types';
+export default class BareFilter implements MeshTransform {
+    noWrap: boolean;
+    typeGlobs: string[];
+    fieldsMap: Map<string, string[]>;
+    argsMap: Map<string, string[]>;
+    constructor({ config: { filters } }: {
+        config: YamlConfig.FilterSchemaTransform;
+    });
+    matchInArray(rulesArray: string[], value: string): null | undefined;
+    transformSchema(schema: GraphQLSchema): GraphQLSchema;
+}

package/typings/index.d.cts

@@ -0,0 +1,10 @@
+import { YamlConfig } from '@graphql-mesh/types';
+import BareFilter from './bareFilter.cjs';
+import WrapFilter from './wrapFilter.cjs';
+interface FilterTransformConstructor {
+    new (options: {
+        config: YamlConfig.FilterSchemaTransform;
+    }): BareFilter | WrapFilter;
+}
+declare const _default: FilterTransformConstructor;
+export default _default;

package/{index.d.ts → typings/index.d.ts}

@@ -1,6 +1,6 @@
 import { YamlConfig } from '@graphql-mesh/types';
-import WrapFilter from './wrapFilter';
-import BareFilter from './bareFilter';
+import BareFilter from './bareFilter.js';
+import WrapFilter from './wrapFilter.js';
 interface FilterTransformConstructor {
     new (options: {
         config: YamlConfig.FilterSchemaTransform;

package/typings/wrapFilter.d.cts

@@ -0,0 +1,13 @@
+import { GraphQLSchema } from 'graphql';
+import { YamlConfig } from '@graphql-mesh/types';
+import { DelegationContext, SubschemaConfig, Transform } from '@graphql-tools/delegate';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+export default class WrapFilter implements Transform {
+    private transforms;
+    constructor({ config: { filters } }: {
+        config: YamlConfig.FilterSchemaTransform;
+    });
+    transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest<any, any, any, Record<string, any>, any>;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: any): ExecutionResult<any, any>;
+}

package/{wrapFilter.d.ts → typings/wrapFilter.d.ts}

@@ -1,13 +1,13 @@
+import { GraphQLSchema } from 'graphql';
 import { YamlConfig } from '@graphql-mesh/types';
 import { DelegationContext, SubschemaConfig, Transform } from '@graphql-tools/delegate';
-import { ExecutionResult, ExecutionRequest } from '@graphql-tools/utils';
-import { GraphQLSchema } from 'graphql';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 export default class WrapFilter implements Transform {
     private transforms;
     constructor({ config: { filters } }: {
         config: YamlConfig.FilterSchemaTransform;
     });
     transformSchema(originalWrappingSchema: GraphQLSchema, subschemaConfig: SubschemaConfig, transformedSchema?: GraphQLSchema): GraphQLSchema;
-    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest<Record<string, any>, any, any, Record<string, any>>;
-    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: any): ExecutionResult<Record<string, any>>;
+    transformRequest(originalRequest: ExecutionRequest, delegationContext: DelegationContext, transformationContext: Record<string, any>): ExecutionRequest<any, any, any, Record<string, any>, any>;
+    transformResult(originalResult: ExecutionResult, delegationContext: DelegationContext, transformationContext: any): ExecutionResult<any, any>;
 }

package/index.js

@@ -1,160 +0,0 @@
-'use strict';
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const utils = require('@graphql-mesh/utils');
-const wrap = require('@graphql-tools/wrap');
-const minimatch = _interopDefault(require('minimatch'));
-const utils$1 = require('@graphql-tools/utils');
-
-class WrapFilter {
-    constructor({ config: { filters } }) {
-        this.transforms = [];
-        for (const filter of filters) {
-            const [typeName, fieldNameOrGlob, argsGlob] = filter.split('.');
-            const typeMatcher = new minimatch.Minimatch(typeName);
-            // TODO: deprecate this in next major release as dscussed in #1605
-            if (!fieldNameOrGlob) {
-                this.transforms.push(new wrap.FilterTypes(type => {
-                    return typeMatcher.match(type.name);
-                }));
-                continue;
-            }
-            let fixedFieldGlob = argsGlob || fieldNameOrGlob;
-            if (fixedFieldGlob.includes('{') && !fixedFieldGlob.includes(',')) {
-                fixedFieldGlob = fieldNameOrGlob.replace('{', '').replace('}', '');
-            }
-            fixedFieldGlob = fixedFieldGlob.split(', ').join(',');
-            const globalTypeMatcher = new minimatch.Minimatch(fixedFieldGlob.trim());
-            if (typeName === 'Type') {
-                this.transforms.push(new wrap.FilterTypes(type => {
-                    return globalTypeMatcher.match(type.name);
-                }));
-                continue;
-            }
-            if (argsGlob) {
-                const fieldMatcher = new minimatch.Minimatch(fieldNameOrGlob);
-                this.transforms.push(new wrap.TransformCompositeFields((fieldTypeName, fieldName, fieldConfig) => {
-                    if (typeMatcher.match(fieldTypeName) && fieldMatcher.match(fieldName)) {
-                        const fieldArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => !globalTypeMatcher.match(argName) ? args : { ...args, [argName]: argConfig }, {});
-                        return { ...fieldConfig, args: fieldArgs };
-                    }
-                    return undefined;
-                }));
-                continue;
-            }
-            // If the glob is not for Types nor Args, finally we register Fields filters
-            this.transforms.push(new wrap.FilterRootFields((rootTypeName, rootFieldName) => {
-                if (typeMatcher.match(rootTypeName)) {
-                    return globalTypeMatcher.match(rootFieldName);
-                }
-                return true;
-            }));
-            this.transforms.push(new wrap.FilterObjectFields((objectTypeName, objectFieldName) => {
-                if (typeMatcher.match(objectTypeName)) {
-                    return globalTypeMatcher.match(objectFieldName);
-                }
-                return true;
-            }));
-            this.transforms.push(new wrap.FilterInputObjectFields((inputObjectTypeName, inputObjectFieldName) => {
-                if (typeMatcher.match(inputObjectTypeName)) {
-                    return globalTypeMatcher.match(inputObjectFieldName);
-                }
-                return true;
-            }));
-        }
-    }
-    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
-        return utils.applySchemaTransforms(originalWrappingSchema, subschemaConfig, transformedSchema, this.transforms);
-    }
-    transformRequest(originalRequest, delegationContext, transformationContext) {
-        return utils.applyRequestTransforms(originalRequest, delegationContext, transformationContext, this.transforms);
-    }
-    transformResult(originalResult, delegationContext, transformationContext) {
-        return utils.applyResultTransforms(originalResult, delegationContext, transformationContext, this.transforms);
-    }
-}
-
-class BareFilter {
-    constructor({ config: { filters } }) {
-        this.noWrap = true;
-        this.typeGlobs = [];
-        this.fieldsMap = new Map();
-        this.argsMap = new Map();
-        for (const filter of filters) {
-            const [typeName, fieldNameOrGlob, argsGlob] = filter.split('.');
-            // TODO: deprecate this in next major release as dscussed in #1605
-            if (!fieldNameOrGlob) {
-                this.typeGlobs.push(typeName);
-                continue;
-            }
-            const rawGlob = argsGlob || fieldNameOrGlob;
-            const fixedGlob = rawGlob.includes('{') && !rawGlob.includes(',') ? rawGlob.replace('{', '').replace('}', '') : rawGlob;
-            const polishedGlob = fixedGlob.split(', ').join(',').trim();
-            if (typeName === 'Type') {
-                this.typeGlobs.push(polishedGlob);
-                continue;
-            }
-            const mapName = argsGlob ? 'argsMap' : 'fieldsMap';
-            const mapKey = argsGlob ? `${typeName}.${fieldNameOrGlob}` : typeName;
-            const currentRules = this[mapName].get(mapKey) || [];
-            this[mapName].set(mapKey, [...currentRules, polishedGlob]);
-        }
-    }
-    matchInArray(rulesArray, value) {
-        for (const rule of rulesArray) {
-            const ruleMatcher = new minimatch.Minimatch(rule);
-            if (!ruleMatcher.match(value))
-                return null;
-        }
-        return undefined;
-    }
-    transformSchema(schema) {
-        const transformedSchema = utils$1.mapSchema(schema, {
-            ...(this.typeGlobs.length && {
-                [utils$1.MapperKind.TYPE]: type => this.matchInArray(this.typeGlobs, type.toString()),
-            }),
-            ...((this.fieldsMap.size || this.argsMap.size) && {
-                [utils$1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
-                    const fieldRules = this.fieldsMap.get(typeName);
-                    const wildcardArgRules = this.argsMap.get(`${typeName}.*`) || [];
-                    const fieldArgRules = this.argsMap.get(`${typeName}.${fieldName}`) || [];
-                    const argRules = wildcardArgRules.concat(fieldArgRules);
-                    const hasFieldRules = Boolean(fieldRules && fieldRules.length);
-                    const hasArgRules = Boolean(argRules && argRules.length);
-                    if (hasFieldRules && this.matchInArray(fieldRules, fieldName) === null)
-                        return null;
-                    if (!hasArgRules)
-                        return undefined;
-                    const fieldArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => this.matchInArray(argRules, argName) === null ? args : { ...args, [argName]: argConfig }, {});
-                    return { ...fieldConfig, args: fieldArgs };
-                },
-            }),
-            ...(this.fieldsMap.size && {
-                [utils$1.MapperKind.INPUT_OBJECT_FIELD]: (_, fieldName, typeName) => {
-                    const fieldRules = this.fieldsMap.get(typeName);
-                    const hasFieldRules = Boolean(fieldRules && fieldRules.length);
-                    if (hasFieldRules && this.matchInArray(fieldRules, fieldName) === null)
-                        return null;
-                    return undefined;
-                },
-            }),
-        });
-        return transformedSchema;
-    }
-}
-
-const FilterTransform = (function FilterTransform(options) {
-    if (Array.isArray(options.config)) {
-        return new WrapFilter({
-            ...options,
-            config: {
-                mode: 'wrap',
-                filters: options.config,
-            },
-        });
-    }
-    return options.config.mode === 'bare' ? new BareFilter(options) : new WrapFilter(options);
-});
-
-module.exports = FilterTransform;

package/index.mjs

@@ -1,156 +0,0 @@
-import { applySchemaTransforms, applyRequestTransforms, applyResultTransforms } from '@graphql-mesh/utils';
-import { FilterTypes, TransformCompositeFields, FilterRootFields, FilterObjectFields, FilterInputObjectFields } from '@graphql-tools/wrap';
-import minimatch from 'minimatch';
-import { mapSchema, MapperKind } from '@graphql-tools/utils';
-
-class WrapFilter {
-    constructor({ config: { filters } }) {
-        this.transforms = [];
-        for (const filter of filters) {
-            const [typeName, fieldNameOrGlob, argsGlob] = filter.split('.');
-            const typeMatcher = new minimatch.Minimatch(typeName);
-            // TODO: deprecate this in next major release as dscussed in #1605
-            if (!fieldNameOrGlob) {
-                this.transforms.push(new FilterTypes(type => {
-                    return typeMatcher.match(type.name);
-                }));
-                continue;
-            }
-            let fixedFieldGlob = argsGlob || fieldNameOrGlob;
-            if (fixedFieldGlob.includes('{') && !fixedFieldGlob.includes(',')) {
-                fixedFieldGlob = fieldNameOrGlob.replace('{', '').replace('}', '');
-            }
-            fixedFieldGlob = fixedFieldGlob.split(', ').join(',');
-            const globalTypeMatcher = new minimatch.Minimatch(fixedFieldGlob.trim());
-            if (typeName === 'Type') {
-                this.transforms.push(new FilterTypes(type => {
-                    return globalTypeMatcher.match(type.name);
-                }));
-                continue;
-            }
-            if (argsGlob) {
-                const fieldMatcher = new minimatch.Minimatch(fieldNameOrGlob);
-                this.transforms.push(new TransformCompositeFields((fieldTypeName, fieldName, fieldConfig) => {
-                    if (typeMatcher.match(fieldTypeName) && fieldMatcher.match(fieldName)) {
-                        const fieldArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => !globalTypeMatcher.match(argName) ? args : { ...args, [argName]: argConfig }, {});
-                        return { ...fieldConfig, args: fieldArgs };
-                    }
-                    return undefined;
-                }));
-                continue;
-            }
-            // If the glob is not for Types nor Args, finally we register Fields filters
-            this.transforms.push(new FilterRootFields((rootTypeName, rootFieldName) => {
-                if (typeMatcher.match(rootTypeName)) {
-                    return globalTypeMatcher.match(rootFieldName);
-                }
-                return true;
-            }));
-            this.transforms.push(new FilterObjectFields((objectTypeName, objectFieldName) => {
-                if (typeMatcher.match(objectTypeName)) {
-                    return globalTypeMatcher.match(objectFieldName);
-                }
-                return true;
-            }));
-            this.transforms.push(new FilterInputObjectFields((inputObjectTypeName, inputObjectFieldName) => {
-                if (typeMatcher.match(inputObjectTypeName)) {
-                    return globalTypeMatcher.match(inputObjectFieldName);
-                }
-                return true;
-            }));
-        }
-    }
-    transformSchema(originalWrappingSchema, subschemaConfig, transformedSchema) {
-        return applySchemaTransforms(originalWrappingSchema, subschemaConfig, transformedSchema, this.transforms);
-    }
-    transformRequest(originalRequest, delegationContext, transformationContext) {
-        return applyRequestTransforms(originalRequest, delegationContext, transformationContext, this.transforms);
-    }
-    transformResult(originalResult, delegationContext, transformationContext) {
-        return applyResultTransforms(originalResult, delegationContext, transformationContext, this.transforms);
-    }
-}
-
-class BareFilter {
-    constructor({ config: { filters } }) {
-        this.noWrap = true;
-        this.typeGlobs = [];
-        this.fieldsMap = new Map();
-        this.argsMap = new Map();
-        for (const filter of filters) {
-            const [typeName, fieldNameOrGlob, argsGlob] = filter.split('.');
-            // TODO: deprecate this in next major release as dscussed in #1605
-            if (!fieldNameOrGlob) {
-                this.typeGlobs.push(typeName);
-                continue;
-            }
-            const rawGlob = argsGlob || fieldNameOrGlob;
-            const fixedGlob = rawGlob.includes('{') && !rawGlob.includes(',') ? rawGlob.replace('{', '').replace('}', '') : rawGlob;
-            const polishedGlob = fixedGlob.split(', ').join(',').trim();
-            if (typeName === 'Type') {
-                this.typeGlobs.push(polishedGlob);
-                continue;
-            }
-            const mapName = argsGlob ? 'argsMap' : 'fieldsMap';
-            const mapKey = argsGlob ? `${typeName}.${fieldNameOrGlob}` : typeName;
-            const currentRules = this[mapName].get(mapKey) || [];
-            this[mapName].set(mapKey, [...currentRules, polishedGlob]);
-        }
-    }
-    matchInArray(rulesArray, value) {
-        for (const rule of rulesArray) {
-            const ruleMatcher = new minimatch.Minimatch(rule);
-            if (!ruleMatcher.match(value))
-                return null;
-        }
-        return undefined;
-    }
-    transformSchema(schema) {
-        const transformedSchema = mapSchema(schema, {
-            ...(this.typeGlobs.length && {
-                [MapperKind.TYPE]: type => this.matchInArray(this.typeGlobs, type.toString()),
-            }),
-            ...((this.fieldsMap.size || this.argsMap.size) && {
-                [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
-                    const fieldRules = this.fieldsMap.get(typeName);
-                    const wildcardArgRules = this.argsMap.get(`${typeName}.*`) || [];
-                    const fieldArgRules = this.argsMap.get(`${typeName}.${fieldName}`) || [];
-                    const argRules = wildcardArgRules.concat(fieldArgRules);
-                    const hasFieldRules = Boolean(fieldRules && fieldRules.length);
-                    const hasArgRules = Boolean(argRules && argRules.length);
-                    if (hasFieldRules && this.matchInArray(fieldRules, fieldName) === null)
-                        return null;
-                    if (!hasArgRules)
-                        return undefined;
-                    const fieldArgs = Object.entries(fieldConfig.args).reduce((args, [argName, argConfig]) => this.matchInArray(argRules, argName) === null ? args : { ...args, [argName]: argConfig }, {});
-                    return { ...fieldConfig, args: fieldArgs };
-                },
-            }),
-            ...(this.fieldsMap.size && {
-                [MapperKind.INPUT_OBJECT_FIELD]: (_, fieldName, typeName) => {
-                    const fieldRules = this.fieldsMap.get(typeName);
-                    const hasFieldRules = Boolean(fieldRules && fieldRules.length);
-                    if (hasFieldRules && this.matchInArray(fieldRules, fieldName) === null)
-                        return null;
-                    return undefined;
-                },
-            }),
-        });
-        return transformedSchema;
-    }
-}
-
-const FilterTransform = (function FilterTransform(options) {
-    if (Array.isArray(options.config)) {
-        return new WrapFilter({
-            ...options,
-            config: {
-                mode: 'wrap',
-                filters: options.config,
-            },
-        });
-    }
-    return options.config.mode === 'bare' ? new BareFilter(options) : new WrapFilter(options);
-});
-
-export default FilterTransform;