vector-framework 0.8.2 → 0.9.1

package/src/http.ts

@@ -33,13 +33,19 @@ interface ExtendedApiOptions extends ApiOptions {
   path: string;
 }
 
+export interface RouteDefinition<TTypes extends VectorTypes = DefaultVectorTypes> {
+  entry: RouteEntry;
+  options: ExtendedApiOptions;
+  handler: (req: VectorRequest<TTypes>) => Promise<unknown>;
+}
+
 export function route<TTypes extends VectorTypes = DefaultVectorTypes>(
   options: ExtendedApiOptions,
   fn: (req: VectorRequest<TTypes>) => Promise<unknown>
-): RouteEntry {
+): RouteDefinition<TTypes> {
   const handler = api(options, fn);
 
-  return [
+  const entry: RouteEntry = [
     options.method.toUpperCase(),
     RegExp(
       `^${
@@ -54,6 +60,12 @@ export function route<TTypes extends VectorTypes = DefaultVectorTypes>(
     [handler],
     options.path,
   ];
+
+  return {
+    entry,
+    options,
+    handler: fn
+  };
 }
 
 function stringifyData(data: unknown): string {
@@ -251,9 +263,11 @@ export const protectedRoute = async <
   responseContentType?: string
 ) => {
   // Get the Vector instance to access the protected handler
-  const vector = (await import("./core/vector")).default;
+  const { getVectorInstance } = await import("./core/vector");
+  const vector = getVectorInstance();
 
-  if (!vector.protected) {
+  const protectedHandler = vector.getProtectedHandler();
+  if (!protectedHandler) {
     throw APIError.unauthorized(
       "Authentication not configured",
       responseContentType
@@ -261,7 +275,7 @@ export const protectedRoute = async <
   }
 
   try {
-    const authUser = await vector.protected(request as any);
+    const authUser = await protectedHandler(request as any);
     request.authUser = authUser as GetAuthType<TTypes>;
   } catch (error) {
     throw APIError.unauthorized(
@@ -292,6 +306,8 @@ 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) => {
     if (!expose) {
       return APIError.forbidden("Forbidden");

package/src/index.ts

@@ -1,19 +1,14 @@
-import { Vector } from './core/vector';
-import { route } from './http';
-import type { DefaultVectorTypes, VectorTypes } from './types';
+// Public exports for route definitions only
+import { route } from "./http";
 
-export { route, Vector };
-export { AuthManager } from './auth/protected';
-export { CacheManager } from './cache/manager';
-export { APIError, createResponse } from './http';
-export { MiddlewareManager } from './middleware/manager';
-export * from './types';
+// Export route function for defining routes
+export { route };
 
-// Create a typed Vector instance with custom types
-export function createVector<TTypes extends VectorTypes = DefaultVectorTypes>(): Vector<TTypes> {
-  return Vector.getInstance<TTypes>();
-}
+// Export utilities for route handlers
+export { APIError, createResponse } from "./http";
 
-// Default vector instance with default AuthUser type
-const vector = Vector.getInstance();
-export default vector;
+// Export types for TypeScript users
+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,9 +4,11 @@ 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>[] = [];
 
@@ -18,7 +20,9 @@ export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes>
     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) {
@@ -34,7 +38,10 @@ export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes>
     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) {
@@ -50,4 +57,9 @@ export class MiddlewareManager<TTypes extends VectorTypes = DefaultVectorTypes>
     manager.finallyHandlers = [...this.finallyHandlers];
     return manager;
   }
+
+  clear(): void {
+    this.beforeHandlers = [];
+    this.finallyHandlers = [];
+  }
 }

package/src/types/index.ts

@@ -72,6 +72,7 @@ export interface RouteOptions<TTypes extends VectorTypes = DefaultVectorTypes> {
   metadata?: GetMetadataType<TTypes>;
 }
 
+// Legacy config interface - will be deprecated
 export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   port?: number;
   hostname?: string;
@@ -84,6 +85,49 @@ export interface VectorConfig<TTypes extends VectorTypes = DefaultVectorTypes> {
   autoDiscover?: boolean;
 }
 
+// New config-driven schema
+export interface VectorConfigSchema<TTypes extends VectorTypes = DefaultVectorTypes> {
+  // Server configuration
+  server?: {
+    port?: number;
+    hostname?: string;
+    reusePort?: boolean;
+    development?: boolean;
+  };
+  
+  // Routes configuration
+  routes?: {
+    dir?: string;
+    autoDiscover?: boolean;
+  };
+  
+  // Middleware configuration - supports both file paths and direct functions
+  middleware?: {
+    before?: string[];
+    after?: string[];
+  };
+  
+  // Direct middleware functions (preferred approach)
+  before?: BeforeMiddlewareHandler<TTypes>[];
+  after?: AfterMiddlewareHandler<TTypes>[];
+  
+  // Handler configuration - supports both file paths and direct functions
+  handlers?: {
+    auth?: string;
+    cache?: string;
+  };
+  
+  // Direct handler functions (preferred approach)
+  auth?: ProtectedHandler<TTypes>;
+  cache?: CacheHandler;
+  
+  // CORS configuration
+  cors?: CorsOptions | boolean;
+  
+  // Custom types for TypeScript
+  types?: VectorTypes;
+}
+
 export interface CorsOptions {
   origin?: string | string[] | ((origin: string) => boolean);
   credentials?: boolean;

package/src/utils/path.ts

@@ -0,0 +1,9 @@
+export function toFileUrl(path: string): string {
+  return process.platform === 'win32'
+    ? `file:///${path.replace(/\\/g, '/')}`
+    : path;
+}
+
+export function normalizePath(path: string): string {
+  return path.replace(/\\/g, '/').replace(/\/+/g, '/');
+}