@graphql-mesh/transform-prefix 1.0.0-alpha-20220804093904-8e2e41f7f → 1.0.0-alpha-20230420181317-a95037648

package/cjs/barePrefix.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const shared_js_1 = require("./shared.js");
+const rootOperations = new Set(['Query', 'Mutation', 'Subscription']);
+class BarePrefix {
+    constructor(options) {
+        this.noWrap = true;
+        const { apiName, config } = options;
+        this.ignoreList = [...(config.ignore || []), ...shared_js_1.ignoreList];
+        this.includeRootOperations = config.includeRootOperations === true;
+        this.includeTypes = config.includeTypes !== false;
+        this.prefix = null;
+        if (config.value) {
+            this.prefix = config.value;
+        }
+        else if (apiName) {
+            this.prefix = `${apiName}_`;
+        }
+        if (!this.prefix) {
+            throw new Error(`Transform 'prefix' has missing config: prefix`);
+        }
+    }
+    transformSchema(schema) {
+        return (0, utils_1.mapSchema)(schema, {
+            [utils_1.MapperKind.TYPE]: (type) => {
+                if (this.includeTypes && !(0, graphql_1.isSpecifiedScalarType)(type)) {
+                    const currentName = type.name;
+                    if (!this.ignoreList.includes(currentName)) {
+                        return (0, utils_1.renameType)(type, this.prefix + currentName);
+                    }
+                }
+                return undefined;
+            },
+            [utils_1.MapperKind.ABSTRACT_TYPE]: type => {
+                if (this.includeTypes && !(0, graphql_1.isSpecifiedScalarType)(type)) {
+                    const existingResolver = type.resolveType;
+                    type.resolveType = async (data, context, info, abstractType) => {
+                        const typeName = await existingResolver(data, context, info, abstractType);
+                        return this.prefix + typeName;
+                    };
+                    const currentName = type.name;
+                    return (0, utils_1.renameType)(type, this.prefix + currentName);
+                }
+                return undefined;
+            },
+            [utils_1.MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+            ...(this.includeRootOperations && {
+                [utils_1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                    return !rootOperations.has(typeName) || // check we're in a root Type
+                        this.ignoreList.includes(typeName) || // check if type is to be ignored
+                        this.ignoreList.includes(`${typeName}.${fieldName}`) // check if field in type is to be ignored
+                        ? undefined // do not perform any change
+                        : [`${this.prefix}${fieldName}`, fieldConfig]; // apply prefix
+                },
+            }),
+        });
+    }
+}
+exports.default = BarePrefix;

package/cjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const barePrefix_js_1 = tslib_1.__importDefault(require("./barePrefix.js"));
+const wrapPrefix_js_1 = tslib_1.__importDefault(require("./wrapPrefix.js"));
+exports.default = (function PrefixTransform(options) {
+    return options.config.mode === 'bare' ? new barePrefix_js_1.default(options) : new wrapPrefix_js_1.default(options);
+});

package/cjs/package.json

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

package/cjs/shared.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ignoreList = void 0;
+const graphql_scalars_1 = require("graphql-scalars");
+exports.ignoreList = [
+    'Int',
+    'Float',
+    'String',
+    'Boolean',
+    'ID',
+    'date',
+    'hostname',
+    'regex',
+    'json-pointer',
+    'relative-json-pointer',
+    'uri-reference',
+    'uri-template',
+    'ObjMap',
+    'HttpMethod',
+    ...Object.keys(graphql_scalars_1.resolvers),
+];

package/cjs/wrapPrefix.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@graphql-mesh/utils");
+const wrap_1 = require("@graphql-tools/wrap");
+const shared_js_1 = require("./shared.js");
+class WrapPrefix {
+    constructor(options) {
+        this.transforms = [];
+        const { apiName, config } = options;
+        let prefix = null;
+        if (config.value) {
+            prefix = config.value;
+        }
+        else if (apiName) {
+            prefix = `${apiName}_`;
+        }
+        if (!prefix) {
+            throw new Error(`Transform 'prefix' has missing config: prefix`);
+        }
+        const ignoreList = [...(config.ignore || []), ...shared_js_1.ignoreList];
+        const includeTypes = config.includeTypes !== false;
+        if (includeTypes) {
+            this.transforms.push(new wrap_1.RenameTypes(typeName => ignoreList.includes(typeName) ? typeName : `${prefix}${typeName}`));
+        }
+        const includeRootOperations = config.includeRootOperations === true;
+        if (includeRootOperations) {
+            this.transforms.push(new wrap_1.RenameRootFields((typeName, fieldName) => ignoreList.includes(typeName) || ignoreList.includes(`${typeName}.${fieldName}`)
+                ? fieldName
+                : `${prefix}${fieldName}`));
+        }
+    }
+    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 = WrapPrefix;

package/esm/barePrefix.js

@@ -0,0 +1,60 @@
+import { isSpecifiedScalarType, } from 'graphql';
+import { MapperKind, mapSchema, renameType } from '@graphql-tools/utils';
+import { ignoreList as defaultIgnoreList } from './shared.js';
+const rootOperations = new Set(['Query', 'Mutation', 'Subscription']);
+export default class BarePrefix {
+    constructor(options) {
+        this.noWrap = true;
+        const { apiName, config } = options;
+        this.ignoreList = [...(config.ignore || []), ...defaultIgnoreList];
+        this.includeRootOperations = config.includeRootOperations === true;
+        this.includeTypes = config.includeTypes !== false;
+        this.prefix = null;
+        if (config.value) {
+            this.prefix = config.value;
+        }
+        else if (apiName) {
+            this.prefix = `${apiName}_`;
+        }
+        if (!this.prefix) {
+            throw new Error(`Transform 'prefix' has missing config: prefix`);
+        }
+    }
+    transformSchema(schema) {
+        return mapSchema(schema, {
+            [MapperKind.TYPE]: (type) => {
+                if (this.includeTypes && !isSpecifiedScalarType(type)) {
+                    const currentName = type.name;
+                    if (!this.ignoreList.includes(currentName)) {
+                        return renameType(type, this.prefix + currentName);
+                    }
+                }
+                return undefined;
+            },
+            [MapperKind.ABSTRACT_TYPE]: type => {
+                if (this.includeTypes && !isSpecifiedScalarType(type)) {
+                    const existingResolver = type.resolveType;
+                    type.resolveType = async (data, context, info, abstractType) => {
+                        const typeName = await existingResolver(data, context, info, abstractType);
+                        return this.prefix + typeName;
+                    };
+                    const currentName = type.name;
+                    return renameType(type, this.prefix + currentName);
+                }
+                return undefined;
+            },
+            [MapperKind.ROOT_OBJECT]() {
+                return undefined;
+            },
+            ...(this.includeRootOperations && {
+                [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
+                    return !rootOperations.has(typeName) || // check we're in a root Type
+                        this.ignoreList.includes(typeName) || // check if type is to be ignored
+                        this.ignoreList.includes(`${typeName}.${fieldName}`) // check if field in type is to be ignored
+                        ? undefined // do not perform any change
+                        : [`${this.prefix}${fieldName}`, fieldConfig]; // apply prefix
+                },
+            }),
+        });
+    }
+}

package/esm/index.js

@@ -0,0 +1,5 @@
+import BarePrefix from './barePrefix.js';
+import WrapPrefix from './wrapPrefix.js';
+export default (function PrefixTransform(options) {
+    return options.config.mode === 'bare' ? new BarePrefix(options) : new WrapPrefix(options);
+});

package/esm/shared.js

@@ -0,0 +1,18 @@
+import { resolvers as scalarsResolversMap } from 'graphql-scalars';
+export const ignoreList = [
+    'Int',
+    'Float',
+    'String',
+    'Boolean',
+    'ID',
+    'date',
+    'hostname',
+    'regex',
+    'json-pointer',
+    'relative-json-pointer',
+    'uri-reference',
+    'uri-template',
+    'ObjMap',
+    'HttpMethod',
+    ...Object.keys(scalarsResolversMap),
+];

package/esm/wrapPrefix.js

@@ -0,0 +1,39 @@
+import { applyRequestTransforms, applyResultTransforms, applySchemaTransforms, } from '@graphql-mesh/utils';
+import { RenameRootFields, RenameTypes } from '@graphql-tools/wrap';
+import { ignoreList as defaultIgnoreList } from './shared.js';
+export default class WrapPrefix {
+    constructor(options) {
+        this.transforms = [];
+        const { apiName, config } = options;
+        let prefix = null;
+        if (config.value) {
+            prefix = config.value;
+        }
+        else if (apiName) {
+            prefix = `${apiName}_`;
+        }
+        if (!prefix) {
+            throw new Error(`Transform 'prefix' has missing config: prefix`);
+        }
+        const ignoreList = [...(config.ignore || []), ...defaultIgnoreList];
+        const includeTypes = config.includeTypes !== false;
+        if (includeTypes) {
+            this.transforms.push(new RenameTypes(typeName => ignoreList.includes(typeName) ? typeName : `${prefix}${typeName}`));
+        }
+        const includeRootOperations = config.includeRootOperations === true;
+        if (includeRootOperations) {
+            this.transforms.push(new RenameRootFields((typeName, fieldName) => ignoreList.includes(typeName) || ignoreList.includes(`${typeName}.${fieldName}`)
+                ? fieldName
+                : `${prefix}${fieldName}`));
+        }
+    }
+    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-prefix",
-  "version": "1.0.0-alpha-20220804093904-8e2e41f7f",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-20220804093904-8e2e41f7f",
-    "@graphql-mesh/utils": "1.0.0-alpha-20220804093904-8e2e41f7f",
-    "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.1",
-    "@graphql-tools/utils": "8.9.0",
-    "@graphql-tools/wrap": "8.5.1",
-    "graphql-scalars": "1.17.0",
-    "tslib": "^2.4.0"
+    "@graphql-tools/delegate": "9.0.32",
+    "@graphql-tools/wrap": "9.4.2",
+    "graphql-scalars": "^1.20.4"
   },
   "repository": {
     "type": "git",
@@ -20,21 +20,28 @@
     "directory": "packages/transforms/prefix"
   },
   "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/barePrefix.d.cts

@@ -0,0 +1,11 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+export default class BarePrefix implements MeshTransform {
+    noWrap: boolean;
+    private ignoreList;
+    private includeRootOperations;
+    private includeTypes;
+    private prefix;
+    constructor(options: MeshTransformOptions<YamlConfig.PrefixTransformConfig>);
+    transformSchema(schema: GraphQLSchema): GraphQLSchema;
+}

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

@@ -1,5 +1,5 @@
 import { GraphQLSchema } from 'graphql';
-import { MeshTransform, YamlConfig, MeshTransformOptions } from '@graphql-mesh/types';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
 export default class BarePrefix implements MeshTransform {
     noWrap: boolean;
     private ignoreList;

package/typings/index.d.cts

@@ -0,0 +1,8 @@
+import { MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import BarePrefix from './barePrefix.cjs';
+import WrapPrefix from './wrapPrefix.cjs';
+interface PrefixTransformConstructor {
+    new (options: MeshTransformOptions<YamlConfig.Transform['prefix']>): BarePrefix | WrapPrefix;
+}
+declare const _default: PrefixTransformConstructor;
+export default _default;

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

@@ -1,6 +1,6 @@
-import { YamlConfig, MeshTransformOptions } from '@graphql-mesh/types';
-import WrapPrefix from './wrapPrefix';
-import BarePrefix from './barePrefix';
+import { MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import BarePrefix from './barePrefix.js';
+import WrapPrefix from './wrapPrefix.js';
 interface PrefixTransformConstructor {
     new (options: MeshTransformOptions<YamlConfig.Transform['prefix']>): BarePrefix | WrapPrefix;
 }

package/typings/shared.d.cts

@@ -0,0 +1 @@
+export declare const ignoreList: string[];

package/typings/shared.d.ts

@@ -0,0 +1 @@
+export declare const ignoreList: string[];

package/typings/wrapPrefix.d.cts

@@ -0,0 +1,11 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import { DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
+export default class WrapPrefix implements MeshTransform {
+    private transforms;
+    constructor(options: MeshTransformOptions<YamlConfig.PrefixTransformConfig>);
+    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/{wrapPrefix.d.ts → typings/wrapPrefix.d.ts}

@@ -1,11 +1,11 @@
 import { GraphQLSchema } from 'graphql';
-import { MeshTransform, YamlConfig, MeshTransformOptions } from '@graphql-mesh/types';
-import { ExecutionResult, ExecutionRequest } from '@graphql-tools/utils';
-import { SubschemaConfig, DelegationContext } from '@graphql-tools/delegate';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import { DelegationContext, SubschemaConfig } from '@graphql-tools/delegate';
+import { ExecutionRequest, ExecutionResult } from '@graphql-tools/utils';
 export default class WrapPrefix implements MeshTransform {
     private transforms;
     constructor(options: MeshTransformOptions<YamlConfig.PrefixTransformConfig>);
     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,106 +0,0 @@
-'use strict';
-
-const wrap = require('@graphql-tools/wrap');
-const utils = require('@graphql-mesh/utils');
-const graphqlScalars = require('graphql-scalars');
-const graphql = require('graphql');
-const utils$1 = require('@graphql-tools/utils');
-
-class WrapPrefix {
-    constructor(options) {
-        this.transforms = [];
-        const { apiName, config } = options;
-        let prefix = null;
-        if (config.value) {
-            prefix = config.value;
-        }
-        else if (apiName) {
-            prefix = `${apiName}_`;
-        }
-        if (!prefix) {
-            throw new Error(`Transform 'prefix' has missing config: prefix`);
-        }
-        const ignoreList = [
-            ...(config.ignore || []),
-            'date',
-            'hostname',
-            'regex',
-            'json-pointer',
-            'relative-json-pointer',
-            'uri-reference',
-            'uri-template',
-            ...Object.keys(graphqlScalars.resolvers),
-        ];
-        const includeTypes = config.includeTypes !== false;
-        if (includeTypes) {
-            this.transforms.push(new wrap.RenameTypes(typeName => (ignoreList.includes(typeName) ? typeName : `${prefix}${typeName}`)));
-        }
-        const includeRootOperations = config.includeRootOperations === true;
-        if (includeRootOperations) {
-            this.transforms.push(new wrap.RenameRootFields((typeName, fieldName) => ignoreList.includes(typeName) || ignoreList.includes(`${typeName}.${fieldName}`)
-                ? fieldName
-                : `${prefix}${fieldName}`));
-        }
-    }
-    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);
-    }
-}
-
-const rootOperations = new Set(['Query', 'Mutation', 'Subscription']);
-class BarePrefix {
-    constructor(options) {
-        this.noWrap = true;
-        const { apiName, config } = options;
-        this.ignoreList = config.ignore || [];
-        this.includeRootOperations = config.includeRootOperations === true;
-        this.includeTypes = config.includeTypes !== false;
-        this.prefix = null;
-        if (config.value) {
-            this.prefix = config.value;
-        }
-        else if (apiName) {
-            this.prefix = `${apiName}_`;
-        }
-        if (!this.prefix) {
-            throw new Error(`Transform 'prefix' has missing config: prefix`);
-        }
-    }
-    transformSchema(schema) {
-        return utils$1.mapSchema(schema, {
-            [utils$1.MapperKind.TYPE]: (type) => {
-                if (this.includeTypes && !graphql.isSpecifiedScalarType(type)) {
-                    const currentName = type.name;
-                    if (!this.ignoreList.includes(currentName)) {
-                        return utils$1.renameType(type, this.prefix + currentName);
-                    }
-                }
-                return undefined;
-            },
-            [utils$1.MapperKind.ROOT_OBJECT]() {
-                return undefined;
-            },
-            ...(this.includeRootOperations && {
-                [utils$1.MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
-                    return !rootOperations.has(typeName) || // check we're in a root Type
-                        this.ignoreList.includes(typeName) || // check if type is to be ignored
-                        this.ignoreList.includes(`${typeName}.${fieldName}`) // check if field in type is to be ignored
-                        ? undefined // do not perform any change
-                        : [`${this.prefix}${fieldName}`, fieldConfig]; // apply prefix
-                },
-            }),
-        });
-    }
-}
-
-const PrefixTransform = (function PrefixTransform(options) {
-    return options.config.mode === 'bare' ? new BarePrefix(options) : new WrapPrefix(options);
-});
-
-module.exports = PrefixTransform;

package/index.mjs

@@ -1,104 +0,0 @@
-import { RenameTypes, RenameRootFields } from '@graphql-tools/wrap';
-import { applySchemaTransforms, applyRequestTransforms, applyResultTransforms } from '@graphql-mesh/utils';
-import { resolvers } from 'graphql-scalars';
-import { isSpecifiedScalarType } from 'graphql';
-import { mapSchema, MapperKind, renameType } from '@graphql-tools/utils';
-
-class WrapPrefix {
-    constructor(options) {
-        this.transforms = [];
-        const { apiName, config } = options;
-        let prefix = null;
-        if (config.value) {
-            prefix = config.value;
-        }
-        else if (apiName) {
-            prefix = `${apiName}_`;
-        }
-        if (!prefix) {
-            throw new Error(`Transform 'prefix' has missing config: prefix`);
-        }
-        const ignoreList = [
-            ...(config.ignore || []),
-            'date',
-            'hostname',
-            'regex',
-            'json-pointer',
-            'relative-json-pointer',
-            'uri-reference',
-            'uri-template',
-            ...Object.keys(resolvers),
-        ];
-        const includeTypes = config.includeTypes !== false;
-        if (includeTypes) {
-            this.transforms.push(new RenameTypes(typeName => (ignoreList.includes(typeName) ? typeName : `${prefix}${typeName}`)));
-        }
-        const includeRootOperations = config.includeRootOperations === true;
-        if (includeRootOperations) {
-            this.transforms.push(new RenameRootFields((typeName, fieldName) => ignoreList.includes(typeName) || ignoreList.includes(`${typeName}.${fieldName}`)
-                ? fieldName
-                : `${prefix}${fieldName}`));
-        }
-    }
-    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);
-    }
-}
-
-const rootOperations = new Set(['Query', 'Mutation', 'Subscription']);
-class BarePrefix {
-    constructor(options) {
-        this.noWrap = true;
-        const { apiName, config } = options;
-        this.ignoreList = config.ignore || [];
-        this.includeRootOperations = config.includeRootOperations === true;
-        this.includeTypes = config.includeTypes !== false;
-        this.prefix = null;
-        if (config.value) {
-            this.prefix = config.value;
-        }
-        else if (apiName) {
-            this.prefix = `${apiName}_`;
-        }
-        if (!this.prefix) {
-            throw new Error(`Transform 'prefix' has missing config: prefix`);
-        }
-    }
-    transformSchema(schema) {
-        return mapSchema(schema, {
-            [MapperKind.TYPE]: (type) => {
-                if (this.includeTypes && !isSpecifiedScalarType(type)) {
-                    const currentName = type.name;
-                    if (!this.ignoreList.includes(currentName)) {
-                        return renameType(type, this.prefix + currentName);
-                    }
-                }
-                return undefined;
-            },
-            [MapperKind.ROOT_OBJECT]() {
-                return undefined;
-            },
-            ...(this.includeRootOperations && {
-                [MapperKind.COMPOSITE_FIELD]: (fieldConfig, fieldName, typeName) => {
-                    return !rootOperations.has(typeName) || // check we're in a root Type
-                        this.ignoreList.includes(typeName) || // check if type is to be ignored
-                        this.ignoreList.includes(`${typeName}.${fieldName}`) // check if field in type is to be ignored
-                        ? undefined // do not perform any change
-                        : [`${this.prefix}${fieldName}`, fieldConfig]; // apply prefix
-                },
-            }),
-        });
-    }
-}
-
-const PrefixTransform = (function PrefixTransform(options) {
-    return options.config.mode === 'bare' ? new BarePrefix(options) : new WrapPrefix(options);
-});
-
-export default PrefixTransform;