Merge branch 'Diluka-intersection-type-helper'

lib/services/model-properties-accessor.ts

@@ -30,7 +30,7 @@ export class ModelPropertiesAccessor {
       }
       const metadata = prototype.constructor[METADATA_FACTORY_NAME]();
       const properties = Object.keys(metadata);
-      properties.forEach(key => {
+      properties.forEach((key) => {
         createApiPropertyDecorator(metadata[key], false)(classPrototype, key);
       });
     } while (

lib/type-helpers/index.ts

@@ -1,3 +1,4 @@
+export * from './intersection-type.helper';
 export * from './omit-type.helper';
 export * from './partial-type.helper';
 export * from './pick-type.helper';

lib/type-helpers/intersection-type.helper.ts

@@ -0,0 +1,63 @@
+import { Type } from '@nestjs/common';
+import {
+  inheritTransformationMetadata,
+  inheritValidationMetadata
+} from '@nestjs/mapped-types';
+import { DECORATORS } from '../constants';
+import { ApiProperty } from '../decorators';
+import { ModelPropertiesAccessor } from '../services/model-properties-accessor';
+import { clonePluginMetadataFactory } from './mapped-types.utils';
+
+const modelPropertiesAccessor = new ModelPropertiesAccessor();
+
+export function IntersectionType<A, B>(
+  classARef: Type<A>,
+  classBRef: Type<B>
+): Type<A & B> {
+  const fieldsOfA = modelPropertiesAccessor.getModelProperties(
+    classARef.prototype
+  );
+  const fieldsOfB = modelPropertiesAccessor.getModelProperties(
+    classBRef.prototype
+  );
+
+  abstract class IntersectionTypeClass {}
+  inheritValidationMetadata(classARef, IntersectionTypeClass);
+  inheritTransformationMetadata(classARef, IntersectionTypeClass);
+  inheritValidationMetadata(classBRef, IntersectionTypeClass);
+  inheritTransformationMetadata(classBRef, IntersectionTypeClass);
+
+  clonePluginMetadataFactory(
+    IntersectionTypeClass as Type<unknown>,
+    classARef.prototype
+  );
+  clonePluginMetadataFactory(
+    IntersectionTypeClass as Type<unknown>,
+    classBRef.prototype
+  );
+
+  fieldsOfA.forEach((propertyKey) => {
+    const metadata = Reflect.getMetadata(
+      DECORATORS.API_MODEL_PROPERTIES,
+      classARef.prototype,
+      propertyKey
+    );
+    const decoratorFactory = ApiProperty(metadata);
+    decoratorFactory(IntersectionTypeClass.prototype, propertyKey);
+  });
+
+  fieldsOfB.forEach((propertyKey) => {
+    const metadata = Reflect.getMetadata(
+      DECORATORS.API_MODEL_PROPERTIES,
+      classBRef.prototype,
+      propertyKey
+    );
+    const decoratorFactory = ApiProperty(metadata);
+    decoratorFactory(IntersectionTypeClass.prototype, propertyKey);
+  });
+
+  Object.defineProperty(IntersectionTypeClass, 'name', {
+    value: `Intersection${classARef.name}${classBRef.name}`
+  });
+  return IntersectionTypeClass as Type<A & B>;
+}

lib/type-helpers/mapped-types.utils.ts

@@ -0,0 +1,43 @@
+import { Type } from '@nestjs/common';
+import { identity } from 'lodash';
+import { METADATA_FACTORY_NAME } from '../plugin/plugin-constants';
+
+export function clonePluginMetadataFactory(
+  target: Type<unknown>,
+  parent: Type<unknown>,
+  transformFn: (metadata: Record<string, any>) => Record<string, any> = identity
+) {
+  let targetMetadata = {};
+
+  do {
+    if (!parent.constructor) {
+      return;
+    }
+    if (!parent.constructor[METADATA_FACTORY_NAME]) {
+      continue;
+    }
+    const parentMetadata = parent.constructor[METADATA_FACTORY_NAME]();
+    targetMetadata = {
+      ...parentMetadata,
+      ...targetMetadata
+    };
+  } while (
+    (parent = Reflect.getPrototypeOf(parent) as Type<any>) &&
+    parent !== Object.prototype &&
+    parent
+  );
+  targetMetadata = transformFn(targetMetadata);
+
+  if (target[METADATA_FACTORY_NAME]) {
+    const originalFactory = target[METADATA_FACTORY_NAME];
+    target[METADATA_FACTORY_NAME] = () => {
+      const originalMetadata = originalFactory();
+      return {
+        ...originalMetadata,
+        ...targetMetadata
+      };
+    };
+  } else {
+    target[METADATA_FACTORY_NAME] = () => targetMetadata;
+  }
+}

lib/type-helpers/omit-type.helper.ts

@@ -1,11 +1,13 @@
 import { Type } from '@nestjs/common';
-import { DECORATORS } from '../constants';
-import { ApiProperty } from '../decorators';
-import { ModelPropertiesAccessor } from '../services/model-properties-accessor';
 import {
   inheritTransformationMetadata,
   inheritValidationMetadata
-} from './type-helpers.utils';
+} from '@nestjs/mapped-types';
+import { omit } from 'lodash';
+import { DECORATORS } from '../constants';
+import { ApiProperty } from '../decorators';
+import { ModelPropertiesAccessor } from '../services/model-properties-accessor';
+import { clonePluginMetadataFactory } from './mapped-types.utils';
 
 const modelPropertiesAccessor = new ModelPropertiesAccessor();
 
@@ -24,6 +26,12 @@ export function OmitType<T, K extends keyof T>(
   inheritValidationMetadata(classRef, OmitTypeClass, isInheritedPredicate);
   inheritTransformationMetadata(classRef, OmitTypeClass, isInheritedPredicate);
 
+  clonePluginMetadataFactory(
+    OmitTypeClass as Type<unknown>,
+    classRef.prototype,
+    (metadata: Record<string, any>) => omit(metadata, keys)
+  );
+
   fields.forEach((propertyKey) => {
     const metadata = Reflect.getMetadata(
       DECORATORS.API_MODEL_PROPERTIES,

lib/type-helpers/partial-type.helper.ts

@@ -1,12 +1,14 @@
 import { Type } from '@nestjs/common';
-import { DECORATORS } from '../constants';
-import { ApiProperty } from '../decorators';
-import { ModelPropertiesAccessor } from '../services/model-properties-accessor';
 import {
   applyIsOptionalDecorator,
   inheritTransformationMetadata,
   inheritValidationMetadata
-} from './type-helpers.utils';
+} from '@nestjs/mapped-types';
+import { mapValues } from 'lodash';
+import { DECORATORS } from '../constants';
+import { ApiProperty } from '../decorators';
+import { ModelPropertiesAccessor } from '../services/model-properties-accessor';
+import { clonePluginMetadataFactory } from './mapped-types.utils';
 
 const modelPropertiesAccessor = new ModelPropertiesAccessor();
 
@@ -17,6 +19,13 @@ export function PartialType<T>(classRef: Type<T>): Type<Partial<T>> {
   inheritValidationMetadata(classRef, PartialTypeClass);
   inheritTransformationMetadata(classRef, PartialTypeClass);
 
+  clonePluginMetadataFactory(
+    PartialTypeClass as Type<unknown>,
+    classRef.prototype,
+    (metadata: Record<string, any>) =>
+      mapValues(metadata, (item) => ({ ...item, required: false }))
+  );
+
   fields.forEach((key) => {
     const metadata =
       Reflect.getMetadata(

lib/type-helpers/pick-type.helper.ts

@@ -1,11 +1,13 @@
 import { Type } from '@nestjs/common';
-import { DECORATORS } from '../constants';
-import { ApiProperty } from '../decorators';
-import { ModelPropertiesAccessor } from '../services/model-properties-accessor';
 import {
   inheritTransformationMetadata,
   inheritValidationMetadata
-} from './type-helpers.utils';
+} from '@nestjs/mapped-types';
+import { pick } from 'lodash';
+import { DECORATORS } from '../constants';
+import { ApiProperty } from '../decorators';
+import { ModelPropertiesAccessor } from '../services/model-properties-accessor';
+import { clonePluginMetadataFactory } from './mapped-types.utils';
 
 const modelPropertiesAccessor = new ModelPropertiesAccessor();
 
@@ -24,6 +26,12 @@ export function PickType<T, K extends keyof T>(
   inheritValidationMetadata(classRef, PickTypeClass, isInheritedPredicate);
   inheritTransformationMetadata(classRef, PickTypeClass, isInheritedPredicate);
 
+  clonePluginMetadataFactory(
+    PickTypeClass as Type<unknown>,
+    classRef.prototype,
+    (metadata: Record<string, any>) => pick(metadata, keys)
+  );
+
   fields.forEach((propertyKey) => {
     const metadata = Reflect.getMetadata(
       DECORATORS.API_MODEL_PROPERTIES,

package.json

@@ -20,6 +20,7 @@
     "release": "release-it"
   },
   "dependencies": {
+    "@nestjs/mapped-types": "0.0.1",
     "lodash": "4.17.15",
     "path-to-regexp": "3.2.0"
   },