create-phoenixjs 0.1.3 → 0.1.5

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "create-phoenixjs",
-	"version": "0.1.3",
+	"version": "0.1.5",
 	"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/config/database.ts

@@ -1,7 +1,19 @@
 export default {
-	default: 'prisma',
+	default: process.env.DB_CONNECTION || 'postgres',
 
 	connections: {
+		postgres: {
+			driver: 'postgres',
+			host: process.env.DB_HOST || 'localhost',
+			port: parseInt(process.env.DB_PORT || '5432'),
+			database: process.env.DB_DATABASE || 'phoenix',
+			username: process.env.DB_USERNAME || 'root',
+			password: process.env.DB_PASSWORD || '',
+			max: 10, // Max connections in pool
+			idle_timeout: 20, // Idle timeout in seconds
+			connect_timeout: 10, // Connection timeout in seconds
+		},
+
 		prisma: {
 			driver: 'prisma',
 			// Prisma usually relies on .env DATABASE_URL, but we can put pool config here

package/template/database/migrations/2024_01_01_000000_create_test_users_cli_table.ts

@@ -0,0 +1,16 @@
+import { Schema, Blueprint } from '@framework/database/schema';
+import { Migration } from '@framework/database/migrations';
+
+export default class CreateUsersTable implements Migration {
+	async up(): Promise<void> {
+		await Schema.create('test_users_cli', (table: Blueprint) => {
+			table.id();
+			table.string('name');
+			table.timestamps();
+		});
+	}
+
+	async down(): Promise<void> {
+		await Schema.dropIfExists('test_users_cli');
+	}
+}

package/template/database/migrations/20260108164611_TestCliMigration.ts

@@ -0,0 +1,16 @@
+
+import { Schema, Blueprint } from '@framework/database/schema';
+import { Migration } from '@framework/database/migrations';
+
+export class TestCliMigration implements Migration {
+    async up() {
+        await Schema.create('test_cli_table', (table) => {
+            table.id();
+            table.string('name');
+        });
+    }
+
+    async down() {
+        await Schema.dropIfExists('test_cli_table');
+    }
+}

package/template/database/migrations/2026_01_08_16_46_11_CreateTestMigrationsTable.ts

@@ -0,0 +1,21 @@
+import { Schema, Blueprint } from '@framework/database/schema';
+import { Migration } from '@framework/database/migrations';
+
+export class CreateTestMigrationsTable implements Migration {
+    /**
+     * Run the migrations.
+     */
+    async up(): Promise<void> {
+        // await Schema.create('table_name', (table: Blueprint) => {
+        //     table.id();
+        //     table.timestamps();
+        // });
+    }
+
+    /**
+     * Reverse the migrations.
+     */
+    async down(): Promise<void> {
+        // await Schema.dropIfExists('table_name');
+    }
+}

package/template/framework/cli/artisan.ts

@@ -3,6 +3,11 @@ import { MakeControllerCommand } from './commands/MakeControllerCommand';
 import { MakeValidatorCommand } from './commands/MakeValidatorCommand';
 import { MakeModelCommand } from './commands/MakeModelCommand';
 import { MakeMiddlewareCommand } from './commands/MakeMiddlewareCommand';
+import { MakeMigrationCommand } from '../database/console/MakeMigrationCommand';
+import { MigrateCommand } from '../database/console/MigrateCommand';
+import { MigrateRollbackCommand } from '../database/console/MigrateRollbackCommand';
+import { MigrateResetCommand } from '../database/console/MigrateResetCommand';
+import { MigrateStatusCommand } from '../database/console/MigrateStatusCommand';
 
 const app = new ConsoleApplication();
 
@@ -12,5 +17,12 @@ app.register(new MakeValidatorCommand());
 app.register(new MakeModelCommand());
 app.register(new MakeMiddlewareCommand());
 
+// Database Commands
+app.register(new MakeMigrationCommand());
+app.register(new MigrateCommand());
+app.register(new MigrateRollbackCommand());
+app.register(new MigrateResetCommand());
+app.register(new MigrateStatusCommand());
+
 // Run
 await app.run(process.argv);

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/database/DatabaseManager.ts

@@ -0,0 +1,133 @@
+/**
+ * PhoenixJS ORM - DatabaseManager
+ *
+ * Main entry point for database operations.
+ * Manages connections, provides default connection, and proxies query methods.
+ */
+
+import type { Connection, ConnectionConfig } from './connection/Connection';
+import { ConnectionFactory } from './connection/ConnectionFactory';
+
+export interface DatabaseConfig {
+	default: string;
+	connections: Record<string, ConnectionConfig>;
+}
+
+export class DatabaseManager {
+	private factory: ConnectionFactory;
+	private connections: Map<string, Connection> = new Map();
+	private config: DatabaseConfig;
+
+	constructor(config: DatabaseConfig) {
+		this.config = config;
+		this.factory = new ConnectionFactory();
+	}
+
+	/**
+	 * Get a database connection by name
+	 * Creates the connection if it doesn't exist
+	 */
+	connection(name?: string): Connection {
+		const connectionName = name || this.config.default;
+
+		if (!this.connections.has(connectionName)) {
+			const connectionConfig = this.config.connections[connectionName];
+			if (!connectionConfig) {
+				throw new Error(`Database connection [${connectionName}] not configured.`);
+			}
+
+			const connection = this.factory.make(connectionConfig);
+			this.connections.set(connectionName, connection);
+		}
+
+		return this.connections.get(connectionName)!;
+	}
+
+	/**
+	 * Connect to a database by name (or default)
+	 */
+	async connect(name?: string): Promise<Connection> {
+		const conn = this.connection(name);
+		await conn.connect();
+		return conn;
+	}
+
+	/**
+	 * Disconnect a specific connection
+	 */
+	async disconnect(name?: string): Promise<void> {
+		const connectionName = name || this.config.default;
+		const conn = this.connections.get(connectionName);
+		if (conn) {
+			await conn.disconnect();
+			this.connections.delete(connectionName);
+		}
+	}
+
+	/**
+	 * Disconnect all connections
+	 */
+	async disconnectAll(): Promise<void> {
+		const disconnectPromises = Array.from(this.connections.values()).map((conn) =>
+			conn.disconnect()
+		);
+		await Promise.all(disconnectPromises);
+		this.connections.clear();
+	}
+
+	/**
+	 * Execute a SELECT query on the default connection
+	 */
+	async query<T = unknown>(sql: string, bindings?: unknown[]): Promise<T[]> {
+		return this.connection().query<T>(sql, bindings);
+	}
+
+	/**
+	 * Execute an INSERT/UPDATE/DELETE on the default connection
+	 */
+	async execute(sql: string, bindings?: unknown[]): Promise<number> {
+		return this.connection().execute(sql, bindings);
+	}
+
+	/**
+	 * Get a single row from the default connection
+	 */
+	async get<T = unknown>(sql: string, bindings?: unknown[]): Promise<T | null> {
+		return this.connection().get<T>(sql, bindings);
+	}
+
+	/**
+	 * Execute a transaction on the default connection
+	 */
+	async transaction<T>(callback: (tx: unknown) => Promise<T>): Promise<T> {
+		return this.connection().transaction(callback);
+	}
+
+	/**
+	 * Begin a fluent query against a database table on the default connection
+	 */
+	table(table: string): any {
+		return this.connection().table(table);
+	}
+
+	/**
+	 * Get the default connection name
+	 */
+	getDefaultConnection(): string {
+		return this.config.default;
+	}
+
+	/**
+	 * Get all connection names
+	 */
+	getConnectionNames(): string[] {
+		return Object.keys(this.config.connections);
+	}
+
+	/**
+	 * Check if a connection is active
+	 */
+	hasConnection(name: string): boolean {
+		return this.connections.has(name);
+	}
+}

package/template/framework/database/connection/Connection.ts

@@ -0,0 +1,71 @@
+/**
+ * PhoenixJS ORM - Connection Interface
+ *
+ * Abstract interface for database connections.
+ * All database drivers must implement this interface.
+ */
+
+export interface ConnectionConfig {
+	driver: string;
+	host?: string;
+	port?: number;
+	database?: string;
+	username?: string;
+	password?: string;
+	[key: string]: unknown;
+}
+
+export interface Connection {
+	/**
+	 * Get the driver name
+	 */
+	readonly driver: string;
+
+	/**
+	 * Connect to the database
+	 */
+	connect(): Promise<void>;
+
+	/**
+	 * Disconnect from the database
+	 */
+	disconnect(): Promise<void>;
+
+	/**
+	 * Check if connected
+	 */
+	isConnected(): boolean;
+
+	/**
+	 * Execute a SELECT query and return results
+	 * @param sql SQL query string
+	 * @param bindings Query parameter bindings
+	 */
+	query<T = unknown>(sql: string, bindings?: unknown[]): Promise<T[]>;
+
+	/**
+	 * Execute an INSERT/UPDATE/DELETE query and return affected rows count
+	 * @param sql SQL statement string
+	 * @param bindings Query parameter bindings
+	 */
+	execute(sql: string, bindings?: unknown[]): Promise<number>;
+
+	/**
+	 * Get a single row
+	 * @param sql SQL query string
+	 * @param bindings Query parameter bindings
+	 */
+	get<T = unknown>(sql: string, bindings?: unknown[]): Promise<T | null>;
+
+	/**
+	 * Execute operations within a transaction
+	 * @param callback Transaction callback that receives a transaction SQL instance
+	 */
+	transaction<T>(callback: (tx: unknown) => Promise<T>): Promise<T>;
+
+	/**
+	 * Begin a fluent query against a database table
+	 * @param table The table name
+	 */
+	table(table: string): any; // Return any to avoid circular type dependency for now, or use Builder interface if available
+}

package/template/framework/database/connection/ConnectionFactory.ts

@@ -0,0 +1,30 @@
+/**
+ * PhoenixJS ORM - ConnectionFactory
+ *
+ * Factory class for creating database connections based on configuration.
+ * Supports driver-based connection instantiation.
+ */
+
+import type { Connection, ConnectionConfig } from './Connection';
+import { PostgresConnection, type PostgresConnectionConfig } from './PostgresConnection';
+
+export class ConnectionFactory {
+	/**
+	 * Create a connection instance based on the driver configuration
+	 */
+	make(config: ConnectionConfig): Connection {
+		switch (config.driver) {
+			case 'postgres':
+				return new PostgresConnection(config as PostgresConnectionConfig);
+			default:
+				throw new Error(`Unsupported database driver: ${config.driver}`);
+		}
+	}
+
+	/**
+	 * Get list of supported drivers
+	 */
+	getSupportedDrivers(): string[] {
+		return ['postgres'];
+	}
+}

package/template/framework/database/connection/PostgresConnection.ts

@@ -0,0 +1,159 @@
+/**
+ * PhoenixJS ORM - PostgresConnection
+ *
+ * PostgreSQL connection implementation using postgres.js (porsager/postgres).
+ * Zero-dependency, fastest Postgres driver for Node.js/Bun.
+ */
+
+import postgres, { type Sql, type TransactionSql } from 'postgres';
+import type { Connection, ConnectionConfig } from './Connection';
+import { Builder } from '@framework/database/query/Builder';
+import { PostgresGrammar } from '@framework/database/query/grammars/PostgresGrammar';
+
+export interface PostgresConnectionConfig extends ConnectionConfig {
+	driver: 'postgres';
+	host: string;
+	port: number;
+	database: string;
+	username: string;
+	password: string;
+	max?: number; // Max connections in pool
+	idle_timeout?: number; // Idle connection timeout in seconds
+	connect_timeout?: number; // Connection timeout in seconds
+}
+
+export class PostgresConnection implements Connection {
+	readonly driver = 'postgres';
+
+	private sql: Sql | null = null;
+	private connected = false;
+	private config: PostgresConnectionConfig;
+
+	constructor(config: PostgresConnectionConfig) {
+		this.config = config;
+	}
+
+	/**
+	 * Connect to the PostgreSQL database
+	 */
+	async connect(): Promise<void> {
+		if (this.connected && this.sql) {
+			return;
+		}
+
+		this.sql = postgres({
+			host: this.config.host,
+			port: this.config.port,
+			database: this.config.database,
+			username: this.config.username,
+			password: this.config.password,
+			max: this.config.max ?? 10,
+			idle_timeout: this.config.idle_timeout ?? 20,
+			connect_timeout: this.config.connect_timeout ?? 10,
+		});
+
+		// Test the connection
+		await this.sql`SELECT 1`;
+		this.connected = true;
+	}
+
+	/**
+	 * Disconnect from the database
+	 */
+	async disconnect(): Promise<void> {
+		if (this.sql) {
+			await this.sql.end();
+			this.sql = null;
+			this.connected = false;
+		}
+	}
+
+	/**
+	 * Check if connected to the database
+	 */
+	isConnected(): boolean {
+		return this.connected;
+	}
+
+	/**
+	 * Execute a SELECT query and return results
+	 */
+	async query<T = unknown>(sql: string, bindings: unknown[] = []): Promise<T[]> {
+		this.ensureConnected();
+		const result = await this.sql!.unsafe(sql, bindings as (string | number | boolean | null)[]);
+		return result as unknown as T[];
+	}
+
+	/**
+	 * Execute an INSERT/UPDATE/DELETE query and return affected rows count
+	 */
+	async execute(sql: string, bindings: unknown[] = []): Promise<number> {
+		this.ensureConnected();
+		const result = await this.sql!.unsafe(sql, bindings as (string | number | boolean | null)[]);
+		return result.count;
+	}
+
+	/**
+	 * Get a single row
+	 */
+	async get<T = unknown>(sql: string, bindings: unknown[] = []): Promise<T | null> {
+		const results = await this.query<T>(sql, bindings);
+		return results.length > 0 ? results[0] : null;
+	}
+
+	/**
+	 * Execute operations within a transaction.
+	 * The callback receives a transaction-scoped SQL instance.
+	 */
+	async transaction<T>(callback: (sql: TransactionSql) => Promise<T>): Promise<T> {
+		this.ensureConnected();
+
+		const result = await this.sql!.begin(async (txSql) => {
+			return callback(txSql);
+		});
+		return result as T;
+	}
+
+	/**
+	 * Execute a transaction query (for use inside transactions)
+	 */
+	async txQuery<T = unknown>(
+		txSql: TransactionSql,
+		sql: string,
+		bindings: unknown[] = []
+	): Promise<T[]> {
+		const result = await txSql.unsafe(sql, bindings as (string | number | boolean | null)[]);
+		return result as unknown as T[];
+	}
+
+	/**
+	 * Execute a transaction statement (for use inside transactions)
+	 */
+	async txExecute(txSql: TransactionSql, sql: string, bindings: unknown[] = []): Promise<number> {
+		const result = await txSql.unsafe(sql, bindings as (string | number | boolean | null)[]);
+		return result.count;
+	}
+
+	/**
+	 * Get the underlying postgres.js SQL instance
+	 */
+	getSql(): Sql | null {
+		return this.sql;
+	}
+
+	/**
+	 * Begin a fluent query against a database table
+	 */
+	table(table: string): Builder {
+		return new Builder(this, new PostgresGrammar(), table);
+	}
+
+	/**
+	 * Ensure we have an active connection
+	 */
+	private ensureConnected(): void {
+		if (!this.connected || !this.sql) {
+			throw new Error('Database not connected. Call connect() first.');
+		}
+	}
+}