create-phoenixjs 0.1.0

package/template/framework/cli/commands/MakeControllerCommand.ts

@@ -0,0 +1,41 @@
+import { Command } from '../Command';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class MakeControllerCommand extends Command {
+	signature = 'make:controller {name}';
+	description = 'Create a new controller class';
+
+	async handle(args: Record<string, any>): Promise<void> {
+		const name = args.name;
+		if (!name) {
+			console.error('Error: Controller name is required.');
+			return;
+		}
+
+		const className = path.basename(name);
+		// Handle nested directories e.g. user/UserController
+		const relativePath = name.endsWith('.ts') ? name : `${name}.ts`;
+		const fullPath = path.join(process.cwd(), 'app', 'controllers', relativePath);
+		const directory = path.dirname(fullPath);
+
+		if (fs.existsSync(fullPath)) {
+			console.error(`Error: Controller "${name}" already exists.`);
+			return;
+		}
+
+		fs.mkdirSync(directory, { recursive: true });
+
+		const template = `import { Controller } from '@framework/controller/Controller';
+
+export class ${className} extends Controller {
+    async index() {
+        return this.json({ message: 'Hello from ${className}' });
+    }
+}
+`;
+
+		fs.writeFileSync(fullPath, template);
+		console.log(`Controller created successfully: app/controllers/${relativePath}`);
+	}
+}

package/template/framework/cli/commands/MakeMiddlewareCommand.ts

@@ -0,0 +1,41 @@
+import { Command } from '../Command';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class MakeMiddlewareCommand extends Command {
+	signature = 'make:middleware {name}';
+	description = 'Create a new middleware class';
+
+	async handle(args: Record<string, any>): Promise<void> {
+		const name = args.name;
+		if (!name) {
+			console.error('Error: Middleware name is required.');
+			return;
+		}
+
+		const className = path.basename(name);
+		const relativePath = name.endsWith('.ts') ? name : `${name}.ts`;
+		const fullPath = path.join(process.cwd(), 'app', 'middlewares', relativePath);
+		const directory = path.dirname(fullPath);
+
+		if (fs.existsSync(fullPath)) {
+			console.error(`Error: Middleware "${name}" already exists.`);
+			return;
+		}
+
+		fs.mkdirSync(directory, { recursive: true });
+
+		const template = `import { Middleware, MiddlewareHandler, NextFunction, Request, Response } from '@framework/middleware/Middleware';
+
+export class ${className} implements Middleware {
+    async handle(request: Request, next: NextFunction): Promise<Response | any> {
+        // middleware logic
+        return next(request);
+    }
+}
+`;
+
+		fs.writeFileSync(fullPath, template);
+		console.log(`Middleware created successfully: app/middlewares/${relativePath}`);
+	}
+}

package/template/framework/cli/commands/MakeModelCommand.ts

@@ -0,0 +1,36 @@
+import { Command } from '../Command';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class MakeModelCommand extends Command {
+	signature = 'make:model {name}';
+	description = 'Create a new model class';
+
+	async handle(args: Record<string, any>): Promise<void> {
+		const name = args.name;
+		if (!name) {
+			console.error('Error: Model name is required.');
+			return;
+		}
+
+		const className = path.basename(name);
+		const relativePath = name.endsWith('.ts') ? name : `${name}.ts`;
+		const fullPath = path.join(process.cwd(), 'app', 'models', relativePath);
+		const directory = path.dirname(fullPath);
+
+		if (fs.existsSync(fullPath)) {
+			console.error(`Error: Model "${name}" already exists.`);
+			return;
+		}
+
+		fs.mkdirSync(directory, { recursive: true });
+
+		const template = `export class ${className} {
+    // Model definition
+}
+`;
+
+		fs.writeFileSync(fullPath, template);
+		console.log(`Model created successfully: app/models/${relativePath}`);
+	}
+}

package/template/framework/cli/commands/MakeValidatorCommand.ts

@@ -0,0 +1,42 @@
+import { Command } from '../Command';
+import fs from 'node:fs';
+import path from 'node:path';
+
+export class MakeValidatorCommand extends Command {
+	signature = 'make:validator {name}';
+	description = 'Create a new validator class';
+
+	async handle(args: Record<string, any>): Promise<void> {
+		const name = args.name;
+		if (!name) {
+			console.error('Error: Validator name is required.');
+			return;
+		}
+
+		const className = path.basename(name);
+		const relativePath = name.endsWith('.ts') ? name : `${name}.ts`;
+		const fullPath = path.join(process.cwd(), 'app', 'validators', relativePath);
+		const directory = path.dirname(fullPath);
+
+		if (fs.existsSync(fullPath)) {
+			console.error(`Error: Validator "${name}" already exists.`);
+			return;
+		}
+
+		fs.mkdirSync(directory, { recursive: true });
+
+		const template = `import { Validator } from '@framework/validation/Validator';
+
+export class ${className} extends Validator {
+    rules() {
+        return {
+            // 'field': ['required', 'string']
+        };
+    }
+}
+`;
+
+		fs.writeFileSync(fullPath, template);
+		console.log(`Validator created successfully: app/validators/${relativePath}`);
+	}
+}

package/template/framework/controller/Controller.ts

@@ -0,0 +1,222 @@
+/**
+ * PhoenixJS - Base Controller
+ * 
+ * Abstract base class for all controllers.
+ * Provides request injection and response helpers.
+ */
+
+import { FrameworkRequest } from '@framework/http/Request';
+import { FrameworkResponse, ResponseBuilder } from '@framework/http/Response';
+import type { ValidationResult } from '@framework/validation/Validator';
+
+/**
+ * Controller constructor type for dependency injection
+ */
+export interface ControllerConstructor {
+	new(): Controller;
+}
+
+/**
+ * Base Controller class
+ * 
+ * All application controllers should extend this class.
+ * Provides access to the current request and response helpers.
+ */
+export abstract class Controller {
+	/**
+	 * The current request instance (injected by Kernel)
+	 */
+	protected request!: FrameworkRequest;
+
+	/**
+	 * Route parameters (injected by Kernel)
+	 */
+	protected params: Record<string, string> = {};
+
+	/**
+	 * Set the request instance (called by Kernel)
+	 */
+	setRequest(request: FrameworkRequest): void {
+		this.request = request;
+	}
+
+	/**
+	 * Set route parameters (called by Kernel)
+	 */
+	setParams(params: Record<string, string>): void {
+		this.params = params;
+	}
+
+	/**
+	 * Get a route parameter
+	 */
+	protected param(key: string, defaultValue?: string): string | undefined {
+		return this.params[key] ?? defaultValue;
+	}
+
+	// ==========================================
+	// Response Helpers
+	// ==========================================
+
+	/**
+	 * Return a JSON response
+	 */
+	protected json(data: unknown, status = 200): Response {
+		return FrameworkResponse.json(data, status);
+	}
+
+	/**
+	 * Return a text response
+	 */
+	protected text(content: string, status = 200): Response {
+		return FrameworkResponse.text(content, status);
+	}
+
+	/**
+	 * Return an HTML response
+	 */
+	protected html(content: string, status = 200): Response {
+		return FrameworkResponse.html(content, status);
+	}
+
+	/**
+	 * Return an XML response
+	 */
+	protected xml(content: string, status = 200): Response {
+		return FrameworkResponse.xml(content, status);
+	}
+
+	/**
+	 * Return a redirect response
+	 */
+	protected redirect(url: string, permanent = false): Response {
+		return FrameworkResponse.redirect(url, permanent ? 301 : 302);
+	}
+
+	/**
+	 * Return a 204 No Content response
+	 */
+	protected noContent(): Response {
+		return FrameworkResponse.noContent();
+	}
+
+	/**
+	 * Return an error response
+	 */
+	protected error(message: string, status = 500, details?: Record<string, unknown>): Response {
+		return FrameworkResponse.error(message, status, details);
+	}
+
+	/**
+	 * Return a 400 Bad Request response
+	 */
+	protected badRequest(message: string, details?: Record<string, unknown>): Response {
+		return FrameworkResponse.badRequest(message, details);
+	}
+
+	/**
+	 * Return a 401 Unauthorized response
+	 */
+	protected unauthorized(message = 'Unauthorized'): Response {
+		return FrameworkResponse.unauthorized(message);
+	}
+
+	/**
+	 * Return a 403 Forbidden response
+	 */
+	protected forbidden(message = 'Forbidden'): Response {
+		return FrameworkResponse.forbidden(message);
+	}
+
+	/**
+	 * Return a 404 Not Found response
+	 */
+	protected notFound(message = 'Not Found'): Response {
+		return FrameworkResponse.notFound(message);
+	}
+
+	/**
+	 * Return a 422 Validation Error response
+	 */
+	protected validationError(errors: Record<string, string[]>): Response {
+		return FrameworkResponse.validationError(errors);
+	}
+
+	/**
+	 * Create a fluent response builder
+	 */
+	protected response(): ResponseBuilder {
+		return FrameworkResponse.create();
+	}
+
+	// ==========================================
+	// Validation
+	// ==========================================
+
+	/**
+	 * Validate the request input using a Validator class
+	 * 
+	 * @param validatorClass - The Validator class to use
+	 * @returns ValidationResult with passes/fails and errors
+	 */
+	protected async validate<T extends { new(): { validate(data: Record<string, unknown>): ValidationResult } }>(
+		validatorClass: T
+	): Promise<ValidationResult> {
+		const validator = new validatorClass();
+		const data = await this.request.all();
+		return validator.validate(data);
+	}
+
+	/**
+	 * Validate data and return error response if validation fails
+	 * Returns null if validation passes, Response if fails
+	 */
+	protected async validateOrFail<T extends { new(): { validate(data: Record<string, unknown>): ValidationResult } }>(
+		validatorClass: T
+	): Promise<Response | null> {
+		const result = await this.validate(validatorClass);
+		if (!result.passes) {
+			return this.validationError(result.errors);
+		}
+		return null;
+	}
+
+	// ==========================================
+	// Request Helpers
+	// ==========================================
+
+	/**
+	 * Get the current request
+	 */
+	protected getRequest(): FrameworkRequest {
+		return this.request;
+	}
+
+	/**
+	 * Get all input data
+	 */
+	protected async all(): Promise<Record<string, unknown>> {
+		return this.request.all();
+	}
+
+	/**
+	 * Get an input value
+	 */
+	protected async input<T = unknown>(key?: string, defaultValue?: T): Promise<T | Record<string, unknown>> {
+		return this.request.input(key, defaultValue);
+	}
+
+	/**
+	 * Get only specified input keys
+	 */
+	protected async only(...keys: string[]): Promise<Record<string, unknown>> {
+		return this.request.only(...keys);
+	}
+
+	/**
+	 * Get all input except specified keys
+	 */
+	protected async except(...keys: string[]): Promise<Record<string, unknown>> {
+		return this.request.except(...keys);
+	}
+}

package/template/framework/core/Application.ts

@@ -0,0 +1,208 @@
+/**
+ * PhoenixJS - Application
+ * 
+ * The main application class that bootstraps the framework.
+ * Extends Container to provide dependency injection capabilities.
+ */
+
+import { Container } from '@framework/core/Container';
+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 type { Gateway } from '@framework/gateway/Gateway';
+import type { SecurityConfig } from '@/config/security';
+
+export interface AppConfig {
+	name: string;
+	env: 'development' | 'production' | 'testing';
+	debug: boolean;
+	port: number;
+	host: string;
+	plugins?: Plugin[];
+	gateways?: Gateway[];
+	security?: Partial<SecurityConfig>;
+}
+
+const defaultConfig: AppConfig = {
+	name: 'PhoenixJS',
+	env: 'development',
+	debug: true,
+	port: 4000,
+	host: 'localhost',
+};
+
+export class Application extends Container {
+	private static instance: Application | null = null;
+	private config: AppConfig;
+	private booted = false;
+	private basePath: string;
+	private pluginManager: PluginManager;
+	private gatewayManager: GatewayManager;
+	private securityManager: SecurityManager;
+
+	constructor(basePath: string = process.cwd()) {
+		super();
+		this.basePath = basePath;
+		this.config = { ...defaultConfig };
+		this.pluginManager = new PluginManager(this);
+		this.gatewayManager = new GatewayManager(this);
+		this.securityManager = new SecurityManager(this);
+		this.registerBaseBindings();
+	}
+
+	/**
+	 * Get the singleton application instance
+	 */
+	static getInstance(): Application {
+		if (!Application.instance) {
+			throw new Error('Application has not been initialized');
+		}
+		return Application.instance;
+	}
+
+	/**
+	 * Create a new application instance
+	 */
+	static create(basePath?: string): Application {
+		Application.instance = new Application(basePath);
+		return Application.instance;
+	}
+
+	/**
+	 * Register base bindings
+	 */
+	private registerBaseBindings(): void {
+		this.instance('app', this);
+		this.instance('config', this.config);
+		this.instance('pluginManager', this.pluginManager);
+		this.instance('gatewayManager', this.gatewayManager);
+		this.instance('securityManager', this.securityManager);
+	}
+
+	/**
+	 * Configure the application
+	 */
+	configure(config: Partial<AppConfig>): this {
+		this.config = { ...this.config, ...config };
+		this.instance('config', this.config);
+
+		// Register plugins from config
+		if (this.config.plugins) {
+			this.config.plugins.forEach(plugin => {
+				this.registerPlugin(plugin);
+			});
+		}
+
+		// Register gateways from config
+		if (this.config.gateways) {
+			this.config.gateways.forEach(gateway => {
+				this.registerGateway(gateway);
+			});
+		}
+
+		// Configure security from config
+		if (this.config.security) {
+			this.securityManager.configure(this.config.security);
+		}
+
+		return this;
+	}
+
+	/**
+	 * Register a plugin
+	 */
+	registerPlugin(plugin: Plugin): this {
+		this.pluginManager.register(plugin);
+		return this;
+	}
+
+	/**
+	 * Get the plugin manager
+	 */
+	getPluginManager(): PluginManager {
+		return this.pluginManager;
+	}
+
+	/**
+	 * Register a gateway
+	 */
+	registerGateway(gateway: Gateway): this {
+		this.gatewayManager.register(gateway);
+		return this;
+	}
+
+	/**
+	 * Get the gateway manager
+	 */
+	getGatewayManager(): GatewayManager {
+		return this.gatewayManager;
+	}
+
+	/**
+	 * Get the security manager
+	 */
+	getSecurityManager(): SecurityManager {
+		return this.securityManager;
+	}
+
+	/**
+	 * Get configuration value
+	 */
+	getConfig<K extends keyof AppConfig>(key: K): AppConfig[K] {
+		return this.config[key];
+	}
+
+	/**
+	 * Get full configuration
+	 */
+	getAllConfig(): AppConfig {
+		return { ...this.config };
+	}
+
+	/**
+	 * Get the base path
+	 */
+	getBasePath(): string {
+		return this.basePath;
+	}
+
+	/**
+	 * Check if application is booted
+	 */
+	isBooted(): boolean {
+		return this.booted;
+	}
+
+	/**
+	 * Boot the application
+	 */
+	boot(): this {
+		if (this.booted) {
+			return this;
+		}
+
+		// Boot all plugins
+		this.pluginManager.boot();
+
+		// Boot all gateways
+		this.gatewayManager.boot();
+
+		this.booted = true;
+		return this;
+	}
+
+	/**
+	 * Get environment
+	 */
+	environment(): string {
+		return this.config.env;
+	}
+
+	/**
+	 * Check if in debug mode
+	 */
+	isDebug(): boolean {
+		return this.config.debug;
+	}
+}

package/template/framework/core/Container.ts

@@ -0,0 +1,100 @@
+/**
+ * PhoenixJS - Dependency Injection Container
+ * 
+ * A simple IoC container for managing dependencies.
+ */
+
+type Factory<T> = () => T;
+type Constructor<T> = new (...args: unknown[]) => T;
+
+interface Binding<T> {
+	resolver: Factory<T>;
+	singleton: boolean;
+	instance?: T;
+}
+
+export class Container {
+	private bindings: Map<string, Binding<unknown>> = new Map();
+	private instances: Map<string, unknown> = new Map();
+
+	/**
+	 * Register a binding in the container
+	 */
+	bind<T>(abstract: string, resolver: Factory<T>, singleton = false): this {
+		this.bindings.set(abstract, {
+			resolver,
+			singleton,
+			instance: undefined,
+		});
+		return this;
+	}
+
+	/**
+	 * Register a singleton binding
+	 */
+	singleton<T>(abstract: string, resolver: Factory<T>): this {
+		return this.bind(abstract, resolver, true);
+	}
+
+	/**
+	 * Register an existing instance in the container
+	 */
+	instance<T>(abstract: string, instance: T): this {
+		this.instances.set(abstract, instance);
+		return this;
+	}
+
+	/**
+	 * Resolve a binding from the container
+	 */
+	make<T>(abstract: string): T {
+		// Check if we have a direct instance
+		if (this.instances.has(abstract)) {
+			return this.instances.get(abstract) as T;
+		}
+
+		// Check if we have a binding
+		const binding = this.bindings.get(abstract);
+		if (!binding) {
+			throw new Error(`No binding found for: ${abstract}`);
+		}
+
+		// If it's a singleton and we have an instance, return it
+		if (binding.singleton && binding.instance !== undefined) {
+			return binding.instance as T;
+		}
+
+		// Resolve the binding
+		const instance = binding.resolver() as T;
+
+		// Store singleton instance
+		if (binding.singleton) {
+			binding.instance = instance;
+		}
+
+		return instance;
+	}
+
+	/**
+	 * Check if a binding exists
+	 */
+	has(abstract: string): boolean {
+		return this.bindings.has(abstract) || this.instances.has(abstract);
+	}
+
+	/**
+	 * Remove a binding from the container
+	 */
+	forget(abstract: string): void {
+		this.bindings.delete(abstract);
+		this.instances.delete(abstract);
+	}
+
+	/**
+	 * Clear all bindings
+	 */
+	flush(): void {
+		this.bindings.clear();
+		this.instances.clear();
+	}
+}