@lenne.tech/nest-server 11.0.0 → 11.1.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "11.0.0",
+  "version": "11.1.0",
   "description": "Modern, fast, powerful Node.js web framework in TypeScript based on Nest with a GraphQL API and a connection to MongoDB (or other databases).",
   "keywords": [
     "node",
@@ -70,26 +70,26 @@
     "@lenne.tech/mongoose-gridfs": "1.4.2",
     "@lenne.tech/multer-gridfs-storage": "5.0.6",
     "@nestjs/apollo": "13.1.0",
-    "@nestjs/common": "11.0.17",
-    "@nestjs/core": "11.0.17",
+    "@nestjs/common": "11.1.0",
+    "@nestjs/core": "11.1.0",
     "@nestjs/graphql": "13.1.0",
     "@nestjs/jwt": "11.0.0",
     "@nestjs/mongoose": "11.0.3",
     "@nestjs/passport": "11.0.5",
-    "@nestjs/platform-express": "11.0.17",
-    "@nestjs/schedule": "5.0.1",
-    "@nestjs/swagger": "11.1.3",
+    "@nestjs/platform-express": "11.1.0",
+    "@nestjs/schedule": "6.0.0",
+    "@nestjs/swagger": "11.2.0",
     "@nestjs/terminus": "11.0.0",
     "apollo-server-core": "3.13.0",
     "apollo-server-express": "3.13.0",
     "bcrypt": "5.1.1",
     "class-transformer": "0.5.1",
-    "class-validator": "0.14.1",
+    "class-validator": "0.14.2",
     "compression": "1.8.0",
     "cookie-parser": "1.4.7",
     "dotenv": "16.5.0",
     "ejs": "3.1.10",
-    "graphql": "16.10.0",
+    "graphql": "16.11.0",
     "graphql-query-complexity": "1.1.0",
     "graphql-subscriptions": "3.0.0",
     "graphql-upload": "15.0.2",
@@ -97,12 +97,12 @@
     "json-to-graphql-query": "2.3.0",
     "light-my-request": "6.6.0",
     "lodash": "4.17.21",
-    "mongodb": "6.15.0",
-    "mongoose": "7.8.6",
+    "mongodb": "6.16.0",
+    "mongoose": "7.8.7",
     "multer": "1.4.5-lts.2",
     "node-mailjet": "6.0.8",
-    "nodemailer": "6.10.1",
-    "nodemon": "3.1.9",
+    "nodemailer": "7.0.3",
+    "nodemon": "3.1.10",
     "passport": "0.7.0",
     "passport-jwt": "4.0.1",
     "reflect-metadata": "0.2.2",
@@ -114,13 +114,13 @@
   "devDependencies": {
     "@babel/plugin-proposal-private-methods": "7.18.6",
     "@compodoc/compodoc": "1.1.26",
-    "@lenne.tech/eslint-config-ts": "1.0.8",
-    "@nestjs/cli": "11.0.6",
+    "@lenne.tech/eslint-config-ts": "2.0.1",
+    "@nestjs/cli": "11.0.7",
     "@nestjs/schematics": "11.0.5",
-    "@nestjs/testing": "11.0.17",
-    "@swc/cli": "0.6.0",
-    "@swc/core": "1.11.21",
-    "@swc/jest": "0.2.37",
+    "@nestjs/testing": "11.1.0",
+    "@swc/cli": "0.7.5",
+    "@swc/core": "1.11.24",
+    "@swc/jest": "0.2.38",
     "@types/compression": "1.7.5",
     "@types/cookie-parser": "1.4.8",
     "@types/ejs": "3.1.5",
@@ -128,15 +128,15 @@
     "@types/jest": "29.5.14",
     "@types/lodash": "4.17.16",
     "@types/multer": "1.4.12",
-    "@types/node": "22.14.1",
+    "@types/node": "22.15.17",
     "@types/nodemailer": "6.4.17",
     "@types/passport": "1.0.17",
     "@types/supertest": "6.0.3",
-    "@typescript-eslint/eslint-plugin": "8.30.1",
-    "@typescript-eslint/parser": "8.30.1",
+    "@typescript-eslint/eslint-plugin": "8.32.0",
+    "@typescript-eslint/parser": "8.32.0",
     "coffeescript": "2.7.0",
-    "eslint": "9.24.0",
-    "eslint-config-prettier": "10.1.2",
+    "eslint": "9.26.0",
+    "eslint-config-prettier": "10.1.5",
     "eslint-plugin-unused-imports": "4.1.4",
     "find-file-up": "2.0.1",
     "grunt": "1.6.1",

package/src/core/common/args/filter.args.ts

@@ -1,6 +1,6 @@
-import { ArgsType, Field } from '@nestjs/graphql';
-import { IsOptional } from 'class-validator';
+import { ArgsType } from '@nestjs/graphql';
 
+import { UnifiedField } from '../decorators/unified-field.decorator';
 import { FilterInput } from '../inputs/filter.input';
 import { PaginationArgs } from './pagination.args';
 
@@ -9,20 +9,17 @@ export class FilterArgs extends PaginationArgs {
   /**
    * Filtering
    */
-  @Field(() => FilterInput, {
-    description: 'Input for filtering',
-    nullable: true,
+  @UnifiedField({
+    isOptional: true,
+    type: FilterInput,
   })
-  @IsOptional()
   filter?: FilterInput = undefined;
 
   /**
    * Get a specific number of random samples from filter results
    */
-  @Field(() => Number, {
-    description:
-      'Request only a specified number of samples from the filter results; if not specified, all results are returned.',
-    nullable: true,
+  @UnifiedField({
+    isOptional: true,
   })
   samples?: number = undefined;
 

package/src/core/common/args/pagination.args.ts

@@ -1,6 +1,6 @@
-import { ArgsType, Field, Int } from '@nestjs/graphql';
-import { IsOptional } from 'class-validator';
+import { ArgsType, Int } from '@nestjs/graphql';
 
+import { UnifiedField } from '../decorators/unified-field.decorator';
 import { maps } from '../helpers/model.helper';
 import { CoreInput } from '../inputs/core-input.input';
 import { SortInput } from '../inputs/sort.input';
@@ -10,51 +10,51 @@ export class PaginationArgs extends CoreInput {
   /**
    * Limit for pagination
    */
-  @Field(() => Int, {
+  @UnifiedField({
     description: 'Limit specifies the maximum number of elements found that are to be returned',
-    nullable: true,
+    isOptional: true,
+    type: Int,
   })
-  @IsOptional()
   limit?: number = undefined;
 
   /**
    * Alias for skip
    */
-  @Field(() => Int, {
+  @UnifiedField({
     description: 'Alias for skip',
-    nullable: true,
+    isOptional: true,
+    type: Int,
   })
-  @IsOptional()
   offset?: number = undefined;
 
   /**
    * Skip for pagination
    */
-  @Field(() => Int, {
+  @UnifiedField({
     description: 'Skip specifies how many found elements should be skipped on return',
-    nullable: true,
+    isOptional: true,
+    type: Int,
   })
-  @IsOptional()
   skip?: number = undefined;
 
   /**
    * Sorting for pagination
    */
-  @Field(() => [SortInput], {
+  @UnifiedField({
     description: 'Sorting the returned elements',
-    nullable: true,
+    isOptional: true,
+    type: () => SortInput,
   })
-  @IsOptional()
   sort?: SortInput[] = undefined;
 
   /**
    * Alias for limit
    */
-  @Field(() => Int, {
+  @UnifiedField({
     description: 'Alias for limit',
-    nullable: true,
+    isOptional: true,
+    type: () => Int,
   })
-  @IsOptional()
   take?: number = undefined;
 
   // ===================================================================================================================

package/src/core/common/decorators/graphql-service-options.decorator.ts

@@ -1,4 +1,5 @@
 import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+import { GqlExecutionContext } from '@nestjs/graphql';
 
 import { currentUserDec, graphqlPopulateDec } from '../helpers/decorator.helper';
 import { ServiceOptions } from '../interfaces/service-options.interface';
@@ -8,6 +9,7 @@ import { ServiceOptions } from '../interfaces/service-options.interface';
  *
  * Includes following properties of ServiceOptions:
  *  - currentUser
+ *  - language
  *  - populate
  *
  * Configuration via Decorator data:
@@ -22,8 +24,14 @@ import { ServiceOptions } from '../interfaces/service-options.interface';
  */
 export const GraphQLServiceOptions = createParamDecorator(
   (data: { gqlPath?: string; ignoreSelections?: boolean }, ctx: ExecutionContext): ServiceOptions => {
+    const gqlContext = GqlExecutionContext.create(ctx);
+    const request = gqlContext.getContext().req;
+
+    const language = request?.headers?.['accept-language'];
+
     return {
       currentUser: currentUserDec(null, ctx),
+      language,
       populate: graphqlPopulateDec(data, ctx),
     };
   },

package/src/core/common/decorators/rest-service-options.decorator.ts

@@ -0,0 +1,22 @@
+import { createParamDecorator, ExecutionContext } from '@nestjs/common';
+
+import { currentUserDec } from '../helpers/decorator.helper';
+import { ServiceOptions } from '../interfaces/service-options.interface';
+
+/**
+ * Get standard ServiceOptions for REST-Requests
+ *
+ * Includes following properties of ServiceOptions:
+ *  - currentUser
+ *  - language
+ */
+export const RESTServiceOptions = createParamDecorator((ctx: ExecutionContext): ServiceOptions => {
+  const request = ctx.switchToHttp().getRequest();
+
+  const language = request?.headers?.['accept-language'];
+
+  return {
+    currentUser: currentUserDec(null, ctx),
+    language,
+  };
+});

package/src/core/common/decorators/restricted.decorator.ts

@@ -1,13 +1,12 @@
 import { UnauthorizedException } from '@nestjs/common';
 import 'reflect-metadata';
+import _ = require('lodash');
 
 import { ProcessType } from '../enums/process-type.enum';
 import { RoleEnum } from '../enums/role.enum';
 import { equalIds, getIncludedIds } from '../helpers/db.helper';
 import { RequireAtLeastOne } from '../types/required-at-least-one.type';
 
-import _ = require('lodash');
-
 /**
  * Restricted meta key
  */

package/src/core/common/decorators/translatable.decorator.ts

@@ -0,0 +1,24 @@
+import 'reflect-metadata';
+
+const TRANSLATABLE_KEY = 'custom:translatable';
+
+export function getTranslatablePropertyKeys(target: unknown): string[] {
+  // for classes
+  if (typeof target === 'function') {
+    return Reflect.getMetadata(TRANSLATABLE_KEY, target) || [];
+  }
+
+  // for instances
+  if (typeof target === 'object' && target.constructor) {
+    return Reflect.getMetadata(TRANSLATABLE_KEY, target.constructor) || [];
+  }
+
+  return [];
+}
+
+export function Translatable(): PropertyDecorator {
+  return (target: object, propertyKey: string | symbol) => {
+    const existingProperties: string[] = Reflect.getMetadata(TRANSLATABLE_KEY, target.constructor) || [];
+    Reflect.defineMetadata(TRANSLATABLE_KEY, [...existingProperties, propertyKey], target.constructor);
+  };
+}

package/src/core/common/decorators/unified-field.decorator.ts

@@ -0,0 +1,243 @@
+import { Field, FieldOptions } from '@nestjs/graphql';
+import { ApiProperty, ApiPropertyOptional, ApiPropertyOptions } from '@nestjs/swagger';
+import { EnumAllowedTypes } from '@nestjs/swagger/dist/interfaces/schema-object-metadata.interface';
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsBoolean,
+  IsDate,
+  IsEnum,
+  IsNotEmpty,
+  IsNumber,
+  IsObject,
+  IsOptional,
+  IsString,
+  ValidateIf,
+  ValidateNested,
+  ValidationOptions,
+} from 'class-validator';
+import { GraphQLScalarType } from 'graphql';
+
+import { RoleEnum } from '../enums/role.enum';
+import { Restricted, RestrictedType } from './restricted.decorator';
+
+export interface UnifiedFieldOptions {
+  /**
+   * Indicates whether the property is an array.
+   *
+   * This value is typically determined automatically based on the property type or metadata.
+   *
+   * However, cases involving complex or dynamic type definitions (e.g., union types, generics, or factory functions)
+   * may result in inaccurate detection.
+   *
+   * When in doubt, explicitly set this property to ensure correct behavior.
+   */
+  array?: boolean;
+  /** Description used for both Swagger & Gql */
+  description?: string;
+  /** Enum for class-validator */
+  enum?: { enum: EnumAllowedTypes; options?: ValidationOptions };
+  /** Example value for swagger api documentation */
+  example?: any;
+  /** Options for graphql */
+  gqlOptions?: FieldOptions;
+  /** Default: false */
+  isOptional?: boolean;
+  /** Restricted roles */
+  roles?: RestrictedType | RoleEnum | RoleEnum[];
+  /** Options for swagger api documentation */
+  swaggerApiOptions?: ApiPropertyOptions;
+  /** Type of the field, if not specified, it will be determined automatically.
+   *
+   * Required if the field is an array (inferred automatically or via the array flag).
+   *
+   * Enums should be defined via the enum option.
+   *
+   * Supports:
+   * - A factory function that returns the type: `() => MyType`
+   * - A GraphQL scalar: `GraphQLScalarType`
+   * - A class constructor: `MyClass`
+   * */
+  type?: (() => any) | GraphQLScalarType | (new (...args: any[]) => any) | Record<number | string, number | string>; // Enums;
+  /** Condition for validation */
+  validateIf?: (obj: any, val: any) => boolean;
+  /** Validation options for class-validator */
+  validationOptions?: ValidationOptions;
+  /** Custom validators, when using this option, all built-in validators are ignored */
+  validator?: (opts: ValidationOptions) => PropertyDecorator[];
+}
+
+export function UnifiedField(opts: UnifiedFieldOptions = {}): PropertyDecorator {
+  return (target: any, propertyKey: string | symbol) => {
+    const metadataType = Reflect.getMetadata('design:type', target, propertyKey);
+    const userType = opts.type;
+    const isArrayField = opts.array === true || metadataType === Array;
+
+    // Throwing because metatype only returns the generic array, but not the type of the array items
+    if (metadataType === Array && !userType) {
+      throw new Error(`Array field '${String(propertyKey)}' of '${String(target)}' must have an explicit type`);
+    }
+
+    const resolvedTypeFn = (): any => {
+        if (opts.enum?.enum) {
+          return opts.enum.enum; // Ensure enums are handled directly
+        }
+      if (userType) {
+        if (userType instanceof GraphQLScalarType) { // Case if it's a scalar
+          return userType;
+        }
+        if (
+          typeof userType === 'function'
+          && userType.prototype
+          && userType.prototype.constructor === userType
+        ) { // Case if it's a function
+          return userType;
+        }
+        try { // case if its a factory
+          return (userType as () => any)();
+        } catch {
+          return userType;
+        }
+      }
+      return metadataType;
+    };
+
+    const baseType = resolvedTypeFn();
+
+    // Prepare merged options
+    const gqlOpts: FieldOptions = { ...opts.gqlOptions };
+    const swaggerOpts: ApiPropertyOptions = { ...opts.swaggerApiOptions };
+    const valOpts: ValidationOptions = { ...opts.validationOptions };
+
+    // Optionality
+    if (opts.isOptional) {
+      gqlOpts.nullable = true;
+      swaggerOpts.nullable = true;
+    } else {
+      gqlOpts.nullable = false;
+      swaggerOpts.nullable = false;
+    }
+
+    // Description
+    const defaultDesc = opts.description ?? `${String(propertyKey)} of ${target.constructor.name}`;
+    gqlOpts.description = gqlOpts.description ?? defaultDesc;
+    swaggerOpts.description = swaggerOpts.description ?? defaultDesc;
+
+    // Swagger example
+    if (opts.example !== undefined) {
+      swaggerOpts.example = swaggerOpts.example ?? opts.example;
+    }
+
+    if (opts.enum && opts.enum.enum) {
+      swaggerOpts.enum = opts.enum.enum;
+    }
+    // Array handling
+    if (isArrayField) {
+      swaggerOpts.isArray = true;
+      IsArray(valOpts)(target, propertyKey);
+      valOpts.each = true;
+    }
+
+    if (opts.isOptional) {
+      IsOptional(valOpts)(target, propertyKey);
+    }
+
+    // Type function for gql
+    const gqlTypeFn = isArrayField
+      ? () => [opts.enum?.enum || resolvedTypeFn()]
+      : () => opts.enum?.enum || resolvedTypeFn();
+
+    // Gql decorator
+    Field(gqlTypeFn, gqlOpts)(target, propertyKey);
+
+    const ApiDec = opts.isOptional ? ApiPropertyOptional : ApiProperty;
+
+    ApiDec({
+      deprecated: swaggerOpts.deprecated,
+      description: swaggerOpts.description,
+      enum: swaggerOpts.enum,
+      example: swaggerOpts.example,
+      examples: swaggerOpts.examples,
+      isArray: swaggerOpts.isArray,
+      nullable: swaggerOpts.nullable,
+      pattern: swaggerOpts.pattern,
+      type: () => resolvedTypeFn(),
+    })(target, propertyKey);
+
+    // Conditional validation
+    if (opts.validateIf) {
+      ValidateIf(opts.validateIf)(target, propertyKey);
+    }
+
+    // isOptional validation
+    if (opts.isOptional) {
+      IsOptional()(target, propertyKey);
+    } else {
+      IsNotEmpty()(target, propertyKey);
+    }
+
+    // Custom or builtin validator
+    if (opts.validator) {
+      opts.validator(valOpts).forEach(d => d(target, propertyKey));
+    } else {
+      const validator = getBuiltInValidator(baseType, valOpts, isArrayField, target);
+      if (validator) {
+        validator(target, propertyKey);
+      }
+    }
+
+    // Enum validation
+    if (opts.enum) {
+      IsEnum(opts.enum.enum, opts.enum.options)(target, propertyKey);
+    }
+
+    // Check if it's a primitive, if not apply transform
+    if (!isPrimitive(baseType) && !opts.enum && !isGraphQLScalar(baseType)) {
+      Type(() => baseType)(target, propertyKey);
+      ValidateNested({ each: isArrayField })(target, propertyKey);
+    }
+
+    // Roles
+    if (opts.roles) {
+      const rolesArr = Array.isArray(opts.roles) ? opts.roles : [opts.roles];
+      Restricted(...rolesArr)(target, propertyKey);
+    }
+  };
+}
+
+function getBuiltInValidator(
+  type: any,
+  opts: ValidationOptions,
+  each: boolean,
+  target: any,
+): ((t: any, k: string | symbol) => void) | null {
+  const map = new Map<any, PropertyDecorator>([
+    [Boolean, IsBoolean(opts)],
+    [Date, IsDate(opts)],
+    [Number, IsNumber({}, opts)],
+    [Object, IsObject(opts)],
+    [String, IsString(opts)],
+  ]);
+  const decorator = map.get(type);
+  if (!decorator) {
+    return null;
+  }
+  if (each) {
+    return (t, k) => decorator(target, k);
+  }
+  return decorator;
+}
+
+function isGraphQLScalar(type: any): boolean {
+  // CustomScalar check (The CustomScalar interface implements these functions below)
+  return type
+    && typeof type === 'function'
+    && typeof type.prototype?.serialize === 'function'
+    && typeof type.prototype?.parseValue === 'function'
+    && typeof type.prototype?.parseLiteral === 'function'
+    || type instanceof GraphQLScalarType;
+}
+
+function isPrimitive(fn: any): boolean {
+  return [Boolean, Date, Number, String].includes(fn);
+}

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

@@ -1,9 +1,8 @@
 import * as dotenv from 'dotenv';
+import _ = require('lodash');
 import * as process from 'node:process';
 import { join } from 'path';
 
-import _ = require('lodash');
-
 /**
  * Helper class for configurations
  * @deprecated use functions directly
@@ -28,8 +27,6 @@ export default class Config {
   }
 }
 
-
-
 /**
  * Get environment configuration (deeply merged into config object set via options)
  *

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

@@ -1,4 +1,5 @@
 import { FieldNode, GraphQLResolveInfo, SelectionNode } from 'graphql';
+import _ = require('lodash');
 import { Document, Model, PopulateOptions, Query, Types } from 'mongoose';
 
 import { ResolveSelector } from '../interfaces/resolve-selector.interface';
@@ -8,8 +9,6 @@ import { IdsType } from '../types/ids.type';
 import { StringOrObjectId } from '../types/string-or-object-id.type';
 import { removePropertiesDeep } from './input.helper';
 
-import _ = require('lodash');
-
 // =====================================================================================================================
 // Export functions
 // =====================================================================================================================

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

@@ -12,7 +12,6 @@ import {
   ValueNode,
   VariableNode,
 } from 'graphql';
-
 import _ = require('lodash');
 
 /**

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

@@ -4,6 +4,8 @@ import { validate } from 'class-validator';
 import { ValidatorOptions } from 'class-validator/types/validation/ValidatorOptions';
 import { Kind } from 'graphql/index';
 import * as inspector from 'inspector';
+import _ = require('lodash');
+import rfdc = require('rfdc');
 import * as util from 'util';
 
 import { checkRestricted } from '../decorators/restricted.decorator';
@@ -12,9 +14,6 @@ import { RoleEnum } from '../enums/role.enum';
 import { merge } from './config.helper';
 import { equalIds } from './db.helper';
 
-import _ = require('lodash');
-import rfdc = require('rfdc');
-
 /**
  * Helper class for inputs
  * @deprecated use functions directly

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

@@ -1,8 +1,11 @@
 import { UnauthorizedException } from '@nestjs/common';
+import bcrypt = require('bcrypt');
 import { plainToInstance } from 'class-transformer';
 import { sha256 } from 'js-sha256';
+import _ = require('lodash');
 import { Types } from 'mongoose';
 
+import { getTranslatablePropertyKeys } from '../decorators/translatable.decorator';
 import { RoleEnum } from '../enums/role.enum';
 import { PrepareInputOptions } from '../interfaces/prepare-input-options.interface';
 import { PrepareOutputOptions } from '../interfaces/prepare-output-options.interface';
@@ -12,9 +15,6 @@ import { ConfigService } from '../services/config.service';
 import { getStringIds } from './db.helper';
 import { clone, processDeep } from './input.helper';
 
-import bcrypt = require('bcrypt');
-import _ = require('lodash');
-
 /**
  * Helper class for services
  * @deprecated use functions directly
@@ -187,6 +187,7 @@ export async function prepareOutput<T = { [key: string]: any; map: (...args: any
     circles?: boolean;
     clone?: boolean;
     getNewArray?: boolean;
+    language?: string;
     objectIdsToStrings?: boolean;
     proto?: boolean;
     removeSecrets?: boolean;
@@ -273,6 +274,20 @@ export async function prepareOutput<T = { [key: string]: any; map: (...args: any
     }
   }
 
+  // Add translated values of current selected language if _translations object exists
+  if (config.targetModel && config.language && typeof output === 'object' && '_translations' in output) {
+    const translation = output._translations?.[options.language];
+
+    if (typeof translation === 'object') {
+      const keys = getTranslatablePropertyKeys(config.targetModel);
+      for (const key of keys) {
+        if (translation[key] != null) {
+          output[key] = translation[key];
+        }
+      }
+    }
+  }
+
   // Return prepared output
   return output;
 }