@tsed/engines 8.0.1 → 8.0.3

package/src/registries/EnginesContainer.ts

@@ -0,0 +1,37 @@
+import {Engine, ViewEngineOptions} from "../components/Engine.js";
+
+export interface EngineProvider {
+  name: string;
+  useClass: typeof Engine;
+  instance?: Engine;
+  options: ViewEngineOptions;
+}
+
+export class EnginesContainer {
+  #providers: Map<string | typeof Engine, EngineProvider> = new Map();
+
+  has(key: string | typeof Engine) {
+    return this.#providers.has(key);
+  }
+
+  get(key: string | typeof Engine) {
+    const provider = this.#providers.get(key);
+
+    if (provider && !provider.instance) {
+      provider.instance = new provider.useClass(provider.name, provider.options);
+    }
+
+    return provider?.instance;
+  }
+
+  set(key: typeof Engine, provider: EngineProvider) {
+    this.#providers.set(key, provider);
+    this.#providers.set(provider.name, provider);
+  }
+
+  getSupportedEngines(): string[] {
+    return [...this.#providers.keys()].filter((key) => typeof key === "string") as string[];
+  }
+}
+
+export const engines = new EnginesContainer();

package/src/utils/cache.spec.ts

@@ -0,0 +1,13 @@
+import {clearCache, getFromCache, setToCache} from "./cache.js";
+
+describe("cache", () => {
+  describe("setToCache()", () => {
+    it("should set result to cache", () => {
+      setToCache("key", "value");
+      expect(getFromCache("key")).toEqual("value");
+
+      clearCache();
+      expect(getFromCache("key")).toEqual(undefined);
+    });
+  });
+});

package/src/utils/cache.ts

@@ -0,0 +1,154 @@
+import {readFile} from "node:fs/promises";
+import {dirname, extname, isAbsolute, join} from "node:path";
+
+import fs from "fs";
+
+const readCache: Map<string, string> = new Map();
+const cacheStore: Map<string, any> = new Map();
+
+export const requires: Map<string, any> = new Map();
+
+export function getCachedEngine(name: string, toName: string = name) {
+  const mdl = requires.get(toName) || {};
+
+  return mdl.default || mdl;
+}
+
+export async function importEngine(name: string, toName: string = name) {
+  if (!requires.has(toName)) {
+    await setEngine(name, toName);
+  }
+
+  return getCachedEngine(toName);
+}
+
+export async function setEngine(name: string, toName: string = name) {
+  const mdl = await import(name);
+
+  requires.set(toName, mdl);
+}
+
+export function setToCache(key: string, value: any) {
+  readCache.set(key, value);
+}
+
+export function getFromCache(key: string) {
+  return readCache.get(key);
+}
+
+/**
+ * Clear the cache.
+ *
+ * @api public
+ */
+
+export const clearCache = () => {
+  readCache.clear();
+  cacheStore.clear();
+};
+
+/**
+ * Conditionally cache `compiled` template based
+ * on the `options` filename and `.cache` boolean.
+ *
+ * @param {Object} options
+ * @param {Function} compiled
+ * @return {Function}
+ */
+export function cache(options: any, compiled?: any) {
+  // cachable
+  if (compiled && options.filename && options.cache) {
+    readCache.delete(options.filename);
+    cacheStore.set(options.filename, compiled);
+    return compiled;
+  }
+
+  // check cache
+  if (options.filename && options.cache) {
+    return cacheStore.get(options.filename);
+  }
+
+  return compiled;
+}
+
+/**
+ * Read `path` with `options` with
+ * callback `(err, str)`. When `options.cache`
+ * is true the template string will be cached.
+ *
+ * @param path
+ * @param {String} options
+ */
+export async function read(path: string, options: any): Promise<string> {
+  let str = readCache.get(path);
+
+  // cached (only if cached is a string and not a compiled template function)
+  if (options.cache && str && typeof str === "string") {
+    return str;
+  }
+
+  // read
+  str = await readFile(path, "utf8");
+
+  // remove extraneous utf8 BOM marker
+  str = str.replace(/^\uFEFF/, "");
+
+  if (options.cache) {
+    readCache.set(path, str);
+  }
+
+  return str;
+}
+
+/**
+ * Read `path` with `options` with
+ * callback `(err, str)`. When `options.cache`
+ * is true the partial string will be cached.
+ *
+ * @param path
+ * @param {String} options
+ * @api private
+ */
+export function readPartials(path: string, options: any): Promise<Record<string, string> | void> {
+  if (!options.partials) {
+    return Promise.resolve();
+  }
+
+  const keys = Object.keys(options.partials);
+  const partials: Record<string, string> = {};
+
+  return new Promise((resolve, reject) => {
+    async function next(index: number): Promise<any> {
+      if (index === keys.length) {
+        return resolve(partials);
+      }
+
+      const key = keys[index];
+      const partialPath = options.partials[key];
+
+      if (partialPath === undefined || partialPath === null || partialPath === false) {
+        return next(++index);
+      }
+
+      let file;
+      if (isAbsolute(partialPath)) {
+        if (extname(partialPath) !== "") {
+          file = partialPath;
+        } else {
+          file = join(partialPath + extname(path));
+        }
+      } else {
+        file = join(dirname(path), partialPath + extname(path));
+      }
+
+      try {
+        partials[key] = await read(file, options);
+        next(++index);
+      } catch (err) {
+        reject(err);
+      }
+    }
+
+    next(0);
+  });
+}

package/src/utils/getEngines.spec.ts

@@ -0,0 +1,133 @@
+import "../index.js";
+
+import {join} from "path";
+
+import {getEngine, getEngines} from "./getEngines.js";
+
+const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
+
+describe("getEngines", () => {
+  describe("getEngine()", () => {
+    describe("render file", () => {
+      it("should return a render function", async () => {
+        const render = getEngine("ejs");
+
+        const result = await new Promise((resolve, reject) => {
+          render(
+            join(rootDir, "../../test/fixtures/ejs/user.ejs"),
+            {
+              user: {
+                name: "Tobi"
+              }
+            },
+            (err, html) => {
+              err ? reject(err) : resolve(html);
+            }
+          );
+        });
+
+        expect(result).toEqual("<p>Tobi</p>");
+      });
+      it("should catch error", async () => {
+        const render = getEngine("ejs");
+
+        const error: any = await new Promise((resolve) => {
+          render(
+            join(rootDir, "../../test/fixtures/ejs/user2.ejs"),
+            {
+              user: {
+                name: "Tobi"
+              }
+            },
+            (err) => {
+              resolve(err);
+            }
+          );
+        });
+
+        expect(error.message).toContain("ENOENT: no such file or directory");
+      });
+    });
+    describe("render template", () => {
+      it("should return a render function", async () => {
+        const {render} = getEngine("ejs");
+
+        const result = await new Promise((resolve, reject) => {
+          render(
+            "<p><%= user.name %></p>",
+            {
+              user: {
+                name: "Tobi"
+              }
+            },
+            (err, html) => {
+              err ? reject(err) : resolve(html);
+            }
+          );
+        });
+
+        expect(result).toEqual("<p>Tobi</p>");
+      });
+      it("should catch error", async () => {
+        const {render} = getEngine("ejs");
+
+        const error: any = await new Promise((resolve) => {
+          render(
+            "<p><%= user.name></p>",
+            {
+              user: {
+                name: "Tobi"
+              }
+            },
+            (err) => {
+              resolve(err);
+            }
+          );
+        });
+
+        expect(error.message).toContain('Could not find matching close tag for "<%=".');
+      });
+    });
+  });
+  describe("getEngines()", () => {
+    it("should return engines", () => {
+      const engines = getEngines();
+      expect(Object.keys(engines)).toEqual([
+        "atpl",
+        "bracket",
+        "dot",
+        "dust",
+        "ect",
+        "ejs",
+        "haml-coffee",
+        "haml",
+        "hamlet",
+        "handlebars",
+        "hogan",
+        "htmling",
+        "jazz",
+        "jqtpl",
+        "just",
+        "liquor",
+        "lodash",
+        "mote",
+        "mustache",
+        "nunjucks",
+        "plates",
+        "pug",
+        "ractive",
+        "react",
+        "slm",
+        "squirrelly",
+        "swig",
+        "templayed",
+        "twig",
+        "twing",
+        "underscore",
+        "vash",
+        "velocityjs",
+        "walrus"
+      ]);
+    });
+  });
+});

package/src/utils/getEngines.ts

@@ -0,0 +1,58 @@
+import {EngineOptions} from "../components/Engine.js";
+import {engines} from "../registries/EnginesContainer.js";
+
+export type RenderCallback = (err: Error | null, str?: string | any) => any;
+export interface EngineFunction {
+  (path: string, options: any, cb: RenderCallback): void;
+  (path: string, options: any): Promise<string>;
+
+  render(template: string, options: any, cb: RenderCallback): void;
+  render(template: string, options: any): Promise<string>;
+}
+
+const callbackify = async (fn: any, cb?: RenderCallback) => {
+  try {
+    const html = await fn();
+    cb && cb(null, html);
+    return html;
+  } catch (er) {
+    if (cb) {
+      cb(er);
+    } else {
+      throw er;
+    }
+  }
+};
+
+export function getEngine(name: string): EngineFunction {
+  const cb = async (path: string, options: any, cb?: RenderCallback) => {
+    const engine = engines.get(name)!;
+    await engine.$onInit();
+
+    return callbackify(() => engine.renderFile(path, options), cb);
+  };
+
+  cb.render = async (template: string, options: EngineOptions, cb: RenderCallback) => {
+    const engine = engines.get(name)!;
+    await engine.$onInit();
+
+    return callbackify(() => engine.render(template, options), cb);
+  };
+
+  return cb as any;
+}
+
+let localEngines: any;
+
+export function getEngines(): Record<string, EngineFunction> {
+  localEngines =
+    localEngines ||
+    engines.getSupportedEngines().reduce((acc, key) => {
+      return {
+        ...acc,
+        [key]: getEngine(key)
+      };
+    }, {});
+
+  return localEngines;
+}