@expressots/cli 3.0.0 → 4.0.0-preview.2

package/bin/costs/sources/remote-json-source.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Remote JSON pricing source - fetches from GitHub-hosted pricing file
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRemoteJSONPricingSource = exports.RemoteJSONPricingSource = void 0;
+const https_1 = __importDefault(require("https"));
+const DEFAULT_URL = "https://raw.githubusercontent.com/expressots/pricing/main/pricing.json";
+const FETCH_TIMEOUT = 10000;
+class RemoteJSONPricingSource {
+    constructor(url) {
+        this.name = "remote";
+        this.url = url || DEFAULT_URL;
+    }
+    async fetch() {
+        return new Promise((resolve) => {
+            const request = https_1.default.get(this.url, { timeout: FETCH_TIMEOUT }, (response) => {
+                if (response.statusCode !== 200) {
+                    resolve(null);
+                    return;
+                }
+                let data = "";
+                response.on("data", (chunk) => {
+                    data += chunk;
+                });
+                response.on("end", () => {
+                    try {
+                        const pricing = JSON.parse(data);
+                        resolve(pricing);
+                    }
+                    catch {
+                        resolve(null);
+                    }
+                });
+            });
+            request.on("error", () => {
+                resolve(null);
+            });
+            request.on("timeout", () => {
+                request.destroy();
+                resolve(null);
+            });
+        });
+    }
+}
+exports.RemoteJSONPricingSource = RemoteJSONPricingSource;
+function createRemoteJSONPricingSource(url) {
+    return new RemoteJSONPricingSource(url);
+}
+exports.createRemoteJSONPricingSource = createRemoteJSONPricingSource;

package/bin/costs/types.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Pricing types and interfaces
+ */
+export type CloudProvider = "aws" | "gcp" | "azure" | "railway" | "render" | "fly" | "digitalocean" | "heroku";
+export type PricingModel = "per-hour" | "per-month" | "usage";
+export interface ProviderPricing {
+    serviceName: string;
+    model: PricingModel;
+    basePrice: number;
+    cpuPerHour: number;
+    memoryPerGbHour: number;
+    storagePerGb: number;
+    bandwidthPerGb: number;
+    freeBandwidth: number;
+    freeCredits?: number;
+    notes?: string;
+    source?: string;
+    lastVerified?: string;
+}
+export interface PricingData {
+    version: string;
+    updated: string;
+    providers: Record<CloudProvider, ProviderPricing>;
+}
+export interface PricingSource {
+    name: string;
+    fetch(): Promise<PricingData | null>;
+}
+export interface ResourceEstimate {
+    instances: number;
+    cpu: number;
+    memory: number;
+    storage: number;
+    bandwidth: number;
+    hours: number;
+}
+export interface CostEstimate {
+    provider: CloudProvider;
+    monthlyCost: number;
+    breakdown: {
+        compute: number;
+        storage: number;
+        bandwidth: number;
+        base: number;
+    };
+    currency: string;
+    notes?: string;
+}
+export interface PricingCacheEntry {
+    data: PricingData;
+    timestamp: number;
+    source: string;
+}

package/bin/costs/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Pricing types and interfaces
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/bin/dev/cli.d.ts

@@ -0,0 +1,4 @@
+import { CommandModule } from "yargs";
+type CommandModuleArgs = {};
+declare const devContainerCommand: () => CommandModule<CommandModuleArgs, any>;
+export { devContainerCommand };

package/bin/dev/cli.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devContainerCommand = void 0;
+const form_1 = require("./form");
+const devContainerCommand = () => {
+    return {
+        command: "container-dev [action]",
+        describe: "Develop inside Docker containers with hot reload.",
+        aliases: ["cdev", "docker-dev"],
+        builder: (yargs) => {
+            yargs.positional("action", {
+                choices: [
+                    "start",
+                    "stop",
+                    "attach",
+                    "shell",
+                    "status",
+                    "logs",
+                ],
+                describe: "Action to perform",
+                type: "string",
+                default: "start",
+            });
+            yargs.option("container", {
+                describe: "Run development in Docker container",
+                type: "boolean",
+                alias: "c",
+                default: false,
+            });
+            yargs.option("service", {
+                describe: "Docker Compose service name",
+                type: "string",
+                alias: "s",
+                default: "app",
+            });
+            yargs.option("compose-file", {
+                describe: "Path to docker-compose file",
+                type: "string",
+                alias: "f",
+                default: "docker-compose.development.yml",
+            });
+            yargs.option("build", {
+                describe: "Rebuild container before starting",
+                type: "boolean",
+                alias: "b",
+                default: false,
+            });
+            yargs.option("detach", {
+                describe: "Run in background",
+                type: "boolean",
+                alias: "d",
+                default: false,
+            });
+            yargs.option("port", {
+                describe: "Override application port",
+                type: "number",
+                alias: "p",
+            });
+            yargs.option("debug-port", {
+                describe: "Debug port for Node.js inspector",
+                type: "number",
+                default: 9229,
+            });
+            yargs.option("watch", {
+                describe: "Enable file watching for hot reload",
+                type: "boolean",
+                alias: "w",
+                default: true,
+            });
+            yargs.option("follow", {
+                describe: "Follow logs (for logs action)",
+                type: "boolean",
+                default: true,
+            });
+            yargs.option("tail", {
+                describe: "Number of log lines to show",
+                type: "number",
+                default: 100,
+            });
+            return yargs;
+        },
+        handler: async (argv) => {
+            const { action, container, service, composeFile, build, detach, port, debugPort, watch, follow, tail, } = argv;
+            const options = {
+                container,
+                service,
+                composeFile,
+                build,
+                detach,
+                port,
+                debugPort,
+                watch,
+                follow,
+                tail,
+            };
+            // If --container flag is set without action, start container dev
+            if (container && action === "start") {
+                await (0, form_1.startDevContainer)(options);
+                return;
+            }
+            switch (action) {
+                case "start":
+                    if (container) {
+                        await (0, form_1.startDevContainer)(options);
+                    }
+                    else {
+                        // Regular dev command (non-container) - delegate to existing
+                        console.log("Starting local development...");
+                        console.log("Use --container flag to develop inside Docker.");
+                        console.log("Or run: npm run dev");
+                    }
+                    break;
+                case "stop":
+                    await (0, form_1.stopDevContainer)(options);
+                    break;
+                case "attach":
+                    await (0, form_1.attachToContainer)(options);
+                    break;
+                case "shell":
+                    await (0, form_1.openShell)(options);
+                    break;
+                case "status":
+                    await (0, form_1.showStatus)(options);
+                    break;
+                case "logs":
+                    await (0, form_1.showLogs)(options);
+                    break;
+                default:
+                    console.log(`Unknown action: ${action}`);
+            }
+        },
+    };
+};
+exports.devContainerCommand = devContainerCommand;

package/bin/dev/form.d.ts

@@ -0,0 +1,36 @@
+export interface DevOptions {
+    container: boolean;
+    service: string;
+    composeFile: string;
+    build: boolean;
+    detach: boolean;
+    port?: number;
+    debugPort: number;
+    watch: boolean;
+    follow: boolean;
+    tail: number;
+}
+/**
+ * Start development container with hot reload
+ */
+export declare function startDevContainer(options: DevOptions): Promise<void>;
+/**
+ * Stop development containers
+ */
+export declare function stopDevContainer(options: DevOptions): Promise<void>;
+/**
+ * Attach to running container
+ */
+export declare function attachToContainer(options: DevOptions): Promise<void>;
+/**
+ * Open shell in container
+ */
+export declare function openShell(options: DevOptions): Promise<void>;
+/**
+ * Show status of development containers
+ */
+export declare function showStatus(options: DevOptions): Promise<void>;
+/**
+ * Show container logs
+ */
+export declare function showLogs(options: DevOptions): Promise<void>;

package/bin/dev/form.js

@@ -0,0 +1,254 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showLogs = exports.showStatus = exports.openShell = exports.attachToContainer = exports.stopDevContainer = exports.startDevContainer = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+/**
+ * Start development container with hot reload
+ */
+async function startDevContainer(options) {
+    console.log(chalk_1.default.cyan("\n🐳 ExpressoTS Container Development\n"));
+    const cwd = process.cwd();
+    const composeFile = path_1.default.join(cwd, options.composeFile);
+    // Check if docker-compose file exists
+    if (!fs_1.default.existsSync(composeFile)) {
+        console.log(chalk_1.default.yellow(`⚠️  ${options.composeFile} not found.`));
+        console.log(chalk_1.default.gray("Generating development Docker configuration..."));
+        // Try to generate if containerize is available
+        console.log(chalk_1.default.gray("\nRun the following to generate development config:"));
+        console.log(chalk_1.default.white(`  expressots containerize docker --env development`));
+        console.log();
+        return;
+    }
+    // Check if Docker is running
+    if (!isDockerRunning()) {
+        console.log(chalk_1.default.red("Error: Docker is not running."));
+        console.log(chalk_1.default.gray("Please start Docker Desktop or Docker daemon."));
+        return;
+    }
+    console.log(chalk_1.default.yellow(`📄 Using ${options.composeFile}`));
+    // Build arguments
+    const args = ["-f", composeFile];
+    if (options.build) {
+        console.log(chalk_1.default.yellow("🔨 Building containers..."));
+        runDockerCompose([...args, "build"], { cwd });
+    }
+    // Start containers
+    console.log(chalk_1.default.yellow("🚀 Starting development containers..."));
+    const upArgs = [...args, "up"];
+    if (options.detach) {
+        upArgs.push("-d");
+    }
+    // Set environment variables
+    const env = {
+        ...process.env,
+    };
+    if (options.port) {
+        env.PORT = String(options.port);
+    }
+    env.DEBUG_PORT = String(options.debugPort);
+    if (options.detach) {
+        runDockerCompose(upArgs, { cwd, env });
+        console.log(chalk_1.default.green("\n✅ Development containers started in background.\n"));
+        printDevInfo(options);
+    }
+    else {
+        console.log(chalk_1.default.green("\n✅ Starting development environment...\n"));
+        printDevInfo(options);
+        console.log(chalk_1.default.gray("Press Ctrl+C to stop\n"));
+        // Run in foreground
+        spawnDockerCompose(upArgs, { cwd, env, stdio: "inherit" });
+    }
+}
+exports.startDevContainer = startDevContainer;
+/**
+ * Stop development containers
+ */
+async function stopDevContainer(options) {
+    console.log(chalk_1.default.cyan("\n🛑 Stopping development containers...\n"));
+    const cwd = process.cwd();
+    const composeFile = path_1.default.join(cwd, options.composeFile);
+    if (!fs_1.default.existsSync(composeFile)) {
+        // Try default compose file
+        const defaultCompose = path_1.default.join(cwd, "docker-compose.yml");
+        if (fs_1.default.existsSync(defaultCompose)) {
+            runDockerCompose(["-f", defaultCompose, "down"], { cwd });
+        }
+        else {
+            console.log(chalk_1.default.yellow("No docker-compose file found."));
+        }
+        return;
+    }
+    runDockerCompose(["-f", composeFile, "down"], { cwd });
+    console.log(chalk_1.default.green("✅ Development containers stopped."));
+}
+exports.stopDevContainer = stopDevContainer;
+/**
+ * Attach to running container
+ */
+async function attachToContainer(options) {
+    console.log(chalk_1.default.cyan(`\n🔗 Attaching to ${options.service}...\n`));
+    const cwd = process.cwd();
+    const composeFile = path_1.default.join(cwd, options.composeFile);
+    if (!fs_1.default.existsSync(composeFile)) {
+        console.log(chalk_1.default.red(`Error: ${options.composeFile} not found.`));
+        return;
+    }
+    spawnDockerCompose(["-f", composeFile, "attach", options.service], {
+        cwd,
+        stdio: "inherit",
+    });
+}
+exports.attachToContainer = attachToContainer;
+/**
+ * Open shell in container
+ */
+async function openShell(options) {
+    console.log(chalk_1.default.cyan(`\n🐚 Opening shell in ${options.service}...\n`));
+    const cwd = process.cwd();
+    const composeFile = path_1.default.join(cwd, options.composeFile);
+    if (!fs_1.default.existsSync(composeFile)) {
+        console.log(chalk_1.default.red(`Error: ${options.composeFile} not found.`));
+        return;
+    }
+    // Try sh first (Alpine), fall back to bash
+    spawnDockerCompose(["-f", composeFile, "exec", options.service, "sh"], {
+        cwd,
+        stdio: "inherit",
+    });
+}
+exports.openShell = openShell;
+/**
+ * Show status of development containers
+ */
+async function showStatus(options) {
+    console.log(chalk_1.default.cyan("\n📊 Development Container Status\n"));
+    const cwd = process.cwd();
+    const composeFile = path_1.default.join(cwd, options.composeFile);
+    if (!fs_1.default.existsSync(composeFile)) {
+        // Try default compose
+        const defaultCompose = path_1.default.join(cwd, "docker-compose.yml");
+        if (fs_1.default.existsSync(defaultCompose)) {
+            runDockerCompose(["-f", defaultCompose, "ps"], { cwd });
+        }
+        else {
+            console.log(chalk_1.default.yellow("No docker-compose file found."));
+        }
+        return;
+    }
+    runDockerCompose(["-f", composeFile, "ps"], { cwd });
+    // Show resource usage
+    console.log(chalk_1.default.bold("\nResource Usage:"));
+    try {
+        // Use double quotes for cross-platform compatibility (Windows + Unix)
+        const output = (0, child_process_1.execSync)('docker stats --no-stream --format "table {{.Name}}\t{{.CPUPerc}}\t{{.MemUsage}}"', {
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        console.log(output);
+    }
+    catch {
+        console.log(chalk_1.default.gray("  Unable to get resource stats"));
+    }
+}
+exports.showStatus = showStatus;
+/**
+ * Show container logs
+ */
+async function showLogs(options) {
+    console.log(chalk_1.default.cyan(`\n📜 Logs for ${options.service}\n`));
+    const cwd = process.cwd();
+    const composeFile = path_1.default.join(cwd, options.composeFile);
+    if (!fs_1.default.existsSync(composeFile)) {
+        console.log(chalk_1.default.red(`Error: ${options.composeFile} not found.`));
+        return;
+    }
+    const args = ["-f", composeFile, "logs"];
+    if (options.follow) {
+        args.push("-f");
+    }
+    args.push("--tail", String(options.tail));
+    args.push(options.service);
+    spawnDockerCompose(args, { cwd, stdio: "inherit" });
+}
+exports.showLogs = showLogs;
+/**
+ * Check if Docker is running
+ */
+function isDockerRunning() {
+    try {
+        (0, child_process_1.execSync)("docker info", { stdio: ["pipe", "pipe", "pipe"] });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Run docker-compose command synchronously
+ */
+function runDockerCompose(args, options) {
+    try {
+        // Try docker compose (v2) first
+        (0, child_process_1.execSync)(`docker compose ${args.join(" ")}`, {
+            cwd: options.cwd,
+            env: options.env || process.env,
+            stdio: "inherit",
+        });
+    }
+    catch {
+        // Fall back to docker-compose (v1)
+        try {
+            (0, child_process_1.execSync)(`docker-compose ${args.join(" ")}`, {
+                cwd: options.cwd,
+                env: options.env || process.env,
+                stdio: "inherit",
+            });
+        }
+        catch (error) {
+            console.log(chalk_1.default.red("Error running docker-compose"));
+            throw error;
+        }
+    }
+}
+/**
+ * Spawn docker-compose command (for interactive/streaming)
+ */
+function spawnDockerCompose(args, options) {
+    // Try docker compose (v2) first
+    const proc = (0, child_process_1.spawn)("docker", ["compose", ...args], {
+        ...options,
+        shell: true,
+    });
+    proc.on("error", () => {
+        // Fall back to docker-compose (v1)
+        (0, child_process_1.spawn)("docker-compose", args, {
+            ...options,
+            shell: true,
+        });
+    });
+}
+/**
+ * Print development info
+ */
+function printDevInfo(options) {
+    console.log(chalk_1.default.bold("Development Environment:"));
+    console.log(`  🌐 App:      http://localhost:${options.port || 3000}`);
+    console.log(`  🔍 Debug:    localhost:${options.debugPort}`);
+    console.log(`  📁 Service:  ${options.service}`);
+    console.log();
+    console.log(chalk_1.default.bold("Available Commands:"));
+    console.log(`  ${chalk_1.default.gray("expressots container-dev status")}   Show container status`);
+    console.log(`  ${chalk_1.default.gray("expressots container-dev logs")}     View logs`);
+    console.log(`  ${chalk_1.default.gray("expressots container-dev shell")}    Open shell in container`);
+    console.log(`  ${chalk_1.default.gray("expressots container-dev stop")}     Stop containers`);
+    console.log();
+    if (options.watch) {
+        console.log(chalk_1.default.green("🔄 Hot reload is enabled - edit files to see changes"));
+    }
+}

package/bin/dev/index.d.ts

@@ -0,0 +1 @@
+export { devContainerCommand } from "./cli";

package/bin/dev/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.devContainerCommand = void 0;
+var cli_1 = require("./cli");
+Object.defineProperty(exports, "devContainerCommand", { enumerable: true, get: function () { return cli_1.devContainerCommand; } });

package/bin/generate/cli.js

@@ -20,6 +20,17 @@ const coerceSchematicAliases = (arg) => {
             return "module";
         case "mi":
             return "middleware";
+        // NEW v4.0 schematics
+        case "i":
+            return "interceptor";
+        case "ev":
+            return "event";
+        case "h":
+            return "handler";
+        case "gu":
+            return "guard";
+        case "cfg":
+            return "config";
         default:
             return arg;
     }
@@ -40,6 +51,12 @@ const generateProject = () => {
                     "entity",
                     "module",
                     "middleware",
+                    // NEW v4.0 schematics
+                    "interceptor",
+                    "event",
+                    "handler",
+                    "guard",
+                    "config",
                 ],
                 describe: "The schematic to generate",
                 type: "string",
@@ -56,10 +73,20 @@ const generateProject = () => {
                 type: "string",
                 alias: "m",
             });
+            // NEW: Options for v4.0 schematics
+            yargs.option("event", {
+                describe: "Event class name for handler generation",
+                type: "string",
+            });
+            yargs.option("priority", {
+                describe: "Priority for interceptors/handlers (lower = earlier execution)",
+                type: "number",
+                default: 10,
+            });
             return yargs;
         },
-        handler: async ({ schematic, path, method }) => {
-            await (0, form_1.createTemplate)({ schematic, path, method });
+        handler: async ({ schematic, path, method, event, priority }) => {
+            await (0, form_1.createTemplate)({ schematic, path, method, event, priority });
         },
     };
 };

package/bin/generate/form.d.ts

@@ -3,11 +3,15 @@
  * @param schematic
  * @param path
  * @param method
+ * @param event - Event class name (for handler generation)
+ * @param priority - Priority for interceptors/handlers
  */
 type CreateTemplateProps = {
     schematic: string;
     path: string;
     method: string;
+    event?: string;
+    priority?: number;
 };
 /**
  * Create a template based on the schematic
@@ -16,5 +20,5 @@ type CreateTemplateProps = {
  * @param method - the http method
  * @returns the file created
  */
-export declare const createTemplate: ({ schematic, path: target, method, }: CreateTemplateProps) => Promise<string>;
+export declare const createTemplate: ({ schematic, path: target, method, event, priority, }: CreateTemplateProps) => Promise<string>;
 export {};

package/bin/generate/form.js

@@ -15,15 +15,15 @@ const opinionated_cmd_1 = require("./utils/opinionated-cmd");
  * @param method - the http method
  * @returns the file created
  */
-const createTemplate = async ({ schematic, path: target, method, }) => {
+const createTemplate = async ({ schematic, path: target, method, event, priority = 10, }) => {
     const config = await compiler_1.default.loadConfig();
     const pathStyle = (0, command_utils_1.checkPathStyle)(target);
     let returnFile = "";
     if (config.opinionated) {
-        returnFile = await (0, opinionated_cmd_1.opinionatedProcess)(schematic, target, method, config, pathStyle);
+        returnFile = await (0, opinionated_cmd_1.opinionatedProcess)(schematic, target, method, config, pathStyle, { event, priority });
     }
     else {
-        returnFile = await (0, nonopininated_cmd_1.nonOpinionatedProcess)(schematic, target, method, config);
+        returnFile = await (0, nonopininated_cmd_1.nonOpinionatedProcess)(schematic, target, method, config, { event, priority });
     }
     return returnFile;
 };

package/bin/generate/templates/nonopinionated/config.tpl

@@ -0,0 +1,12 @@
+import { defineConfig, Env, loadEnvSync } from "@expressots/core";
+
+loadEnvSync({ files: { development: ".env.local", production: ".env.prod" } });
+
+export const {{moduleName}}Config = defineConfig({
+    enabled: Env.boolean("{{envPrefix}}_ENABLED", { default: true }),
+    // Add more config options as needed
+});
+
+export const config = {{moduleName}}Config.values;
+export type {{className}}Config = typeof config;
+

package/bin/generate/templates/nonopinionated/event.tpl

@@ -0,0 +1,10 @@
+/**
+ * {{className}} Event
+ */
+export class {{className}}Event {
+    constructor(
+        public readonly data: Record<string, unknown>,
+        public readonly timestamp: Date = new Date(),
+    ) {}
+}
+