@arkyn/server 3.0.1-beta.21 → 3.0.1-beta.22

package/src/http/successResponses/success.ts

@@ -1,64 +0,0 @@
-/**
- * Represents a successful HTTP response with a status code of 200 (OK).
- * This class is used to standardize the structure of a "Success" response,
- * including the response body, headers, status, and status text.
- *
- * @template T - The type of the response body.
- */
-
-class Success<T> {
-  body: T;
-  headers: ResponseInit["headers"];
-  status: number;
-  statusText: string;
-
-  /**
-   * Creates an instance of the `Success` class.
-   *
-   * @param body - The response body to be included in the HTTP response.
-   * @param init - Optional initialization object for customizing headers, status, and status text.
-   */
-
-  constructor(body: T, init?: ResponseInit) {
-    this.body = body;
-    this.headers = init?.headers || {};
-    this.status = init?.status || 200;
-    this.statusText = init?.statusText ?? "OK";
-  }
-
-  /**
-   * Converts the `Success` instance into a `Response` object with a JSON body.
-   * This method ensures the response has the appropriate headers, status, and status text.
-   *
-   * @returns A `Response` object with the serialized JSON body and response metadata.
-   */
-
-  toResponse(): Response {
-    const responseInit: ResponseInit = {
-      headers: { "Content-Type": "application/json", ...this.headers },
-      status: this.status,
-      statusText: this.statusText,
-    };
-
-    return new Response(JSON.stringify(this.body), responseInit);
-  }
-
-  /**
-   * Converts the `Success` instance into a `Response` object using the `Response.json` method.
-   * This method is an alternative to `toResponse` for generating JSON responses.
-   *
-   * @returns A `Response` object with the JSON body and response metadata.
-   */
-
-  toJson(): Response {
-    const responseInit: ResponseInit = {
-      headers: this.headers,
-      status: this.status,
-      statusText: this.statusText,
-    };
-
-    return Response.json(this.body, responseInit);
-  }
-}
-
-export { Success };

package/src/http/successResponses/updated.ts

@@ -1,64 +0,0 @@
-/**
- * Represents a successful HTTP response with a status code of 200 (OK) or other custom status codes.
- * This class is used to standardize the structure of an "Updated" response,
- * including the response body, headers, status, and status text.
- *
- * @template T - The type of the response body.
- */
-
-class Updated<T> {
-  body: T;
-  headers: ResponseInit["headers"];
-  status: number;
-  statusText: string;
-
-  /**
-   * Creates an instance of the `Updated` class.
-   *
-   * @param body - The response body to be included in the HTTP response.
-   * @param init - Optional initialization object for customizing headers, status, and status text.
-   */
-
-  constructor(body: T, init?: ResponseInit) {
-    this.body = body;
-    this.headers = init?.headers || {};
-    this.status = init?.status || 200;
-    this.statusText = init?.statusText || "Resource updated successfully";
-  }
-
-  /**
-   * Converts the `Updated` instance into a `Response` object with a JSON body.
-   * This method ensures the response has the appropriate headers, status, and status text.
-   *
-   * @returns A `Response` object with the serialized JSON body and response metadata.
-   */
-
-  toResponse(): Response {
-    const responseInit: ResponseInit = {
-      headers: { "Content-Type": "application/json", ...this.headers },
-      status: this.status,
-      statusText: this.statusText,
-    };
-
-    return new Response(JSON.stringify(this.body), responseInit);
-  }
-
-  /**
-   * Converts the `Updated` instance into a `Response` object using the `Response.json` method.
-   * This method is an alternative to `toResponse` for generating JSON responses.
-   *
-   * @returns A `Response` object with the JSON body and response metadata.
-   */
-
-  toJson(): Response {
-    const responseInit: ResponseInit = {
-      headers: this.headers,
-      status: this.status,
-      statusText: this.statusText,
-    };
-
-    return Response.json(this.body, responseInit);
-  }
-}
-
-export { Updated };

package/src/index.ts

@@ -1,31 +0,0 @@
-// config
-export { ApiInstance } from "./config/apiInstance";
-export { ArkynLogInstance } from "./config/arkynLogInstance";
-
-// http bad responses
-export { BadGateway } from "./http/badResponses/badGateway";
-export { BadRequest } from "./http/badResponses/badRequest";
-export { Conflict } from "./http/badResponses/conflict";
-export { Forbidden } from "./http/badResponses/forbidden";
-export { NotFound } from "./http/badResponses/notFound";
-export { NotImplemented } from "./http/badResponses/notImplemented";
-export { ServerError } from "./http/badResponses/serverError";
-export { Unauthorized } from "./http/badResponses/unauthorized";
-export { UnprocessableEntity } from "./http/badResponses/unprocessableEntity";
-
-// http success responses
-export { Created } from "./http/successResponses/created";
-export { Found } from "./http/successResponses/found";
-export { NoContent } from "./http/successResponses/noContent";
-export { Success } from "./http/successResponses/success";
-export { Updated } from "./http/successResponses/updated";
-
-// services
-export { decodeErrorMessageFromRequest } from "./services/decodeErrorMessageFromRequest";
-export { decodeRequestBody } from "./services/decodeRequestBody";
-export { errorHandler } from "./services/errorHandler";
-export { formParse } from "./services/formParse";
-export { getCaller } from "./services/getCaller";
-export { getScopedParams } from "./services/getScopedParams";
-export { httpDebug } from "./services/httpDebug";
-export { SchemaValidator } from "./services/schemaValidator";

package/src/mapper/arkynLogRequestMapper.ts

@@ -1,73 +0,0 @@
-type InputProps = {
-  status: number;
-  url: string;
-  method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-  requestHeaders: HeadersInit;
-  responseHeaders: HeadersInit;
-  requestBody: any;
-  elapsedTime: number;
-  responseBody: any;
-  queryParams: URLSearchParams;
-};
-
-type OutputProps = {
-  rawUrl: string;
-  status: number;
-  method: "GET" | "POST" | "PUT" | "DELETE" | "PATCH";
-  token: string | null;
-  elapsedTime: number;
-  requestHeaders: Record<string, string>;
-  requestBody: Record<string, string>;
-  queryParams: Record<string, string>;
-  responseHeaders: Record<string, string>;
-  responseBody: any;
-};
-
-class ArkynLogRequestMapper {
-  private static mapHeaders(headers: HeadersInit): Record<string, string> {
-    if (headers instanceof Headers) {
-      return Object.fromEntries(headers.entries());
-    } else if (typeof headers === "object") {
-      return Object.entries(headers).reduce((acc, [key, value]) => {
-        if (typeof value === "string") {
-          acc[key] = value;
-        } else if (Array.isArray(value)) {
-          acc[key] = value.join(", ");
-        } else {
-          acc[key] = JSON.stringify(value);
-        }
-        return acc;
-      }, {} as Record<string, string>);
-    }
-    return {};
-  }
-
-  private static mapQueryParams(
-    queryParams: URLSearchParams
-  ): Record<string, string> {
-    const params: Record<string, string> = {};
-
-    queryParams.forEach((value, key) => {
-      params[key] = value;
-    });
-
-    return params;
-  }
-
-  static handle(props: InputProps): OutputProps {
-    return {
-      rawUrl: props.url,
-      status: props.status,
-      method: props.method,
-      token: null,
-      elapsedTime: props.elapsedTime,
-      requestHeaders: this.mapHeaders(props.requestHeaders),
-      requestBody: props.requestBody || null,
-      queryParams: this.mapQueryParams(props.queryParams),
-      responseHeaders: this.mapHeaders(props.responseHeaders),
-      responseBody: props.responseBody || null,
-    };
-  }
-}
-
-export { ArkynLogRequestMapper };

package/src/services/decodeErrorMessageFromRequest.ts

@@ -1,36 +0,0 @@
-/**
- * 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,43 +0,0 @@
-import { BadRequest } from "../http/badResponses/badRequest";
-
-type DecodeRequestBodyFunction = (request: Request) => Promise<any>;
-
-/**
- * Decodes the body of an incoming request into a JavaScript object.
- *
- * This function attempts to parse the request body in the following order:
- * 1. Tries to parse the body as JSON.
- * 2. If JSON parsing fails, attempts to parse the body as URL-encoded form data.
- * 3. If both parsing attempts fail, logs the errors and returns an empty object.
- *
- * @param req - The incoming request object containing the body to decode.
- * @returns A promise that resolves to the decoded data as a JavaScript object.
- *
- * @throws Logs errors to the console if the request body cannot be read or parsed.
- */
-
-const decodeRequestBody: DecodeRequestBodyFunction = async (req) => {
-  let data: any;
-
-  const arrayBuffer = await req.arrayBuffer();
-  const text = new TextDecoder().decode(arrayBuffer);
-
-  try {
-    data = JSON.parse(text);
-  } catch (jsonError) {
-    try {
-      if (text.includes("=")) {
-        const formData = new URLSearchParams(text);
-        data = Object.fromEntries(formData.entries());
-      } else {
-        throw new BadRequest("Invalid URLSearchParams format");
-      }
-    } catch (formDataError) {
-      throw new BadRequest("Failed to extract data from request");
-    }
-  }
-
-  return data;
-};
-
-export { decodeRequestBody };

package/src/services/errorHandler.ts

@@ -1,99 +0,0 @@
-import { BadGateway } from "../http/badResponses/badGateway";
-import { BadRequest } from "../http/badResponses/badRequest";
-import { Conflict } from "../http/badResponses/conflict";
-import { Forbidden } from "../http/badResponses/forbidden";
-import { NotFound } from "../http/badResponses/notFound";
-import { NotImplemented } from "../http/badResponses/notImplemented";
-import { ServerError } from "../http/badResponses/serverError";
-import { Unauthorized } from "../http/badResponses/unauthorized";
-import { UnprocessableEntity } from "../http/badResponses/unprocessableEntity";
-
-import { Created } from "../http/successResponses/created";
-import { Found } from "../http/successResponses/found";
-import { NoContent } from "../http/successResponses/noContent";
-import { Success } from "../http/successResponses/success";
-import { Updated } from "../http/successResponses/updated";
-
-/**
- * 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;
-    case error instanceof Found:
-      return error.toResponse();
-    case error instanceof Created:
-      return error.toResponse();
-    case error instanceof Updated:
-      return error.toResponse();
-    case error instanceof Success:
-      return error.toResponse();
-    case error instanceof NoContent:
-      return error.toResponse();
-  }
-
-  switch (true) {
-    case error instanceof BadGateway:
-      return error.toResponse();
-    case error instanceof BadRequest:
-      return error.toResponse();
-    case error instanceof Conflict:
-      return error.toResponse();
-    case error instanceof Forbidden:
-      return error.toResponse();
-    case error instanceof NotFound:
-      return error.toResponse();
-    case error instanceof NotImplemented:
-      return error.toResponse();
-    case error instanceof ServerError:
-      return error.toResponse();
-    case error instanceof Unauthorized:
-      return error.toResponse();
-    case error instanceof UnprocessableEntity:
-      return error.toResponse();
-  }
-
-  return new ServerError("Server error", error).toResponse();
-}
-
-export { errorHandler };

package/src/services/formParse.ts

@@ -1,86 +0,0 @@
-import type { ZodType } from "zod";
-
-type SuccessResponse<T extends FormParseProps> = {
-  success: true;
-  data: T[1] extends ZodType<infer U> ? U : never;
-};
-
-type ErrorResponse = {
-  success: false;
-  fields: { [x: string]: string };
-  fieldErrors: { [x: string]: string };
-};
-
-type FormParseProps = [formData: { [k: string]: any }, schema: ZodType];
-
-type FormParseReturnType<T extends FormParseProps> =
-  | SuccessResponse<T>
-  | ErrorResponse;
-
-/**
- * Parses form data using a Zod schema and returns the result.
- *
- * @template T - A type that extends `FormParseProps`.
- *
- * @param {T} param0 - An array containing the form data and the Zod schema.
- * @param {T[0]} param0[0] - The form data to be validated.
- * @param {T[1]} param0[1] - The Zod schema used for validation.
- *
- * @returns {FormParseReturnType<T>} An object containing the validation result.
- * - If validation fails, it includes:
- *   - `success`: A boolean indicating the validation status (false).
- *   - `fieldErrors`: An object mapping field names to their respective error messages.
- *   - `fields`: The original form data.
- * - If validation succeeds, it includes:
- *   - `success`: A boolean indicating the validation status (true).
- *   - `data`: The parsed and validated data.
- *
- * @example
- * ```typescript
- * import { z } from "zod";
- *
- * const schema = z.object({
- *   name: z.string().min(1, "Name is required"),
- *   age: z.number().min(18, "Must be at least 18"),
- * });
- *
- * const formData = { name: "", age: 17 };
- *
- * const result = formParse([formData, schema]);
- *
- * if (!result.success) {
- *   console.log(result.fieldErrors); // { name: "Name is required", age: "Must be at least 18" }
- * } else {
- *   console.log(result.data); // Parsed data
- * }
- * ```
- */
-
-function formParse<T extends FormParseProps>([
-  formData,
-  schema,
-]: T): FormParseReturnType<T> {
-  const zodResponse = schema.safeParse(formData);
-
-  if (zodResponse.success === false) {
-    const errorsObject = Object.fromEntries(
-      zodResponse.error.issues.map((item) => {
-        console.log(item);
-        return [item.path.join("."), item.message];
-      })
-    );
-
-    return {
-      success: zodResponse.success,
-      fieldErrors: errorsObject,
-      fields: formData,
-    };
-  } else {
-    return {
-      success: zodResponse.success,
-      data: zodResponse.data as T[1] extends ZodType<infer U> ? U : never,
-    };
-  }
-}
-
-export { formParse };

package/src/services/getCaller.ts

@@ -1,82 +0,0 @@
-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() {
-  const projectRoot = process.cwd();
-
-  const err = new Error();
-  const stack = err.stack || "";
-  const stackLines = stack.split("\n").map((line) => line.trim());
-
-  // The first line is the error message
-  // The second line is this function (getCaller)
-  // The third line should be the direct caller
-  // We start from 2 because indexes are zero-based
-  let callerIndex = 2;
-
-  // Ignore internal or infrastructure lines if necessary
-  while (
-    callerIndex < stackLines.length &&
-    (stackLines[callerIndex].includes("node:internal") ||
-      stackLines[callerIndex].includes("/node_modules/"))
-  ) {
-    callerIndex++;
-  }
-
-  const callerLine = stackLines[callerIndex] || "";
-
-  let functionName = "Unknown function";
-  let callerInfo = "Unknown caller";
-
-  // Default for named functions: "at functionName (file:line:column)"
-  const namedFunctionMatch = callerLine.match(/at\s+([^(\s]+)\s+\(([^)]+)\)/);
-  if (namedFunctionMatch) {
-    functionName = namedFunctionMatch[1];
-    callerInfo = namedFunctionMatch[2];
-  }
-  // Default for anonymous functions or methods: "at file:line:column"
-  else {
-    const anonymousFunctionMatch = callerLine.match(/at\s+(.+)/);
-    if (anonymousFunctionMatch) {
-      callerInfo = anonymousFunctionMatch[1];
-
-      // Tenta extrair nome da função de padrões como Object.method ou Class.method
-      const objectMethodMatch = callerInfo.match(/at\s+([^(\s]+)\s+/);
-      if (objectMethodMatch && objectMethodMatch[1] !== "new") {
-        functionName = objectMethodMatch[1];
-      }
-    }
-  }
-
-  // Handles file paths
-  if (callerInfo.includes("(")) {
-    callerInfo = callerInfo.substring(
-      callerInfo.indexOf("(") + 1,
-      callerInfo.lastIndexOf(")")
-    );
-  }
-
-  // Remove the line:column part of the file path
-  callerInfo = callerInfo.split(":").slice(0, -2).join(":");
-
-  // Make the path relative to the project
-  try {
-    callerInfo = path.relative(projectRoot, callerInfo);
-  } catch (e) {
-    // If it fails to relativize, use the original path
-  }
-
-  return { functionName, callerInfo };
-}
-
-export { getCaller };

package/src/services/getScopedParams.ts

@@ -1,43 +0,0 @@
-type GetScopedParamsFunction = (
-  request: Request,
-  scope?: string
-) => URLSearchParams;
-/**
- * Extracts and returns scoped query parameters from a request URL.
- *
- * @param request - The incoming request object containing the URL.
- * @param scope - An optional string representing the scope prefix for filtering query parameters.
- *                If no scope is provided, all query parameters are returned.
- *
- * @returns A `URLSearchParams` object containing the scoped query parameters.
- *          If a scope is provided, only parameters with keys starting with the scope
- *          (e.g., `scope:key`) are included, and the scope prefix is removed from the keys.
- *          If no scope is provided, all query parameters are returned as-is.
- *
- * @example
- * // Example 1: No scope provided
- * const request = { url: "https://example.com?key1=value1&key2=value2" };
- * const params = getScopedParams(request);
- * console.log(params.toString()); // Output: "key1=value1&key2=value2"
- *
- * @example
- * // Example 2: Scope provided
- * const request = { url: "https://example.com?scope:key1=value1&scope:key2=value2&key3=value3" };
- * const params = getScopedParams(request, "scope");
- * console.log(params.toString()); // Output: "key1=value1&key2=value2"
- */
-
-const getScopedParams: GetScopedParamsFunction = (request, scope = "") => {
-  const url = new URL(request.url);
-  if (scope === "") return url.searchParams;
-
-  const scopedSearchParams: [string, string][] = Array.from(
-    url.searchParams.entries()
-  )
-    .filter(([key]) => key.startsWith(`${scope}:`))
-    .map(([key, value]) => [key.replace(`${scope}:`, ""), value]);
-
-  return new URLSearchParams(scopedSearchParams);
-};
-
-export { getScopedParams };

package/src/services/httpDebug.ts

@@ -1,61 +0,0 @@
-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" ||
-    process.env?.SHOW_ERRORS_IN_CONSOLE === "true";
-
-  if (isDebugMode) {
-    const reset = "\x1b[0m";
-    const cyan = "\x1b[36m";
-
-    const debugName = `${cyan}[ARKYN-DEBUG]${reset}`;
-    const { callerInfo, functionName } = getCaller();
-
-    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);
-  }
-}
-
-export { httpDebug };