create-phoenixjs 0.1.5 → 0.1.7

package/package.json

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

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/orm/Model.ts

@@ -73,32 +73,72 @@ export abstract class Model {
 
 	/**
 	 * The attributes that are mass assignable.
+	 * Child classes should override this with their fillable fields.
 	 *
 	 * @var string[]
 	 */
-	protected _fillable: string[] = [];
-
-	public get fillable(): string[] {
-		return this._fillable;
-	}
-
-	public set fillable(value: string[]) {
-		this._fillable = value;
-	}
+	protected fillable: string[] = [];
 
 	/**
 	 * The attributes that aren't mass assignable.
+	 * Default to guarding everything for security.
 	 *
-	 * @var string[] // Default to guarding everything
+	 * @var string[]
 	 */
-	protected _guarded: string[] = ['*'];
+	protected guarded: string[] = ['*'];
+
+	/**
+	 * Get the fillable fields for this model.
+	 * This method properly handles inheritance by checking instance and prototype.
+	 * Due to JS class initialization order, we need to check the prototype chain
+	 * when called from the parent constructor before child properties are initialized.
+	 */
+	public getFillableFields(): string[] {
+		// First check if 'this' has its own fillable property (already initialized)
+		if (Object.prototype.hasOwnProperty.call(this, 'fillable') &&
+			Array.isArray(this.fillable) && this.fillable.length > 0) {
+			return this.fillable;
+		}
+
+		// Walk up the prototype chain looking for fillable definition
+		let proto = Object.getPrototypeOf(this);
+		while (proto && proto.constructor.name !== 'Model' && proto.constructor.name !== 'Object') {
+			const descriptor = Object.getOwnPropertyDescriptor(proto, 'fillable');
+			if (descriptor && descriptor.value && Array.isArray(descriptor.value)) {
+				return descriptor.value;
+			}
+			proto = Object.getPrototypeOf(proto);
+		}
 
-	public get guarded(): string[] {
-		return this._guarded;
+		// Default to the instance property
+		return this.fillable;
 	}
 
-	public set guarded(value: string[]) {
-		this._guarded = value;
+	/**
+	 * Get the guarded fields for this model.
+	 * This method properly handles inheritance by checking instance and prototype.
+	 * Due to JS class initialization order, we need to check the prototype chain
+	 * when called from the parent constructor before child properties are initialized.
+	 */
+	public getGuardedFields(): string[] {
+		// First check if 'this' has its own guarded property (already initialized)
+		// We need to detect if the child class set a different value
+		if (Object.prototype.hasOwnProperty.call(this, 'guarded')) {
+			return this.guarded;
+		}
+
+		// Walk up the prototype chain looking for guarded definition
+		let proto = Object.getPrototypeOf(this);
+		while (proto && proto.constructor.name !== 'Model' && proto.constructor.name !== 'Object') {
+			const descriptor = Object.getOwnPropertyDescriptor(proto, 'guarded');
+			if (descriptor && descriptor.value && Array.isArray(descriptor.value)) {
+				return descriptor.value;
+			}
+			proto = Object.getPrototypeOf(proto);
+		}
+
+		// Default to the instance property (will be ['*'] from Model base)
+		return this.guarded;
 	}
 
 	/**
@@ -219,9 +259,13 @@ export abstract class Model {
 
 	/**
 	 * Create a new model instance.
+	 * 
+	 * Note: We use forceFill in the constructor because constructor arguments
+	 * are trusted (not external user input). Mass assignment protection is
+	 * meant for external input like HTTP request bodies, not constructor init.
 	 */
 	constructor(attributes: Record<string, unknown> = {}) {
-		this.fill(attributes);
+		this.forceFill(attributes);
 
 		// Return a proxy to handle attribute access directly on the model instance
 		return new Proxy(this, {
@@ -248,7 +292,6 @@ export abstract class Model {
 				// Otherwise set attribute
 				if (typeof prop === 'string') {
 					if (prop === 'table' || prop === 'primaryKey' || prop === 'forceDeleting') {
-						console.log(`Preventing ${prop} from being set as attribute. defining on target.`);
 						Object.defineProperty(target, prop, { value, writable: true, configurable: true, enumerable: true });
 						return true;
 					}
@@ -271,19 +314,9 @@ export abstract class Model {
 	 * @throws Error if mass assignment protection is violated (optional, traditionally just ignored)
 	 */
 	public fill(attributes: Record<string, unknown>): this {
-		const totallyGuarded = this.guarded.length === 1 && this.guarded[0] === '*';
-		console.log(`Filling model ${this.constructor.name}:`, attributes);
-		console.log(`Guarded:`, this.guarded);
-		console.log(`Totally Guarded:`, totallyGuarded);
-
 		for (const key in attributes) {
-			const fillable = this.isFillable(key);
-			console.log(`Key '${key}' fillable:`, fillable);
-			if (fillable) {
+			if (this.isFillable(key)) {
 				this.setAttribute(key, attributes[key]);
-			} else if (totallyGuarded) {
-				// Optional: We could throw an error here or log a warning
-				// console.warn(`Mass assignment to guarded attribute '${key}' on model '${this.constructor.name}'`);
 			}
 		}
 		return this;
@@ -304,18 +337,21 @@ export abstract class Model {
 	 * Determine if the given attribute may be mass assigned.
 	 */
 	public isFillable(key: string): boolean {
+		const fillableFields = this.getFillableFields();
+		const guardedFields = this.getGuardedFields();
+
 		// If the key is in the fillable array, it can be filled
-		if (this.fillable.includes(key)) {
+		if (fillableFields.includes(key)) {
 			return true;
 		}
 
-		// If the model is totally guarded, return false
-		if (this.guarded.length === 1 && this.guarded[0] === '*') {
+		// If the model is totally guarded (guarded = ['*']), return false
+		if (guardedFields.length === 1 && guardedFields[0] === '*') {
 			return false;
 		}
 
-		// If the model is not guarded and the key is not in the guarded array, it can be filled
-		if (!this.guarded.includes(key) && !this.guarded.includes('*')) {
+		// If the key is not in the guarded array, it can be filled
+		if (!guardedFields.includes(key) && !guardedFields.includes('*')) {
 			return true;
 		}
 
@@ -989,7 +1025,8 @@ export abstract class Model {
 
 		if (result) {
 			// Update model with returned values (including generated ID)
-			this.fill(result);
+			// Use forceFill since this is trusted data from the database
+			this.forceFill(result);
 			this.exists = true;
 			this.syncOriginal();
 

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

@@ -1,16 +0,0 @@
-
-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

@@ -1,21 +0,0 @@
-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');
-    }
-}