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

package/dist/services/sendFileToS3.js

@@ -1,31 +1,22 @@
+import { generateId } from "@arkyn/shared";
 import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
 import { unstable_composeUploadHandlers as composeUploadHandlers, unstable_createFileUploadHandler as createFileUploadHandler, unstable_parseMultipartFormData as parseMultipartFormData, } 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";
-async function s3_upload(fileStream, contentType, awsS3Config) {
-    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();
-    }
+async function s3Upload(fileStream, contentType, awsConfig) {
     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,
         },
     });
     const command = new PutObjectCommand(uploadParams);
@@ -36,15 +27,64 @@ async function s3_upload(fileStream, contentType, awsS3Config) {
         console.error(error);
     }
     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, awsS3Config, 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 = 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({
         maxPartSize,
         file: ({ filename }) => filename,
@@ -52,14 +92,14 @@ async function sendFileToS3(props, awsS3Config, config = {
     const formData = await parseMultipartFormData(request, uploadHandler);
     const file = formData.get(fileName);
     if (!file)
-        throw new BadRequestError("No file uploaded");
+        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();
         if (metadata.width && metadata.height) {
@@ -67,7 +107,9 @@ async function sendFileToS3(props, awsS3Config, config = {
             const heightDiff = Math.abs(metadata.height - +height);
             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),
                 };
             }
         }
@@ -87,7 +129,7 @@ async function sendFileToS3(props, awsS3Config, config = {
         await image.toFile(compressedFilePath);
         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}`);
@@ -95,7 +137,7 @@ async function sendFileToS3(props, awsS3Config, config = {
         return { url: apiResponse.location };
     }
     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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arkyn/server",
-  "version": "2.0.1-beta.1",
+  "version": "2.0.1-beta.10",
   "main": "./dist/bundle.js",
   "module": "./src/index.ts",
   "type": "module",
@@ -12,9 +12,11 @@
   },
   "dependencies": {
     "@arkyn/server": "*",
+    "@arkyn/shared": "*",
     "@aws-sdk/client-s3": "^3.775.0",
     "@remix-run/node": "^2.16.2",
-    "sharp": "^0.33.5"
+    "sharp": "^0.33.5",
+    "zod": "^3.24.2"
   },
   "devDependencies": {
     "bun-types": "latest",

package/src/http/badResponses/badGateway.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../../services/httpDebug";
+
+class BadGateway {
+  body: any;
+  cause?: any;
+  status: number = 502;
+  statusText: string;
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "BadGateway", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("BadGateway", this.body, this.cause);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { BadGateway };

package/src/http/badResponses/badRequest.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../../services/httpDebug";
+
+class BadRequest {
+  body: any;
+  cause?: any;
+  status: number = 400;
+  statusText: string;
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "BadRequest", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("BadRequest", this.body, this.cause);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { BadRequest };

package/src/http/badResponses/conflict.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../../services/httpDebug";
+
+class Conflict {
+  body: any;
+  cause?: any;
+  status: number = 409;
+  statusText: string;
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "Conflict", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("Conflict", this.body, this.cause);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Conflict };

package/src/http/badResponses/forbidden.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../../services/httpDebug";
+
+class Forbidden {
+  body: any;
+  cause?: any;
+  status: number = 402;
+  statusText: string;
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "Forbidden", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("Forbidden", this.body, this.cause);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Forbidden };

package/src/http/badResponses/notFound.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../../services/httpDebug";
+
+class NotFound {
+  body: any;
+  cause?: any;
+  status: number = 404;
+  statusText: string;
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "NotFound", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("NotFound", this.body, this.cause);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { NotFound };

package/src/http/badResponses/notImplemented.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../../services/httpDebug";
+
+class NotImplemented {
+  body: any;
+  cause?: any;
+  status: number = 501;
+  statusText: string;
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "NotImplemented", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("NotImplemented", this.body, this.cause);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { NotImplemented };

package/src/http/badResponses/serverError.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../../services/httpDebug";
+
+class ServerError {
+  body: any;
+  cause?: any;
+  status: number = 500;
+  statusText: string;
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "ServerError", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("ServerError", this.body, this.cause);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { ServerError };

package/src/http/badResponses/unauthorized.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../../services/httpDebug";
+
+class Unauthorized {
+  body: any;
+  cause?: any;
+  status: number = 401;
+  statusText: string;
+
+  constructor(message: string, cause?: any) {
+    this.body = { name: "Unauthorized", message: message };
+    this.statusText = message;
+    this.cause = cause ? JSON.stringify(cause) : undefined;
+    httpDebug("Unauthorized", this.body, this.cause);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Unauthorized };

package/src/http/badResponses/unprocessableEntity.ts

@@ -0,0 +1,48 @@
+import { httpDebug } from "../../services/httpDebug";
+
+type UnprocessableEntityProps = {
+  data?: any;
+  fieldErrors?: Record<string, string>;
+  fields?: Record<string, string>;
+  message?: string;
+};
+
+class UnprocessableEntity {
+  body: any;
+  status: number = 422;
+  statusText: string;
+
+  constructor(props: UnprocessableEntityProps, enableDebug = false) {
+    this.statusText = props.message || "Unprocessable Entity";
+    this.body = {
+      name: "UnprocessableEntity",
+      message: props.message || null,
+      data: props.data,
+      fieldErrors: props.fieldErrors,
+      fields: props.fields,
+    };
+
+    enableDebug && httpDebug("UnprocessableEntity", this.body);
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json" },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { UnprocessableEntity };

package/src/http/successResponses/created.ts

@@ -0,0 +1,35 @@
+class Created<T> {
+  body: T;
+  headers: ResponseInit["headers"];
+  status: number;
+  statusText: string;
+
+  constructor(body: T, init?: ResponseInit) {
+    this.body = body;
+    this.headers = init?.headers || {};
+    this.status = init?.status || 201;
+    this.statusText = init?.statusText || "Resource created successfully";
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Created };

package/src/http/successResponses/found.ts

@@ -0,0 +1,35 @@
+class Found<T> {
+  body: T;
+  headers: ResponseInit["headers"];
+  status: number;
+  statusText: string;
+
+  constructor(body: T, init?: ResponseInit) {
+    this.body = body;
+    this.headers = init?.headers || {};
+    this.status = init?.status || 302;
+    this.statusText = init?.statusText || "Found";
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Found };

package/src/http/successResponses/noContent.ts

@@ -0,0 +1,33 @@
+class NoContent {
+  headers: ResponseInit["headers"];
+  status: number;
+  statusText: string;
+
+  constructor(init?: ResponseInit) {
+    this.headers = init?.headers || {};
+    this.status = init?.status || 204;
+    this.statusText = init?.statusText ?? "No content";
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(null, responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(null, responseInit);
+  }
+}
+
+export { NoContent };

package/src/http/successResponses/success.ts

@@ -0,0 +1,35 @@
+class Success<T> {
+  body: T;
+  headers: ResponseInit["headers"];
+  status: number;
+  statusText: string;
+
+  constructor(body: T, init?: ResponseInit) {
+    this.body = body;
+    this.headers = init?.headers || {};
+    this.status = init?.status || 200;
+    this.statusText = init?.statusText ?? "OK";
+  }
+
+  toResponse() {
+    const responseInit: ResponseInit = {
+      headers: { "Content-Type": "application/json", ...this.headers },
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return new Response(JSON.stringify(this.body), responseInit);
+  }
+
+  toJson() {
+    const responseInit: ResponseInit = {
+      headers: this.headers,
+      status: this.status,
+      statusText: this.statusText,
+    };
+
+    return Response.json(this.body, responseInit);
+  }
+}
+
+export { Success };