fragment-ts 1.0.33 → 1.0.35

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

@@ -120,6 +120,9 @@ export class InitCommand {
       "src/dto",
       "src/repositories",
       "src/middlewares",
+      "src/guards",
+      "src/interceptors",
+      "src/filters",
       "src/config",
     ];
 
@@ -173,14 +176,19 @@ export class InitCommand {
         "migrate:revert": "fragment migrate:revert",
       },
       dependencies: {
-        "fragment-ts": "^1.0.33",
+        "fragment-ts": "^1.0.35",
         "reflect-metadata": "^0.1.13",
+        express: "^4.18.2",
       },
       devDependencies: {
         typescript: "^5.3.3",
         "@types/node": "^20.10.5",
+        "@types/express": "^4.17.21",
         "ts-node": "^10.9.2",
         "tsconfig-paths": "^4.2.0",
+        jest: "^29.7.0",
+        "@types/jest": "^29.5.12",
+        "ts-jest": "^29.1.2",
       },
     };
 
@@ -200,6 +208,7 @@ export class InitCommand {
         experimentalDecorators: true,
         emitDecoratorMetadata: true,
         skipLibCheck: true,
+        sourceMap: true,
       },
       include: ["src/**/*"],
       exclude: ["node_modules", "dist"],
@@ -209,21 +218,32 @@ export class InitCommand {
       spaces: 2,
     });
 
+    // Create fragment.json with proper environment structure
     const fragmentConfig: any = {};
 
     if (features.includes("database")) {
-      const isProd = process.env.NODE_ENV === "production";
-
-      fragmentConfig.database = {
-        type: "sqlite",
-        database: process.env.DATABASE_FILE || "database.sqlite",
-        synchronize: true,
-        logging: false,
-        entities: isProd ? ["dist/**/*.entity.js"] : ["src/**/*.entity.ts"],
-        migrations: isProd
-          ? ["dist/migrations/**/*.js"]
-          : ["src/migrations/**/*.ts"],
-        subscribers: [],
+      fragmentConfig.development = {
+        database: {
+          type: "sqlite",
+          database: process.env.DATABASE_FILE || "database.sqlite",
+          synchronize: true, // Enable sync in development for easy setup
+          logging: false,
+          entities: ["src/**/*.entity.ts"],
+          migrations: ["src/migrations/**/*.ts"],
+          subscribers: [],
+        },
+      };
+
+      fragmentConfig.production = {
+        database: {
+          type: "sqlite",
+          database: process.env.DATABASE_FILE || "database.sqlite",
+          synchronize: false, // Disable sync in production
+          logging: true,
+          entities: ["dist/**/*.entity.js"],
+          migrations: ["dist/migrations/**/*.js"],
+          subscribers: [],
+        },
       };
     }
 
@@ -243,7 +263,12 @@ ${features.includes("database") ? "DATABASE_FILE=database.sqlite" : ""}
 
     await fs.writeFile(
       path.join(projectPath, ".gitignore"),
-      "node_modules/\ndist/\n.env\n*.sqlite\n",
+      `node_modules/
+dist/
+.env
+*.sqlite
+coverage/
+`,
     );
   }
 
@@ -257,7 +282,7 @@ import { FragmentWebApplication } from 'fragment-ts';
 import { AppController } from './controllers/app.controller';
 
 @FragmentApplication({
-  port: 3000,
+  port: parseInt(process.env.PORT || '3000', 10),
   autoScan: true
 })
 class Application {
@@ -282,12 +307,21 @@ bootstrap().catch(console.error);
     projectPath: string,
   ): Promise<void> {
     const content = `import { Controller, Get } from 'fragment-ts';
+import { AppService } from '../services/app.service';
+import { Autowired } from 'fragment-ts';
 
 @Controller('/api')
 export class AppController {
+  @Autowired()
+  private appService!: AppService;
+
   @Get('/health')
   health() {
-    return { status: 'ok', timestamp: new Date().toISOString() };
+    return {
+      status: 'ok',
+      timestamp: new Date().toISOString(),
+      message: this.appService.getMessage()
+    };
   }
 }
 `;
@@ -320,20 +354,20 @@ export class AppService {
   private static async generateExampleEntity(
     projectPath: string,
   ): Promise<void> {
-    const content = `import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';
+    const content = `import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn } from 'typeorm';
 
 @Entity()
 export class User {
   @PrimaryGeneratedColumn()
   id: number;
 
-  @Column()
+  @Column({ unique: true })
   email: string;
 
   @Column()
   name: string;
 
-  @Column({ type: 'timestamp', default: () => 'CURRENT_TIMESTAMP' })
+  @CreateDateColumn()
   createdAt: Date;
 }
 `;
@@ -345,12 +379,13 @@ export class User {
   }
 
   private static async generateAuthFiles(projectPath: string): Promise<void> {
-    const controllerContent = `import { Controller, Post, Body } from 'fragment-ts';
+    const controllerContent = `import { Controller, Post, Body, Autowired } from 'fragment-ts';
 import { AuthService } from '../services/auth.service';
 
 @Controller('/auth')
 export class AuthController {
-  constructor(private authService: AuthService) {}
+  @Autowired()
+  private authService!: AuthService;
 
   @Post('/login')
   async login(@Body() body: any) {
@@ -365,18 +400,38 @@ export class AuthController {
 `;
 
     const serviceContent = `import { Service } from 'fragment-ts';
-import { AuthModule } from 'fragment-ts';
+import * as bcrypt from 'bcrypt';
+import * as jwt from 'jsonwebtoken';
 
 @Service()
 export class AuthService {
+  private readonly jwtSecret = process.env.JWT_SECRET || 'default-secret-key';
+
   async login(email: string, password: string) {
-    const token = AuthModule.generateToken({ userId: '1', email });
-    return { token };
+    // TODO: Implement actual user lookup and password verification
+    const isValid = await this.validatePassword(password, 'hashed-password-placeholder');
+
+    if (isValid) {
+      const token = jwt.sign({ userId: '1', email }, this.jwtSecret, { expiresIn: '1h' });
+      return { token };
+    }
+
+    throw new Error('Invalid credentials');
   }
 
   async register(userData: any) {
-    const hashedPassword = await AuthModule.hashPassword(userData.password);
-    return { message: 'User registered successfully' };
+    // TODO: Implement actual user creation
+    const hashedPassword = await this.hashPassword(userData.password);
+    return { message: 'User registered successfully', email: userData.email };
+  }
+
+  private async hashPassword(password: string): Promise<string> {
+    const saltRounds = 10;
+    return bcrypt.hash(password, saltRounds);
+  }
+
+  private async validatePassword(password: string, hashedPassword: string): Promise<boolean> {
+    return bcrypt.compare(password, hashedPassword);
   }
 }
 `;
@@ -397,10 +452,9 @@ import { DIContainer } from 'fragment-ts';
 
 describe('AppService', () => {
   let service: AppService;
-  let container: DIContainer;
 
   beforeEach(() => {
-    container = DIContainer.getInstance();
+    const container = DIContainer.getInstance();
     container.reset();
     service = container.resolve(AppService);
   });
@@ -411,14 +465,31 @@ describe('AppService', () => {
     expect(message).toBe('Welcome to Fragment Framework!');
     expect(message).toBeTruthy();
     expect(message).toContain('Fragment');
-    // expect(message).toHaveLength(28);
   });
 });
+`;
+
+    const jestConfig = `module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  roots: ['<rootDir>/src'],
+  transform: {
+    '^.+\\\\.tsx?$': 'ts-jest',
+  },
+  testRegex: '(/__tests__/.*|(\\\\.|/)(test|spec))\\\\.tsx?$',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+  collectCoverageFrom: [
+    'src/**/*.{ts,tsx}',
+    '!src/main.ts',
+    '!src/**/*.controller.ts',
+  ],
+};
 `;
 
     const testDir = path.join(projectPath, "src", "test");
     await fs.ensureDir(testDir);
 
     await fs.writeFile(path.join(testDir, "app.spec.ts"), testContent);
+    await fs.writeFile(path.join(projectPath, "jest.config.js"), jestConfig);
   }
 }