create-phoenixjs 0.1.4 → 0.1.6

package/package.json

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

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/20260108165704_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_57_04_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/cli/commands/MakeModelCommand.ts

@@ -6,7 +6,7 @@ export class MakeModelCommand extends Command {
 	signature = 'make:model {name}';
 	description = 'Create a new model class';
 
-	async handle(args: Record<string, any>): Promise<void> {
+	async handle(args: Record<string, string>): Promise<void> {
 		const name = args.name;
 		if (!name) {
 			console.error('Error: Model name is required.');
@@ -25,12 +25,42 @@ export class MakeModelCommand extends Command {
 
 		fs.mkdirSync(directory, { recursive: true });
 
-		const template = `export class ${className} {
-    // Model definition
+		// Generate snake_case table name from class name (e.g., UserProfile -> user_profiles)
+		const tableName = this.generateTableName(className);
+
+		const template = `import { Model } from '@framework/database/orm/Model';
+
+export class ${className} extends Model {
+    protected table = '${tableName}';
+    protected fillable: string[] = [];
 }
 `;
 
 		fs.writeFileSync(fullPath, template);
 		console.log(`Model created successfully: app/models/${relativePath}`);
 	}
+
+	/**
+	 * Generate a table name from the class name.
+	 * Converts PascalCase to snake_case and pluralizes.
+	 * e.g., User -> users, UserProfile -> user_profiles
+	 */
+	private generateTableName(className: string): string {
+		// Convert PascalCase to snake_case
+		let result = '';
+		for (let i = 0; i < className.length; i++) {
+			const char = className[i];
+			if (char >= 'A' && char <= 'Z') {
+				if (i > 0) {
+					result += '_';
+				}
+				result += char.toLowerCase();
+			} else {
+				result += char;
+			}
+		}
+
+		// Simple pluralization (add 's')
+		return result + 's';
+	}
 }

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.');
+		}
+	}
+}

package/template/framework/database/console/MakeMigrationCommand.ts

@@ -0,0 +1,58 @@
+import { Command } from '../../cli/Command';
+import { join } from 'path';
+import { writeFile, mkdir } from 'fs/promises';
+
+export class MakeMigrationCommand extends Command {
+	signature = 'make:migration {name}';
+	description = 'Create a new migration file';
+
+	async handle(args: { name: string }): Promise<void> {
+		const name = args.name;
+
+		// Generate timestamp YYYY_MM_DD_HHMMSS
+		const now = new Date();
+		const timestamp = now.toISOString().replace(/[-T:]/g, '_').split('.')[0];
+
+		const fileName = `${timestamp}_${name}`;
+		const className = this.toPascalCase(name);
+
+		const content = this.getTemplate(className);
+
+		const directory = join(process.cwd(), 'database', 'migrations');
+		const filePath = join(directory, `${fileName}.ts`);
+
+		await mkdir(directory, { recursive: true });
+		await writeFile(filePath, content);
+
+		console.log(`Created Migration: ${fileName}`);
+	}
+
+	protected toPascalCase(str: string): string {
+		return str.replace(/(?:^|_)(\w)/g, (_, c) => c.toUpperCase());
+	}
+
+	protected getTemplate(className: string): string {
+		return `import { Schema, Blueprint } from '@framework/database/schema';
+import { Migration } from '@framework/database/migrations';
+
+export class ${className} 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/database/console/MigrateCommand.ts

@@ -0,0 +1,32 @@
+import { Command } from '../../cli/Command';
+import { Migrator } from '../migrations/Migrator';
+import { DatabaseMigrationRepository } from '../migrations/DatabaseMigrationRepository';
+import { DatabaseManager } from '../DatabaseManager';
+import { join } from 'path';
+
+export class MigrateCommand extends Command {
+	signature = 'migrate';
+	description = 'Run the database migrations';
+
+	async handle(args: any): Promise<void> {
+		const { migrator, connection } = await this.getMigratorAndConnection();
+		try {
+			await connection.connect();
+			await migrator.run();
+		} finally {
+			await connection.disconnect();
+		}
+	}
+
+	protected async getMigratorAndConnection() {
+		// This is a bit hacky, normally we'd usage DI container.
+		const { default: databaseConfig } = await import(join(process.cwd(), 'config', 'database'));
+		const db = new DatabaseManager(databaseConfig);
+		const connection = db.connection(); // default connection
+
+		const repository = new DatabaseMigrationRepository(connection, 'migrations');
+		const paths = [join(process.cwd(), 'database', 'migrations')];
+
+		return { migrator: new Migrator(repository, connection, paths), connection };
+	}
+}

package/template/framework/database/console/MigrateResetCommand.ts

@@ -0,0 +1,31 @@
+import { Command } from '../../cli/Command';
+import { Migrator } from '../migrations/Migrator';
+import { DatabaseMigrationRepository } from '../migrations/DatabaseMigrationRepository';
+import { DatabaseManager } from '../DatabaseManager';
+import { join } from 'path';
+
+export class MigrateResetCommand extends Command {
+	signature = 'migrate:reset';
+	description = 'Rollback all database migrations';
+
+	async handle(args: any): Promise<void> {
+		const { migrator, connection } = await this.getMigratorAndConnection();
+		try {
+			await connection.connect();
+			await migrator.reset();
+		} finally {
+			await connection.disconnect();
+		}
+	}
+
+	protected async getMigratorAndConnection() {
+		const { default: databaseConfig } = await import(join(process.cwd(), 'config', 'database'));
+		const db = new DatabaseManager(databaseConfig);
+		const connection = db.connection();
+
+		const repository = new DatabaseMigrationRepository(connection, 'migrations');
+		const paths = [join(process.cwd(), 'database', 'migrations')];
+
+		return { migrator: new Migrator(repository, connection, paths), connection };
+	}
+}