plutin 1.1.3 → 1.2.1

package/dist/index.cjs

@@ -448,8 +448,11 @@ __export(src_exports, {
   DependencyContainer: () => DependencyContainer,
   DiscordNotifier: () => DiscordNotifier,
   Entity: () => Entity,
+  ExpressAdapter: () => ExpressAdapter,
+  FastifyAdapter: () => FastifyAdapter,
   Inject: () => Inject,
   NotificationErrorInMemory: () => NotificationErrorInMemory,
+  NotificationFactory: () => NotificationFactory,
   SentryNotifier: () => SentryNotifier,
   UniqueEntityId: () => UniqueEntityId,
   ValueObject: () => ValueObject,
@@ -460,9 +463,6 @@ __export(src_exports, {
 });
 module.exports = __toCommonJS(src_exports);
 
-// src/core/http/base-controller.ts
-var import_reflect_metadata2 = require("reflect-metadata");
-
 // src/core/decorators/dependency-container.ts
 var import_reflect_metadata = require("reflect-metadata");
 var DependencyContainer = class {
@@ -624,6 +624,7 @@ var ValidationError = class extends Error {
 };
 
 // src/core/http/base-controller.ts
+var import_reflect_metadata2 = require("reflect-metadata");
 var BaseController = class {
   static {
     __name(this, "BaseController");
@@ -934,13 +935,164 @@ __name(getTakeAndSkip, "getTakeAndSkip");
 var import_cors = __toESM(require("cors"), 1);
 var import_express = __toESM(require("express"), 1);
 
+// 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
 var import_reflect_metadata3 = require("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 = (0, import_express.default)();
+    this.instance.use((0, import_cors.default)());
+    this.instance.use(import_express.default.json({
+      limit: "10mb"
+    }));
+    this.instance.use(import_express.default.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
 var import_cors2 = __toESM(require("@fastify/cors"), 1);
 var import_fastify = __toESM(require("fastify"), 1);
 var import_qs = __toESM(require("qs"), 1);
+var FastifyAdapter = class {
+  static {
+    __name(this, "FastifyAdapter");
+  }
+  env;
+  instance;
+  constructor(env) {
+    this.env = env;
+    this.instance = (0, import_fastify.default)({
+      bodyLimit: 10 * 1024 * 1024,
+      querystringParser: (str) => import_qs.default.parse(str)
+    });
+    this.instance.register(import_cors2.default);
+  }
+  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
 var import_discord_webhook_node = require("discord-webhook-node");
@@ -1080,6 +1232,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 {
@@ -1199,13 +1379,15 @@ function zodValidator(schema) {
 }
 __name(zodValidator, "zodValidator");
 
+// src/infra/env/index.ts
+var import_zod = require("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
-var import_zod = require("zod");
 var baseEnvSchema = import_zod.z.object({
   NODE_ENV: import_zod.z.enum([
     "test",
@@ -1231,8 +1413,11 @@ var baseEnvSchema = import_zod.z.object({
   DependencyContainer,
   DiscordNotifier,
   Entity,
+  ExpressAdapter,
+  FastifyAdapter,
   Inject,
   NotificationErrorInMemory,
+  NotificationFactory,
   SentryNotifier,
   UniqueEntityId,
   ValueObject,