@iamnnort/nestjs-serializer 1.1.3 → 1.1.6

package/dist/index.mjs

@@ -9026,7 +9026,7 @@ var import_operators = __toESM(require_operators());
 import { Injectable as Injectable2 } from "@nestjs/common";
 
 // src/service.ts
-import { flattenDeep, isArray, isFunction, isNil, isPlainObject, merge, set, uniq } from "lodash";
+import { flattenDeep, isArray, isFunction, isNil, isPlainObject, merge, pick, set, uniq } from "lodash";
 import { Inject, Injectable } from "@nestjs/common";
 
 // src/module-definition.ts
@@ -9061,31 +9061,36 @@ var SerializerService = class {
     this.config = config;
     this.globalEntityNames = config.globalEntityNames || [];
   }
-  async transform(response, scopes) {
-    if (!scopes) {
+  async transform(response, config) {
+    if (!config.scopes && !config.fields) {
       return response;
     }
     if (!isNil(response.pagination) && !isNil(response.data)) {
       const transformedData = await Promise.all(response.data.map((entity) => {
-        return this.transformEntity(entity, scopes);
+        return this.transformEntity(entity, config);
       }));
       response.data = transformedData;
       return response;
     }
     if (isArray(response)) {
       const transformedEntities = await Promise.all(response.map((entity) => {
-        return this.transformEntity(entity, scopes);
+        return this.transformEntity(entity, config);
       }));
       return transformedEntities;
     }
-    const transformedEntity = await this.transformEntity(response, scopes);
+    const transformedEntity = await this.transformEntity(response, config);
     return transformedEntity;
   }
-  async transformEntity(entity, scopes = []) {
-    console.log("1", entity);
+  async transformEntity(entity, config) {
     if (!entity) {
       return entity;
     }
+    if (!config.scopes && !config.fields) {
+      return entity;
+    }
+    if (config.fields) {
+      return pick(entity, config.fields);
+    }
     const serializerFieldConfigs = global.serializerFieldConfigs.filter((fieldConfig) => {
       const isTarget = fieldConfig.target === entity.constructor;
       if (!isTarget) {
@@ -9095,11 +9100,13 @@ var SerializerService = class {
         }
       }
       const isScope = fieldConfig.scopes.some((scope) => {
-        return scopes.includes(scope);
+        if (!config.scopes) {
+          return false;
+        }
+        return config.scopes.includes(scope);
       });
       return isScope;
     });
-    console.log("2", serializerFieldConfigs);
     let transformedEntity = {};
     await Promise.all(serializerFieldConfigs.map(async (fieldConfig) => {
       const fieldName = fieldConfig.fieldName || fieldConfig.name;
@@ -9107,14 +9114,18 @@ var SerializerService = class {
       if (!isNil(fieldConfig.relationScopes)) {
         if (isArray(fieldValue)) {
           fieldValue = await Promise.all(fieldValue.map(async (relationEntity) => {
-            let relationEntityFieldValue = await this.transformEntity(relationEntity, fieldConfig.relationScopes);
+            let relationEntityFieldValue = await this.transformEntity(relationEntity, {
+              scopes: fieldConfig.relationScopes
+            });
             if (isFunction(fieldConfig.fieldTransform)) {
               relationEntityFieldValue = await fieldConfig.fieldTransform(relationEntityFieldValue);
             }
             return relationEntityFieldValue;
           }));
         } else {
-          fieldValue = await this.transformEntity(fieldValue, fieldConfig.relationScopes);
+          fieldValue = await this.transformEntity(fieldValue, {
+            scopes: fieldConfig.relationScopes
+          });
           if (isFunction(fieldConfig.fieldTransform)) {
             fieldValue = await fieldConfig.fieldTransform(fieldValue);
           }
@@ -9132,7 +9143,9 @@ var SerializerService = class {
       const transformedRelatedScope = {};
       await Promise.all(Object.keys(entity.relatedScope).map(async (relaitedEntityKey) => {
         const relaitedEntity = entity.relatedScope[relaitedEntityKey];
-        transformedRelatedScope[relaitedEntityKey] = await this.transformEntity(relaitedEntity, scopes);
+        transformedRelatedScope[relaitedEntityKey] = await this.transformEntity(relaitedEntity, {
+          scopes: config.scopes
+        });
       }));
       transformedEntity.relatedScope = transformedRelatedScope;
     }
@@ -9166,7 +9179,7 @@ SerializerService = _ts_decorate([
 ], SerializerService);
 
 // src/interceptor.ts
-import { pick } from "lodash";
+import { pick as pick2 } from "lodash";
 function _ts_decorate2(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
   if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -9192,10 +9205,13 @@ var SerializerInterceptor = /* @__PURE__ */ __name((config) => {
       return next.handle().pipe((0, import_operators.map)(async (responsePromise) => {
         const response = await responsePromise;
         if (config.fields) {
-          return pick(response, config.fields);
+          return pick2(response, config.fields);
         }
         if (scopes) {
-          return this.serializerService.transform(response, scopes);
+          return this.serializerService.transform(response, {
+            scopes,
+            fields: config.fields
+          });
         }
         return response;
       }));