@tsed/components-scan 8.0.0 → 8.0.2

package/package.json

@@ -2,13 +2,14 @@
   "name": "@tsed/components-scan",
   "description": "Components scan utilities for Ts.ED Framework",
   "type": "module",
-  "version": "8.0.0",
+  "version": "8.0.2",
   "source": "./src/index.ts",
   "main": "./lib/esm/index.js",
   "module": "./lib/esm/index.js",
   "typings": "./lib/types/index.d.ts",
   "exports": {
     ".": {
+      "@tsed/source": "./src/index.ts",
       "types": "./lib/types/index.d.ts",
       "import": "./lib/esm/index.js",
       "default": "./lib/esm/index.js"
@@ -22,21 +23,21 @@
     "test:ci": "vitest run --coverage.thresholds.autoUpdate=true"
   },
   "dependencies": {
-    "@tsed/normalize-path": "8.0.0",
+    "@tsed/normalize-path": "8.0.2",
     "globby": "^14.0.2",
     "tslib": "2.7.0"
   },
   "devDependencies": {
-    "@tsed/barrels": "8.0.0",
-    "@tsed/core": "8.0.0",
-    "@tsed/di": "8.0.0",
-    "@tsed/typescript": "8.0.0",
+    "@tsed/barrels": "8.0.2",
+    "@tsed/core": "8.0.2",
+    "@tsed/di": "8.0.2",
+    "@tsed/typescript": "8.0.2",
     "eslint": "9.12.0",
     "typescript": "5.4.5",
     "vitest": "2.1.2"
   },
   "peerDependencies": {
-    "@tsed/core": "8.0.0"
+    "@tsed/core": "8.0.2"
   },
   "peerDependenciesMeta": {
     "@tsed/core": {

package/src/cleanGlobPatterns.spec.ts

@@ -0,0 +1,32 @@
+import {cleanGlobPatterns} from "./cleanGlobPatterns.js";
+import {isTsEnv} from "./isTsEnv.js";
+
+vi.mock("./isTsEnv");
+
+describe("cleanGlobPatterns()", () => {
+  describe("when haven't typescript compiler", () => {
+    beforeAll(() => {
+      (isTsEnv as any).mockReturnValue(false);
+    });
+
+    it("should return file.js", () => {
+      expect(cleanGlobPatterns("file.ts", ["!**.spec.ts"])[0]).toContain("file.js");
+    });
+
+    it("should return file.ts,js", () => {
+      expect(cleanGlobPatterns("file{.ts,.js}", ["!**.spec.ts"])[0]).toContain("file.js");
+    });
+
+    it("should return file.ts.js and manipulate only the file extension", () => {
+      expect(cleanGlobPatterns("file.ts.ts", ["!**.spec.ts"])[0]).toContain("file.ts.js");
+    });
+  });
+  describe("when have typescript compiler", () => {
+    beforeAll(() => {
+      (isTsEnv as any).mockReturnValue(true);
+    });
+    it("should return file.ts", () => {
+      expect(cleanGlobPatterns("file.ts", ["!**.spec.ts"])[0]).toContain("file.ts");
+    });
+  });
+});

package/src/cleanGlobPatterns.ts

@@ -0,0 +1,26 @@
+// @ts-ignore
+import {normalizePath} from "@tsed/normalize-path";
+import {resolve} from "path";
+
+import {isTsEnv} from "./isTsEnv.js";
+
+function mapExcludes(excludes: string[]) {
+  return excludes.map((s: string) => `!${s.replace(/!/gi, "")}`);
+}
+
+function mapExtensions(file: string): string {
+  if (!isTsEnv()) {
+    file = file.replace(/\.ts$/i, ".js").replace(/{\.ts,\.js}$/i, ".js");
+  }
+
+  return file;
+}
+
+export function cleanGlobPatterns(files: string | string[], excludes: string[]): string[] {
+  return []
+    .concat(files as never)
+    .map((s: string) => resolve(s))
+    .concat(mapExcludes(excludes) as never)
+    .map(mapExtensions)
+    .map((s: string) => normalizePath(s));
+}

package/src/importFiles.spec.ts

@@ -0,0 +1,21 @@
+import {join} from "path";
+
+import {Test1} from "./__mock__/Test1.js";
+import {Test2} from "./__mock__/Test2.js";
+import {importFiles} from "./importFiles.js";
+
+const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
+
+describe("importFiles", () => {
+  it("should import symbols", async () => {
+    const symbols = await importFiles([join(rootDir, "__mock__/*.ts")], []);
+
+    expect(symbols.sort()).toEqual(["value", Test1, "value", Test2].sort());
+  });
+
+  it("should import symbols without excluded files", async () => {
+    const symbols = await importFiles([join(rootDir, "__mock__/*.ts")], [join(rootDir, "__mock__/Test2.ts")]);
+
+    expect(symbols.sort()).toEqual(["value", Test1].sort());
+  });
+});

package/src/importFiles.ts

@@ -0,0 +1,18 @@
+import {cleanGlobPatterns} from "./cleanGlobPatterns.js";
+
+export async function importFiles(patterns: string | string[], exclude: string[]): Promise<any[]> {
+  const {globby} = await import("globby");
+
+  const files = await globby(cleanGlobPatterns(patterns, exclude));
+  const symbols: any[] = [];
+
+  for (const file of files.sort((a, b) => (a < b ? -1 : 1))) {
+    if (!file.endsWith(".d.ts")) {
+      // prevent .d.ts import if the global pattern isn't correctly configured
+      const exports = await import(file);
+      Object.keys(exports).forEach((key) => symbols.push(exports[key]));
+    }
+  }
+
+  return symbols;
+}

package/src/importProviders.spec.ts

@@ -0,0 +1,41 @@
+import {nameOf} from "@tsed/core";
+import {resolveControllers} from "@tsed/platform-http";
+
+import {importProviders} from "./importProviders.js";
+
+const rootDir = import.meta.dirname; // automatically replaced by import.meta.dirname on build
+
+describe("importProviders", () => {
+  it("should load providers and merge configuration", async () => {
+    const configuration = {
+      mount: {
+        "/rest": [`${rootDir}/__mock__/controllers/**/*.ts`]
+      },
+      imports: [`${rootDir}/__mock__/**/Module*.ts`]
+    };
+
+    const result = await importProviders(configuration);
+
+    expect(result.imports?.map(nameOf)).toEqual(["Module1", "Module2"]);
+    expect(result.mount!["/rest"].map(nameOf)).toEqual(["TestCtrl"]);
+
+    const result2 = resolveControllers(result);
+
+    const routes = result2.map((item) => ({...item, token: nameOf(item.token)}));
+
+    expect(routes).toEqual([
+      {
+        route: "/m1",
+        token: "M1Ctrl1"
+      },
+      {
+        route: "/mod2",
+        token: "M2Ctrl"
+      },
+      {
+        route: "/rest",
+        token: "TestCtrl"
+      }
+    ]);
+  });
+});

package/src/importProviders.ts

@@ -0,0 +1,57 @@
+import {isArray, isClass, isString} from "@tsed/core";
+import {GlobalProviders, ProviderType} from "@tsed/di";
+
+import {importFiles} from "./importFiles.js";
+
+const lookup = ["imports", "componentsScan", "mount"];
+
+async function resolveRecursively(items: any[], exclude: string[], rootDir: string) {
+  for (const index in items) {
+    if (isString(items[index])) {
+      items[index] = await importFiles(items[index].replace("${rootDir}", rootDir), exclude);
+    }
+  }
+
+  const providers = items.flat().filter(isClass);
+
+  for (const token of providers) {
+    const provider = GlobalProviders.get(token);
+
+    if (provider?.type === ProviderType.MODULE && provider.configuration) {
+      provider.configuration.exclude = exclude;
+      provider.configuration.rootDir = provider.configuration.rootDir || rootDir;
+
+      provider.configuration = await importProviders(provider.configuration);
+    }
+  }
+
+  return providers;
+}
+
+/**
+ * Lookup settings and replace glob pattern by the resolved providers
+ *
+ * @param settings
+ */
+export async function importProviders(settings: Record<string, any>): Promise<Partial<TsED.Configuration>> {
+  const {exclude = [], rootDir} = settings;
+
+  for (const property of lookup) {
+    if (settings[property]) {
+      if (!isArray(settings[property])) {
+        const current = settings[property];
+        const promises = Object.entries(current).map(async ([key, items]: [string, any]) => {
+          current[key] = await resolveRecursively([].concat(items), exclude, rootDir);
+        });
+
+        await Promise.all(promises);
+      } else {
+        settings[property] = await resolveRecursively(settings[property], exclude, rootDir);
+      }
+    }
+  }
+
+  settings.disableComponentsScan = true;
+
+  return settings;
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+/**
+ * @file Automatically generated by @tsed/barrels.
+ */
+export * from "./cleanGlobPatterns.js";
+export * from "./importFiles.js";
+export * from "./importProviders.js";
+export * from "./isTsEnv.js";

package/src/isTsEnv.ts

@@ -0,0 +1,9 @@
+export function isTsEnv() {
+  return (
+    process.env["TS_NODE_DEV"] ||
+    process.env["_"]?.includes("ts-node") ||
+    process.env["TS_TEST"] ||
+    process.env.JEST_WORKER_ID !== undefined ||
+    process.env.NODE_ENV === "test"
+  );
+}