vector-framework 1.1.1 → 1.2.0

package/src/http.ts

@@ -1,81 +1,63 @@
-import { cors, type IRequest, type RouteEntry, withContent } from 'itty-router';
-import { buildRouteRegex } from './utils/path';
 import { CONTENT_TYPES, HTTP_STATUS } from './constants';
 import type {
   CacheOptions,
   DefaultVectorTypes,
   GetAuthType,
+  InferRouteInputFromSchemaDefinition,
+  RouteSchemaDefinition,
   VectorRequest,
   VectorTypes,
 } from './types';
 import { getVectorInstance } from './core/vector';
 
-export interface ProtectedRequest<TTypes extends VectorTypes = DefaultVectorTypes>
-  extends IRequest {
-  authUser?: GetAuthType<TTypes>;
-}
-
-export const { preflight, corsify } = cors({
-  origin: '*',
-  credentials: true,
-  allowHeaders: 'Content-Type, Authorization',
-  allowMethods: 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
-  exposeHeaders: 'Authorization',
-  maxAge: 86_400,
-});
-
-interface ExtendedApiOptions extends ApiOptions {
+interface ExtendedApiOptions<TSchemaDef extends RouteSchemaDefinition | undefined = RouteSchemaDefinition | undefined>
+  extends ApiOptions<TSchemaDef> {
   method: string;
   path: string;
 }
 
-export interface RouteDefinition<TTypes extends VectorTypes = DefaultVectorTypes> {
-  entry: RouteEntry;
-  options: ExtendedApiOptions;
-  handler: (req: VectorRequest<TTypes>) => Promise<unknown>;
+export interface RouteDefinition<
+  TTypes extends VectorTypes = DefaultVectorTypes,
+  TValidatedInput = undefined,
+  TSchemaDef extends RouteSchemaDefinition | undefined = RouteSchemaDefinition | undefined,
+> {
+  entry: { method: string; path: string };
+  options: ExtendedApiOptions<TSchemaDef>;
+  handler: (req: VectorRequest<TTypes, TValidatedInput>) => Promise<unknown> | unknown;
 }
 
-export function route<TTypes extends VectorTypes = DefaultVectorTypes>(
-  options: ExtendedApiOptions,
-  fn: (req: VectorRequest<TTypes>) => Promise<unknown>
-): RouteDefinition<TTypes> {
-  const handler = api(options, fn);
-
-  const entry: RouteEntry = [
-    options.method.toUpperCase(),
-    buildRouteRegex(options.path),
-    [handler],
-    options.path,
-  ];
-
+export function route<
+  TTypes extends VectorTypes = DefaultVectorTypes,
+  TSchemaDef extends RouteSchemaDefinition | undefined = RouteSchemaDefinition | undefined,
+>(
+  options: ExtendedApiOptions<TSchemaDef>,
+  fn: (req: VectorRequest<TTypes, InferRouteInputFromSchemaDefinition<TSchemaDef>>) => Promise<unknown> | unknown
+): RouteDefinition<TTypes, InferRouteInputFromSchemaDefinition<TSchemaDef>, TSchemaDef> {
   return {
-    entry,
+    entry: {
+      method: options.method.toUpperCase(),
+      path: options.path,
+    },
     options,
     handler: fn,
   };
 }
 
-function hasBigInt(value: unknown, depth = 0): boolean {
-  if (typeof value === 'bigint') return true;
-  if (depth > 4 || value === null || typeof value !== 'object') return false;
-  for (const v of Object.values(value as object)) {
-    if (hasBigInt(v, depth + 1)) return true;
-  }
-  return false;
-}
-
 function stringifyData(data: unknown): string {
   const val = data ?? null;
-  if (!hasBigInt(val)) return JSON.stringify(val);
-  return JSON.stringify(val, (_key, value) =>
-    typeof value === 'bigint' ? value.toString() : value
-  );
+  try {
+    return JSON.stringify(val);
+  } catch (e) {
+    if (e instanceof TypeError && /\bbigint\b/i.test(e.message)) {
+      return JSON.stringify(val, (_key, value) => (typeof value === 'bigint' ? value.toString() : value));
+    }
+    throw e;
+  }
 }
 
 const ApiResponse = {
   success: <T>(data: T, contentType?: string) => createResponse(HTTP_STATUS.OK, data, contentType),
-  created: <T>(data: T, contentType?: string) =>
-    createResponse(HTTP_STATUS.CREATED, data, contentType),
+  created: <T>(data: T, contentType?: string) => createResponse(HTTP_STATUS.CREATED, data, contentType),
 };
 
 function createErrorResponse(code: number, message: string, contentType?: string): Response {
@@ -97,40 +79,29 @@ export const APIError = {
   unauthorized: (msg = 'Unauthorized', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.UNAUTHORIZED, msg, contentType),
 
-  paymentRequired: (msg = 'Payment Required', contentType?: string) =>
-    createErrorResponse(402, msg, contentType),
+  paymentRequired: (msg = 'Payment Required', contentType?: string) => createErrorResponse(402, msg, contentType),
 
-  forbidden: (msg = 'Forbidden', contentType?: string) =>
-    createErrorResponse(HTTP_STATUS.FORBIDDEN, msg, contentType),
+  forbidden: (msg = 'Forbidden', contentType?: string) => createErrorResponse(HTTP_STATUS.FORBIDDEN, msg, contentType),
 
-  notFound: (msg = 'Not Found', contentType?: string) =>
-    createErrorResponse(HTTP_STATUS.NOT_FOUND, msg, contentType),
+  notFound: (msg = 'Not Found', contentType?: string) => createErrorResponse(HTTP_STATUS.NOT_FOUND, msg, contentType),
 
-  methodNotAllowed: (msg = 'Method Not Allowed', contentType?: string) =>
-    createErrorResponse(405, msg, contentType),
+  methodNotAllowed: (msg = 'Method Not Allowed', contentType?: string) => createErrorResponse(405, msg, contentType),
 
-  notAcceptable: (msg = 'Not Acceptable', contentType?: string) =>
-    createErrorResponse(406, msg, contentType),
+  notAcceptable: (msg = 'Not Acceptable', contentType?: string) => createErrorResponse(406, msg, contentType),
 
-  requestTimeout: (msg = 'Request Timeout', contentType?: string) =>
-    createErrorResponse(408, msg, contentType),
+  requestTimeout: (msg = 'Request Timeout', contentType?: string) => createErrorResponse(408, msg, contentType),
 
-  conflict: (msg = 'Conflict', contentType?: string) =>
-    createErrorResponse(HTTP_STATUS.CONFLICT, msg, contentType),
+  conflict: (msg = 'Conflict', contentType?: string) => createErrorResponse(HTTP_STATUS.CONFLICT, msg, contentType),
 
   gone: (msg = 'Gone', contentType?: string) => createErrorResponse(410, msg, contentType),
 
-  lengthRequired: (msg = 'Length Required', contentType?: string) =>
-    createErrorResponse(411, msg, contentType),
+  lengthRequired: (msg = 'Length Required', contentType?: string) => createErrorResponse(411, msg, contentType),
 
-  preconditionFailed: (msg = 'Precondition Failed', contentType?: string) =>
-    createErrorResponse(412, msg, contentType),
+  preconditionFailed: (msg = 'Precondition Failed', contentType?: string) => createErrorResponse(412, msg, contentType),
 
-  payloadTooLarge: (msg = 'Payload Too Large', contentType?: string) =>
-    createErrorResponse(413, msg, contentType),
+  payloadTooLarge: (msg = 'Payload Too Large', contentType?: string) => createErrorResponse(413, msg, contentType),
 
-  uriTooLong: (msg = 'URI Too Long', contentType?: string) =>
-    createErrorResponse(414, msg, contentType),
+  uriTooLong: (msg = 'URI Too Long', contentType?: string) => createErrorResponse(414, msg, contentType),
 
   unsupportedMediaType: (msg = 'Unsupported Media Type', contentType?: string) =>
     createErrorResponse(415, msg, contentType),
@@ -138,33 +109,27 @@ export const APIError = {
   rangeNotSatisfiable: (msg = 'Range Not Satisfiable', contentType?: string) =>
     createErrorResponse(416, msg, contentType),
 
-  expectationFailed: (msg = 'Expectation Failed', contentType?: string) =>
-    createErrorResponse(417, msg, contentType),
+  expectationFailed: (msg = 'Expectation Failed', contentType?: string) => createErrorResponse(417, msg, contentType),
 
-  imATeapot: (msg = "I'm a teapot", contentType?: string) =>
-    createErrorResponse(418, msg, contentType),
+  imATeapot: (msg = "I'm a teapot", contentType?: string) => createErrorResponse(418, msg, contentType),
 
-  misdirectedRequest: (msg = 'Misdirected Request', contentType?: string) =>
-    createErrorResponse(421, msg, contentType),
+  misdirectedRequest: (msg = 'Misdirected Request', contentType?: string) => createErrorResponse(421, msg, contentType),
 
   unprocessableEntity: (msg = 'Unprocessable Entity', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.UNPROCESSABLE_ENTITY, msg, contentType),
 
   locked: (msg = 'Locked', contentType?: string) => createErrorResponse(423, msg, contentType),
 
-  failedDependency: (msg = 'Failed Dependency', contentType?: string) =>
-    createErrorResponse(424, msg, contentType),
+  failedDependency: (msg = 'Failed Dependency', contentType?: string) => createErrorResponse(424, msg, contentType),
 
   tooEarly: (msg = 'Too Early', contentType?: string) => createErrorResponse(425, msg, contentType),
 
-  upgradeRequired: (msg = 'Upgrade Required', contentType?: string) =>
-    createErrorResponse(426, msg, contentType),
+  upgradeRequired: (msg = 'Upgrade Required', contentType?: string) => createErrorResponse(426, msg, contentType),
 
   preconditionRequired: (msg = 'Precondition Required', contentType?: string) =>
     createErrorResponse(428, msg, contentType),
 
-  tooManyRequests: (msg = 'Too Many Requests', contentType?: string) =>
-    createErrorResponse(429, msg, contentType),
+  tooManyRequests: (msg = 'Too Many Requests', contentType?: string) => createErrorResponse(429, msg, contentType),
 
   requestHeaderFieldsTooLarge: (msg = 'Request Header Fields Too Large', contentType?: string) =>
     createErrorResponse(431, msg, contentType),
@@ -176,17 +141,13 @@ export const APIError = {
   internalServerError: (msg = 'Internal Server Error', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.INTERNAL_SERVER_ERROR, msg, contentType),
 
-  notImplemented: (msg = 'Not Implemented', contentType?: string) =>
-    createErrorResponse(501, msg, contentType),
+  notImplemented: (msg = 'Not Implemented', contentType?: string) => createErrorResponse(501, msg, contentType),
 
-  badGateway: (msg = 'Bad Gateway', contentType?: string) =>
-    createErrorResponse(502, msg, contentType),
+  badGateway: (msg = 'Bad Gateway', contentType?: string) => createErrorResponse(502, msg, contentType),
 
-  serviceUnavailable: (msg = 'Service Unavailable', contentType?: string) =>
-    createErrorResponse(503, msg, contentType),
+  serviceUnavailable: (msg = 'Service Unavailable', contentType?: string) => createErrorResponse(503, msg, contentType),
 
-  gatewayTimeout: (msg = 'Gateway Timeout', contentType?: string) =>
-    createErrorResponse(504, msg, contentType),
+  gatewayTimeout: (msg = 'Gateway Timeout', contentType?: string) => createErrorResponse(504, msg, contentType),
 
   httpVersionNotSupported: (msg = 'HTTP Version Not Supported', contentType?: string) =>
     createErrorResponse(505, msg, contentType),
@@ -197,11 +158,9 @@ export const APIError = {
   insufficientStorage: (msg = 'Insufficient Storage', contentType?: string) =>
     createErrorResponse(507, msg, contentType),
 
-  loopDetected: (msg = 'Loop Detected', contentType?: string) =>
-    createErrorResponse(508, msg, contentType),
+  loopDetected: (msg = 'Loop Detected', contentType?: string) => createErrorResponse(508, msg, contentType),
 
-  notExtended: (msg = 'Not Extended', contentType?: string) =>
-    createErrorResponse(510, msg, contentType),
+  notExtended: (msg = 'Not Extended', contentType?: string) => createErrorResponse(510, msg, contentType),
 
   networkAuthenticationRequired: (msg = 'Network Authentication Required', contentType?: string) =>
     createErrorResponse(511, msg, contentType),
@@ -210,22 +169,15 @@ export const APIError = {
   invalidArgument: (msg = 'Invalid Argument', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.UNPROCESSABLE_ENTITY, msg, contentType),
 
-  rateLimitExceeded: (msg = 'Rate Limit Exceeded', contentType?: string) =>
-    createErrorResponse(429, msg, contentType),
+  rateLimitExceeded: (msg = 'Rate Limit Exceeded', contentType?: string) => createErrorResponse(429, msg, contentType),
 
-  maintenance: (msg = 'Service Under Maintenance', contentType?: string) =>
-    createErrorResponse(503, msg, contentType),
+  maintenance: (msg = 'Service Under Maintenance', contentType?: string) => createErrorResponse(503, msg, contentType),
 
   // Helper to create custom error with any status code
-  custom: (statusCode: number, msg: string, contentType?: string) =>
-    createErrorResponse(statusCode, msg, contentType),
+  custom: (statusCode: number, msg: string, contentType?: string) => createErrorResponse(statusCode, msg, contentType),
 };
 
-export function createResponse(
-  statusCode: number,
-  data?: unknown,
-  contentType: string = CONTENT_TYPES.JSON
-): Response {
+export function createResponse(statusCode: number, data?: unknown, contentType: string = CONTENT_TYPES.JSON): Response {
   const body = contentType === CONTENT_TYPES.JSON ? stringifyData(data) : data;
 
   return new Response(body as string, {
@@ -238,7 +190,6 @@ export const protectedRoute = async <TTypes extends VectorTypes = DefaultVectorT
   request: VectorRequest<TTypes>,
   responseContentType?: string
 ) => {
-  // Get the Vector instance to access the protected handler
   const vector = getVectorInstance();
 
   const protectedHandler = vector.getProtectedHandler();
@@ -250,25 +201,24 @@ export const protectedRoute = async <TTypes extends VectorTypes = DefaultVectorT
     const authUser = await protectedHandler(request as any);
     request.authUser = authUser as GetAuthType<TTypes>;
   } catch (error) {
-    throw APIError.unauthorized(
-      error instanceof Error ? error.message : 'Authentication failed',
-      responseContentType
-    );
+    throw APIError.unauthorized(error instanceof Error ? error.message : 'Authentication failed', responseContentType);
   }
 };
 
-export interface ApiOptions {
+export interface ApiOptions<TSchemaDef extends RouteSchemaDefinition | undefined = RouteSchemaDefinition | undefined> {
   auth?: boolean;
   expose?: boolean;
   rawRequest?: boolean;
+  validate?: boolean;
   rawResponse?: boolean;
   cache?: CacheOptions | number | null;
   responseContentType?: string;
+  schema?: TSchemaDef;
 }
 
-export function api<TTypes extends VectorTypes = DefaultVectorTypes>(
+export function api<TTypes extends VectorTypes = DefaultVectorTypes, TValidatedInput = undefined>(
   options: ApiOptions,
-  fn: (request: VectorRequest<TTypes>) => Promise<unknown>
+  fn: (request: VectorRequest<TTypes, TValidatedInput>) => Promise<unknown> | unknown
 ) {
   const {
     auth = false,
@@ -278,32 +228,42 @@ export function api<TTypes extends VectorTypes = DefaultVectorTypes>(
     responseContentType = CONTENT_TYPES.JSON,
   } = options;
 
-  // For backward compatibility with direct route usage (not auto-discovered)
-  // This wrapper is only used when routes are NOT auto-discovered
-  return async (request: IRequest) => {
+  return async (request: Request) => {
+    const req = request as unknown as VectorRequest<TTypes>;
+
     if (!expose) {
       return APIError.forbidden('Forbidden');
     }
 
     try {
       if (auth) {
-        await protectedRoute(request as any as VectorRequest<TTypes>, responseContentType);
+        await protectedRoute(req, responseContentType);
       }
 
-      if (!rawRequest) {
-        await withContent(request);
+      if (!rawRequest && req.method !== 'GET' && req.method !== 'HEAD') {
+        try {
+          const contentType = req.headers.get('content-type');
+          if (contentType?.startsWith('application/json')) {
+            req.content = await req.json();
+          } else if (contentType?.startsWith('application/x-www-form-urlencoded')) {
+            req.content = Object.fromEntries(await req.formData());
+          } else if (contentType?.startsWith('multipart/form-data')) {
+            req.content = await req.formData();
+          } else {
+            req.content = await req.text();
+          }
+        } catch {
+          req.content = null;
+        }
       }
 
-      // Cache handling is now done in the router
-      const result = await fn(request as any as VectorRequest<TTypes>);
+      const result = await fn(req as unknown as VectorRequest<TTypes, TValidatedInput>);
 
       return rawResponse ? result : ApiResponse.success(result, responseContentType);
     } catch (err: unknown) {
-      // Ensure we return a Response object
       if (err instanceof Response) {
         return err;
       }
-      // For non-Response errors, wrap them
       return APIError.internalServerError(String(err), responseContentType);
     }
   };

package/src/middleware/manager.ts

@@ -19,6 +19,8 @@ export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes>
   }
 
   async executeBefore(request: VectorRequest<TTypes>): Promise<VectorRequest<TTypes> | Response> {
+    if (this.beforeHandlers.length === 0) return request;
+
     let currentRequest = request;
 
     for (const handler of this.beforeHandlers) {
@@ -35,6 +37,8 @@ export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes>
   }
 
   async executeFinally(response: Response, request: VectorRequest<TTypes>): Promise<Response> {
+    if (this.finallyHandlers.length === 0) return response;
+
     let currentResponse = response;
 
     for (const handler of this.finallyHandlers) {