katax-cli 0.1.0

package/dist/database/mongodb.ts

@@ -0,0 +1,46 @@
+import { MongoClient, Db } from 'mongodb';
+
+let client: MongoClient;
+let db: Db;
+
+export async function connect(): Promise<Db> {
+  if (db) {
+    return db;
+  }
+
+  const uri = process.env.DATABASE_URL;
+  if (!uri) {
+    throw new Error('DATABASE_URL is not defined in environment variables');
+  }
+
+  client = new MongoClient(uri);
+  
+  try {
+    await client.connect();
+    console.log('✅ Connected to MongoDB database');
+    
+    const dbName = uri.split('/').pop()?.split('?')[0];
+    db = client.db(dbName);
+    
+    return db;
+  } catch (error) {
+    console.error('❌ MongoDB connection error:', error);
+    throw error;
+  }
+}
+
+export async function disconnect(): Promise<void> {
+  if (client) {
+    await client.close();
+    console.log('Disconnected from MongoDB');
+  }
+}
+
+export function getDb(): Db {
+  if (!db) {
+    throw new Error('Database not initialized. Call connect() first.');
+  }
+  return db;
+}
+
+export default { connect, disconnect, getDb };

package/dist/database/mysql.ts

@@ -0,0 +1,26 @@
+import mysql from 'mysql2/promise';
+
+const pool = mysql.createPool({
+  uri: process.env.DATABASE_URL,
+  waitForConnections: true,
+  connectionLimit: 10,
+  queueLimit: 0
+});
+
+pool.on('connection', () => {
+  console.log('✅ Connected to MySQL database');
+});
+
+export default pool;
+
+export async function query(sql: string, params?: any[]) {
+  const start = Date.now();
+  const [rows] = await pool.execute(sql, params);
+  const duration = Date.now() - start;
+  console.log('Executed query', { sql, duration, rows: Array.isArray(rows) ? rows.length : 0 });
+  return rows;
+}
+
+export async function getConnection() {
+  return await pool.getConnection();
+}

package/dist/database/postgresql.ts

@@ -0,0 +1,52 @@
+import { Pool } from 'pg';
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+  ssl: process.env.NODE_ENV === 'production' ? { rejectUnauthorized: false } : false
+});
+
+pool.on('connect', () => {
+  console.log('✅ Connected to PostgreSQL database');
+});
+
+pool.on('error', (err) => {
+  console.error('❌ PostgreSQL connection error:', err);
+  process.exit(-1);
+});
+
+export default pool;
+
+export async function query(text: string, params?: any[]) {
+  const start = Date.now();
+  const res = await pool.query(text, params);
+  const duration = Date.now() - start;
+  console.log('Executed query', { text, duration, rows: res.rowCount });
+  return res;
+}
+
+export async function getClient() {
+  const client = await pool.connect();
+  const query = client.query;
+  const release = client.release;
+  
+  // Set a timeout of 5 seconds, after which we will log this client's last query
+  const timeout = setTimeout(() => {
+    console.error('A client has been checked out for more than 5 seconds!');
+    console.error(`The last executed query on this client was: ${(client as any).lastQuery}`);
+  }, 5000);
+  
+  // Monkey patch the query method to keep track of the last query executed
+  client.query = (...args: any[]) => {
+    (client as any).lastQuery = args;
+    return query.apply(client, args);
+  };
+  
+  client.release = () => {
+    clearTimeout(timeout);
+    client.query = query;
+    client.release = release;
+    return release.apply(client);
+  };
+  
+  return client;
+}

package/dist/generators/controller-generator.d.ts

@@ -0,0 +1,2 @@
+import { EndpointConfig } from '../types/index.js';
+export declare function generateController(config: EndpointConfig): string;

package/dist/generators/controller-generator.js

@@ -0,0 +1,223 @@
+import { toPascalCase, toCamelCase } from '../utils/file-utils.js';
+export function generateController(config) {
+    const { name, method, fields = [] } = config;
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    let content = '';
+    // Imports
+    if (config.addValidation) {
+        content += `import { ${pascalName}Data } from './${name.toLowerCase()}.validator.js';\n`;
+    }
+    content += `import {\n`;
+    content += `  ControllerResult,\n`;
+    content += `  createSuccessResult,\n`;
+    content += `  createErrorResult\n`;
+    content += `} from '../../shared/api.utils.js';\n`;
+    content += `// import pool from '../../database/db.config.js'; // Uncomment if using database\n\n`;
+    // Generate controller function based on method
+    switch (method) {
+        case 'POST':
+            content += generateCreateController(pascalName, camelName, fields);
+            break;
+        case 'GET':
+            content += generateGetController(pascalName, camelName);
+            break;
+        case 'PUT':
+        case 'PATCH':
+            content += generateUpdateController(pascalName, camelName, fields);
+            break;
+        case 'DELETE':
+            content += generateDeleteController(pascalName, camelName);
+            break;
+        default:
+            content += generateGenericController(pascalName, camelName, method);
+    }
+    return content;
+}
+function generateCreateController(pascalName, camelName, fields) {
+    return `/**
+ * Create a new ${camelName}
+ */
+export async function create${pascalName}(
+  data: ${pascalName}Data
+): Promise<ControllerResult<any>> {
+  try {
+    console.log(\`[${pascalName.toUpperCase()}] Creating ${camelName}:\`, data);
+
+    // TODO: Implement database insertion
+    // const result = await pool.query(
+    //   'INSERT INTO ${camelName}s (${fields.map(f => f.name).join(', ')}) VALUES (${fields.map((_, i) => `$${i + 1}`).join(', ')}) RETURNING *',
+    //   [${fields.map(f => `data.${f.name}`).join(', ')}]
+    // );
+    // const new${pascalName} = result.rows[0];
+
+    // Mock response for now
+    const new${pascalName} = {
+      id: Math.floor(Math.random() * 1000),
+      ...data,
+      createdAt: new Date().toISOString()
+    };
+
+    return createSuccessResult(
+      '${pascalName} created successfully',
+      new${pascalName},
+      undefined,
+      201
+    );
+  } catch (error) {
+    console.error(\`[${pascalName.toUpperCase()}] Error creating ${camelName}:\`, error);
+    return createErrorResult(
+      'Failed to create ${camelName}',
+      error instanceof Error ? error.message : 'Unknown error',
+      500
+    );
+  }
+}
+`;
+}
+function generateGetController(pascalName, camelName) {
+    return `/**
+ * Get ${camelName}(s)
+ */
+export async function get${pascalName}(
+  id?: string
+): Promise<ControllerResult<any>> {
+  try {
+    console.log(\`[${pascalName.toUpperCase()}] Getting ${camelName}\`, id ? \`with id: \${id}\` : '(all)');
+
+    // TODO: Implement database query
+    // if (id) {
+    //   const result = await pool.query('SELECT * FROM ${camelName}s WHERE id = $1', [id]);
+    //   if (result.rows.length === 0) {
+    //     return createErrorResult('${pascalName} not found', undefined, 404);
+    //   }
+    //   return createSuccessResult('${pascalName} retrieved', result.rows[0]);
+    // } else {
+    //   const result = await pool.query('SELECT * FROM ${camelName}s');
+    //   return createSuccessResult('${pascalName}s retrieved', result.rows);
+    // }
+
+    // Mock response for now
+    const mock${pascalName} = {
+      id: id || 1,
+      name: 'Sample ${pascalName}',
+      createdAt: new Date().toISOString()
+    };
+
+    return createSuccessResult(
+      '${pascalName} retrieved successfully',
+      id ? mock${pascalName} : [mock${pascalName}]
+    );
+  } catch (error) {
+    console.error(\`[${pascalName.toUpperCase()}] Error getting ${camelName}:\`, error);
+    return createErrorResult(
+      'Failed to get ${camelName}',
+      error instanceof Error ? error.message : 'Unknown error',
+      500
+    );
+  }
+}
+`;
+}
+function generateUpdateController(pascalName, camelName, fields) {
+    return `/**
+ * Update ${camelName}
+ */
+export async function update${pascalName}(
+  id: string,
+  data: Partial<${pascalName}Data>
+): Promise<ControllerResult<any>> {
+  try {
+    console.log(\`[${pascalName.toUpperCase()}] Updating ${camelName} \${id}:\`, data);
+
+    // TODO: Implement database update
+    // const result = await pool.query(
+    //   'UPDATE ${camelName}s SET ... WHERE id = $1 RETURNING *',
+    //   [id, ...]
+    // );
+    // if (result.rows.length === 0) {
+    //   return createErrorResult('${pascalName} not found', undefined, 404);
+    // }
+
+    // Mock response for now
+    const updated${pascalName} = {
+      id: parseInt(id),
+      ...data,
+      updatedAt: new Date().toISOString()
+    };
+
+    return createSuccessResult(
+      '${pascalName} updated successfully',
+      updated${pascalName}
+    );
+  } catch (error) {
+    console.error(\`[${pascalName.toUpperCase()}] Error updating ${camelName}:\`, error);
+    return createErrorResult(
+      'Failed to update ${camelName}',
+      error instanceof Error ? error.message : 'Unknown error',
+      500
+    );
+  }
+}
+`;
+}
+function generateDeleteController(pascalName, camelName) {
+    return `/**
+ * Delete ${camelName}
+ */
+export async function delete${pascalName}(
+  id: string
+): Promise<ControllerResult<void>> {
+  try {
+    console.log(\`[${pascalName.toUpperCase()}] Deleting ${camelName} \${id}\`);
+
+    // TODO: Implement database deletion
+    // const result = await pool.query('DELETE FROM ${camelName}s WHERE id = $1 RETURNING id', [id]);
+    // if (result.rows.length === 0) {
+    //   return createErrorResult('${pascalName} not found', undefined, 404);
+    // }
+
+    return createSuccessResult(
+      '${pascalName} deleted successfully',
+      undefined,
+      undefined,
+      200
+    );
+  } catch (error) {
+    console.error(\`[${pascalName.toUpperCase()}] Error deleting ${camelName}:\`, error);
+    return createErrorResult(
+      'Failed to delete ${camelName}',
+      error instanceof Error ? error.message : 'Unknown error',
+      500
+    );
+  }
+}
+`;
+}
+function generateGenericController(pascalName, camelName, method) {
+    return `/**
+ * Handle ${method} request for ${camelName}
+ */
+export async function handle${pascalName}${method}(
+  data?: any
+): Promise<ControllerResult<any>> {
+  try {
+    console.log(\`[${pascalName.toUpperCase()}] Handling ${method} request\`, data);
+
+    // TODO: Implement your logic here
+
+    return createSuccessResult(
+      'Request processed successfully',
+      { message: '${method} ${camelName} endpoint' }
+    );
+  } catch (error) {
+    console.error(\`[${pascalName.toUpperCase()}] Error:\`, error);
+    return createErrorResult(
+      'Failed to process request',
+      error instanceof Error ? error.message : 'Unknown error',
+      500
+    );
+  }
+}
+`;
+}

package/dist/generators/handler-generator.d.ts

@@ -0,0 +1,2 @@
+import { EndpointConfig } from '../types/index.js';
+export declare function generateHandler(config: EndpointConfig): string;

package/dist/generators/handler-generator.js

@@ -0,0 +1,84 @@
+import { toPascalCase, toCamelCase } from '../utils/file-utils.js';
+export function generateHandler(config) {
+    const { name, method } = config;
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    let content = "import { Request, Response } from 'express';\n";
+    if (config.addValidation) {
+        content += `import { validate${pascalName} } from './${name.toLowerCase()}.validator.js';\n`;
+    }
+    // Import controller functions
+    switch (method) {
+        case 'POST':
+            content += `import { create${pascalName} } from './${name.toLowerCase()}.controller.js';\n`;
+            break;
+        case 'GET':
+            content += `import { get${pascalName} } from './${name.toLowerCase()}.controller.js';\n`;
+            break;
+        case 'PUT':
+        case 'PATCH':
+            content += `import { update${pascalName} } from './${name.toLowerCase()}.controller.js';\n`;
+            break;
+        case 'DELETE':
+            content += `import { delete${pascalName} } from './${name.toLowerCase()}.controller.js';\n`;
+            break;
+    }
+    content += "import { sendResponse } from '../../shared/api.utils.js';\n\n";
+    content += "// ==================== HANDLERS ====================\n\n";
+    // Generate handler based on method
+    content += generateHandlerFunction(method, pascalName, camelName, config.addValidation);
+    return content;
+}
+function generateHandlerFunction(method, pascalName, camelName, hasValidation) {
+    const handlerName = getHandlerName(method, pascalName);
+    let content = `/**\n * Handler for ${method} ${camelName}\n`;
+    content += ` * Uses sendResponse utility for automatic validation and response handling\n */\n`;
+    content += `export async function ${handlerName}(req: Request, res: Response): Promise<void> {\n`;
+    content += `  await sendResponse(\n`;
+    content += `    req,\n`;
+    content += `    res,\n`;
+    // Validator based on method
+    if (hasValidation && (method === 'POST' || method === 'PUT' || method === 'PATCH')) {
+        content += `    () => validate${pascalName}(req.body),\n`;
+    }
+    else if (method === 'GET' || method === 'DELETE') {
+        content += `    () => validate${pascalName}Id(req.params.id),\n`;
+    }
+    else {
+        content += `    () => validate${pascalName}(req.body),\n`;
+    }
+    // Controller call based on method
+    switch (method) {
+        case 'POST':
+            content += `    (validData) => create${pascalName}(validData)\n`;
+            break;
+        case 'GET':
+            content += `    (validData) => get${pascalName}(validData)\n`;
+            break;
+        case 'PUT':
+        case 'PATCH':
+            content += `    (validData) => update${pascalName}(req.params.id, validData)\n`;
+            break;
+        case 'DELETE':
+            content += `    (validData) => delete${pascalName}(validData)\n`;
+            break;
+    }
+    content += `  );\n`;
+    content += `}\n`;
+    return content;
+}
+function getHandlerName(method, pascalName) {
+    switch (method) {
+        case 'POST':
+            return `create${pascalName}Handler`;
+        case 'GET':
+            return `get${pascalName}Handler`;
+        case 'PUT':
+        case 'PATCH':
+            return `update${pascalName}Handler`;
+        case 'DELETE':
+            return `delete${pascalName}Handler`;
+        default:
+            return `handle${pascalName}${method}`;
+    }
+}

package/dist/generators/route-generator.d.ts

@@ -0,0 +1,2 @@
+import { EndpointConfig } from '../types/index.js';
+export declare function generateRoute(config: EndpointConfig): string;

package/dist/generators/route-generator.js

@@ -0,0 +1,50 @@
+import { toPascalCase } from '../utils/file-utils.js';
+export function generateRoute(config) {
+    const { name, method, path } = config;
+    const pascalName = toPascalCase(name);
+    let content = "import { Router } from 'express';\n";
+    // Import handler function
+    const handlerName = getHandlerName(method, pascalName);
+    content += `import { ${handlerName} } from './${name.toLowerCase()}.handler.js';\n\n`;
+    content += `const router = Router();\n\n`;
+    content += `// ==================== ROUTES ====================\n\n`;
+    // Generate route
+    const routePath = path.replace(/^\/api/, '');
+    content += `/**\n`;
+    content += ` * @route ${method} ${path}\n`;
+    content += ` * @desc ${getRouteDescription(method, pascalName)}\n`;
+    content += ` */\n`;
+    content += `router.${method.toLowerCase()}('${routePath}', ${handlerName});\n\n`;
+    content += `export default router;\n`;
+    return content;
+}
+function getHandlerName(method, pascalName) {
+    switch (method) {
+        case 'POST':
+            return `create${pascalName}Handler`;
+        case 'GET':
+            return `get${pascalName}Handler`;
+        case 'PUT':
+        case 'PATCH':
+            return `update${pascalName}Handler`;
+        case 'DELETE':
+            return `delete${pascalName}Handler`;
+        default:
+            return `handle${pascalName}${method}`;
+    }
+}
+function getRouteDescription(method, name) {
+    switch (method) {
+        case 'POST':
+            return `Create a new ${name}`;
+        case 'GET':
+            return `Get ${name}(s)`;
+        case 'PUT':
+        case 'PATCH':
+            return `Update ${name}`;
+        case 'DELETE':
+            return `Delete ${name}`;
+        default:
+            return `Handle ${method} request for ${name}`;
+    }
+}

package/dist/generators/router-updater.d.ts

@@ -0,0 +1,2 @@
+import { EndpointConfig } from '../types/index.js';
+export declare function updateMainRouter(name: string, config: EndpointConfig): Promise<void>;

package/dist/generators/router-updater.js

@@ -0,0 +1,48 @@
+import path from 'path';
+import { fileExists, writeFile } from '../utils/file-utils.js';
+export async function updateMainRouter(name, config) {
+    const routesPath = path.join(process.cwd(), 'src', 'api', 'routes.ts');
+    let content;
+    if (fileExists(routesPath)) {
+        // Read existing routes.ts
+        const fs = await import('fs');
+        content = await fs.promises.readFile(routesPath, 'utf-8');
+        // Check if import already exists
+        const importStatement = `import ${name.toLowerCase()}Router from './${name.toLowerCase()}/${name.toLowerCase()}.routes.js';`;
+        if (!content.includes(importStatement)) {
+            // Add import after last import
+            const lastImportIndex = content.lastIndexOf('import ');
+            const endOfLineIndex = content.indexOf('\n', lastImportIndex);
+            content = content.slice(0, endOfLineIndex + 1) + importStatement + '\n' + content.slice(endOfLineIndex + 1);
+        }
+        // Add route registration
+        const routePath = config.path.replace(/^\/api/, '');
+        const basePath = routePath.split('/')[1] || name.toLowerCase();
+        const routeStatement = `router.use('/${basePath}', ${name.toLowerCase()}Router);`;
+        if (!content.includes(routeStatement)) {
+            // Add before export default
+            const exportIndex = content.lastIndexOf('export default router;');
+            if (exportIndex !== -1) {
+                content = content.slice(0, exportIndex) + routeStatement + '\n\n' + content.slice(exportIndex);
+            }
+            else {
+                content += `\n${routeStatement}\n`;
+            }
+        }
+    }
+    else {
+        // Create new routes.ts
+        content = `import { Router } from 'express';\n`;
+        content += `import ${name.toLowerCase()}Router from './${name.toLowerCase()}/${name.toLowerCase()}.routes.js';\n\n`;
+        content += `const router = Router();\n\n`;
+        content += `// Health check\n`;
+        content += `router.get('/health', (req, res) => {\n`;
+        content += `  res.json({ status: 'ok', timestamp: new Date().toISOString() });\n`;
+        content += `});\n\n`;
+        const routePath = config.path.replace(/^\/api/, '');
+        const basePath = routePath.split('/')[1] || name.toLowerCase();
+        content += `router.use('/${basePath}', ${name.toLowerCase()}Router);\n\n`;
+        content += `export default router;\n`;
+    }
+    await writeFile(routesPath, content);
+}

package/dist/generators/validator-generator.d.ts

@@ -0,0 +1,2 @@
+import { EndpointConfig } from '../types/index.js';
+export declare function generateValidator(config: EndpointConfig): string;