plutin 1.1.3 → 1.2.1

package/dist/index.js

@@ -420,9 +420,6 @@ var require_cli_options = __commonJS({
   }
 });
 
-// src/core/http/base-controller.ts
-import "reflect-metadata";
-
 // src/core/decorators/dependency-container.ts
 import "reflect-metadata";
 var DependencyContainer = class {
@@ -584,6 +581,7 @@ var ValidationError = class extends Error {
 };
 
 // src/core/http/base-controller.ts
+import "reflect-metadata";
 var BaseController = class {
   static {
     __name(this, "BaseController");
@@ -894,13 +892,164 @@ __name(getTakeAndSkip, "getTakeAndSkip");
 import cors from "cors";
 import express from "express";
 
+// src/infra/adapters/http/response-error-code.ts
+var ErrorResponseCode = /* @__PURE__ */ function(ErrorResponseCode2) {
+  ErrorResponseCode2["NO_CONTENT_BODY"] = "B001";
+  ErrorResponseCode2["NO_CONTENT_ERROR"] = "B002";
+  return ErrorResponseCode2;
+}({});
+
 // src/infra/adapters/http/validate-controller-metadata.ts
 import "reflect-metadata";
+function validateControllerMetadata(controller) {
+  const metadata = Reflect.getMetadata("route", controller.constructor);
+  if (!metadata) {
+    throw new Error(`Controller ${controller.constructor.name} not have metadata. Need to add decorator.`);
+  }
+  return {
+    metadata
+  };
+}
+__name(validateControllerMetadata, "validateControllerMetadata");
+
+// src/infra/adapters/http/express-adapter.ts
+var ExpressAdapter = class {
+  static {
+    __name(this, "ExpressAdapter");
+  }
+  env;
+  instance;
+  server;
+  constructor(env) {
+    this.env = env;
+    this.instance = express();
+    this.instance.use(cors());
+    this.instance.use(express.json({
+      limit: "10mb"
+    }));
+    this.instance.use(express.urlencoded({
+      limit: "10mb",
+      extended: false
+    }));
+    this.instance.disable("x-powered-by");
+  }
+  registerRoute(controllerClass) {
+    const { metadata } = validateControllerMetadata(controllerClass);
+    this.instance[metadata.method](metadata.path, async (request, response) => {
+      const requestData = {
+        body: request.body,
+        params: request.params,
+        headers: request.headers,
+        query: request.query
+      };
+      try {
+        const output = await controllerClass.execute(requestData);
+        response.status(output.code || 204).json(output.data || {
+          code: ErrorResponseCode.NO_CONTENT_BODY
+        });
+      } catch (err) {
+        const error = await controllerClass.failure(err, {
+          env: this.env.ENVIRONMENT,
+          request: {
+            body: requestData.body,
+            headers: requestData.headers,
+            params: request.params,
+            query: requestData.query,
+            url: metadata.path,
+            method: metadata.method
+          }
+        });
+        response.status(error.code).json(error.data || {
+          error: ErrorResponseCode.NO_CONTENT_ERROR
+        });
+      }
+    });
+  }
+  async startServer(port) {
+    return new Promise((resolve) => {
+      this.server = this.instance.listen(port, () => {
+        console.log(`\u{1F680} Server is running on PORT ${port}`);
+        resolve();
+      });
+    });
+  }
+  async closeServer() {
+    return new Promise((resolve, reject) => {
+      if (this.server) {
+        this.server.close((err) => {
+          if (err)
+            return reject(err);
+          resolve();
+        });
+      } else {
+        resolve();
+      }
+    });
+  }
+};
 
 // src/infra/adapters/http/fastify-adapter.ts
 import cors2 from "@fastify/cors";
 import fastify from "fastify";
 import qs from "qs";
+var FastifyAdapter = class {
+  static {
+    __name(this, "FastifyAdapter");
+  }
+  env;
+  instance;
+  constructor(env) {
+    this.env = env;
+    this.instance = fastify({
+      bodyLimit: 10 * 1024 * 1024,
+      querystringParser: (str) => qs.parse(str)
+    });
+    this.instance.register(cors2);
+  }
+  registerRoute(controllerClass) {
+    const { metadata } = validateControllerMetadata(controllerClass);
+    this.instance[metadata.method](metadata.path, async (request, reply) => {
+      const requestData = {
+        body: request.body,
+        params: request.params,
+        headers: request.headers,
+        query: request.query
+      };
+      try {
+        const output = await controllerClass.execute(requestData);
+        return reply.status(output.code || 200).send(output.data || {
+          code: ErrorResponseCode.NO_CONTENT_BODY
+        });
+      } catch (err) {
+        const error = await controllerClass.failure(err, {
+          env: this.env.ENVIRONMENT,
+          request: {
+            body: requestData.body,
+            headers: requestData.headers,
+            params: request.params,
+            query: requestData.query,
+            url: metadata.path,
+            method: metadata.method
+          }
+        });
+        return reply.status(error.code || 200).send(error.data || {
+          code: ErrorResponseCode.NO_CONTENT_ERROR
+        });
+      }
+    });
+  }
+  async startServer(port) {
+    await this.instance.listen({
+      port
+    });
+    if (this.env.NODE_ENV !== "test") {
+      console.log(`\u{1F680}  Server is running on PORT ${port}`);
+    }
+  }
+  async closeServer() {
+    await this.instance.close();
+  }
+};
 
 // src/infra/adapters/notifications/discord.ts
 import { MessageBuilder, Webhook } from "discord-webhook-node";
@@ -1040,6 +1189,34 @@ SentryNotifier = _ts_decorate2([
   ])
 ], SentryNotifier);
 
+// src/infra/adapters/notifications/notification-factory.ts
+var NotificationFactory = class {
+  static {
+    __name(this, "NotificationFactory");
+  }
+  static define(env, definitions) {
+    const defaultDefinition = {
+      test: this.defineProvider(definitions?.local ?? "console"),
+      development: this.defineProvider(definitions?.local ?? "console"),
+      staging: this.defineProvider(definitions?.local ?? "discord"),
+      production: this.defineProvider(definitions?.local ?? "sentry")
+    };
+    return defaultDefinition[env];
+  }
+  static defineProvider(provider) {
+    switch (provider) {
+      case "console":
+        return NotificationErrorInMemory;
+      case "discord":
+        return DiscordNotifier;
+      case "sentry":
+        return SentryNotifier;
+      default:
+        return NotificationErrorInMemory;
+    }
+  }
+};
+
 // src/infra/adapters/validators/zod/zod-map-error.ts
 var ZodMapError = class {
   static {
@@ -1159,13 +1336,15 @@ function zodValidator(schema) {
 }
 __name(zodValidator, "zodValidator");
 
+// src/infra/env/index.ts
+import { z } from "zod";
+
 // node_modules/dotenv/config.js
 (function() {
   require_main().config(Object.assign({}, require_env_options(), require_cli_options()(process.argv)));
 })();
 
 // src/infra/env/index.ts
-import { z } from "zod";
 var baseEnvSchema = z.object({
   NODE_ENV: z.enum([
     "test",
@@ -1190,8 +1369,11 @@ export {
   DependencyContainer,
   DiscordNotifier,
   Entity,
+  ExpressAdapter,
+  FastifyAdapter,
   Inject,
   NotificationErrorInMemory,
+  NotificationFactory,
   SentryNotifier,
   UniqueEntityId,
   ValueObject,