Merge pull request #23 from tiny-nestjs/dev

release: `v0.2.1`

Author: player31-kks

.eslintrc.js

@@ -1,7 +1,6 @@
 module.exports = {
   parser: '@typescript-eslint/parser',
   parserOptions: {
-    project: 'tsconfig.json',
     tsconfigRootDir: __dirname,
     sourceType: 'module',
   },

.gitignore

@@ -398,3 +398,7 @@ Temporary Items
 dist
 .webpack
 .serverless/**/*.zip
+
+# Local Test
+tsconfig.build.json
+src/

.husky/pre-commit

@@ -0,0 +1,4 @@
+#!/usr/bin/env sh
+. "$(dirname -- "$0")/_/husky.sh"
+
+npx lint-staged

.prettierrc

@@ -1,4 +1,6 @@
 {
   "singleQuote": true,
-  "trailingComma": "all"
+  "trailingComma": "all",
+  "printWidth": 120,
+  "tabWidth": 2
 }

README.md

@@ -3,7 +3,7 @@
 </p>
 
 <div align="center">
-  <img src="https://img.shields.io/badge/npm-v0.0.1-blue" alt="npm version">
+  <img src="https://img.shields.io/badge/npm-v0.2.1-blue" alt="npm version">
   <img src="https://img.shields.io/badge/license-MIT-green" alt="License">
 </div>
 
@@ -16,8 +16,9 @@ With this library, you can inject dependencies into classes without the need for
 
 ## Features
 
-- `@AutoInjectable()` decorator allows classes to be automatically injectable for DI.
 - `@ComponentScan()` decorator enables automatic scanning and injection of classes within a module.
+- `@AutoInjectable()` decorator allows classes to be automatically injectable for DI.
+- `@AutoController()` decorator automatically registers controllers.
 
 ## Installation
 
@@ -29,62 +30,67 @@ npm install @tiny-nestjs/auto-injectable
 
 **1. `@ComponentScan()`**
 
-   Use `@ComponentScan()` decorator to enable automatic scanning and injection of classes within a module:
-   
-   ```typescript
-  import { Module } from '@nestjs/common';
-  import { AppService } from './app.service';
-  import { AppController } from './app.controller';
-  import { ComponentScan } from '@nestjs/auto-injectable';
-  
-  @ComponentScan()
-  @Module({
-      imports: [],
-      controllers: [AppController],
-      providers: [AppService],
-  })
-  export class AppModule {}
-  ``` 
-
-   By applying the `@ComponentScan()` decorator to the AppModule class, Nest will automatically scan for classes and
-   inject necessary dependencies.
+```ts
+import { Module } from '@nestjs/common';
+import { ComponentScan } from '@tiny-nestjs/auto-injectable';
+
+@ComponentScan()
+@Module({
+  imports: [],
+  controllers: [],
+  providers: [],
+})
+export class AppModule {
+}
+``` 
+
+By applying the `@ComponentScan()` decorator to the AppModule class, Nest will automatically scan for classes and
+inject necessary dependencies.
 
 **2. `@AutoInjectable()`**
 
-   Use `@AutoInjectable()` decorator to make a class injectable for DI:
+```ts
+import { AutoInjectable } from '@tiny-nestjs/auto-injectable';
 
-  ```typescript
-  import { AutoInjectable } from '@nestjs/auto-injectable';
-  
-  @AutoInjectable()
-  export class CatService {
-      // ...
-  }
-  ```
+@AutoInjectable()
+export class CatService {
+  // ...
+}
+```
 
-   In this case, by applying the @AutoInjectable() decorator to the CatService class, the class has become injectable, allowing it to be injected into other modules without the need for module definitions.
+In this case, by applying the `@AutoInjectable()` decorator to the CatService class, the class has become injectable,
+allowing it to be injected into other modules without the need for module definitions.
 
-**3. Inject**
+**3. `@AutoController()` and dependency injection**
+
+```ts
+import { AutoController } from '@tiny-nestjs/auto-injectable';
+
+@AutoController()
+export class CatController {
+  constructor(private readonly catService: CatService) {
+  }
+
+  @Get('cats')
+  getCats() {
+    return this.catService.findAll();
+  }
+}
+```
 
-   ```typescript
-   @Controller()
-   export class AppController {
-     constructor(private readonly catService: CatService) {}
-   
-     @Get('cats')
-     getCats() {
-       return this.catService.findAll();
-     }
-   }
-   ```
+The class with the `@AutoInjectable()` decorator has been successfully injected and `/cats` api can be accessed by
+applying `@AutoController()` on `CatController` service.
 
-   The class with the @AutoInjectable() decorator has been successfully injected.
+| You can see actual [project example](https://github.com/tiny-nestjs/auto-injectable-example) here. |
+|----------------------------------------------------------------------------------------------------|
 
 ## Contribution
 
-To contribute to this library, fork the GitHub repository, make your changes, and create a pull request. Your
+To contribute to this library, fork the [GitHub repository](https://github.com/tiny-nestjs/auto-injectable), make your
+changes, and create a pull request. Your
 contributions are highly appreciated. If you find any improvements or bugs, please open an issue.
 
 ## License
 
-`@tiny-nestjs/auto-injectable` is distributed under the MIT license.
+`@tiny-nestjs/auto-injectable` is distributed under
+the [MIT license](https://github.com/tiny-nestjs/auto-injectable/blob/main/LICENSE).

jest.config.js

@@ -1,6 +1,6 @@
 module.exports = {
   moduleFileExtensions: ['js', 'json', 'ts'],
-  rootDir: 'src',
+  rootDir: './',
   testRegex: '.*\\.spec\\.ts$',
   transform: {
     '^.+\\.(t|j)s$': 'ts-jest',

lib/auto.module.ts

@@ -0,0 +1,16 @@
+import { DynamicModule, Module } from '@nestjs/common';
+import { Importer } from './core';
+
+@Module({})
+export class AutoModule {
+  static async forRootAsync(patterns: string[]): Promise<DynamicModule> {
+    const classes = await Importer.load(patterns);
+
+    return {
+      module: AutoModule,
+      controllers: [...classes.controllers],
+      providers: [...classes.providers],
+      exports: [...classes.providers],
+    };
+  }
+}

lib/core/importer.spec.ts

@@ -0,0 +1,15 @@
+import { Importer } from './importer';
+
+describe('Importer', () => {
+  const paths = ['./test/fixture.ts'];
+
+  it('should get path of patterns', async () => {
+    const result = await Importer.load(paths);
+    console.log(result);
+  });
+
+  it('should import file', async () => {
+    const result = await Importer.load(paths);
+    console.log(result);
+  });
+});

lib/core/importer.ts

@@ -0,0 +1,54 @@
+import { glob } from 'glob';
+import { resolve } from 'path';
+import { AUTO_CONTROLLER_WATERMARK, AUTO_INJECTABLE_WATERMARK } from '../interfaces';
+import 'reflect-metadata';
+
+type ClassType = new (...args: any[]) => any;
+
+interface AutoClasses {
+  providers: ClassType[];
+  controllers: ClassType[];
+}
+
+export class Importer {
+  private static instance: Importer | null = null;
+
+  static getInstance(): Importer {
+    if (!Importer.instance) {
+      Importer.instance = new Importer();
+    }
+    return Importer.instance;
+  }
+
+  static async load(patterns: string[]): Promise<AutoClasses> {
+    const importer = Importer.getInstance();
+    const pathNames = await importer.matchGlob(patterns);
+    const foundClasses = await Promise.all(pathNames.map((pathName) => importer.scan(pathName)));
+    return foundClasses.reduce(
+      (merged, found) => ({
+        providers: [...merged.providers, ...found.providers],
+        controllers: [...merged.controllers, ...found.controllers],
+      }),
+      { providers: [], controllers: [] } as AutoClasses,
+    );
+  }
+
+  private async scan(pathName: string): Promise<AutoClasses> {
+    const exports: Record<string, unknown> = await import(pathName);
+    const autoClasses = Object.values(exports).filter((value) => typeof value === 'function') as ClassType[];
+
+    return autoClasses.reduce(
+      (result: AutoClasses, value: ClassType) => {
+        Reflect.hasMetadata(AUTO_INJECTABLE_WATERMARK, value) && result.providers.push(value);
+        Reflect.hasMetadata(AUTO_CONTROLLER_WATERMARK, value) && result.controllers.push(value);
+        return result;
+      },
+      { providers: [], controllers: [] },
+    );
+  }
+
+  private async matchGlob(patterns: string[]) {
+    const globs = patterns.map((pattern) => glob(resolve(process.cwd(), pattern)));
+    return (await Promise.all(globs)).flat();
+  }
+}

src/lib/core/index.ts lib/core/index.ts

@@ -0,0 +1,21 @@
+import { Controller, ControllerOptions } from '@nestjs/common';
+import { AUTO_CONTROLLER_WATERMARK } from '../interfaces';
+
+export function AutoController(prefixOrOptions?: string | string[] | ControllerOptions) {
+  return (target: object) => {
+    Reflect.defineMetadata(AUTO_CONTROLLER_WATERMARK, true, target);
+
+    /**
+     * Listing of if statements due to `@Controller` overloading.
+     */
+    if (typeof prefixOrOptions === 'undefined') {
+      return Controller()(target as new (...args: any[]) => any);
+    }
+    if (typeof prefixOrOptions === 'string' || Array.isArray(prefixOrOptions)) {
+      return Controller(prefixOrOptions)(target as new (...args: any[]) => any);
+    }
+    if (typeof prefixOrOptions === 'object') {
+      return Controller(prefixOrOptions)(target as new (...args: any[]) => any);
+    }
+  };
+}

lib/decorators/auto-controller.decorator.ts

@@ -1,5 +1,5 @@
-import { AUTO_INJECTABLE_WATERMARK } from '../interfaces';
 import { AutoInjectable } from './auto-injectable.decorator';
+import { AUTO_INJECTABLE_WATERMARK } from '../interfaces';
 
 describe('AutoInjectable decorator', () => {
   @AutoInjectable()

src/lib/decorators/auto-injectable.decorator.spec.ts lib/decorators/auto-injectable.decorator.spec.ts

@@ -0,0 +1,14 @@
+import { AUTO_INJECTABLE_WATERMARK } from '../interfaces';
+import { Injectable } from '@nestjs/common';
+import { InjectableOptions } from '@nestjs/common/decorators/core/injectable.decorator';
+
+export function AutoInjectable(options?: InjectableOptions) {
+  return (target: object) => {
+    Reflect.defineMetadata(AUTO_INJECTABLE_WATERMARK, true, target);
+
+    /**
+     * `@Injectable` decorator only has one type.
+     */
+    return Injectable(options)(target as new (...args: any[]) => any);
+  };
+}

lib/decorators/auto-injectable.decorator.ts

@@ -2,27 +2,24 @@ import { AutoModule } from '../auto.module';
 import { Module } from '@nestjs/common';
 import * as path from 'path';
 
-export function ComponentScan(
-  paths: string[] = [getRootPath()],
-): ClassDecorator {
+export function ComponentScan(paths: string[] = [getRootPath()]): ClassDecorator {
   return function (target: any) {
     const originalMetadata = {
       imports: Reflect.getMetadata(MODULE_OPTIONS.IMPORTS, target) || [],
-      controllers:
-        Reflect.getMetadata(MODULE_OPTIONS.CONTROLLERS, target) || [],
+      controllers: Reflect.getMetadata(MODULE_OPTIONS.CONTROLLERS, target) || [],
       providers: Reflect.getMetadata(MODULE_OPTIONS.PROVIDERS, target) || [],
     };
 
-    const options = paths.map((path) => `${path}/**/*.js`);
+    const patterns = paths.map((path) => `${path}/**/*.js`);
     Module({
       ...originalMetadata,
-      imports: [...originalMetadata.imports, AutoModule.forRootAsync(options)],
+      imports: [...originalMetadata.imports, AutoModule.forRootAsync(patterns)],
     })(target);
   };
 }
 
 function getRootPath(): string {
-  return path.join(path.resolve(require.main?.filename), '..') || 'dist';
+  return path.join(path.resolve(require.main?.filename ?? ''), '..') || 'dist';
 }
 
 const MODULE_OPTIONS = {

src/lib/decorators/component-scan.decorator.ts lib/decorators/component-scan.decorator.ts

@@ -1,2 +1,3 @@
+export * from './auto-controller.decorator';
 export * from './auto-injectable.decorator';
 export * from './component-scan.decorator';

src/lib/decorators/index.ts lib/decorators/index.ts

@@ -0,0 +1 @@
+export const AUTO_CONTROLLER_WATERMARK = Symbol('AUTO_CONTROLLER_WATERMARK');

src/lib/index.ts lib/index.ts

@@ -1 +1,2 @@
 export * from './auto-injectable.constant';
+export * from './auto-controller.constant';