@graphql-mesh/merger-bare 1.0.0-alpha-20220804093904-8e2e41f7f → 1.0.0-alpha-20230420220344-25b6b92bf

package/cjs/index.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const merger_stitching_1 = tslib_1.__importDefault(require("@graphql-mesh/merger-stitching"));
+const utils_1 = require("@graphql-mesh/utils");
+const schema_1 = require("@graphql-tools/schema");
+const utils_2 = require("@graphql-tools/utils");
+class BareMerger {
+    constructor(options) {
+        this.options = options;
+        this.name = 'bare';
+    }
+    handleSingleWrappedExtendedSource(mergerCtx) {
+        // switch to stitching merger
+        this.name = 'stitching';
+        this.options.logger.debug(`Switching to Stitching merger due to the transforms and additional resolvers`);
+        this.options.logger = this.options.logger.child('Stitching Proxy');
+        this.stitchingMerger = this.stitchingMerger || new merger_stitching_1.default(this.options);
+        return this.stitchingMerger.getUnifiedSchema(mergerCtx);
+    }
+    handleSingleRegularSource({ rawSources: [rawSource], typeDefs, resolvers }) {
+        let schema = rawSource.schema;
+        if (typeDefs.length > 0 || (0, utils_2.asArray)(resolvers).length > 0) {
+            for (const typeDef of typeDefs) {
+                schema = (0, graphql_1.extendSchema)(schema, typeDef);
+            }
+            for (const resolversObj of (0, utils_2.asArray)(resolvers)) {
+                (0, schema_1.addResolversToSchema)({
+                    schema,
+                    resolvers: resolversObj,
+                    updateResolversInPlace: true,
+                });
+            }
+        }
+        this.options.logger.debug(`Attaching a dummy sourceMap to the final schema`);
+        schema.extensions = schema.extensions || {};
+        Object.defineProperty(schema.extensions, 'sourceMap', {
+            get: () => {
+                return {
+                    get() {
+                        // We should return a version of the schema only with the source-level transforms
+                        // But we should prevent the existing schema from being mutated internally
+                        const nonExecutableSchema = (0, utils_2.mapSchema)(schema);
+                        return (0, utils_1.applySchemaTransforms)(nonExecutableSchema, rawSource, nonExecutableSchema, rawSource.transforms);
+                    },
+                };
+            },
+        });
+        return {
+            ...rawSource,
+            schema,
+        };
+    }
+    async getUnifiedSchema({ rawSources, typeDefs, resolvers }) {
+        var _a;
+        if (rawSources.length === 1) {
+            if ((rawSources[0].executor || ((_a = rawSources[0].transforms) === null || _a === void 0 ? void 0 : _a.length)) &&
+                (typeDefs.length > 0 || (0, utils_2.asArray)(resolvers).length > 0)) {
+                return this.handleSingleWrappedExtendedSource({ rawSources, typeDefs, resolvers });
+            }
+            return this.handleSingleRegularSource({ rawSources, typeDefs, resolvers });
+        }
+        const sourceMap = new Map();
+        this.options.logger.debug(`Applying transforms for each source`);
+        const schemas = rawSources.map(source => {
+            let schema = source.schema;
+            let sourceLevelSchema = source.schema;
+            schema = (0, utils_1.applySchemaTransforms)(schema, undefined, schema, source.transforms);
+            // After that step, it will be considered as root level schema
+            sourceLevelSchema = schema;
+            sourceMap.set(source, sourceLevelSchema);
+            return schema;
+        });
+        this.options.logger.debug(`Merging sources`);
+        const unifiedSchema = (0, schema_1.mergeSchemas)({
+            schemas,
+            typeDefs,
+            resolvers,
+        });
+        this.options.logger.debug(`Attaching sources to the unified schema`);
+        unifiedSchema.extensions = unifiedSchema.extensions || {};
+        Object.defineProperty(unifiedSchema.extensions, 'sourceMap', {
+            get: () => sourceMap,
+        });
+        return {
+            schema: unifiedSchema,
+        };
+    }
+}
+exports.default = BareMerger;

package/cjs/package.json

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

package/{index.mjs → esm/index.js}

@@ -1,42 +1,20 @@
+import { extendSchema } from 'graphql';
+import StitchingMerger from '@graphql-mesh/merger-stitching';
 import { applySchemaTransforms } from '@graphql-mesh/utils';
 import { addResolversToSchema, mergeSchemas } from '@graphql-tools/schema';
-import { asArray, getDocumentNodeFromSchema } from '@graphql-tools/utils';
-import { wrapSchema } from '@graphql-tools/wrap';
-import { extendSchema, buildASTSchema } from 'graphql';
-
-class BareMerger {
+import { asArray, mapSchema } from '@graphql-tools/utils';
+export default class BareMerger {
     constructor(options) {
+        this.options = options;
         this.name = 'bare';
-        this.logger = options.logger;
     }
-    handleSingleWrappedExtendedSource({ rawSources: [rawSource], typeDefs, resolvers }) {
-        let schema = wrapSchema(rawSource);
-        if (typeDefs.length > 0 || asArray(resolvers).length > 0) {
-            for (const typeDef of typeDefs) {
-                schema = extendSchema(schema, typeDef);
-            }
-            for (const resolversObj of asArray(resolvers)) {
-                addResolversToSchema({
-                    schema,
-                    resolvers: resolversObj,
-                    updateResolversInPlace: true,
-                });
-            }
-        }
-        this.logger.debug(`Attaching a dummy sourceMap to the final schema`);
-        schema.extensions = schema.extensions || {};
-        Object.defineProperty(schema.extensions, 'sourceMap', {
-            get: () => {
-                return {
-                    get() {
-                        return schema;
-                    },
-                };
-            },
-        });
-        return {
-            schema,
-        };
+    handleSingleWrappedExtendedSource(mergerCtx) {
+        // switch to stitching merger
+        this.name = 'stitching';
+        this.options.logger.debug(`Switching to Stitching merger due to the transforms and additional resolvers`);
+        this.options.logger = this.options.logger.child('Stitching Proxy');
+        this.stitchingMerger = this.stitchingMerger || new StitchingMerger(this.options);
+        return this.stitchingMerger.getUnifiedSchema(mergerCtx);
     }
     handleSingleRegularSource({ rawSources: [rawSource], typeDefs, resolvers }) {
         let schema = rawSource.schema;
@@ -52,7 +30,7 @@ class BareMerger {
                 });
             }
         }
-        this.logger.debug(`Attaching a dummy sourceMap to the final schema`);
+        this.options.logger.debug(`Attaching a dummy sourceMap to the final schema`);
         schema.extensions = schema.extensions || {};
         Object.defineProperty(schema.extensions, 'sourceMap', {
             get: () => {
@@ -60,7 +38,7 @@ class BareMerger {
                     get() {
                         // We should return a version of the schema only with the source-level transforms
                         // But we should prevent the existing schema from being mutated internally
-                        const nonExecutableSchema = buildASTSchema(getDocumentNodeFromSchema(schema));
+                        const nonExecutableSchema = mapSchema(schema);
                         return applySchemaTransforms(nonExecutableSchema, rawSource, nonExecutableSchema, rawSource.transforms);
                     },
                 };
@@ -81,7 +59,7 @@ class BareMerger {
             return this.handleSingleRegularSource({ rawSources, typeDefs, resolvers });
         }
         const sourceMap = new Map();
-        this.logger.debug(`Applying transforms for each source`);
+        this.options.logger.debug(`Applying transforms for each source`);
         const schemas = rawSources.map(source => {
             let schema = source.schema;
             let sourceLevelSchema = source.schema;
@@ -91,13 +69,13 @@ class BareMerger {
             sourceMap.set(source, sourceLevelSchema);
             return schema;
         });
-        this.logger.debug(`Merging sources`);
+        this.options.logger.debug(`Merging sources`);
         const unifiedSchema = mergeSchemas({
             schemas,
             typeDefs,
             resolvers,
         });
-        this.logger.debug(`Attaching sources to the unified schema`);
+        this.options.logger.debug(`Attaching sources to the unified schema`);
         unifiedSchema.extensions = unifiedSchema.extensions || {};
         Object.defineProperty(unifiedSchema.extensions, 'sourceMap', {
             get: () => sourceMap,
@@ -107,5 +85,3 @@ class BareMerger {
         };
     }
 }
-
-export default BareMerger;

package/package.json

@@ -1,17 +1,17 @@
 {
   "name": "@graphql-mesh/merger-bare",
-  "version": "1.0.0-alpha-20220804093904-8e2e41f7f",
+  "version": "1.0.0-alpha-20230420220344-25b6b92bf",
   "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-20230420220344-25b6b92bf",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420220344-25b6b92bf",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@graphql-tools/schema": "8.5.1",
-    "@graphql-tools/utils": "8.9.0",
-    "@graphql-tools/wrap": "8.5.1",
-    "tslib": "^2.4.0"
+    "@graphql-mesh/merger-stitching": "1.0.0-alpha-20230420220344-25b6b92bf",
+    "@graphql-tools/schema": "9.0.18"
   },
   "repository": {
     "type": "git",
@@ -19,21 +19,28 @@
     "directory": "packages/mergers/bare"
   },
   "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/index.d.cts

@@ -0,0 +1,25 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshMerger, MeshMergerContext, MeshMergerOptions } from '@graphql-mesh/types';
+export default class BareMerger implements MeshMerger {
+    private options;
+    name: string;
+    private stitchingMerger;
+    constructor(options: MeshMergerOptions);
+    handleSingleWrappedExtendedSource(mergerCtx: MeshMergerContext): Promise<{
+        schema: GraphQLSchema;
+    }>;
+    handleSingleRegularSource({ rawSources: [rawSource], typeDefs, resolvers }: MeshMergerContext): {
+        schema: GraphQLSchema;
+        name: string;
+        executor?: import("@graphql-tools/utils").Executor;
+        transforms: import("@graphql-mesh/types").MeshTransform<any>[];
+        contextVariables: Record<string, string>;
+        handler: import("@graphql-mesh/types").MeshHandler;
+        batch: boolean;
+        merge?: Record<string, import("@graphql-tools/delegate").MergedTypeConfig<any, any, Record<string, any>>>;
+        createProxyingResolver: import("@graphql-tools/delegate").CreateProxyingResolverFn<any>;
+    };
+    getUnifiedSchema({ rawSources, typeDefs, resolvers }: MeshMergerContext): Promise<{
+        schema: GraphQLSchema;
+    }>;
+}

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

@@ -1,21 +1,23 @@
-import { MeshMerger, MeshMergerContext, MeshMergerOptions } from '@graphql-mesh/types';
 import { GraphQLSchema } from 'graphql';
+import { MeshMerger, MeshMergerContext, MeshMergerOptions } from '@graphql-mesh/types';
 export default class BareMerger implements MeshMerger {
+    private options;
     name: string;
-    private logger;
+    private stitchingMerger;
     constructor(options: MeshMergerOptions);
-    handleSingleWrappedExtendedSource({ rawSources: [rawSource], typeDefs, resolvers }: MeshMergerContext): {
+    handleSingleWrappedExtendedSource(mergerCtx: MeshMergerContext): Promise<{
         schema: GraphQLSchema;
-    };
+    }>;
     handleSingleRegularSource({ rawSources: [rawSource], typeDefs, resolvers }: MeshMergerContext): {
         schema: GraphQLSchema;
         name: string;
-        executor?: import("@graphql-tools/utils").Executor<Record<string, any>, Record<string, any>>;
+        executor?: import("@graphql-tools/utils").Executor;
         transforms: import("@graphql-mesh/types").MeshTransform<any>[];
         contextVariables: Record<string, string>;
         handler: import("@graphql-mesh/types").MeshHandler;
         batch: boolean;
         merge?: Record<string, import("@graphql-tools/delegate").MergedTypeConfig<any, any, Record<string, any>>>;
+        createProxyingResolver: import("@graphql-tools/delegate").CreateProxyingResolverFn<any>;
     };
     getUnifiedSchema({ rawSources, typeDefs, resolvers }: MeshMergerContext): Promise<{
         schema: GraphQLSchema;

package/index.js

@@ -1,113 +0,0 @@
-'use strict';
-
-const utils = require('@graphql-mesh/utils');
-const schema = require('@graphql-tools/schema');
-const utils$1 = require('@graphql-tools/utils');
-const wrap = require('@graphql-tools/wrap');
-const graphql = require('graphql');
-
-class BareMerger {
-    constructor(options) {
-        this.name = 'bare';
-        this.logger = options.logger;
-    }
-    handleSingleWrappedExtendedSource({ rawSources: [rawSource], typeDefs, resolvers }) {
-        let schema$1 = wrap.wrapSchema(rawSource);
-        if (typeDefs.length > 0 || utils$1.asArray(resolvers).length > 0) {
-            for (const typeDef of typeDefs) {
-                schema$1 = graphql.extendSchema(schema$1, typeDef);
-            }
-            for (const resolversObj of utils$1.asArray(resolvers)) {
-                schema.addResolversToSchema({
-                    schema: schema$1,
-                    resolvers: resolversObj,
-                    updateResolversInPlace: true,
-                });
-            }
-        }
-        this.logger.debug(`Attaching a dummy sourceMap to the final schema`);
-        schema$1.extensions = schema$1.extensions || {};
-        Object.defineProperty(schema$1.extensions, 'sourceMap', {
-            get: () => {
-                return {
-                    get() {
-                        return schema$1;
-                    },
-                };
-            },
-        });
-        return {
-            schema: schema$1,
-        };
-    }
-    handleSingleRegularSource({ rawSources: [rawSource], typeDefs, resolvers }) {
-        let schema$1 = rawSource.schema;
-        if (typeDefs.length > 0 || utils$1.asArray(resolvers).length > 0) {
-            for (const typeDef of typeDefs) {
-                schema$1 = graphql.extendSchema(schema$1, typeDef);
-            }
-            for (const resolversObj of utils$1.asArray(resolvers)) {
-                schema.addResolversToSchema({
-                    schema: schema$1,
-                    resolvers: resolversObj,
-                    updateResolversInPlace: true,
-                });
-            }
-        }
-        this.logger.debug(`Attaching a dummy sourceMap to the final schema`);
-        schema$1.extensions = schema$1.extensions || {};
-        Object.defineProperty(schema$1.extensions, 'sourceMap', {
-            get: () => {
-                return {
-                    get() {
-                        // We should return a version of the schema only with the source-level transforms
-                        // But we should prevent the existing schema from being mutated internally
-                        const nonExecutableSchema = graphql.buildASTSchema(utils$1.getDocumentNodeFromSchema(schema$1));
-                        return utils.applySchemaTransforms(nonExecutableSchema, rawSource, nonExecutableSchema, rawSource.transforms);
-                    },
-                };
-            },
-        });
-        return {
-            ...rawSource,
-            schema: schema$1,
-        };
-    }
-    async getUnifiedSchema({ rawSources, typeDefs, resolvers }) {
-        var _a;
-        if (rawSources.length === 1) {
-            if ((rawSources[0].executor || ((_a = rawSources[0].transforms) === null || _a === void 0 ? void 0 : _a.length)) &&
-                (typeDefs.length > 0 || utils$1.asArray(resolvers).length > 0)) {
-                return this.handleSingleWrappedExtendedSource({ rawSources, typeDefs, resolvers });
-            }
-            return this.handleSingleRegularSource({ rawSources, typeDefs, resolvers });
-        }
-        const sourceMap = new Map();
-        this.logger.debug(`Applying transforms for each source`);
-        const schemas = rawSources.map(source => {
-            let schema = source.schema;
-            let sourceLevelSchema = source.schema;
-            schema = utils.applySchemaTransforms(schema, undefined, schema, source.transforms);
-            // After that step, it will be considered as root level schema
-            sourceLevelSchema = schema;
-            sourceMap.set(source, sourceLevelSchema);
-            return schema;
-        });
-        this.logger.debug(`Merging sources`);
-        const unifiedSchema = schema.mergeSchemas({
-            schemas,
-            typeDefs,
-            resolvers,
-        });
-        this.logger.debug(`Attaching sources to the unified schema`);
-        unifiedSchema.extensions = unifiedSchema.extensions || {};
-        Object.defineProperty(unifiedSchema.extensions, 'sourceMap', {
-            get: () => sourceMap,
-        });
-        return {
-            schema: unifiedSchema,
-        };
-    }
-}
-
-module.exports = BareMerger;