create-phoenixjs 0.1.3 → 0.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-phoenixjs",
-	"version": "0.1.3",
+	"version": "0.1.4",
 	"description": "Create a new PhoenixJS project - A TypeScript framework inspired by Laravel, powered by Bun",
 	"type": "module",
 	"bin": {

package/template/app/controllers/HealthController.ts

@@ -0,0 +1,22 @@
+import { Controller } from '@framework/controller/Controller';
+
+export class HealthController extends Controller {
+	/**
+	 * Health check endpoint
+	 */
+	async check() {
+		return this.json({
+			status: 'healthy',
+			timestamp: new Date().toISOString(),
+			uptime: process.uptime(),
+			service: 'PhoenixJS',
+		});
+	}
+
+	/**
+	 * Ping endpoint
+	 */
+	async ping() {
+		return this.text('pong');
+	}
+}

package/template/app/gateways/EchoGateway.ts

@@ -0,0 +1,58 @@
+/**
+ * PhoenixJS - Echo Gateway (Sample)
+ * 
+ * A simple WebSocket gateway that echoes messages back to the sender.
+ */
+
+import type { ServerWebSocket } from 'bun';
+import { WebSocketGateway } from '@framework/gateway/WebSocketGateway';
+import type { WebSocketData } from '@framework/gateway/Gateway';
+
+export class EchoGateway extends WebSocketGateway {
+	readonly name = 'echo';
+	readonly path = '/ws/echo';
+
+	/**
+	 * Called when a connection is opened
+	 */
+	onOpen(ws: ServerWebSocket<WebSocketData>): void {
+		super.onOpen(ws);
+		console.log(`[EchoGateway] Client connected: ${ws.data.connectionId}`);
+
+		// Send welcome message
+		this.sendJson(ws, {
+			type: 'connected',
+			connectionId: ws.data.connectionId,
+			message: 'Welcome to EchoGateway!',
+		});
+	}
+
+	/**
+	 * Called when a message is received - echo it back
+	 */
+	onMessage(ws: ServerWebSocket<WebSocketData>, message: string | Buffer): void {
+		const text = typeof message === 'string' ? message : message.toString();
+		console.log(`[EchoGateway] Received: ${text}`);
+
+		// Try to parse as JSON
+		try {
+			const data = JSON.parse(text);
+			this.sendJson(ws, {
+				type: 'echo',
+				original: data,
+				timestamp: Date.now(),
+			});
+		} catch {
+			// Not JSON, echo as plain text
+			this.send(ws, `Echo: ${text}`);
+		}
+	}
+
+	/**
+	 * Called when a connection is closed
+	 */
+	onClose(ws: ServerWebSocket<WebSocketData>, code: number, reason: string): void {
+		console.log(`[EchoGateway] Client disconnected: ${ws.data.connectionId} (${code}: ${reason})`);
+		super.onClose(ws, code, reason);
+	}
+}

package/template/bootstrap/app.ts

@@ -7,6 +7,7 @@
 import { Application } from '@framework/core/Application';
 import { Kernel } from '@framework/core/Kernel';
 import { registerRoutes } from '@/routes/api';
+import { appConfig } from '@/config/app';
 
 /**
  * Create and configure the application
@@ -15,13 +16,7 @@ export function createApplication(): Application {
 	const app = Application.create();
 
 	// Configure application
-	app.configure({
-		name: 'PhoenixJS',
-		env: (process.env.NODE_ENV as 'development' | 'production' | 'testing') ?? 'development',
-		debug: process.env.DEBUG === 'true' || process.env.NODE_ENV !== 'production',
-		port: parseInt(process.env.PORT ?? '4000', 10),
-		host: process.env.HOST ?? 'localhost',
-	});
+	app.configure(appConfig);
 
 	return app;
 }

package/template/config/app.ts

@@ -0,0 +1,12 @@
+import type { AppConfig } from '@framework/core/Application';
+
+export const appConfig: AppConfig = {
+	name: process.env.APP_NAME || 'PhoenixJS',
+	env: (process.env.NODE_ENV as 'development' | 'production' | 'testing') || 'development',
+	debug: process.env.DEBUG === 'true' || process.env.NODE_ENV !== 'production',
+	port: parseInt(process.env.PORT || '4000', 10),
+	host: process.env.HOST || 'localhost',
+	logging: {
+		enabled: process.env.LOGGING_ENABLED !== 'false',
+	},
+};

package/template/framework/core/Application.ts

@@ -10,6 +10,7 @@ import { PluginManager } from '@framework/plugin/PluginManager';
 import { Plugin } from '@framework/plugin/Plugin';
 import { GatewayManager } from '@framework/gateway/GatewayManager';
 import { SecurityManager } from '@framework/security/SecurityManager';
+import { Logger } from '@framework/log/Logger';
 import type { Gateway } from '@framework/gateway/Gateway';
 import type { SecurityConfig } from '@/config/security';
 
@@ -22,6 +23,9 @@ export interface AppConfig {
 	plugins?: Plugin[];
 	gateways?: Gateway[];
 	security?: Partial<SecurityConfig>;
+	logging?: {
+		enabled?: boolean;
+	};
 }
 
 const defaultConfig: AppConfig = {
@@ -30,6 +34,9 @@ const defaultConfig: AppConfig = {
 	debug: true,
 	port: 4000,
 	host: 'localhost',
+	logging: {
+		enabled: true
+	}
 };
 
 export class Application extends Container {
@@ -40,6 +47,7 @@ export class Application extends Container {
 	private pluginManager: PluginManager;
 	private gatewayManager: GatewayManager;
 	private securityManager: SecurityManager;
+	private logger: Logger;
 
 	constructor(basePath: string = process.cwd()) {
 		super();
@@ -48,6 +56,7 @@ export class Application extends Container {
 		this.pluginManager = new PluginManager(this);
 		this.gatewayManager = new GatewayManager(this);
 		this.securityManager = new SecurityManager(this);
+		this.logger = new Logger('Application');
 		this.registerBaseBindings();
 	}
 
@@ -78,6 +87,7 @@ export class Application extends Container {
 		this.instance('pluginManager', this.pluginManager);
 		this.instance('gatewayManager', this.gatewayManager);
 		this.instance('securityManager', this.securityManager);
+		this.instance('logger', this.logger);
 	}
 
 	/**
@@ -87,6 +97,11 @@ export class Application extends Container {
 		this.config = { ...this.config, ...config };
 		this.instance('config', this.config);
 
+		// Configure Logger
+		if (this.config.logging) {
+			Logger.configure(this.config.logging);
+		}
+
 		// Register plugins from config
 		if (this.config.plugins) {
 			this.config.plugins.forEach(plugin => {

package/template/framework/log/Logger.ts

@@ -0,0 +1,195 @@
+/**
+ * PhoenixJS - Logger
+ * 
+ * A NestJS-inspired logger service with color support, timestamps, and context.
+ */
+
+export type LogLevel = 'log' | 'error' | 'warn' | 'debug' | 'verbose';
+
+export class Logger {
+	private static instance: Logger;
+	private context?: string;
+	private static isDebugMode = process.env.NODE_ENV !== 'production';
+	private static isEnabled = true;
+
+	// ANSI Colors
+	private static readonly COLORS = {
+		reset: '\x1b[0m',
+		bright: '\x1b[1m',
+		dim: '\x1b[2m',
+		underscore: '\x1b[4m',
+		blink: '\x1b[5m',
+		reverse: '\x1b[7m',
+		hidden: '\x1b[8m',
+
+		fgBlack: '\x1b[30m',
+		fgRed: '\x1b[31m',
+		fgGreen: '\x1b[32m',
+		fgYellow: '\x1b[33m',
+		fgBlue: '\x1b[34m',
+		fgMagenta: '\x1b[35m',
+		fgCyan: '\x1b[36m',
+		fgWhite: '\x1b[37m',
+
+		bgBlack: '\x1b[40m',
+		bgRed: '\x1b[41m',
+		bgGreen: '\x1b[42m',
+		bgYellow: '\x1b[43m',
+		bgBlue: '\x1b[44m',
+		bgMagenta: '\x1b[45m',
+		bgCyan: '\x1b[46m',
+		bgWhite: '\x1b[47m',
+	};
+
+	constructor(context?: string) {
+		this.context = context;
+	}
+
+	/**
+	 * Configure the logger
+	 */
+	static configure(options: { enabled?: boolean }): void {
+		if (options.enabled !== undefined) {
+			Logger.isEnabled = options.enabled;
+		}
+	}
+
+	/**
+	 * Set the logger context
+	 */
+	setContext(context: string): void {
+		this.context = context;
+	}
+
+	/**
+	 * Log a message (Level: LOG)
+	 */
+	log(message: any, context?: string): void {
+		if (!Logger.isEnabled) return;
+		this.printMessage('log', message, context || this.context);
+	}
+
+	/**
+	 * Log an error message (Level: ERROR)
+	 */
+	error(message: any, trace?: string, context?: string): void {
+		if (!Logger.isEnabled) return;
+		this.printMessage('error', message, context || this.context, trace);
+	}
+
+	/**
+	 * Log a warning message (Level: WARN)
+	 */
+	warn(message: any, context?: string): void {
+		if (!Logger.isEnabled) return;
+		this.printMessage('warn', message, context || this.context);
+	}
+
+	/**
+	 * Log a debug message (Level: DEBUG)
+	 */
+	debug(message: any, context?: string): void {
+		if (!Logger.isEnabled || !Logger.isDebugMode) return;
+		this.printMessage('debug', message, context || this.context);
+	}
+
+	/**
+	 * Log a verbose message (Level: VERBOSE)
+	 */
+	verbose(message: any, context?: string): void {
+		if (!Logger.isEnabled || !Logger.isDebugMode) return;
+		this.printMessage('verbose', message, context || this.context);
+	}
+
+	/**
+	 * Static method to log a message
+	 */
+	static log(message: any, context?: string): void {
+		new Logger(context).log(message);
+	}
+
+	/**
+	 * Static method to log an error
+	 */
+	static error(message: any, trace?: string, context?: string): void {
+		new Logger(context).error(message, trace);
+	}
+
+	/**
+	 * Static method to log a warning
+	 */
+	static warn(message: any, context?: string): void {
+		new Logger(context).warn(message);
+	}
+
+	/**
+	 * Static method to log debug
+	 */
+	static debug(message: any, context?: string): void {
+		new Logger(context).debug(message);
+	}
+
+	/**
+	 * Static method to log verbose
+	 */
+	static verbose(message: any, context?: string): void {
+		new Logger(context).verbose(message);
+	}
+
+	/**
+	 * Print the log message with formatting
+	 */
+	private printMessage(level: LogLevel, message: any, context: string = 'System', trace?: string): void {
+		const timestamp = new Date().toLocaleString();
+		const pid = process.pid;
+		const color = this.getColor(level);
+		const reset = Logger.COLORS.reset;
+		const bright = Logger.COLORS.bright;
+		const dim = Logger.COLORS.dim;
+		const yellow = Logger.COLORS.fgYellow;
+
+		// Format: [AppName] PID - Timestamp   LEVEL [Context] Message
+		// Example: [PhoenixJS] 1234 - 1/5/2026, 10:00:00 AM   LOG [Router] Route registered
+
+		const appName = `[PhoenixJS]`;
+		const pidStr = `${pid}`;
+		const timeStr = timestamp;
+		const levelStr = level.toUpperCase().padEnd(7);
+		const contextStr = `[${context}]`;
+
+		let output = '';
+
+		// Green AppName
+		output += `${Logger.COLORS.fgGreen}${appName}${reset} `;
+		// Yellow PID
+		output += `${yellow}${pidStr}${reset}  - `;
+		// White Timestamp
+		output += `${timeStr}   `;
+		// Configured Color Level
+		output += `${color}${levelStr}${reset} `;
+		// Yellow Context
+		output += `${yellow}${contextStr}${reset} `;
+		// Message
+		output += `${color}${typeof message === 'object' ? JSON.stringify(message, null, 2) : message}${reset}`;
+
+		if (trace) {
+			output += `\n${Logger.COLORS.fgRed}${trace}${reset}`;
+		}
+
+		console.log(output);
+	}
+
+	/**
+	 * Get ANSI color for log level
+	 */
+	private getColor(level: LogLevel): string {
+		switch (level) {
+			case 'log': return Logger.COLORS.fgGreen;
+			case 'error': return Logger.COLORS.fgRed;
+			case 'warn': return Logger.COLORS.fgYellow;
+			case 'debug': return Logger.COLORS.fgMagenta;
+			case 'verbose': return Logger.COLORS.fgCyan;
+			default: return Logger.COLORS.fgWhite;
+		}
+	}
+}

package/template/routes/api.ts

@@ -1,56 +1,34 @@
 import { Router } from '@framework/routing/Router';
 import { FrameworkResponse as Response } from '@framework/http/Response';
 
-/**
- * API Routes
- * 
- * Define your API routes here. These routes are loaded by the kernel
- * and all routes here will have the /api prefix.
- */
 export function registerRoutes() {
-	// Health check endpoint
-	Router.get('/health', () => {
+
+	Router.get('/', () => {
 		return Response.json({
-			status: 'ok',
-			timestamp: new Date().toISOString(),
+			name: 'PhoenixJS',
+			version: '0.1.0',
+			message: 'Welcome to PhoenixJS'
 		});
 	});
 
-	// Welcome endpoint
-	Router.get('/hello', () => {
+	Router.get('/health', () => {
 		return Response.json({
-			message: 'Welcome to PhoenixJS! 🚀',
+			status: 'healthy',
+			timestamp: new Date().toISOString(),
+			uptime: process.uptime()
 		});
 	});
 
-	// Example API group with routes
+	// Sample API group
 	Router.group({ prefix: '/api' }, () => {
-		// Ping endpoint
 		Router.get('/ping', () => Response.json({ message: 'pong' }));
 
-		// Example with route parameter
 		Router.get('/users/:id', () => {
-			return Response.json({
-				user: { id: '1', name: 'John Doe' },
-			});
+			return Response.json({ id: '123' });
 		});
 
-		// Example POST route (use Controller for real implementations)
-		Router.post('/users', () => {
-			return Response.json({
-				message: 'User created',
-			}, 201);
+		Router.group({ prefix: '/v1' }, () => {
+			Router.get('/count', () => Response.json({ count: 1 }));
 		});
 	});
-
-	/**
-	 * Route Groups Example
-	 * 
-	 * You can use Controllers with the 'ControllerName@method' syntax:
-	 * 
-	 * Router.group({ prefix: '/v1', middleware: [] }, () => {
-	 *     Router.get('/products', 'ProductController@index');
-	 *     Router.post('/products', 'ProductController@store');
-	 * });
-	 */
 }

package/template/app/controllers/ExampleController.ts

@@ -1,61 +0,0 @@
-import { Controller } from '@framework/controller/Controller';
-
-/**
- * Example Controller
- * 
- * This is a sample controller to get you started.
- * Generate new controllers using: bun artisan make:controller <name>
- */
-export class ExampleController extends Controller {
-	/**
-	 * Display a listing of the resource.
-	 */
-	async index() {
-		return this.json({
-			message: 'Welcome to PhoenixJS!',
-			items: [],
-		});
-	}
-
-	/**
-	 * Display the specified resource.
-	 */
-	async show() {
-		const id = this.param('id');
-		return this.json({
-			id,
-			message: `Showing resource ${id}`,
-		});
-	}
-
-	/**
-	 * Store a newly created resource.
-	 */
-	async store() {
-		const data = await this.request.json();
-		return this.json({
-			message: 'Resource created successfully',
-			data,
-		}, 201);
-	}
-
-	/**
-	 * Update the specified resource.
-	 */
-	async update() {
-		const id = this.param('id');
-		const data = await this.request.json();
-		return this.json({
-			message: `Resource ${id} updated`,
-			data,
-		});
-	}
-
-	/**
-	 * Remove the specified resource.
-	 */
-	async destroy() {
-		const id = this.param('id');
-		return this.noContent();
-	}
-}