@elysiumjs/styx 0.3.0 → 0.5.0

package/src/commands/migration_run.ts

@@ -0,0 +1,153 @@
+// Copyright (c) 2025-present Workbud Technologies Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { basename } from 'node:path';
+
+import { Command, CommandArgumentType, Database } from '@elysiumjs/core';
+import prompts from 'prompts';
+import { alphabetical } from 'radash';
+
+/**
+ * Execute migration files.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export class MigrationRunCommand extends Command {
+	public static readonly command: string = 'migration:run';
+	public static readonly description: string = 'Generates migration files.';
+
+	@Command.arg({
+		description: 'The name of the tenant in which the migrations will be executed.',
+		type: CommandArgumentType.STRING,
+		required: true
+	})
+	private tenant: string = '';
+
+	@Command.arg({
+		description: 'The name of the connection to use.',
+		type: CommandArgumentType.STRING,
+		default: 'default'
+	})
+	private connection: string = 'default';
+
+	@Command.arg({
+		description: 'Drop the entire schema before running the migrations.',
+		type: CommandArgumentType.BOOLEAN,
+		default: false
+	})
+	private fresh: boolean = false;
+
+	public async run(): Promise<void> {
+		if (!Database.connectionExists(this.connection)) {
+			this.error(`Connection ${this.bold(this.connection)} does not exist.`);
+			return process.exit(1);
+		}
+
+		const sql = Database.getConnection(this.connection).$client;
+		await sql.connect();
+
+		await sql.begin(async (sql) => {
+			if (this.fresh) {
+				await sql`DROP SCHEMA IF EXISTS ${sql(this.tenant)} CASCADE;`;
+				await sql`CREATE SCHEMA ${sql(this.tenant)};`;
+			}
+
+			const [{ schema_exists }] = await sql`SELECT EXISTS (
+			SELECT schema_name
+			  FROM information_schema.schemata
+			 WHERE schema_name = ${this.tenant}
+		) AS schema_exists;`;
+
+			if (!schema_exists) {
+				const answers = await prompts(
+					[
+						{
+							type: 'confirm',
+							name: 'create',
+							message: `Schema ${this.tenant} does not exist. Do you want to create it?`,
+							initial: true
+						}
+					],
+					{
+						onCancel: () => {
+							this.error('Operation cancelled.');
+							process.exit(0);
+						}
+					}
+				);
+
+				if (answers.create) {
+					await sql`CREATE SCHEMA ${sql(this.tenant)};`;
+				} else {
+					this.error(`Schema ${this.bold(this.tenant)} creation cancelled.`);
+					return process.exit(1);
+				}
+			}
+
+			await sql`SET search_path TO ${sql(this.tenant)};`;
+
+			const [{ table_exists }] = await sql`SELECT EXISTS (
+			SELECT *
+			  FROM information_schema.tables
+			 WHERE table_name = 'elysium_migrations'
+			   AND table_schema = ${this.tenant}
+		) AS table_exists;`;
+
+			if (!table_exists) {
+				await sql`CREATE TABLE elysium_migrations (
+				id SERIAL PRIMARY KEY,
+				name TEXT NOT NULL,
+				batch INTEGER NOT NULL,
+				applied_at TIMESTAMP NOT NULL
+			);`;
+			}
+
+			const migrations: { name: string }[] = await sql`SELECT name FROM elysium_migrations;`;
+			const completedMigrations = migrations.map((row) => row.name);
+
+			const filesIt = new Bun.Glob(`./src/database/migrations/**/*.sql`).scan({
+				absolute: true,
+				onlyFiles: true
+			});
+
+			const files = await Array.fromAsync(filesIt);
+			const sqlFiles = alphabetical(
+				files.filter((file) => !completedMigrations.includes(basename(file))),
+				(file) => file
+			);
+
+			if (sqlFiles.length === 0) {
+				this.success('No new migrations to apply.');
+				return;
+			}
+
+			const s = this.spinner(`Running migrations for tenant ${this.bold(this.tenant)}...`);
+
+			const [{ max }]: [{ max?: number }] =
+				await sql`SELECT MAX(batch) + 1 AS max FROM elysium_migrations;`;
+
+			const batch = max ?? 0;
+
+			for (const path of sqlFiles) {
+				await sql.file(path);
+				const [{ name }] =
+					await sql`INSERT INTO elysium_migrations (name, batch, applied_at) VALUES (${basename(path)}, ${batch}, ${new Date()}) RETURNING name;`;
+				s.pause(`Migration ${this.bold(name)} applied successfully.`);
+			}
+
+			s.complete(`Migrations for tenant ${this.bold(this.tenant)} applied successfully.`);
+		});
+
+		await sql.close();
+	}
+}

package/src/commands/module_new.ts

@@ -0,0 +1,112 @@
+// Copyright (c) 2025-present Workbud Technologies Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { exists, rmdir } from 'node:fs/promises';
+import { join } from 'node:path';
+
+import { Command, CommandArgumentType } from '@elysiumjs/core';
+import prompts from 'prompts';
+import { snake } from 'radash';
+
+import { parseProjectConfig } from '../config';
+import { createModule, getProjectPath } from '../utils';
+
+/**
+ * Command for creating Elysium.js modules.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export class ModuleNewCommand extends Command {
+	public static readonly command: string = 'module:new';
+	public static readonly description: string = 'Creates a new module.';
+
+	@Command.arg({
+		description: 'The name of the module to create',
+		type: CommandArgumentType.STRING
+	})
+	private name?: string;
+
+	private module?: string;
+	private convert: boolean = false;
+
+	public override async run(): Promise<void> {
+		const config = await parseProjectConfig();
+
+		// 1. Prompt for new module name if not provided
+		if (!this.name) {
+			const name = await prompts(
+				{
+					type: 'text',
+					name: 'name',
+					message: 'New module name:',
+					initial: 'module',
+					validate(value) {
+						return value.length > 0 ? true : 'Module name cannot be empty';
+					}
+				},
+				{
+					onCancel: () => process.exit(0)
+				}
+			);
+
+			this.name = snake(name.name);
+		}
+
+		// 2. If mono-module, prompt for conversion and current module name
+		if (config.mono) {
+			const { module, convert } = await prompts(
+				[
+					{
+						type: 'confirm',
+						name: 'convert',
+						message:
+							'This project is a mono-module project. Do you want to convert it to a multi-module project?',
+						initial: false
+					},
+					{
+						type: (convert) => (convert ? 'text' : null),
+						name: 'module',
+						message: 'Current module name:',
+						initial: 'main',
+						validate(value) {
+							return value.length > 0 ? true : 'Module name cannot be empty';
+						}
+					}
+				],
+				{
+					onCancel: () => process.exit(0)
+				}
+			);
+
+			if (!convert) return this.error('Operation cancelled. The project is left unchanged.');
+
+			this.module = snake(module as string);
+			this.convert = convert;
+		}
+
+		// 3. If multi-module conversion is enabled, convert the project to a multi-module project
+		if (this.convert) {
+			const modulesDir = join(getProjectPath(), 'src', 'modules');
+			if (await exists(modulesDir)) await rmdir(modulesDir, { recursive: true });
+
+			await createModule(this.module!, 'root');
+
+			this.success(`Project converted to multi-module.`);
+			this.success(`Module '${this.module}' created.`);
+		}
+
+		// 4. Create the new module
+		await createModule(this.name);
+		this.success(`Module '${this.name}' created.`);
+	}
+}

package/src/commands/module_rename.ts

@@ -0,0 +1,78 @@
+// Copyright (c) 2025-present Workbud Technologies Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { Command, CommandArgumentType } from '@elysiumjs/core';
+import prompts from 'prompts';
+
+import { parseProjectConfig } from '../config';
+import { createModule } from '../utils';
+
+/**
+ * Command for renaming Elysium.js modules.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export class ModuleRenameCommand extends Command {
+	public static readonly command: string = 'module:rename';
+	public static readonly description: string = 'Renames a module.';
+
+	@Command.arg({
+		description: 'The module to rename',
+		type: CommandArgumentType.STRING
+	})
+	private module?: string;
+
+	@Command.arg({
+		description: 'The new name of the module',
+		type: CommandArgumentType.STRING
+	})
+	private name?: string;
+
+	public override async run(): Promise<void> {
+		const config = await parseProjectConfig();
+
+		if (config.mono) {
+			return this.error('This operation is not supported for mono-module projects.');
+		}
+
+		if (!this.module) {
+			const { module } = await prompts({
+				type: 'text',
+				name: 'module',
+				message: 'Module to rename:',
+				validate: (value) => value.length > 0
+			});
+
+			this.module = module as string;
+		}
+
+		if (!this.name) {
+			const { name } = await prompts({
+				type: 'text',
+				name: 'name',
+				message: 'New module name:',
+				initial: this.module,
+				validate: (value) => value.length > 0
+			});
+
+			this.name = name as string;
+		}
+
+		if (this.module === this.name) {
+			return this.info('Module name is the same as the current name.');
+		}
+
+		await createModule(this.name!, this.module!);
+		this.success(`Module '${this.module}' renamed to '${this.name}'.`);
+	}
+}

package/src/config.ts

@@ -0,0 +1,101 @@
+// Copyright (c) 2025-present Workbud Technologies Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { join } from 'node:path';
+
+import { getProjectPath } from './utils';
+
+/**
+ * Describes the Elysium project's configuration.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export interface ProjectConfig {
+	/**
+	 * The name of the Elysium project.
+	 */
+	projectName: string;
+
+	/**
+	 * Whether the Elysium project is a mono module.
+	 */
+	mono: boolean;
+
+	/**
+	 * A map of module names to their paths.
+	 *
+	 * Only used if the Elysium project is not a mono module.
+	 */
+	modules?: Record<string, string>;
+}
+
+/**
+ * Parses the Elysium project's configuration file.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @throws If the Elysium config file is not found.
+ * @returns The Elysium project's configuration.
+ */
+export const parseProjectConfig = async (): Promise<ProjectConfig> => {
+	const file = Bun.file(join(getProjectPath(), '.elysiumrc'));
+	if (!file.exists()) {
+		throw new Error('Elysium config file not found.');
+	}
+
+	return file.json();
+};
+
+/**
+ * Writes the Elysium project's configuration file.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param config The Elysium project's configuration.
+ */
+export const writeProjectConfig = async (config: ProjectConfig) => {
+	const file = Bun.file(join(getProjectPath(), '.elysiumrc'));
+	await file.write(JSON.stringify(config, null, 2));
+};
+
+/**
+ * Checks if the Elysium project is a mono-module project.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @returns Whether the Elysium project is a mono module.
+ */
+export const isMonoModule = async () => {
+	const config = await parseProjectConfig();
+	return config.mono;
+};
+
+/**
+ * Gets the path of a module.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param moduleName The name of the module.
+ * @returns The path of the module.
+ */
+export const getModulePath = async (moduleName: string) => {
+	const config = await parseProjectConfig();
+	if (config.mono) {
+		return './src';
+	}
+
+	return config.modules![moduleName];
+};
+
+/**
+ * Checks if a module exists.
+ * @author Axel Nana <axel.nana@workbud.com>
+ * @param moduleName The name of the module.
+ * @returns Whether the module exists.
+ */
+export const moduleExists = async (moduleName: string) => {
+	const path = await getModulePath(moduleName);
+	return Bun.file(path).exists();
+};

package/src/styx.ts

@@ -0,0 +1,54 @@
+#!/usr/bin/env bun
+// Copyright (c) 2025-present Workbud Technologies Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+import 'reflect-metadata';
+
+import {
+	MakeCommandCommand,
+	MakeControllerCommand,
+	MakeJobCommand,
+	MakeMiddlewareCommand,
+	MakeModelCommand,
+	MakeRepositoryCommand,
+	MakeServiceCommand,
+	MakeValidatorCommand,
+	MigrationGenerateCommand,
+	MigrationRunCommand,
+	ModuleNewCommand,
+	ModuleRenameCommand
+} from './commands';
+import { getProjectPath } from './utils';
+
+const projectPath = getProjectPath();
+const { App } = await import(`${projectPath}/src/app`);
+
+@App.register({
+	commands: [
+		MakeCommandCommand,
+		MakeControllerCommand,
+		MakeJobCommand,
+		MakeMiddlewareCommand,
+		MakeModelCommand,
+		MakeRepositoryCommand,
+		MakeServiceCommand,
+		MakeValidatorCommand,
+		MigrationGenerateCommand,
+		MigrationRunCommand,
+		ModuleNewCommand,
+		ModuleRenameCommand
+	]
+})
+class StyxApp extends App {}
+
+new StyxApp();

package/src/utils.ts

@@ -0,0 +1,148 @@
+// Copyright (c) 2025-present Workbud Technologies Inc. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+import { existsSync } from 'node:fs';
+import { mkdir, readdir, rename } from 'node:fs/promises';
+import { dirname, extname, join } from 'node:path';
+
+/**
+ * Gets the root path of the styx package.
+ * @author Axel Nana <axel.nana@workbud.com>
+ */
+export const getRootPath = () => {
+	return dirname(Bun.fileURLToPath(import.meta.url));
+};
+
+/**
+ * Gets the root path of the Elysium.js project.
+ * @author Axel Nana <axel.nana@workbud.com>
+ *
+ * @returns The detected project path.
+ */
+export const getProjectPath = () => {
+	let startPath = process.cwd(),
+		dir = startPath;
+
+	while (true) {
+		if (existsSync(join(dir, '.elysiumrc'))) return dir;
+
+		const parentDir = dirname(dir);
+		if (dir === parentDir) break;
+
+		dir = parentDir;
+	}
+
+	return startPath;
+};
+
+/**
+ * Creates a new module or rename an existing module.
+ * @author Axel Nana <axel.nana@workbud.com>
+ *
+ * @param name The name of the module to create or rename.
+ * @param oldName The old name of the module to rename.
+ */
+export const createModule = async (name: string, oldName?: string) => {
+	const root = getProjectPath();
+
+	// Create module directory
+	{
+		const moduleDir = join(root, 'src', 'modules', name);
+		await mkdir(moduleDir, { recursive: true });
+
+		if (oldName) {
+			if (oldName === 'root') {
+				const entries = await readdir(join(root, 'src'));
+				for (const entry of entries) {
+					if (['app.ts', 'env.ts', 'database', 'modules'].includes(entry)) continue;
+					const oldPath = join(root, 'src', entry);
+					const newPath = join(moduleDir, entry === 'main.module.ts' ? `${name}.module.ts` : entry);
+					await rename(oldPath, newPath);
+				}
+			} else {
+				const oldModuleDir = join(root, 'src', 'modules', oldName);
+				await rename(oldModuleDir, moduleDir);
+			}
+		}
+	}
+
+	// Update package.json imports
+	{
+		const pkg = await Bun.file(join(root, 'package.json')).json();
+
+		pkg.imports = pkg.imports ?? {};
+		pkg.imports[`#${name}/*`] = `./src/modules/${name}/*.ts`;
+
+		if (oldName && oldName !== 'root') {
+			delete pkg.imports[`#${oldName}/*`];
+		}
+
+		await Bun.write(join(root, 'package.json'), JSON.stringify(pkg, null, 2));
+	}
+
+	// Update .elysiumrc
+	{
+		const rc = await Bun.file(join(root, '.elysiumrc')).json();
+
+		rc.mono = false;
+		rc.modules = rc.modules ?? {};
+		rc.modules[name] = `./src/modules/${name}`;
+
+		if (oldName) {
+			delete rc.modules[oldName];
+		}
+
+		await Bun.write(join(root, '.elysiumrc'), JSON.stringify(rc, null, 2));
+	}
+
+	// Update imports in all modules
+	if (oldName) {
+		const rewriteImports = async (dir: string) => {
+			const entries = await readdir(dir, { withFileTypes: true });
+
+			for (const entry of entries) {
+				const fullPath = join(dir, entry.name);
+
+				if (entry.isDirectory()) {
+					await rewriteImports(fullPath);
+				} else if (extname(entry.name) === '.ts') {
+					let text = await Bun.file(fullPath).text();
+
+					if (oldName === 'root') {
+						text = text.replace(
+							new RegExp(`(['"])#${oldName}/((?!(env|app|database(?:/|$))).*?)(['"])`, 'g'),
+							`$1#${name}/$2$4`
+						);
+					} else {
+						text = text.replace(new RegExp(`(['"])#${oldName}/`, 'g'), `$1#${name}/`);
+					}
+
+					text = text.replace(
+						new RegExp(`(['"])#${oldName}/main\\.module(['"])/g`, 'g'),
+						`$1#${name}/${name}.module$2`
+					);
+
+					text = text.replace(
+						new RegExp(`(['"])#${oldName}/main\\.module\\.ts(['"])?/g`, 'g'),
+						`$1#${name}/${name}.module$2`
+					);
+
+					await Bun.write(fullPath, text);
+				}
+			}
+		};
+
+		await rewriteImports(root);
+	}
+};

package/stubs/validator.stub

@@ -1,3 +1,5 @@
+import type { Context } from '@elysiumjs/core';
+
 import { t } from 'elysia';
 
 export class {name} {
@@ -34,6 +36,34 @@ export class {name} {
      * })
      */
     public static readonly schema = t.Object({});
+
+    /**
+     * Whether the request should be authorized before validation.
+     *
+     * If the request is not authorized, the validation will be skipped.
+     *
+     * @param ctx The request context.
+     * @returns Whether the request is authorized.
+     */
+    public static async authorize(ctx: Context<{request_name}>): Promise<boolean> {
+        return true;
+    }
+
+    /**
+     * Processes custom validation logic.
+     *
+     * This method is called after the validation schema is checked against the input data.
+     * So it's safe to assume that the schema is valid.
+     *
+     * You can use this method to perform any custom validation logic on the request body or
+     * query parameters.
+     *
+     * @param ctx The request context.
+     * @returns Whether the input data is valid.
+     */
+    public static async validate(ctx: Context<{request_name}>): Promise<boolean> {
+        return true;
+    }
 }
 
 export type {request_name} = typeof {name}.schema.static;