proof of concept

mapSchema can support copying graphql object annotations, but annotations will have to be copied for every graphql object whenever a new schema, type, enumValue, field, argument, is created. this change just covers type annotations with symbols and property annotations for object types
ardatan · May 20, 2020 · ba6791c · ba6791c
1 parent ab926bb
commit ba6791c
Show file tree

Hide file tree

Showing 5 changed files with 98 additions and 20 deletions.
diff --git a/packages/utils/src/annotate.ts b/packages/utils/src/annotate.ts
@@ -0,0 +1,19 @@
+import { GraphQLNamedType, isObjectType } from 'graphql';
+
+export function annotateType<T extends GraphQLNamedType>(newType: T, originalType: T): T {
+  const symbols = Object.getOwnPropertySymbols(originalType);
+  symbols.forEach(symbol => {
+    newType[symbol] = originalType[symbol];
+  });
+
+  if (isObjectType(newType)) {
+    const names = Object.getOwnPropertyNames(originalType);
+    const objectPropertyNames = ['name', 'description', 'isTypeOf', 'extensions', 'astNode', 'extensionASTNodes'];
+    names.forEach(name => {
+      if (!objectPropertyNames.includes(name) && !name.startsWith('_')) {
+        newType[name] = originalType[name];
+      }
+    });
+  }
+  return newType;
+}
diff --git a/packages/utils/src/index.ts b/packages/utils/src/index.ts
@@ -44,3 +44,4 @@ export * from './updateArgument';
 export * from './implementsAbstractType';
 export * from './errors';
 export * from './toConfig';
+export * from './annotate';
diff --git a/packages/utils/src/mapSchema.ts b/packages/utils/src/mapSchema.ts
@@ -40,6 +40,7 @@ import {
 
 import { rewireTypes } from './rewire';
 import { serializeInputValue, parseInputValue } from './transformInputValue';
+import { annotateType } from './annotate';
 
 export function mapSchema(schema: GraphQLSchema, schemaMapper: SchemaMapper = {}): GraphQLSchema {
   const originalTypeMap = schema.getTypeMap();
@@ -98,18 +99,27 @@ function mapTypes(
   Object.keys(originalTypeMap).forEach(typeName => {
     if (!typeName.startsWith('__')) {
       const originalType = originalTypeMap[typeName];
-      if (originalType != null && testFn(originalType)) {
-        const typeMapper = getTypeMapper(schema, schemaMapper, typeName);
-
-        if (typeMapper != null) {
-          const maybeNewType = typeMapper(originalType, schema);
-          newTypeMap[typeName] = maybeNewType !== undefined ? maybeNewType : originalType;
-        } else {
-          newTypeMap[typeName] = originalType;
-        }
-      } else {
+
+      if (originalType == null || !testFn(originalType)) {
+        newTypeMap[typeName] = originalType;
+        return;
+      }
+
+      const typeMapper = getTypeMapper(schema, schemaMapper, typeName);
+
+      if (typeMapper == null) {
         newTypeMap[typeName] = originalType;
+        return;
       }
+
+      const maybeNewType = typeMapper(originalType, schema);
+
+      if (maybeNewType === undefined) {
+        newTypeMap[typeName] = originalType;
+        return;
+      }
+
+      newTypeMap[typeName] = annotateType(maybeNewType, originalType);
     }
   });
 
@@ -237,10 +247,13 @@ function mapFields(originalTypeMap: TypeMap, schema: GraphQLSchema, schemaMapper
       });
 
       if (isObjectType(originalType)) {
-        newTypeMap[typeName] = new GraphQLObjectType({
-          ...((config as unknown) as GraphQLObjectTypeConfig<any, any>),
-          fields: newFieldConfigMap,
-        });
+        newTypeMap[typeName] = annotateType(
+          new GraphQLObjectType({
+            ...((config as unknown) as GraphQLObjectTypeConfig<any, any>),
+            fields: newFieldConfigMap,
+          }),
+          originalType
+        );
       } else if (isInterfaceType(originalType)) {
         newTypeMap[typeName] = new GraphQLInterfaceType({
           ...((config as unknown) as GraphQLInterfaceTypeConfig<any, any>),
@@ -319,10 +332,13 @@ function mapArguments(originalTypeMap: TypeMap, schema: GraphQLSchema, schemaMap
       });
 
       if (isObjectType(originalType)) {
-        newTypeMap[typeName] = new GraphQLObjectType({
-          ...((config as unknown) as GraphQLObjectTypeConfig<any, any>),
-          fields: newFieldConfigMap,
-        });
+        newTypeMap[typeName] = annotateType(
+          new GraphQLObjectType({
+            ...((config as unknown) as GraphQLObjectTypeConfig<any, any>),
+            fields: newFieldConfigMap,
+          }),
+          originalType
+        );
       } else if (isInterfaceType(originalType)) {
         newTypeMap[typeName] = new GraphQLInterfaceType({
           ...((config as unknown) as GraphQLInterfaceTypeConfig<any, any>),

diff --git a/packages/utils/src/rewire.ts b/packages/utils/src/rewire.ts
@@ -27,6 +27,7 @@ import {
 
 import { getBuiltInForStub, isNamedStub } from './stub';
 import { TypeMap } from './Interfaces';
+import { annotateType } from './annotate';
 
 export function rewireTypes(
   originalTypeMap: Record<string, GraphQLNamedType | null>,
@@ -62,7 +63,7 @@ export function rewireTypes(
   });
 
   Object.keys(newTypeMap).forEach(typeName => {
-    newTypeMap[typeName] = rewireNamedType(newTypeMap[typeName]);
+    newTypeMap[typeName] = annotateType(rewireNamedType(newTypeMap[typeName]), newTypeMap[typeName]);
   });
 
   const newDirectives = directives.map(directive => rewireDirective(directive));

diff --git a/packages/utils/tests/mapSchema.test.ts b/packages/utils/tests/mapSchema.test.ts
@@ -1,4 +1,4 @@
-import { GraphQLObjectType, GraphQLSchema, graphqlSync } from 'graphql';
+import { GraphQLObjectType, GraphQLSchema, graphqlSync, GraphQLString } from 'graphql';
 
 import { makeExecutableSchema } from '@graphql-tools/schema';
 import { MapperKind, mapSchema } from '@graphql-tools/utils';
@@ -60,4 +60,45 @@ describe('mapSchema', () => {
     expect(newSchema).toBeInstanceOf(GraphQLSchema);
     expect(newSchema.getQueryType().name).toBe('RootQuery');
   });
+
+  test('can copy nonstandard properties', () => {
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          'test': {
+            type: GraphQLString
+          }
+        }
+      })
+    });
+
+    const symbol = Symbol('symbol');
+
+    Object.defineProperty(
+      schema.getQueryType(),
+      symbol,
+      {
+        enumerable: false,
+        configurable: false,
+        value: symbol,
+      }
+    );
+
+    Object.defineProperty(
+      schema.getQueryType(),
+      'value',
+      {
+        enumerable: false,
+        configurable: false,
+        value: 'value',
+      }
+    );
+
+    const newSchema = mapSchema(schema, {});
+
+    expect(newSchema).toBeInstanceOf(GraphQLSchema);
+    expect((newSchema.getQueryType() as unknown as { symbol: symbol })[symbol]).toBe(symbol);
+    expect((newSchema.getQueryType() as unknown as { value: string }).value).toBe('value');
+  });
 });