archforge-x 1.0.2 → 1.0.4

package/dist/generators/base.js

@@ -0,0 +1,166 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseGenerator = void 0;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+class BaseGenerator {
+    async generate(arch, options) {
+        const projectName = options.projectName || arch.project.name || "generated-project";
+        const root = path_1.default.resolve(projectName);
+        console.log(chalk_1.default.blueBright(`🚀 Starting ${this.getGeneratorName()} generation for ${projectName}...`));
+        if (!fs_extra_1.default.existsSync(root)) {
+            fs_extra_1.default.mkdirpSync(root);
+        }
+        await this.generateProjectStructure(root, arch, options);
+        this.generateArchForgeConfig(root, arch, options);
+        // Ensure all layer and custom folders exist
+        const config = js_yaml_1.default.load(fs_extra_1.default.readFileSync(path_1.default.join(root, "archforge.yaml"), "utf8"));
+        if (config.layers) {
+            for (const layer of Object.values(config.layers)) {
+                this.createDir(root, layer.path);
+            }
+        }
+        if (config.customStructure?.enabled && config.customStructure.folders) {
+            for (const folder of config.customStructure.folders) {
+                this.createDir(root, folder.path);
+            }
+        }
+        if (options.modules?.includes("docker")) {
+            console.log(chalk_1.default.blue("   🐳 Generating Docker configuration..."));
+            this.generateDocker(root, options);
+        }
+        if (options.modules?.includes("ci")) {
+            console.log(chalk_1.default.blue("   👷 Generating CI/CD workflows..."));
+            this.generateCI(root, options);
+        }
+        this.generateProductionDocs(root, arch, options);
+        this.ensureNoEmptyFolders(root);
+        console.log(chalk_1.default.green.bold(`\n✅ ${this.getGeneratorName()} project ${projectName} successfully generated!`));
+    }
+    generateProductionDocs(root, arch, options) {
+        this.writeFile(root, "docs/architecture.md", `
+# Architecture Guide
+
+This project follows the **${options.architecture || arch.metadata.type}** architecture style.
+
+## Layers
+${arch.layers.map(l => `- **${l.name}**: ${l.description || 'Located at ' + l.path}`).join('\n')}
+
+## Rules
+- **Layer Boundaries**: Enforced via \`archforge.yaml\`.
+- **Naming**: Services must end with \`Service\`, Repositories with \`Repository\`.
+        `);
+        this.writeFile(root, "docs/database.md", `
+# Database Guide
+
+- **ORM**: ${options.orm || arch.metadata.orm}
+- **Database**: ${options.database || arch.metadata.database}
+
+## Setup
+1. Ensure Docker is running.
+2. Run \`docker-compose up -d\`.
+3. Migrations are handled automatically on startup.
+        `);
+        this.writeFile(root, "docs/caching.md", `
+# Caching Guide
+
+This project implements a first-class caching layer.
+
+## Strategies
+- **Redis**: Used in production for distributed caching.
+- **In-Memory**: Used for local development or as a fallback.
+
+## Usage
+Inject the \`ICache\` interface into your services.
+        `);
+        this.writeFile(root, "docs/rules.md", `
+# ArchForge Rules
+
+This project uses \`archforge.yaml\` to enforce architectural standards.
+
+## How to Sync
+Run \`npx archforge sync\` to validate the structure.
+        `);
+    }
+    ensureNoEmptyFolders(root) {
+        const scan = (dir) => {
+            const files = fs_extra_1.default.readdirSync(dir);
+            if (files.length === 0) {
+                this.writeFile(dir, "README.md", `# ${path_1.default.basename(dir)}\n\nThis folder is part of the architectural structure.`);
+            }
+            else {
+                for (const file of files) {
+                    const fullPath = path_1.default.join(dir, file);
+                    if (fs_extra_1.default.statSync(fullPath).isDirectory()) {
+                        scan(fullPath);
+                    }
+                }
+            }
+        };
+        scan(path_1.default.join(root, "src"));
+    }
+    generateArchForgeConfig(root, arch, options) {
+        const config = {
+            architecture: options.architecture || arch.metadata.type,
+            stack: options.framework || arch.metadata.framework,
+            orm: options.orm || arch.metadata.orm || "none",
+            database: options.database || arch.metadata.database || "none",
+            layers: arch.layers.length > 0 ? arch.layers.reduce((acc, layer) => {
+                acc[layer.name] = {
+                    path: layer.path,
+                    canImport: layer.canImport || layer.allowedImports || []
+                };
+                return acc;
+            }, {}) : this.getDefaultLayers(options.architecture || "clean"),
+            naming: arch.naming || {
+                services: "*Service",
+                repositories: "*Repository",
+                controllers: "*Controller"
+            },
+            rules: arch.rules || {
+                forbidDirectDbAccess: true,
+                forbidFrameworkInDomain: true,
+                enforceLayerBoundaries: true
+            },
+            customStructure: arch.customStructure || {
+                enabled: true,
+                folders: [
+                    { path: "src/modules" },
+                    { path: "src/shared" }
+                ]
+            }
+        };
+        this.writeFile(root, "archforge.yaml", `
+# ArchForge X Configuration
+# This file is the single source of truth for your project architecture.
+${require('js-yaml').dump(config)}
+        `.trim());
+    }
+    getDefaultLayers(arch) {
+        if (arch === "clean") {
+            return {
+                domain: { path: "src/domain", canImport: [] },
+                application: { path: "src/application", canImport: ["domain"] },
+                infrastructure: { path: "src/infrastructure", canImport: ["application", "domain"] },
+                presentation: { path: "src/presentation", canImport: ["application"] }
+            };
+        }
+        // Add other defaults as needed
+        return {};
+    }
+    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());
+    }
+    createDir(root, dirPath) {
+        const fullPath = path_1.default.join(root, dirPath);
+        fs_extra_1.default.mkdirpSync(fullPath);
+    }
+}
+exports.BaseGenerator = BaseGenerator;

package/dist/generators/generator.js

@@ -4,339 +4,42 @@ var __importDefault = (this && this.__importDefault) || function (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 ---
+const registry_1 = require("./registry");
+// Import Generators
+const express_1 = require("./node/express");
+const nestjs_1 = require("./node/nestjs");
+const nextjs_1 = require("./node/nextjs");
+const fastapi_1 = require("./python/fastapi");
+const django_1 = require("./python/django");
+const gin_1 = require("./go/gin");
+// Register Generators
+registry_1.GeneratorRegistry.register("ts:express", new express_1.ExpressGenerator());
+registry_1.GeneratorRegistry.register("js:express", new express_1.ExpressGenerator());
+registry_1.GeneratorRegistry.register("ts:nestjs", new nestjs_1.NestJSGenerator());
+registry_1.GeneratorRegistry.register("js:nestjs", new nestjs_1.NestJSGenerator()); // NestJS usually TS, but just in case
+registry_1.GeneratorRegistry.register("ts:nextjs", new nextjs_1.NextJSGenerator()); // Next.js
+registry_1.GeneratorRegistry.register("js:nextjs", new nextjs_1.NextJSGenerator());
+registry_1.GeneratorRegistry.register("py:fastapi", new fastapi_1.FastAPIGenerator());
+registry_1.GeneratorRegistry.register("py:django", new django_1.DjangoGenerator());
+registry_1.GeneratorRegistry.register("py", new fastapi_1.FastAPIGenerator()); // Default Python
+registry_1.GeneratorRegistry.register("go:gin", new gin_1.GoGinGenerator());
+registry_1.GeneratorRegistry.register("go", new gin_1.GoGinGenerator()); // Default Go
 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);
-        }
+    const lang = options.language || arch.metadata.language || "ts";
+    const fw = options.framework || arch.metadata.framework || "";
+    console.log(chalk_1.default.blueBright(`🔍 Looking for generator for ${lang} + ${fw}...`));
+    const generator = registry_1.GeneratorRegistry.getGenerator(lang, fw);
+    if (!generator) {
+        console.error(chalk_1.default.red(`❌ No generator found for language: ${lang} and framework: ${fw}`));
+        console.log(chalk_1.default.yellow(`Available generators: ${registry_1.GeneratorRegistry.listGenerators().join(", ")}`));
+        return;
+    }
+    try {
+        await generator.generate(arch, options);
+    }
+    catch (error) {
+        console.error(chalk_1.default.red("❌ Error during generation:"), error);
+        throw error;
     }
-    console.log(chalk_1.default.green.bold(`\n✅ Project ${projectName} successfully generated!`));
 }