codeweaver 1.0.9

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Ehsan-Afzali-2024
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,203 @@
+# A lightweight framework built on top of Express and TypeScript
+
+## Overview
+
+**Codeweaver** is a lightweight framework built on top of `Express` and `TypeScript`, integrating `Swagger` for API documentation. The application utilizes `async handlers` for improved error management and follows a modular structure for routers, enabling easy expansion and organization of the application.
+
+## Features
+
+- **Modular Router Structure**: Each router is automatically imported and mounted, providing clean separation of endpoints and logic.
+- **Express Framework**: A lightweight web application framework for building web applications in Node.js.
+- **TypeScript**: Provides strong typing for better development experience and less runtime errors.
+- **Swagger Integration**: Automatically generates interactive API documentation, making it easy for developers and consumers to understand the available endpoints.
+- **Async Handlers**: Supports async/await syntax for writing cleaner and more maintainable asynchronous code without deeply nested callbacks.
+
+## Technologies Used
+
+- **Node.js**
+- **Express**
+- **TypeScript**
+- **Zod** (for input validation)
+- **ts-zod-decorators** (for validation using Zod with decorators)
+- **utils-decorators** (for middleware utilities like throttling and error handling)
+- **Swagger** (for API documentation)
+
+## Installation
+
+To get started with the project, follow these steps:
+
+1. **Clone the repository**:
+
+   ```bash
+   git clone https://github.com/@js-code-crafter/codeweaver.git
+   cd codeweaver
+   ```
+
+2. **Install dependencies**:
+
+   ```bash
+   npm install
+   ```
+
+3. **Run the application**:
+
+   ```bash
+   npm start
+   ```
+
+4. **Visit the Swagger UI**: Open your browser and go to `http://localhost:3000/api-docs` to view the automatically generated API documentation.
+
+5. **Build**: Compile the TypeScript files for the production environment:
+
+   ```bash
+   npm run build
+   ```
+
+## Sample Project Structure
+
+**/src**  
+├── **/routers** `Directory containing all router files`  
+│ ├── **/user** `Routers for user-related endpoints`  
+│ │ ├── user_router1.ts `/user/user_router1`  
+│ │ ├── user_router2.ts `/user/user_router2`  
+│ │ ├── user.controller.ts  
+│ │ ├── user.service.ts  
+│ │ └── user.dto.ts  
+│ ├── **/product** `Routers for product-related endpoints`  
+│ │ ├── index.ts `/product`  
+│ │ ├── product_test.spec.ts  
+│ │ ├── product.controller.ts  
+│ │ ├── product.service.ts  
+│ │ ├── **/dto**  
+│ │ │ └── product.dto.ts  
+│ ├── **/order** `Routers for order-related endpoints`  
+│ │ ├── index.ts `/order`  
+│ │ ├── order_test.spec.ts  
+│ │ ├── order.controller.ts  
+│ │ └── order.service.ts  
+│ └── index.ts `Home page`  
+├── app.ts `Main application file`  
+├── config.ts `Application configuration file`  
+└── ... `Other files (middleware, models, etc.)`
+
+### Router Directory
+
+Each router file in the `/routers` directory is organized to handle related endpoints. The `app.ts` file automatically imports all routers and mounts them to the main Express application, making it simple to add new routes without modifying central files.
+
+Files that end with `.controller`, `.service`, `.spec`, `.dto`, `.middleware`, `.error`, or `.decorator`, as well as those that start with `_` or `@`, are excluded from the router list and can be utilized for various other purposes within the application.
+
+Example of a basic router:
+
+```typescript
+import { Router, Request, Response } from "express";
+import asyncHandler from "express-async-handler";
+
+const router = Router();
+
+/**
+ * @swagger
+ * /:
+ *   get:
+ *     summary: Get the home page
+ *     description: Returns the home page.
+ *     responses:
+ *       200:
+ *         description: home page
+ */
+router.get(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.send("Home");
+  })
+);
+
+export = router;
+```
+
+### Controllers
+
+**Controllers** in this Express TypeScript framework act as the intermediary between the incoming HTTP requests and the application logic. Each controller is responsible for handling specific routes and defining the behavior associated with those routes. This organization promotes a clean architecture by separating business logic, validation, and routing concerns.
+
+Controllers can be organized within the router folders, allowing them to stay closely related to their respective routes. However, they are not limited to this structure and can be placed anywhere within the `src` folder as needed, providing flexibility in organizing the codebase.
+
+Controllers leverage decorators from the `ts-zod-decorators` package to implement input validation and error handling gracefully. With validators like `@Validate`, controllers can ensure that incoming data adheres to defined schemas before any processing occurs, preventing invalid data from reaching the service layer. This capability enhances data integrity and application reliability.
+
+For example, in the provided `UserController`, the `createUser` method demonstrates how to apply input validation and error handling through decorators. It employs `@rateLimit` to restrict the number of allowed requests within a specified timeframe, effectively guarding against too many rapid submissions. When an error arises, the `@onError` decorator provides a systematic way to handle exceptions, allowing for logging or other error management processes to be performed centrally.
+
+Here’s a brief breakdown of key components used in the `UserController`:
+
+- **Validation**: The `CreateUserDto` is validated against incoming data using the `@ZodInput` decorator, ensuring that only well-formed data is passed to the business logic, which is crucial for maintaining application stability.
+
+```typescript
+import { z } from "zod";
+
+export const createUserDto = z.object({
+  username: z.string().min(3),
+  email: z.string().email(),
+  password: z.string().min(6),
+});
+
+export type CreateUser = z.infer<typeof createUserDto>;
+```
+
+- **Throttling and Rate Limiting**: The `@rateLimit` decorator is applied to safeguard the application's endpoints from abuse by limiting how frequently a particular method can be invoked.
+
+- **Error Handling**: The `@onError` decorator captures any exceptions that occur during the execution of the createUser method, allowing for centralized error management, which can greatly simplify debugging and improve maintainability.
+
+By using a well-organized controller structure, this project makes it easier to add, modify, and manage endpoints as the application grows. Developers can focus on implementing business logic while the controllers handle the intricacies of request parsing, validation, and response formatting. Additionally, this separation of concerns improves unit testing, as controllers can be tested independently from the rest of the application logic, ensuring robust and reliable API behavior.
+
+Here is a quick reference to the UserController in practice:
+
+```typescript
+import { Validate, ZodInput } from "ts-zod-decorators";
+import { createUserDto, CreateUser } from "./dto/user.dto";
+import { onError, rateLimit } from "utils-decorators";
+
+function exceedHandler() {
+  throw new Error("Too much call in allowed window");
+}
+
+function errorHandler(e: Error): void {
+  console.error(e);
+}
+
+export default class UserController {
+  //constructor(private readonly userService: UserService) { }
+
+  // Throttle the createUser method to 1 request per 200 milliseconds
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  @onError({
+    func: errorHandler,
+  })
+  @Validate
+  public async createUser(
+    @ZodInput(CreateUserDto) data: CreateUser
+  ): Promise<string> {
+    // Here you can include logic to save user to database
+    console.log("Creating user:", data);
+    return "User created successfully";
+  }
+}
+```
+
+This structure not only supports effective code organization but also ensures that each part of the application is working towards the same goal: a scalable, maintainable, and robust API.
+
+### Async Handlers
+
+To maintain cleaner code and improve error handling, the app suggests the `express-async-handler` package that automatically catches exceptions inside of async express routes and passing them to the express error handlers. This allows you to focus on writing the business logic without worrying about try/catch blocks.
+
+### API Documentation
+
+Once the application is running, visit the Swagger UI at http://localhost:3000/api-docs. This automatically generated documentation will provide you with all available routes along with details on request parameters, response structures, and possible error codes.
+
+### Decorators
+
+To prevent abuse of your API, you can utilize throttling, and validation decorators from the `utils-decorators` and `ts-zod-decorators` packages respectively. This packages provides decorators that can be applied directly to your service and controller classes.
+
+### Contributing
+
+Contributions are welcome! If you have suggestions for improvements or new features, feel free to create an issue or submit a pull request.

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "codeweaver",
+  "version": "1.0.9",
+  "main": "src/app.ts",
+  "scripts": {
+    "start": "nodemon src/app.ts",
+    "build": "tsc",
+    "serve": "node dist/app.js"
+  },
+  "keywords": [
+    "lightweight framework",
+    "framework",
+    "boilerplate",
+    "bootstrap",
+    "lightweight",
+    "nested routers"
+  ],
+  "author": "Ehsan Afzali",
+  "license": "MIT",
+  "description": "A lightweight framework built on top of Express and TypeScript",
+  "dependencies": {
+    "express": "^4.21.1",
+    "express-async-handler": "^1.2.0",
+    "ts-zod-decorators": "^1.7.1",
+    "utils-decorators": "^2.0.9",
+    "zod": "^3.23.8"
+  },
+  "devDependencies": {
+    "@types/express": "^5.0.0",
+    "@types/node": "^22.10.7",
+    "nodemon": "^3.1.7",
+    "swagger-jsdoc": "^6.2.8",
+    "swagger-ui-express": "^5.0.1",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.6.3"
+  }
+}

package/src/app.ts

@@ -0,0 +1,95 @@
+import express from "express";
+import fs from "fs";
+import path from "path";
+import config from "./config";
+
+// Function to load routers recursively
+function loadRouters(routerPath: string, basePath: string = "") {
+  fs.readdirSync(routerPath).forEach((file) => {
+    // Check if the filename should be excluded based on certain criteria
+    if (
+      // Exclude files that start with an underscore (_)
+      file.startsWith("_") ||
+      // Exclude files that start with an at symbol (@)
+      file.startsWith("@") ||
+      // Exclude JavaScript controller files
+      file.endsWith(".controller.js") ||
+      // Exclude TypeScript controller files
+      file.endsWith(".controller.ts") ||
+      // Exclude JavaScript service files
+      file.endsWith(".service.js") ||
+      // Exclude TypeScript service files
+      file.endsWith(".service.ts") ||
+      // Exclude JavaScript middleware files
+      file.endsWith(".middleware.js") ||
+      // Exclude TypeScript middleware files
+      file.endsWith(".middleware.ts") ||
+      // Exclude JavaScript error middleware files
+      file.endsWith(".error.js") ||
+      // Exclude TypeScript error middleware files
+      file.endsWith(".error.ts") ||
+      // Exclude JavaScript service files
+      file.endsWith(".decorator.js") ||
+      // Exclude TypeScript service files
+      file.endsWith(".decorator.ts") ||
+      // Exclude JavaScript DTO files
+      file.endsWith(".dto.js") ||
+      // Exclude TypeScript DTO files
+      file.endsWith(".dto.ts") ||
+      // Exclude JavaScript test specification files
+      file.endsWith(".spec.js") ||
+      // Exclude TypeScript test specification files
+      file.endsWith(".spec.ts")
+    )
+      // If any of the above conditions are true, exit the function early
+      return;
+
+    const fullPath = path.join(routerPath, file);
+
+    // Construct a route path by combining the base path with the filename
+    const routePath = path
+      // Join the base path and the filename, removing the file extension (.js or .ts)
+      .join(basePath, file.replace(/(\.js|\.ts)/g, ""))
+      // Replace all backslashes with forward slashes for consistent file path formatting
+      .replaceAll("\\", "/")
+      // Remove the trailing '/index' if it exists, to clean up the route
+      .replace(/\/?index$/g, "");
+
+    if (fs.lstatSync(fullPath).isDirectory()) {
+      // If the file is a directory, call the function again
+      loadRouters(fullPath, routePath);
+    } else if (file.endsWith(".ts") || file.endsWith(".js")) {
+      // Import the router module and mount it to the app
+      const router = require(fullPath);
+      app.use("/" + routePath, router);
+      console.log(`Mounted ${file} at ${"/" + routePath}`);
+    }
+  });
+}
+
+const app = express();
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+//app.use(cors());
+
+// Automatically import all routers from the /src/routers directory
+const routersPath = path.join(__dirname, "/routers");
+loadRouters(routersPath);
+
+// Swagger setup
+if (config.devMode) {
+  const swaggerJsDoc = require("swagger-jsdoc");
+  const swaggerUi = require("swagger-ui-express");
+  const swaggerDocs = swaggerJsDoc(config.swaggerOptions);
+  app.use("/api-docs", swaggerUi.serve, swaggerUi.setup(swaggerDocs));
+}
+
+// Start the server
+app.listen(config.port, () => {
+  console.log(`Server is running on http://localhost:${config.port}`);
+  if (config.devMode)
+    console.log(
+      `Swagger UI is available at http://localhost:${config.port}/api-docs`
+    );
+});

package/src/config.ts

@@ -0,0 +1,65 @@
+interface Server {
+  url: string;
+}
+
+interface Info {
+  title: string;
+  version: string;
+  description: string;
+}
+
+interface SwaggerDefinition {
+  openApi: string;
+  info: Info;
+  servers: Server[];
+}
+
+interface SwaggerOptions {
+  swaggerDefinition: SwaggerDefinition;
+  apis: string[];
+}
+
+interface Config {
+  devMode: boolean;
+  port: string;
+  swaggerOptions: SwaggerOptions;
+}
+const port = process.env.PORT || "3000";
+const config: Config = {
+  devMode: process.env.NODE_ENV !== "production",
+  port,
+  swaggerOptions: {
+    swaggerDefinition: {
+      openApi: "3.0.0",
+      info: {
+        title: "Express Items API",
+        version: "1.0.0",
+        description: "A simple CRUD API with Swagger documentation",
+      },
+      servers: [
+        {
+          url: "http://localhost:" + port,
+        },
+      ],
+    },
+    apis: [
+      "./src/routers/index.ts",
+      "./src/routers/**/*.ts",
+      "./src/routers/index.js",
+      "./src/routers/**/*.js",
+    ], // Path to the API docs
+  },
+};
+
+// Other configurations:
+//
+// config.jwt_key = config.devMode ? "" : "";
+// config.jwt_expiration = config.devMode ? 360000 : 360000;
+// config.dbConnectionString = config.devMode ? `mongoDb url` : `mongoDb url`;
+// config.mongoDebug = config.devMode;
+// config.port = config.devMode ? 3000 : 3000;
+// config.host = config.devMode ? "localhost" : "localhost";
+// config.env = config.devMode ? "development" : "production";
+// config.mongoUrl = config.devMode ? "mongodb://localhost:27017/test" : "mongodb://localhost:27017/test";
+
+export default config;

package/src/routers/index.ts

@@ -0,0 +1,23 @@
+import { Router, Request, Response } from "express";
+import asyncHandler from "express-async-handler";
+
+const router = Router();
+
+/**
+ * @swagger
+ * /:
+ *   get:
+ *     summary: Get the home page
+ *     description: Returns the home page.
+ *     responses:
+ *       200:
+ *         description: home page
+ */
+router.get(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.send("Home");
+  })
+);
+
+export = router;

package/src/routers/orders/index.ts

@@ -0,0 +1,40 @@
+import { Router, Request, Response } from "express";
+import asyncHandler from "express-async-handler";
+
+const router = Router();
+
+/**
+ * @swagger
+ * /orders:
+ *   get:
+ *     summary: Get order home
+ *     description: Returns the order home page.
+ *     responses:
+ *       200:
+ *         description: Order home page
+ */
+router.get(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.send("Order Home");
+  })
+);
+
+/**
+ * @swagger
+ * /orders/history:
+ *   get:
+ *     summary: Get order history
+ *     description: Returns order history.
+ *     responses:
+ *       200:
+ *         description: Order history
+ */
+router.get(
+  "/history",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.send("Order History");
+  })
+);
+
+export = router;

package/src/routers/products/index.ts

@@ -0,0 +1,167 @@
+import { Router, Request, Response } from "express";
+import asyncHandler from "express-async-handler";
+
+const router = Router();
+
+// Array to store products (as a mock database)
+const products = [
+  { id: 1, name: "Product1" },
+  { id: 2, name: "Product2" },
+  { id: 3, name: "Product3" },
+  { id: 4, name: "Product4" },
+  { id: 5, name: "Product5" },
+  { id: 6, name: "Product6" },
+  { id: 7, name: "Product7" },
+  { id: 8, name: "Product8" },
+  { id: 9, name: "Product9" },
+];
+
+// CRUD Routes
+
+/**
+ * @swagger
+ * /products:
+ *   post:
+ *     summary: Create an product
+ *     description: Create a new product.
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               name:
+ *                 type: string
+ *               description:
+ *                 type: string
+ *     responses:
+ *       201:
+ *         description: product created
+ */
+router.post(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    const product = { id: products.length + 1, name: req.body.name };
+    products.push(product);
+    res.status(201).json(product);
+  })
+);
+
+/**
+ * @swagger
+ * /products:
+ *   get:
+ *     summary: Get all products
+ *     responses:
+ *       200:
+ *         description: A list of products
+ */
+router.get(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.json(products);
+  })
+);
+
+/**
+ * @swagger
+ * /products/{id}:
+ *   get:
+ *     summary: Get an product by ID
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: The ID of the product
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       200:
+ *         description: An product object
+ *       404:
+ *         description: product not found
+ */
+router.get(
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const product = products.find((i) => i.id === parseInt(req.params.id));
+    if (!product) res.status(404).send("product not found");
+    else res.json(product);
+  })
+);
+
+/**
+ * @swagger
+ * /products/{id}:
+ *   put:
+ *     summary: Update an product
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: The ID of the product to update
+ *         schema:
+ *           type: integer
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             properties:
+ *               name:
+ *                 type: string
+ *               description:
+ *                 type: string
+ *     responses:
+ *       200:
+ *         description: product updated
+ *       404:
+ *         description: product not found
+ */
+router.put(
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const product = products.find((i) => i.id === parseInt(req.params.id));
+    if (!product) res.status(404).send("product not found");
+    else {
+      Object.assign(product, { id: req.body.id, name: req.body.name });
+      res.json(product);
+    }
+  })
+);
+
+/**
+ * @swagger
+ * /products/{id}:
+ *   delete:
+ *     summary: Delete an product
+ *     parameters:
+ *       - name: id
+ *         in: path
+ *         required: true
+ *         description: The ID of the product to delete
+ *         schema:
+ *           type: integer
+ *     responses:
+ *       204:
+ *         description: product deleted
+ *       404:
+ *         description: product not found
+ */
+router.delete(
+  "/:id",
+  asyncHandler(async (req: Request, res: Response) => {
+    const productIndex = products.findIndex(
+      (i) => i.id === parseInt(req.params.id)
+    );
+    if (productIndex === -1) res.status(404).send("product not found");
+    else {
+      products.splice(productIndex, 1);
+      res.status(204).send();
+    }
+  })
+);
+
+export = router;

package/src/routers/users/dto/user.dto.ts

@@ -0,0 +1,9 @@
+import { z } from "zod";
+
+export const CreateUserDto = z.object({
+  username: z.string().min(3),
+  email: z.string().email(),
+  password: z.string().min(6),
+});
+
+export type CreateUser = z.infer<typeof CreateUserDto>;

package/src/routers/users/index.ts

@@ -0,0 +1,81 @@
+import { Router, Request, Response } from "express";
+import asyncHandler from "express-async-handler";
+import UserController from "./user.controller";
+
+const router = Router();
+const userController = new UserController();
+
+/**
+ * @swagger
+ * /users:
+ *   post:
+ *     summary: Create a user
+ *     description: Create a new user.
+ *     requestBody:
+ *       required: true
+ *       content:
+ *         application/json:
+ *           schema:
+ *             type: object
+ *             required:
+ *               - username
+ *               - email
+ *               - password
+ *             properties:
+ *               username:
+ *                 type: string
+ *               email:
+ *                 type: string
+ *               password:
+ *                 type: string
+ *             example: # Sample object
+ *               username: JessicaSmith
+ *               email: william.howard.taft@my-own-personal-domain.com
+ *               password: password123
+ *     responses:
+ *       201:
+ *         description: product created
+ */
+router.post(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    const result = await userController.createUser(req.body);
+    res.status(201).json({ message: result });
+  })
+);
+
+/**
+ * @swagger
+ * /user:
+ *   get:
+ *     summary: Get user home
+ *     description: Returns the user home page.
+ *     responses:
+ *       200:
+ *         description: User home page
+ */
+router.get(
+  "/",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.send("User Home");
+  })
+);
+
+/**
+ * @swagger
+ * /user/profile:
+ *   get:
+ *     summary: Get user profile
+ *     description: Returns user profile information.
+ *     responses:
+ *       200:
+ *         description: User profile information
+ */
+router.get(
+  "/profile",
+  asyncHandler(async (req: Request, res: Response) => {
+    res.send("User Profile");
+  })
+);
+
+export = router;

package/src/routers/users/user.controller.ts

@@ -0,0 +1,33 @@
+import { Validate, ZodInput } from "ts-zod-decorators";
+import { CreateUserDto, CreateUser } from "./dto/user.dto";
+import { onError, rateLimit, throttle } from "utils-decorators";
+
+function exceedHandler() {
+  throw new Error("Too much call in allowed window");
+}
+
+function errorHandler(e: Error): void {
+  console.error(e);
+}
+
+export default class UserController {
+  //constructor(private readonly userService: UserService) { }
+
+  // Throttle the createUser method to 1 request per 200 milliseconds
+  @rateLimit({
+    timeSpanMs: 60000,
+    allowedCalls: 300,
+    exceedHandler,
+  })
+  @onError({
+    func: errorHandler,
+  })
+  @Validate
+  public async createUser(
+    @ZodInput(CreateUserDto) data: CreateUser
+  ): Promise<string> {
+    // Here you can include logic to save user to database
+    console.log("Creating user:", data);
+    return "User created successfully";
+  }
+}

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "commonjs",
+    "outDir": "./dist",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true
+  },
+  "include": ["src/**/*.ts", "src/**/*.js"],
+  "exclude": ["node_modules"]
+}