@jango-blockchained/hoox-cli 0.5.1 → 0.5.6

package/src/commands/dashboard/dashboard-command.ts

@@ -1,128 +0,0 @@
-import type { Command } from "commander";
-import { ConfigService } from "../../services/config/index.js";
-import { CLIError, ExitCode } from "../../utils/errors.js";
-import {
-  formatSuccess,
-  formatError,
-  formatTable,
-} from "../../utils/formatters.js";
-import type { FormatOptions } from "../../utils/formatters.js";
-import { theme, icons } from "../../utils/theme.js";
-import * as jsonc from "jsonc-parser";
-import { readFileSync, writeFileSync, existsSync } from "node:fs";
-import { resolve } from "node:path";
-
-interface ServiceUrl {
-  worker: string;
-  url: string;
-}
-
-function getServiceUrls(config: ConfigService): ServiceUrl[] {
-  const global = config.getGlobal();
-  const prefix = global.subdomain_prefix ?? "hoox";
-  const workers = config.listEnabledWorkers();
-
-  return workers.map((name) => ({
-    worker: name,
-    url: `https://${name}.${prefix}.workers.dev`,
-  }));
-}
-
-function updateWranglerVars(
-  filePath: string,
-  urls: ServiceUrl[],
-  dryRun: boolean,
-  opts: FormatOptions
-): void {
-  if (!existsSync(filePath)) {
-    throw new CLIError(
-      `Dashboard wrangler.jsonc not found at ${filePath}`,
-      ExitCode.ERROR
-    );
-  }
-
-  const content = readFileSync(filePath, "utf-8");
-  const errors: jsonc.ParseError[] = [];
-  const parsed = jsonc.parse(content, errors) as Record<string, unknown>;
-
-  if (errors.length > 0) {
-    throw new CLIError(`Invalid JSONC in ${filePath}`, ExitCode.ERROR);
-  }
-
-  const vars = (parsed.vars as Record<string, string>) ?? {};
-  const changes: { key: string; oldValue: string; newValue: string }[] = [];
-
-  for (const { worker, url } of urls) {
-    const key = `${worker.toUpperCase().replace(/-/g, "_")}_URL`;
-    const oldValue = vars[key] ?? "(not set)";
-    changes.push({ key, oldValue, newValue: url });
-    vars[key] = url;
-  }
-
-  if (changes.length === 0) {
-    formatSuccess("No service URLs to update.", opts);
-    return;
-  }
-
-  if (!opts.quiet) {
-    const rows = changes.map((c) => ({
-      Key: c.key,
-      Old: c.oldValue,
-      New: theme.success(c.newValue),
-    }));
-    console.log(theme.heading("\nService URL changes:"));
-    formatTable(rows, opts);
-  }
-
-  if (dryRun) {
-    formatSuccess("Dry run — no changes written.", opts);
-    return;
-  }
-
-  const fresh = readFileSync(filePath, "utf-8");
-  const edits = jsonc.modify(fresh, ["vars"], vars, {
-    formattingOptions: { tabSize: 2, insertSpaces: true },
-  });
-  const updated = jsonc.applyEdits(fresh, edits);
-  writeFileSync(filePath, updated, "utf-8");
-
-  formatSuccess(
-    `Updated ${changes.length} service URL(s) in dashboard wrangler.jsonc`,
-    opts
-  );
-}
-
-export function registerDashboardCommand(program: Command): void {
-  const dashboardCmd = program
-    .command("dashboard")
-    .description("Dashboard-specific operations");
-
-  dashboardCmd
-    .command("update-urls")
-    .description("Update dashboard wrangler.jsonc with current service URLs")
-    .option("--dry-run", "Show changes without applying")
-    .action(async (options: { dryRun?: boolean }) => {
-      const opts: FormatOptions = {
-        json: program.opts<{ json?: boolean }>().json,
-        quiet: program.opts<{ quiet?: boolean }>().quiet,
-      };
-
-      try {
-        const config = new ConfigService();
-        await config.load();
-
-        const urls = getServiceUrls(config);
-        const dashboardPath = resolve(
-          process.cwd(),
-          "pages",
-          "dashboard",
-          "wrangler.jsonc"
-        );
-
-        updateWranglerVars(dashboardPath, urls, options.dryRun === true, opts);
-      } catch (err) {
-        formatError(err instanceof Error ? err : String(err), opts);
-        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
-      }
-    });
-}

package/src/commands/dashboard/index.ts

@@ -1 +0,0 @@
-export { registerDashboardCommand } from "./dashboard-command.js";

package/src/commands/db/db-command.test.ts

@@ -1,21 +0,0 @@
-import { describe, expect, it } from "bun:test";
-import { DbService } from "../../services/db/index.js";
-
-describe("db command", () => {
-  describe("DbService integration", () => {
-    it("resolves database name from explicit arg", async () => {
-      const svc = new DbService();
-      const name = await svc.resolveDbName("my-test-db");
-      expect(name).toBe("my-test-db");
-    });
-
-    it("parses table names from wrangler output", () => {
-      const output = JSON.stringify([
-        { results: [{ name: "trades" }, { name: "signals" }] },
-      ]);
-      const tables = DbService.parseTableNames(output);
-      expect(tables).toContain("trades");
-      expect(tables).toContain("signals");
-    });
-  });
-});

package/src/commands/db/db-command.ts

@@ -1,312 +0,0 @@
-/**
- * `hoox db` command group — database management.
- *
- * Subcommands:
- *   apply [--remote] [--file <path>]   — Apply schema.sql to D1
- *   migrate [--remote]                  — Run tracking migrations
- *   list [--remote]                     — List database tables
- *   query <sql> [--remote]              — Execute a SQL query
- *   export [--output <path>]            — Export database
- *   reset [--confirm]                   — Drop and recreate (DESTRUCTIVE)
- */
-
-import { Command } from "commander";
-import * as p from "@clack/prompts";
-import { DbService } from "../../services/db/index.js";
-import {
-  formatSuccess,
-  formatError,
-  formatTable,
-  formatJson,
-  getFormatOptions,
-} from "../../utils/formatters.js";
-import { CLIError, ExitCode } from "../../utils/errors.js";
-import type { FormatOptions } from "../../utils/formatters.js";
-
-/**
- * Resolve database name from config or --database flag.
- */
-async function resolveDb(cmd: Command, svc: DbService): Promise<string> {
-  const opts = cmd.optsWithGlobals<{ database?: string }>();
-  return await svc.resolveDbName(opts.database);
-}
-
-// ---------------------------------------------------------------------------
-// db apply
-// ---------------------------------------------------------------------------
-
-async function handleApply(
-  opts: FormatOptions,
-  dbName: string,
-  remote: boolean,
-  file?: string
-): Promise<void> {
-  const svc = new DbService();
-  const output = await svc.apply(dbName, remote, file);
-  formatSuccess(
-    `Schema applied to ${dbName}${remote ? " (remote)" : " (local)"}`,
-    opts
-  );
-  if (!opts.quiet && output) {
-    process.stdout.write(`${output}\n`);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// db migrate
-// ---------------------------------------------------------------------------
-
-async function handleMigrate(
-  opts: FormatOptions,
-  dbName: string,
-  remote: boolean
-): Promise<void> {
-  const svc = new DbService();
-  const output = await svc.migrate(dbName, remote);
-  formatSuccess(
-    `Migrations applied to ${dbName}${remote ? " (remote)" : " (local)"}`,
-    opts
-  );
-  if (!opts.quiet && output) {
-    process.stdout.write(`${output}\n`);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// db list
-// ---------------------------------------------------------------------------
-
-async function handleList(
-  opts: FormatOptions,
-  dbName: string,
-  remote: boolean
-): Promise<void> {
-  const svc = new DbService();
-  const tables = await svc.listTables(dbName, remote);
-
-  if (opts.json) {
-    formatJson(tables, opts);
-  } else if (!opts.quiet) {
-    if (tables.length === 0) {
-      process.stdout.write("No tables found.\n");
-      return;
-    }
-    const rows = tables.map((t) => ({ Table: t }));
-    formatTable(rows, opts);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// db query
-// ---------------------------------------------------------------------------
-
-async function handleQuery(
-  opts: FormatOptions,
-  dbName: string,
-  sql: string,
-  remote: boolean
-): Promise<void> {
-  const svc = new DbService();
-  const output = await svc.query(dbName, sql, remote);
-
-  if (opts.json) {
-    // Already JSON from wrangler — try to parse for cleaner output
-    try {
-      const parsed = JSON.parse(output);
-      formatJson(parsed, opts);
-    } catch {
-      process.stdout.write(`${output}\n`);
-    }
-  } else {
-    process.stdout.write(`${output}\n`);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// db export
-// ---------------------------------------------------------------------------
-
-async function handleExport(
-  opts: FormatOptions,
-  dbName: string,
-  outputPath?: string
-): Promise<void> {
-  const svc = new DbService();
-  const path = await svc.export(dbName, outputPath);
-  formatSuccess(`Database exported to ${path}`, opts);
-}
-
-// ---------------------------------------------------------------------------
-// db reset
-// ---------------------------------------------------------------------------
-
-async function handleReset(
-  opts: FormatOptions,
-  dbName: string,
-  confirmed: boolean
-): Promise<void> {
-  if (!confirmed) {
-    const answer = await p.confirm({
-      message: `WARNING: This will DELETE and recreate the "${dbName}" database. ALL DATA WILL BE LOST. Continue?`,
-      initialValue: false,
-    });
-    if (p.isCancel(answer) || !answer) {
-      p.cancel("Reset cancelled.");
-      return;
-    }
-  }
-
-  const svc = new DbService();
-  const output = await svc.reset(dbName);
-  formatSuccess(`Database "${dbName}" has been recreated`, opts);
-  if (!opts.quiet && output) {
-    process.stdout.write(`${output}\n`);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Registration
-// ---------------------------------------------------------------------------
-
-export function registerDbCommand(program: Command): void {
-  const dbCmd = program
-    .command("db")
-    .summary("Manage D1 databases")
-    .description(
-      `Manage Cloudflare D1 databases — schema, queries, migrations, backup.
-
-SUBCOMMANDS:
-  apply               Apply schema.sql to D1
-  migrate             Run tracking migrations
-  list                List database tables
-  query <sql>         Execute a SQL query
-  export              Export database to .sql file
-  reset               Drop and recreate database (DESTRUCTIVE)
-
-OPTIONS:
-  --database <name>   Database name (auto-detected from config if omitted)
-  --remote            Operate on production (remote) database
-
-EXAMPLES:
-  hoox db apply
-  hoox db apply --remote
-  hoox db migrate
-  hoox db list
-  hoox db query "SELECT * FROM trade_signals LIMIT 5"
-  hoox db export
-  hoox db reset`
-    )
-    .option("--database <name>", "Database name (auto-detected if omitted)")
-    .option("--remote", "Operate on production (remote) database");
-
-  // -- apply
-  dbCmd
-    .command("apply")
-    .description("Apply schema.sql to the database")
-    .option("--file <path>", "Path to schema.sql file")
-    .action(async (options: { file?: string }, cmd: Command) => {
-      const opts = getFormatOptions(cmd);
-      try {
-        const svc = new DbService();
-        const dbName = await resolveDb(cmd, svc);
-        const remote = Boolean(
-          cmd.optsWithGlobals<{ remote?: boolean }>().remote
-        );
-        await handleApply(opts, dbName, remote, options.file);
-      } catch (err) {
-        formatError(err instanceof Error ? err : String(err), opts);
-        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
-      }
-    });
-
-  // -- migrate
-  dbCmd
-    .command("migrate")
-    .description("Run tracking migrations")
-    .action(async (_, cmd: Command) => {
-      const opts = getFormatOptions(cmd);
-      try {
-        const svc = new DbService();
-        const dbName = await resolveDb(cmd, svc);
-        const remote = Boolean(
-          cmd.optsWithGlobals<{ remote?: boolean }>().remote
-        );
-        await handleMigrate(opts, dbName, remote);
-      } catch (err) {
-        formatError(err instanceof Error ? err : String(err), opts);
-        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
-      }
-    });
-
-  // -- list
-  dbCmd
-    .command("list")
-    .description("List database tables")
-    .action(async (_, cmd: Command) => {
-      const opts = getFormatOptions(cmd);
-      try {
-        const svc = new DbService();
-        const dbName = await resolveDb(cmd, svc);
-        const remote = Boolean(
-          cmd.optsWithGlobals<{ remote?: boolean }>().remote
-        );
-        await handleList(opts, dbName, remote);
-      } catch (err) {
-        formatError(err instanceof Error ? err : String(err), opts);
-        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
-      }
-    });
-
-  // -- query
-  dbCmd
-    .command("query <sql>")
-    .description("Execute a SQL query")
-    .action(async (sql: string, _, cmd: Command) => {
-      const opts = getFormatOptions(cmd);
-      try {
-        const svc = new DbService();
-        const dbName = await resolveDb(cmd, svc);
-        const remote = Boolean(
-          cmd.optsWithGlobals<{ remote?: boolean }>().remote
-        );
-        await handleQuery(opts, dbName, sql, remote);
-      } catch (err) {
-        formatError(err instanceof Error ? err : String(err), opts);
-        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
-      }
-    });
-
-  // -- export
-  dbCmd
-    .command("export")
-    .description("Export database to .sql file")
-    .option("--output <path>", "Output file path")
-    .action(async (options: { output?: string }, cmd: Command) => {
-      const opts = getFormatOptions(cmd);
-      try {
-        const svc = new DbService();
-        const dbName = await resolveDb(cmd, svc);
-        await handleExport(opts, dbName, options.output);
-      } catch (err) {
-        formatError(err instanceof Error ? err : String(err), opts);
-        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
-      }
-    });
-
-  // -- reset
-  dbCmd
-    .command("reset")
-    .description("Drop and recreate the database (DESTRUCTIVE)")
-    .option("--confirm", "Skip confirmation prompt")
-    .action(async (options: { confirm?: boolean }, cmd: Command) => {
-      const opts = getFormatOptions(cmd);
-      try {
-        const svc = new DbService();
-        const dbName = await resolveDb(cmd, svc);
-        await handleReset(opts, dbName, Boolean(options.confirm));
-      } catch (err) {
-        formatError(err instanceof Error ? err : String(err), opts);
-        process.exit(err instanceof CLIError ? err.code : ExitCode.ERROR);
-      }
-    });
-}

package/src/commands/db/index.ts

@@ -1 +0,0 @@
-export { registerDbCommand } from "./db-command.js";