@codebakers/cli 1.3.0 → 1.4.0

package/dist/commands/generate.d.ts

@@ -0,0 +1,9 @@
+interface GenerateOptions {
+    type?: string;
+    name?: string;
+}
+/**
+ * Generate code from templates
+ */
+export declare function generate(options: GenerateOptions): Promise<void>;
+export {};

package/dist/commands/generate.js

@@ -0,0 +1,653 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generate = generate;
+const chalk_1 = __importDefault(require("chalk"));
+const ora_1 = __importDefault(require("ora"));
+const fs_1 = require("fs");
+const path_1 = require("path");
+const readline_1 = require("readline");
+async function prompt(question) {
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+// Convert to PascalCase
+function toPascalCase(str) {
+    return str
+        .split(/[-_\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+// Convert to kebab-case
+function toKebabCase(str) {
+    return str
+        .replace(/([a-z])([A-Z])/g, '$1-$2')
+        .replace(/[\s_]+/g, '-')
+        .toLowerCase();
+}
+// Convert to camelCase
+function toCamelCase(str) {
+    const pascal = toPascalCase(str);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+// Component template
+function componentTemplate(name, hasProps) {
+    const pascalName = toPascalCase(name);
+    if (hasProps) {
+        return `import { cn } from '@/lib/utils';
+
+interface ${pascalName}Props {
+  className?: string;
+  children?: React.ReactNode;
+}
+
+export function ${pascalName}({ className, children }: ${pascalName}Props) {
+  return (
+    <div className={cn('', className)}>
+      {children}
+    </div>
+  );
+}
+`;
+    }
+    return `import { cn } from '@/lib/utils';
+
+export function ${pascalName}() {
+  return (
+    <div>
+      {/* ${pascalName} content */}
+    </div>
+  );
+}
+`;
+}
+// API route template
+function apiRouteTemplate(name, methods) {
+    const lines = [
+        `import { NextRequest, NextResponse } from 'next/server';`,
+        `import { z } from 'zod';`,
+        `import { db } from '@/db';`,
+        ``,
+    ];
+    if (methods.includes('GET')) {
+        lines.push(`export async function GET(request: NextRequest) {
+  try {
+    // TODO: Implement GET logic
+    return NextResponse.json({ message: 'Success' });
+  } catch (error) {
+    console.error('GET /${name} error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+`);
+    }
+    if (methods.includes('POST')) {
+        const schemaName = `Create${toPascalCase(name)}Schema`;
+        lines.push(`const ${schemaName} = z.object({
+  // TODO: Define your schema
+  name: z.string().min(1),
+});
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const validated = ${schemaName}.parse(body);
+
+    // TODO: Implement POST logic
+    return NextResponse.json({ message: 'Created', data: validated });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: 'Validation failed', details: error.errors },
+        { status: 400 }
+      );
+    }
+    console.error('POST /${name} error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+`);
+    }
+    if (methods.includes('PUT')) {
+        const schemaName = `Update${toPascalCase(name)}Schema`;
+        lines.push(`const ${schemaName} = z.object({
+  // TODO: Define your update schema
+  id: z.string().uuid(),
+  name: z.string().min(1).optional(),
+});
+
+export async function PUT(request: NextRequest) {
+  try {
+    const body = await request.json();
+    const validated = ${schemaName}.parse(body);
+
+    // TODO: Implement PUT logic
+    return NextResponse.json({ message: 'Updated', data: validated });
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return NextResponse.json(
+        { error: 'Validation failed', details: error.errors },
+        { status: 400 }
+      );
+    }
+    console.error('PUT /${name} error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+`);
+    }
+    if (methods.includes('DELETE')) {
+        lines.push(`export async function DELETE(request: NextRequest) {
+  try {
+    const { searchParams } = new URL(request.url);
+    const id = searchParams.get('id');
+
+    if (!id) {
+      return NextResponse.json(
+        { error: 'ID is required' },
+        { status: 400 }
+      );
+    }
+
+    // TODO: Implement DELETE logic
+    return NextResponse.json({ message: 'Deleted' });
+  } catch (error) {
+    console.error('DELETE /${name} error:', error);
+    return NextResponse.json(
+      { error: 'Internal server error' },
+      { status: 500 }
+    );
+  }
+}
+`);
+    }
+    return lines.join('\n');
+}
+// Service template
+function serviceTemplate(name) {
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    return `import { db } from '@/db';
+import { z } from 'zod';
+
+// Validation schemas
+export const Create${pascalName}Schema = z.object({
+  // TODO: Define your schema
+  name: z.string().min(1),
+});
+
+export const Update${pascalName}Schema = Create${pascalName}Schema.partial();
+
+export type Create${pascalName}Input = z.infer<typeof Create${pascalName}Schema>;
+export type Update${pascalName}Input = z.infer<typeof Update${pascalName}Schema>;
+
+/**
+ * ${pascalName} Service
+ * Handles all ${camelName}-related business logic
+ */
+export const ${camelName}Service = {
+  /**
+   * Get all ${camelName}s
+   */
+  async getAll() {
+    // TODO: Implement
+    return [];
+  },
+
+  /**
+   * Get a single ${camelName} by ID
+   */
+  async getById(id: string) {
+    // TODO: Implement
+    return null;
+  },
+
+  /**
+   * Create a new ${camelName}
+   */
+  async create(input: Create${pascalName}Input) {
+    const validated = Create${pascalName}Schema.parse(input);
+    // TODO: Implement
+    return validated;
+  },
+
+  /**
+   * Update an existing ${camelName}
+   */
+  async update(id: string, input: Update${pascalName}Input) {
+    const validated = Update${pascalName}Schema.parse(input);
+    // TODO: Implement
+    return { id, ...validated };
+  },
+
+  /**
+   * Delete a ${camelName}
+   */
+  async delete(id: string) {
+    // TODO: Implement
+    return true;
+  },
+};
+`;
+}
+// Hook template
+function hookTemplate(name) {
+    const hookName = name.startsWith('use') ? name : `use${toPascalCase(name)}`;
+    const pascalName = toPascalCase(name.replace(/^use/i, ''));
+    return `'use client';
+
+import { useState, useEffect, useCallback } from 'react';
+
+interface ${pascalName}State {
+  data: unknown | null;
+  isLoading: boolean;
+  error: Error | null;
+}
+
+interface ${hookName}Options {
+  // TODO: Add options if needed
+}
+
+export function ${hookName}(options?: ${hookName}Options) {
+  const [state, setState] = useState<${pascalName}State>({
+    data: null,
+    isLoading: false,
+    error: null,
+  });
+
+  const fetch${pascalName} = useCallback(async () => {
+    setState(prev => ({ ...prev, isLoading: true, error: null }));
+
+    try {
+      // TODO: Implement fetch logic
+      const data = null;
+      setState({ data, isLoading: false, error: null });
+    } catch (error) {
+      setState(prev => ({
+        ...prev,
+        isLoading: false,
+        error: error instanceof Error ? error : new Error('Unknown error'),
+      }));
+    }
+  }, []);
+
+  useEffect(() => {
+    fetch${pascalName}();
+  }, [fetch${pascalName}]);
+
+  return {
+    ...state,
+    refetch: fetch${pascalName},
+  };
+}
+`;
+}
+// Page template
+function pageTemplate(name, isServer) {
+    const pascalName = toPascalCase(name);
+    if (isServer) {
+        return `import { Suspense } from 'react';
+
+export const metadata = {
+  title: '${pascalName}',
+  description: '${pascalName} page',
+};
+
+async function ${pascalName}Content() {
+  // TODO: Fetch data server-side
+  const data = null;
+
+  return (
+    <div>
+      <h1 className="text-2xl font-bold">${pascalName}</h1>
+      {/* Content here */}
+    </div>
+  );
+}
+
+export default function ${pascalName}Page() {
+  return (
+    <main className="container mx-auto py-8">
+      <Suspense fallback={<div>Loading...</div>}>
+        <${pascalName}Content />
+      </Suspense>
+    </main>
+  );
+}
+`;
+    }
+    return `'use client';
+
+import { useState } from 'react';
+
+export default function ${pascalName}Page() {
+  const [loading, setLoading] = useState(false);
+
+  return (
+    <main className="container mx-auto py-8">
+      <h1 className="text-2xl font-bold">${pascalName}</h1>
+      {/* Content here */}
+    </main>
+  );
+}
+`;
+}
+// Schema template for Drizzle
+function schemaTemplate(name) {
+    const tableName = toKebabCase(name).replace(/-/g, '_');
+    const pascalName = toPascalCase(name);
+    return `import { pgTable, text, timestamp, uuid, boolean } from 'drizzle-orm/pg-core';
+
+export const ${tableName} = pgTable('${tableName}', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  // TODO: Add your columns
+  name: text('name').notNull(),
+  description: text('description'),
+  isActive: boolean('is_active').default(true),
+  createdAt: timestamp('created_at').defaultNow().notNull(),
+  updatedAt: timestamp('updated_at').defaultNow().notNull(),
+});
+
+export type ${pascalName} = typeof ${tableName}.$inferSelect;
+export type New${pascalName} = typeof ${tableName}.$inferInsert;
+`;
+}
+// Form template
+function formTemplate(name) {
+    const pascalName = toPascalCase(name);
+    const camelName = toCamelCase(name);
+    return `'use client';
+
+import { useForm } from 'react-hook-form';
+import { zodResolver } from '@hookform/resolvers/zod';
+import { z } from 'zod';
+
+const ${camelName}Schema = z.object({
+  // TODO: Define your form fields
+  name: z.string().min(1, 'Name is required'),
+  email: z.string().email('Invalid email'),
+});
+
+type ${pascalName}FormData = z.infer<typeof ${camelName}Schema>;
+
+interface ${pascalName}FormProps {
+  onSubmit: (data: ${pascalName}FormData) => void | Promise<void>;
+  defaultValues?: Partial<${pascalName}FormData>;
+  isLoading?: boolean;
+}
+
+export function ${pascalName}Form({ onSubmit, defaultValues, isLoading }: ${pascalName}FormProps) {
+  const {
+    register,
+    handleSubmit,
+    formState: { errors },
+  } = useForm<${pascalName}FormData>({
+    resolver: zodResolver(${camelName}Schema),
+    defaultValues,
+  });
+
+  return (
+    <form onSubmit={handleSubmit(onSubmit)} className="space-y-4">
+      <div>
+        <label htmlFor="name" className="block text-sm font-medium">
+          Name
+        </label>
+        <input
+          {...register('name')}
+          type="text"
+          id="name"
+          className="mt-1 block w-full rounded-md border border-gray-300 px-3 py-2"
+          disabled={isLoading}
+        />
+        {errors.name && (
+          <p className="mt-1 text-sm text-red-600">{errors.name.message}</p>
+        )}
+      </div>
+
+      <div>
+        <label htmlFor="email" className="block text-sm font-medium">
+          Email
+        </label>
+        <input
+          {...register('email')}
+          type="email"
+          id="email"
+          className="mt-1 block w-full rounded-md border border-gray-300 px-3 py-2"
+          disabled={isLoading}
+        />
+        {errors.email && (
+          <p className="mt-1 text-sm text-red-600">{errors.email.message}</p>
+        )}
+      </div>
+
+      <button
+        type="submit"
+        disabled={isLoading}
+        className="rounded-md bg-blue-600 px-4 py-2 text-white hover:bg-blue-700 disabled:opacity-50"
+      >
+        {isLoading ? 'Submitting...' : 'Submit'}
+      </button>
+    </form>
+  );
+}
+`;
+}
+/**
+ * Generate code from templates
+ */
+async function generate(options) {
+    console.log(chalk_1.default.blue(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║                                                           ║
+  ║   ${chalk_1.default.bold('CodeBakers Code Generator')}                            ║
+  ║                                                           ║
+  ║   Generate production-ready code from templates           ║
+  ║                                                           ║
+  ╚═══════════════════════════════════════════════════════════╝
+  `));
+    const cwd = process.cwd();
+    // Check if we're in a project
+    const hasPackageJson = (0, fs_1.existsSync)((0, path_1.join)(cwd, 'package.json'));
+    if (!hasPackageJson) {
+        console.log(chalk_1.default.yellow('  No package.json found. Run this in a project directory.\n'));
+        console.log(chalk_1.default.gray('  Use `codebakers scaffold` to create a new project first.\n'));
+        return;
+    }
+    // Available generators
+    const generators = [
+        { key: '1', name: 'component', desc: 'React component with TypeScript' },
+        { key: '2', name: 'api', desc: 'Next.js API route with validation' },
+        { key: '3', name: 'service', desc: 'Business logic service with CRUD' },
+        { key: '4', name: 'hook', desc: 'React hook with state management' },
+        { key: '5', name: 'page', desc: 'Next.js page (server or client)' },
+        { key: '6', name: 'schema', desc: 'Drizzle database table schema' },
+        { key: '7', name: 'form', desc: 'Form with React Hook Form + Zod' },
+    ];
+    let type = options.type;
+    let name = options.name;
+    // If type not provided, ask
+    if (!type) {
+        console.log(chalk_1.default.white('  What would you like to generate?\n'));
+        for (const gen of generators) {
+            console.log(chalk_1.default.gray(`    ${gen.key}. `) + chalk_1.default.cyan(gen.name) + chalk_1.default.gray(` - ${gen.desc}`));
+        }
+        console.log('');
+        let choice = '';
+        while (!['1', '2', '3', '4', '5', '6', '7'].includes(choice)) {
+            choice = await prompt('  Enter 1-7: ');
+        }
+        type = generators.find(g => g.key === choice)?.name;
+    }
+    // If name not provided, ask
+    if (!name) {
+        name = await prompt(`  ${toPascalCase(type)} name: `);
+        if (!name) {
+            console.log(chalk_1.default.red('\n  Name is required.\n'));
+            return;
+        }
+    }
+    const spinner = (0, ora_1.default)('  Generating...').start();
+    try {
+        let filePath;
+        let content;
+        switch (type) {
+            case 'component': {
+                const hasProps = await prompt('  Include props interface? (Y/n): ');
+                content = componentTemplate(name, hasProps.toLowerCase() !== 'n');
+                const componentDir = (0, path_1.join)(cwd, 'src/components');
+                if (!(0, fs_1.existsSync)(componentDir)) {
+                    (0, fs_1.mkdirSync)(componentDir, { recursive: true });
+                }
+                filePath = (0, path_1.join)(componentDir, `${toPascalCase(name)}.tsx`);
+                break;
+            }
+            case 'api': {
+                console.log(chalk_1.default.gray('\n  Select HTTP methods (comma-separated):'));
+                console.log(chalk_1.default.gray('  Examples: GET,POST or GET,POST,PUT,DELETE\n'));
+                const methodsInput = await prompt('  Methods (GET,POST): ') || 'GET,POST';
+                const methods = methodsInput.toUpperCase().split(',').map(m => m.trim());
+                content = apiRouteTemplate(name, methods);
+                const apiDir = (0, path_1.join)(cwd, 'src/app/api', toKebabCase(name));
+                if (!(0, fs_1.existsSync)(apiDir)) {
+                    (0, fs_1.mkdirSync)(apiDir, { recursive: true });
+                }
+                filePath = (0, path_1.join)(apiDir, 'route.ts');
+                break;
+            }
+            case 'service': {
+                content = serviceTemplate(name);
+                const serviceDir = (0, path_1.join)(cwd, 'src/services');
+                if (!(0, fs_1.existsSync)(serviceDir)) {
+                    (0, fs_1.mkdirSync)(serviceDir, { recursive: true });
+                }
+                filePath = (0, path_1.join)(serviceDir, `${toKebabCase(name)}.ts`);
+                break;
+            }
+            case 'hook': {
+                content = hookTemplate(name);
+                const hookDir = (0, path_1.join)(cwd, 'src/hooks');
+                if (!(0, fs_1.existsSync)(hookDir)) {
+                    (0, fs_1.mkdirSync)(hookDir, { recursive: true });
+                }
+                const hookName = name.startsWith('use') ? name : `use${toPascalCase(name)}`;
+                filePath = (0, path_1.join)(hookDir, `${hookName}.ts`);
+                break;
+            }
+            case 'page': {
+                const isServer = await prompt('  Server component? (Y/n): ');
+                content = pageTemplate(name, isServer.toLowerCase() !== 'n');
+                const pageDir = (0, path_1.join)(cwd, 'src/app', toKebabCase(name));
+                if (!(0, fs_1.existsSync)(pageDir)) {
+                    (0, fs_1.mkdirSync)(pageDir, { recursive: true });
+                }
+                filePath = (0, path_1.join)(pageDir, 'page.tsx');
+                break;
+            }
+            case 'schema': {
+                content = schemaTemplate(name);
+                const schemaDir = (0, path_1.join)(cwd, 'src/db/schemas');
+                if (!(0, fs_1.existsSync)(schemaDir)) {
+                    (0, fs_1.mkdirSync)(schemaDir, { recursive: true });
+                }
+                filePath = (0, path_1.join)(schemaDir, `${toKebabCase(name)}.ts`);
+                break;
+            }
+            case 'form': {
+                content = formTemplate(name);
+                const formDir = (0, path_1.join)(cwd, 'src/components/forms');
+                if (!(0, fs_1.existsSync)(formDir)) {
+                    (0, fs_1.mkdirSync)(formDir, { recursive: true });
+                }
+                filePath = (0, path_1.join)(formDir, `${toPascalCase(name)}Form.tsx`);
+                break;
+            }
+            default:
+                spinner.fail('Unknown generator type');
+                return;
+        }
+        // Check if file already exists
+        if ((0, fs_1.existsSync)(filePath)) {
+            spinner.warn('File already exists');
+            const overwrite = await prompt('  Overwrite? (y/N): ');
+            if (overwrite.toLowerCase() !== 'y') {
+                console.log(chalk_1.default.gray('\n  Skipped.\n'));
+                return;
+            }
+        }
+        // Write the file
+        (0, fs_1.writeFileSync)(filePath, content);
+        const relativePath = filePath.replace(cwd, '').replace(/\\/g, '/');
+        spinner.succeed(`Generated ${relativePath}`);
+        console.log(chalk_1.default.green(`
+  ╔═══════════════════════════════════════════════════════════╗
+  ║   ${chalk_1.default.bold('✓ Code generated successfully!')}                        ║
+  ╚═══════════════════════════════════════════════════════════╝
+    `));
+        console.log(chalk_1.default.white('  Created:\n'));
+        console.log(chalk_1.default.cyan(`    ${relativePath}\n`));
+        // Show next steps based on type
+        console.log(chalk_1.default.white('  Next steps:\n'));
+        switch (type) {
+            case 'component':
+                console.log(chalk_1.default.gray('    1. Import and use the component in your page'));
+                console.log(chalk_1.default.gray('    2. Add any additional props you need'));
+                console.log(chalk_1.default.gray('    3. Style it with Tailwind classes\n'));
+                break;
+            case 'api':
+                console.log(chalk_1.default.gray('    1. Implement the TODO sections'));
+                console.log(chalk_1.default.gray('    2. Add authentication if needed'));
+                console.log(chalk_1.default.gray('    3. Test with curl or your frontend\n'));
+                break;
+            case 'service':
+                console.log(chalk_1.default.gray('    1. Update the Zod schemas'));
+                console.log(chalk_1.default.gray('    2. Implement database queries'));
+                console.log(chalk_1.default.gray('    3. Import and use in your API routes\n'));
+                break;
+            case 'hook':
+                console.log(chalk_1.default.gray('    1. Implement the fetch logic'));
+                console.log(chalk_1.default.gray('    2. Update the return type'));
+                console.log(chalk_1.default.gray('    3. Use it in your components\n'));
+                break;
+            case 'page':
+                console.log(chalk_1.default.gray(`    1. Visit /${toKebabCase(name)} in your browser`));
+                console.log(chalk_1.default.gray('    2. Add your page content'));
+                console.log(chalk_1.default.gray('    3. Update the metadata\n'));
+                break;
+            case 'schema':
+                console.log(chalk_1.default.gray('    1. Add your column definitions'));
+                console.log(chalk_1.default.gray('    2. Export from src/db/schema.ts'));
+                console.log(chalk_1.default.gray('    3. Run `npm run db:push` to sync\n'));
+                break;
+            case 'form':
+                console.log(chalk_1.default.gray('    1. Update the Zod schema with your fields'));
+                console.log(chalk_1.default.gray('    2. Add form inputs for each field'));
+                console.log(chalk_1.default.gray('    3. Handle form submission in parent\n'));
+                break;
+        }
+    }
+    catch (error) {
+        spinner.fail('Generation failed');
+        const message = error instanceof Error ? error.message : 'Unknown error';
+        console.log(chalk_1.default.red(`\n  Error: ${message}\n`));
+        process.exit(1);
+    }
+}