@buenojs/bueno 0.8.3 → 0.8.5

package/src/cli/templates/generators/index.ts

@@ -0,0 +1,339 @@
+/**
+ * Generators Templates
+ *
+ * Code generator templates registry
+ */
+
+// Re-export types
+export type {
+	GeneratorType,
+	GeneratorConfig,
+	GeneratorResult,
+} from "./types";
+
+export { GENERATOR_ALIASES } from "./types";
+
+import type { GeneratorConfig, GeneratorResult, GeneratorType } from "./types";
+
+/**
+ * Generator template function type
+ */
+type GeneratorTemplate = (config: GeneratorConfig) => string;
+
+/**
+ * Generator template registry
+ */
+const generatorTemplates: Record<GeneratorType, GeneratorTemplate> = {
+	controller: (config) => getControllerTemplate(config),
+	service: () => getServiceTemplate(),
+	module: (config) => getModuleTemplate(config),
+	guard: (config) => getGuardTemplate(config),
+	interceptor: (config) => getInterceptorTemplate(config),
+	pipe: (config) => getPipeTemplate(config),
+	filter: (config) => getFilterTemplate(config),
+	dto: (config) => getDtoTemplate(config),
+	middleware: (config) => getMiddlewareTemplate(config),
+	migration: (config) => getMigrationTemplate(config),
+};
+
+/**
+ * Get generator template
+ */
+export function getGeneratorTemplate(type: GeneratorType): GeneratorTemplate {
+	return generatorTemplates[type];
+}
+
+/**
+ * Get all available generator types
+ */
+export function getGeneratorTypes(): GeneratorType[] {
+	return Object.keys(generatorTemplates) as GeneratorType[];
+}
+
+/**
+ * Get default directory for generator type
+ */
+export function getDefaultDirectory(type: GeneratorType): string {
+	switch (type) {
+		case "controller":
+		case "service":
+		case "module":
+		case "dto":
+			return "modules";
+		case "guard":
+			return "common/guards";
+		case "interceptor":
+			return "common/interceptors";
+		case "pipe":
+			return "common/pipes";
+		case "filter":
+			return "common/filters";
+		case "middleware":
+			return "common/middleware";
+		case "migration":
+			return "database/migrations";
+		default:
+			return "";
+	}
+}
+
+/**
+ * Get file extension for generator type
+ */
+export function getFileExtension(type: GeneratorType): string {
+	return type === "dto" ? ".dto.ts" : ".ts";
+}
+
+// ============= Template Functions =============
+
+function getControllerTemplate(config: GeneratorConfig): string {
+	return `import { Controller, Get, Post, Put, Delete{{#if path}} } from '@buenojs/bueno'{{/if}}{{#if service}}, { {{pascalCase service}}Service } from './{{kebabCase service}}.service'{{/if}};
+import type { Context } from '@buenojs/bueno';
+
+@Controller('{{path}}')
+export class {{pascalCase name}}Controller {
+  {{#if service}}
+  constructor(private readonly {{camelCase service}}Service: {{pascalCase service}}Service) {}
+  {{/if}}
+
+  @Get()
+  async findAll(ctx: Context) {
+    return { message: '{{pascalCase name}} controller' };
+  }
+
+  @Get(':id')
+  async findOne(ctx: Context) {
+    const id = ctx.params.id;
+    return { id, message: '{{pascalCase name}} item' };
+  }
+
+  @Post()
+  async create(ctx: Context) {
+    const body = await ctx.body();
+    return { message: 'Created', data: body };
+  }
+
+  @Put(':id')
+  async update(ctx: Context) {
+    const id = ctx.params.id;
+    const body = await ctx.body();
+    return { id, message: 'Updated', data: body };
+  }
+
+  @Delete(':id')
+  async remove(ctx: Context) {
+    const id = ctx.params.id;
+    return { id, message: 'Deleted' };
+  }
+}
+`;
+}
+
+function getServiceTemplate(): string {
+	return `import { Injectable } from '@buenojs/bueno';
+
+@Injectable()
+export class {{pascalCase name}}Service {
+  async findAll() {
+    // TODO: Implement findAll
+    return [];
+  }
+
+  async findOne(id: string) {
+    // TODO: Implement findOne
+    return { id };
+  }
+
+  async create(data: unknown) {
+    // TODO: Implement create
+    return data;
+  }
+
+  async update(id: string, data: unknown) {
+    // TODO: Implement update
+    return { id, ...data };
+  }
+
+  async remove(id: string) {
+    // TODO: Implement remove
+    return { id };
+  }
+}
+`;
+}
+
+function getModuleTemplate(config: GeneratorConfig): string {
+	return `import { Module } from '@buenojs/bueno';
+import { {{pascalCase name}}Controller } from './{{kebabCase name}}.controller';
+import { {{pascalCase name}}Service } from './{{kebabCase name}}.service';
+
+@Module({
+  controllers: [{{pascalCase name}}Controller],
+  providers: [{{pascalCase name}}Service],
+  exports: [{{pascalCase name}}Service],
+})
+export class {{pascalCase name}}Module {}
+`;
+}
+
+function getGuardTemplate(config: GeneratorConfig): string {
+	return `import { Injectable, type CanActivate, type Context } from '@buenojs/bueno';
+
+@Injectable()
+export class {{pascalCase name}}Guard implements CanActivate {
+  async canActivate(ctx: Context): Promise<boolean> {
+    // TODO: Implement guard logic
+    // Return true to allow access, false to deny
+    return true;
+  }
+}
+`;
+}
+
+function getInterceptorTemplate(config: GeneratorConfig): string {
+	return `import { Injectable, type NestInterceptor, type CallHandler, type Context } from '@buenojs/bueno';
+import type { Observable } from 'rxjs';
+
+@Injectable()
+export class {{pascalCase name}}Interceptor implements NestInterceptor {
+  async intercept(ctx: Context, next: CallHandler): Promise<Observable<unknown>> {
+    // Before handler execution
+    console.log('{{pascalCase name}}Interceptor - Before');
+
+    // Call the handler
+    const result = await next.handle();
+
+    // After handler execution
+    console.log('{{pascalCase name}}Interceptor - After');
+
+    return result;
+  }
+}
+`;
+}
+
+function getPipeTemplate(config: GeneratorConfig): string {
+	return `import { Injectable, type PipeTransform, type Context } from '@buenojs/bueno';
+
+@Injectable()
+export class {{pascalCase name}}Pipe implements PipeTransform {
+  async transform(value: unknown, ctx: Context): Promise<unknown> {
+    // TODO: Implement transformation/validation logic
+    // Throw an error to reject the value
+    return value;
+  }
+}
+`;
+}
+
+function getFilterTemplate(config: GeneratorConfig): string {
+	return `import { Injectable, type ExceptionFilter, type Context } from '@buenojs/bueno';
+import type { Response } from '@buenojs/bueno';
+
+@Injectable()
+export class {{pascalCase name}}Filter implements ExceptionFilter {
+  async catch(exception: Error, ctx: Context): Promise<Response> {
+    // TODO: Implement exception handling
+    console.error('{{pascalCase name}}Filter caught:', exception);
+
+    return new Response(
+      JSON.stringify({
+        statusCode: 500,
+        message: 'Internal Server Error',
+        error: exception.message,
+      }),
+      {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' },
+      }
+    );
+  }
+}
+`;
+}
+
+function getDtoTemplate(config: GeneratorConfig): string {
+	return `/**
+ * {{pascalCase name}} DTO
+ */
+export interface {{pascalCase name}}Dto {
+  // TODO: Define properties
+  id?: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+/**
+ * Create {{pascalCase name}} DTO
+ */
+export interface Create{{pascalCase name}}Dto {
+  // TODO: Define required properties for creation
+}
+
+/**
+ * Update {{pascalCase name}} DTO
+ */
+export interface Update{{pascalCase name}}Dto extends Partial<Create{{pascalCase name}}Dto> {
+  // TODO: Define optional properties for update
+}
+`;
+}
+
+function getMiddlewareTemplate(config: GeneratorConfig): string {
+	return `import type { Middleware, Context, Handler } from '@buenojs/bueno';
+
+/**
+ * {{pascalCase name}} Middleware
+ */
+export const {{camelCase name}}Middleware: Middleware = async (
+  ctx: Context,
+  next: Handler
+) => {
+  // Before handler execution
+  console.log('{{pascalCase name}}Middleware - Before');
+
+  // Call the next handler
+  const result = await next();
+
+  // After handler execution
+  console.log('{{pascalCase name}}Middleware - After');
+
+  return result;
+};
+`;
+}
+
+function getMigrationTemplate(config: GeneratorConfig): string {
+	const migrationId = generateMigrationId();
+	return `import { createMigration, type MigrationRunner } from '@buenojs/bueno/migrations';
+
+export default createMigration('${migrationId}', '{{migrationName}}')
+  .up(async (db: MigrationRunner) => {
+    // TODO: Add migration logic
+    // Example:
+    // await db.createTable({
+    //   name: '{{tableName}}',
+    //   columns: [
+    //     { name: 'id', type: 'uuid', primary: true },
+    //     { name: 'created_at', type: 'timestamp', default: 'NOW()' },
+    //   ],
+    // });
+  })
+  .down(async (db: MigrationRunner) => {
+    // TODO: Add rollback logic
+    // Example:
+    // await db.dropTable('{{tableName}}');
+  });
+`;
+}
+
+function generateMigrationId(): string {
+	const now = new Date();
+	const year = now.getFullYear();
+	const month = String(now.getMonth() + 1).padStart(2, "0");
+	const day = String(now.getDate()).padStart(2, "0");
+	const hour = String(now.getHours()).padStart(2, "0");
+	const minute = String(now.getMinutes()).padStart(2, "0");
+	const second = String(now.getSeconds()).padStart(2, "0");
+	return `${year}${month}${day}${hour}${minute}${second}`;
+}

package/src/cli/templates/generators/types.ts

@@ -0,0 +1,56 @@
+/**
+ * Generator Types
+ *
+ * Type definitions for code generators
+ */
+
+/**
+ * Generator types available
+ */
+export type GeneratorType =
+	| "controller"
+	| "service"
+	| "module"
+	| "guard"
+	| "interceptor"
+	| "pipe"
+	| "filter"
+	| "dto"
+	| "middleware"
+	| "migration";
+
+/**
+ * Generator aliases
+ */
+export const GENERATOR_ALIASES: Record<string, GeneratorType> = {
+	c: "controller",
+	s: "service",
+	m: "module",
+	gu: "guard",
+	i: "interceptor",
+	p: "pipe",
+	f: "filter",
+	d: "dto",
+	mw: "middleware",
+	mi: "migration",
+};
+
+/**
+ * Generator configuration
+ */
+export interface GeneratorConfig {
+	type: GeneratorType;
+	name: string;
+	module?: string;
+	path?: string;
+	dryRun: boolean;
+	force: boolean;
+}
+
+/**
+ * Generator result
+ */
+export interface GeneratorResult {
+	filePath: string;
+	content: string;
+}

package/src/cli/templates/index.ts

@@ -10,7 +10,7 @@ export {
 	getDockerignoreTemplate,
 	getDockerComposeTemplate,
 	getDockerEnvTemplate,
-} from './docker';
+} from "./docker";
 
 // Cloud platform deployment templates
 export {
@@ -21,4 +21,37 @@ export {
 	getDeployTemplate,
 	getDeployFilename,
 	getDeployPlatformName,
-} from './deploy';
+} from "./deploy";
+
+// Project templates
+export {
+	type ProjectTemplate,
+	type ProjectConfig,
+	type FrontendFramework,
+	type DatabaseDriver,
+	getProjectTemplate,
+	getTemplateOptions,
+} from "./project";
+
+// Database templates
+export {
+	getDatabaseTemplate,
+	getDatabaseOptions,
+} from "./database";
+
+// Frontend templates
+export {
+	getFrontendTemplate,
+	getFrontendOptions,
+} from "./frontend";
+
+// Generator templates
+export {
+	type GeneratorType,
+	type GeneratorConfig,
+	GENERATOR_ALIASES,
+	getGeneratorTemplate,
+	getGeneratorTypes,
+	getDefaultDirectory,
+	getFileExtension,
+} from "./generators";

package/src/cli/templates/project/api.ts

@@ -0,0 +1,81 @@
+/**
+ * API Project Template
+ */
+
+import { getBuenoDependency } from "../../utils/version";
+import type { ProjectConfig, ProjectTemplateResult } from "./types";
+
+export function apiTemplate(config: ProjectConfig): ProjectTemplateResult {
+	return {
+		files: [
+			{
+				path: "server/main.ts",
+				content: `import { createApp, Module, Controller, Get, Post, Injectable } from '@buenojs/bueno';
+import type { Context } from '@buenojs/bueno';
+
+// Services
+@Injectable()
+export class AppService {
+		findAll() {
+				return { message: 'Welcome to Bueno API!', items: [] };
+		}
+}
+
+// Controllers
+@Controller('/api')
+export class AppController {
+		constructor(private readonly appService: AppService) {}
+
+		@Get()
+		hello() {
+				return Response.json({ message: 'Welcome to Bueno API!', version: '1.0.0' });
+		}
+
+		@Get('health')
+		health(ctx: Context) {
+				return Response.json({ status: 'ok', timestamp: new Date().toISOString() });
+		}
+}
+
+// Module
+@Module({
+		controllers: [AppController],
+		providers: [AppService],
+})
+export class AppModule {}
+
+// Bootstrap
+const app = createApp(AppModule);
+await app.listen(3000);
+console.log('🚀 API server running at http://localhost:3000/api');
+`,
+			},
+		],
+		directories: [
+			"server/modules/app",
+			"server/common/middleware",
+			"server/common/guards",
+			"server/common/interceptors",
+			"server/common/pipes",
+			"server/common/filters",
+			"server/database/migrations",
+			"server/config",
+			"tests/unit",
+			"tests/integration",
+		],
+		dependencies: {
+			...getBuenoDependency(),
+			zod: "^3.24.0",
+		},
+		devDependencies: {
+			"@types/bun": "latest",
+			typescript: "^5.3.0",
+		},
+		scripts: {
+			dev: "bun run --watch server/main.ts",
+			build: "bun build ./server/main.ts --outdir ./dist --target bun",
+			start: "bun run dist/main.js",
+			test: "bun test",
+		},
+	};
+}

package/src/cli/templates/project/default.ts

@@ -0,0 +1,140 @@
+/**
+ * Default Project Template
+ */
+
+import { noneTemplate } from "../frontend/none";
+import { reactTemplate } from "../frontend/react";
+import { solidTemplate } from "../frontend/solid";
+import { svelteTemplate } from "../frontend/svelte";
+import { vueTemplate } from "../frontend/vue";
+import type { ProjectConfig, ProjectTemplateResult } from "./types";
+
+export function defaultTemplate(config: ProjectConfig): ProjectTemplateResult {
+	// Get frontend template based on framework
+	const frontendTemplates: Record<string, () => ProjectTemplateResult> = {
+		react: reactTemplate,
+		vue: vueTemplate,
+		svelte: svelteTemplate,
+		solid: solidTemplate,
+		none: noneTemplate,
+	};
+
+	const frontendTemplate = frontendTemplates[config.framework]
+		? frontendTemplates[config.framework]()
+		: reactTemplate();
+
+	return {
+		files: [
+			{
+				path: "server/main.ts",
+				content: `import { createApp, Module, Controller, Get, Injectable } from '@buenojs/bueno';
+import type { Context } from '@buenojs/bueno';
+
+// Services
+@Injectable()
+export class AppService {
+  findAll() {
+    return { message: 'Welcome to Bueno!', items: [] };
+  }
+}
+
+// Controllers
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  hello() {
+    return new Response(\`<html>
+<head>
+  <title>Welcome to Bueno</title>
+  <style>
+    body { font-family: system-ui, sans-serif; max-width: 800px; margin: 50px auto; padding: 20px; }
+    h1 { color: #2563eb; }
+    code { background: #f3f4f6; padding: 2px 6px; border-radius: 4px; }
+    pre { background: #f3f4f6; padding: 16px; border-radius: 8px; overflow-x: auto; }
+    a { color: #2563eb; }
+  </style>
+</head>
+<body>
+  <h1>🎉 Welcome to Bueno Framework!</h1>
+  <p>Your Bun-native full-stack framework is running successfully.</p>
+  
+  <h2>Getting Started</h2>
+  <ul>
+    <li>Edit <code>server/main.ts</code> to modify this app</li>
+    <li>Add routes using the <code>@Get()</code>, <code>@Post()</code> decorators</li>
+    <li>Create services with <code>@Injectable()</code> and inject them in controllers</li>
+  </ul>
+  
+  <h2>Documentation</h2>
+  <p>Visit <a href="https://buenojs.dev">https://buenojs.dev</a> for full documentation.</p>
+  
+  <h2>Quick Example</h2>
+  <pre><code>@Controller('/api')
+class MyController {
+  @Get('/users')
+  getUsers() {
+    return { users: [] };
+  }
+}</code></pre>
+</body>
+</html>\`, {
+      headers: { 'Content-Type': 'text/html; charset=utf-8' }
+    });
+  }
+
+  @Get('health')
+  health(ctx: Context) {
+    return { status: 'ok', timestamp: new Date().toISOString() };
+  }
+}
+
+// Module
+@Module({
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+
+// Bootstrap
+const app = createApp(AppModule);
+await app.listen(3000);
+`,
+			},
+			// Include frontend files
+			...frontendTemplate.files,
+		],
+		directories: [
+			"server/modules/app",
+			"server/common/middleware",
+			"server/common/guards",
+			"server/common/interceptors",
+			"server/common/pipes",
+			"server/common/filters",
+			"server/database/migrations",
+			"server/config",
+			"tests/unit",
+			"tests/integration",
+			// Include frontend directories
+			...frontendTemplate.directories,
+		],
+		dependencies: {
+			zod: "^3.24.0",
+			// Include frontend dependencies
+			...frontendTemplate.dependencies,
+		},
+		devDependencies: {
+			// Include frontend dev dependencies
+			...frontendTemplate.devDependencies,
+		},
+		scripts: {
+			dev: "bun run --watch server/main.ts",
+			build: "bun build ./server/main.ts --outdir ./dist --target bun",
+			start: "bun run dist/main.js",
+			test: "bun test",
+			// Include frontend scripts
+			...frontendTemplate.scripts,
+		},
+	};
+}