fragment-ts 1.0.2 → 1.0.4

package/package.json

@@ -1,46 +1,68 @@
 {
   "name": "fragment-ts",
-  "version": "1.0.2",
-  "description": "TypeScript Backend Framework",
-  "main": "dist/server.js",
+  "version": "1.0.4",
+  "description": "Spring Boot-style framework for TypeScript with Express and TypeORM",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
-    "frg": "./dist/cli/cli.js"
+    "fragment": "./bin/fragment.js",
+    "frg": "./bin/fragment.js"
   },
   "scripts": {
-    "dev": "ts-node-dev --respawn --transpile-only src/server.ts",
     "build": "tsc",
-    "start": "node dist/server.js",
-    "cli": "ts-node src/cli/index.ts"
+    "prepublishOnly": "npm run build",
+    "test": "node dist/testing/runner.js"
   },
+  "keywords": [
+    "framework",
+    "typescript",
+    "express",
+    "typeorm",
+    "spring-boot",
+    "dependency-injection"
+  ],
+  "author": "Fragment Team",
+  "license": "MIT",
   "dependencies": {
-    "express": "^4.18.2",
-    "typeorm": "^0.3.17",
-    "pg": "^8.11.3",
-    "mysql2": "^3.6.0",
-    "sqlite3": "^5.1.6",
-    "dotenv": "^16.3.1",
-    "pino": "^8.15.0",
-    "pino-pretty": "^10.2.0",
-    "reflect-metadata": "^0.1.13",
-    "commander": "^11.0.0",
-    "inquirer": "^9.2.11",
+    "axios": "^1.6.2",
+    "bcryptjs": "^2.4.3",
     "chalk": "^4.1.2",
+    "chokidar": "^3.6.0",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0",
+    "commander": "^11.1.0",
+    "compression": "^1.7.4",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "ejs": "^3.1.9",
+    "express": "^4.18.2",
+    "express-rate-limit": "^7.1.5",
+    "figlet": "^1.9.4",
+    "fs-extra": "^11.1.1",
+    "glob": "^10.3.10",
+    "helmet": "^7.1.0",
+    "inquirer": "^9.2.12",
+    "jsonwebtoken": "^9.0.2",
+    "openai": "^4.20.1",
     "ora": "^5.4.1",
-    "js-yaml": "^4.1.0",
-    "@anthropic-ai/sdk": "^0.9.0",
-    "openai": "^4.20.0",
-    "axios": "^1.6.0",
-    "bcrypt": "^5.1.1"
+    "reflect-metadata": "^0.1.13",
+    "ts-node": "^10.9.2",
+    "typeorm": "^0.3.17"
   },
   "devDependencies": {
-    "@types/express": "^4.17.17",
-    "@types/node": "^20.5.0",
-    "@types/inquirer": "^9.0.3",
-    "@types/js-yaml": "^4.0.5",
-    "@types/bcrypt": "^5.0.0",
-    "@types/jsonwebtoken": "^9.0.3",
-    "ts-node-dev": "^2.0.0",
-    "ts-node": "^10.9.1",
-    "typescript": "^5.1.6"
+    "@types/bcryptjs": "^2.4.6",
+    "@types/chokidar": "^2.1.3",
+    "@types/compression": "^1.7.5",
+    "@types/cors": "^2.8.17",
+    "@types/express": "^4.17.21",
+    "@types/figlet": "^1.7.0",
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.9",
+    "@types/jsonwebtoken": "^9.0.5",
+    "@types/node": "^20.10.5",
+    "typescript": "^5.3.3"
+  },
+  "engines": {
+    "node": ">=16.0.0"
   }
-}
+}

package/src/ai/ai.module.ts

@@ -0,0 +1,110 @@
+import OpenAI from 'openai';
+import axios from 'axios';
+
+export interface AIMessage {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface AICompletionOptions {
+  model?: string;
+  temperature?: number;
+  maxTokens?: number;
+  stream?: boolean;
+}
+
+export class AIModule {
+  private openaiClient?: OpenAI;
+  private azureClient?: any;
+  private ollamaBaseUrl?: string;
+
+  constructor(config?: {
+    openaiKey?: string;
+    azureKey?: string;
+    azureEndpoint?: string;
+    ollamaUrl?: string;
+  }) {
+    if (config?.openaiKey) {
+      this.openaiClient = new OpenAI({ apiKey: config.openaiKey });
+    }
+    
+    if (config?.azureKey && config?.azureEndpoint) {
+      this.azureClient = { key: config.azureKey, endpoint: config.azureEndpoint };
+    }
+    
+    if (config?.ollamaUrl) {
+      this.ollamaBaseUrl = config.ollamaUrl;
+    }
+  }
+
+  async complete(messages: AIMessage[], options: AICompletionOptions = {}): Promise<string> {
+    if (this.openaiClient) {
+      return this.completeWithOpenAI(messages, options);
+    }
+    
+    if (this.ollamaBaseUrl) {
+      return this.completeWithOllama(messages, options);
+    }
+    
+    throw new Error('No AI provider configured');
+  }
+
+  private async completeWithOpenAI(messages: AIMessage[], options: AICompletionOptions): Promise<string> {
+    const response = await this.openaiClient!.chat.completions.create({
+      model: options.model || 'gpt-3.5-turbo',
+      messages: messages as any,
+      temperature: options.temperature || 0.7,
+      max_tokens: options.maxTokens || 1000
+    });
+    
+    return response.choices[0]?.message?.content || '';
+  }
+
+  private async completeWithOllama(messages: AIMessage[], options: AICompletionOptions): Promise<string> {
+    const response = await axios.post(`${this.ollamaBaseUrl}/api/chat`, {
+      model: options.model || 'llama2',
+      messages,
+      stream: false
+    });
+    
+    return response.data.message.content;
+  }
+
+  async streamComplete(
+    messages: AIMessage[], 
+    options: AICompletionOptions,
+    onChunk: (chunk: string) => void
+  ): Promise<void> {
+    if (!this.openaiClient) {
+      throw new Error('Streaming only supported with OpenAI');
+    }
+
+    const stream = await this.openaiClient.chat.completions.create({
+      model: options.model || 'gpt-3.5-turbo',
+      messages: messages as any,
+      temperature: options.temperature || 0.7,
+      max_tokens: options.maxTokens || 1000,
+      stream: true
+    });
+
+    for await (const chunk of stream) {
+      const content = chunk.choices[0]?.delta?.content || '';
+      if (content) {
+        onChunk(content);
+      }
+    }
+  }
+
+  async embeddings(texts: string[]): Promise<number[][]> {
+    if (!this.openaiClient) {
+      throw new Error('Embeddings only supported with OpenAI');
+    }
+
+    const response = await this.openaiClient.embeddings.create({
+      model: 'text-embedding-ada-002',
+      input: texts
+    });
+
+    return response.data.map(item => item.embedding);
+  }
+}

package/src/auth/auth.module.ts

@@ -0,0 +1,77 @@
+import * as jwt from "jsonwebtoken";
+import * as bcrypt from "bcryptjs";
+import { Request, Response, NextFunction } from "express";
+
+export interface JWTPayload {
+  userId: string;
+  email?: string;
+  roles?: string[];
+  [key: string]: any;
+}
+
+export class AuthModule {
+  private static jwtSecret: jwt.Secret =
+    process.env.JWT_SECRET || "fragment-secret-key";
+  private static jwtExpiration: string = process.env.JWT_EXPIRATION || "1d";
+
+  static async hashPassword(password: string): Promise<string> {
+    return bcrypt.hash(password, 10);
+  }
+
+  static async comparePassword(
+    password: string,
+    hash: string,
+  ): Promise<boolean> {
+    return bcrypt.compare(password, hash);
+  }
+
+  static generateToken(payload: JWTPayload): string {
+    const options: jwt.SignOptions = {
+      expiresIn: this.jwtExpiration as unknown as jwt.SignOptions["expiresIn"],
+    };
+
+    return jwt.sign(payload, this.jwtSecret, options);
+  }
+
+  static verifyToken(token: string): JWTPayload {
+    return jwt.verify(token, this.jwtSecret) as JWTPayload;
+  }
+
+  static authMiddleware() {
+    return (req: Request, res: Response, next: NextFunction) => {
+      const authHeader = req.headers.authorization;
+
+      if (!authHeader || !authHeader.startsWith("Bearer ")) {
+        return res.status(401).json({ error: "Unauthorized" });
+      }
+
+      const token = authHeader.substring(7);
+
+      try {
+        const payload = AuthModule.verifyToken(token);
+        (req as any).user = payload;
+        next();
+      } catch (error) {
+        return res.status(401).json({ error: "Invalid token" });
+      }
+    };
+  }
+
+  static roleGuard(...roles: string[]) {
+    return (req: Request, res: Response, next: NextFunction) => {
+      const user = (req as any).user;
+
+      if (!user || !user.roles) {
+        return res.status(403).json({ error: "Forbidden" });
+      }
+
+      const hasRole = roles.some((role) => user.roles.includes(role));
+
+      if (!hasRole) {
+        return res.status(403).json({ error: "Insufficient permissions" });
+      }
+
+      next();
+    };
+  }
+}

package/src/cli/commands/build.command.ts

@@ -1,24 +1,134 @@
-
-import { execSync } from 'child_process';
-import { CLILogger } from '../utils/logger';
+import { Command } from "commander";
+import { execSync } from "child_process";
+import * as path from "path";
+import * as fs from "fs";
+import chalk from "chalk";
+import ora from "ora";
 
 export class BuildCommand {
-  async execute(): Promise<void> {
-    CLILogger.title('🔨 Building Fragment Application');
+  static register(program: Command): void {
+    program
+      .command("build")
+      .description("Build the project for production")
+      .option("--minify", "Minify output")
+      .option("--analyze", "Analyze bundle size")
+      .action(async (options) => {
+        await BuildCommand.execute(options);
+      });
+  }
 
-    const spinner = CLILogger.spinner('Compiling TypeScript...');
+  static async execute(options: any): Promise<void> {
+    const spinner = ora("Building project...").start();
 
     try {
-      execSync('tsc', { stdio: 'pipe' });
-      spinner.succeed('Build completed successfully');
+      // Find TypeScript compiler
+      const tscPath = this.findTsc();
+
+      if (!tscPath) {
+        spinner.fail("TypeScript compiler not found");
+        console.log(chalk.yellow("\nInstall TypeScript:"));
+        console.log(chalk.cyan("  npm install --save-dev typescript"));
+        process.exit(1);
+      }
+
+      // Check if tsconfig.json exists
+      const tsconfigPath = path.join(process.cwd(), "tsconfig.json");
+      if (!fs.existsSync(tsconfigPath)) {
+        spinner.fail("tsconfig.json not found");
+        console.log(
+          chalk.yellow("\nCreate a tsconfig.json file in your project root"),
+        );
+        process.exit(1);
+      }
 
-      CLILogger.success('Output directory: ./dist');
-      CLILogger.info('Run "node dist/server.js" to start the production server');
+      // Run TypeScript compiler
+      spinner.text = "Compiling TypeScript...";
+      execSync(`"${tscPath}"`, {
+        cwd: process.cwd(),
+        stdio: "inherit",
+      });
 
+      spinner.succeed("Build completed successfully!");
+
+      if (options.analyze) {
+        console.log(chalk.blue("\n📊 Bundle Analysis:"));
+        this.analyzeBuild();
+      }
+
+      console.log(chalk.green("\n✨ Build output: dist/"));
     } catch (error: any) {
-      spinner.fail('Build failed');
-      CLILogger.error(error.message);
+      spinner.fail("Build failed");
+      console.error(chalk.red(error.message || error));
       process.exit(1);
     }
   }
-}
+
+  private static findTsc(): string | null {
+    // Try local node_modules first
+    const localTsc = path.join(process.cwd(), "node_modules", ".bin", "tsc");
+
+    if (fs.existsSync(localTsc)) {
+      return localTsc;
+    }
+
+    // Try with platform-specific extension
+    const localTscCmd = path.join(
+      process.cwd(),
+      "node_modules",
+      ".bin",
+      process.platform === "win32" ? "tsc.cmd" : "tsc",
+    );
+
+    if (fs.existsSync(localTscCmd)) {
+      return localTscCmd;
+    }
+
+    // Try global TypeScript
+    try {
+      execSync("tsc --version", { stdio: "ignore" });
+      return "tsc"; // Global tsc is available
+    } catch {
+      // Not available globally
+    }
+
+    return null;
+  }
+
+  private static analyzeBuild(): void {
+    const distPath = path.join(process.cwd(), "dist");
+
+    if (!fs.existsSync(distPath)) {
+      console.log(chalk.yellow("  No dist/ directory found"));
+      return;
+    }
+
+    let totalSize = 0;
+    let fileCount = 0;
+
+    const calculateSize = (dir: string) => {
+      const files = fs.readdirSync(dir);
+
+      files.forEach((file) => {
+        const filePath = path.join(dir, file);
+        const stat = fs.statSync(filePath);
+
+        if (stat.isDirectory()) {
+          calculateSize(filePath);
+        } else {
+          totalSize += stat.size;
+          fileCount++;
+        }
+      });
+    };
+
+    calculateSize(distPath);
+
+    const sizeInKB = (totalSize / 1024).toFixed(2);
+    const sizeInMB = (totalSize / 1024 / 1024).toFixed(2);
+
+    console.log(`  Files: ${fileCount}`);
+    console.log(
+      `  Size: ${totalSize > 1024 * 1024 ? sizeInMB + " MB" : sizeInKB + " KB"}`,
+    );
+  }
+}