@lenne.tech/nest-server 10.8.9 → 10.8.11

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

@@ -26,7 +26,7 @@ export class Filter {
   /**
    * Generate filter query
    */
-  public static generateFilterQuery<T = any>(filter?: Partial<FilterInput>): FilterQuery<T> | any {
+  public static generateFilterQuery<T = any>(filter?: Partial<FilterInput>): any | FilterQuery<T> {
     return generateFilterQuery(filter);
   }
 
@@ -38,6 +38,39 @@ export class Filter {
   }
 }
 
+/**
+ * Convert filter arguments to a query array
+ */
+export function convertFilterArgsToQuery<T = any>(filterArgs: Partial<FilterArgs>): [FilterQuery<T>, QueryOptions] {
+  return [generateFilterQuery(filterArgs?.filter), generateFindOptions(filterArgs)];
+}
+
+/**
+ * Merge FilterArgs and FilterQueries
+ */
+export function filterMerge<T = unknown>(
+  filterArgs: Partial<FilterArgs>,
+  filterQuery: Partial<FilterQuery<T>>,
+  options?: {
+    operator?: '$and' | '$nor' | '$or';
+    queryOptions?: Partial<QueryOptions>;
+    samples?: number;
+  },
+): { filterQuery: FilterQuery<T>; queryOptions?: QueryOptions; samples?: number } {
+  const config = {
+    operator: '$and',
+    ...options,
+  };
+  const converted = convertFilterArgsToQuery(filterArgs);
+  return {
+    filterQuery: (converted[0]
+      ? { [config.operator]: [converted[0], filterQuery || {}] }
+      : filterQuery) as FilterQuery<T>,
+    queryOptions: converted[1] || config.queryOptions ? { ...converted[1], ...config.queryOptions } : undefined,
+    samples: config.samples,
+  };
+}
+
 /**
  * Helper function to create $and, $or or $nor filter
  */
@@ -104,20 +137,13 @@ export function findFilter(options?: {
   return filterOptions;
 }
 
-/**
- * Convert filter arguments to a query array
- */
-export function convertFilterArgsToQuery<T = any>(filterArgs: Partial<FilterArgs>): [FilterQuery<T>, QueryOptions] {
-  return [generateFilterQuery(filterArgs?.filter), generateFindOptions(filterArgs)];
-}
-
 /**
  * Generate filter query
  */
 export function generateFilterQuery<T = any>(
   filter?: Partial<FilterInput>,
   options?: { automaticObjectIdFiltering?: boolean },
-): FilterQuery<T> | any {
+): any | FilterQuery<T> {
   // Check filter
   if (!filter) {
     return undefined;
@@ -263,29 +289,3 @@ export function generateFindOptions(filterArgs: Partial<FilterArgs>, options?: {
 
   return queryOptions;
 }
-
-/**
- * Merge FilterArgs and FilterQueries
- */
-export function filterMerge<T = unknown>(
-  filterArgs: Partial<FilterArgs>,
-  filterQuery: Partial<FilterQuery<T>>,
-  options?: {
-    operator?: '$and' | '$nor' | '$or';
-    queryOptions?: Partial<QueryOptions>;
-    samples?: number;
-  },
-): { filterQuery: FilterQuery<T>; queryOptions?: QueryOptions; samples?: number } {
-  const config = {
-    operator: '$and',
-    ...options,
-  };
-  const converted = convertFilterArgsToQuery(filterArgs);
-  return {
-    filterQuery: (converted[0]
-      ? { [config.operator]: [converted[0], filterQuery || {}] }
-      : filterQuery) as FilterQuery<T>,
-    queryOptions: converted[1] || config.queryOptions ? { ...converted[1], ...config.queryOptions } : undefined,
-    samples: config.samples,
-  };
-}

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

@@ -139,48 +139,59 @@ export default class GraphQLHelper {
 }
 
 /**
- * Check if AST is a Field
- * @param ast
+ * Create flatten AST from FieldNode for GraphQLResolveInfo
  */
-export function isFieldNode(ast: SelectionNode): ast is FieldNode {
-  return ast.kind === 'Field';
-}
+export function flattenAST(
+  ast: FieldNode,
+  info: GraphQLResolveInfo,
+  obj: any = {},
+  config: Partial<GraphQLFieldsConfig> = {},
+) {
+  // Process configuration
+  config = Object.assign(
+    {
+      excludedFields: [],
+      processArguments: false,
+    },
+    config,
+  );
 
-/**
- * Check if ValueNode has a value field
- */
-export function isValueNodeWithValueField(value: ValueNode): value is ValueNodeWithValueField {
-  return value.kind !== 'NullValue' && value.kind !== 'ListValue' && value.kind !== 'ObjectValue';
-}
+  return getASTSelections(ast).reduce((flattened, a) => {
+    if (a.directives && a.directives.length) {
+      const { shouldInclude, shouldSkip } = getDirectiveResults(a, info);
+      // Field/fragment is not included if either the @skip condition is true or the @include condition is false
+      // https://facebook.github.io/graphql/draft/#sec--include
+      if (shouldSkip || !shouldInclude) {
+        return flattened;
+      }
+    }
 
-/**
- * Check ValueNode is a ListValue
- * @param value
- */
-export function isListValueNode(value: ValueNode): value is ListValueNode {
-  return value.kind === 'ListValue';
-}
+    if (isFieldNode(a)) {
+      const name = a.name.value;
+      if (config.excludedFields.indexOf(name) !== -1) {
+        return flattened;
+      }
 
-/**
- * Get selections of AST
- */
-export function getASTSelections(ast: FieldNode) {
-  if (ast && ast.selectionSet && ast.selectionSet.selections && ast.selectionSet.selections.length) {
-    return ast.selectionSet.selections;
-  }
+      if (flattened[name] && flattened[name] !== '__arguments') {
+        Object.assign(flattened[name], flattenAST(a, info, flattened[name]));
+      } else {
+        flattened[name] = flattenAST(a, info);
+      }
 
-  return [];
-}
+      if (config.processArguments) {
+        // check if the current field has arguments
+        if (a.arguments && a.arguments.length) {
+          Object.assign(flattened[name], {
+            __arguments: getArguments(a),
+          });
+        }
+      }
+    } else {
+      flattened = flattenAST(getAST(a, info), info, flattened);
+    }
 
-/**
- * Get AST
- */
-export function getAST(ast, info) {
-  if (ast.kind === 'FragmentSpread') {
-    const fragmentName = ast.name.value;
-    return info.fragments[fragmentName];
-  }
-  return ast;
+    return flattened;
+  }, obj);
 }
 
 /**
@@ -203,18 +214,25 @@ export function getArguments(ast: FieldNode) {
 }
 
 /**
- * Get directive value from DirectiveNode for GraphQLResolveInfo
+ * Get AST
  */
-export function getDirectiveValue(directive: DirectiveNode, info: GraphQLResolveInfo) {
-  const arg = directive.arguments?.[0]; // only arg on an include or skip directive is "if"
-  if (!arg) {
-    return;
+export function getAST(ast, info) {
+  if (ast.kind === 'FragmentSpread') {
+    const fragmentName = ast.name.value;
+    return info.fragments[fragmentName];
   }
-  if (arg.value.kind !== 'Variable') {
-    const valueNode = arg.value;
-    return isValueNodeWithValueField(valueNode) ? !!valueNode.value : false;
+  return ast;
+}
+
+/**
+ * Get selections of AST
+ */
+export function getASTSelections(ast: FieldNode) {
+  if (ast && ast.selectionSet && ast.selectionSet.selections && ast.selectionSet.selections.length) {
+    return ast.selectionSet.selections;
   }
-  return info.variableValues[arg.value.name.value];
+
+  return [];
 }
 
 /**
@@ -246,59 +264,18 @@ export function getDirectiveResults(ast: SelectionNode, info: GraphQLResolveInfo
 }
 
 /**
- * Create flatten AST from FieldNode for GraphQLResolveInfo
+ * Get directive value from DirectiveNode for GraphQLResolveInfo
  */
-export function flattenAST(
-  ast: FieldNode,
-  info: GraphQLResolveInfo,
-  obj: any = {},
-  config: Partial<GraphQLFieldsConfig> = {},
-) {
-  // Process configuration
-  config = Object.assign(
-    {
-      excludedFields: [],
-      processArguments: false,
-    },
-    config,
-  );
-
-  return getASTSelections(ast).reduce((flattened, a) => {
-    if (a.directives && a.directives.length) {
-      const { shouldInclude, shouldSkip } = getDirectiveResults(a, info);
-      // Field/fragment is not included if either the @skip condition is true or the @include condition is false
-      // https://facebook.github.io/graphql/draft/#sec--include
-      if (shouldSkip || !shouldInclude) {
-        return flattened;
-      }
-    }
-
-    if (isFieldNode(a)) {
-      const name = a.name.value;
-      if (config.excludedFields.indexOf(name) !== -1) {
-        return flattened;
-      }
-
-      if (flattened[name] && flattened[name] !== '__arguments') {
-        Object.assign(flattened[name], flattenAST(a, info, flattened[name]));
-      } else {
-        flattened[name] = flattenAST(a, info);
-      }
-
-      if (config.processArguments) {
-        // check if the current field has arguments
-        if (a.arguments && a.arguments.length) {
-          Object.assign(flattened[name], {
-            __arguments: getArguments(a),
-          });
-        }
-      }
-    } else {
-      flattened = flattenAST(getAST(a, info), info, flattened);
-    }
-
-    return flattened;
-  }, obj);
+export function getDirectiveValue(directive: DirectiveNode, info: GraphQLResolveInfo) {
+  const arg = directive.arguments?.[0]; // only arg on an include or skip directive is "if"
+  if (!arg) {
+    return;
+  }
+  if (arg.value.kind !== 'Variable') {
+    const valueNode = arg.value;
+    return isValueNodeWithValueField(valueNode) ? !!valueNode.value : false;
+  }
+  return info.variableValues[arg.value.name.value];
 }
 
 /**
@@ -326,10 +303,11 @@ export function getFields(
 }
 
 /**
- * Check if field is in GraphQLResolveInfo
+ * Check if AST is a Field
+ * @param ast
  */
-export function isInGraphQLResolveInfo(path: any, info: GraphQLResolveInfo, config: Partial<GraphQLFieldsConfig> = {}) {
-  return _.has(getFields(info, config), path);
+export function isFieldNode(ast: SelectionNode): ast is FieldNode {
+  return ast.kind === 'Field';
 }
 
 /**
@@ -338,3 +316,25 @@ export function isInGraphQLResolveInfo(path: any, info: GraphQLResolveInfo, conf
 export function isInFields(path: any, fields: any) {
   return _.has(fields, path);
 }
+
+/**
+ * Check if field is in GraphQLResolveInfo
+ */
+export function isInGraphQLResolveInfo(path: any, info: GraphQLResolveInfo, config: Partial<GraphQLFieldsConfig> = {}) {
+  return _.has(getFields(info, config), path);
+}
+
+/**
+ * Check ValueNode is a ListValue
+ * @param value
+ */
+export function isListValueNode(value: ValueNode): value is ListValueNode {
+  return value.kind === 'ListValue';
+}
+
+/**
+ * Check if ValueNode has a value field
+ */
+export function isValueNodeWithValueField(value: ValueNode): value is ValueNodeWithValueField {
+  return value.kind !== 'NullValue' && value.kind !== 'ListValue' && value.kind !== 'ObjectValue';
+}

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

@@ -466,6 +466,29 @@ export function getPlain(object: any) {
   return JSON.parse(JSON.stringify(object));
 }
 
+/**
+ * Get instance of array items (via first item)
+ */
+export function instanceofArray(arr: any[], strict = false): string {
+  let constructor: string = undefined;
+  if (!arr?.length) {
+    return constructor;
+  }
+  try {
+    constructor = arr[0].constructor;
+    if (strict) {
+      for (const item of arr) {
+        if (item.constructor !== constructor) {
+          return undefined;
+        }
+      }
+    }
+  } catch (e) {
+    return undefined;
+  }
+  return constructor;
+}
+
 /**
  * Check if parameter is an array
  */
@@ -605,13 +628,6 @@ export function isObject(parameter: any, falseFunction: (...params) => any = err
     : falseFunction(isObject);
 }
 
-/**
- * Check whether the parameter can be converted to true
- */
-export function isTrue(parameter: any, falseFunction: (...params) => any = errorFunction): boolean {
-  return !!parameter ? true : falseFunction(isTrue);
-}
-
 /**
  * Check if parameter is a string
  */
@@ -620,41 +636,10 @@ export function isString(parameter: string, falseFunction: (...params) => any =
 }
 
 /**
- * Merge plain objects deep into target object and ignores undefined
- */
-export function mergePlain(target: Record<any, any>, ...args: Record<any, any>[]): any {
-  return merge(
-    target,
-    ...args.map(
-      // Prepare records
-      item =>
-        // Return item if not an object or cloned record with undefined properties removed
-        !item ? item : filterProperties(clone(item, { circles: false }), prop => prop !== undefined),
-    ),
-  );
-}
-
-/**
- * Alternative for errorFunction
- */
-export function returnFalse(): boolean {
-  return false;
-}
-
-/**
- * Match function to use instead of switch case
- * Inspired by https://yusfuu.medium.com/dont-use-switch-or-if-else-in-javascript-instead-try-this-82f32616c269
- *
- * Example:
- * const matched = match(expr, {
- *   Oranges: 'Oranges are $0.59 a pound.',
- *   Mangoes: 'Mangoes and papayas are $2.79 a pound.',
- *   Papayas: 'Mangoes and papayas are $2.79 a pound.',
- *   default: `Sorry, we are out of ${expr}.`,
- * });
+ * Check whether the parameter can be converted to true
  */
-export function match(expression: any, cases: Record<any, any>): any {
-  return cases[expression] || cases?.default;
+export function isTrue(parameter: any, falseFunction: (...params) => any = errorFunction): boolean {
+  return !!parameter ? true : falseFunction(isTrue);
 }
 
 /**
@@ -684,45 +669,50 @@ export function mapClass<T>(
 }
 
 /**
- * Get type of array (via first item)
+ * Match function to use instead of switch case
+ * Inspired by https://yusfuu.medium.com/dont-use-switch-or-if-else-in-javascript-instead-try-this-82f32616c269
+ *
+ * Example:
+ * const matched = match(expr, {
+ *   Oranges: 'Oranges are $0.59 a pound.',
+ *   Mangoes: 'Mangoes and papayas are $2.79 a pound.',
+ *   Papayas: 'Mangoes and papayas are $2.79 a pound.',
+ *   default: `Sorry, we are out of ${expr}.`,
+ * });
  */
-export function typeofArray(arr: any[], strict = false): string {
-  let type: string = undefined;
-  if (!arr?.length) {
-    return type;
-  }
-  type = typeof arr[0];
-  if (strict) {
-    for (const item of arr) {
-      if (typeof item !== type) {
-        return undefined;
-      }
-    }
-  }
-  return type;
+export function match(expression: any, cases: Record<any, any>): any {
+  return cases[expression] || cases?.default;
 }
 
 /**
- * Get instance of array items (via first item)
+ * Merge plain objects deep into target object and ignores undefined
  */
-export function instanceofArray(arr: any[], strict = false): string {
-  let constructor: string = undefined;
-  if (!arr?.length) {
-    return constructor;
+export function mergePlain(target: Record<any, any>, ...args: Record<any, any>[]): any {
+  return merge(
+    target,
+    ...args.map(
+      // Prepare records
+      item =>
+        // Return item if not an object or cloned record with undefined properties removed
+        !item ? item : filterProperties(clone(item, { circles: false }), prop => prop !== undefined),
+    ),
+  );
+}
+
+/**
+ * Helper to avoid very slow merge of serviceOptions
+ */
+export function prepareServiceOptionsForCreate(serviceOptions: any) {
+  if (!serviceOptions) {
+    serviceOptions = {};
   }
-  try {
-    constructor = arr[0].constructor;
-    if (strict) {
-      for (const item of arr) {
-        if (item.constructor !== constructor) {
-          return undefined;
-        }
-      }
-    }
-  } catch (e) {
-    return undefined;
+  if (!serviceOptions.prepareInput) {
+    serviceOptions.prepareInput = {};
   }
-  return constructor;
+  if (serviceOptions.prepareInput.create === undefined) {
+    serviceOptions.prepareInput.create = true;
+  }
+  return serviceOptions;
 }
 
 /**
@@ -794,22 +784,6 @@ export function processDeep(
   return func(data);
 }
 
-/**
- * Helper to avoid very slow merge of serviceOptions
- */
-export function prepareServiceOptionsForCreate(serviceOptions: any) {
-  if (!serviceOptions) {
-    serviceOptions = {};
-  }
-  if (!serviceOptions.prepareInput) {
-    serviceOptions.prepareInput = {};
-  }
-  if (serviceOptions.prepareInput.create === undefined) {
-    serviceOptions.prepareInput.create = true;
-  }
-  return serviceOptions;
-}
-
 /**
  * Remove properties deep
  */
@@ -857,3 +831,29 @@ export function removePropertiesDeep(
   // Process others
   return data;
 }
+
+/**
+ * Alternative for errorFunction
+ */
+export function returnFalse(): boolean {
+  return false;
+}
+
+/**
+ * Get type of array (via first item)
+ */
+export function typeofArray(arr: any[], strict = false): string {
+  let type: string = undefined;
+  if (!arr?.length) {
+    return type;
+  }
+  type = typeof arr[0];
+  if (strict) {
+    for (const item of arr) {
+      if (typeof item !== type) {
+        return undefined;
+      }
+    }
+  }
+  return type;
+}