@lenne.tech/nest-server 8.0.2 → 8.3.0

package/src/core/common/helpers/file.helper.ts

@@ -4,39 +4,22 @@ import { extname } from 'path';
 
 /**
  * Helper class for inputs
+ * @deprecated use functions directly
  */
-export class FileHelper {
+export default class FileHelper {
   /**
    * Get function to generate a random file name for multer with a certain
    * number of digits
    */
   public static multerRandomFileName(numberOfDigits = 32) {
-    return (req, file, cb) => {
-      // Generating a random string
-      const randomName = Array(numberOfDigits)
-        .fill(null)
-        .map(() => Math.round(Math.random() * 16).toString(16))
-        .join('');
-
-      // Calling the callback passing the random name generated with the
-      // original extension name
-      cb(null, `${randomName}${extname(file.originalname)}`);
-    };
+    return multerRandomFileName(numberOfDigits);
   }
 
   /**
    * Get function to filter files for multer with a certain mimetype & extname
    */
   public static multerFileFilter(fileTypeRegex = /jpeg|jpg|png/) {
-    return (req, file, cb) => {
-      const mimetype = fileTypeRegex.test(file.mimetype);
-      const extName = fileTypeRegex.test(extname(file.originalname).toLowerCase());
-
-      if (mimetype && extName) {
-        return cb(null, true);
-      }
-      cb('Error: File upload only supports the following filetypes - ' + fileTypeRegex);
-    };
+    return multerFileFilter(fileTypeRegex);
   }
 
   /**
@@ -47,36 +30,80 @@ export class FileHelper {
     fileSize?: number;
     fileTypeRegex?: RegExp;
   }): MulterOptions {
-    // Default options
-    options = Object.assign(
-      {
-        fileSize: 1024 * 1024, // 1MB
-        fileTypeRegex: /jpeg|jpg|png/, // Images only
-      },
-      options
-    );
+    return multerOptionsForImageUpload(options);
+  }
+}
+
+/**
+ * Get function to generate a random file name for multer with a certain
+ * number of digits
+ */
+export function multerRandomFileName(numberOfDigits = 32) {
+  return (req, file, cb) => {
+    // Generating a random string
+    const randomName = Array(numberOfDigits)
+      .fill(null)
+      .map(() => Math.round(Math.random() * 16).toString(16))
+      .join('');
+
+    // Calling the callback passing the random name generated with the
+    // original extension name
+    cb(null, `${randomName}${extname(file.originalname)}`);
+  };
+}
 
-    return {
-      // File filter
-      fileFilter: options.fileTypeRegex ? FileHelper.multerFileFilter(options.fileTypeRegex) : undefined,
+/**
+ * Get function to filter files for multer with a certain mimetype & extname
+ */
+export function multerFileFilter(fileTypeRegex = /jpeg|jpg|png/) {
+  return (req, file, cb) => {
+    const mimetype = fileTypeRegex.test(file.mimetype);
+    const extName = fileTypeRegex.test(extname(file.originalname).toLowerCase());
 
-      // Limits
-      limits: {
-        // Limit of file size
-        fileSize: options.fileSize ? options.fileSize : undefined,
-      },
+    if (mimetype && extName) {
+      return cb(null, true);
+    }
+    cb('Error: File upload only supports the following filetypes - ' + fileTypeRegex);
+  };
+}
 
-      // Automatic storage handling
-      // For configuration see https://github.com/expressjs/multer#storage
-      storage: diskStorage({
-        // Destination for uploaded file
-        // If destination is not set file will be buffered and can be processed
-        // in the method
-        destination: options.destination ? options.destination : undefined,
+/**
+ * Get multer options for image upload
+ */
+export function multerOptionsForImageUpload(options: {
+  destination?: string;
+  fileSize?: number;
+  fileTypeRegex?: RegExp;
+}): MulterOptions {
+  // Default options
+  options = Object.assign(
+    {
+      fileSize: 1024 * 1024, // 1MB
+      fileTypeRegex: /jpeg|jpg|png/, // Images only
+    },
+    options
+  );
 
-        // Generated random file name
-        filename: FileHelper.multerRandomFileName(),
-      }),
-    };
-  }
+  return {
+    // File filter
+    fileFilter: options.fileTypeRegex ? multerFileFilter(options.fileTypeRegex) : undefined,
+
+    // Limits
+    limits: {
+      // Limit of file size
+      fileSize: options.fileSize ? options.fileSize : undefined,
+    },
+
+    // Automatic storage handling
+    // For configuration see https://github.com/expressjs/multer#storage
+    storage: diskStorage({
+      // Destination for uploaded file
+      // If destination is not set file will be buffered and can be processed
+      // in the method
+      destination: options.destination ? options.destination : undefined,
+
+      // Generated random file name
+      filename: multerRandomFileName(),
+    }),
+  };
 }

package/src/core/common/helpers/filter.helper.ts

@@ -7,6 +7,7 @@ import { SortInput } from '../inputs/sort.input';
 
 /**
  * Helper for filter handling
+ * @deprecated use functions directly
  */
 export class Filter {
   /**
@@ -14,121 +15,143 @@ export class Filter {
    * @param filterArgs
    */
   public static convertFilterArgsToQuery<T = any>(filterArgs: Partial<FilterArgs>): [FilterQuery<T>, QueryOptions] {
-    return [Filter.generateFilterQuery(filterArgs.filter), Filter.generateFindOptions(filterArgs)];
+    return convertFilterArgsToQuery(filterArgs);
   }
 
   /**
    * Generate filter query
    */
   public static generateFilterQuery<T = any>(filter?: Partial<FilterInput>): FilterQuery<T> | any {
-    // Check filter
-    if (!filter) {
-      return undefined;
-    }
-
-    // Init result
-    const result: any = {};
-
-    // Process combined filters
-    if (filter.combinedFilter) {
-      switch (filter.combinedFilter.logicalOperator) {
-        case LogicalOperatorEnum.AND:
-          return {
-            $and: filter.combinedFilter.filters.map((item: FilterInput) => Filter.generateFilterQuery(item)),
-          };
-        case LogicalOperatorEnum.NOR:
-          return {
-            $nor: filter.combinedFilter.filters.map((item: FilterInput) => Filter.generateFilterQuery(item)),
-          };
-        case LogicalOperatorEnum.OR:
-          return {
-            $or: filter.combinedFilter.filters.map((item: FilterInput) => Filter.generateFilterQuery(item)),
-          };
-      }
-    }
-
-    // Process single filter
-    if (filter.singleFilter) {
-      // Init variables
-      const { not, options, field, value } = filter.singleFilter;
-
-      // Convert filter
-      switch (filter.singleFilter.operator) {
-        case ComparisonOperatorEnum.EQ:
-          result[field] = not ? { $ne: value } : value;
-          break;
-        case ComparisonOperatorEnum.GT:
-          result[field] = not ? { $not: { $gt: value } } : { $gt: value };
-          break;
-        case ComparisonOperatorEnum.GTE:
-          result[field] = not ? { $not: { $gte: value } } : { $gte: value };
-          break;
-        case ComparisonOperatorEnum.IN:
-          result[field] = not ? { $nin: value } : { $in: value };
-          break;
-        case ComparisonOperatorEnum.LT:
-          result[field] = not ? { $not: { $lt: value } } : { $lt: value };
-          break;
-        case ComparisonOperatorEnum.LTE:
-          result[field] = not ? { $not: { $lte: value } } : { $lte: value };
-          break;
-        case ComparisonOperatorEnum.NE:
-          result[field] = not ? value : { $ne: value };
-          break;
-        case ComparisonOperatorEnum.NIN:
-          result[field] = not ? { $in: value } : { $nin: value };
-          break;
-        case ComparisonOperatorEnum.REGEX:
-          result[field] = not
-            ? {
-                $not: {
-                  $regex: new RegExp(value),
-                  $options: options || '',
-                },
-              }
-            : { $regex: new RegExp(value), $options: options || '' };
-          break;
-      }
-    }
-
-    // Return result
-    return result;
+    return generateFilterQuery(filter);
   }
 
   /**
    * Generate find options
    */
   public static generateFindOptions<T = any>(filterArgs: Partial<FilterArgs>): QueryOptions {
-    // Check filterArgs
-    if (!filterArgs) {
-      return {};
-    }
+    return generateFindOptions(filterArgs);
+  }
+}
 
-    // Get values
-    const { limit, offset, skip, sort, take } = filterArgs;
+/**
+ * Convert filter arguments to a query array
+ * @param filterArgs
+ */
+export function convertFilterArgsToQuery<T = any>(filterArgs: Partial<FilterArgs>): [FilterQuery<T>, QueryOptions] {
+  return [generateFilterQuery(filterArgs?.filter), generateFindOptions(filterArgs)];
+}
 
-    // Init options
-    const options: QueryOptions = {
-      limit: limit ? limit : take,
-    };
+/**
+ * Generate filter query
+ */
+export function generateFilterQuery<T = any>(filter?: Partial<FilterInput>): FilterQuery<T> | any {
+  // Check filter
+  if (!filter) {
+    return undefined;
+  }
 
-    if (skip > 0 || offset > 0) {
-      options.skip = offset ? offset : skip;
-    }
+  // Init result
+  const result: any = {};
 
-    // Check take
-    if (!options.limit || options.limit > 100) {
-      options.limit = 25;
+  // Process combined filters
+  if (filter.combinedFilter) {
+    switch (filter.combinedFilter.logicalOperator) {
+      case LogicalOperatorEnum.AND:
+        return {
+          $and: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item)),
+        };
+      case LogicalOperatorEnum.NOR:
+        return {
+          $nor: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item)),
+        };
+      case LogicalOperatorEnum.OR:
+        return {
+          $or: filter.combinedFilter.filters.map((item: FilterInput) => generateFilterQuery(item)),
+        };
     }
+  }
+
+  // Process single filter
+  if (filter.singleFilter) {
+    // Init variables
+    const { not, options, field, value } = filter.singleFilter;
 
-    // Prepare order
-    if (sort) {
-      options.sort = {};
-      sort.forEach((item: SortInput) => {
-        options.sort[item.field] = item.order;
-      });
+    // Convert filter
+    switch (filter.singleFilter.operator) {
+      case ComparisonOperatorEnum.EQ:
+        result[field] = not ? { $ne: value } : value;
+        break;
+      case ComparisonOperatorEnum.GT:
+        result[field] = not ? { $not: { $gt: value } } : { $gt: value };
+        break;
+      case ComparisonOperatorEnum.GTE:
+        result[field] = not ? { $not: { $gte: value } } : { $gte: value };
+        break;
+      case ComparisonOperatorEnum.IN:
+        result[field] = not ? { $nin: value } : { $in: value };
+        break;
+      case ComparisonOperatorEnum.LT:
+        result[field] = not ? { $not: { $lt: value } } : { $lt: value };
+        break;
+      case ComparisonOperatorEnum.LTE:
+        result[field] = not ? { $not: { $lte: value } } : { $lte: value };
+        break;
+      case ComparisonOperatorEnum.NE:
+        result[field] = not ? value : { $ne: value };
+        break;
+      case ComparisonOperatorEnum.NIN:
+        result[field] = not ? { $in: value } : { $nin: value };
+        break;
+      case ComparisonOperatorEnum.REGEX:
+        result[field] = not
+          ? {
+              $not: {
+                $regex: new RegExp(value),
+                $options: options || '',
+              },
+            }
+          : { $regex: new RegExp(value), $options: options || '' };
+        break;
     }
+  }
+
+  // Return result
+  return result;
+}
+
+/**
+ * Generate find options
+ */
+export function generateFindOptions<T = any>(filterArgs: Partial<FilterArgs>): QueryOptions {
+  // Check filterArgs
+  if (!filterArgs) {
+    return {};
+  }
+
+  // Get values
+  const { limit, offset, skip, sort, take } = filterArgs;
+
+  // Init options
+  const options: QueryOptions = {
+    limit: limit ? limit : take,
+  };
+
+  if (skip > 0 || offset > 0) {
+    options.skip = offset ? offset : skip;
+  }
+
+  // Check take
+  if (!options.limit || options.limit > 100) {
+    options.limit = 25;
+  }
 
-    return options;
+  // Prepare order
+  if (sort) {
+    options.sort = {};
+    sort.forEach((item: SortInput) => {
+      options.sort[item.field] = item.order;
+    });
   }
+
+  return options;
 }