create-phoenixjs 0.1.0

package/index.ts

@@ -0,0 +1,196 @@
+#!/usr/bin/env bun
+
+import { existsSync, mkdirSync, readdirSync, statSync, readFileSync, writeFileSync, copyFileSync, chmodSync } from 'fs';
+import { join, dirname, basename } from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Colors for terminal output
+const colors = {
+	reset: '\x1b[0m',
+	bold: '\x1b[1m',
+	green: '\x1b[32m',
+	cyan: '\x1b[36m',
+	yellow: '\x1b[33m',
+	red: '\x1b[31m',
+	dim: '\x1b[2m',
+};
+
+function log(message: string): void {
+	console.log(message);
+}
+
+function success(message: string): void {
+	console.log(`${colors.green}✓${colors.reset} ${message}`);
+}
+
+function error(message: string): void {
+	console.error(`${colors.red}✗${colors.reset} ${message}`);
+}
+
+function info(message: string): void {
+	console.log(`${colors.cyan}→${colors.reset} ${message}`);
+}
+
+function printBanner(): void {
+	console.log(`
+${colors.cyan}${colors.bold}
+  P H O E N I X   J S
+${colors.reset}${colors.dim} Create a new PhoenixJS project${colors.reset}
+`);
+}
+
+function copyDir(src: string, dest: string): void {
+	mkdirSync(dest, { recursive: true });
+
+	const entries = readdirSync(src);
+
+	for (const entry of entries) {
+		const srcPath = join(src, entry);
+		const destPath = join(dest, entry);
+
+		const stat = statSync(srcPath);
+
+		if (stat.isDirectory()) {
+			copyDir(srcPath, destPath);
+		} else {
+			copyFileSync(srcPath, destPath);
+		}
+	}
+}
+
+function updatePackageJson(projectPath: string, projectName: string): void {
+	const packageJsonPath = join(projectPath, 'package.json');
+
+	if (existsSync(packageJsonPath)) {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+		packageJson.name = projectName;
+		writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n');
+	}
+}
+
+function makeExecutable(projectPath: string): void {
+	const artisanPath = join(projectPath, 'artisan');
+	if (existsSync(artisanPath)) {
+		chmodSync(artisanPath, 0o755);
+	}
+}
+
+async function main(): Promise<void> {
+	const args = process.argv.slice(2);
+
+	// Handle help flag
+	if (args.includes('--help') || args.includes('-h')) {
+		printBanner();
+		console.log(`${colors.bold}Usage:${colors.reset}`);
+		console.log(`  bunx create-phoenixjs <project-name>`);
+		console.log(`  npx create-phoenixjs <project-name>`);
+		console.log();
+		console.log(`${colors.bold}Examples:${colors.reset}`);
+		console.log(`  bunx create-phoenixjs my-api`);
+		console.log(`  bunx create-phoenixjs ./my-project`);
+		console.log();
+		console.log(`${colors.bold}Options:${colors.reset}`);
+		console.log(`  -h, --help     Show this help message`);
+		console.log(`  -v, --version  Show version number`);
+		process.exit(0);
+	}
+
+	// Handle version flag
+	if (args.includes('--version') || args.includes('-v')) {
+		console.log('0.1.0');
+		process.exit(0);
+	}
+
+	printBanner();
+
+	// Get project name
+	const projectName = args[0];
+
+	if (!projectName) {
+		error('Please specify a project name:');
+		console.log();
+		console.log(`  ${colors.cyan}bunx create-phoenixjs${colors.reset} ${colors.green}<project-name>${colors.reset}`);
+		console.log();
+		console.log('For example:');
+		console.log(`  ${colors.cyan}bunx create-phoenixjs${colors.reset} ${colors.green}my-api${colors.reset}`);
+		process.exit(1);
+	}
+
+	const projectPath = join(process.cwd(), projectName);
+	const templatePath = join(__dirname, 'template');
+
+	// Check if directory already exists
+	if (existsSync(projectPath)) {
+		const files = readdirSync(projectPath);
+		if (files.length > 0) {
+			error(`Directory "${projectName}" already exists and is not empty.`);
+			process.exit(1);
+		}
+	}
+
+	// Check if template exists
+	if (!existsSync(templatePath)) {
+		error('Template files not found. Please reinstall create-phoenixjs.');
+		process.exit(1);
+	}
+
+	log('');
+	info(`Creating a new PhoenixJS project in ${colors.cyan}${projectPath}${colors.reset}`);
+	log('');
+
+	// Copy template files
+	try {
+		copyDir(templatePath, projectPath);
+		success('Copied project files');
+	} catch (err) {
+		error(`Failed to copy template files: ${err}`);
+		process.exit(1);
+	}
+
+	// Update package.json with project name
+	try {
+		updatePackageJson(projectPath, basename(projectName));
+		success('Updated package.json');
+	} catch (err) {
+		error(`Failed to update package.json: ${err}`);
+	}
+
+	// Make artisan executable
+	try {
+		makeExecutable(projectPath);
+		success('Made artisan executable');
+	} catch (err) {
+		// Non-critical error
+	}
+
+	// Print success message
+	log('');
+	console.log(`${colors.green}${colors.bold}Success!${colors.reset} Created ${colors.cyan}${projectName}${colors.reset}`);
+	log('');
+	console.log('Inside that directory, you can run:');
+	log('');
+	console.log(`  ${colors.cyan}bun install${colors.reset}`);
+	console.log('    Install dependencies');
+	log('');
+	console.log(`  ${colors.cyan}bun run dev${colors.reset}`);
+	console.log('    Start the development server');
+	log('');
+	console.log(`  ${colors.cyan}bun artisan make:controller UserController${colors.reset}`);
+	console.log('    Generate a new controller');
+	log('');
+	console.log('Get started by running:');
+	log('');
+	console.log(`  ${colors.cyan}cd ${projectName}${colors.reset}`);
+	console.log(`  ${colors.cyan}bun install${colors.reset}`);
+	console.log(`  ${colors.cyan}bun run dev${colors.reset}`);
+	log('');
+	console.log(`${colors.dim}Happy coding! 🚀${colors.reset}`);
+}
+
+main().catch((err) => {
+	error(`An unexpected error occurred: ${err}`);
+	process.exit(1);
+});

package/package.json

@@ -0,0 +1,31 @@
+{
+	"name": "create-phoenixjs",
+	"version": "0.1.0",
+	"description": "Create a new PhoenixJS project - A TypeScript framework inspired by Laravel, powered by Bun",
+	"type": "module",
+	"bin": {
+		"create-phoenixjs": "./index.ts"
+	},
+	"files": [
+		"index.ts",
+		"template"
+	],
+	"keywords": [
+		"phoenixjs",
+		"create",
+		"scaffold",
+		"bun",
+		"typescript",
+		"api",
+		"framework"
+	],
+	"author": "",
+	"license": "MIT",
+	"engines": {
+		"bun": ">=1.0.0"
+	},
+	"repository": {
+		"type": "git",
+		"url": ""
+	}
+}

package/template/README.md

@@ -0,0 +1,62 @@
+# PhoenixJS Project
+
+A TypeScript API project built with [PhoenixJS](https://github.com/your-username/phoenixjs), powered by Bun.
+
+## Quick Start
+
+```bash
+# Install dependencies
+bun install
+
+# Start development server (with hot reload)
+bun run dev
+```
+
+Your API is running at `http://localhost:4000`
+
+## Available Endpoints
+
+| Method | Path | Description |
+|--------|------|-------------|
+| GET | `/api/health` | Health check |
+| GET | `/api/hello` | Welcome message |
+| GET | `/api/users/:id` | Get user by ID |
+| POST | `/api/users` | Create user |
+
+## CLI Commands
+
+```bash
+# Generate a new controller
+bun artisan make:controller UserController
+
+# Generate a validator
+bun artisan make:validator CreateUserValidator
+
+# Generate a model
+bun artisan make:model User
+
+# Generate middleware
+bun artisan make:middleware AuthMiddleware
+```
+
+## Project Structure
+
+```
+├── app/
+│   ├── controllers/    # HTTP controllers
+│   ├── middlewares/    # Custom middleware
+│   ├── validators/     # Request validators
+│   ├── models/         # Data models
+│   └── gateways/       # WebSocket gateways
+├── routes/
+│   └── api.ts          # API route definitions
+├── config/             # Configuration files
+├── framework/          # Core framework (don't modify)
+├── bootstrap/app.ts    # Application bootstrap
+└── server.ts           # Entry point
+```
+
+## Learn More
+
+- [Getting Started Guide](https://github.com/your-username/phoenixjs/blob/main/docs/README.md)
+- [Full Documentation](https://github.com/your-username/phoenixjs/blob/main/README.md)

package/template/app/controllers/ExampleController.ts

@@ -0,0 +1,61 @@
+import { Controller } from '@framework/controller/Controller';
+
+/**
+ * Example Controller
+ * 
+ * This is a sample controller to get you started.
+ * Generate new controllers using: bun artisan make:controller <name>
+ */
+export class ExampleController extends Controller {
+	/**
+	 * Display a listing of the resource.
+	 */
+	async index() {
+		return this.json({
+			message: 'Welcome to PhoenixJS!',
+			items: [],
+		});
+	}
+
+	/**
+	 * Display the specified resource.
+	 */
+	async show() {
+		const id = this.param('id');
+		return this.json({
+			id,
+			message: `Showing resource ${id}`,
+		});
+	}
+
+	/**
+	 * Store a newly created resource.
+	 */
+	async store() {
+		const data = await this.request.json();
+		return this.json({
+			message: 'Resource created successfully',
+			data,
+		}, 201);
+	}
+
+	/**
+	 * Update the specified resource.
+	 */
+	async update() {
+		const id = this.param('id');
+		const data = await this.request.json();
+		return this.json({
+			message: `Resource ${id} updated`,
+			data,
+		});
+	}
+
+	/**
+	 * Remove the specified resource.
+	 */
+	async destroy() {
+		const id = this.param('id');
+		return this.noContent();
+	}
+}

package/template/artisan

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import './framework/cli/artisan';

package/template/bootstrap/app.ts

@@ -0,0 +1,44 @@
+/**
+ * PhoenixJS - Application Bootstrap
+ * 
+ * This file creates and configures the application instance.
+ */
+
+import { Application } from '@framework/core/Application';
+import { Kernel } from '@framework/core/Kernel';
+import { registerRoutes } from '@/routes/api';
+
+/**
+ * Create and configure the application
+ */
+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',
+	});
+
+	return app;
+}
+
+/**
+ * Create the HTTP kernel
+ */
+export function createKernel(app: Application): Kernel {
+	const kernel = new Kernel(app);
+
+	// Register routes
+	registerRoutes();
+
+	return kernel;
+}
+
+// Export pre-configured instances
+export const app = createApplication();
+export const kernel = createKernel(app);
+

package/template/bunfig.toml

@@ -0,0 +1,7 @@
+[install]
+# Use exact versions for reproducibility
+exact = true
+
+[run]
+# Enable hot reloading during development  
+watch = true

package/template/config/database.ts

@@ -0,0 +1,25 @@
+export default {
+	default: 'prisma',
+
+	connections: {
+		prisma: {
+			driver: 'prisma',
+			// Prisma usually relies on .env DATABASE_URL, but we can put pool config here
+			pool: {
+				min: 2,
+				max: 10,
+				idle: 10000,
+			},
+		},
+
+		sqlite: {
+			driver: 'sqlite',
+			// Use ':memory:' for in-memory database or a file path
+			filename: ':memory:',
+			// Whether to create the database if it doesn't exist
+			create: true,
+			// Read-only mode
+			readonly: false,
+		},
+	},
+};

package/template/config/plugins.ts

@@ -0,0 +1,7 @@
+import { Plugin } from '@framework/plugin/Plugin';
+
+const plugins: Plugin[] = [
+	// Add your plugins here
+];
+
+export default plugins;

package/template/config/security.ts

@@ -0,0 +1,158 @@
+/**
+ * PhoenixJS - Security Configuration
+ * 
+ * Configure security features: CORS, Helmet headers, Rate limiting, Input sanitization, CSRF.
+ */
+
+export interface CorsConfig {
+	/** Allowed origins - string, array, regex, or function */
+	origin: string | string[] | RegExp | ((origin: string) => boolean);
+	/** Allowed HTTP methods */
+	methods: string[];
+	/** Allowed headers */
+	allowedHeaders: string[];
+	/** Exposed headers */
+	exposedHeaders: string[];
+	/** Allow credentials (cookies, authorization headers) */
+	credentials: boolean;
+	/** Preflight request cache duration (seconds) */
+	maxAge: number;
+}
+
+export interface HelmetConfig {
+	/** X-Frame-Options header */
+	frameOptions: 'DENY' | 'SAMEORIGIN' | false;
+	/** X-Content-Type-Options header */
+	contentTypeOptions: boolean;
+	/** X-XSS-Protection header */
+	xssProtection: boolean;
+	/** Strict-Transport-Security header */
+	hsts: {
+		enabled: boolean;
+		maxAge: number;
+		includeSubDomains: boolean;
+		preload: boolean;
+	};
+	/** Content-Security-Policy header */
+	contentSecurityPolicy: {
+		enabled: boolean;
+		directives: Record<string, string | string[]>;
+	};
+	/** Referrer-Policy header */
+	referrerPolicy: string;
+	/** X-Permitted-Cross-Domain-Policies header */
+	crossDomainPolicy: string;
+	/** X-Download-Options header (IE) */
+	downloadOptions: boolean;
+}
+
+export interface RateLimitConfig {
+	/** Enable rate limiting */
+	enabled: boolean;
+	/** Time window in milliseconds */
+	windowMs: number;
+	/** Maximum requests per window */
+	max: number;
+	/** Message when rate limit exceeded */
+	message: string;
+	/** Skip rate limiting for certain requests */
+	skip?: (request: Request) => boolean;
+	/** Key generator for rate limiting (default: IP) */
+	keyGenerator?: (request: Request) => string;
+}
+
+export interface SanitizerConfig {
+	/** Enable input sanitization */
+	enabled: boolean;
+	/** Strip HTML tags */
+	stripTags: boolean;
+	/** Escape HTML entities */
+	escapeHtml: boolean;
+	/** Trim whitespace */
+	trim: boolean;
+	/** Fields to skip sanitization */
+	skipFields: string[];
+}
+
+export interface CsrfConfig {
+	/** Enable CSRF protection */
+	enabled: boolean;
+	/** Cookie name for CSRF token */
+	cookieName: string;
+	/** Header name for CSRF token */
+	headerName: string;
+	/** Token length */
+	tokenLength: number;
+	/** Safe methods (no CSRF check) */
+	safeMethods: string[];
+}
+
+export interface SecurityConfig {
+	cors: CorsConfig;
+	helmet: HelmetConfig;
+	rateLimit: RateLimitConfig;
+	sanitizer: SanitizerConfig;
+	csrf: CsrfConfig;
+}
+
+const securityConfig: SecurityConfig = {
+	cors: {
+		origin: '*',
+		methods: ['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'],
+		allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With', 'X-CSRF-Token'],
+		exposedHeaders: ['X-RateLimit-Limit', 'X-RateLimit-Remaining', 'X-RateLimit-Reset'],
+		credentials: false,
+		maxAge: 86400, // 24 hours
+	},
+
+	helmet: {
+		frameOptions: 'DENY',
+		contentTypeOptions: true,
+		xssProtection: true,
+		hsts: {
+			enabled: true,
+			maxAge: 31536000, // 1 year
+			includeSubDomains: true,
+			preload: false,
+		},
+		contentSecurityPolicy: {
+			enabled: false, // Disabled by default, enable in production
+			directives: {
+				defaultSrc: ["'self'"],
+				scriptSrc: ["'self'"],
+				styleSrc: ["'self'", "'unsafe-inline'"],
+				imgSrc: ["'self'", 'data:', 'https:'],
+				fontSrc: ["'self'"],
+				connectSrc: ["'self'"],
+			},
+		},
+		referrerPolicy: 'no-referrer',
+		crossDomainPolicy: 'none',
+		downloadOptions: true,
+	},
+
+	rateLimit: {
+		enabled: true,
+		windowMs: 60000, // 1 minute
+		max: 100, // 100 requests per minute
+		message: 'Too many requests, please try again later.',
+	},
+
+	sanitizer: {
+		enabled: true,
+		stripTags: true,
+		escapeHtml: true,
+		trim: true,
+		skipFields: ['password', 'html', 'content'],
+	},
+
+	csrf: {
+		enabled: false, // Disabled by default for API-first framework
+		cookieName: 'XSRF-TOKEN',
+		headerName: 'X-CSRF-Token',
+		tokenLength: 32,
+		safeMethods: ['GET', 'HEAD', 'OPTIONS'],
+	},
+};
+
+export default securityConfig;

package/template/framework/cli/Command.ts

@@ -0,0 +1,17 @@
+export abstract class Command {
+	abstract signature: string;
+	abstract description: string;
+
+	abstract handle(args: Record<string, any>): Promise<void>;
+
+	protected parseSignature(): { name: string; args: string[] } {
+		const parts = this.signature.split(' ');
+		const name = parts[0];
+		const args = parts.slice(1); // naive parsing for now
+		return { name, args };
+	}
+
+	get name(): string {
+		return this.parseSignature().name;
+	}
+}

package/template/framework/cli/ConsoleApplication.ts

@@ -0,0 +1,55 @@
+import { Command } from './Command';
+
+export class ConsoleApplication {
+	private commands: Map<string, Command> = new Map();
+
+	register(command: Command) {
+		this.commands.set(command.name, command);
+	}
+
+	async run(argv: string[]) {
+		const commandName = argv[2]; // bun artisan command:name ...
+
+		if (!commandName) {
+			this.showHelp();
+			return;
+		}
+
+		const command = this.commands.get(commandName);
+
+		if (!command) {
+			console.error(`Command "${commandName}" not found.`);
+			this.showHelp();
+			process.exit(1);
+		}
+
+		// Simple argument parsing
+		const args: Record<string, any> = {};
+		const signatureArgs = command.signature.split(' ').slice(1);
+		const inputArgs = argv.slice(3);
+
+		signatureArgs.forEach((argName, index) => {
+			// Removing {} or [] from arg definition for key name
+			const key = argName.replace(/[{}[\]]/g, '');
+			args[key] = inputArgs[index];
+		});
+
+		try {
+			await command.handle(args);
+		} catch (error) {
+			console.error('Command failed:', error);
+			process.exit(1);
+		}
+	}
+
+	private showHelp() {
+		console.log('PhoenixJS Framework CLI');
+		console.log('\nUsage:');
+		console.log('  bun artisan <command> [args]\n');
+		console.log('Available commands:');
+
+		for (const command of this.commands.values()) {
+			console.log(`  ${command.signature.padEnd(40)} ${command.description}`);
+		}
+	}
+}

package/template/framework/cli/artisan.ts

@@ -0,0 +1,16 @@
+import { ConsoleApplication } from './ConsoleApplication';
+import { MakeControllerCommand } from './commands/MakeControllerCommand';
+import { MakeValidatorCommand } from './commands/MakeValidatorCommand';
+import { MakeModelCommand } from './commands/MakeModelCommand';
+import { MakeMiddlewareCommand } from './commands/MakeMiddlewareCommand';
+
+const app = new ConsoleApplication();
+
+// Register commands
+app.register(new MakeControllerCommand());
+app.register(new MakeValidatorCommand());
+app.register(new MakeModelCommand());
+app.register(new MakeMiddlewareCommand());
+
+// Run
+await app.run(process.argv);