@lenne.tech/nest-server 10.2.5 → 10.2.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "10.2.5",
+  "version": "10.2.7",
   "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",
@@ -63,6 +63,7 @@
   },
   "dependencies": {
     "@apollo/gateway": "2.5.7",
+    "@getbrevo/brevo": "1.0.1",
     "@lenne.tech/mongoose-gridfs": "1.4.2",
     "@lenne.tech/multer-gridfs-storage": "5.0.6",
     "@nestjs/apollo": "12.0.11",

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

@@ -0,0 +1,35 @@
+export function htmlTable(
+  header: string[],
+  rows: string[][],
+  options?: {
+    tableStyle?: string;
+    theadStyle?: string;
+    trHeadStyle?: string;
+    thStyle?: string;
+    tbodyStyle?: string;
+    trStyle?: string;
+    tdStyle?: string;
+  },
+): string {
+  const config = {
+    tableStyle: 'width: 100%; border: 1px solid #000; border-collapse: collapse;',
+    trHeadStyle: 'background-color: #f0f0f0;',
+    thStyle: 'border: 1px solid #000; padding: 10px;',
+    tcStyle: 'border: 1px solid #000; padding: 10px;',
+    ...options,
+  };
+  let table = `<table style="${config.tableStyle}"><thead style="${config.theadStyle}"><tr style="${config.trHeadStyle}">`;
+  for (const head of header) {
+    table += `<th style="${config.thStyle}">${head}</th>`;
+  }
+  table += '</tr></thead><tbody style="${config.tbodyStyle}">';
+  for (const row of rows) {
+    table += `<tr style="${config.trStyle}">`;
+    for (const cell of row) {
+      table += `<td style="${config.tdStyle}">${cell}</td>`;
+    }
+    table += '</tr>';
+  }
+  table += '</tbody></table>';
+  return table;
+}

package/src/core/common/interceptors/check-security.interceptor.ts

@@ -12,7 +12,7 @@ import { processDeep } from '../helpers/input.helper';
 export class CheckSecurityInterceptor implements NestInterceptor {
   intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
     // Get current user
-    const user = getContextData(context)?.currentUser;
+    const user = getContextData(context)?.currentUser || null;
 
     // Set force mode for sign in and sign up
     let force = false;

package/src/core/common/interfaces/server-options.interface.ts

@@ -70,6 +70,23 @@ export interface IServerOptions {
    */
   automaticObjectIdFiltering?: boolean;
 
+  /**
+   * Configuration for Brevo
+   * See: https://developers.brevo.com/
+   */
+  brevo?: {
+    /**
+     * API key for Brevo
+     */
+    apiKey?: string;
+
+    /**
+     * Regular expression for excluding (test) users
+     * e.g. /@testuser.com$/i
+     */
+    exclude?: RegExp;
+  };
+
   /**
    * Whether to use the compression middleware package to enable gzip compression.
    * See: https://docs.nestjs.com/techniques/compression

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

@@ -0,0 +1,48 @@
+import { Injectable } from '@nestjs/common';
+import brevo = require('@getbrevo/brevo');
+import { ConfigService } from './config.service';
+
+@Injectable()
+export class BrevoService {
+  constructor(protected configService: ConfigService) {
+    const defaultClient = brevo.ApiClient.instance;
+    const apiKey = defaultClient.authentications['api-key'];
+    apiKey.apiKey = configService.configFastButReadOnly.brevo?.apiKey;
+    if (!apiKey.apiKey) {
+      console.warn('Brevo API key not set!');
+    }
+  }
+
+  /**
+   * Send a transactional email via Brevo
+   */
+  async sendMail(to: string, templateId: number, params?: object): Promise<unknown> {
+
+    // Check input
+    if (!to || !templateId) {
+      return false;
+    }
+
+    // Exclude (test) users
+    if (this.configService.configFastButReadOnly.brevo?.exclude?.test?.(to)) {
+      return 'TEST_USER!';
+    }
+
+    // Prepare data
+    const apiInstance = new brevo.TransactionalEmailsApi();
+    const sendSmtpEmail = new brevo.SendSmtpEmail();
+    sendSmtpEmail.templateId = templateId;
+    sendSmtpEmail.to = [{ email: to }];
+    sendSmtpEmail.params = params;
+
+    // Send email
+    try {
+      return await apiInstance.sendTransacEmail(sendSmtpEmail);
+    } catch (error) {
+      console.error(error);
+    }
+
+    // Return null if error
+    return null;
+  }
+}

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

@@ -1,5 +1,5 @@
 import { NotFoundException } from '@nestjs/common';
-import { Document, FilterQuery, PipelineStage, Query, QueryOptions } from 'mongoose';
+import { AggregateOptions, Document, FilterQuery, PipelineStage, Query, QueryOptions } from 'mongoose';
 import { FilterArgs } from '../args/filter.args';
 import { getStringIds } from '../helpers/db.helper';
 import { convertFilterArgsToQuery } from '../helpers/filter.helper';
@@ -15,6 +15,51 @@ export abstract class CrudService<
   CreateInput = any,
   UpdateInput = any,
 > extends ModuleService<Model> {
+
+  /**
+   * Aggregate
+   * @param serviceOptions.aggregateOptions Aggregate options, see https://www.mongodb.com/docs/manual/core/aggregation-pipeline/
+   * @param serviceOptions.collation Collation, see https://www.mongodb.com/docs/manual/reference/collation/
+   * @param serviceOptions.outputPath Output path of items which should be prepared, e.g. 'items'
+   */
+  async aggregate<T = any>(
+    pipeline: PipelineStage[],
+    serviceOptions?: ServiceOptions & { aggregateOptions?: AggregateOptions },
+  ): Promise<T> {
+    return this.process(
+      async () => {
+        const aggregateOptions = serviceOptions?.aggregateOptions || {};
+        const collation = serviceOptions?.collation || ConfigService.get('mongoose.collation');
+        if (collation && !aggregateOptions.collation) {
+          aggregateOptions.collation = collation;
+        }
+        return this.mainDbModel.aggregate(pipeline, aggregateOptions).exec();
+      },
+      { serviceOptions },
+    );
+  }
+
+  /**
+   * Aggregate without checks or restrictions
+   * Warning: Disables the handling of rights and restrictions!
+   */
+  async aggregateForce<T = any>(pipeline: PipelineStage[], serviceOptions: ServiceOptions = {}): Promise<T> {
+    serviceOptions = serviceOptions || {};
+    serviceOptions.force = true;
+    return this.aggregate(pipeline, serviceOptions);
+  }
+
+  /**
+   * Aggregate without checks, restrictions or preparations
+   * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
+   */
+  async aggregateRaw<T = any>(pipeline: PipelineStage[], serviceOptions: ServiceOptions = {}): Promise<T> {
+    serviceOptions = serviceOptions || {};
+    serviceOptions.prepareInput = null;
+    serviceOptions.prepareOutput = null;
+    return this.aggregateForce(pipeline, serviceOptions);
+  }
+
   /**
    * Create item
    */
@@ -311,6 +356,69 @@ export abstract class CrudService<
     return this.findAndUpdateForce(filter, update, serviceOptions);
   }
 
+  /**
+   * Find one item via filter
+   */
+  async findOne(
+    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions },
+    serviceOptions?: ServiceOptions,
+  ): Promise<Model> {
+    // If filter is not instance of FilterArgs a simple form with filterQuery and queryOptions is set
+    // and should not be processed as FilterArgs
+    if (!(filter instanceof FilterArgs) && serviceOptions?.inputType === FilterArgs) {
+      serviceOptions = Object.assign({ prepareInput: null }, serviceOptions, { inputType: null });
+    }
+
+    return this.process(
+      async (data) => {
+
+        // Prepare filter query
+        const filterQuery = { filterQuery: data?.input?.filterQuery, queryOptions: data?.input?.queryOptions };
+        if (data?.input instanceof FilterArgs) {
+          const converted = convertFilterArgsToQuery(data.input);
+          filterQuery.filterQuery = converted[0];
+          filterQuery.queryOptions = converted[1];
+        }
+
+        // Find in DB
+        let find = this.mainDbModel.findOne(filterQuery.filterQuery, null, filterQuery.queryOptions);
+        const collation = serviceOptions?.collation || ConfigService.get('mongoose.collation');
+        if (collation) {
+          find = find.collation(collation);
+        }
+        return find.exec();
+      },
+      { input: filter, serviceOptions },
+    );
+  }
+
+  /**
+   * Find one item via filter without checks or restrictions
+   * Warning: Disables the handling of rights and restrictions!
+   */
+  async findOneForce(
+    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    serviceOptions: ServiceOptions = {},
+  ): Promise<Model> {
+    serviceOptions = serviceOptions || {};
+    serviceOptions.force = true;
+    return this.findOne(filter, serviceOptions);
+  }
+
+  /**
+   * Find one item via filter without checks, restrictions or preparations
+   * Warning: Disables the handling of rights and restrictions! The raw data may contain secrets (such as passwords).
+   */
+  async findOneRaw(
+    filter?: FilterArgs | { filterQuery?: FilterQuery<any>; queryOptions?: QueryOptions; samples?: number },
+    serviceOptions: ServiceOptions = {},
+  ): Promise<Model> {
+    serviceOptions = serviceOptions || {};
+    serviceOptions.prepareInput = null;
+    serviceOptions.prepareOutput = null;
+    return this.findOneForce(filter, serviceOptions);
+  }
+
   /**
    * CRUD alias for get
    */

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

@@ -180,8 +180,14 @@ export abstract class ModuleService<T extends CoreModel = any> {
 
     // Pop and map main model
     if (config.processFieldSelection && config.fieldSelection && this.processFieldSelection) {
-      const field = config.outputPath ? _.get(result, config.outputPath) : result;
-      await this.processFieldSelection(field, config.fieldSelection, config.processFieldSelection);
+      let temps = result;
+      if (!Array.isArray(result)) {
+        temps = [result];
+      }
+      for (const temp of temps) {
+        const field = config.outputPath ? _.get(temp, config.outputPath) : temp;
+        await this.processFieldSelection(field, config.fieldSelection, config.processFieldSelection);
+      }
     }
 
     // Prepare output
@@ -191,7 +197,13 @@ export abstract class ModuleService<T extends CoreModel = any> {
         opts.targetModel = config.outputType;
       }
       if (config.outputPath) {
-        _.set(result, config.outputPath, await this.prepareOutput(_.get(result, config.outputPath), opts));
+        let temps = result;
+        if (!Array.isArray(result)) {
+          temps = [result];
+        }
+        for (const temp of temps) {
+          _.set(temp, config.outputPath, await this.prepareOutput(_.get(temp, config.outputPath), opts));
+        }
       } else {
         result = await this.prepareOutput(result, config);
       }

package/src/index.ts

@@ -33,6 +33,7 @@ export * from './core/common/helpers/graphql.helper';
 export * from './core/common/helpers/input.helper';
 export * from './core/common/helpers/model.helper';
 export * from './core/common/helpers/service.helper';
+export * from './core/common/helpers/table.helper';
 export * from './core/common/inputs/combined-filter.input';
 export * from './core/common/inputs/core-input.input';
 export * from './core/common/inputs/filter.input';
@@ -61,6 +62,7 @@ export * from './core/common/scalars/any.scalar';
 export * from './core/common/scalars/date.scalar';
 export * from './core/common/scalars/date-timestamp.scalar';
 export * from './core/common/scalars/json.scalar';
+export * from './core/common/services/brevo.service';
 export * from './core/common/services/config.service';
 export * from './core/common/services/core-cron-jobs.service';
 export * from './core/common/services/crud.service';