Load files from subdirectories

README.md

@@ -45,9 +45,9 @@ Before:
 import { Module } from '@nestjs/common';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Admin])],
   controllers: [AuthController],
   providers: [AuthService, AdminGuard, UserMiddleware, AdminService],
+  imports: [TypeOrmModule.forFeature([Admin])],
   exports: [AuthService],
 })
 export class AuthModule {}
@@ -64,3 +64,23 @@ import { AutoloadModule } from 'nestjs-autoloader';
 })
 export class AuthModule {}
 ```
+
+## Nested Module Directories
+
+The autoloader is designed to work with nested module directories.
+For example:
+
+```
+parent/
+├── parent.module.ts
+├── parent.service.ts
+└── sub/
+    ├── sub.module.ts
+    └── sub.service.ts
+```
+
+This will load the `parent.service.ts` for the `parent` module,
+but not the `sub.service.ts`.
+The autoloader recognises nested modules by looking at `*.module.ts` files.
+If a directory contains a file with that name,
+it will exclude this directory from autoloading for the containing module.

package.json

@@ -20,7 +20,7 @@
   },
   "scripts": {
     "prepack": "npm run build",
-    "build": "tsc",
+    "build": "tsc -p tsconfig.build.json",
     "lint": "eslint \"src/**/*.ts\" \"test/**/*.ts\" --max-warnings 0",
     "format": "npm run lint -- --fix",
     "test": "jest"

src/AutoloadModule.ts

@@ -0,0 +1,77 @@
+import { Logger, Module, ModuleMetadata, Provider, Type } from '@nestjs/common';
+import {
+  CONTROLLER_WATERMARK,
+  INJECTABLE_WATERMARK,
+} from '@nestjs/common/constants';
+import { combine } from './combine';
+import { listFiles } from './listFiles';
+import { isScript } from './isScript';
+
+const logger = new Logger('AutoloadModule');
+
+export function AutoloadModule(
+  dirName: string,
+  metadata?: ModuleMetadata
+): ClassDecorator {
+  return (target) => {
+    logger.verbose(`Autoloading module: ${dirName}`);
+    const loaded = loadScripts(dirName);
+    const combinedMeta: ModuleMetadata = {
+      ...metadata,
+      controllers: combine(metadata?.controllers, loaded.controllers),
+      providers: combine(metadata?.providers, loaded.providers),
+    };
+    Module(combinedMeta)(target);
+  };
+}
+
+interface LoadResult {
+  controllers: Type[];
+  providers: Provider[];
+}
+
+function loadScripts(dirName: string): LoadResult {
+  const scripts = listFiles(dirName).filter(isScript);
+
+  const result: LoadResult = {
+    controllers: [],
+    providers: [],
+  };
+
+  for (const script of scripts) {
+    logger.verbose(`Autoloading file: ${script}`);
+
+    // Here we have to use require, to get the exports into a variable.
+    // eslint-disable-next-line @typescript-eslint/no-var-requires
+    const reqVals = Object.values(require(script));
+
+    for (const check of reqVals) {
+      if (typeof check === 'function') {
+        if (isController(check)) {
+          logger.verbose(`Found controller: ${check.name}`);
+          result.controllers.push(check);
+        }
+
+        if (isProvider(check)) {
+          logger.verbose(`Found provider: ${check.name}`);
+          result.providers.push(check);
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+// For both of these functions,
+// we specifically want to use the Object type because it accepts almost anything.
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isController(fn: Object): fn is Type {
+  return Reflect.hasMetadata(CONTROLLER_WATERMARK, fn);
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+function isProvider(fn: Object): fn is Provider {
+  return Reflect.hasMetadata(INJECTABLE_WATERMARK, fn);
+}

src/combine.ts

@@ -0,0 +1,3 @@
+export function combine<T>(left: T[] | undefined, right: T[]): T[] {
+  return [...(left || []), ...right];
+}

src/index.ts

@@ -1,89 +1 @@
-import { Logger, Module, ModuleMetadata, Provider, Type } from '@nestjs/common';
-import {
-  CONTROLLER_WATERMARK,
-  INJECTABLE_WATERMARK,
-} from '@nestjs/common/constants';
-import fs from 'fs';
-
-const logger = new Logger('AutoloadModule');
-
-export function AutoloadModule(
-  dirName: string,
-  metadata?: ModuleMetadata
-): ClassDecorator {
-  return (target) => {
-    logger.verbose(`Autoloading module: ${dirName}`);
-    const loaded = loadFiles(dirName);
-    const combinedMeta: ModuleMetadata = {
-      ...metadata,
-      controllers: combine(metadata?.controllers, loaded.controllers),
-      providers: combine(metadata?.providers, loaded.providers),
-    };
-    Module(combinedMeta)(target);
-  };
-}
-
-interface LoadResult {
-  controllers: Type[];
-  providers: Provider[];
-}
-
-function loadFiles(dirName: string): LoadResult {
-  const checkFiles = fs
-    .readdirSync(dirName)
-    .filter(
-      (f) => (f.endsWith('.js') || f.endsWith('.ts')) && !f.endsWith('.d.ts')
-    )
-    .map((f) => `${dirName}/${f}`);
-
-  const result: LoadResult = {
-    controllers: [],
-    providers: [],
-  };
-
-  for (const file of checkFiles) {
-    logger.verbose(`Autoloading file: ${file}`);
-
-    // Here we have to use require, to get the exports into a variable.
-    // eslint-disable-next-line @typescript-eslint/no-var-requires
-    const reqVals = Object.values(require(file));
-
-    for (const check of reqVals) {
-      if (typeof check === 'function') {
-        const controller = checkController(check);
-        if (controller) {
-          result.controllers.push(controller);
-        }
-
-        const provider = checkProvider(check);
-        if (provider) {
-          result.providers.push(provider);
-        }
-      }
-    }
-  }
-
-  return result;
-}
-
-// For both of these functions, we specifically want to use the Function type because it accepts any function-like.
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-function checkController(fn: Function): Type | undefined {
-  if (Reflect.hasMetadata(CONTROLLER_WATERMARK, fn)) {
-    logger.verbose(`Found controller: ${fn.name}`);
-    return fn as Type;
-  }
-}
-
-// eslint-disable-next-line @typescript-eslint/ban-types
-function checkProvider(fn: Function): Provider | undefined {
-  if (Reflect.hasMetadata(INJECTABLE_WATERMARK, fn)) {
-    logger.verbose(`Found provider: ${fn.name}`);
-    return fn as Provider;
-  }
-}
-
-function combine<T>(left: T[] | undefined, right: T[]): T[] {
-  return [...(left || []), ...right];
-}
+export * from './AutoloadModule';

src/isScript.ts

@@ -0,0 +1,13 @@
+export function isScript(name: string): boolean {
+  return (
+    // Include js and ts files.
+    (name.endsWith('.js') || name.endsWith('.ts')) &&
+    // Exclude type mappings.
+    !name.endsWith('.d.ts') &&
+    // Exclude test-related files.
+    !name.endsWith('.test.ts') &&
+    !name.endsWith('.spec.ts') &&
+    !name.endsWith('.test.js') &&
+    !name.endsWith('.spec.js')
+  );
+}

src/listFiles.ts

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+
+export function listFiles(dirName: string): string[] {
+  return listFilesRecursive(dirName, true);
+}
+
+function listFilesRecursive(dirName: string, isRootModule: boolean): string[] {
+  const entries = fs.readdirSync(dirName, { withFileTypes: true });
+  const files: string[] = [];
+  const dirs: string[] = [];
+
+  let isSubModuleDir = false;
+
+  entries.forEach((e) => {
+    // Get the full path to the entry.
+    const p = path.join(dirName, e.name);
+
+    // Split the entry into one of the lists: file or directory.
+    if (e.isDirectory()) {
+      dirs.push(p);
+    } else {
+      files.push(p);
+
+      // Check if this directory is a separate submodule.
+      if (
+        !isRootModule &&
+        (p.endsWith('.module.ts') || p.endsWith('.module.js'))
+      ) {
+        isSubModuleDir = true;
+      }
+    }
+  });
+
+  // If this directory is a submodule, we want to ignore it from autoloading.
+  if (isSubModuleDir) {
+    return [];
+  }
+
+  // Recurse into all subdirectories.
+  dirs.forEach((d) => files.push(...listFilesRecursive(d, false)));
+
+  return files;
+}

test/AutoloadModule.test.ts

@@ -1,19 +1,33 @@
 import { AutoloadModule } from '../src';
-import { TestController } from './test.controller';
-import { TestProvider } from './test.provider';
+import { TestController } from './module/test.controller';
+import { TestProvider } from './module/test.provider';
+import { SubdirController } from './module/subdir/subdir.controller';
+import { SubdirProvider } from './module/subdir/subdir.provider';
+import path from 'path';
+import { IncludeProvider } from './module-with-submodule/include.provider';
+
+/*
+The way to check if items are properly loaded is to check the class metadata.
+The `@Module` decorator set each passed object property as a metadata property.
+ */
 
 describe('AutoloadModule', () => {
   it('loads controllers and providers', () => {
-    @AutoloadModule(__dirname)
+    @AutoloadModule(path.join(__dirname, 'module'))
     class TestModule {}
 
-    // The way to check if items are properly loaded, is to check the class metadata.
-    // The `@Module` decorator set each passed object property as a metadata property.
-
     const controllers = Reflect.getOwnMetadata('controllers', TestModule);
-    expect(controllers).toStrictEqual([TestController]);
+    expect(controllers).toStrictEqual([TestController, SubdirController]);
+
+    const providers = Reflect.getOwnMetadata('providers', TestModule);
+    expect(providers).toStrictEqual([TestProvider, SubdirProvider]);
+  });
+
+  it('does not load items from submodules', () => {
+    @AutoloadModule(path.join(__dirname, 'module-with-submodule'))
+    class TestModule {}
 
     const providers = Reflect.getOwnMetadata('providers', TestModule);
-    expect(providers).toStrictEqual([TestProvider]);
+    expect(providers).toStrictEqual([IncludeProvider]);
   });
 });

test/isScript.test.ts

@@ -0,0 +1,18 @@
+import { isScript } from '../src/isScript';
+
+describe('isScript', () => {
+  it.each`
+    extension            | result
+    ${'file.js'}         | ${true}
+    ${'file.ts'}         | ${true}
+    ${'file.service.ts'} | ${true}
+    ${'file.service.js'} | ${true}
+    ${'file.d.ts'}       | ${false}
+    ${'file.test.ts'}    | ${false}
+    ${'file.test.js'}    | ${false}
+    ${'file.spec.ts'}    | ${false}
+    ${'file.spec.js'}    | ${false}
+  `('returns $result when given $extension', ({ extension, result }) => {
+    expect(isScript(extension)).toBe(result);
+  });
+});

test/listFiles.test.ts

@@ -0,0 +1,20 @@
+import { listFiles } from '../src/listFiles';
+import path from 'path';
+
+describe('listFiles', () => {
+  it('returns a list of all files, from all subdirectories', () => {
+    const root = path.join(__dirname, 'list');
+    const paths = listFiles(root);
+    expect(paths).toStrictEqual([
+      path.join(root, 'one.txt'),
+      path.join(root, 'list-sub', 'two.txt'),
+      path.join(root, 'list-sub', 'list-sub-sub', 'three.txt'),
+    ]);
+  });
+
+  it('excludes directories containing a module file', () => {
+    const root = path.join(__dirname, 'module-with-submodule');
+    const paths = listFiles(root);
+    expect(paths).toStrictEqual([path.join(root, 'include.provider.ts')]);
+  });
+});

test/module-with-submodule/include.provider.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class IncludeProvider {}

test/module-with-submodule/submodule/no-include.provider.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class NoIncludeProvider {}

test/module-with-submodule/submodule/sub.module.ts

@@ -0,0 +1 @@
+export class SubModule {}

test/module/subdir/subdir.controller.ts

@@ -0,0 +1,4 @@
+import { Controller } from '@nestjs/common';
+
+@Controller()
+export class SubdirController {}

test/module/subdir/subdir.provider.ts

@@ -0,0 +1,4 @@
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class SubdirProvider {}

tsconfig.build.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "src/**/*"
+  ]
+}

tsconfig.json

@@ -47,9 +47,9 @@
     "declaration": true,                                 /* Generate .d.ts files from TypeScript and JavaScript files in your project. */
     // "declarationMap": true,                           /* Create sourcemaps for d.ts files. */
     // "emitDeclarationOnly": true,                      /* Only output d.ts files and not JavaScript files. */
-    "sourceMap": true,                                   /* Create source map files for emitted JavaScript files. */
+    // "sourceMap": true,                                /* Create source map files for emitted JavaScript files. */
     // "outFile": "./",                                  /* Specify a file that bundles all outputs into one JavaScript file. If 'declaration' is true, also designates a file that bundles all .d.ts output. */
-    "outDir": "./dist",                                      /* Specify an output folder for all emitted files. */
+    "outDir": "./dist",                                  /* Specify an output folder for all emitted files. */
     // "removeComments": true,                           /* Disable emitting comments. */
     // "noEmit": true,                                   /* Disable emitting files from a compilation. */
     // "importHelpers": true,                            /* Allow importing helper functions from tslib once per project, instead of including them per-file. */