@arkyn/server 2.0.1-beta.0 → 2.0.1-beta.10

package/src/index.ts

@@ -1,23 +1,24 @@
-// http bad responses
-export { BadRequestError } from "./httpBadResponses/badRequest";
-export { ConflictError } from "./httpBadResponses/conflict";
-export { ForbiddenError } from "./httpBadResponses/forbidden";
-export { NotFoundError } from "./httpBadResponses/notFound";
-export { ServerError } from "./httpBadResponses/serverError";
-export { UnauthorizedError } from "./httpBadResponses/unauthorized";
-export { UnprocessableEntityError } from "./httpBadResponses/unprocessableEntity";
+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 responses
-export { Created } from "./httpResponses/created";
-export { NoContent } from "./httpResponses/noContent";
-export { Success } from "./httpResponses/success";
-export { Updated } from "./httpResponses/updated";
+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";
 
-// helpers
-export { globalErrorHandler } from "./helpers/globalErrorHandler";
-
-// services
-export { extractJsonFromRequest } from "./services/extractJsonFromRequest";
+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 { sendFileToS3 } from "./services/sendFileToS3";
+export { SchemaValidator } from "./services/schemaValidator";

package/src/services/decodeRequestBody.ts

@@ -0,0 +1,46 @@
+import type { DecodeRequestBodyFunction } from "@arkyn/types";
+
+/**
+ * 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;
+
+  try {
+    const arrayBuffer = await req.arrayBuffer();
+    const text = new TextDecoder().decode(arrayBuffer);
+
+    try {
+      data = JSON.parse(text);
+    } catch (jsonError) {
+      try {
+        const formData = new URLSearchParams(text);
+        data = Object.fromEntries(formData.entries());
+      } catch (formDataError) {
+        console.error("Failed to extract data from request:", {
+          jsonError,
+          formDataError,
+        });
+        data = {};
+      }
+    }
+  } catch (error) {
+    console.error("Failed to read request body:", error);
+    data = {};
+  }
+
+  return data;
+};
+
+export { decodeRequestBody };

package/src/services/errorHandler.ts

@@ -0,0 +1,55 @@
+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";
+
+function errorHandler(error: any) {
+  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();
+  }
+}
+
+export { errorHandler };

package/src/services/formParse.ts

@@ -1,6 +1,45 @@
 import type { FormParseProps, FormParseReturnType } from "@arkyn/types";
 
-export function formParse<T extends FormParseProps>([
+/**
+ * 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> {
@@ -24,3 +63,5 @@ export function formParse<T extends FormParseProps>([
     return { success: zodResponse.success, data: zodResponse.data };
   }
 }
+
+export { formParse };

package/src/services/getCaller.ts

@@ -0,0 +1,37 @@
+import path from "path";
+
+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) {
+    // Ignora chamadas dentro de @arkyn/server
+    if (!line.includes("@arkyn/server")) {
+      // Captura diferentes formatos 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;
+      }
+    }
+  }
+
+  return { functionName, callerInfo };
+}
+
+export { getCaller };

package/src/services/getScopedParams.ts

@@ -1,4 +1,31 @@
-function getScopedParams(request: Request, scope: string = "") {
+import type { GetScopedParamsFunction } from "@arkyn/types";
+
+/**
+ * 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;
 
@@ -9,6 +36,6 @@ function getScopedParams(request: Request, scope: string = "") {
     .map(([key, value]) => [key.replace(`${scope}:`, ""), value]);
 
   return new URLSearchParams(scopedSearchParams);
-}
+};
 
 export { getScopedParams };

package/src/services/httpDebug.ts

@@ -0,0 +1,23 @@
+import { getCaller } from "../services/getCaller";
+
+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();
+
+    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);
+  }
+}
+
+export { httpDebug };

package/src/services/schemaValidator.ts

@@ -0,0 +1,66 @@
+import { Schema, z } from "zod";
+
+import { ServerError } from "../http/badResponses/serverError";
+import { UnprocessableEntity } from "../http/badResponses/unprocessableEntity";
+import { formParse } from "./formParse";
+import { getCaller } from "./getCaller";
+import { httpDebug } from "./httpDebug";
+
+function formatErrorMessage(error: z.ZodError) {
+  const title = "Error validating:";
+  const lines = error.issues.map(
+    ({ path, message }) => `-> ${path.join(".")}: ${message}`
+  );
+
+  return [title, ...lines].join("\n");
+}
+
+class SchemaValidator<T extends Schema> {
+  functionName: string;
+  callerInfo: string;
+
+  constructor(readonly schema: T) {
+    const { callerInfo, functionName } = getCaller();
+    this.callerInfo = callerInfo;
+    this.functionName = functionName;
+  }
+
+  isValid(data: any): boolean {
+    return this.schema.safeParse(data).success;
+  }
+
+  safeValidate(data: any): z.SafeParseReturnType<z.infer<T>, z.infer<T>> {
+    return this.schema.safeParse(data);
+  }
+
+  validate(data: any): z.infer<T> {
+    try {
+      return this.schema.parse(data);
+    } catch (error: any) {
+      throw new ServerError(formatErrorMessage(error));
+    }
+  }
+
+  formValidate(data: any, message?: string): z.infer<T> {
+    const formParsed = formParse([data, this.schema]);
+
+    if (!formParsed.success) {
+      httpDebug("UnprocessableEntity", formParsed);
+      const firstErrorKey = Object.keys(formParsed.fieldErrors)[0];
+
+      throw new UnprocessableEntity(
+        {
+          fields: formParsed.fields,
+          fieldErrors: formParsed.fieldErrors,
+          data: { scrollTo: firstErrorKey },
+          message,
+        },
+        false
+      );
+    }
+
+    return formParsed.data;
+  }
+}
+
+export { SchemaValidator };

package/src/services/sendFileToS3.ts

@@ -1,62 +1,34 @@
+import { generateId } from "@arkyn/shared";
+import type { AwsConfig, SendFileToS3Function } from "@arkyn/types";
 import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import {
   unstable_composeUploadHandlers as composeUploadHandlers,
   unstable_createFileUploadHandler as createFileUploadHandler,
   unstable_parseMultipartFormData as parseMultipartFormData,
-  type ActionFunctionArgs,
   type NodeOnDiskFile,
 } from "@remix-run/node";
-import { randomUUID } from "crypto";
 import fs from "fs";
 import sharp from "sharp";
-import { BadRequestError } from "../httpBadResponses/badRequest";
+import { BadRequest } from "../http/badResponses/badRequest";
 import { getScopedParams } from "./getScopedParams";
 
-type AWSConfig = {
-  AWS_REGION: string;
-  AWS_ACCESS_KEY_ID: string;
-  AWS_SECRET_ACCESS_KEY: string;
-  AWS_S3_BUCKET: string;
-};
-
-type Config = {
-  maxPartSize?: number;
-  fileName?: string;
-};
-
-async function s3_upload(
+async function s3Upload(
   fileStream: fs.ReadStream,
   contentType: string,
-  awsS3Config: AWSConfig
+  awsConfig: AwsConfig
 ) {
-  const {
-    AWS_ACCESS_KEY_ID,
-    AWS_REGION,
-    AWS_S3_BUCKET,
-    AWS_SECRET_ACCESS_KEY,
-  } = awsS3Config;
-
-  const filePath = fileStream.path;
-  let fileName = "";
-
-  if (typeof filePath === "string") {
-    fileName = filePath.split("/").pop() || "";
-  } else {
-    fileName = randomUUID();
-  }
-
   const uploadParams = {
-    Bucket: AWS_S3_BUCKET,
-    Key: `uploads/${Date.now()}-${fileName.split(" ").join("-")}`,
+    Bucket: awsConfig.AWS_S3_BUCKET,
+    Key: `uploads/${generateId("text", "v4")}`,
     Body: fileStream,
     ContentType: contentType,
   };
 
   const s3Client = new S3Client({
-    region: AWS_REGION,
+    region: awsConfig.AWS_REGION,
     credentials: {
-      accessKeyId: AWS_ACCESS_KEY_ID,
-      secretAccessKey: AWS_SECRET_ACCESS_KEY,
+      accessKeyId: awsConfig.AWS_ACCESS_KEY_ID,
+      secretAccessKey: awsConfig.AWS_SECRET_ACCESS_KEY,
     },
   });
 
@@ -69,20 +41,71 @@ async function s3_upload(
   }
 
   return {
-    location: `https://${AWS_S3_BUCKET}.s3.amazonaws.com/${uploadParams.Key}`,
+    location: `https://${awsConfig.AWS_S3_BUCKET}.s3.amazonaws.com/${uploadParams.Key}`,
   };
 }
 
-async function sendFileToS3(
-  props: ActionFunctionArgs,
-  awsS3Config: AWSConfig,
-  config: Config = {
-    maxPartSize: 5_000_000,
-    fileName: "file",
-  }
-) {
-  const { fileName = "file", maxPartSize = 5_000_000 } = config;
-  const { request } = props;
+/**
+ * Handles file uploads to an AWS S3 bucket. This function processes a file
+ * from a multipart form request, validates and optionally compresses the file,
+ * and uploads it to S3. It supports image-specific operations such as resizing
+ * validation and quality reduction.
+ *
+ * @param request - The HTTP request containing the multipart form data.
+ * @param awsS3Config - Configuration object for AWS S3, including bucket name,
+ * region, and credentials.
+ * @param config - Optional configuration object for file handling.
+ *
+ * @param config.fileName - The name of the form field containing the file. Defaults to `"file"`.
+ * @param config.maxPartSize - The maximum size (in bytes) for each part of the file. Defaults to `5_000_000`.
+ * @param config.reduceImageQuality - The quality percentage for image compression. Defaults to `100`.
+ * @param config.validateImageSize - Whether to validate the image dimensions. Defaults to `false`.
+ * @param config.validateImageMessage - The error message template for invalid image dimensions.
+ * Defaults to `"Invalid dimensions {{width}}px x {{height}}px"`.
+ *
+ * @returns A promise that resolves to an object containing the uploaded file's URL
+ * or an error message if validation fails.
+ *
+ * @throws {BadRequest} If no file is uploaded.
+ *
+ * @example
+ * ```typescript
+ * const awsS3Config = {
+ *   AWS_S3_BUCKET: "my-bucket",
+ *   AWS_REGION: "us-east-1",
+ *   AWS_ACCESS_KEY_ID: "my-access-key",
+ *   AWS_SECRET_ACCESS_KEY: "my-secret-key",
+ * };
+ *
+ * const config = {
+ *   fileName: "upload",
+ *   maxPartSize: 10_000_000,
+ *   reduceImageQuality: 80,
+ *   validateImageSize: true,
+ *   validateImageMessage: "Invalid dimensions {{width}}px x {{height}}px",
+ * };
+ *
+ * const response = await sendFileToS3(request, awsS3Config, config);
+ * if (response.error) {
+ *   console.error(response.error);
+ * } else {
+ *   console.log("File uploaded to:", response.url);
+ * }
+ * ```
+ */
+
+const sendFileToS3: SendFileToS3Function = async (
+  request,
+  awsS3Config,
+  config
+) => {
+  const fileName = config?.fileName || "file";
+  const maxPartSize = config?.maxPartSize || 5_000_000;
+  const reduceImageQuality = config?.reduceImageQuality || 100;
+  const validateImageSize = config?.validateImageSize || false;
+  const validateImageMessage =
+    config?.validateImageMessage ||
+    "Invalid dimensions {{width}}px x {{height}}px";
 
   const uploadHandler = composeUploadHandlers(
     createFileUploadHandler({
@@ -94,18 +117,18 @@ async function sendFileToS3(
   const formData = await parseMultipartFormData(request, uploadHandler);
   const file = formData.get(fileName) as unknown as NodeOnDiskFile;
 
-  if (!file) throw new BadRequestError("No file uploaded");
+  if (!file) throw new BadRequest("No file uploaded");
 
   const filterParams = getScopedParams(request);
   const width = filterParams.get("w");
   const height = filterParams.get("h");
 
   const reduceQuality = filterParams.get("reduceQuality");
-  const quality = reduceQuality ? +reduceQuality : 100;
+  const quality = reduceQuality ? +reduceQuality : reduceImageQuality;
 
   const isImage = file.type.startsWith("image");
 
-  if (isImage && width && height) {
+  if (isImage && width && height && validateImageSize) {
     const image = sharp(file.getFilePath());
     const metadata = await image.metadata();
 
@@ -115,7 +138,9 @@ async function sendFileToS3(
 
       if (widthDiff > 10 || heightDiff > 10) {
         return {
-          error: `Formato inválido ${metadata.width}px x ${metadata.height}px`,
+          error: validateImageMessage
+            .replace("{{width}}", width)
+            .replace("{{height}}", height),
         };
       }
     }
@@ -138,7 +163,7 @@ async function sendFileToS3(
     file.getFilePath = () => compressedFilePath;
 
     const streamFile = fs.createReadStream(file.getFilePath());
-    const apiResponse = await s3_upload(streamFile, file.type, awsS3Config);
+    const apiResponse = await s3Upload(streamFile, file.type, awsS3Config);
 
     fs.unlink(compressedFilePath, (err) => {
       if (err) console.error(`Delete image error: ${err}`);
@@ -148,9 +173,9 @@ async function sendFileToS3(
   }
 
   const streamFile = fs.createReadStream(file.getFilePath());
-  const apiResponse = await s3_upload(streamFile, file.type, awsS3Config);
+  const apiResponse = await s3Upload(streamFile, file.type, awsS3Config);
 
   return { url: apiResponse.location };
-}
+};
 
 export { sendFileToS3 };

package/src/helpers/globalErrorHandler.ts

@@ -1,64 +0,0 @@
-import { badRequest, BadRequestError } from "../httpBadResponses/badRequest";
-import { conflict, ConflictError } from "../httpBadResponses/conflict";
-import { forbidden, ForbiddenError } from "../httpBadResponses/forbidden";
-import { notFound, NotFoundError } from "../httpBadResponses/notFound";
-import { serverError } from "../httpBadResponses/serverError";
-import {
-  unauthorized,
-  UnauthorizedError,
-} from "../httpBadResponses/unauthorized";
-import {
-  unprocessableEntity,
-  UnprocessableEntityError,
-} from "../httpBadResponses/unprocessableEntity";
-import { created, Created } from "../httpResponses/created";
-import { noContent, NoContent } from "../httpResponses/noContent";
-import { success, Success } from "../httpResponses/success";
-import { updated, Updated } from "../httpResponses/updated";
-
-const globalErrorHandler = (error: any) => {
-  // If the error is not an instance of Error, return the response
-  switch (true) {
-    case error instanceof Response:
-      return error;
-    case error instanceof Created:
-      return created(error.body, error.init);
-    case error instanceof Updated:
-      return updated(error.body, error.init);
-    case error instanceof Success:
-      return success(error.body, error.init);
-    case error instanceof NoContent:
-      return noContent(error.init);
-  }
-
-  const showConsoleError =
-    process.env.NODE_ENV === "development" ||
-    process.env?.SHOW_ERRORS_IN_CONSOLE === "true";
-
-  // If showConsoleError is true, log the error to the console
-  if (showConsoleError) console.error(error);
-
-  // If the error is an instance of BadRequestError, ForbiddenError, ConflictError, UnauthorizedError, NotFoundError, or UnprocessableEntityError, return the error
-  switch (true) {
-    case error instanceof BadRequestError:
-      return badRequest(error);
-    case error instanceof ForbiddenError:
-      return forbidden(error);
-    case error instanceof ConflictError:
-      return conflict(error);
-    case error instanceof UnauthorizedError:
-      return unauthorized(error);
-    case error instanceof NotFoundError:
-      return notFound(error);
-    case error instanceof UnprocessableEntityError:
-      return unprocessableEntity(error);
-    default:
-      return serverError({
-        message: error?.message || "Server error | Message not found",
-        name: "Server Error",
-        cause: error.cause || "Unknown",
-      });
-  }
-};
-
-export { globalErrorHandler };

package/src/httpBadResponses/badRequest.ts

@@ -1,29 +0,0 @@
-function badRequest(error: BadRequestError) {
-  return new Response(
-    JSON.stringify({
-      status: 400,
-      success: false,
-      name: error.name,
-      message: error.message,
-    }),
-    {
-      status: 400,
-      statusText: "Bad Request",
-      headers: { "Content-Type": "application/json" },
-    }
-  );
-}
-
-class BadRequestError {
-  name: string;
-  message: string;
-  cause?: any;
-
-  constructor(message: string, cause?: any) {
-    this.name = "BadRequestError";
-    this.message = message;
-    this.cause = cause ? JSON.stringify(cause) : undefined;
-  }
-}
-
-export { badRequest, BadRequestError };