fix(graphql): apply external metadata file and override fields

kamilmysliwiec · kamilmysliwiec · commit 8d95fd913554 · 2023-07-11T14:23:50.000+02:00
diff --git a/packages/graphql/lib/plugin/metadata-loader.ts b/packages/graphql/lib/plugin/metadata-loader.ts
@@ -1,6 +1,8 @@
 import { METADATA_FACTORY_NAME } from './plugin-constants';
 
 export class MetadataLoader {
+  public static readonly refreshHooks = new Set<() => void>();
+
   async load(metadata: Record<string, any>) {
     const pkgMetadata = metadata['@nestjs/graphql'];
     if (!pkgMetadata) {
@@ -10,6 +12,8 @@ export class MetadataLoader {
     if (models) {
       await this.applyMetadata(models);
     }
+
+    MetadataLoader.refreshHooks.forEach((hook) => hook());
   }
 
   private async applyMetadata(meta: Record<string, any>) {
diff --git a/packages/graphql/lib/schema-builder/storages/type-metadata.storage.ts b/packages/graphql/lib/schema-builder/storages/type-metadata.storage.ts
@@ -253,9 +253,12 @@ export class TypeMetadataStorageHost {
     );
   }
 
-  compileClassMetadata(metadata: ClassMetadata[]) {
+  compileClassMetadata(
+    metadata: ClassMetadata[],
+    options?: { overrideFields?: boolean },
+  ) {
     metadata.forEach((item) => {
-      if (!item.properties) {
+      if (!item.properties || options?.overrideFields) {
         item.properties = this.getClassFieldsByPredicate(item);
       }
       if (!item.directives) {
diff --git a/packages/graphql/lib/schema-builder/utils/get-fields-and-decorator.util.ts b/packages/graphql/lib/schema-builder/utils/get-fields-and-decorator.util.ts
@@ -13,7 +13,10 @@ import { ClassMetadata, PropertyMetadata } from '../metadata';
 import { LazyMetadataStorage } from '../storages/lazy-metadata.storage';
 import { TypeMetadataStorage } from '../storages/type-metadata.storage';
 
-export function getFieldsAndDecoratorForType<T>(objType: Type<T>) {
+export function getFieldsAndDecoratorForType<T>(
+  objType: Type<T>,
+  options?: { overrideFields?: boolean },
+) {
   const classType = Reflect.getMetadata(CLASS_TYPE_METADATA, objType);
   if (!classType) {
     throw new UnableToFindFieldsError(objType.name);
@@ -27,7 +30,7 @@ export function getFieldsAndDecoratorForType<T>(objType: Type<T>) {
     getClassMetadataAndFactoryByTargetAndType(classType, objType);
 
   TypeMetadataStorage.loadClassPluginMetadata([classMetadata]);
-  TypeMetadataStorage.compileClassMetadata([classMetadata]);
+  TypeMetadataStorage.compileClassMetadata([classMetadata], options);
 
   let fields = classMetadata?.properties;
   if (!fields) {
diff --git a/packages/graphql/lib/type-helpers/intersection-type.helper.ts b/packages/graphql/lib/type-helpers/intersection-type.helper.ts
@@ -7,6 +7,8 @@ import {
 } from '@nestjs/mapped-types';
 import { Field } from '../decorators';
 import { ClassDecoratorFactory } from '../interfaces/class-decorator-factory.interface';
+import { MetadataLoader } from '../plugin/metadata-loader';
+import { PropertyMetadata } from '../schema-builder/metadata';
 import { getFieldsAndDecoratorForType } from '../schema-builder/utils/get-fields-and-decorator.util';
 import { applyFieldDecorators } from './type-helpers.utils';
 
@@ -37,20 +39,35 @@ export function IntersectionType<A, B>(
   inheritValidationMetadata(classBRef, IntersectionObjectType);
   inheritTransformationMetadata(classBRef, IntersectionObjectType);
 
-  fields.forEach((item) => {
-    if (isFunction(item.typeFn)) {
-      /**
-       * Execute type function eagarly to update the type options object (before "clone" operation)
-       * when the passed function (e.g., @Field(() => Type)) lazily returns an array.
-       */
-      item.typeFn();
-    }
+  function applyFields(fields: PropertyMetadata[]) {
+    fields.forEach((item) => {
+      if (isFunction(item.typeFn)) {
+        /**
+         * Execute type function eagarly to update the type options object (before "clone" operation)
+         * when the passed function (e.g., @Field(() => Type)) lazily returns an array.
+         */
+        item.typeFn();
+      }
+
+      Field(item.typeFn, { ...item.options })(
+        IntersectionObjectType.prototype,
+        item.name,
+      );
+      applyFieldDecorators(IntersectionObjectType, item);
+    });
+  }
+  applyFields(fields);
+
+  MetadataLoader.refreshHooks.add(() => {
+    const { fields: fieldsA } = getFieldsAndDecoratorForType(classARef, {
+      overrideFields: true,
+    });
+    const { fields: fieldsB } = getFieldsAndDecoratorForType(classBRef, {
+      overrideFields: true,
+    });
+    const fields = [...fieldsA, ...fieldsB];
 
-    Field(item.typeFn, { ...item.options })(
-      IntersectionObjectType.prototype,
-      item.name,
-    );
-    applyFieldDecorators(IntersectionObjectType, item);
+    applyFields(fields);
   });
 
   Object.defineProperty(IntersectionObjectType, 'name', {
diff --git a/packages/graphql/lib/type-helpers/omit-type.helper.ts b/packages/graphql/lib/type-helpers/omit-type.helper.ts
@@ -7,14 +7,16 @@ import {
 } from '@nestjs/mapped-types';
 import { Field } from '../decorators';
 import { ClassDecoratorFactory } from '../interfaces/class-decorator-factory.interface';
+import { MetadataLoader } from '../plugin/metadata-loader';
+import { PropertyMetadata } from '../schema-builder/metadata';
 import { getFieldsAndDecoratorForType } from '../schema-builder/utils/get-fields-and-decorator.util';
 import { applyFieldDecorators } from './type-helpers.utils';
 
 export function OmitType<T, K extends keyof T>(
   classRef: Type<T>,
   keys: readonly K[],
   decorator?: ClassDecoratorFactory,
-): Type<Omit<T, typeof keys[number]>> {
+): Type<Omit<T, (typeof keys)[number]>> {
   const { fields, decoratorFactory } = getFieldsAndDecoratorForType(classRef);
 
   const isInheritedPredicate = (propertyKey: string) =>
@@ -33,22 +35,33 @@ export function OmitType<T, K extends keyof T>(
   inheritValidationMetadata(classRef, OmitObjectType, isInheritedPredicate);
   inheritTransformationMetadata(classRef, OmitObjectType, isInheritedPredicate);
 
-  fields
-    .filter((item) => !keys.includes(item.name as K))
-    .forEach((item) => {
-      if (isFunction(item.typeFn)) {
-        /**
-         * Execute type function eagarly to update the type options object (before "clone" operation)
-         * when the passed function (e.g., @Field(() => Type)) lazily returns an array.
-         */
-        item.typeFn();
-      }
+  function applyFields(fields: PropertyMetadata[]) {
+    fields
+      .filter((item) => !keys.includes(item.name as K))
+      .forEach((item) => {
+        if (isFunction(item.typeFn)) {
+          /**
+           * Execute type function eagarly to update the type options object (before "clone" operation)
+           * when the passed function (e.g., @Field(() => Type)) lazily returns an array.
+           */
+          item.typeFn();
+        }
 
-      Field(item.typeFn, { ...item.options })(
-        OmitObjectType.prototype,
-        item.name,
-      );
-      applyFieldDecorators(OmitObjectType, item);
+        Field(item.typeFn, { ...item.options })(
+          OmitObjectType.prototype,
+          item.name,
+        );
+        applyFieldDecorators(OmitObjectType, item);
+      });
+  }
+  applyFields(fields);
+
+  MetadataLoader.refreshHooks.add(() => {
+    const { fields } = getFieldsAndDecoratorForType(classRef, {
+      overrideFields: true,
     });
-  return OmitObjectType as Type<Omit<T, typeof keys[number]>>;
+    applyFields(fields);
+  });
+
+  return OmitObjectType as Type<Omit<T, (typeof keys)[number]>>;
 }
diff --git a/packages/graphql/lib/type-helpers/partial-type.helper.ts b/packages/graphql/lib/type-helpers/partial-type.helper.ts
@@ -8,7 +8,9 @@ import {
 } from '@nestjs/mapped-types';
 import { Field } from '../decorators';
 import { ClassDecoratorFactory } from '../interfaces/class-decorator-factory.interface';
+import { MetadataLoader } from '../plugin/metadata-loader';
 import { METADATA_FACTORY_NAME } from '../plugin/plugin-constants';
+import { PropertyMetadata } from '../schema-builder/metadata';
 import { getFieldsAndDecoratorForType } from '../schema-builder/utils/get-fields-and-decorator.util';
 import { applyFieldDecorators } from './type-helpers.utils';
 
@@ -17,7 +19,6 @@ export function PartialType<T>(
   decorator?: ClassDecoratorFactory,
 ): Type<Partial<T>> {
   const { fields, decoratorFactory } = getFieldsAndDecoratorForType(classRef);
-
   abstract class PartialObjectType {
     constructor() {
       inheritPropertyInitializers(this, classRef);
@@ -32,21 +33,24 @@ export function PartialType<T>(
   inheritValidationMetadata(classRef, PartialObjectType);
   inheritTransformationMetadata(classRef, PartialObjectType);
 
-  fields.forEach((item) => {
-    if (isFunction(item.typeFn)) {
-      /**
-       * Execute type function eagerly to update the type options object (before "clone" operation)
-       * when the passed function (e.g., @Field(() => Type)) lazily returns an array.
-       */
-      item.typeFn();
-    }
-    Field(item.typeFn, { ...item.options, nullable: true })(
-      PartialObjectType.prototype,
-      item.name,
-    );
-    applyIsOptionalDecorator(PartialObjectType, item.name);
-    applyFieldDecorators(PartialObjectType, item);
-  });
+  function applyFields(fields: PropertyMetadata[]) {
+    fields.forEach((item) => {
+      if (isFunction(item.typeFn)) {
+        /**
+         * Execute type function eagerly to update the type options object (before "clone" operation)
+         * when the passed function (e.g., @Field(() => Type)) lazily returns an array.
+         */
+        item.typeFn();
+      }
+      Field(item.typeFn, { ...item.options, nullable: true })(
+        PartialObjectType.prototype,
+        item.name,
+      );
+      applyIsOptionalDecorator(PartialObjectType, item.name);
+      applyFieldDecorators(PartialObjectType, item);
+    });
+  }
+  applyFields(fields);
 
   if (PartialObjectType[METADATA_FACTORY_NAME]) {
     const pluginFields = Object.keys(
@@ -56,6 +60,12 @@ export function PartialType<T>(
       applyIsOptionalDecorator(PartialObjectType, key),
     );
   }
+  MetadataLoader.refreshHooks.add(() => {
+    const { fields } = getFieldsAndDecoratorForType(classRef, {
+      overrideFields: true,
+    });
+    applyFields(fields);
+  });
 
   Object.defineProperty(PartialObjectType, 'name', {
     value: `Partial${classRef.name}`,
diff --git a/packages/graphql/lib/type-helpers/pick-type.helper.ts b/packages/graphql/lib/type-helpers/pick-type.helper.ts
@@ -7,14 +7,16 @@ import {
 } from '@nestjs/mapped-types';
 import { Field } from '../decorators';
 import { ClassDecoratorFactory } from '../interfaces/class-decorator-factory.interface';
+import { MetadataLoader } from '../plugin/metadata-loader';
+import { PropertyMetadata } from '../schema-builder/metadata';
 import { getFieldsAndDecoratorForType } from '../schema-builder/utils/get-fields-and-decorator.util';
 import { applyFieldDecorators } from './type-helpers.utils';
 
 export function PickType<T, K extends keyof T>(
   classRef: Type<T>,
   keys: readonly K[],
   decorator?: ClassDecoratorFactory,
-): Type<Pick<T, typeof keys[number]>> {
+): Type<Pick<T, (typeof keys)[number]>> {
   const { fields, decoratorFactory } = getFieldsAndDecoratorForType(classRef);
 
   const isInheritedPredicate = (propertyKey: string) =>
@@ -34,22 +36,32 @@ export function PickType<T, K extends keyof T>(
   inheritValidationMetadata(classRef, PickObjectType, isInheritedPredicate);
   inheritTransformationMetadata(classRef, PickObjectType, isInheritedPredicate);
 
-  fields
-    .filter((item) => keys.includes(item.name as K))
-    .forEach((item) => {
-      if (isFunction(item.typeFn)) {
-        /**
-         * Execute type function eagarly to update the type options object (before "clone" operation)
-         * when the passed function (e.g., @Field(() => Type)) lazily returns an array.
-         */
-        item.typeFn();
-      }
+  function applyFields(fields: PropertyMetadata[]) {
+    fields
+      .filter((item) => keys.includes(item.name as K))
+      .forEach((item) => {
+        if (isFunction(item.typeFn)) {
+          /**
+           * Execute type function eagarly to update the type options object (before "clone" operation)
+           * when the passed function (e.g., @Field(() => Type)) lazily returns an array.
+           */
+          item.typeFn();
+        }
 
-      Field(item.typeFn, { ...item.options })(
-        PickObjectType.prototype,
-        item.name,
-      );
-      applyFieldDecorators(PickObjectType, item);
+        Field(item.typeFn, { ...item.options })(
+          PickObjectType.prototype,
+          item.name,
+        );
+        applyFieldDecorators(PickObjectType, item);
+      });
+  }
+  applyFields(fields);
+
+  MetadataLoader.refreshHooks.add(() => {
+    const { fields } = getFieldsAndDecoratorForType(classRef, {
+      overrideFields: true,
     });
-  return PickObjectType as Type<Pick<T, typeof keys[number]>>;
+    applyFields(fields);
+  });
+  return PickObjectType as Type<Pick<T, (typeof keys)[number]>>;
 }

Original file line number	Diff line number	Diff line change
`@@ -253,9 +253,12 @@ export class TypeMetadataStorageHost {`
`253`	`253`	`);`
`254`	`254`	`}`
`255`	`255`
`256`		`- compileClassMetadata(metadata: ClassMetadata[]) {`
	`256`	`+ compileClassMetadata(`
	`257`	`+ metadata: ClassMetadata[],`
	`258`	`+ options?: { overrideFields?: boolean },`
	`259`	`+ ) {`
`257`	`260`	`metadata.forEach((item) => {`
`258`		`- if (!item.properties) {`
	`261`	`+ if (!item.properties \|\| options?.overrideFields) {`
`259`	`262`	`item.properties = this.getClassFieldsByPredicate(item);`
`260`	`263`	`}`
`261`	`264`	`if (!item.directives) {`