create-phoenixjs 0.1.3 → 0.1.5

package/template/framework/database/schema/SchemaBuilder.ts

@@ -0,0 +1,152 @@
+/**
+ * PhoenixJS ORM - Schema Builder
+ *
+ * Executes schema operations using a database connection and grammar.
+ */
+
+import type { Connection } from '../connection/Connection';
+import { Blueprint } from './Blueprint';
+import { PostgresSchemaGrammar } from './grammars/PostgresSchemaGrammar';
+
+/**
+ * Schema Builder - executes DDL operations
+ */
+export class SchemaBuilder {
+	private grammar: PostgresSchemaGrammar;
+
+	constructor(
+		private connection: Connection,
+		grammar?: PostgresSchemaGrammar
+	) {
+		this.grammar = grammar || new PostgresSchemaGrammar();
+	}
+
+	/**
+	 * Create a new table with the given callback
+	 */
+	async create(table: string, callback: (blueprint: Blueprint) => void): Promise<void> {
+		const blueprint = new Blueprint(table);
+		callback(blueprint);
+
+		const sql = this.grammar.compileCreate(blueprint);
+		await this.connection.execute(sql);
+
+		// Create indexes separately
+		const indexes = blueprint.getIndexes();
+		for (const index of indexes) {
+			const indexSql = this.grammar.compileCreateIndex(table, index);
+			await this.connection.execute(indexSql);
+		}
+	}
+
+	/**
+	 * Modify an existing table
+	 */
+	async table(table: string, callback: (blueprint: Blueprint) => void): Promise<void> {
+		const blueprint = new Blueprint(table);
+		callback(blueprint);
+
+		const statements = this.grammar.compileAlter(blueprint);
+		for (const sql of statements) {
+			await this.connection.execute(sql);
+		}
+	}
+
+	/**
+	 * Drop a table
+	 */
+	async drop(table: string): Promise<void> {
+		const sql = this.grammar.compileDrop(table);
+		await this.connection.execute(sql);
+	}
+
+	/**
+	 * Drop a table if it exists
+	 */
+	async dropIfExists(table: string): Promise<void> {
+		const sql = this.grammar.compileDropIfExists(table);
+		await this.connection.execute(sql);
+	}
+
+	/**
+	 * Rename a table
+	 */
+	async rename(from: string, to: string): Promise<void> {
+		const sql = this.grammar.compileRename(from, to);
+		await this.connection.execute(sql);
+	}
+
+	/**
+	 * Check if a table exists
+	 */
+	async hasTable(table: string): Promise<boolean> {
+		const sql = this.grammar.compileTableExists(table);
+		const result = await this.connection.query<{ exists: boolean }>(sql);
+		return result[0]?.exists ?? false;
+	}
+
+	/**
+	 * Check if a column exists in a table
+	 */
+	async hasColumn(table: string, column: string): Promise<boolean> {
+		const sql = this.grammar.compileColumnExists(table, column);
+		const result = await this.connection.query<{ exists: boolean }>(sql);
+		return result[0]?.exists ?? false;
+	}
+
+	/**
+	 * Get all tables in the database
+	 */
+	async getTables(): Promise<string[]> {
+		const sql = this.grammar.compileGetTables();
+		const result = await this.connection.query<{ table_name: string }>(sql);
+		return result.map((row) => row.table_name);
+	}
+
+	/**
+	 * Get all columns for a table
+	 */
+	async getColumns(table: string): Promise<
+		{
+			column_name: string;
+			data_type: string;
+			is_nullable: string;
+			column_default: string | null;
+		}[]
+	> {
+		const sql = this.grammar.compileGetColumns(table);
+		return this.connection.query(sql);
+	}
+
+	/**
+	 * Truncate a table
+	 */
+	async truncate(table: string): Promise<void> {
+		const sql = this.grammar.compileTruncate(table);
+		await this.connection.execute(sql);
+	}
+
+	/**
+	 * Drop all tables in the database (dangerous!)
+	 */
+	async dropAllTables(): Promise<void> {
+		const tables = await this.getTables();
+		for (const table of tables) {
+			await this.dropIfExists(table);
+		}
+	}
+
+	/**
+	 * Get the grammar instance
+	 */
+	getGrammar(): PostgresSchemaGrammar {
+		return this.grammar;
+	}
+
+	/**
+	 * Get the connection instance
+	 */
+	getConnection(): Connection {
+		return this.connection;
+	}
+}

package/template/framework/database/schema/grammars/PostgresSchemaGrammar.ts

@@ -0,0 +1,293 @@
+/**
+ * PhoenixJS ORM - PostgreSQL Schema Grammar
+ *
+ * Compiles Blueprint definitions into PostgreSQL DDL statements.
+ */
+
+import type {
+	Blueprint,
+	ColumnDefinition,
+	IndexDefinition,
+	ForeignKeyDefinition,
+} from '../Blueprint';
+
+/**
+ * PostgreSQL Schema Grammar
+ *
+ * Compiles Blueprint column definitions into PostgreSQL DDL statements.
+ */
+export class PostgresSchemaGrammar {
+	/**
+	 * Wrap an identifier in quotes
+	 */
+	wrap(value: string): string {
+		if (value === '*') return value;
+		return `"${value}"`;
+	}
+
+	/**
+	 * Wrap a table name
+	 */
+	wrapTable(table: string): string {
+		return this.wrap(table);
+	}
+
+	/**
+	 * Compile a CREATE TABLE statement
+	 */
+	compileCreate(blueprint: Blueprint): string {
+		const tableName = this.wrapTable(blueprint.getTableName());
+		const columns = blueprint.getColumns();
+
+		if (columns.length === 0) {
+			throw new Error('Cannot create table without columns');
+		}
+
+		const columnDefinitions = columns.map((col) => this.compileColumn(col));
+
+		// Add primary key constraints for non-serial columns
+		const primaryColumns = columns.filter((c) => c.primary && !c.autoIncrement);
+		if (primaryColumns.length > 0) {
+			const pkColumns = primaryColumns.map((c) => this.wrap(c.name)).join(', ');
+			columnDefinitions.push(`PRIMARY KEY (${pkColumns})`);
+		}
+
+		// Add unique constraints for unique columns
+		const uniqueColumns = columns.filter((c) => c.unique);
+		for (const col of uniqueColumns) {
+			columnDefinitions.push(`UNIQUE (${this.wrap(col.name)})`);
+		}
+
+		// Add foreign key constraints
+		const foreignKeys = blueprint.getForeignKeys();
+		for (const fk of foreignKeys) {
+			columnDefinitions.push(this.compileForeignKey(fk));
+		}
+
+		return `CREATE TABLE ${tableName} (\n  ${columnDefinitions.join(',\n  ')}\n)`;
+	}
+
+	/**
+	 * Compile a single column definition
+	 */
+	compileColumn(column: ColumnDefinition): string {
+		const parts: string[] = [this.wrap(column.name)];
+
+		// Type with length/precision
+		parts.push(this.getColumnType(column));
+
+		// Primary key for SERIAL types
+		if (column.primary && column.autoIncrement) {
+			parts.push('PRIMARY KEY');
+		}
+
+		// Nullable
+		if (!column.nullable && !column.autoIncrement) {
+			parts.push('NOT NULL');
+		}
+
+		// Default value
+		if (column.defaultValue !== undefined) {
+			parts.push(`DEFAULT ${this.compileDefaultValue(column.defaultValue)}`);
+		}
+
+		// Foreign key reference (inline)
+		if (column.references && column.references.table) {
+			parts.push(
+				`REFERENCES ${this.wrap(column.references.table)}(${this.wrap(column.references.column)})`
+			);
+			if (column.references.onDelete) {
+				parts.push(`ON DELETE ${column.references.onDelete}`);
+			}
+			if (column.references.onUpdate) {
+				parts.push(`ON UPDATE ${column.references.onUpdate}`);
+			}
+		}
+
+		return parts.join(' ');
+	}
+
+	/**
+	 * Get the PostgreSQL column type
+	 */
+	private getColumnType(column: ColumnDefinition): string {
+		switch (column.type) {
+			case 'VARCHAR':
+				return `VARCHAR(${column.length || 255})`;
+			case 'CHAR':
+				return `CHAR(${column.length || 255})`;
+			case 'NUMERIC':
+				return `NUMERIC(${column.precision || 8}, ${column.scale || 2})`;
+			case 'REAL':
+				return column.precision ? `FLOAT(${column.precision})` : 'REAL';
+			case 'TIMESTAMPTZ':
+				return 'TIMESTAMP WITH TIME ZONE';
+			default:
+				return column.type;
+		}
+	}
+
+	/**
+	 * Compile a default value
+	 */
+	private compileDefaultValue(value: string | number | boolean | null): string {
+		if (value === null) return 'NULL';
+		if (typeof value === 'boolean') return value ? 'TRUE' : 'FALSE';
+		if (typeof value === 'number') return String(value);
+		// Check for SQL expressions like CURRENT_TIMESTAMP
+		if (
+			value === 'CURRENT_TIMESTAMP' ||
+			value === 'NOW()' ||
+			value.startsWith('gen_random_uuid')
+		) {
+			return value;
+		}
+		return `'${value}'`;
+	}
+
+	/**
+	 * Compile a foreign key constraint
+	 */
+	private compileForeignKey(fk: ForeignKeyDefinition): string {
+		const columns = fk.columns.map((c) => this.wrap(c)).join(', ');
+		const refs = fk.references.map((c) => this.wrap(c)).join(', ');
+
+		let sql = `FOREIGN KEY (${columns}) REFERENCES ${this.wrap(fk.on)}(${refs})`;
+
+		if (fk.onDelete) {
+			sql += ` ON DELETE ${fk.onDelete}`;
+		}
+		if (fk.onUpdate) {
+			sql += ` ON UPDATE ${fk.onUpdate}`;
+		}
+
+		return sql;
+	}
+
+	/**
+	 * Compile an ALTER TABLE ADD COLUMN statement
+	 */
+	compileAdd(table: string, column: ColumnDefinition): string {
+		return `ALTER TABLE ${this.wrapTable(table)} ADD COLUMN ${this.compileColumn(column)}`;
+	}
+
+	/**
+	 * Compile ALTER TABLE statements for modifying a table
+	 */
+	compileAlter(blueprint: Blueprint): string[] {
+		const statements: string[] = [];
+		const table = this.wrapTable(blueprint.getTableName());
+
+		// Add new columns
+		for (const column of blueprint.getColumns()) {
+			statements.push(`ALTER TABLE ${table} ADD COLUMN ${this.compileColumn(column)}`);
+		}
+
+		// Drop columns
+		for (const column of blueprint.getDroppedColumns()) {
+			statements.push(`ALTER TABLE ${table} DROP COLUMN IF EXISTS ${this.wrap(column)}`);
+		}
+
+		// Add indexes
+		for (const index of blueprint.getIndexes()) {
+			statements.push(this.compileCreateIndex(blueprint.getTableName(), index));
+		}
+
+		// Drop indexes
+		for (const indexName of blueprint.getDroppedIndexes()) {
+			statements.push(`DROP INDEX IF EXISTS ${this.wrap(indexName)}`);
+		}
+
+		// Add foreign keys
+		for (const fk of blueprint.getForeignKeys()) {
+			statements.push(`ALTER TABLE ${table} ADD ${this.compileForeignKey(fk)}`);
+		}
+
+		return statements;
+	}
+
+	/**
+	 * Compile a DROP TABLE statement
+	 */
+	compileDrop(table: string): string {
+		return `DROP TABLE ${this.wrapTable(table)}`;
+	}
+
+	/**
+	 * Compile a DROP TABLE IF EXISTS statement
+	 */
+	compileDropIfExists(table: string): string {
+		return `DROP TABLE IF EXISTS ${this.wrapTable(table)} CASCADE`;
+	}
+
+	/**
+	 * Compile a RENAME TABLE statement
+	 */
+	compileRename(from: string, to: string): string {
+		return `ALTER TABLE ${this.wrapTable(from)} RENAME TO ${this.wrap(to)}`;
+	}
+
+	/**
+	 * Compile a CREATE INDEX statement
+	 */
+	compileCreateIndex(table: string, index: IndexDefinition): string {
+		const unique = index.unique ? 'UNIQUE ' : '';
+		const columns = index.columns.map((c) => this.wrap(c)).join(', ');
+		return `CREATE ${unique}INDEX ${this.wrap(index.name)} ON ${this.wrapTable(table)} (${columns})`;
+	}
+
+	/**
+	 * Compile a DROP INDEX statement
+	 */
+	compileDropIndex(name: string): string {
+		return `DROP INDEX IF EXISTS ${this.wrap(name)}`;
+	}
+
+	/**
+	 * Compile a check table exists query
+	 */
+	compileTableExists(table: string): string {
+		return `SELECT EXISTS (
+			SELECT FROM information_schema.tables 
+			WHERE table_schema = 'public' 
+			AND table_name = '${table}'
+		)`;
+	}
+
+	/**
+	 * Compile a check column exists query
+	 */
+	compileColumnExists(table: string, column: string): string {
+		return `SELECT EXISTS (
+			SELECT FROM information_schema.columns 
+			WHERE table_schema = 'public' 
+			AND table_name = '${table}' 
+			AND column_name = '${column}'
+		)`;
+	}
+
+	/**
+	 * Compile get all tables query
+	 */
+	compileGetTables(): string {
+		return `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' ORDER BY table_name`;
+	}
+
+	/**
+	 * Compile get all columns for a table query
+	 */
+	compileGetColumns(table: string): string {
+		return `SELECT column_name, data_type, is_nullable, column_default 
+			FROM information_schema.columns 
+			WHERE table_schema = 'public' 
+			AND table_name = '${table}' 
+			ORDER BY ordinal_position`;
+	}
+
+	/**
+	 * Compile a TRUNCATE TABLE statement
+	 */
+	compileTruncate(table: string): string {
+		return `TRUNCATE TABLE ${this.wrapTable(table)} RESTART IDENTITY CASCADE`;
+	}
+}

package/template/framework/database/schema/grammars/index.ts

@@ -0,0 +1,5 @@
+/**
+ * PhoenixJS ORM - Schema Grammar Exports
+ */
+
+export { PostgresSchemaGrammar } from './PostgresSchemaGrammar';

package/template/framework/database/schema/index.ts

@@ -0,0 +1,9 @@
+/**
+ * PhoenixJS ORM - Schema Module Exports
+ */
+
+export { Blueprint, ColumnBuilder } from './Blueprint';
+export type { ColumnDefinition, IndexDefinition, ForeignKeyDefinition } from './Blueprint';
+export { SchemaBuilder } from './SchemaBuilder';
+export { Schema } from './Schema';
+export { PostgresSchemaGrammar } from './grammars/PostgresSchemaGrammar';

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "my-phoenixjs-app",
-  "version": "0.1.0",
+  "version": "0.1.5",
   "description": "A PhoenixJS API project",
   "type": "module",
   "main": "server.ts",
@@ -20,5 +20,8 @@
   "devDependencies": {
     "@types/bun": "latest",
     "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "postgres": "3.4.8"
   }
 }