katax-cli 0.1.0

package/dist/commands/add-endpoint.d.ts

@@ -0,0 +1,6 @@
+interface AddEndpointOptions {
+    method?: string;
+    path?: string;
+}
+export declare function addEndpointCommand(name: string, options?: AddEndpointOptions): Promise<void>;
+export {};

package/dist/commands/add-endpoint.js

@@ -0,0 +1,229 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import path from 'path';
+import { success, error, warning, gray, title, info } from '../utils/logger.js';
+import { fileExists, writeFile } from '../utils/file-utils.js';
+import { generateValidator } from '../generators/validator-generator.js';
+import { generateController } from '../generators/controller-generator.js';
+import { generateHandler } from '../generators/handler-generator.js';
+import { generateRoute } from '../generators/route-generator.js';
+import { updateMainRouter } from '../generators/router-updater.js';
+export async function addEndpointCommand(name, options = {}) {
+    title(`🎯 Add Endpoint: ${name}`);
+    // Check if we're in a Katax project
+    if (!fileExists(path.join(process.cwd(), 'package.json'))) {
+        error('Not in a project directory!');
+        gray('Run this command from your project root\n');
+        process.exit(1);
+    }
+    // Check if katax-core is installed
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    const packageJson = JSON.parse(await import('fs').then(fs => fs.promises.readFile(packageJsonPath, 'utf-8')));
+    const hasKataxCore = packageJson.dependencies?.['katax-core'];
+    if (!hasKataxCore) {
+        warning('katax-core is not installed in this project');
+        const { install } = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'install',
+                message: 'Would you like to install katax-core?',
+                default: true
+            }
+        ]);
+        if (!install) {
+            error('Cannot create endpoint without validation library');
+            process.exit(1);
+        }
+        // Install katax-core
+        const spinner = ora('Installing katax-core...').start();
+        const { execa } = await import('execa');
+        await execa('npm', ['install', 'katax-core'], { cwd: process.cwd() });
+        spinner.succeed('katax-core installed');
+    }
+    // Interactive prompts
+    const answers = await inquirer.prompt([
+        {
+            type: 'list',
+            name: 'method',
+            message: 'HTTP Method:',
+            choices: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE'],
+            default: options.method?.toUpperCase() || 'POST',
+            when: !options.method
+        },
+        {
+            type: 'input',
+            name: 'path',
+            message: 'Route path:',
+            default: `/api/${name.toLowerCase()}`,
+            when: !options.path,
+            validate: (input) => {
+                if (!input.startsWith('/')) {
+                    return 'Path must start with /';
+                }
+                return true;
+            }
+        },
+        {
+            type: 'confirm',
+            name: 'addValidation',
+            message: 'Add validation?',
+            default: true
+        }
+    ]);
+    const config = {
+        name,
+        method: (options.method?.toUpperCase() || answers.method),
+        path: options.path || answers.path,
+        addValidation: answers.addValidation,
+        fields: [],
+        addAsyncValidators: false,
+        dbOperations: []
+    };
+    // If validation is enabled, collect fields
+    if (config.addValidation && config.method !== 'GET' && config.method !== 'DELETE') {
+        info('\nDefine request body fields:');
+        let addingFields = true;
+        while (addingFields) {
+            const fieldAnswers = await inquirer.prompt([
+                {
+                    type: 'input',
+                    name: 'fieldName',
+                    message: 'Field name (press Enter to finish):',
+                    validate: (input) => {
+                        if (input && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input)) {
+                            return 'Field name must be a valid identifier';
+                        }
+                        return true;
+                    }
+                }
+            ]);
+            if (!fieldAnswers.fieldName) {
+                addingFields = false;
+                break;
+            }
+            const fieldConfig = await inquirer.prompt([
+                {
+                    type: 'list',
+                    name: 'type',
+                    message: `Type for "${fieldAnswers.fieldName}":`,
+                    choices: ['string', 'number', 'boolean', 'date', 'email', 'array', 'object']
+                },
+                {
+                    type: 'confirm',
+                    name: 'required',
+                    message: 'Required?',
+                    default: true
+                }
+            ]);
+            const field = {
+                name: fieldAnswers.fieldName,
+                type: fieldConfig.type,
+                required: fieldConfig.required,
+                rules: []
+            };
+            // Add type-specific rules
+            if (fieldConfig.type === 'string' || fieldConfig.type === 'email') {
+                const stringRules = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'minLength',
+                        message: 'Minimum length (press Enter to skip):',
+                        validate: (input) => !input || !isNaN(parseInt(input)) || 'Must be a number'
+                    },
+                    {
+                        type: 'input',
+                        name: 'maxLength',
+                        message: 'Maximum length (press Enter to skip):',
+                        validate: (input) => !input || !isNaN(parseInt(input)) || 'Must be a number'
+                    }
+                ]);
+                if (stringRules.minLength) {
+                    field.rules.push({ type: 'minLength', value: parseInt(stringRules.minLength) });
+                }
+                if (stringRules.maxLength) {
+                    field.rules.push({ type: 'maxLength', value: parseInt(stringRules.maxLength) });
+                }
+            }
+            if (fieldConfig.type === 'number') {
+                const numberRules = await inquirer.prompt([
+                    {
+                        type: 'input',
+                        name: 'min',
+                        message: 'Minimum value (press Enter to skip):',
+                        validate: (input) => !input || !isNaN(parseFloat(input)) || 'Must be a number'
+                    },
+                    {
+                        type: 'input',
+                        name: 'max',
+                        message: 'Maximum value (press Enter to skip):',
+                        validate: (input) => !input || !isNaN(parseFloat(input)) || 'Must be a number'
+                    }
+                ]);
+                if (numberRules.min) {
+                    field.rules.push({ type: 'min', value: parseFloat(numberRules.min) });
+                }
+                if (numberRules.max) {
+                    field.rules.push({ type: 'max', value: parseFloat(numberRules.max) });
+                }
+            }
+            config.fields.push(field);
+            gray(`  ✓ Added field: ${field.name} (${field.type})`);
+        }
+        if (config.fields.length > 0) {
+            const { addAsync } = await inquirer.prompt([
+                {
+                    type: 'confirm',
+                    name: 'addAsync',
+                    message: 'Add async validators (e.g., unique email)?',
+                    default: false
+                }
+            ]);
+            config.addAsyncValidators = addAsync;
+        }
+    }
+    // Generate files
+    const spinner = ora('Generating endpoint files...').start();
+    try {
+        const basePath = path.join(process.cwd(), 'src', 'api', name.toLowerCase());
+        // Generate validator
+        if (config.addValidation) {
+            const validatorPath = path.join(basePath, `${name.toLowerCase()}.validator.ts`);
+            const validatorContent = generateValidator(config);
+            await writeFile(validatorPath, validatorContent);
+            spinner.text = `Generated ${name.toLowerCase()}.validator.ts`;
+        }
+        // Generate controller
+        const controllerPath = path.join(basePath, `${name.toLowerCase()}.controller.ts`);
+        const controllerContent = generateController(config);
+        await writeFile(controllerPath, controllerContent);
+        spinner.text = `Generated ${name.toLowerCase()}.controller.ts`;
+        // Generate handler
+        const handlerPath = path.join(basePath, `${name.toLowerCase()}.handler.ts`);
+        const handlerContent = generateHandler(config);
+        await writeFile(handlerPath, handlerContent);
+        spinner.text = `Generated ${name.toLowerCase()}.handler.ts`;
+        // Generate route
+        const routePath = path.join(basePath, `${name.toLowerCase()}.routes.ts`);
+        const routeContent = generateRoute(config);
+        await writeFile(routePath, routeContent);
+        spinner.text = `Generated ${name.toLowerCase()}.routes.ts`;
+        // Update main router
+        await updateMainRouter(name, config);
+        spinner.succeed('Endpoint files generated');
+        success(`\n✨ Endpoint "${name}" created successfully!\n`);
+        info('Generated files:');
+        gray(`  src/api/${name.toLowerCase()}/${name.toLowerCase()}.validator.ts`);
+        gray(`  src/api/${name.toLowerCase()}/${name.toLowerCase()}.controller.ts`);
+        gray(`  src/api/${name.toLowerCase()}/${name.toLowerCase()}.handler.ts`);
+        gray(`  src/api/${name.toLowerCase()}/${name.toLowerCase()}.routes.ts`);
+        gray(`  Updated: src/api/routes.ts\n`);
+        gray(`  Updated: src/api/routes.ts\n`);
+        info('Test your endpoint:');
+        gray(`  ${config.method} ${config.path}\n`);
+    }
+    catch (err) {
+        spinner.fail('Failed to generate endpoint');
+        error(err instanceof Error ? err.message : 'Unknown error');
+        process.exit(1);
+    }
+}

package/dist/commands/generate-crud.d.ts

@@ -0,0 +1,5 @@
+interface GenerateCrudOptions {
+    auth?: boolean;
+}
+export declare function generateCrudCommand(resourceName: string, options?: GenerateCrudOptions): Promise<void>;
+export {};

package/dist/commands/generate-crud.js

@@ -0,0 +1,282 @@
+import inquirer from 'inquirer';
+import ora from 'ora';
+import path from 'path';
+import { success, error, warning, gray, title, info } from '../utils/logger.js';
+import { fileExists, writeFile, toPascalCase, toCamelCase } from '../utils/file-utils.js';
+export async function generateCrudCommand(resourceName, options = {}) {
+    title(`🔧 Generate CRUD: ${resourceName}`);
+    // Check if we're in a project
+    if (!fileExists(path.join(process.cwd(), 'package.json'))) {
+        error('Not in a project directory!');
+        gray('Run this command from your project root\n');
+        process.exit(1);
+    }
+    // Interactive prompts
+    const answers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'tableName',
+            message: 'Database table name:',
+            default: `${resourceName.toLowerCase()}s`
+        },
+        {
+            type: 'confirm',
+            name: 'addAuth',
+            message: 'Require authentication for endpoints?',
+            default: options.auth !== false
+        }
+    ]);
+    info('\nDefine fields for the resource:');
+    const fields = [];
+    let addingFields = true;
+    while (addingFields) {
+        const fieldAnswers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'fieldName',
+                message: 'Field name (press Enter to finish):',
+                validate: (input) => {
+                    if (input && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input)) {
+                        return 'Field name must be a valid identifier';
+                    }
+                    return true;
+                }
+            }
+        ]);
+        if (!fieldAnswers.fieldName) {
+            addingFields = false;
+            break;
+        }
+        const fieldConfig = await inquirer.prompt([
+            {
+                type: 'list',
+                name: 'type',
+                message: `Type for "${fieldAnswers.fieldName}":`,
+                choices: ['string', 'number', 'boolean', 'date', 'email']
+            },
+            {
+                type: 'confirm',
+                name: 'required',
+                message: 'Required?',
+                default: true
+            }
+        ]);
+        fields.push({
+            name: fieldAnswers.fieldName,
+            type: fieldConfig.type,
+            required: fieldConfig.required,
+            rules: []
+        });
+        gray(`  ✓ Added field: ${fieldAnswers.fieldName} (${fieldConfig.type})`);
+    }
+    if (fields.length === 0) {
+        error('At least one field is required to generate CRUD');
+        process.exit(1);
+    }
+    const config = {
+        resourceName,
+        tableName: answers.tableName,
+        fields,
+        addAuth: answers.addAuth
+    };
+    const spinner = ora('Generating CRUD endpoints...').start();
+    try {
+        await generateCRUDFiles(config);
+        spinner.succeed('CRUD endpoints generated');
+        success(`\n✨ CRUD for "${resourceName}" created successfully!\n`);
+        info('Generated endpoints:');
+        gray(`  GET    /api/${resourceName.toLowerCase()}     - List all`);
+        gray(`  GET    /api/${resourceName.toLowerCase()}/:id - Get one`);
+        gray(`  POST   /api/${resourceName.toLowerCase()}     - Create`);
+        gray(`  PUT    /api/${resourceName.toLowerCase()}/:id - Update`);
+        gray(`  DELETE /api/${resourceName.toLowerCase()}/:id - Delete\n`);
+        if (config.addAuth) {
+            warning('Remember to implement authentication middleware!');
+        }
+    }
+    catch (err) {
+        spinner.fail('Failed to generate CRUD');
+        error(err instanceof Error ? err.message : 'Unknown error');
+        process.exit(1);
+    }
+}
+async function generateCRUDFiles(config) {
+    const { resourceName, fields } = config;
+    const basePath = path.join(process.cwd(), 'src', 'api', resourceName.toLowerCase());
+    // Generate validator with all operations
+    const validatorContent = generateCRUDValidator(config);
+    await writeFile(path.join(basePath, `${resourceName.toLowerCase()}.validator.ts`), validatorContent);
+    // Generate controller with CRUD operations
+    const controllerContent = generateCRUDController(config);
+    await writeFile(path.join(basePath, `${resourceName.toLowerCase()}.controller.ts`), controllerContent);
+    // Generate routes with all CRUD endpoints
+    const routesContent = generateCRUDRoutes(config);
+    await writeFile(path.join(basePath, `${resourceName.toLowerCase()}.routes.ts`), routesContent);
+    // Update main router
+    const { updateMainRouter } = await import('../generators/router-updater.js');
+    await updateMainRouter(resourceName, {
+        name: resourceName,
+        method: 'GET',
+        path: `/api/${resourceName.toLowerCase()}`,
+        addValidation: true,
+        fields,
+        addAsyncValidators: false
+    });
+}
+function generateCRUDValidator(config) {
+    const { resourceName, fields } = config;
+    const pascalName = toPascalCase(resourceName);
+    const camelName = toCamelCase(resourceName);
+    let content = `import { k, kataxInfer } from 'katax-core';\n\n`;
+    content += `// ==================== SCHEMAS ====================\n\n`;
+    // Create schema
+    content += `export const create${pascalName}Schema = k.object({\n`;
+    fields.forEach((field, index) => {
+        const isLast = index === fields.length - 1;
+        let fieldSchema = field.type === 'email' ? 'k.string().email()' : `k.${field.type}()`;
+        if (!field.required)
+            fieldSchema += '.optional()';
+        content += `  ${field.name}: ${fieldSchema}${isLast ? '' : ','}\n`;
+    });
+    content += `});\n\n`;
+    // Update schema (all fields optional)
+    content += `export const update${pascalName}Schema = k.object({\n`;
+    fields.forEach((field, index) => {
+        const isLast = index === fields.length - 1;
+        const fieldSchema = field.type === 'email' ? 'k.string().email().optional()' : `k.${field.type}().optional()`;
+        content += `  ${field.name}: ${fieldSchema}${isLast ? '' : ','}\n`;
+    });
+    content += `});\n\n`;
+    content += `export type Create${pascalName}Data = kataxInfer<typeof create${pascalName}Schema>;\n`;
+    content += `export type Update${pascalName}Data = kataxInfer<typeof update${pascalName}Schema>;\n`;
+    return content;
+}
+function generateCRUDController(config) {
+    const { resourceName, tableName } = config;
+    const pascalName = toPascalCase(resourceName);
+    const camelName = toCamelCase(resourceName);
+    return `import { Create${pascalName}Data, Update${pascalName}Data } from './${resourceName.toLowerCase()}.validator.js';
+import { ControllerResult, createSuccessResult, createErrorResult } from '../../shared/api.utils.js';
+
+// List all ${camelName}s
+export async function list${pascalName}s(): Promise<ControllerResult<any[]>> {
+  try {
+    // TODO: Implement database query
+    // const result = await pool.query('SELECT * FROM ${tableName}');
+    
+    const mock${pascalName}s = [
+      { id: 1, name: 'Sample ${pascalName} 1', createdAt: new Date().toISOString() },
+      { id: 2, name: 'Sample ${pascalName} 2', createdAt: new Date().toISOString() }
+    ];
+
+    return createSuccessResult('${pascalName}s retrieved', mock${pascalName}s);
+  } catch (error) {
+    return createErrorResult('Failed to list ${camelName}s', error instanceof Error ? error.message : 'Unknown error', 500);
+  }
+}
+
+// Get single ${camelName}
+export async function get${pascalName}(id: string): Promise<ControllerResult<any>> {
+  try {
+    // TODO: Implement database query
+    // const result = await pool.query('SELECT * FROM ${tableName} WHERE id = $1', [id]);
+    
+    const mock${pascalName} = { id: parseInt(id), name: 'Sample ${pascalName}', createdAt: new Date().toISOString() };
+    return createSuccessResult('${pascalName} retrieved', mock${pascalName});
+  } catch (error) {
+    return createErrorResult('Failed to get ${camelName}', error instanceof Error ? error.message : 'Unknown error', 500);
+  }
+}
+
+// Create ${camelName}
+export async function create${pascalName}(data: Create${pascalName}Data): Promise<ControllerResult<any>> {
+  try {
+    // TODO: Implement database insertion
+    const new${pascalName} = { id: Math.floor(Math.random() * 1000), ...data, createdAt: new Date().toISOString() };
+    return createSuccessResult('${pascalName} created', new${pascalName}, undefined, 201);
+  } catch (error) {
+    return createErrorResult('Failed to create ${camelName}', error instanceof Error ? error.message : 'Unknown error', 500);
+  }
+}
+
+// Update ${camelName}
+export async function update${pascalName}(id: string, data: Update${pascalName}Data): Promise<ControllerResult<any>> {
+  try {
+    // TODO: Implement database update
+    const updated${pascalName} = { id: parseInt(id), ...data, updatedAt: new Date().toISOString() };
+    return createSuccessResult('${pascalName} updated', updated${pascalName});
+  } catch (error) {
+    return createErrorResult('Failed to update ${camelName}', error instanceof Error ? error.message : 'Unknown error', 500);
+  }
+}
+
+// Delete ${camelName}
+export async function delete${pascalName}(id: string): Promise<ControllerResult<void>> {
+  try {
+    // TODO: Implement database deletion
+    return createSuccessResult('${pascalName} deleted');
+  } catch (error) {
+    return createErrorResult('Failed to delete ${camelName}', error instanceof Error ? error.message : 'Unknown error', 500);
+  }
+}
+`;
+}
+function generateCRUDRoutes(config) {
+    const { resourceName, addAuth } = config;
+    const pascalName = toPascalCase(resourceName);
+    return `import { Router, Request, Response } from 'express';
+import {
+  list${pascalName}s,
+  get${pascalName},
+  create${pascalName},
+  update${pascalName},
+  delete${pascalName}
+} from './${resourceName.toLowerCase()}.controller.js';
+import { create${pascalName}Schema, update${pascalName}Schema } from './${resourceName.toLowerCase()}.validator.js';
+import { sendResponse } from '../../shared/api.utils.js';
+${addAuth ? "// import { requireAuth } from '../auth/auth.middleware.js';\n" : ''}
+const router = Router();
+
+// List all
+router.get('/', ${addAuth ? '/* requireAuth, */ ' : ''}async (req: Request, res: Response) => {
+  try {
+    const result = await list${pascalName}s();
+    res.status(result.statusCode || 200).json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, message: 'Internal error', error });
+  }
+});
+
+// Get one
+router.get('/:id', ${addAuth ? '/* requireAuth, */ ' : ''}async (req: Request, res: Response) => {
+  try {
+    const result = await get${pascalName}(req.params.id);
+    res.status(result.statusCode || 200).json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, message: 'Internal error', error });
+  }
+});
+
+// Create
+router.post('/', ${addAuth ? '/* requireAuth, */ ' : ''}async (req: Request, res: Response) => {
+  await sendResponse(req, res, () => create${pascalName}Schema.safeParse(req.body), (data) => create${pascalName}(data));
+});
+
+// Update
+router.put('/:id', ${addAuth ? '/* requireAuth, */ ' : ''}async (req: Request, res: Response) => {
+  await sendResponse(req, res, () => update${pascalName}Schema.safeParse(req.body), (data) => update${pascalName}(req.params.id, data));
+});
+
+// Delete
+router.delete('/:id', ${addAuth ? '/* requireAuth, */ ' : ''}async (req: Request, res: Response) => {
+  try {
+    const result = await delete${pascalName}(req.params.id);
+    res.status(result.statusCode || 200).json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, message: 'Internal error', error });
+  }
+});
+
+export default router;
+`;
+}

package/dist/commands/info.d.ts

@@ -0,0 +1 @@
+export declare function infoCommand(): Promise<void>;

package/dist/commands/info.js

@@ -0,0 +1,80 @@
+import path from 'path';
+import { title, info, gray, error, warning } from '../utils/logger.js';
+import { fileExists } from '../utils/file-utils.js';
+export async function infoCommand() {
+    title('📊 Project Information');
+    // Check if in project
+    const packageJsonPath = path.join(process.cwd(), 'package.json');
+    if (!fileExists(packageJsonPath)) {
+        error('Not in a project directory!');
+        process.exit(1);
+    }
+    // Read package.json
+    const fs = await import('fs');
+    const packageJson = JSON.parse(await fs.promises.readFile(packageJsonPath, 'utf-8'));
+    info('Project Details:');
+    gray(`  Name: ${packageJson.name}`);
+    gray(`  Version: ${packageJson.version}`);
+    gray(`  Description: ${packageJson.description || 'N/A'}\n`);
+    // Check for katax-core
+    const hasKataxCore = packageJson.dependencies?.['katax-core'];
+    info('Dependencies:');
+    gray(`  katax-core: ${hasKataxCore ? '✅ Installed' : '❌ Not installed'}`);
+    gray(`  express: ${packageJson.dependencies?.express ? '✅ Installed' : '❌ Not installed'}`);
+    gray(`  TypeScript: ${packageJson.devDependencies?.typescript ? '✅ Installed' : '❌ Not installed'}\n`);
+    // Scan for API routes
+    const apiPath = path.join(process.cwd(), 'src', 'api');
+    if (await dirExists(apiPath)) {
+        info('API Routes:');
+        const routes = await scanRoutes(apiPath);
+        if (routes.length > 0) {
+            routes.forEach(route => gray(`  ${route}`));
+        }
+        else {
+            gray('  No routes found');
+        }
+    }
+    else {
+        warning('API directory not found');
+    }
+    console.log();
+}
+async function dirExists(dirPath) {
+    try {
+        const fs = await import('fs');
+        const stats = await fs.promises.stat(dirPath);
+        return stats.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function scanRoutes(apiPath) {
+    const routes = [];
+    try {
+        const fs = await import('fs');
+        const entries = await fs.promises.readdir(apiPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory() && entry.name !== 'routes') {
+                const routeFile = path.join(apiPath, entry.name, `${entry.name}.routes.ts`);
+                if (await fileExistsAsync(routeFile)) {
+                    routes.push(`/${entry.name}`);
+                }
+            }
+        }
+    }
+    catch (err) {
+        // Ignore errors
+    }
+    return routes;
+}
+async function fileExistsAsync(filePath) {
+    try {
+        const fs = await import('fs');
+        await fs.promises.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,5 @@
+interface InitOptions {
+    force?: boolean;
+}
+export declare function initCommand(projectName?: string, options?: InitOptions): Promise<void>;
+export {};