katax-cli 0.1.0

package/dist/generators/validator-generator.js

@@ -0,0 +1,160 @@
+import { toPascalCase, toCamelCase } from '../utils/file-utils.js';
+export function generateValidator(config) {
+    const { name, fields = [], addAsyncValidators } = config;
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    let content = `import { k, kataxInfer } from 'katax-core';\n`;
+    content += `import type { ValidationResult } from '../../shared/api.utils.js';\n`;
+    if (addAsyncValidators) {
+        content += `import type { AsyncValidator } from 'katax-core';\n`;
+        content += `// import pool from '../../database/db.config.js'; // Uncomment if using database\n\n`;
+    }
+    else {
+        content += '\n';
+    }
+    // Generate async validators if needed
+    if (addAsyncValidators) {
+        content += `// ==================== ASYNC VALIDATORS ====================\n\n`;
+        fields.forEach(field => {
+            if (field.asyncValidator) {
+                content += `/**\n * Check if ${field.name} is unique\n */\n`;
+                content += `export const ${field.name}UniqueValidator: AsyncValidator<string> = async (value, path) => {\n`;
+                content += `  console.log(\`[ASYNC] Checking ${field.name}: \${value}\`);\n`;
+                content += `  \n`;
+                content += `  // TODO: Implement database check\n`;
+                content += `  // const result = await pool.query(\n`;
+                content += `  //   'SELECT id FROM ${field.asyncValidator.table || 'table_name'} WHERE ${field.asyncValidator.column || field.name} = $1',\n`;
+                content += `  //   [value]\n`;
+                content += `  // );\n`;
+                content += `  // \n`;
+                content += `  // if (result.rows.length > 0) {\n`;
+                content += `  //   return [{ path, message: "This ${field.name} is already taken" }];\n`;
+                content += `  // }\n`;
+                content += `  \n`;
+                content += `  return [];\n`;
+                content += `};\n\n`;
+            }
+        });
+    }
+    // Generate schema
+    content += `// ==================== SCHEMAS ====================\n\n`;
+    content += `/**\n * Schema for ${name} ${config.method} request\n */\n`;
+    content += `export const ${camelName}Schema = k.object({\n`;
+    fields.forEach((field, index) => {
+        const isLast = index === fields.length - 1;
+        let fieldSchema = '';
+        // Base type
+        switch (field.type) {
+            case 'string':
+                fieldSchema = 'k.string()';
+                break;
+            case 'number':
+                fieldSchema = 'k.number()';
+                break;
+            case 'boolean':
+                fieldSchema = 'k.boolean()';
+                break;
+            case 'date':
+                fieldSchema = 'k.date()';
+                break;
+            case 'email':
+                fieldSchema = 'k.string().email()';
+                break;
+            case 'array':
+                fieldSchema = 'k.array(k.string())';
+                break;
+            case 'object':
+                fieldSchema = 'k.object({})';
+                break;
+            default:
+                fieldSchema = 'k.string()';
+        }
+        // Add rules
+        if (field.rules && field.rules.length > 0) {
+            field.rules.forEach(rule => {
+                switch (rule.type) {
+                    case 'minLength':
+                        fieldSchema += `\n    .minLength(${rule.value}, '${rule.message || `Must be at least ${rule.value} characters`}')`;
+                        break;
+                    case 'maxLength':
+                        fieldSchema += `\n    .maxLength(${rule.value}, '${rule.message || `Must not exceed ${rule.value} characters`}')`;
+                        break;
+                    case 'min':
+                        fieldSchema += `\n    .min(${rule.value}, '${rule.message || `Must be at least ${rule.value}`}')`;
+                        break;
+                    case 'max':
+                        fieldSchema += `\n    .max(${rule.value}, '${rule.message || `Must not exceed ${rule.value}`}')`;
+                        break;
+                    case 'email':
+                        fieldSchema += `\n    .email('${rule.message || 'Must be a valid email'}')`;
+                        break;
+                    case 'regex':
+                        fieldSchema += `\n    .regex(${rule.value}, '${rule.message || 'Invalid format'}')`;
+                        break;
+                }
+            });
+        }
+        // Add async validator
+        if (field.asyncValidator && addAsyncValidators) {
+            fieldSchema += `\n    .asyncRefine(${field.name}UniqueValidator)`;
+        }
+        // Add optional
+        if (!field.required) {
+            fieldSchema += `\n    .optional()`;
+        }
+        content += `  ${field.name}: ${fieldSchema}${isLast ? '' : ','}\n`;
+    });
+    content += `});\n\n`;
+    // Generate type
+    content += `/**\n * Inferred TypeScript type from schema\n */\n`;
+    content += `export type ${pascalName}Data = kataxInfer<typeof ${camelName}Schema>;\n\n`;
+    // Generate ID schema for GET/DELETE operations
+    if (config.method === 'GET' || config.method === 'DELETE' || config.method === 'PUT' || config.method === 'PATCH') {
+        content += `/**\n * Schema for ${name} ID validation\n */\n`;
+        content += `export const ${camelName}IdSchema = k.string()\n`;
+        content += `  .minLength(1, 'ID is required')\n`;
+        content += `  .regex(/^[0-9a-fA-F-]{36}$|^\\d+$/, 'ID must be a valid UUID or integer');\n\n`;
+        content += `export type ${pascalName}IdType = kataxInfer<typeof ${camelName}IdSchema>;\n\n`;
+    }
+    // Generate validation functions (ValidationResult is imported from api.utils)
+    content += `/**\n * Validate ${name} data\n */\n`;
+    content += `export async function validate${pascalName}(data: unknown): Promise<ValidationResult<${pascalName}Data>> {\n`;
+    content += `  const result = ${addAsyncValidators ? 'await ' : ''}${camelName}Schema.safeParse${addAsyncValidators ? 'Async' : ''}(data);\n\n`;
+    content += `  if (!result.success) {\n`;
+    content += `    const errors = result.issues.map(issue => ({\n`;
+    content += `      field: issue.path.join('.'),\n`;
+    content += `      message: issue.message\n`;
+    content += `    }));\n\n`;
+    content += `    return {\n`;
+    content += `      isValid: false,\n`;
+    content += `      errors\n`;
+    content += `    };\n`;
+    content += `  }\n\n`;
+    content += `  return {\n`;
+    content += `    isValid: true,\n`;
+    content += `    data: result.data\n`;
+    content += `  };\n`;
+    content += `}\n`;
+    // Generate ID validation function for GET/DELETE
+    if (config.method === 'GET' || config.method === 'DELETE' || config.method === 'PUT' || config.method === 'PATCH') {
+        content += `\n/**\n * Validate ${name} ID\n */\n`;
+        content += `export async function validate${pascalName}Id(id: string): Promise<ValidationResult<${pascalName}IdType>> {\n`;
+        content += `  const result = ${camelName}IdSchema.safeParse(id);\n\n`;
+        content += `  if (!result.success) {\n`;
+        content += `    const errors = result.issues.map(issue => ({\n`;
+        content += `      field: issue.path.join('.') || 'id',\n`;
+        content += `      message: issue.message\n`;
+        content += `    }));\n\n`;
+        content += `    return {\n`;
+        content += `      isValid: false,\n`;
+        content += `      errors\n`;
+        content += `    };\n`;
+        content += `  }\n\n`;
+        content += `  return {\n`;
+        content += `    isValid: true,\n`;
+        content += `    data: result.data\n`;
+        content += `  };\n`;
+        content += `}\n`;
+    }
+    return content;
+}

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * Katax CLI - API Generator with TypeScript and katax-core validation
+ *
+ * A CLI tool for generating Express REST APIs with TypeScript,
+ * integrated with katax-core for robust schema validation.
+ */
+export {};

package/dist/index.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * Katax CLI - API Generator with TypeScript and katax-core validation
+ *
+ * A CLI tool for generating Express REST APIs with TypeScript,
+ * integrated with katax-core for robust schema validation.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { readFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { initCommand } from './commands/init.js';
+import { addEndpointCommand } from './commands/add-endpoint.js';
+import { generateCrudCommand } from './commands/generate-crud.js';
+import { infoCommand } from './commands/info.js';
+import { setVerbose, setColorMode } from './utils/logger.js';
+// Get version from package.json
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJson = JSON.parse(readFileSync(join(__dirname, '../package.json'), 'utf-8'));
+const version = packageJson.version;
+const program = new Command();
+program
+    .name('katax')
+    .description(chalk.blue('🚀 Generate Express APIs with TypeScript and katax-core validation'))
+    .version(version, '-v, --version', 'Output the current version');
+// Init command - Initialize new API project
+program
+    .command('init [project-name]')
+    .description('Initialize a new Express API project with TypeScript')
+    .option('-f, --force', 'Overwrite existing project')
+    .action(initCommand);
+// Add command - Add resources to project
+const addCommand = program
+    .command('add')
+    .description('Add resources to your project');
+addCommand
+    .command('endpoint <name>')
+    .description('Add a new endpoint with validation')
+    .option('-m, --method <method>', 'HTTP method (GET, POST, PUT, DELETE)', 'POST')
+    .option('-p, --path <path>', 'Route path')
+    .action(addEndpointCommand);
+// Generate command - Generate complete resources
+const generateCommand = program
+    .command('generate')
+    .aliases(['gen', 'g'])
+    .description('Generate complete resources');
+generateCommand
+    .command('crud <resource-name>')
+    .description('Generate a complete CRUD resource')
+    .option('--no-auth', 'Skip authentication middleware')
+    .action(generateCrudCommand);
+// Info command - Show project structure
+program
+    .command('info')
+    .aliases(['status', 'ls'])
+    .description('Show current project structure and routes')
+    .action(infoCommand);
+// Global options
+program
+    .option('--no-color', 'Disable colored output')
+    .option('--verbose', 'Enable verbose logging');
+// Parse global options
+program.hook('preAction', (thisCommand) => {
+    const opts = thisCommand.optsWithGlobals();
+    if (opts.verbose)
+        setVerbose(true);
+    if (opts.color === false)
+        setColorMode(false);
+});
+// Show help after error and suggestions
+program.showHelpAfterError('(add --help for additional information)');
+program.showSuggestionAfterError(true);
+// Add examples to help
+program.addHelpText('after', `
+${chalk.bold('Examples:')}
+  ${chalk.gray('# Initialize a new API project')}
+  $ katax init my-api
+
+  ${chalk.gray('# Add a single endpoint')}
+  $ katax add endpoint users
+
+  ${chalk.gray('# Generate a complete CRUD resource')}
+  $ katax generate crud products
+
+  ${chalk.gray('# View project structure')}
+  $ katax info
+
+  ${chalk.gray('# Initialize with options')}
+  $ katax init my-api --force
+
+${chalk.bold('Documentation:')}
+  ${chalk.cyan('https://github.com/LOPIN6FARRIER/katax-cli#readme')}
+`);
+// Parse command line arguments
+program.parse(process.argv);
+// Show help if no command provided
+if (!process.argv.slice(2).length) {
+    program.outputHelp();
+}

package/dist/types/index.d.ts

@@ -0,0 +1,50 @@
+export interface ProjectConfig {
+    name: string;
+    description?: string;
+    type: 'rest-api' | 'graphql';
+    typescript: boolean;
+    database?: 'postgresql' | 'mysql' | 'mongodb' | 'none';
+    authentication?: 'jwt' | 'none';
+    validation: 'katax-core' | 'none';
+    orm?: 'none' | 'prisma' | 'typeorm';
+    port: number;
+    dbConfig?: {
+        host?: string;
+        port?: string;
+        user?: string;
+        password?: string;
+        database?: string;
+        useAuth?: boolean;
+    };
+}
+export interface EndpointConfig {
+    name: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    addValidation: boolean;
+    fields?: FieldConfig[];
+    addAsyncValidators: boolean;
+    dbOperations?: ('create' | 'read' | 'update' | 'delete')[];
+}
+export interface FieldConfig {
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'email' | 'array' | 'object';
+    required: boolean;
+    rules?: ValidationRule[];
+    asyncValidator?: {
+        type: 'unique' | 'exists' | 'custom';
+        table?: string;
+        column?: string;
+    };
+}
+export interface ValidationRule {
+    type: 'minLength' | 'maxLength' | 'min' | 'max' | 'email' | 'regex' | 'oneOf' | 'custom';
+    value?: any;
+    message?: string;
+}
+export interface CRUDConfig {
+    resourceName: string;
+    tableName?: string;
+    fields: FieldConfig[];
+    addAuth: boolean;
+}

package/dist/types/index.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/file-utils.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Get the templates directory path
+ */
+export declare function getTemplatesDir(): string;
+/**
+ * Render an EJS template
+ */
+export declare function renderTemplate(templatePath: string, data: any): Promise<string>;
+/**
+ * Copy template file to destination
+ */
+export declare function copyTemplate(templatePath: string, destinationPath: string, data?: any): Promise<void>;
+/**
+ * Write a file with content
+ */
+export declare function writeFile(filePath: string, content: string): Promise<void>;
+/**
+ * Check if directory exists
+ */
+export declare function directoryExists(dirPath: string): boolean;
+/**
+ * Check if file exists
+ */
+export declare function fileExists(filePath: string): boolean;
+/**
+ * Create directory if it doesn't exist
+ */
+export declare function ensureDir(dirPath: string): Promise<void>;
+/**
+ * Convert string to PascalCase
+ */
+export declare function toPascalCase(str: string): string;
+/**
+ * Convert string to camelCase
+ */
+export declare function toCamelCase(str: string): string;
+/**
+ * Convert string to kebab-case
+ */
+export declare function toKebabCase(str: string): string;

package/dist/utils/file-utils.js

@@ -0,0 +1,89 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ejs from 'ejs';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+ * Get the templates directory path
+ */
+export function getTemplatesDir() {
+    // In development: ../../templates
+    // In production: ../templates (dist folder)
+    const devPath = path.join(__dirname, '..', '..', 'templates');
+    const prodPath = path.join(__dirname, '..', 'templates');
+    return fs.existsSync(devPath) ? devPath : prodPath;
+}
+/**
+ * Render an EJS template
+ */
+export async function renderTemplate(templatePath, data) {
+    const fullPath = path.join(getTemplatesDir(), templatePath);
+    const templateContent = await fs.readFile(fullPath, 'utf-8');
+    return ejs.render(templateContent, data);
+}
+/**
+ * Copy template file to destination
+ */
+export async function copyTemplate(templatePath, destinationPath, data) {
+    const sourcePath = path.join(getTemplatesDir(), templatePath);
+    await fs.ensureDir(path.dirname(destinationPath));
+    if (data) {
+        const rendered = await renderTemplate(templatePath, data);
+        await fs.writeFile(destinationPath, rendered, 'utf-8');
+    }
+    else {
+        await fs.copy(sourcePath, destinationPath);
+    }
+}
+/**
+ * Write a file with content
+ */
+export async function writeFile(filePath, content) {
+    await fs.ensureDir(path.dirname(filePath));
+    await fs.writeFile(filePath, content, 'utf-8');
+}
+/**
+ * Check if directory exists
+ */
+export function directoryExists(dirPath) {
+    return fs.existsSync(dirPath);
+}
+/**
+ * Check if file exists
+ */
+export function fileExists(filePath) {
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+}
+/**
+ * Create directory if it doesn't exist
+ */
+export async function ensureDir(dirPath) {
+    await fs.ensureDir(dirPath);
+}
+/**
+ * Convert string to PascalCase
+ */
+export function toPascalCase(str) {
+    return str
+        .split(/[-_\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+/**
+ * Convert string to camelCase
+ */
+export function toCamelCase(str) {
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+/**
+ * Convert string to kebab-case
+ */
+export function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,10 @@
+export declare function setVerbose(enabled: boolean): void;
+export declare function setColorMode(enabled: boolean): void;
+export declare function success(message: string): void;
+export declare function error(message: string): void;
+export declare function warning(message: string): void;
+export declare function info(message: string): void;
+export declare function verbose(message: string): void;
+export declare function gray(message: string): void;
+export declare function title(message: string): void;
+export declare function code(message: string): void;

package/dist/utils/logger.js

@@ -0,0 +1,38 @@
+import chalk from 'chalk';
+let verboseMode = false;
+let colorMode = true;
+export function setVerbose(enabled) {
+    verboseMode = enabled;
+}
+export function setColorMode(enabled) {
+    colorMode = enabled;
+}
+function applyColor(color, text) {
+    return colorMode ? color(text) : text;
+}
+export function success(message) {
+    console.log(applyColor(chalk.green, `✅ ${message}`));
+}
+export function error(message) {
+    console.log(applyColor(chalk.red, `❌ ${message}`));
+}
+export function warning(message) {
+    console.log(applyColor(chalk.yellow, `⚠️  ${message}`));
+}
+export function info(message) {
+    console.log(applyColor(chalk.blue, `ℹ️  ${message}`));
+}
+export function verbose(message) {
+    if (verboseMode) {
+        console.log(applyColor(chalk.gray, `[VERBOSE] ${message}`));
+    }
+}
+export function gray(message) {
+    console.log(applyColor(chalk.gray, message));
+}
+export function title(message) {
+    console.log(applyColor(chalk.bold.cyan, `\n${message}\n`));
+}
+export function code(message) {
+    console.log(applyColor(chalk.bgBlack.white, ` ${message} `));
+}

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "katax-cli",
+  "version": "0.1.0",
+  "description": "CLI tool to generate Express APIs with TypeScript and katax-core validation",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "katax": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "dev": "tsx watch src/index.ts",
+    "build": "tsc && npm run copy-templates",
+    "copy-templates": "copyfiles -u 1 \"templates/**/*\" dist",
+    "start": "node dist/index.js",
+    "clean": "rimraf dist",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "api",
+    "generator",
+    "express",
+    "typescript",
+    "validation",
+    "katax-core",
+    "cli",
+    "rest-api",
+    "crud"
+  ],
+  "author": "Vinicio Esparza",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/LOPIN6FARRIER/katax-cli.git"
+  },
+  "bugs": {
+    "url": "https://github.com/LOPIN6FARRIER/katax-cli/issues"
+  },
+  "homepage": "https://github.com/LOPIN6FARRIER/katax-cli#readme",
+  "dependencies": {
+    "chalk": "^5.3.0",
+    "commander": "^12.1.0",
+    "ejs": "^3.1.10",
+    "execa": "^9.5.2",
+    "fs-extra": "^11.2.0",
+    "inquirer": "^12.3.0",
+    "katax-core": "^1.1.0",
+    "ora": "^8.1.1"
+  },
+  "devDependencies": {
+    "@types/ejs": "^3.1.5",
+    "@types/fs-extra": "^11.0.4",
+    "@types/inquirer": "^9.0.7",
+    "@types/node": "^22.10.5",
+    "copyfiles": "^2.4.1",
+    "rimraf": "^6.0.1",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  }
+}