fragment-ts 1.0.2 → 1.0.3

package/src/web/application.ts

@@ -0,0 +1,348 @@
+import express, { Express, Request, Response, NextFunction } from "express";
+import helmet from "helmet";
+import cors from "cors";
+import compression from "compression";
+import * as fs from "fs";
+import * as path from "path";
+import { DIContainer } from "../core/container/di-container";
+import { MetadataStorage } from "../core/metadata/metadata-storage";
+import { METADATA_KEYS } from "../core/metadata/metadata-keys";
+import { ComponentScanner } from "../core/scanner/component-scanner";
+
+export class FragmentWebApplication {
+  private app: Express;
+  private container: DIContainer;
+  private metadataStorage: MetadataStorage;
+
+  constructor() {
+    this.app = express();
+    this.container = DIContainer.getInstance();
+    this.metadataStorage = MetadataStorage.getInstance();
+    this.setupMiddleware();
+  }
+
+  private setupMiddleware(): void {
+    this.app.use(helmet());
+    this.app.use(cors());
+    this.app.use(compression());
+    this.app.use(express.json());
+    this.app.use(express.urlencoded({ extended: true }));
+  }
+
+  async bootstrap(appClass: any): Promise<void> {
+    const appMetadata = Reflect.getMetadata(
+      METADATA_KEYS.APPLICATION,
+      appClass,
+    );
+
+    // CRITICAL: Scan and load all component files first
+    // This triggers decorator execution
+    if (appMetadata?.autoScan !== false) {
+      console.log("🔍 Scanning for components...");
+      await this.scanComponents();
+    }
+
+    // Now metadata storage will be populated
+    this.discoverAndRegisterComponents();
+    this.registerRoutes();
+
+    const port = appMetadata?.port || 3000;
+    const host = appMetadata?.host || "0.0.0.0";
+
+    this.app.use(this.errorHandler.bind(this));
+
+    this.app.listen(port, host, () => {
+      console.log(`✨ Fragment application running on http://${host}:${port}`);
+    });
+  }
+
+  /**
+   * Detects environment and scans appropriate files
+   */
+  private async scanComponents(): Promise<void> {
+    const cwd = process.cwd();
+    const distExists = fs.existsSync(path.join(cwd, "dist"));
+    const srcExists = fs.existsSync(path.join(cwd, "src"));
+
+    // Determine if we're running TypeScript directly (dev) or compiled JS (prod)
+    const isDevMode = this.isRunningTypeScript();
+
+    if (isDevMode && srcExists) {
+      // Development mode: scan TypeScript source files
+      console.log("   📝 Development mode: scanning TypeScript files");
+      await ComponentScanner.scanSource();
+    } else if (distExists) {
+      // Production mode: scan compiled JavaScript files
+      console.log("   📦 Production mode: scanning compiled files");
+      await ComponentScanner.scan();
+    } else {
+      console.warn("   ⚠️  Warning: No src/ or dist/ directory found");
+    }
+  }
+
+  /**
+   * Detects if we're running TypeScript directly (ts-node or similar)
+   */
+  private isRunningTypeScript(): boolean {
+    // Check if ts-node is in require.extensions
+    if (require.extensions[".ts"]) {
+      return true;
+    }
+
+    // Check if process is running with ts-node or tsx
+    const execPath = process.argv[0];
+    const scriptPath = process.argv[1] || "";
+
+    if (
+      execPath.includes("ts-node") ||
+      execPath.includes("tsx") ||
+      scriptPath.includes("ts-node") ||
+      scriptPath.includes("tsx")
+    ) {
+      return true;
+    }
+
+    // Check if main module has .ts extension
+    if (require.main?.filename.endsWith(".ts")) {
+      return true;
+    }
+
+    // Check NODE_ENV or explicit flag
+    if (process.env.FRAGMENT_DEV_MODE === "true") {
+      return true;
+    }
+
+    return false;
+  }
+
+  private discoverAndRegisterComponents(): void {
+    const classes = this.metadataStorage.getAllClasses();
+
+    // Group by type
+    const grouped = classes.reduce(
+      (acc, cls) => {
+        if (!acc[cls.type]) acc[cls.type] = [];
+        acc[cls.type].push(cls);
+        return acc;
+      },
+      {} as Record<string, any[]>,
+    );
+
+    const total = classes.length;
+    const registered = classes.filter((m) =>
+      this.shouldRegister(m.target),
+    ).length;
+
+    console.log(`\n📦 Discovered ${total} component(s)`);
+
+    Object.entries(grouped).forEach(([type, items]) => {
+      const icon = this.getTypeIcon(type);
+      console.log(`   ${icon} ${items.length} ${type}(s)`);
+    });
+
+    let count = 0;
+    classes.forEach((metadata) => {
+      if (this.shouldRegister(metadata.target)) {
+        if (!this.container.has(metadata.target)) {
+          this.container.register(metadata.target);
+          count++;
+        }
+      }
+    });
+
+    console.log(`   ✓ Registered ${count}/${total} component(s)\n`);
+  }
+
+  private getTypeIcon(type: string): string {
+    const icons: Record<string, string> = {
+      controller: "🎮",
+      service: "⚙️",
+      repository: "💾",
+      injectable: "💉",
+      "auto-configuration": "🔧",
+    };
+    return icons[type] || "📌";
+  }
+
+  private shouldRegister(target: any): boolean {
+    const conditionalClass = Reflect.getMetadata(
+      METADATA_KEYS.CONDITIONAL_ON_CLASS,
+      target,
+    );
+    if (conditionalClass && !this.isClassAvailable(conditionalClass)) {
+      return false;
+    }
+
+    const conditionalMissingBean = Reflect.getMetadata(
+      METADATA_KEYS.CONDITIONAL_ON_MISSING_BEAN,
+      target,
+    );
+    if (conditionalMissingBean && this.container.has(conditionalMissingBean)) {
+      return false;
+    }
+
+    const conditionalProperty = Reflect.getMetadata(
+      METADATA_KEYS.CONDITIONAL_ON_PROPERTY,
+      target,
+    );
+    if (conditionalProperty) {
+      const value = process.env[conditionalProperty.key];
+      if (
+        conditionalProperty.expectedValue !== undefined &&
+        value !== conditionalProperty.expectedValue
+      ) {
+        return false;
+      }
+      if (!value) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  private isClassAvailable(classRef: any): boolean {
+    try {
+      return typeof classRef === "function";
+    } catch {
+      return false;
+    }
+  }
+
+  private registerRoutes(): void {
+    const controllers = this.metadataStorage
+      .getAllClasses()
+      .filter((c) => c.type === "controller");
+
+    if (controllers.length === 0) {
+      console.log("🛣️  No routes to register\n");
+      return;
+    }
+
+    let totalRoutes = 0;
+    console.log(`🛣️  Registering routes...\n`);
+
+    controllers.forEach((controllerMetadata) => {
+      const controller = this.container.resolve(controllerMetadata.target);
+      const basePath = controllerMetadata.path || "";
+      const methods = this.metadataStorage
+        .getAllMethods()
+        .filter((m) => m.target === controllerMetadata.target);
+
+      if (methods.length > 0) {
+        const controllerName = controllerMetadata.target.name;
+        console.log(`   📍 ${controllerName}`);
+
+        methods.forEach((methodMetadata) => {
+          const fullPath = this.normalizePath(basePath + methodMetadata.path);
+          const httpMethod = methodMetadata.method.toLowerCase();
+          const methodColor = this.getMethodColor(httpMethod);
+          const methodIcon = this.getMethodIcon(httpMethod);
+
+          console.log(
+            `      ${methodIcon} ${methodColor}${httpMethod.toUpperCase().padEnd(7)}\x1b[0m ${fullPath}`,
+          );
+          totalRoutes++;
+
+          (this.app as any)[httpMethod](
+            fullPath,
+            async (req: Request, res: Response, next: NextFunction) => {
+              try {
+                const args = this.resolveMethodParameters(
+                  methodMetadata,
+                  req,
+                  res,
+                );
+                const result = await (controller as any)[
+                  methodMetadata.propertyKey
+                ](...args);
+                if (!res.headersSent) {
+                  res.json(result);
+                }
+              } catch (error) {
+                next(error);
+              }
+            },
+          );
+        });
+        console.log("");
+      }
+    });
+
+    console.log(`   ✓ Registered ${totalRoutes} route(s)\n`);
+  }
+
+  private getMethodColor(method: string): string {
+    const colors: Record<string, string> = {
+      get: "\x1b[32m", // Green
+      post: "\x1b[33m", // Yellow
+      put: "\x1b[34m", // Blue
+      delete: "\x1b[31m", // Red
+      patch: "\x1b[35m", // Magenta
+    };
+    return colors[method] || "\x1b[37m"; // White default
+  }
+
+  private getMethodIcon(method: string): string {
+    const icons: Record<string, string> = {
+      get: "🔍",
+      post: "➕",
+      put: "✏️",
+      delete: "🗑️",
+      patch: "🔧",
+    };
+    return icons[method] || "•";
+  }
+
+  private resolveMethodParameters(
+    methodMetadata: any,
+    req: Request,
+    res: Response,
+  ): any[] {
+    const params = methodMetadata.paramMetadata.sort(
+      (a: any, b: any) => a.index - b.index,
+    );
+
+    return params.map((param: any) => {
+      switch (param.type) {
+        case "body":
+          return req.body;
+        case "param":
+          return param.paramName ? req.params[param.paramName] : req.params;
+        case "query":
+          return param.paramName ? req.query[param.paramName] : req.query;
+        case "header":
+          return param.paramName
+            ? req.headers[param.paramName.toLowerCase()]
+            : req.headers;
+        case "req":
+          return req;
+        case "res":
+          return res;
+        default:
+          return undefined;
+      }
+    });
+  }
+
+  private normalizePath(path: string): string {
+    return "/" + path.split("/").filter(Boolean).join("/");
+  }
+
+  private errorHandler(
+    err: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction,
+  ): void {
+    console.error(err.stack);
+    res.status(500).json({
+      error: "Internal Server Error",
+      message: err.message,
+    });
+  }
+
+  getExpressApp(): Express {
+    return this.app;
+  }
+}

package/src/web/interfaces.ts

@@ -0,0 +1,17 @@
+import { Request, Response, NextFunction } from 'express';
+
+export interface Middleware {
+  use(req: Request, res: Response, next: NextFunction): void | Promise<void>;
+}
+
+export interface Guard {
+  canActivate(req: Request): boolean | Promise<boolean>;
+}
+
+export interface Interceptor {
+  intercept(req: Request, res: Response, next: NextFunction): void | Promise<void>;
+}
+
+export interface ExceptionFilter {
+  catch(exception: Error, req: Request, res: Response): void;
+}

package/tsconfig.json

@@ -5,17 +5,19 @@
     "lib": ["ES2020"],
     "outDir": "./dist",
     "rootDir": "./src",
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
+    "moduleResolution": "node",
+    "resolveJsonModule": true,
     "experimentalDecorators": true,
     "emitDecoratorMetadata": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node",
-    "declaration": true,
-    "sourceMap": true
+    "allowSyntheticDefaultImports": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "examples", "tests"]
-}
+  "exclude": ["node_modules", "dist", "**/*.spec.ts"]
+}