archforge-x 1.0.0

package/dist/generators/generator.js

@@ -0,0 +1,342 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProject = generateProject;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+// --- HELPER FUNCTIONS ---
+const writeFile = (root, filePath, content) => {
+    const fullPath = path_1.default.join(root, filePath);
+    fs_extra_1.default.mkdirpSync(path_1.default.dirname(fullPath));
+    fs_extra_1.default.writeFileSync(fullPath, content.trim());
+};
+const getPackageJson = (name, fw, arch, modules) => {
+    const deps = {
+        "dotenv": "^16.0.3",
+    };
+    const devDeps = {
+        "typescript": "^5.0.0",
+        "@types/node": "^20.0.0",
+        "jest": "^29.5.0",
+        "ts-jest": "^29.1.0",
+        "@types/jest": "^29.5.0",
+        "eslint": "^8.0.0",
+        "prettier": "^3.0.0"
+    };
+    if (fw === "nestjs") {
+        Object.assign(deps, {
+            "@nestjs/common": "^10.0.0",
+            "@nestjs/core": "^10.0.0",
+            "@nestjs/platform-express": "^10.0.0",
+            "reflect-metadata": "^0.1.13",
+            "rxjs": "^7.8.0"
+        });
+        Object.assign(devDeps, {
+            "@nestjs/cli": "^10.0.0",
+            "@nestjs/schematics": "^10.0.0",
+            "@nestjs/testing": "^10.0.0"
+        });
+    }
+    else if (fw === "express") {
+        Object.assign(deps, { "express": "^4.18.2", "cors": "^2.8.5" });
+        Object.assign(devDeps, { "@types/express": "^4.17.17", "ts-node-dev": "^2.0.0" });
+    }
+    if (modules.includes("auth"))
+        deps["jsonwebtoken"] = "^9.0.0";
+    if (modules.includes("auth") && fw === "nestjs")
+        deps["@nestjs/jwt"] = "^10.0.0";
+    if (modules.includes("db"))
+        deps["typeorm"] = "^0.3.17";
+    if (modules.includes("cache"))
+        deps["ioredis"] = "^5.3.0";
+    return JSON.stringify({
+        name,
+        version: "0.0.1",
+        scripts: {
+            "start:dev": fw === "nestjs" ? "nest start --watch" : "ts-node-dev src/main.ts",
+            "build": "tsc",
+            "test": "jest"
+        },
+        dependencies: deps,
+        devDependencies: devDeps
+    }, null, 2);
+};
+const getGoMod = (name, fw) => {
+    return `module ${name}
+
+go 1.21
+
+require (
+    ${fw === "gin" ? 'github.com/gin-gonic/gin v1.9.1' : ''}
+    github.com/joho/godotenv v1.5.1
+)`;
+};
+const getRequirementsTxt = (fw, modules) => {
+    const reqs = ["python-dotenv"];
+    if (fw === "django")
+        reqs.push("Django>=4.2");
+    if (fw === "flask")
+        reqs.push("Flask>=2.3");
+    if (modules.includes("db"))
+        reqs.push("psycopg2-binary", "sqlalchemy");
+    if (modules.includes("auth"))
+        reqs.push("PyJWT");
+    return reqs.join("\n");
+};
+const getArchForgeYaml = (name, arch, lang, fw, modules) => {
+    let layers = "";
+    if (arch === "clean") {
+        layers = `
+layers:
+  - name: "domain"
+    path: "src/domain"
+    description: "Enterprise business rules and entities"
+    forbiddenImports: ["application", "infrastructure", "interface-adapters"]
+  
+  - name: "application"
+    path: "src/application"
+    description: "Application business rules and use cases"
+    allowedImports: ["domain"]
+
+  - name: "interface-adapters"
+    path: "src/interface-adapters"
+    description: "Controllers, presenters, and gateways"
+    allowedImports: ["domain", "application"]
+
+  - name: "infrastructure"
+    path: "src/infrastructure"
+    description: "Frameworks, drivers, and external tools"
+    allowedImports: ["domain", "application", "interface-adapters"]
+`;
+    }
+    else if (arch === "ddd") {
+        layers = `
+layers:
+  - name: "domain"
+    path: "src/domain"
+    description: "Core domain logic and aggregates"
+    forbiddenImports: ["application", "infrastructure", "interfaces"]
+
+  - name: "application"
+    path: "src/application"
+    description: "Application services and orchestration"
+    allowedImports: ["domain"]
+
+  - name: "infrastructure"
+    path: "src/infrastructure"
+    description: "Persistence and external service implementations"
+    allowedImports: ["domain", "application"]
+
+  - name: "interfaces"
+    path: "src/interfaces"
+    description: "Web APIs and user interfaces"
+    allowedImports: ["domain", "application"]
+`;
+    }
+    else {
+        // Default layered
+        layers = `
+layers:
+  - name: "core"
+    path: "src/core"
+    description: "Core business logic"
+
+  - name: "services"
+    path: "src/services"
+    allowedImports: ["core"]
+
+  - name: "api"
+    path: "src/api"
+    allowedImports: ["core", "services"]
+`;
+    }
+    return `
+version: "1.0"
+name: "${name} Architecture"
+project:
+  name: "${name}"
+  root: "."
+
+metadata:
+  type: "${arch}"
+  language: "${lang}"
+  framework: "${fw}"
+  modules: ${JSON.stringify(modules)}
+
+${layers.trim()}
+`.trim();
+};
+// --- CONTENT GENERATORS ---
+const generateTsCleanArch = (root, options) => {
+    const fw = options.framework;
+    writeFile(root, "src/domain/entities/user.entity.ts", `
+export class User {
+    constructor(
+        public readonly id: string,
+        public readonly name: string,
+        public readonly email: string,
+        public readonly passwordHash: string
+    ) {}
+}
+    `);
+    writeFile(root, "src/domain/repositories/user.repository.interface.ts", `
+import { User } from "../entities/user.entity";
+
+export interface IUserRepository {
+    save(user: User): Promise<User>;
+    findByEmail(email: string): Promise<User | null>;
+    findById(id: string): Promise<User | null>;
+}
+    `);
+    writeFile(root, "src/application/use-cases/create-user.use-case.ts", `
+import { User } from "../../domain/entities/user.entity";
+import { IUserRepository } from "../../domain/repositories/user.repository.interface";
+
+export class CreateUserUseCase {
+    constructor(private userRepository: IUserRepository) {}
+
+    async execute(name: string, email: string, passwordHash: string): Promise<User> {
+        const existing = await this.userRepository.findByEmail(email);
+        if (existing) throw new Error("User already exists");
+
+        const user = new User(Date.now().toString(), name, email, passwordHash);
+        return await this.userRepository.save(user);
+    }
+}
+    `);
+    if (fw === "express") {
+        writeFile(root, "src/interface-adapters/controllers/user.controller.ts", `
+import { Request, Response } from "express";
+import { CreateUserUseCase } from "../../application/use-cases/create-user.use-case";
+
+export class UserController {
+    constructor(private createUserUseCase: CreateUserUseCase) {}
+
+    async create(req: Request, res: Response) {
+        try {
+            const { name, email, password } = req.body;
+            const user = await this.createUserUseCase.execute(name, email, password);
+            res.status(201).json(user);
+        } catch (e: any) {
+            res.status(400).json({ error: e.message });
+        }
+    }
+}
+        `);
+        writeFile(root, "src/main.ts", `
+import express from "express";
+import { UserController } from "./interface-adapters/controllers/user.controller";
+import { CreateUserUseCase } from "./application/use-cases/create-user.use-case";
+import { InMemoryUserRepository } from "./infrastructure/repositories/in-memory-user.repository";
+
+const app = express();
+app.use(express.json());
+
+const userRepo = new InMemoryUserRepository();
+const createUserUseCase = new CreateUserUseCase(userRepo);
+const userController = new UserController(createUserUseCase);
+
+app.post("/users", (req, res) => userController.create(req, res));
+
+app.listen(3000, () => console.log("🚀 Server running on PORT 3000 (Clean Architecture)"));
+        `);
+    }
+    else if (fw === "nestjs") {
+        writeFile(root, "src/app.module.ts", `
+import { Module } from '@nestjs/common';
+import { UserController } from './interface-adapters/controllers/user.controller';
+import { CreateUserUseCase } from './application/use-cases/create-user.use-case';
+import { InMemoryUserRepository } from './infrastructure/repositories/in-memory-user.repository';
+
+@Module({
+  controllers: [UserController],
+  providers: [
+    { provide: 'IUserRepository', useClass: InMemoryUserRepository },
+    CreateUserUseCase
+  ],
+})
+export class AppModule {}
+        `);
+        writeFile(root, "src/main.ts", `
+import { NestFactory } from '@nestjs/core';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  await app.listen(3000);
+  console.log("🚀 NestJS Server with Clean Architecture running on 3000");
+}
+bootstrap();
+        `);
+    }
+    writeFile(root, "src/infrastructure/repositories/in-memory-user.repository.ts", `
+import { User } from "../../domain/entities/user.entity";
+import { IUserRepository } from "../../domain/repositories/user.repository.interface";
+
+export class InMemoryUserRepository implements IUserRepository {
+    private users: User[] = [];
+    async save(user: User): Promise<User> {
+        this.users.push(user);
+        return user;
+    }
+    async findByEmail(email: string): Promise<User | null> {
+        return this.users.find(u => u.email === email) || null;
+    }
+    async findById(id: string): Promise<User | null> {
+        return this.users.find(u => u.id === id) || null;
+    }
+}
+    `);
+};
+// --- MAIN GENERATOR ---
+async function generateProject(arch, options = {}) {
+    const mode = options.mode || 'standard';
+    const projectName = options.projectName || arch.project.name || "generated-project";
+    const root = path_1.default.resolve(projectName);
+    console.log(chalk_1.default.blueBright(`🚀 Starting project generation in ${mode} mode...`));
+    if (mode === 'professional') {
+        if (!fs_extra_1.default.existsSync(root))
+            fs_extra_1.default.mkdirpSync(root);
+        const lang = options.language || arch.metadata.language;
+        const fw = options.framework || arch.metadata.framework || "";
+        const modules = options.modules || arch.metadata.modules || [];
+        const archStyle = options.architecture || arch.metadata.type;
+        // Config Files
+        if (lang === "ts" || lang === "js") {
+            writeFile(root, "package.json", getPackageJson(projectName, fw, archStyle, modules));
+            writeFile(root, "tsconfig.json", JSON.stringify({
+                compilerOptions: { target: "ES2020", module: "commonjs", outDir: "./dist", rootDir: "./src", strict: true, experimentalDecorators: true, emitDecoratorMetadata: true },
+                exclude: ["node_modules", "dist"]
+            }, null, 2));
+        }
+        else if (lang === "go") {
+            writeFile(root, "go.mod", getGoMod(projectName, fw));
+        }
+        else if (lang === "py") {
+            writeFile(root, "requirements.txt", getRequirementsTxt(fw, modules));
+        }
+        writeFile(root, ".env.example", "PORT=3000\nDB_HOST=localhost\nJWT_SECRET=supersecret");
+        writeFile(root, ".gitignore", "node_modules/\ndist/\n.env\n__pycache__/\n*.exe\nvendor/");
+        writeFile(root, "README.md", `# ${projectName}\nGenerated by ArchForge X\nArchitecture: ${archStyle}`);
+        // Generate archforge.yaml Rules File
+        writeFile(root, "archforge.yaml", getArchForgeYaml(projectName, archStyle, lang, fw, modules));
+        if (lang === "ts" || lang === "js") {
+            generateTsCleanArch(root, options);
+        }
+    }
+    else {
+        // Standard Mode: Just layers and READMEs
+        for (const layer of arch.layers) {
+            const layerPath = path_1.default.resolve(root, layer.path);
+            fs_extra_1.default.mkdirpSync(layerPath);
+            const readmeContent = `# ${layer.name} Layer\n\nPath: ${layer.path}\n\nAllowed Imports: ${layer.allowedImports?.join(", ") || "Any"}\nForbidden Imports: ${layer.forbiddenImports?.join(", ") || "None"}\n`;
+            fs_extra_1.default.writeFileSync(path_1.default.join(layerPath, "README.md"), readmeContent);
+            const baseFileContent = `/**\n * Base file for ${layer.name} layer\n * Generated by ArchForge X\n */\n`;
+            fs_extra_1.default.writeFileSync(path_1.default.join(layerPath, `${layer.name}.ts`), baseFileContent);
+        }
+    }
+    console.log(chalk_1.default.green.bold(`\n✅ Project ${projectName} successfully generated!`));
+}