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

package/dist/services/sendFileToS3.js

@@ -0,0 +1,143 @@
+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 fs from "fs";
+import sharp from "sharp";
+import { BadRequest } from "../http/badResponses/badRequest";
+import { getScopedParams } from "./getScopedParams";
+async function s3Upload(fileStream, contentType, awsConfig) {
+    const uploadParams = {
+        Bucket: awsConfig.AWS_S3_BUCKET,
+        Key: `uploads/${generateId("text", "v4")}`,
+        Body: fileStream,
+        ContentType: contentType,
+    };
+    const s3Client = new S3Client({
+        region: awsConfig.AWS_REGION,
+        credentials: {
+            accessKeyId: awsConfig.AWS_ACCESS_KEY_ID,
+            secretAccessKey: awsConfig.AWS_SECRET_ACCESS_KEY,
+        },
+    });
+    const command = new PutObjectCommand(uploadParams);
+    try {
+        await s3Client.send(command);
+    }
+    catch (error) {
+        console.error(error);
+    }
+    return {
+        location: `https://${awsConfig.AWS_S3_BUCKET}.s3.amazonaws.com/${uploadParams.Key}`,
+    };
+}
+/**
+ * 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,
+    }));
+    const formData = await parseMultipartFormData(request, uploadHandler);
+    const file = formData.get(fileName);
+    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 : reduceImageQuality;
+    const isImage = file.type.startsWith("image");
+    if (isImage && width && height && validateImageSize) {
+        const image = sharp(file.getFilePath());
+        const metadata = await image.metadata();
+        if (metadata.width && metadata.height) {
+            const widthDiff = Math.abs(metadata.width - +width);
+            const heightDiff = Math.abs(metadata.height - +height);
+            if (widthDiff > 10 || heightDiff > 10) {
+                return {
+                    error: validateImageMessage
+                        .replace("{{width}}", width)
+                        .replace("{{height}}", height),
+                };
+            }
+        }
+    }
+    if (isImage) {
+        let image = sharp(file.getFilePath());
+        if (file.type === "image/jpeg") {
+            image = image.jpeg({ quality });
+        }
+        else if (file.type === "image/png") {
+            image = image.png({ quality });
+        }
+        else if (file.type === "image/webp") {
+            image = image.webp({ quality });
+        }
+        const compressedFilePath = file.getFilePath() + "_compressed";
+        await image.toFile(compressedFilePath);
+        file.getFilePath = () => compressedFilePath;
+        const streamFile = fs.createReadStream(file.getFilePath());
+        const apiResponse = await s3Upload(streamFile, file.type, awsS3Config);
+        fs.unlink(compressedFilePath, (err) => {
+            if (err)
+                console.error(`Delete image error: ${err}`);
+        });
+        return { url: apiResponse.location };
+    }
+    const streamFile = fs.createReadStream(file.getFilePath());
+    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.0",
+  "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 };

package/src/http/successResponses/updated.ts

@@ -0,0 +1,35 @@
+class Updated<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 || "Resource updated 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 { Updated };