@aura-stack/router 0.1.0

package/dist/error.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The HTTP status codes used in AuraStack Router.
+ */
+declare const statusCode: {
+    OK: number;
+    CREATED: number;
+    ACCEPTED: number;
+    NO_CONTENT: number;
+    MULTIPLE_CHOICES: number;
+    MOVED_PERMANENTLY: number;
+    FOUND: number;
+    SEE_OTHER: number;
+    NOT_MODIFIED: number;
+    TEMPORARY_REDIRECT: number;
+    BAD_REQUEST: number;
+    UNAUTHORIZED: number;
+    PAYMENT_REQUIRED: number;
+    FORBIDDEN: number;
+    NOT_FOUND: number;
+    METHOD_NOT_ALLOWED: number;
+    NOT_ACCEPTABLE: number;
+    PROXY_AUTHENTICATION_REQUIRED: number;
+    UNPROCESSABLE_ENTITY: number;
+    INTERNAL_SERVER_ERROR: number;
+    NOT_IMPLEMENTED: number;
+    BAD_GATEWAY: number;
+    SERVICE_UNAVAILABLE: number;
+    HTTP_VERSION_NOT_SUPPORTED: number;
+};
+/**
+ * Defines the errors used in AuraStack Router. Includes HTTP status code and
+ * status text.
+ */
+declare class AuraStackRouterError extends Error {
+    readonly status: number;
+    readonly statusText: keyof typeof statusCode;
+    constructor(type: keyof typeof statusCode, message: string, name?: string);
+}
+
+export { AuraStackRouterError };

package/dist/error.js

@@ -0,0 +1,6 @@
+import {
+  AuraStackRouterError
+} from "./chunk-RFYOPPMW.js";
+export {
+  AuraStackRouterError
+};

package/dist/index.cjs

@@ -0,0 +1,264 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createEndpoint: () => createEndpoint,
+  createEndpointConfig: () => createEndpointConfig,
+  createRouter: () => createRouter
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/assert.ts
+var supportedMethods = ["GET", "POST", "DELETE", "PUT", "PATCH"];
+var supportedBodyMethods = ["POST", "PUT", "PATCH"];
+var isSupportedMethod = (method) => {
+  return supportedMethods.includes(method);
+};
+var isSupportedBodyMethod = (method) => {
+  return supportedBodyMethods.includes(method);
+};
+var isValidRoute = (route) => {
+  const routePattern = /^\/[a-zA-Z0-9/_:-]*$/;
+  return routePattern.test(route);
+};
+var isValidHandler = (handler) => {
+  return typeof handler === "function";
+};
+
+// src/error.ts
+var statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusText = Object.entries(statusCode).reduce(
+  (previous, [status, code]) => {
+    return { ...previous, [code]: status };
+  },
+  {}
+);
+var AuraStackRouterError = class extends Error {
+  constructor(type, message, name) {
+    super(message);
+    this.name = name ?? "AuraStackRouterError";
+    this.status = statusCode[type];
+    this.statusText = statusText[this.status];
+  }
+};
+
+// src/endpoint.ts
+var createRoutePattern = (route) => {
+  const pattern = route.replace(/:[^/]+/g, "([^/]+)").replace(/\//g, "\\/");
+  return new RegExp(`^${pattern}$`);
+};
+var createEndpoint = (method, route, handler, config = {}) => {
+  if (!isSupportedMethod(method)) {
+    throw new AuraStackRouterError("METHOD_NOT_ALLOWED", `Unsupported HTTP method: ${method}`);
+  }
+  if (!isValidRoute(route)) {
+    throw new AuraStackRouterError("BAD_REQUEST", `Invalid route format: ${route}`);
+  }
+  if (!isValidHandler(handler)) {
+    throw new AuraStackRouterError("BAD_REQUEST", "Handler must be a function");
+  }
+  return { method, route, handler, config };
+};
+function createEndpointConfig(...args) {
+  if (typeof args[0] === "string") return args[1];
+  return args[0];
+}
+
+// src/context.ts
+var getRouteParams = (route, path) => {
+  const routeRegex = createRoutePattern(route);
+  if (!routeRegex.test(path)) {
+    throw new AuraStackRouterError("BAD_REQUEST", `Missing required route params for route: ${route}`);
+  }
+  const params = routeRegex.exec(route)?.slice(1).map((seg) => seg.replace(":", ""));
+  if (!params) return {};
+  const values = routeRegex.exec(path)?.slice(1);
+  return params.reduce(
+    (previous, now, idx) => ({
+      ...previous,
+      [now]: decodeURIComponent(values?.[idx] ?? "")
+    }),
+    {}
+  );
+};
+var getSearchParams = (url, config) => {
+  const route = new URL(url);
+  if (config.schemas?.searchParams) {
+    const parsed = config.schemas.searchParams.safeParse(Object.fromEntries(route.searchParams.entries()));
+    if (!parsed.success) {
+      throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid search parameters");
+    }
+    return parsed.data;
+  }
+  return new URLSearchParams(route.searchParams.toString());
+};
+var getHeaders = (request) => {
+  return new Headers(request.headers);
+};
+var getBody = async (request, config) => {
+  if (!isSupportedBodyMethod(request.method)) {
+    return void 0;
+  }
+  const contentType = request.headers.get("Content-Type") ?? "";
+  if (contentType.includes("application/json")) {
+    const json = await request.json();
+    if (config.schemas?.body) {
+      const parsed = config.schemas.body.safeParse(json);
+      if (!parsed.success) {
+        throw new AuraStackRouterError("UNPROCESSABLE_ENTITY", "Invalid request body");
+      }
+      return parsed.data;
+    }
+    return json;
+  }
+  if (contentType.includes("application/x-www-form-urlencoded") || contentType.includes("multipart/form-data")) {
+    return await request.formData();
+  }
+  if (contentType.includes("text/")) {
+    return await request.text();
+  }
+  if (contentType.includes("application/octet-stream")) {
+    return await request.arrayBuffer();
+  }
+  if (contentType.includes("image/") || contentType.includes("video/") || contentType.includes("audio/")) {
+    return await request.blob();
+  }
+  return null;
+};
+
+// src/middleware.ts
+var executeGlobalMiddlewares = async (request, middlewares) => {
+  if (!middlewares) return request;
+  for (const middleware of middlewares) {
+    if (typeof middleware !== "function") {
+      throw new AuraStackRouterError("BAD_REQUEST", "Global middlewares must be functions");
+    }
+    const executed = await middleware(request);
+    if (executed instanceof Response) {
+      return executed;
+    }
+    request = executed;
+  }
+  if (!request || !(request instanceof Request)) {
+    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  }
+  return request;
+};
+var executeMiddlewares = async (request, context, middlewares = []) => {
+  try {
+    let ctx = context;
+    for (const middleware of middlewares) {
+      if (typeof middleware !== "function") {
+        throw new AuraStackRouterError("BAD_REQUEST", "Middleware must be a function");
+      }
+      ctx = await middleware(request, ctx);
+    }
+    return ctx;
+  } catch {
+    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
+  }
+};
+
+// src/router.ts
+var createRouter = (endpoints, config = {}) => {
+  const server = {};
+  const groups = {
+    GET: [],
+    POST: [],
+    DELETE: [],
+    PUT: [],
+    PATCH: []
+  };
+  endpoints.forEach((endpoint) => groups[endpoint.method].push(endpoint));
+  for (const method in groups) {
+    server[method] = async (request, ctx) => {
+      try {
+        const globalRequest = await executeGlobalMiddlewares(request, config.middlewares);
+        if (globalRequest instanceof Response) {
+          return globalRequest;
+        }
+        const url = new URL(globalRequest.url);
+        const pathname = url.pathname;
+        const endpoint = groups[method].find((endpoint2) => {
+          const withBasePath = config.basePath ? `${config.basePath}${endpoint2.route}` : endpoint2.route;
+          const regex = createRoutePattern(withBasePath);
+          return regex.test(pathname);
+        });
+        if (endpoint) {
+          const withBasePath = config.basePath ? `${config.basePath}${endpoint.route}` : endpoint.route;
+          const body = await getBody(globalRequest, endpoint.config);
+          const params = getRouteParams(withBasePath, pathname);
+          const searchParams = getSearchParams(globalRequest.url, endpoint.config);
+          const headers = getHeaders(globalRequest);
+          const context = {
+            ...ctx,
+            params,
+            searchParams,
+            headers,
+            body
+          };
+          await executeMiddlewares(globalRequest, context, endpoint.config.middlewares);
+          return endpoint.handler(globalRequest, context);
+        }
+        return Response.json({ message: "Not Found" }, { status: 404 });
+      } catch (error) {
+        if (error instanceof AuraStackRouterError) {
+          const { message, status, statusText: statusText2 } = error;
+          console.log("StatusText: ", statusText2);
+          return Response.json({ message }, { status, statusText: statusText2 });
+        }
+        return Response.json({ message: "Internal Server Error" }, { status: 500 });
+      }
+    };
+  }
+  return server;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createEndpoint,
+  createEndpointConfig,
+  createRouter
+});

package/dist/index.d.cts

@@ -0,0 +1,4 @@
+export { createEndpoint, createEndpointConfig } from './endpoint.cjs';
+export { createRouter } from './router.cjs';
+export { ContentType, ContextBody, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Params, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig } from './types.cjs';
+import 'zod';

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { createEndpoint, createEndpointConfig } from './endpoint.js';
+export { createRouter } from './router.js';
+export { ContentType, ContextBody, ContextSearchParams, EndpointConfig, EndpointSchemas, GetHttpHandlers, GetRouteParams, GlobalMiddleware, HTTPMethod, InferMethod, MiddlewareFunction, Params, Prettify, RequestContext, RouteEndpoint, RouteHandler, RoutePattern, RouterConfig } from './types.js';
+import 'zod';

package/dist/index.js

@@ -0,0 +1,16 @@
+import {
+  createRouter
+} from "./chunk-VBI7H3AK.js";
+import "./chunk-NNCUFWPI.js";
+import {
+  createEndpoint,
+  createEndpointConfig
+} from "./chunk-6UBPSXKR.js";
+import "./chunk-ENOBC3XN.js";
+import "./chunk-RVJ2F7OL.js";
+import "./chunk-RFYOPPMW.js";
+export {
+  createEndpoint,
+  createEndpointConfig,
+  createRouter
+};

package/dist/middleware.cjs

@@ -0,0 +1,106 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/middleware.ts
+var middleware_exports = {};
+__export(middleware_exports, {
+  executeGlobalMiddlewares: () => executeGlobalMiddlewares,
+  executeMiddlewares: () => executeMiddlewares
+});
+module.exports = __toCommonJS(middleware_exports);
+
+// src/error.ts
+var statusCode = {
+  OK: 200,
+  CREATED: 201,
+  ACCEPTED: 202,
+  NO_CONTENT: 204,
+  MULTIPLE_CHOICES: 300,
+  MOVED_PERMANENTLY: 301,
+  FOUND: 302,
+  SEE_OTHER: 303,
+  NOT_MODIFIED: 304,
+  TEMPORARY_REDIRECT: 307,
+  BAD_REQUEST: 400,
+  UNAUTHORIZED: 401,
+  PAYMENT_REQUIRED: 402,
+  FORBIDDEN: 403,
+  NOT_FOUND: 404,
+  METHOD_NOT_ALLOWED: 405,
+  NOT_ACCEPTABLE: 406,
+  PROXY_AUTHENTICATION_REQUIRED: 407,
+  UNPROCESSABLE_ENTITY: 422,
+  INTERNAL_SERVER_ERROR: 500,
+  NOT_IMPLEMENTED: 501,
+  BAD_GATEWAY: 502,
+  SERVICE_UNAVAILABLE: 503,
+  HTTP_VERSION_NOT_SUPPORTED: 505
+};
+var statusText = Object.entries(statusCode).reduce(
+  (previous, [status, code]) => {
+    return { ...previous, [code]: status };
+  },
+  {}
+);
+var AuraStackRouterError = class extends Error {
+  constructor(type, message, name) {
+    super(message);
+    this.name = name ?? "AuraStackRouterError";
+    this.status = statusCode[type];
+    this.statusText = statusText[this.status];
+  }
+};
+
+// src/middleware.ts
+var executeGlobalMiddlewares = async (request, middlewares) => {
+  if (!middlewares) return request;
+  for (const middleware of middlewares) {
+    if (typeof middleware !== "function") {
+      throw new AuraStackRouterError("BAD_REQUEST", "Global middlewares must be functions");
+    }
+    const executed = await middleware(request);
+    if (executed instanceof Response) {
+      return executed;
+    }
+    request = executed;
+  }
+  if (!request || !(request instanceof Request)) {
+    throw new AuraStackRouterError("BAD_REQUEST", "Global middleware must return a Request or Response object");
+  }
+  return request;
+};
+var executeMiddlewares = async (request, context, middlewares = []) => {
+  try {
+    let ctx = context;
+    for (const middleware of middlewares) {
+      if (typeof middleware !== "function") {
+        throw new AuraStackRouterError("BAD_REQUEST", "Middleware must be a function");
+      }
+      ctx = await middleware(request, ctx);
+    }
+    return ctx;
+  } catch {
+    throw new AuraStackRouterError("BAD_REQUEST", "Handler threw an error");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  executeGlobalMiddlewares,
+  executeMiddlewares
+});

package/dist/middleware.d.cts

@@ -0,0 +1,22 @@
+import { RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.cjs';
+import 'zod';
+
+/**
+ * Executes the middlewares in sequence, passing the request to each middleware.
+ *
+ * @param request - Original request made from the client
+ * @param middlewares - Array of global middleware functions to be executed
+ * @returns - The modified request after all middlewares have been executed
+ */
+declare const executeGlobalMiddlewares: (request: Request, middlewares: RouterConfig["middlewares"]) => Promise<Request | Response>;
+/**
+ * Executes middlewares in sequence, passing the request and context to each middleware.
+ *
+ * @param request - Original request made from the client
+ * @param context - Context object of the endpoint functionality
+ * @param middlewares - Array of middleware functions to be executed
+ * @returns The modified context after all middlewares have been executed
+ */
+declare const executeMiddlewares: <const RouteParams extends Record<string, string>, const Config extends EndpointConfig>(request: Request, context: RequestContext<RouteParams, Config>, middlewares?: MiddlewareFunction<RouteParams, Config>[]) => Promise<RequestContext<RouteParams, Config>>;
+
+export { executeGlobalMiddlewares, executeMiddlewares };

package/dist/middleware.d.ts

@@ -0,0 +1,22 @@
+import { RouterConfig, EndpointConfig, RequestContext, MiddlewareFunction } from './types.js';
+import 'zod';
+
+/**
+ * Executes the middlewares in sequence, passing the request to each middleware.
+ *
+ * @param request - Original request made from the client
+ * @param middlewares - Array of global middleware functions to be executed
+ * @returns - The modified request after all middlewares have been executed
+ */
+declare const executeGlobalMiddlewares: (request: Request, middlewares: RouterConfig["middlewares"]) => Promise<Request | Response>;
+/**
+ * Executes middlewares in sequence, passing the request and context to each middleware.
+ *
+ * @param request - Original request made from the client
+ * @param context - Context object of the endpoint functionality
+ * @param middlewares - Array of middleware functions to be executed
+ * @returns The modified context after all middlewares have been executed
+ */
+declare const executeMiddlewares: <const RouteParams extends Record<string, string>, const Config extends EndpointConfig>(request: Request, context: RequestContext<RouteParams, Config>, middlewares?: MiddlewareFunction<RouteParams, Config>[]) => Promise<RequestContext<RouteParams, Config>>;
+
+export { executeGlobalMiddlewares, executeMiddlewares };

package/dist/middleware.js

@@ -0,0 +1,9 @@
+import {
+  executeGlobalMiddlewares,
+  executeMiddlewares
+} from "./chunk-RVJ2F7OL.js";
+import "./chunk-RFYOPPMW.js";
+export {
+  executeGlobalMiddlewares,
+  executeMiddlewares
+};