Merge pull request #66 from expressots/343-support-for-render-engines

343 support for render engines

Author: rsaz

package.json

@@ -75,7 +75,7 @@
     "@codecov/vite-plugin": "^0.0.1-beta.6",
     "@commitlint/cli": "19.2.1",
     "@commitlint/config-conventional": "19.2.2",
-    "@expressots/core": "latest",
+    "@expressots/core": "2.15.0",
     "@release-it/conventional-changelog": "8.0.1",
     "@types/express": "4.17.21",
     "@types/node": "20.14.10",

src/adapter-express/application-express.interface.ts

@@ -1,5 +1,5 @@
+import { IApplicationMessageToConsole } from "@expressots/core";
 import express from "express";
-import { IApplicationMessageToConsole, RenderTemplateOptions } from "@expressots/core";
 import { ServerEnvironment } from "./application-express.types";
 
 /**
@@ -18,19 +18,6 @@ export interface IWebServerPublic {
     consoleMessage?: IApplicationMessageToConsole,
   ): Promise<void>;
 
-  /**
-   * Configures the application's view engine based on the provided configuration options.
-   *
-   * @public
-   * @method setEngine
-   * @template T - A generic type extending from RenderTemplateOptions.
-   *
-   * @param {T} options - An object of type T (must be an object that extends RenderTemplateOptions)
-   *                      that provides the configuration options for setting the view engine.
-   *                      This includes the extension name, view path, and the engine function itself.
-   */
-  setEngine<T extends RenderTemplateOptions>(options: T): void;
-
   /**
    * Get the underlying HTTP server. (default: Express.js)
    * @returns The underlying HTTP server after initialization.

src/adapter-express/application-express.ts

@@ -1,11 +1,4 @@
-import {
-  Console,
-  IApplicationMessageToConsole,
-  IHandlebars,
-  Logger,
-  Middleware,
-  RenderTemplateOptions,
-} from "@expressots/core";
+import { Console, IApplicationMessageToConsole, Logger, Middleware } from "@expressots/core";
 import express from "express";
 import { Container } from "inversify";
 import { provide } from "inversify-binding-decorators";
@@ -18,8 +11,12 @@ import {
   MiddlewareConfig,
   ServerEnvironment,
 } from "./application-express.types";
-import { InversifyExpressServer } from "./express-utils/inversify-express-server";
 import { HttpStatusCodeMiddleware } from "./express-utils/http-status-middleware";
+import { InversifyExpressServer } from "./express-utils/inversify-express-server";
+import { EjsOptions, setEngineEjs } from "./render/ejs/ejs.config";
+import { Engine, EngineOptions, RenderOptions } from "./render/engine";
+import { HandlebarsOptions, setEngineHandlebars } from "./render/handlebars/hbs.config";
+import { packageResolver } from "./render/resolve-render";
 
 /**
  * The AppExpress class provides methods for configuring and running an Express application.
@@ -42,6 +39,7 @@ class AppExpress extends ApplicationBase implements IWebServer {
   private globalPrefix: string = "/";
   private middlewares: Array<ExpressHandler | MiddlewareConfig | ExpressoMiddleware> = [];
   private console: Console;
+  private renderOptions: RenderOptions = {} as RenderOptions;
 
   protected configureServices(): void | Promise<void> {}
   protected postServerInitialization(): void | Promise<void> {}
@@ -146,6 +144,7 @@ class AppExpress extends ApplicationBase implements IWebServer {
     consoleMessage?: IApplicationMessageToConsole,
   ): Promise<void> {
     await this.init();
+    await this.configEngine();
 
     this.port = port || 3000;
     this.environment = environment;
@@ -177,23 +176,45 @@ class AppExpress extends ApplicationBase implements IWebServer {
     this.globalPrefix = prefix;
   }
 
+  /**
+   * Configures the application's view engine based on the provided configuration options.
+   */
+  private async configEngine(): Promise<void> {
+    if (this.renderOptions.engine) {
+      switch (this.renderOptions.engine) {
+        case Engine.HBS:
+          await setEngineHandlebars(this.app, this.renderOptions.options as HandlebarsOptions);
+          break;
+        case Engine.EJS:
+          await setEngineEjs(this.app, this.renderOptions.options as EjsOptions);
+          break;
+        default:
+          throw new Error("Unsupported engine type!");
+      }
+    }
+  }
+
   /**
    * Configures the application's view engine based on the provided configuration options.
    *
    * @public
    * @method setEngine
    * @template T - A generic type extending from RenderTemplateOptions.
    *
-   * @param {T} options - An object of type T (must be an object that extends RenderTemplateOptions)
-   *                      that provides the configuration options for setting the view engine.
-   *                      This includes the extension name, view path, and the engine function itself.
+   * @param {Engine} engine - The view engine to set
+   * @param {EngineOptions} [options] - The configuration options for the view engine
    */
-  public setEngine<T extends RenderTemplateOptions>(options: T): void {
-    if ("extName" in options) {
-      const { extName, viewPath, engine } = options as IHandlebars;
-      this.app.engine(extName, engine);
-      this.app.set("view engine", extName);
-      this.app.set("views", viewPath);
+  public async setEngine<T extends EngineOptions>(engine: Engine, options?: T): Promise<void> {
+    packageResolver(engine, options);
+
+    try {
+      if (options) {
+        this.renderOptions = { engine, options };
+      } else {
+        this.renderOptions = { engine };
+      }
+    } catch (error: unknown) {
+      this.logger.error((error as Error).message, "adapter-express");
     }
   }
 

src/adapter-express/application-express.types.ts

@@ -1,6 +1,7 @@
 import express, { Request, Response, NextFunction } from "express";
-import { IApplicationMessageToConsole, RenderTemplateOptions } from "@expressots/core";
+import { IApplicationMessageToConsole } from "@expressots/core";
 import { Container } from "inversify";
+import { Engine, EngineOptions } from "./render/engine";
 
 /**
  * Interface for the WebServer application implementation.
@@ -12,7 +13,7 @@ export interface IWebServer {
     environment: ServerEnvironment,
     consoleMessage?: IApplicationMessageToConsole,
   ): Promise<void>;
-  setEngine<T extends RenderTemplateOptions>(options: T): void;
+  setEngine<T extends EngineOptions>(engine: Engine, options?: T): Promise<void>;
 }
 
 /**

src/adapter-express/express-utils/inversify-express-server.ts

@@ -267,10 +267,9 @@ export class InversifyExpressServer {
         } else if (value instanceof Function) {
           value();
         } else if (!res.headersSent) {
-          if (value === undefined) {
-            res.status(204);
+          if (value !== undefined) {
+            res.send(value);
           }
-          res.send(value);
         }
       } catch (err) {
         next(err);

src/adapter-express/index.ts

@@ -2,3 +2,4 @@ export * from "./express-utils";
 export { AppExpress } from "./application-express";
 export { IWebServerPublic } from "./application-express.interface";
 export { IWebServer, IWebServerConstructor, ServerEnvironment } from "./application-express.types";
+export * from "./render";

src/adapter-express/render/ejs/ejs.config.ts

@@ -0,0 +1,55 @@
+import { Application } from "express";
+import { join } from "path";
+import { Options } from "./ejs.types";
+
+/**
+ * Ejs options
+ * @typedef {Object} EjsOptions
+ * @property {string | Array<string>} viewsDir - The path to the views folder
+ * @property {string} viewEngine - The view engine
+ * @property {ejs.Options} [serverOptions] - The server options
+ *
+ */
+export type EjsOptions = {
+  viewsDir?: string | Array<string>;
+  viewEngine?: string;
+  serverOptions?: Options;
+};
+
+/**
+ * Ejs defaults
+ * @type {EjsOptions}
+ * @constant
+ * @default
+ */
+const EJS_DEFAULTS: EjsOptions = {
+  viewsDir: join(process.cwd(), "views"),
+  viewEngine: "ejs",
+  serverOptions: {},
+};
+
+/**
+ * Set Ejs as the view engine
+ * @param {Application} app - The express application
+ * @param {EjsOptions} [options=EJS_DEFAULTS] - The ejs options
+ */
+export async function setEngineEjs(
+  app: Application,
+  options: EjsOptions = EJS_DEFAULTS,
+): Promise<void> {
+  app.set("view engine", options.viewEngine || EJS_DEFAULTS.viewEngine);
+  app.set("views", options.viewsDir || EJS_DEFAULTS.viewsDir);
+
+  if (Array.isArray(options.viewsDir)) {
+    options.viewsDir.forEach((dir) => {
+      app.set("views", dir);
+    });
+  }
+
+  if (options.serverOptions) {
+    app.locals = {
+      ...app.locals,
+      ...options.serverOptions,
+    };
+  }
+}