fragment-ts 1.0.0

package/dist/cli/commands/config.command.js

@@ -0,0 +1,284 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfigCommand = void 0;
+const path = __importStar(require("path"));
+const yaml = __importStar(require("js-yaml"));
+const logger_1 = require("../utils/logger");
+const file_generator_1 = require("../utils/file-generator");
+const inquirer_1 = __importDefault(require("inquirer"));
+class ConfigCommand {
+    async execute(target) {
+        switch (target) {
+            case 'ai':
+                await this.configureAI();
+                break;
+            case 'db':
+            case 'database':
+                await this.configureDatabase();
+                break;
+            case 'show':
+                await this.showConfig();
+                break;
+            default:
+                logger_1.CLILogger.error(`Unknown config target: ${target}`);
+                logger_1.CLILogger.info('Available targets: ai, db, show');
+        }
+    }
+    async configureAI() {
+        logger_1.CLILogger.title('🤖 OpenAI Configuration');
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'password',
+                name: 'apiKey',
+                message: 'OpenAI API Key:',
+                mask: '*',
+                validate: (input) => {
+                    if (!input || !input.startsWith('sk-')) {
+                        return 'Please enter a valid OpenAI API key (starts with sk-)';
+                    }
+                    return true;
+                }
+            },
+            {
+                type: 'list',
+                name: 'model',
+                message: 'Default model:',
+                choices: [
+                    'gpt-4-turbo',
+                    'gpt-4',
+                    'gpt-3.5-turbo',
+                    'claude-sonnet-4-5-20250929',
+                    'claude-opus-4-1-20250514'
+                ],
+                default: 'gpt-4'
+            },
+            {
+                type: 'confirm',
+                name: 'saveToEnv',
+                message: 'Save API key to .env file?',
+                default: true
+            }
+        ]);
+        const configPath = path.join(process.cwd(), 'config/fragment.yaml');
+        if (!file_generator_1.FileGenerator.fileExists(configPath)) {
+            logger_1.CLILogger.error('fragment.yaml not found. Are you in a Fragment project?');
+            return;
+        }
+        try {
+            const configContent = file_generator_1.FileGenerator.readFile(configPath);
+            const config = yaml.load(configContent);
+            if (!config.openai) {
+                config.openai = {};
+            }
+            config.openai.apiKey = answers.saveToEnv ? '${OPENAI_API_KEY}' : answers.apiKey;
+            config.openai.model = answers.model;
+            file_generator_1.FileGenerator.writeFile(configPath, yaml.dump(config));
+            if (answers.saveToEnv) {
+                const envPath = path.join(process.cwd(), '.env');
+                let envContent = '';
+                if (file_generator_1.FileGenerator.fileExists(envPath)) {
+                    envContent = file_generator_1.FileGenerator.readFile(envPath);
+                }
+                // Update or add OPENAI_API_KEY
+                if (envContent.includes('OPENAI_API_KEY=')) {
+                    envContent = envContent.replace(/OPENAI_API_KEY=.*/, `OPENAI_API_KEY=${answers.apiKey}`);
+                }
+                else {
+                    envContent += `\nOPENAI_API_KEY=${answers.apiKey}`;
+                }
+                file_generator_1.FileGenerator.writeFile(envPath, envContent);
+                logger_1.CLILogger.success('API key saved to .env file');
+            }
+            logger_1.CLILogger.success('OpenAI configuration updated');
+            logger_1.CLILogger.table({
+                'Model': answers.model,
+                'API Key': answers.saveToEnv ? 'Stored in .env' : 'Stored in config'
+            });
+        }
+        catch (error) {
+            logger_1.CLILogger.error(`Failed to update configuration: ${error.message}`);
+        }
+    }
+    async configureDatabase() {
+        logger_1.CLILogger.title('🗄️  Database Configuration');
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: 'Database type:',
+                choices: ['postgres', 'mysql', 'sqlite', 'mongodb']
+            },
+            {
+                type: 'input',
+                name: 'host',
+                message: 'Host:',
+                default: 'localhost',
+                when: (answers) => answers.type !== 'sqlite'
+            },
+            {
+                type: 'input',
+                name: 'port',
+                message: 'Port:',
+                default: (answers) => {
+                    const ports = { postgres: 5432, mysql: 3306, mongodb: 27017 };
+                    return ports[answers.type] || 5432;
+                },
+                when: (answers) => answers.type !== 'sqlite'
+            },
+            {
+                type: 'input',
+                name: 'username',
+                message: 'Username:',
+                default: (answers) => answers.type === 'postgres' ? 'postgres' : 'root',
+                when: (answers) => answers.type !== 'sqlite'
+            },
+            {
+                type: 'password',
+                name: 'password',
+                message: 'Password:',
+                mask: '*',
+                when: (answers) => answers.type !== 'sqlite'
+            },
+            {
+                type: 'input',
+                name: 'database',
+                message: 'Database name:',
+                default: 'fragment_db'
+            },
+            {
+                type: 'confirm',
+                name: 'synchronize',
+                message: 'Auto-synchronize schema? (not recommended for production)',
+                default: true
+            }
+        ]);
+        const configPath = path.join(process.cwd(), 'config/fragment.yaml');
+        try {
+            const configContent = file_generator_1.FileGenerator.readFile(configPath);
+            const config = yaml.load(configContent);
+            config.database = {
+                type: answers.type,
+                ...(answers.type !== 'sqlite' && {
+                    host: '${DB_HOST:' + answers.host + '}',
+                    port: '${DB_PORT:' + answers.port + '}',
+                    username: '${DB_USERNAME:' + answers.username + '}',
+                    password: '${DB_PASSWORD}'
+                }),
+                database: '${DB_DATABASE:' + answers.database + '}',
+                synchronize: answers.synchronize,
+                logging: false
+            };
+            file_generator_1.FileGenerator.writeFile(configPath, yaml.dump(config));
+            // Update .env
+            const envPath = path.join(process.cwd(), '.env');
+            let envContent = file_generator_1.FileGenerator.fileExists(envPath) ? file_generator_1.FileGenerator.readFile(envPath) : '';
+            const envVars = {
+                DB_HOST: answers.host,
+                DB_PORT: answers.port,
+                DB_USERNAME: answers.username,
+                DB_PASSWORD: answers.password,
+                DB_DATABASE: answers.database
+            };
+            Object.entries(envVars).forEach(([key, value]) => {
+                if (value !== undefined) {
+                    if (envContent.includes(`${key}=`)) {
+                        envContent = envContent.replace(new RegExp(`${key}=.*`), `${key}=${value}`);
+                    }
+                    else {
+                        envContent += `\n${key}=${value}`;
+                    }
+                }
+            });
+            file_generator_1.FileGenerator.writeFile(envPath, envContent.trim());
+            logger_1.CLILogger.success('Database configuration updated');
+            logger_1.CLILogger.table({
+                'Type': answers.type,
+                'Host': answers.host || 'N/A',
+                'Database': answers.database,
+                'Synchronize': answers.synchronize ? 'Yes' : 'No'
+            });
+        }
+        catch (error) {
+            logger_1.CLILogger.error(`Failed to update configuration: ${error.message}`);
+        }
+    }
+    async showConfig() {
+        logger_1.CLILogger.title('📋 Current Configuration');
+        const configPath = path.join(process.cwd(), 'config/fragment.yaml');
+        if (!file_generator_1.FileGenerator.fileExists(configPath)) {
+            logger_1.CLILogger.error('fragment.yaml not found');
+            return;
+        }
+        try {
+            const configContent = file_generator_1.FileGenerator.readFile(configPath);
+            const config = yaml.load(configContent);
+            logger_1.CLILogger.section('Application');
+            logger_1.CLILogger.table({
+                'Name': config.app?.name || 'N/A',
+                'Port': config.app?.port || 'N/A',
+                'Environment': config.app?.env || 'N/A'
+            });
+            logger_1.CLILogger.section('Database');
+            logger_1.CLILogger.table({
+                'Type': config.database?.type || 'N/A',
+                'Host': config.database?.host || 'N/A',
+                'Database': config.database?.database || 'N/A',
+                'Synchronize': config.database?.synchronize ? 'Yes' : 'No'
+            });
+            if (config.openai) {
+                logger_1.CLILogger.section('OpenAI');
+                logger_1.CLILogger.table({
+                    'Model': config.openai.model || 'N/A',
+                    'API Key': config.openai.apiKey?.includes('${') ? 'From environment' : 'Configured'
+                });
+            }
+            if (config.auth) {
+                logger_1.CLILogger.section('Authentication');
+                logger_1.CLILogger.table({
+                    'Token Expiry': config.auth.tokenExpiry || 'N/A',
+                    'Session Expiry': config.auth.sessionExpiry || 'N/A'
+                });
+            }
+        }
+        catch (error) {
+            logger_1.CLILogger.error(`Failed to read configuration: ${error.message}`);
+        }
+    }
+}
+exports.ConfigCommand = ConfigCommand;

package/dist/cli/commands/generate.command.d.ts

@@ -0,0 +1,8 @@
+export declare class GenerateCommand {
+    execute(type: string, name?: string): Promise<void>;
+    private generateController;
+    private generateService;
+    private generateRepository;
+    private generateEntity;
+    private generateResource;
+}

package/dist/cli/commands/generate.command.js

@@ -0,0 +1,180 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GenerateCommand = void 0;
+const path = __importStar(require("path"));
+const logger_1 = require("../utils/logger");
+const file_generator_1 = require("../utils/file-generator");
+const inquirer_1 = __importDefault(require("inquirer"));
+const controller_template_1 = require("../templates/controller.template");
+const entity_template_1 = require("../templates/entity.template");
+const repository_template_1 = require("../templates/repository.template");
+const service_template_1 = require("../templates/service.template");
+class GenerateCommand {
+    async execute(type, name) {
+        if (!name) {
+            const answer = await inquirer_1.default.prompt([
+                {
+                    type: 'input',
+                    name: 'name',
+                    message: `Enter ${type} name:`,
+                    validate: (input) => {
+                        if (!input)
+                            return 'Name is required';
+                        return true;
+                    }
+                }
+            ]);
+            name = answer.name;
+        }
+        const pascalName = file_generator_1.FileGenerator.toPascalCase(name);
+        const kebabName = file_generator_1.FileGenerator.toKebabCase(name);
+        switch (type) {
+            case 'controller':
+                await this.generateController(pascalName, kebabName);
+                break;
+            case 'service':
+                await this.generateService(pascalName, kebabName);
+                break;
+            case 'repository':
+                await this.generateRepository(pascalName, kebabName);
+                break;
+            case 'entity':
+                await this.generateEntity(pascalName, kebabName);
+                break;
+            case 'resource':
+                await this.generateResource(pascalName, kebabName);
+                break;
+            default:
+                logger_1.CLILogger.error(`Unknown type: ${type}`);
+                logger_1.CLILogger.info('Available types: controller, service, repository, entity, resource');
+        }
+    }
+    async generateController(name, fileName) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'route',
+                message: 'Route path:',
+                default: `/api/${fileName}s`
+            }
+        ]);
+        const filePath = path.join(process.cwd(), 'src/controllers', `${fileName}.controller.ts`);
+        if (file_generator_1.FileGenerator.fileExists(filePath)) {
+            logger_1.CLILogger.error(`Controller ${name} already exists`);
+            return;
+        }
+        const content = (0, controller_template_1.controllerTemplate)(name, answers.route);
+        file_generator_1.FileGenerator.writeFile(filePath, content);
+        logger_1.CLILogger.success(`Controller created: src/controllers/${fileName}.controller.ts`);
+        logger_1.CLILogger.info(`Route: ${answers.route}`);
+    }
+    async generateService(name, fileName) {
+        const filePath = path.join(process.cwd(), 'src/services', `${fileName}.service.ts`);
+        if (file_generator_1.FileGenerator.fileExists(filePath)) {
+            logger_1.CLILogger.error(`Service ${name} already exists`);
+            return;
+        }
+        const content = (0, service_template_1.serviceTemplate)(name);
+        file_generator_1.FileGenerator.writeFile(filePath, content);
+        logger_1.CLILogger.success(`Service created: src/services/${fileName}.service.ts`);
+    }
+    async generateRepository(name, fileName) {
+        const answers = await inquirer_1.default.prompt([
+            {
+                type: 'input',
+                name: 'entity',
+                message: 'Entity name:',
+                default: name.replace('Repository', '')
+            }
+        ]);
+        const filePath = path.join(process.cwd(), 'src/repositories', `${fileName}.repository.ts`);
+        if (file_generator_1.FileGenerator.fileExists(filePath)) {
+            logger_1.CLILogger.error(`Repository ${name} already exists`);
+            return;
+        }
+        const content = (0, repository_template_1.repositoryTemplate)(name, answers.entity);
+        file_generator_1.FileGenerator.writeFile(filePath, content);
+        logger_1.CLILogger.success(`Repository created: src/repositories/${fileName}.repository.ts`);
+    }
+    async generateEntity(name, fileName) {
+        const filePath = path.join(process.cwd(), 'src/entities', `${fileName}.entity.ts`);
+        if (file_generator_1.FileGenerator.fileExists(filePath)) {
+            logger_1.CLILogger.error(`Entity ${name} already exists`);
+            return;
+        }
+        const content = (0, entity_template_1.entityTemplate)(name);
+        file_generator_1.FileGenerator.writeFile(filePath, content);
+        logger_1.CLILogger.success(`Entity created: src/entities/${fileName}.entity.ts`);
+    }
+    async generateResource(name, fileName) {
+        logger_1.CLILogger.title(`🔷 Generating resource: ${name}`);
+        const spinner = logger_1.CLILogger.spinner('Generating files...');
+        try {
+            // Generate entity
+            const entityPath = path.join(process.cwd(), 'src/entities', `${fileName}.entity.ts`);
+            file_generator_1.FileGenerator.writeFile(entityPath, (0, entity_template_1.entityTemplate)(name));
+            spinner.text = 'Entity created...';
+            // Generate repository
+            const repoPath = path.join(process.cwd(), 'src/repositories', `${fileName}.repository.ts`);
+            file_generator_1.FileGenerator.writeFile(repoPath, (0, repository_template_1.repositoryTemplate)(name + 'Repository', name));
+            spinner.text = 'Repository created...';
+            // Generate service
+            const servicePath = path.join(process.cwd(), 'src/services', `${fileName}.service.ts`);
+            file_generator_1.FileGenerator.writeFile(servicePath, (0, service_template_1.serviceTemplate)(name + 'Service'));
+            spinner.text = 'Service created...';
+            // Generate controller
+            const controllerPath = path.join(process.cwd(), 'src/controllers', `${fileName}.controller.ts`);
+            file_generator_1.FileGenerator.writeFile(controllerPath, (0, controller_template_1.controllerTemplate)(name + 'Controller', `/api/${fileName}s`));
+            spinner.text = 'Controller created...';
+            spinner.succeed('Resource generated successfully');
+            logger_1.CLILogger.box('📦 Generated Files', [
+                `Entity: src/entities/${fileName}.entity.ts`,
+                `Repository: src/repositories/${fileName}.repository.ts`,
+                `Service: src/services/${fileName}.service.ts`,
+                `Controller: src/controllers/${fileName}.controller.ts`
+            ]);
+            logger_1.CLILogger.info(`\nRoute available at: /api/${fileName}s`);
+        }
+        catch (error) {
+            spinner.fail('Failed to generate resource');
+            logger_1.CLILogger.error(error.message);
+        }
+    }
+}
+exports.GenerateCommand = GenerateCommand;

package/dist/cli/commands/init.command.d.ts

@@ -0,0 +1,7 @@
+export declare class InitCommand {
+    execute(projectName?: string): Promise<void>;
+    private getDatabaseConfig;
+    private getEnvTemplate;
+    private generateReadme;
+    private copyFrameworkCore;
+}