@arkyn/server 2.0.1-beta.8 → 2.0.1

package/src/services/__test__/schemaValidator.spec.ts

@@ -0,0 +1,106 @@
+import { z } from "zod";
+import { SchemaValidator } from "../schemaValidator";
+import { httpDebug } from "../httpDebug";
+import { ServerError } from "../../http/badResponses/serverError";
+import { UnprocessableEntity } from "../../http/badResponses/unprocessableEntity";
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("../getCaller", () => ({
+  getCaller: vi.fn(() => ({
+    callerInfo: "mockedCallerInfo",
+    functionName: "mockedFunctionName",
+  })),
+}));
+
+vi.mock("../httpDebug", () => ({
+  httpDebug: vi.fn(),
+}));
+
+describe("SchemaValidator", () => {
+  const schema = z.object({
+    name: z.string().min(1, "Name is required"),
+    age: z.number().min(18, "Must be at least 18"),
+  });
+
+  const validator = new SchemaValidator(schema);
+
+  describe("constructor", () => {
+    it("should initialize with caller info and function name", () => {
+      expect(validator.callerInfo).toBe("mockedCallerInfo");
+      expect(validator.functionName).toBe("mockedFunctionName");
+    });
+  });
+
+  describe("isValid", () => {
+    it("should return true for valid data", () => {
+      const data = { name: "John", age: 25 };
+      expect(validator.isValid(data)).toBe(true);
+    });
+
+    it("should return false for invalid data", () => {
+      const data = { name: "", age: 17 };
+      expect(validator.isValid(data)).toBe(false);
+    });
+  });
+
+  describe("safeValidate", () => {
+    it("should return success for valid data", () => {
+      const data = { name: "John", age: 25 };
+      const result = validator.safeValidate(data);
+      expect(result.success).toBe(true);
+      expect(result.data).toEqual(data);
+    });
+
+    it("should return failure for invalid data", () => {
+      const data = { name: "", age: 17 };
+      const result = validator.safeValidate(data);
+      expect(result.success).toBe(false);
+      if (!result.success) expect(result.error.issues).toHaveLength(2);
+    });
+  });
+
+  describe("validate", () => {
+    it("should return parsed data for valid input", () => {
+      const data = { name: "John", age: 25 };
+      expect(validator.validate(data)).toEqual(data);
+    });
+
+    it("should throw ServerError for invalid input", () => {
+      const data = { name: "", age: 17 };
+      expect(() => validator.validate(data)).toThrow(ServerError);
+    });
+  });
+
+  describe("formValidate", () => {
+    it("should return parsed data for valid input", () => {
+      const data = { name: "John", age: 25 };
+      expect(validator.formValidate(data)).toEqual(data);
+    });
+
+    it("should throw UnprocessableEntity for invalid input", () => {
+      const data = { name: "", age: 17 };
+      expect(() => validator.formValidate(data)).toThrow(UnprocessableEntity);
+    });
+
+    it("should call httpDebug with formParsed data on validation failure", () => {
+      const data = { name: "", age: 17 };
+
+      try {
+        validator.formValidate(data);
+      } catch (error) {
+        // Ignore the error
+      }
+
+      expect(httpDebug).toHaveBeenCalledWith(
+        "UnprocessableEntity",
+        expect.objectContaining({
+          success: false,
+          fieldErrors: {
+            name: "Name is required",
+            age: "Must be at least 18",
+          },
+        })
+      );
+    });
+  });
+});

package/src/services/decodeErrorMessageFromRequest.ts

@@ -0,0 +1,36 @@
+/**
+ * Decodes an error message from a given request data object or response object.
+ *
+ * This function attempts to extract a meaningful error message from the provided
+ * `data` or `response` objects by checking various properties in a specific order.
+ * If no valid error message is found, it returns a default message: "Missing error message".
+ *
+ * @param data - The data object that may contain error information. It can have properties
+ * such as `message`, `error`, or `error.message` that are checked for a string value.
+ * @param response - The response object that may contain a `statusText` property
+ * representing the HTTP status text.
+ * @returns A string representing the decoded error message, or a default message
+ * if no error message is found.
+ */
+
+function decodeErrorMessageFromRequest(data: any, response: Response): string {
+  if (data?.message && typeof data?.message === "string") {
+    return data?.message;
+  }
+
+  if (data?.error && typeof data?.error === "string") {
+    return data?.error;
+  }
+
+  if (data?.error?.message && typeof data?.error?.message === "string") {
+    return data?.error?.message;
+  }
+
+  if (response?.statusText && typeof response?.statusText === "string") {
+    return response?.statusText;
+  }
+
+  return "Missing error message";
+}
+
+export { decodeErrorMessageFromRequest };

package/src/services/decodeRequestBody.ts

@@ -1,4 +1,5 @@
 import type { DecodeRequestBodyFunction } from "@arkyn/types";
+import { BadRequest } from "../http/badResponses/badRequest";
 
 /**
  * Decodes the body of an incoming request into a JavaScript object.
@@ -17,27 +18,22 @@ import type { DecodeRequestBodyFunction } from "@arkyn/types";
 const decodeRequestBody: DecodeRequestBodyFunction = async (req) => {
   let data: any;
 
-  try {
-    const arrayBuffer = await req.arrayBuffer();
-    const text = new TextDecoder().decode(arrayBuffer);
+  const arrayBuffer = await req.arrayBuffer();
+  const text = new TextDecoder().decode(arrayBuffer);
 
+  try {
+    data = JSON.parse(text);
+  } catch (jsonError) {
     try {
-      data = JSON.parse(text);
-    } catch (jsonError) {
-      try {
+      if (text.includes("=")) {
         const formData = new URLSearchParams(text);
         data = Object.fromEntries(formData.entries());
-      } catch (formDataError) {
-        console.error("Failed to extract data from request:", {
-          jsonError,
-          formDataError,
-        });
-        data = {};
+      } else {
+        throw new BadRequest("Invalid URLSearchParams format");
       }
+    } catch (formDataError) {
+      throw new BadRequest("Failed to extract data from request");
     }
-  } catch (error) {
-    console.error("Failed to read request body:", error);
-    data = {};
   }
 
   return data;

package/src/services/errorHandler.ts

@@ -14,7 +14,49 @@ import { NoContent } from "../http/successResponses/noContent";
 import { Success } from "../http/successResponses/success";
 import { Updated } from "../http/successResponses/updated";
 
-function errorHandler(error: any) {
+/**
+ * Handles errors and converts them into appropriate HTTP responses.
+ *
+ * This function takes an error object and determines its type to return
+ * the corresponding HTTP response. It supports both success and error
+ * response types, converting them into a standardized format using the
+ * `toResponse` method when applicable.
+ *
+ * @param error - The error object to handle. It can be an instance of various
+ * HTTP response classes or a generic error.
+ *
+ * @returns The corresponding HTTP response object if the error matches a known
+ * type, or `undefined` if no match is found.
+ *
+ * ### Supported Success Responses:
+ * - `Found`
+ * - `Created`
+ * - `Updated`
+ * - `Success`
+ * - `NoContent`
+ *
+ * ### Supported Error Responses:
+ * - `BadGateway`
+ * - `BadRequest`
+ * - `Conflict`
+ * - `Forbidden`
+ * - `NotFound`
+ * - `NotImplemented`
+ * - `ServerError`
+ * - `Unauthorized`
+ * - `UnprocessableEntity`
+ *
+ * ### Example Usage:
+ * ```typescript
+ * try {
+ *   // Some operation that might throw an error
+ * } catch (error) {
+ *   return errorHandler(error);
+ * }
+ * ```
+ */
+
+function errorHandler(error: any): Response {
   switch (true) {
     case error instanceof Response:
       return error;
@@ -50,6 +92,8 @@ function errorHandler(error: any) {
     case error instanceof UnprocessableEntity:
       return error.toResponse();
   }
+
+  return new ServerError("Server error").toResponse();
 }
 
 export { errorHandler };

package/src/services/formParse.ts

@@ -46,12 +46,11 @@ function formParse<T extends FormParseProps>([
   const zodResponse = schema.safeParse(formData);
 
   if (zodResponse.success === false) {
-    const errorsArray = Object.entries(
-      zodResponse.error.formErrors.fieldErrors
-    );
-
     const errorsObject = Object.fromEntries(
-      errorsArray.map((item) => [item[0], item[1]?.[0] || "Error"])
+      zodResponse.error.errors.map((item) => [
+        item.path.join("."),
+        item.message,
+      ])
     );
 
     return {

package/src/services/getCaller.ts

@@ -1,36 +1,54 @@
 import path from "path";
 
+/**
+ * Retrieves information about the caller of the current function.
+ *
+ * This function analyzes the stack trace to determine the file path and function name
+ * of the caller. It excludes stack trace entries related to the `@arkyn/server` package
+ * and attempts to resolve the file path relative to the project root directory.
+ *
+ * @returns An object containing:
+ * - `functionName`: The name of the function that called the current function, or "Unknown function" if it cannot be determined.
+ * - `callerInfo`: The file path of the caller relative to the project root, or "Unknown caller" if it cannot be determined.
+ */
+
 function getCaller() {
-  // Diretório raiz do projeto
   const projectRoot = process.cwd();
 
-  // Captura a stack trace
   const error = new Error();
   const stackLines = error.stack?.split("\n").map((line) => line.trim()) || [];
 
   let callerInfo = "Unknown caller";
   let functionName = "Unknown function";
 
-  for (const line of stackLines) {
-    if (
-      !line.includes("httpDebug") &&
-      !line.includes("BadGateway") &&
-      !line.includes("BadRequest")
-    ) {
-      // Captura formatos diferentes de stack trace
-      const match = line.match(/at (.+?) \((.+?)\)/) || line.match(/at (.+)/);
-      if (match) {
-        functionName = match[1].split(" ")[0]; // Nome da função
-        let fullPath = match[2] || match[1]; // Caminho absoluto do arquivo
-
-        // Transforma caminho absoluto em relativo ao projeto
-        if (fullPath.startsWith(projectRoot)) {
-          fullPath = path.relative(projectRoot, fullPath);
-        }
-
-        callerInfo = fullPath;
-        break;
+  const relevantLines = stackLines.filter(
+    (line) => !line.includes("@arkyn/server")
+  );
+
+  let foundGetCaller = false;
+  for (const line of relevantLines) {
+    if (!foundGetCaller) {
+      if (line.includes("getCaller")) {
+        foundGetCaller = true;
+      }
+      continue;
+    }
+
+    const match = line.match(/at (.+?) \((.+?)\)/) || line.match(/at (.+)/);
+    if (match) {
+      const rawFuncName = match[1]?.split(" ")[0] || "";
+
+      functionName =
+        rawFuncName && !rawFuncName.includes("/")
+          ? rawFuncName
+          : "Unknown function";
+
+      let fullPath = match[2] || match[1];
+      if (fullPath.startsWith(projectRoot)) {
+        fullPath = path.relative(projectRoot, fullPath);
       }
+      callerInfo = fullPath;
+      break;
     }
   }
 

package/src/services/httpDebug.ts

@@ -1,5 +1,39 @@
+import { InboxFlowInstance } from "../config/inboxFlowInstance";
 import { getCaller } from "../services/getCaller";
 
+/**
+ * Logs debug information to the console when in development mode or when the
+ * `SHOW_ERRORS_IN_CONSOLE` environment variable is set to "true".
+ *
+ * This function provides detailed information about the caller function,
+ * its location, and the provided body and cause, if any.
+ *
+ * @param name - A string representing the name or context of the debug log.
+ * @param body - The main content or data to be logged.
+ * @param cause - (Optional) Additional information or error cause to be logged.
+ *
+ * @remarks
+ * The debug logs are only displayed when the application is running in
+ * development mode (`NODE_ENV === "development"`) or when the
+ * `SHOW_ERRORS_IN_CONSOLE` environment variable is explicitly set to "true".
+ *
+ * The logs include:
+ * - The name of the debug context.
+ * - The caller function name and its location.
+ * - The provided body content.
+ * - The optional cause, if provided.
+ *
+ * @example
+ * ```typescript
+ * httpDebug("FetchUserData", { userId: 123 });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * httpDebug("FetchUserDataError", { userId: 123 }, new Error("User not found"));
+ * ```
+ */
+
 function httpDebug(name: string, body: any, cause?: any) {
   const isDebugMode =
     process.env.NODE_ENV === "development" ||
@@ -12,11 +46,18 @@ function httpDebug(name: string, body: any, cause?: any) {
     const debugName = `${cyan}[ARKYN-DEBUG]${reset}`;
     const { callerInfo, functionName } = getCaller();
 
-    console.log(`${debugName} ${name} initialized`);
-    console.log(`${debugName} Caller Function: ${functionName}`);
-    console.log(`${debugName} Caller Location: ${callerInfo}`);
-    console.log(`${debugName} Body:`, body);
-    if (cause) console.log(`[ARKYN-DEBUG] Cause:`, cause);
+    let consoleData = `${debugName} ${name} initialized\n`;
+    consoleData += `${debugName} Caller Function: ${functionName}\n`;
+    consoleData += `${debugName} Caller Location: ${callerInfo}\n`;
+    consoleData += `${debugName} Body: ${JSON.stringify(body, null, 2)}\n`;
+
+    if (cause) {
+      consoleData += `${debugName} Cause: ${JSON.stringify(cause, null, 2)}\n`;
+    }
+
+    console.log(consoleData);
+    const arkynKeys = InboxFlowInstance.getInboxConfig();
+    if (arkynKeys) console.log(arkynKeys);
   }
 }
 

package/vitest.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from "vite";
+
+export default defineConfig({
+  resolve: { mainFields: ["module"] },
+});

package/dist/http/httpDebug.d.ts

@@ -1,3 +0,0 @@
-declare function httpDebug(name: string, body: any, cause?: any): void;
-export { httpDebug };
-//# sourceMappingURL=httpDebug.d.ts.map

package/dist/http/httpDebug.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"httpDebug.d.ts","sourceRoot":"","sources":["../../src/http/httpDebug.ts"],"names":[],"mappings":"AAAA,iBAAS,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,EAAE,GAAG,QAetD;AAED,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/http/httpDebug.js

@@ -1,15 +0,0 @@
-function httpDebug(name, body, cause) {
-    const isDebugMode = process.env.NODE_ENV === "development" ||
-        process.env?.SHOW_ERRORS_IN_CONSOLE === "true";
-    if (isDebugMode) {
-        const reset = "\x1b[0m";
-        const cyan = "\x1b[36m";
-        const pathname = new URL(import.meta.url).pathname;
-        console.log(`${cyan}[ARKYN-DEBUG]${reset} ${name} initialized`);
-        console.log(`${cyan}[ARKYN-DEBUG]${reset} Pathname:`, pathname);
-        console.log(`${cyan}[ARKYN-DEBUG]${reset} Body:`, body);
-        if (cause)
-            console.log(`[ARKYN-DEBUG] Cause:`, cause);
-    }
-}
-export { httpDebug };