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

package/src/http/badResponses/badGateway.ts

@@ -0,0 +1,36 @@
+import { httpDebug } from "../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 "../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 "../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 "../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 "../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 "../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 "../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 "../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 "../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) {
+    this.statusText = props.message || "Unprocessable Entity";
+    this.body = {
+      name: "UnprocessableEntity",
+      message: props.message || null,
+      data: props.data,
+      fieldErrors: props.fieldErrors,
+      fields: props.fields,
+    };
+
+    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/httpDebug.ts

@@ -0,0 +1,18 @@
+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 pathname = new URL(import.meta.url).pathname;
+    console.log(`${cyan}[ARKYN-DEBUG]${reset} ${name} initialized`);
+    console.log(`${cyan}[ARKYN-DEBUG]${reset} Pathname:`, pathname);
+    console.log(`${cyan}[ARKYN-DEBUG]${reset} Body:`, body);
+    if (cause) console.log(`[ARKYN-DEBUG] Cause:`, cause);
+  }
+}
+
+export { httpDebug };

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

package/src/index.ts

@@ -1,23 +1,21 @@
-// 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 { getScopedParams } from "./services/getScopedParams";
 export { sendFileToS3 } from "./services/sendFileToS3";

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