@lenne.tech/nest-server 8.6.17 → 8.6.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "8.6.17",
+  "version": "8.6.20",
   "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",

package/src/config.env.ts

@@ -12,9 +12,11 @@ const config: { [env: string]: IServerOptions } = {
   local: {
     cronJobs: {
       sayHello: {
-        cronTime: CronExpression.EVERY_5_MINUTES,
-        timeZone: 'Europe/Berlin',
+        cronTime: CronExpression.EVERY_10_SECONDS,
         runOnInit: false,
+        runParallel: 1,
+        timeZone: 'Europe/Berlin',
+        throwException: false,
       },
     },
     email: {

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

@@ -0,0 +1,18 @@
+/**
+ * Wait a certain number of milliseconds
+ */
+export function sleep(ms: number) {
+  return new Promise<void>((resolve) => {
+    setTimeout(() => {
+      resolve();
+    }, ms);
+  });
+}
+
+/**
+ * Wait a certain number of milliseconds
+ * Alias of sleep
+ */
+export function wait(ms: number) {
+  return sleep(ms);
+}

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

@@ -175,9 +175,10 @@ export function mapClasses<T = Record<string, any>>(
   }
 
   // Process input
-  for (const [prop, value] of Object.entries(input)) {
-    if (prop in mapping) {
-      const targetClass = mapping[prop] as any;
+  for (const [prop, mapTarget] of Object.entries(mapping)) {
+    if (prop in input) {
+      const targetClass = mapTarget as any;
+      const value = input[prop];
 
       // Process array
       if (Array.isArray(value)) {
@@ -250,9 +251,10 @@ export async function mapClassesAsync<T = Record<string, any>>(
   }
 
   // Process input
-  for (const [prop, value] of Object.entries(input)) {
-    if (prop in mapping) {
-      const targetClass = mapping[prop] as any;
+  for (const [prop, mapTarget] of Object.entries(mapping)) {
+    if (prop in input) {
+      const targetClass = mapTarget as any;
+      const value = input[prop];
 
       // Process array
       if (Array.isArray(value)) {

package/src/core/common/interfaces/cron-job-config.interface.ts

@@ -24,11 +24,24 @@ export interface CronJobConfig {
   onComplete?: CronCommand | null;
 
   /**
-   * This will immediately fire your `onTickfunction as soon as the requisit initialization has happened.
-   * This option is set to ``true``` by default.
+   * This will immediately fire your `onTickfunction` as soon as the requisit initialization has happened.
+   * This option is set to `true` by default.
    */
   runOnInit?: boolean;
 
+  /**
+   * Depending on how long the execution of a job takes, it may happen that several executions take place at the
+   * same time. This can be prevented with `runParallel = false`.This option is set to `true` by default.
+   * If a number is specified, it is used as the number of maximum parallel executions.
+   */
+  runParallel?: boolean | number;
+
+  /**
+   * Whether an exception is thrown or only acknowledged with a console.error.
+   * This option is set to `true` by default.
+   */
+  throwException?: boolean;
+
   /**
    * Specify the timezone for the execution. This will modify the actual time relative to your timezone.
    * If the timezone is invalid, an error is thrown. Can be any string accepted by luxon's `DateTime.setZone()`

package/src/core/common/services/core-cron-jobs.service.ts

@@ -15,6 +15,11 @@ export abstract class CoreCronJobs {
     log: boolean;
   };
 
+  /**
+   * Cron jobs that are currently running
+   */
+  runningJobs: Record<string, Date[]> = {};
+
   // ===================================================================================================================
   // Initializations
   // ===================================================================================================================
@@ -51,18 +56,20 @@ export abstract class CoreCronJobs {
       }
 
       // Prepare config
-      let config: CronExpression | string | Date | Falsy | CronJobConfig = CronExpressionOrConfig;
-      if (typeof config === 'string' || config instanceof Date) {
-        config = {
-          cronTime: config,
+      let conf: CronExpression | string | Date | Falsy | CronJobConfig = CronExpressionOrConfig;
+      if (typeof conf === 'string' || conf instanceof Date) {
+        conf = {
+          cronTime: conf,
         };
       }
 
       // Set defaults
-      config = {
-        timeZone: 'Europe/Berlin',
+      const config: CronJobConfig = {
         runOnInit: true,
-        ...config,
+        runParallel: true,
+        throwException: true,
+        timeZone: 'Europe/Berlin',
+        ...conf,
       };
 
       // Check if cron job should be activated
@@ -81,8 +88,40 @@ export abstract class CoreCronJobs {
       // Init cron job
       const job = new CronJob(
         config.cronTime,
-        () => {
-          this[name]();
+        async () => {
+          // Get current processes of cron job
+          const dates = this.runningJobs[name];
+
+          // Check if parallel execution is allowed and if so how many can run in parallel
+          if (
+            dates?.length &&
+            (!config.runParallel || (typeof config.runParallel === 'number' && dates.length >= config.runParallel))
+          ) {
+            return;
+          }
+
+          // Prepare the acquisition of parallel job executions
+          if (!this.runningJobs[name]) {
+            this.runningJobs[name] = [];
+          }
+          const date = new Date();
+          this.runningJobs[name].push(date);
+
+          // Execute the job and wait until job process is done
+          try {
+            await this[name]();
+          } catch (e) {
+            // Remove job from running list
+            this.runningJobs[name] = this.runningJobs[name].filter((item) => item !== date);
+            if (config.throwException) {
+              throw e;
+            } else {
+              console.error(e);
+            }
+          }
+
+          // Remove job from running list
+          this.runningJobs[name] = this.runningJobs[name].filter((item) => item !== date);
         },
         null,
         true,

package/src/core/common/services/crud.service.ts

@@ -2,6 +2,7 @@ import { NotFoundException } from '@nestjs/common';
 import { FilterQuery, QueryOptions } from 'mongoose';
 import { FilterArgs } from '../args/filter.args';
 import { merge } from '../helpers/config.helper';
+import { getStringIds } from '../helpers/db.helper';
 import { convertFilterArgsToQuery } from '../helpers/filter.helper';
 import { assignPlain } from '../helpers/input.helper';
 import { ServiceOptions } from '../interfaces/service-options.interface';
@@ -58,6 +59,34 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
     );
   }
 
+  /**
+   * Find and update
+   */
+  async findAndUpdate(
+    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    update: any,
+    serviceOptions?: ServiceOptions
+  ): Promise<T[]> {
+    const dbItems: T[] = await this.find(filter, serviceOptions);
+    if (!dbItems?.length) {
+      return [];
+    }
+    const promises: Promise<T>[] = [];
+    for (const dbItem of dbItems) {
+      promises.push(
+        new Promise(async (resolve, reject) => {
+          try {
+            const item = await this.update(getStringIds(dbItem as any), update, serviceOptions);
+            resolve(item);
+          } catch (e) {
+            reject(e);
+          }
+        })
+      );
+    }
+    return await Promise.all(promises);
+  }
+
   /**
    * CRUD alias for get
    */
@@ -66,12 +95,18 @@ export abstract class CrudService<T extends CoreModel = any> extends ModuleServi
   /**
    * CRUD alias for find
    */
-  async read(filterArgs?: FilterArgs, serviceOptions?: ServiceOptions): Promise<T[]>;
+  async read(
+    filter: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    serviceOptions?: ServiceOptions
+  ): Promise<T[]>;
 
   /**
    * CRUD alias for get or find
    */
-  async read(input: string | FilterArgs, serviceOptions?: ServiceOptions): Promise<T | T[]> {
+  async read(
+    input: string | FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    serviceOptions?: ServiceOptions
+  ): Promise<T | T[]> {
     if (typeof input === 'string') {
       return this.get(input, serviceOptions);
     } else {

package/src/core/common/types/plain-input.type.ts

@@ -1,5 +1,5 @@
 /**
- * Type for plain Inputs
+ * Type for plain inputs with only optional properties
  */
 export type PlainInput<T> = {
   [P in keyof T]?: Partial<T[P]> | Partial<PlainInput<T[P]>>;

package/src/core/common/types/remove-methods.type.ts

@@ -0,0 +1,4 @@
+/**
+ * Type for plain object with only properties and no methods
+ */
+export type RemoveMethods<T> = { [P in keyof T as T[P] extends (...args: any) => any ? never : P]: T[P] };

package/src/core/common/types/string-or-object-id.type.ts

@@ -1,3 +1,6 @@
 import { Types } from 'mongoose';
 
-export type StringOrObjectId = string | Types.ObjectId | any;
+/**
+ * Everything which will be used by getStringIds or getObjectIds (see helpers/db.helper.ts)
+ */
+export type StringOrObjectId<T = any> = string | Types.ObjectId | T;

package/src/core/modules/file/core-file.service.ts

@@ -1,5 +1,5 @@
 import { NotFoundException } from '@nestjs/common';
-import { GridFSBucket, GridFSBucketReadStreamOptions } from 'mongodb';
+import { GridFSBucket, GridFSBucketReadStream, GridFSBucketReadStreamOptions } from 'mongodb';
 import { Connection, Types } from 'mongoose';
 import { createBucket, MongoGridFSOptions, MongooseGridFS } from 'mongoose-gridfs';
 import { FilterArgs } from '../../common/args/filter.args';
@@ -115,7 +115,7 @@ export abstract class CoreFileService {
     if (!(await this.checkRights(id, { ...serviceOptions, checkInputType: 'id' }))) {
       return null;
     }
-    return this.files.openDownloadStream(getObjectIds(id));
+    return this.files.openDownloadStream(getObjectIds(id)) as GridFSBucketReadStream;
   }
 
   /**

package/src/core/modules/file/interfaces/file-service-options.interface.ts

@@ -3,5 +3,6 @@
  */
 export interface FileServiceOptions {
   currentUser?: { id: any; hasRole: (roles: string[]) => boolean };
+  force?: boolean;
   roles?: string | string[];
 }

package/src/index.ts

@@ -18,6 +18,7 @@ export * from './core/common/enums/logical-operator.enum';
 export * from './core/common/enums/process-type.enum';
 export * from './core/common/enums/role.enum';
 export * from './core/common/enums/sort-order.emum';
+export * from './core/common/helpers/common.helper';
 export * from './core/common/helpers/config.helper';
 export * from './core/common/helpers/context.helper';
 export * from './core/common/helpers/db.helper';
@@ -61,6 +62,7 @@ export * from './core/common/types/field-selection.type';
 export * from './core/common/types/ids.type';
 export * from './core/common/types/maybe-promise.type';
 export * from './core/common/types/plain-input.type';
+export * from './core/common/types/remove-methods.type';
 export * from './core/common/types/require-only-one.type';
 export * from './core/common/types/required-at-least-one.type';
 export * from './core/common/types/string-or-object-id.type';

package/src/server/common/services/cron-jobs.service.ts

@@ -20,7 +20,10 @@ export class CronJobs extends CoreCronJobs {
   // Cron jobs
   // ===================================================================================================================
 
-  protected sayHello() {
+  protected async sayHello() {
     console.log('Hello :)');
+    await new Promise<void>((resolve) => {
+      setTimeout(() => resolve(), 30000);
+    });
   }
 }

package/src/test/test.helper.ts

@@ -4,10 +4,12 @@ import * as fs from 'fs';
 import { createClient } from 'graphql-ws';
 import { jsonToGraphQLQuery } from 'json-to-graphql-query';
 import * as LightMyRequest from 'light-my-request';
+import { Types } from 'mongoose';
 import * as superagent from 'superagent';
 import * as supertest from 'supertest';
 import * as util from 'util';
 import * as ws from 'ws';
+import { getStringIds } from '../core/common/helpers/db.helper';
 
 /**
  * GraphQL request type
@@ -98,6 +100,11 @@ export interface TestGraphQLOptions {
    */
   logError?: boolean;
 
+  /**
+   * Whether to prepare arguments (like dates)
+   */
+  prepareArguments?: boolean;
+
   /**
    * Status Code = 400
    */
@@ -187,6 +194,7 @@ export class TestHelper {
       statusCode: 200,
       log: false,
       logError: false,
+      prepareArguments: true,
       ...options,
     };
 
@@ -233,7 +241,9 @@ export class TestHelper {
 
       // Set arguments
       if (graphql.arguments) {
-        queryObj[graphql.type][graphql.name].__args = graphql.arguments;
+        queryObj[graphql.type][graphql.name].__args = config.prepareArguments
+          ? this.prepareArguments(graphql.arguments)
+          : graphql.arguments;
       }
 
       // Create request payload query
@@ -330,6 +340,39 @@ export class TestHelper {
     return result;
   }
 
+  /**
+   * Prepare arguments
+   */
+  prepareArguments(args: any, objects?: WeakMap<any, any>) {
+    if (!args) {
+      return args;
+    }
+    if (args instanceof Date) {
+      return args.toISOString();
+    }
+    if (args instanceof Types.ObjectId) {
+      return getStringIds(args);
+    }
+    if (!objects) {
+      objects = new WeakMap<any, any>();
+    }
+    if (typeof args === 'object' && objects.get(args)) {
+      return objects.get(args);
+    }
+    if (Array.isArray(args)) {
+      objects.set(args, args);
+      return args.map((item) => this.prepareArguments(item, objects));
+    }
+    if (typeof args === 'object') {
+      objects.set(args, args);
+      for (const [key, value] of Object.entries(args)) {
+        args[key] = this.prepareArguments(value, objects);
+      }
+      return args;
+    }
+    return args;
+  }
+
   /**
    * Prepare GraphQL fields for request
    * @param fields
@@ -424,6 +467,9 @@ export class TestHelper {
     }
 
     // Response
+    if (log) {
+      console.log(requestConfig);
+    }
     const response = await (variables ? request : request.send(requestConfig.payload));
     return this.processResponse(response, statusCode, log, logError);
   }