Develop

.gitignore

@@ -1,6 +1,7 @@
 node_modules
 dist
 
+npm-debug.log
 .DS_Store
 .nyc_output
 coverage

package.json

@@ -33,6 +33,7 @@
     "chai": "^4.1.2",
     "coveralls": "^3.0.0",
     "mocha": "^3.5.3",
+    "mock-fs": "^4.4.2",
     "tslint": "^5.7.0",
     "tslint-microsoft-contrib": "^5.0.1",
     "typescript": "^2.5.2"

src/index.ts

@@ -37,3 +37,5 @@ export { default as ITemplateEngine } from "./lib/types/http/renderEngine/ITempl
 export { default as ITemplateLoader } from "./lib/types/http/renderEngine/ITemplateLoader";
 export { default as ITemplateRenderer } from "./lib/types/http/renderEngine/ITemplateRenderer";
 export { default as DefaultTemplateLoader } from "./lib/http/renderEngine/DefaultTemplateLoader";
+export { default as DevTemplateLoader } from "./lib/http/renderEngine/DevTemplateLoader";
+export { default as Template } from "./lib/http/renderEngine/Template";

src/lib/App.ts

@@ -7,8 +7,6 @@ import HttpError from "./exceptions/HttpError";
 import httpFinalHandler from "./http/httpFinalHandler";
 import HttpRequest from "./http/HttpRequest";
 import HttpResponse from "./http/HttpResponse";
-import DefaultTemplateLoader from "./http/renderEngine/DefaultTemplateLoader";
-import TemplateEngine from "./http/renderEngine/TemplateEngine";
 import Router from "./Router";
 import IEventHandler from "./types/event/IEventHandler";
 import IEventRequest from "./types/event/IEventRequest";
@@ -18,8 +16,6 @@ import IHttpPlaceholderHandler from "./types/http/IHttpPlaceholderHandler";
 import IHttpRequest from "./types/http/IHttpRequest";
 import IHttpResponse from "./types/http/IHttpResponse";
 import IHttpRoute from "./types/http/IHttpRoute";
-import ITemplateEngine from "./types/http/renderEngine/ITemplateEngine";
-import ITemplateLoader from "./types/http/renderEngine/ITemplateLoader";
 import ITemplateRenderer from "./types/http/renderEngine/ITemplateRenderer";
 import IApp from "./types/IApp";
 import IRouter from "./types/IRouter";
@@ -32,17 +28,12 @@ export default class App implements IApp {
 
   private _settings: object;
   private _router: IRouter;
-  private _templateEngine: ITemplateEngine;
 
   constructor() {
     this._settings = {};
     this._router = new Router();
   }
 
-  get templateEngine(): ITemplateEngine {
-    return this._templateEngine;
-  }
-
   public init(settings?: object): void {
     this.initDefaultConfiguration(settings);
   }
@@ -111,9 +102,8 @@ export default class App implements IApp {
     return this;
   }
 
-  public addTemplateEngine(bucket: string, renderer: ITemplateRenderer, ttl?: number): IApp {
-    const templateLoader: ITemplateLoader = new DefaultTemplateLoader(bucket, ttl);
-    this._templateEngine = new TemplateEngine(bucket, renderer, templateLoader);
+  public addTemplateEngine(renderer: ITemplateRenderer, engineConfiguration?: {[name: string]: any}): IApp {
+    this._router.addTemplateEngine(renderer, engineConfiguration);
 
     return this;
   }

src/lib/Router.ts

@@ -3,6 +3,7 @@ import EventRouterExecutor from "./event/EventRouterExecutor";
 import HttpLayer from "./http/HttpLayer";
 import HttpRoute from "./http/HttpRoute";
 import HttpRouterExecutor from "./http/HttpRouterExecutor";
+import TemplateEngine from "./http/renderEngine/TemplateEngine";
 import IEventHandler from "./types/event/IEventHandler";
 import IEventLayer from "./types/event/IEventLayer";
 import IEventRequest from "./types/event/IEventRequest";
@@ -15,6 +16,8 @@ import IHttpRequest from "./types/http/IHttpRequest";
 import IHttpResponse from "./types/http/IHttpResponse";
 import IHttpRoute from "./types/http/IHttpRoute";
 import IHttpRouterExecutor from "./types/http/IHttpRouterExecutor";
+import ITemplateEngine from "./types/http/renderEngine/ITemplateEngine";
+import ITemplateRenderer from "./types/http/renderEngine/ITemplateRenderer";
 import INext from "./types/INext";
 import IRouter from "./types/IRouter";
 
@@ -46,6 +49,7 @@ export default class Router implements IRouter {
   private _strict: boolean;
   private _subpath: string;
   private _parent: IRouter;
+  private _templateEngine: ITemplateEngine;
 
   constructor(opts?: {[name: string]: any}) {
     const options = opts || {};
@@ -101,6 +105,16 @@ export default class Router implements IRouter {
     }
   }
 
+  get templateEngine(): ITemplateEngine {
+    if (this._templateEngine) {
+      return this._templateEngine;
+    } else if (this._parent) {
+      return this._parent.templateEngine;
+    } else {
+      return null;
+    }
+  }
+
   public param(name: string, handler: IHttpPlaceholderHandler): IRouter {
     if (!this._params[name]) {
       this._params[name] = [];
@@ -181,6 +195,7 @@ export default class Router implements IRouter {
       }
     } else {
       const routerExecutor: IHttpRouterExecutor = new HttpRouterExecutor(this, req, res, out);
+      res.router = this;
       routerExecutor.next();
     }
   }
@@ -271,4 +286,10 @@ export default class Router implements IRouter {
     routerExecutor.next();
   }
 
+  public addTemplateEngine(renderer: ITemplateRenderer, engineConfiguration?: {[name: string]: any}): IRouter {
+    this._templateEngine = new TemplateEngine(renderer, engineConfiguration);
+
+    return this;
+  }
+
 }

src/lib/http/HttpResponse.ts

@@ -13,13 +13,16 @@ import IHttpResponse from "./../types/http/IHttpResponse";
 import ITemplateEngine from "./../types/http/renderEngine/ITemplateEngine";
 import IApp from "./../types/IApp";
 import INext from "./../types/INext";
+import IRouter from "./../types/IRouter";
 import { merge, normalizeType, setCharset, stringify } from "./../utils/utils";
 
 /**
  * This class represents an HTTP response, with the helpers to be sent.
  */
 export default class HttpResponse implements IHttpResponse {
 
+  public router: IRouter;
+
   private _statusCode: number;
   private _app: IApp;
   private _request: IHttpRequest;
@@ -351,8 +354,8 @@ export default class HttpResponse implements IHttpResponse {
     }
   }
 
-  public render(view: string, params: {[name: string]: any}, callback?: (err: Error, html: string) => void): void {
-    const templateEngine: ITemplateEngine = this._app.templateEngine;
+  public render(view: string, params?: {[name: string]: any}, callback?: (err: Error, html: string) => void): void {
+    const templateEngine: ITemplateEngine = this.router ? this.router.templateEngine : null;
     if (templateEngine == null) {
       throw new Error("The template engine must to be added in `app.addTemplateEngine` if you want to use render.");
     } else {

src/lib/http/renderEngine/DefaultTemplateLoader.ts

@@ -1,5 +1,7 @@
 import * as S3 from "aws-sdk/clients/s3";
 import * as NodeCache from "node-cache";
+import Template from "./../../http/renderEngine/Template";
+import ITemplate from "./../../types/http/renderEngine/ITemplate";
 import ITemplateLoader from "./../../types/http/renderEngine/ITemplateLoader";
 
 /**
@@ -19,8 +21,8 @@ export default class DefaultTemplateLoader implements ITemplateLoader {
     }
   }
 
-  public load(fileName: string, callback: (err: Error, content: string) => void): void {
-    this.getFromCache(fileName, (cacheErr: Error, cacheValue: string) => {
+  public load(fileName: string, callback: (err: Error, template: ITemplate) => void): void {
+    this.getFromCache(fileName, (cacheErr: Error, cacheValue: ITemplate) => {
       if (cacheErr) {
         callback(cacheErr, null);
       } else {
@@ -35,8 +37,9 @@ export default class DefaultTemplateLoader implements ITemplateLoader {
                 callback(err, null);
               } else {
                 const content: string = data.Body.toString();
-                this.setToCache(fileName, content);
-                callback(null, content);
+                const template: ITemplate = new Template(fileName, content);
+                this.setToCache(template);
+                callback(null, template);
               }
             }
           );
@@ -47,19 +50,19 @@ export default class DefaultTemplateLoader implements ITemplateLoader {
     });
   }
 
-  private getFromCache(fileName: string, callback: (cacheErr: Error, cacheValue: string) => void): void {
+  private getFromCache(fileName: string, callback: (cacheErr: Error, cacheValue: ITemplate) => void): void {
     if (this._cache) {
       this._cache.get(fileName, callback);
     } else {
       callback(null, undefined);
     }
   }
 
-  private setToCache(fileName: string, content: string): void {
+  private setToCache(template: ITemplate): void {
     if (this._cache) {
-      this._cache.set(fileName, (err: Error, success: boolean) => {
+      this._cache.set(template.fileName, template, (err: Error, success: boolean) => {
         if (err || !success) {
-          console.error("Error saving template into cache: " + fileName, err);
+          console.error("Error saving template into cache: " + template.fileName, err);
         }
       });
     }

src/lib/http/renderEngine/DevTemplateLoader.ts

@@ -0,0 +1,34 @@
+import * as fs from "fs";
+import * as path from "path";
+import Template from "./../../http/renderEngine/Template";
+import ITemplate from "./../../types/http/renderEngine/ITemplate";
+import ITemplateLoader from "./../../types/http/renderEngine/ITemplateLoader";
+
+/**
+ * Loads the template from file system.
+ */
+export default class DevTemplateLoader implements ITemplateLoader {
+
+  private _basePath: string;
+  private _encoding: string;
+
+  constructor(basePath?: string, encoding?: string) {
+    this._basePath = basePath;
+    this._encoding = encoding;
+  }
+
+  public load(fileName: string, callback: (err: Error, template: ITemplate) => void): void {
+    const basePath = this._basePath || "";
+    const filePath = path.join(basePath, fileName);
+    const encoding = this._encoding || "utf8";
+    fs.readFile(filePath, encoding, (err: Error, content: string) => {
+      if (err) {
+        callback(err, null);
+      } else {
+        const template: ITemplate = new Template(fileName, content);
+        callback(null, template);
+      }
+    });
+  }
+
+}

src/lib/http/renderEngine/Template.ts

@@ -1,5 +1,4 @@
 import ITemplate from "./../../types/http/renderEngine/ITemplate";
-import ITemplateLoader from "./../../types/http/renderEngine/ITemplateLoader";
 
 /**
  * Representation of a template file.
@@ -8,39 +7,18 @@ export default class Template implements ITemplate {
 
   private _fileName: string;
   private _content: string;
-  private _loaded: boolean;
-  private _templateLoader: ITemplateLoader;
 
-  constructor(fileName: string, templateLoader: ITemplateLoader) {
+  constructor(fileName: string, content: string) {
     this._fileName = fileName;
-    this._loaded = false;
-    this._templateLoader = templateLoader;
+    this._content = content;
   }
 
-  get content(): string {
-    if (!this._loaded) {
-      throw new Error("The template " + this._fileName + " has not been loaded.");
-    }
-    return this._content;
+  get fileName(): string {
+    return this._fileName;
   }
 
-  public load(callback: (err?: Error) => void): void {
-    if (!this._loaded) {
-      this._templateLoader.load(
-        this._fileName,
-        (err: Error, content: string) => {
-          if (err) {
-            callback(err);
-          } else {
-            this._content = content;
-            this._loaded = true;
-            callback();
-          }
-        }
-      );
-    } else {
-      callback();
-    }
+  get content(): string {
+    return this._content;
   }
 
 }