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

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/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 };

package/src/httpBadResponses/conflict.ts

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

package/src/httpBadResponses/forbidden.ts

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

package/src/httpBadResponses/notFound.ts

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

package/src/httpBadResponses/serverError.ts

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

package/src/httpBadResponses/unauthorized.ts

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

package/src/httpBadResponses/unprocessableEntity.ts

@@ -1,43 +0,0 @@
-type UnprocessableEntityErrorProps = {
-  data?: any;
-  fieldErrors?: Record<string, string>;
-  fields?: Record<string, string>;
-  message?: string;
-};
-
-function unprocessableEntity(error: UnprocessableEntityError) {
-  return new Response(
-    JSON.stringify({
-      status: 433,
-      success: false,
-      name: error.name,
-      message: error.message,
-      data: error.data || null,
-      fieldErrors: error.fieldErrors || null,
-      fields: error.fields || null,
-    }),
-    {
-      status: 433,
-      statusText: "Bad Request",
-      headers: { "Content-Type": "application/json" },
-    }
-  );
-}
-
-class UnprocessableEntityError {
-  name: string;
-  message?: string;
-  fieldErrors: any;
-  fields: any;
-  data: any;
-
-  constructor(data: UnprocessableEntityErrorProps) {
-    this.data = data?.data || null;
-    this.fieldErrors = data?.fieldErrors || null;
-    this.fields = data?.fields || null;
-    this.name = "UnprocessableEntity";
-    this.message = data?.message;
-  }
-}
-
-export { unprocessableEntity, UnprocessableEntityError };

package/src/httpResponses/created.ts

@@ -1,35 +0,0 @@
-function created(body: any, init?: ResponseInit): Response {
-  return new Response(JSON.stringify(body), {
-    ...init,
-    status: 201,
-    headers: { "Content-Type": "application/json", ...init?.headers },
-  });
-}
-
-class Created<T> {
-  body: T;
-  init: ResponseInit;
-
-  constructor(body: T, init?: ResponseInit) {
-    this.body = body;
-    this.init = init || {};
-  }
-
-  response() {
-    return new Response(JSON.stringify(this.body), {
-      ...this.init,
-      status: 201,
-      headers: { "Content-Type": "application/json", ...this.init.headers },
-    });
-  }
-
-  json() {
-    return new Response(JSON.stringify(this.body), {
-      ...this.init,
-      status: 201,
-      headers: { "Content-Type": "application/json", ...this.init.headers },
-    }).json();
-  }
-}
-
-export { created, Created };

package/src/httpResponses/noContent.ts

@@ -1,33 +0,0 @@
-function noContent(init?: ResponseInit): Response {
-  return new Response(null, {
-    ...init,
-    status: 200,
-    headers: { "Content-Type": "application/json", ...init?.headers },
-  });
-}
-
-class NoContent {
-  init: ResponseInit;
-
-  constructor(init?: ResponseInit) {
-    this.init = init || {};
-  }
-
-  response() {
-    return new Response(null, {
-      ...this.init,
-      status: 200,
-      headers: { "Content-Type": "application/json", ...this.init.headers },
-    });
-  }
-
-  json() {
-    return new Response(null, {
-      ...this.init,
-      status: 200,
-      headers: { "Content-Type": "application/json", ...this.init.headers },
-    }).json();
-  }
-}
-
-export { noContent, NoContent };

package/src/httpResponses/success.ts

@@ -1,35 +0,0 @@
-function success(body: any, init?: ResponseInit): Response {
-  return new Response(JSON.stringify(body), {
-    ...init,
-    status: 200,
-    headers: { "Content-Type": "application/json", ...init?.headers },
-  });
-}
-
-class Success<T> {
-  body: T;
-  init: ResponseInit;
-
-  constructor(body: T, init?: ResponseInit) {
-    this.body = body;
-    this.init = init || {};
-  }
-
-  response() {
-    return new Response(JSON.stringify(this.body), {
-      ...this.init,
-      status: 200,
-      headers: { "Content-Type": "application/json", ...this.init.headers },
-    });
-  }
-
-  json() {
-    return new Response(JSON.stringify(this.body), {
-      ...this.init,
-      status: 200,
-      headers: { "Content-Type": "application/json", ...this.init.headers },
-    }).json();
-  }
-}
-
-export { success, Success };

package/src/httpResponses/updated.ts

@@ -1,35 +0,0 @@
-function updated(body: any, init?: ResponseInit): Response {
-  return new Response(JSON.stringify(body), {
-    ...init,
-    status: 200,
-    headers: { "Content-Type": "application/json", ...init?.headers },
-  });
-}
-
-class Updated<T> {
-  body: T;
-  init: ResponseInit;
-
-  constructor(body: T, init?: ResponseInit) {
-    this.body = body;
-    this.init = init || {};
-  }
-
-  response() {
-    return new Response(JSON.stringify(this.body), {
-      ...this.init,
-      status: 200,
-      headers: { "Content-Type": "application/json", ...this.init.headers },
-    });
-  }
-
-  json() {
-    return new Response(JSON.stringify(this.body), {
-      ...this.init,
-      status: 200,
-      headers: { "Content-Type": "application/json", ...this.init.headers },
-    }).json();
-  }
-}
-
-export { updated, Updated };