@martel/calyx 0.1.0 → 1.1.0

package/docs/controllers.md

@@ -47,7 +47,7 @@ Method arguments can extract parts of the request payload using parameter decora
 | Decorator | NestJS Match | Description |
 | :--- | :--- | :--- |
 | `@Req()` / `@Request()` | `req` | Exposes the raw Bun `Request` object. |
-| `@Res()` / `@Response()` | `res` | Exposes the `calyxResponse` wrapper for manual responses. |
+| `@Res()` / `@Response()` | `res` | Exposes the `CalyxResponse` wrapper for manual responses. |
 | `@Param(key?: string)` | `params[key]` | Extracts path parameters (e.g. `@Param('id')`). |
 | `@Query(key?: string)` | `query[key]` | Extracts query parameters (e.g. `@Query('limit')`). |
 | `@Body(key?: string)` | `body[key]` | Extracts request body payload (parsed JSON/urlencoded). |
@@ -104,7 +104,7 @@ legacy() {}
 If you need full control over the response, inject `@Res()`:
 ```typescript
 @Get('manual')
-manualResponse(@Res() res: calyxResponse) {
+manualResponse(@Res() res: CalyxResponse) {
   res.status(202).set('X-Manual', 'true').json({ success: true });
 }
 ```

package/docs/dependency-injection.md

@@ -7,7 +7,7 @@ calyx features a native, compile-safe, high-performance Dependency Injection (DI
 The DI system is composed of:
 1. **Modules (`@Module`)**: Encapsulated scopes organizing providers and controllers.
 2. **Providers (`@Injectable`)**: Classes, factories, or static values that can be injected into constructor functions.
-3. **Container (`calyxContainer`)**: The core registry that parses metadata, detects circular dependencies, and instantiates services.
+3. **Container (`CalyxContainer`)**: The core registry that parses metadata, detects circular dependencies, and instantiates services.
 
 ---
 

package/docs/lifecycle.md

@@ -135,14 +135,14 @@ square(@Query('num', ParseIntPipe) num: number) {
 Filters catch unhandled exceptions thrown during request execution. Use `@Catch(...Exceptions)` to declare which exceptions the filter catches.
 
 ```typescript
-import { ExceptionFilter, Catch, ArgumentsHost, UseFilters, calyxResponse } from '@martel/calyx';
+import { ExceptionFilter, Catch, ArgumentsHost, UseFilters, CalyxResponse } from '@martel/calyx';
 
 class CustomError extends Error {}
 
 @Catch(CustomError)
 class TeapotFilter implements ExceptionFilter {
   catch(exception: CustomError, host: ArgumentsHost) {
-    const res = host.switchToHttp().getResponse<calyxResponse>();
+    const res = host.switchToHttp().getResponse<CalyxResponse>();
     res.status(418).json({
       error: 'Teapot',
       message: exception.message,

package/docs/migration.md

@@ -47,14 +47,14 @@ import { Module, Injectable, Controller, Get, Param } from '@nestjs/common';
 import { NestFactory } from '@nestjs/core';
 
 // AFTER (calyx)
-import { Module, Injectable, Controller, Get, Param, calyxFactory } from '@martel/calyx';
+import { Module, Injectable, Controller, Get, Param, CalyxFactory } from '@martel/calyx';
 ```
 
 ---
 
 ## 3. Bootstrap Changes
 
-In NestJS, applications are bootstrapped using `NestFactory.create`. In calyx, use `calyxFactory.create` which returns a `calyxApplication` instance backed by Bun's native HTTP server:
+In NestJS, applications are bootstrapped using `NestFactory.create`. In calyx, use `CalyxFactory.create` which returns a `CalyxApplication` instance backed by Bun's native HTTP server:
 
 ```typescript
 // BEFORE (NestJS)
@@ -68,11 +68,11 @@ async function bootstrap() {
 bootstrap();
 
 // AFTER (calyx)
-import { calyxFactory } from '@martel/calyx';
+import { CalyxFactory } from '@martel/calyx';
 import { AppModule } from './app.module';
 
 async function bootstrap() {
-  const app = await calyxFactory.create(AppModule);
+  const app = await CalyxFactory.create(AppModule);
   await app.listen(3000);
 }
 bootstrap();
@@ -89,7 +89,7 @@ calyx implements identical decorators and interfaces for lifecycle elements:
     *   *Note: In NestJS, `next.handle()` returns an RxJS `Observable`. In calyx, it returns a standard native `Promise` or an `Observable` based on developer preference. If migrating RxJS interceptors, you can map the result or rewrite to simple async-await.*
 *   **Pipes**: Change `import { PipeTransform } from '@nestjs/common'` to `@martel/calyx`.
 *   **Exception Filters**: Change `import { ExceptionFilter, Catch } from '@nestjs/common'` to `@martel/calyx`.
-    *   *Note: Expose `host.switchToHttp().getResponse()` which returns calyx's Express-compatible `calyxResponse` wrapper to make calls like `res.status(code).json(body)` compatible without modifications.*
+    *   *Note: Expose `host.switchToHttp().getResponse()` which returns calyx's Express-compatible `CalyxResponse` wrapper to make calls like `res.status(code).json(body)` compatible without modifications.*
 
 ---
 

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@martel/calyx",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "High-performance Bun-native NestJS-compatible framework",
   "main": "src/index.ts",
+  "bin": {
+    "calyx": "./src/cli/index.ts"
+  },
   "type": "module",
   "scripts": {
     "test": "bun test",
@@ -19,13 +22,14 @@
     "@types/bun": "latest",
     "autocannon": "^8.0.0",
     "rxjs": "^7.8.2",
-    "semantic-release": "^24.0.0",
+    "semantic-release": "^25.0.0",
     "@semantic-release/changelog": "^6.0.3",
     "@semantic-release/git": "^10.0.1",
-    "@semantic-release/github": "^10.0.0",
-    "@semantic-release/npm": "^12.0.1"
+    "@semantic-release/github": "^12.0.0",
+    "@semantic-release/npm": "^13.0.0"
   },
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
   }
 }

package/src/cli/index.ts

@@ -0,0 +1,323 @@
+#!/usr/bin/env bun
+import { spawnSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join, dirname } from 'path';
+
+const args = Bun.argv.slice(2);
+const command = args[0];
+
+if (!command) {
+  printHelp();
+  process.exit(0);
+}
+
+switch (command) {
+  case 'info':
+    runInfo();
+    break;
+  case 'start':
+    runStart(args.slice(1));
+    break;
+  case 'build':
+    runBuild(args.slice(1));
+    break;
+  case 'new':
+    runNew(args[1]);
+    break;
+  case 'generate':
+  case 'g':
+    runGenerate(args[1], args[2]);
+    break;
+  default:
+    console.log(`Unknown command: ${command}`);
+    printHelp();
+    process.exit(1);
+}
+
+function printHelp() {
+  console.log(`
+Calyx CLI - Bun-native NestJS-compatible Framework CLI
+
+Usage:
+  calyx <command> [options]
+
+Commands:
+  new <name>            Scaffold a new Calyx application
+  generate, g <type> <name>   Generate a new schematic element (module, controller, service)
+  start                 Start the application
+    -w, --watch         Enable hot reload / watch mode
+  build                 Bundle the application using Bun compiler
+  info                  Display system and environment details
+  `);
+}
+
+function runInfo() {
+  console.log(`
+Calyx CLI Information:
+  Calyx Version: 0.1.0
+  Bun Version:   ${Bun.version}
+  OS Platform:   ${process.platform}
+  Node Compatibility: Yes
+  `);
+}
+
+function runStart(cmdArgs: string[]) {
+  const isWatch = cmdArgs.includes('--watch') || cmdArgs.includes('-w');
+  const mainPath = 'src/main.ts';
+
+  if (!existsSync(mainPath)) {
+    console.error(`Error: Cannot find entrypoint "${mainPath}". Make sure you are in a Calyx project root.`);
+    process.exit(1);
+  }
+
+  const spawnArgs = isWatch ? ['--watch', mainPath] : [mainPath];
+  console.log(`Starting Calyx application... (${isWatch ? 'Watch Mode' : 'Standard Mode'})`);
+  
+  const proc = spawnSync('bun', spawnArgs, { stdio: 'inherit' });
+  process.exit(proc.status ?? 0);
+}
+
+function runBuild(cmdArgs: string[]) {
+  const mainPath = 'src/main.ts';
+  if (!existsSync(mainPath)) {
+    console.error(`Error: Cannot find entrypoint "${mainPath}". Make sure you are in a Calyx project root.`);
+    process.exit(1);
+  }
+
+  console.log('Building Calyx application using bun build...');
+  const proc = spawnSync('bun', ['build', mainPath, '--outdir', './dist', '--target', 'bun'], { stdio: 'inherit' });
+  if (proc.status === 0) {
+    console.log('Build completed successfully. Output at ./dist/main.js');
+  }
+  process.exit(proc.status ?? 0);
+}
+
+function runNew(name: string) {
+  if (!name) {
+    console.error('Error: Please specify the project name. Example: calyx new my-app');
+    process.exit(1);
+  }
+
+  if (existsSync(name)) {
+    console.error(`Error: Directory "${name}" already exists.`);
+    process.exit(1);
+  }
+
+  console.log(`Scaffolding new Calyx application in "${name}"...`);
+
+  mkdirSync(name, { recursive: true });
+  mkdirSync(join(name, 'src'), { recursive: true });
+
+  // Write package.json
+  const packageJson = {
+    name,
+    version: '0.0.1',
+    description: 'Calyx application',
+    type: 'module',
+    scripts: {
+      "start": "calyx start",
+      "start:dev": "calyx start --watch",
+      "build": "calyx build"
+    },
+    dependencies: {
+      "@martel/calyx": "link:../..", // link back to Calyx package parent root for local tests
+      "reflect-metadata": "^0.2.2"
+    }
+  };
+  writeFileSync(join(name, 'package.json'), JSON.stringify(packageJson, null, 2));
+
+  // Write tsconfig.json
+  const tsconfigJson = {
+    compilerOptions: {
+      module: "ESNext",
+      target: "ESNext",
+      moduleResolution: "bundler",
+      esModuleInterop: true,
+      experimentalDecorators: true,
+      emitDecoratorMetadata: true,
+      strict: true,
+      skipLibCheck: true
+    }
+  };
+  writeFileSync(join(name, 'tsconfig.json'), JSON.stringify(tsconfigJson, null, 2));
+
+  // Write src/app.service.ts
+  const appService = `import { Injectable } from '@martel/calyx';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}
+`;
+  writeFileSync(join(name, 'src/app.service.ts'), appService);
+
+  // Write src/app.controller.ts
+  const appController = `import { Controller, Get } from '@martel/calyx';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}
+`;
+  writeFileSync(join(name, 'src/app.controller.ts'), appController);
+
+  // Write src/app.module.ts
+  const appModule = `import { Module } from '@martel/calyx';
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+@Module({
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+`;
+  writeFileSync(join(name, 'src/app.module.ts'), appModule);
+
+  // Write src/main.ts
+  const mainTs = `import 'reflect-metadata';
+import { CalyxFactory } from '@martel/calyx';
+import { AppModule } from './app.module';
+
+async function bootstrap() {
+  const app = await CalyxFactory.create(AppModule);
+  await app.listen(3000);
+  console.log('Application is running on http://localhost:3000');
+}
+bootstrap();
+`;
+  writeFileSync(join(name, 'src/main.ts'), mainTs);
+
+  console.log('Installing dependencies...');
+  spawnSync('bun', ['install'], { cwd: name, stdio: 'inherit' });
+
+  console.log(`
+Calyx application successfully created!
+
+To start running your app:
+  cd ${name}
+  bun run start:dev
+  `);
+}
+
+function runGenerate(schematic: string, rawName: string) {
+  if (!schematic || !rawName) {
+    console.error('Error: Please specify schematic type and name. Example: calyx g controller users');
+    process.exit(1);
+  }
+
+  const name = rawName.toLowerCase();
+  const pascalName = rawName.charAt(0).toUpperCase() + rawName.slice(1);
+  const type = schematic.toLowerCase();
+
+  const srcDir = existsSync('src') ? 'src' : '.';
+  const targetDir = join(srcDir, name);
+
+  if (!existsSync(targetDir)) {
+    mkdirSync(targetDir, { recursive: true });
+  }
+
+  switch (type) {
+    case 'module': {
+      const filePath = join(targetDir, `${name}.module.ts`);
+      const content = `import { Module } from '@martel/calyx';
+
+@Module({})
+export class ${pascalName}Module {}
+`;
+      writeFileSync(filePath, content);
+      console.log(`CREATE ${filePath}`);
+      break;
+    }
+    case 'controller': {
+      const filePath = join(targetDir, `${name}.controller.ts`);
+      const content = `import { Controller, Get } from '@martel/calyx';
+
+@Controller('${name}')
+export class ${pascalName}Controller {
+  @Get()
+  findAll() {
+    return 'This action returns all ${name}';
+  }
+}
+`;
+      writeFileSync(filePath, content);
+      console.log(`CREATE ${filePath}`);
+      autoRegisterInModule(name, pascalName, 'controller');
+      break;
+    }
+    case 'service': {
+      const filePath = join(targetDir, `${name}.service.ts`);
+      const content = `import { Injectable } from '@martel/calyx';
+
+@Injectable()
+export class ${pascalName}Service {}
+`;
+      writeFileSync(filePath, content);
+      console.log(`CREATE ${filePath}`);
+      autoRegisterInModule(name, pascalName, 'service');
+      break;
+    }
+    default:
+      console.error(`Error: Unknown schematic type "${type}". Supported: module, controller, service`);
+      process.exit(1);
+  }
+}
+
+function autoRegisterInModule(name: string, pascalName: string, type: 'controller' | 'service') {
+  const srcDir = existsSync('src') ? 'src' : '.';
+  const modulePath = join(srcDir, name, `${name}.module.ts`);
+  const rootModulePath = join(srcDir, `app.module.ts`);
+
+  const pathToCheck = existsSync(modulePath) ? modulePath : (existsSync(rootModulePath) ? rootModulePath : null);
+  if (!pathToCheck) return;
+
+  let content = readFileSync(pathToCheck, 'utf-8');
+
+  // Insert import statement
+  const importName = `${pascalName}${type === 'controller' ? 'Controller' : 'Service'}`;
+  const importRelativePath = pathToCheck === rootModulePath ? `./${name}/${name}.${type}` : `./${name}.${type}`;
+  const importStatement = `import { ${importName} } from '${importRelativePath}';\n`;
+
+  // Find last import line and insert after it
+  const lines = content.split('\n');
+  let lastImportIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].trim().startsWith('import ')) {
+      lastImportIdx = i;
+    }
+  }
+  lines.splice(lastImportIdx + 1, 0, importStatement.trim());
+  content = lines.join('\n');
+
+  // Add item into metadata decorator
+  const arrayName = type === 'controller' ? 'controllers' : 'providers';
+  const arrayRegex = new RegExp(`(${arrayName}\\s*:\\s*\\[)([^\\]]*)(\\])`);
+
+  if (arrayRegex.test(content)) {
+    content = content.replace(arrayRegex, (match, prefix, list, suffix) => {
+      const trimmedList = list.trim();
+      const newList = trimmedList ? `${trimmedList}, ${importName}` : importName;
+      return `${prefix}${newList}${suffix}`;
+    });
+  } else {
+    // Add the metadata property if it doesn't exist
+    const decoratorRegex = /(@Module\(\s*\{)([\s\S]*?)(\}\s*\))/;
+    content = content.replace(decoratorRegex, (match, prefix, body, suffix) => {
+      const trimmedBody = body.trim();
+      const newBody = trimmedBody ? `${trimmedBody},\n  ${arrayName}: [${importName}]` : `  ${arrayName}: [${importName}]`;
+      return `${prefix}\n${newBody}\n${suffix}`;
+    });
+  }
+
+  writeFileSync(pathToCheck, content);
+  console.log(`UPDATE ${pathToCheck} (Registered ${importName})`);
+}