vector-framework 0.8.1 → 0.9.0

package/src/dev/route-generator.ts

@@ -1,4 +1,4 @@
-import { mkdir, writeFile } from 'node:fs/promises';
+import { promises as fs } from 'node:fs';
 import { dirname, relative } from 'node:path';
 import type { GeneratedRoute } from '../types';
 
@@ -11,7 +11,7 @@ export class RouteGenerator {
 
   async generate(routes: GeneratedRoute[]): Promise<void> {
     const outputDir = dirname(this.outputPath);
-    await mkdir(outputDir, { recursive: true });
+    await fs.mkdir(outputDir, { recursive: true });
 
     const imports: string[] = [];
     const groupedByFile = new Map<string, GeneratedRoute[]>();
@@ -64,7 +64,7 @@ ${routeEntries.join('\n')}
 export default routes;
 `;
 
-    await writeFile(this.outputPath, content, 'utf-8');
+    await fs.writeFile(this.outputPath, content, 'utf-8');
     console.log(`Generated routes file: ${this.outputPath}`);
   }
 

package/src/dev/route-scanner.ts

@@ -1,4 +1,4 @@
-import { readdir, stat } from 'node:fs/promises';
+import { promises as fs } from 'node:fs';
 import { join, relative, resolve, sep } from 'node:path';
 import type { GeneratedRoute } from '../types';
 
@@ -26,11 +26,11 @@ export class RouteScanner {
   }
 
   private async scanDirectory(dir: string, routes: GeneratedRoute[], basePath = ''): Promise<void> {
-    const entries = await readdir(dir);
+    const entries = await fs.readdir(dir);
 
     for (const entry of entries) {
       const fullPath = join(dir, entry);
-      const stats = await stat(fullPath);
+      const stats = await fs.stat(fullPath);
 
       if (stats.isDirectory()) {
         const newBasePath = basePath ? `${basePath}/${entry}` : entry;
@@ -64,7 +64,18 @@ export class RouteScanner {
           for (const [name, value] of Object.entries(module)) {
             if (name === 'default') continue;
 
-            if (Array.isArray(value) && value.length >= 4) {
+            // Check for new RouteDefinition format
+            if (value && typeof value === 'object' && 'entry' in value && 'options' in value && 'handler' in value) {
+              const routeDef = value as any;
+              routes.push({
+                name,
+                path: fullPath,
+                method: routeDef.options.method as string,
+                options: routeDef.options,
+              });
+            }
+            // Legacy RouteEntry format support
+            else if (Array.isArray(value) && value.length >= 4) {
               const [method, , , path] = value;
               routes.push({
                 name,

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

@@ -64,7 +64,7 @@ export interface RouteOptions<TTypes extends VectorTypes = DefaultVectorTypes> {
   method: string;
   path: string;
   auth?: boolean;
-  expose?: boolean;
+  expose?: boolean; // defaults to true
   cache?: CacheOptions | number;
   rawRequest?: boolean;
   rawResponse?: boolean;
@@ -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, '/');
+}