vector-framework 1.0.0 → 1.1.1

package/src/http.ts

@@ -1,26 +1,26 @@
-import { cors, type IRequest, type RouteEntry, withContent } from "itty-router";
-import { CONTENT_TYPES, HTTP_STATUS } from "./constants";
+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,
   VectorRequest,
   VectorTypes,
-} from "./types";
-import { getVectorInstance } from "./core/vector";
+} from './types';
+import { getVectorInstance } from './core/vector';
 
-export interface ProtectedRequest<
-  TTypes extends VectorTypes = DefaultVectorTypes
-> extends IRequest {
+export interface ProtectedRequest<TTypes extends VectorTypes = DefaultVectorTypes>
+  extends IRequest {
   authUser?: GetAuthType<TTypes>;
 }
 
 export const { preflight, corsify } = cors({
-  origin: "*",
+  origin: '*',
   credentials: true,
-  allowHeaders: "Content-Type, Authorization",
-  allowMethods: "GET, POST, PUT, PATCH, DELETE, OPTIONS",
-  exposeHeaders: "Authorization",
+  allowHeaders: 'Content-Type, Authorization',
+  allowMethods: 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+  exposeHeaders: 'Authorization',
   maxAge: 86_400,
 });
 
@@ -29,9 +29,7 @@ interface ExtendedApiOptions extends ApiOptions {
   path: string;
 }
 
-export interface RouteDefinition<
-  TTypes extends VectorTypes = DefaultVectorTypes
-> {
+export interface RouteDefinition<TTypes extends VectorTypes = DefaultVectorTypes> {
   entry: RouteEntry;
   options: ExtendedApiOptions;
   handler: (req: VectorRequest<TTypes>) => Promise<unknown>;
@@ -45,16 +43,7 @@ export function route<TTypes extends VectorTypes = DefaultVectorTypes>(
 
   const entry: RouteEntry = [
     options.method.toUpperCase(),
-    RegExp(
-      `^${
-        options.path
-          .replace(/\/+(\/|$)/g, "$1") // strip double & trailing splash
-          .replace(/(\/?\.?):(\w+)\+/g, "($1(?<$2>*))") // greedy params
-          .replace(/(\/?\.?):(\w+)/g, "($1(?<$2>[^$1/]+?))") // named params and image format
-          .replace(/\./g, "\\.") // dot in path
-          .replace(/(\/?)\*/g, "($1.*)?") // wildcard
-      }/*$`
-    ),
+    buildRouteRegex(options.path),
     [handler],
     options.path,
   ];
@@ -66,24 +55,30 @@ export function route<TTypes extends VectorTypes = DefaultVectorTypes>(
   };
 }
 
+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 {
-  return JSON.stringify(data ?? null, (_key, value) =>
-    typeof value === "bigint" ? value.toString() : value
+  const val = data ?? null;
+  if (!hasBigInt(val)) return JSON.stringify(val);
+  return JSON.stringify(val, (_key, value) =>
+    typeof value === 'bigint' ? value.toString() : value
   );
 }
 
 const ApiResponse = {
-  success: <T>(data: T, contentType?: string) =>
-    createResponse(HTTP_STATUS.OK, data, contentType),
+  success: <T>(data: T, contentType?: string) => createResponse(HTTP_STATUS.OK, data, contentType),
   created: <T>(data: T, contentType?: string) =>
     createResponse(HTTP_STATUS.CREATED, data, contentType),
 };
 
-function createErrorResponse(
-  code: number,
-  message: string,
-  contentType?: string
-): Response {
+function createErrorResponse(code: number, message: string, contentType?: string): Response {
   const errorBody = {
     error: true,
     message,
@@ -96,144 +91,129 @@ function createErrorResponse(
 
 export const APIError = {
   // 4xx Client Errors
-  badRequest: (msg = "Bad Request", contentType?: string) =>
+  badRequest: (msg = 'Bad Request', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.BAD_REQUEST, msg, contentType),
 
-  unauthorized: (msg = "Unauthorized", contentType?: string) =>
+  unauthorized: (msg = 'Unauthorized', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.UNAUTHORIZED, msg, contentType),
 
-  paymentRequired: (msg = "Payment Required", contentType?: string) =>
+  paymentRequired: (msg = 'Payment Required', contentType?: string) =>
     createErrorResponse(402, msg, contentType),
 
-  forbidden: (msg = "Forbidden", contentType?: string) =>
+  forbidden: (msg = 'Forbidden', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.FORBIDDEN, msg, contentType),
 
-  notFound: (msg = "Not Found", contentType?: string) =>
+  notFound: (msg = 'Not Found', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.NOT_FOUND, msg, contentType),
 
-  methodNotAllowed: (msg = "Method Not Allowed", contentType?: string) =>
+  methodNotAllowed: (msg = 'Method Not Allowed', contentType?: string) =>
     createErrorResponse(405, msg, contentType),
 
-  notAcceptable: (msg = "Not Acceptable", contentType?: string) =>
+  notAcceptable: (msg = 'Not Acceptable', contentType?: string) =>
     createErrorResponse(406, msg, contentType),
 
-  requestTimeout: (msg = "Request Timeout", contentType?: string) =>
+  requestTimeout: (msg = 'Request Timeout', contentType?: string) =>
     createErrorResponse(408, msg, contentType),
 
-  conflict: (msg = "Conflict", contentType?: string) =>
+  conflict: (msg = 'Conflict', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.CONFLICT, msg, contentType),
 
-  gone: (msg = "Gone", contentType?: string) =>
-    createErrorResponse(410, msg, contentType),
+  gone: (msg = 'Gone', contentType?: string) => createErrorResponse(410, msg, contentType),
 
-  lengthRequired: (msg = "Length Required", contentType?: string) =>
+  lengthRequired: (msg = 'Length Required', contentType?: string) =>
     createErrorResponse(411, msg, contentType),
 
-  preconditionFailed: (msg = "Precondition Failed", contentType?: string) =>
+  preconditionFailed: (msg = 'Precondition Failed', contentType?: string) =>
     createErrorResponse(412, msg, contentType),
 
-  payloadTooLarge: (msg = "Payload Too Large", contentType?: string) =>
+  payloadTooLarge: (msg = 'Payload Too Large', contentType?: string) =>
     createErrorResponse(413, msg, contentType),
 
-  uriTooLong: (msg = "URI Too Long", contentType?: string) =>
+  uriTooLong: (msg = 'URI Too Long', contentType?: string) =>
     createErrorResponse(414, msg, contentType),
 
-  unsupportedMediaType: (
-    msg = "Unsupported Media Type",
-    contentType?: string
-  ) => createErrorResponse(415, msg, contentType),
+  unsupportedMediaType: (msg = 'Unsupported Media Type', contentType?: string) =>
+    createErrorResponse(415, msg, contentType),
 
-  rangeNotSatisfiable: (msg = "Range Not Satisfiable", contentType?: string) =>
+  rangeNotSatisfiable: (msg = 'Range Not Satisfiable', contentType?: string) =>
     createErrorResponse(416, msg, contentType),
 
-  expectationFailed: (msg = "Expectation Failed", contentType?: string) =>
+  expectationFailed: (msg = 'Expectation Failed', contentType?: string) =>
     createErrorResponse(417, msg, contentType),
 
   imATeapot: (msg = "I'm a teapot", contentType?: string) =>
     createErrorResponse(418, msg, contentType),
 
-  misdirectedRequest: (msg = "Misdirected Request", contentType?: string) =>
+  misdirectedRequest: (msg = 'Misdirected Request', contentType?: string) =>
     createErrorResponse(421, msg, contentType),
 
-  unprocessableEntity: (msg = "Unprocessable Entity", contentType?: string) =>
+  unprocessableEntity: (msg = 'Unprocessable Entity', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.UNPROCESSABLE_ENTITY, msg, contentType),
 
-  locked: (msg = "Locked", contentType?: string) =>
-    createErrorResponse(423, msg, contentType),
+  locked: (msg = 'Locked', contentType?: string) => createErrorResponse(423, msg, contentType),
 
-  failedDependency: (msg = "Failed Dependency", contentType?: string) =>
+  failedDependency: (msg = 'Failed Dependency', contentType?: string) =>
     createErrorResponse(424, msg, contentType),
 
-  tooEarly: (msg = "Too Early", contentType?: string) =>
-    createErrorResponse(425, msg, contentType),
+  tooEarly: (msg = 'Too Early', contentType?: string) => createErrorResponse(425, msg, contentType),
 
-  upgradeRequired: (msg = "Upgrade Required", contentType?: string) =>
+  upgradeRequired: (msg = 'Upgrade Required', contentType?: string) =>
     createErrorResponse(426, msg, contentType),
 
-  preconditionRequired: (msg = "Precondition Required", contentType?: string) =>
+  preconditionRequired: (msg = 'Precondition Required', contentType?: string) =>
     createErrorResponse(428, msg, contentType),
 
-  tooManyRequests: (msg = "Too Many Requests", contentType?: string) =>
+  tooManyRequests: (msg = 'Too Many Requests', contentType?: string) =>
     createErrorResponse(429, msg, contentType),
 
-  requestHeaderFieldsTooLarge: (
-    msg = "Request Header Fields Too Large",
-    contentType?: string
-  ) => createErrorResponse(431, msg, contentType),
+  requestHeaderFieldsTooLarge: (msg = 'Request Header Fields Too Large', contentType?: string) =>
+    createErrorResponse(431, msg, contentType),
 
-  unavailableForLegalReasons: (
-    msg = "Unavailable For Legal Reasons",
-    contentType?: string
-  ) => createErrorResponse(451, msg, contentType),
+  unavailableForLegalReasons: (msg = 'Unavailable For Legal Reasons', contentType?: string) =>
+    createErrorResponse(451, msg, contentType),
 
   // 5xx Server Errors
-  internalServerError: (msg = "Internal Server Error", contentType?: string) =>
+  internalServerError: (msg = 'Internal Server Error', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.INTERNAL_SERVER_ERROR, msg, contentType),
 
-  notImplemented: (msg = "Not Implemented", contentType?: string) =>
+  notImplemented: (msg = 'Not Implemented', contentType?: string) =>
     createErrorResponse(501, msg, contentType),
 
-  badGateway: (msg = "Bad Gateway", contentType?: string) =>
+  badGateway: (msg = 'Bad Gateway', contentType?: string) =>
     createErrorResponse(502, msg, contentType),
 
-  serviceUnavailable: (msg = "Service Unavailable", contentType?: string) =>
+  serviceUnavailable: (msg = 'Service Unavailable', contentType?: string) =>
     createErrorResponse(503, msg, contentType),
 
-  gatewayTimeout: (msg = "Gateway Timeout", contentType?: string) =>
+  gatewayTimeout: (msg = 'Gateway Timeout', contentType?: string) =>
     createErrorResponse(504, msg, contentType),
 
-  httpVersionNotSupported: (
-    msg = "HTTP Version Not Supported",
-    contentType?: string
-  ) => createErrorResponse(505, msg, contentType),
+  httpVersionNotSupported: (msg = 'HTTP Version Not Supported', contentType?: string) =>
+    createErrorResponse(505, msg, contentType),
 
-  variantAlsoNegotiates: (
-    msg = "Variant Also Negotiates",
-    contentType?: string
-  ) => createErrorResponse(506, msg, contentType),
+  variantAlsoNegotiates: (msg = 'Variant Also Negotiates', contentType?: string) =>
+    createErrorResponse(506, msg, contentType),
 
-  insufficientStorage: (msg = "Insufficient Storage", contentType?: string) =>
+  insufficientStorage: (msg = 'Insufficient Storage', contentType?: string) =>
     createErrorResponse(507, msg, contentType),
 
-  loopDetected: (msg = "Loop Detected", contentType?: string) =>
+  loopDetected: (msg = 'Loop Detected', contentType?: string) =>
     createErrorResponse(508, msg, contentType),
 
-  notExtended: (msg = "Not Extended", contentType?: string) =>
+  notExtended: (msg = 'Not Extended', contentType?: string) =>
     createErrorResponse(510, msg, contentType),
 
-  networkAuthenticationRequired: (
-    msg = "Network Authentication Required",
-    contentType?: string
-  ) => createErrorResponse(511, msg, contentType),
+  networkAuthenticationRequired: (msg = 'Network Authentication Required', contentType?: string) =>
+    createErrorResponse(511, msg, contentType),
 
   // Aliases for common use cases
-  invalidArgument: (msg = "Invalid Argument", contentType?: string) =>
+  invalidArgument: (msg = 'Invalid Argument', contentType?: string) =>
     createErrorResponse(HTTP_STATUS.UNPROCESSABLE_ENTITY, msg, contentType),
 
-  rateLimitExceeded: (msg = "Rate Limit Exceeded", contentType?: string) =>
+  rateLimitExceeded: (msg = 'Rate Limit Exceeded', contentType?: string) =>
     createErrorResponse(429, msg, contentType),
 
-  maintenance: (msg = "Service Under Maintenance", contentType?: string) =>
+  maintenance: (msg = 'Service Under Maintenance', contentType?: string) =>
     createErrorResponse(503, msg, contentType),
 
   // Helper to create custom error with any status code
@@ -250,13 +230,11 @@ export function createResponse(
 
   return new Response(body as string, {
     status: statusCode,
-    headers: { "content-type": contentType },
+    headers: { 'content-type': contentType },
   });
 }
 
-export const protectedRoute = async <
-  TTypes extends VectorTypes = DefaultVectorTypes
->(
+export const protectedRoute = async <TTypes extends VectorTypes = DefaultVectorTypes>(
   request: VectorRequest<TTypes>,
   responseContentType?: string
 ) => {
@@ -265,10 +243,7 @@ export const protectedRoute = async <
 
   const protectedHandler = vector.getProtectedHandler();
   if (!protectedHandler) {
-    throw APIError.unauthorized(
-      "Authentication not configured",
-      responseContentType
-    );
+    throw APIError.unauthorized('Authentication not configured', responseContentType);
   }
 
   try {
@@ -276,7 +251,7 @@ export const protectedRoute = async <
     request.authUser = authUser as GetAuthType<TTypes>;
   } catch (error) {
     throw APIError.unauthorized(
-      error instanceof Error ? error.message : "Authentication failed",
+      error instanceof Error ? error.message : 'Authentication failed',
       responseContentType
     );
   }
@@ -307,15 +282,12 @@ export function api<TTypes extends VectorTypes = DefaultVectorTypes>(
   // This wrapper is only used when routes are NOT auto-discovered
   return async (request: IRequest) => {
     if (!expose) {
-      return APIError.forbidden("Forbidden");
+      return APIError.forbidden('Forbidden');
     }
 
     try {
       if (auth) {
-        await protectedRoute(
-          request as any as VectorRequest<TTypes>,
-          responseContentType
-        );
+        await protectedRoute(request as any as VectorRequest<TTypes>, responseContentType);
       }
 
       if (!rawRequest) {
@@ -325,9 +297,7 @@ export function api<TTypes extends VectorTypes = DefaultVectorTypes>(
       // Cache handling is now done in the router
       const result = await fn(request as any as VectorRequest<TTypes>);
 
-      return rawResponse
-        ? result
-        : ApiResponse.success(result, responseContentType);
+      return rawResponse ? result : ApiResponse.success(result, responseContentType);
     } catch (err: unknown) {
       // Ensure we return a Response object
       if (err instanceof Response) {

package/src/index.ts

@@ -1,14 +1,14 @@
 // Public exports for route definitions only
-import { route } from "./http";
+import { route } from './http';
 
 // Export route function for defining routes
 export { route };
 
 // Export utilities for route handlers
-export { APIError, createResponse } from "./http";
+export { APIError, createResponse } from './http';
 
 // Export types for TypeScript users
-export * from "./types";
+export * from './types';
 
 // Note: Vector framework is now config-driven and runs via CLI
 // Usage: Create vector.config.ts and run 'vector dev' or 'vector start'

package/src/middleware/manager.ts

@@ -4,11 +4,9 @@ import type {
   DefaultVectorTypes,
   VectorRequest,
   VectorTypes,
-} from "../types";
+} from '../types';
 
-export class MiddlewareManager<
-  TTypes extends VectorTypes = DefaultVectorTypes
-> {
+export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes> {
   private beforeHandlers: BeforeMiddlewareHandler<TTypes>[] = [];
   private finallyHandlers: AfterMiddlewareHandler<TTypes>[] = [];
 
@@ -20,9 +18,7 @@ export class MiddlewareManager<
     this.finallyHandlers.push(...handlers);
   }
 
-  async executeBefore(
-    request: VectorRequest<TTypes>
-  ): Promise<VectorRequest<TTypes> | Response> {
+  async executeBefore(request: VectorRequest<TTypes>): Promise<VectorRequest<TTypes> | Response> {
     let currentRequest = request;
 
     for (const handler of this.beforeHandlers) {
@@ -38,10 +34,7 @@ export class MiddlewareManager<
     return currentRequest;
   }
 
-  async executeFinally(
-    response: Response,
-    request: VectorRequest<TTypes>
-  ): Promise<Response> {
+  async executeFinally(response: Response, request: VectorRequest<TTypes>): Promise<Response> {
     let currentResponse = response;
 
     for (const handler of this.finallyHandlers) {

package/src/utils/path.ts

@@ -1,9 +1,18 @@
 export function toFileUrl(path: string): string {
-  return process.platform === 'win32'
-    ? `file:///${path.replace(/\\/g, '/')}`
-    : path;
+  return process.platform === 'win32' ? `file:///${path.replace(/\\/g, '/')}` : path;
 }
 
 export function normalizePath(path: string): string {
   return path.replace(/\\/g, '/').replace(/\/+/g, '/');
-}
+}
+
+export function buildRouteRegex(path: string): RegExp {
+  return RegExp(
+    `^${path
+      .replace(/\/+(\/|$)/g, '$1')
+      .replace(/(\/?\.?):(\w+)\+/g, '($1(?<$2>[\\s\\S]+))')
+      .replace(/(\/?\.?):(\w+)/g, '($1(?<$2>[^$1/]+?))')
+      .replace(/\./g, '\\.')
+      .replace(/(\/?)\*/g, '($1.*)?')}/*$`
+  );
+}