create-phoenixjs 0.1.4 → 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/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"
   }
 }