cli.ts

import envConfig, {
  buildServeCommandConfig,
  parseDataDirFromCli,
  type ServeCommandCliArgs,
} from "@/config";

import { join, resolve } from "node:path";
import { fileURLToPath } from "node:url";

import type { ArgumentsCamelCase, Argv } from "yargs";
import { hideBin } from "yargs/helpers";
import yargs from "yargs/yargs";

import { buildLabelSetId, buildLabelSetVersion } from "@ensnode/ensnode-sdk";
import { PortNumberSchema } from "@ensnode/ensnode-sdk/internal";

import { type ConvertSqlCommandCliArgs, convertCommand } from "@/commands/convert-command-sql";
import { type ConvertCsvCommandCliArgs, convertCsvCommand } from "@/commands/convert-csv-command";
import { entrypointCommand } from "@/commands/entrypoint-command";
import {
  type IngestProtobufCommandCliArgs,
  ingestProtobufCommand,
} from "@/commands/ingest-protobuf-command";
import { type PurgeCommandCliArgs, purgeCommand } from "@/commands/purge-command";
import { serverCommand } from "@/commands/server-command";
import { type ValidateCommandCliArgs, validateCommand } from "@/commands/validate-command";

export interface CLIOptions {
  exitProcess?: boolean;
}

/**
 * yargs-parsed argument shape for the `entrypoint` command.
 *
 * `label-set-id` and `label-set-version` are coerced to their branded types via
 * `buildLabelSetId` / `buildLabelSetVersion`, so the CLI layer works with primitive types
 * and hands branded values to {@link entrypointCommand}.
 */
interface EntrypointCommandCliArgs {
  port: number;
  "data-dir": string;
  "db-schema-version": number;
  "label-set-id": string;
  "label-set-version": number;
  "download-temp-dir"?: string;
}

export function createCLI(options: CLIOptions = {}) {
  const { exitProcess = true } = options;

  return (
    yargs()
      .scriptName("ensrainbow")
      .exitProcess(exitProcess)
      // .command(
      //   "ingest",
      //   "Ingest labels from SQL dump into LevelDB",
      //   (yargs: Argv) => {
      //     return yargs
      //       .option("input-file", {
      //         type: "string",
      //         description: "Path to the gzipped SQL dump file",
      //         default: join(process.cwd(), "ens_names.sql.gz"),
      //       })
      //       .option("data-dir", {
      //         type: "string",
      //         description: "Directory to store LevelDB data",
      //         default: getDefaultDataDir(),
      //       });
      //   },
      //   async (argv: ArgumentsCamelCase<IngestArgs>) => {
      //     await ingestCommand({
      //       inputFile: argv["input-file"],
      //       dataDir: argv["data-dir"],
      //     });
      //   },
      // )
      .command(
        "ingest-ensrainbow",
        "Ingest labels from protobuf file into LevelDB",
        (yargs: Argv) => {
          return yargs
            .option("input-file", {
              type: "string",
              description: "Path to the protobuf file",
              default: join(process.cwd(), "rainbow-records.pb"),
            })
            .option("data-dir", {
              type: "string",
              description: "Directory to store LevelDB data",
              default: envConfig.dataDir,
            });
        },
        async (argv: ArgumentsCamelCase<IngestProtobufCommandCliArgs>) => {
          const dataDir = parseDataDirFromCli(argv["data-dir"]);
          await ingestProtobufCommand({
            inputFile: argv["input-file"],
            dataDir,
          });
        },
      )
      .command(
        "serve",
        "Start the ENS Rainbow API server",
        (yargs: Argv) => {
          return yargs
            .option("port", {
              type: "number",
              description: "Port to listen on (overrides PORT env var if both are set)",
              default: envConfig.port,
              coerce: (port: number) => {
                const result = PortNumberSchema.safeParse(port);
                if (!result.success) {
                  const firstError = result.error.issues[0];
                  throw new Error(`Invalid port: ${firstError?.message ?? "invalid port number"}`);
                }
                return result.data;
              },
            })
            .option("data-dir", {
              type: "string",
              description: "Directory containing LevelDB data",
              default: envConfig.dataDir,
            });
        },
        async (argv: ArgumentsCamelCase<ServeCommandCliArgs>) => {
          const serveCommandConfig = buildServeCommandConfig(argv);
          await serverCommand(serveCommandConfig);
        },
      )
      .command(
        "entrypoint",
        "Start the ENS Rainbow API server immediately and bootstrap the database in the background",
        (yargs: Argv) => {
          return yargs
            .option("port", {
              type: "number",
              description: "Port to listen on (overrides PORT env var if both are set)",
              default: envConfig.port,
              coerce: (port: number) => {
                const result = PortNumberSchema.safeParse(port);
                if (!result.success) {
                  const firstError = result.error.issues[0];
                  throw new Error(`Invalid port: ${firstError?.message ?? "invalid port number"}`);
                }
                return result.data;
              },
            })
            .option("data-dir", {
              type: "string",
              description: "Directory containing LevelDB data",
              default: envConfig.dataDir,
            })
            .option("db-schema-version", {
              type: "number",
              description:
                "Expected database schema version (falls back to DB_SCHEMA_VERSION env var)",
              default: envConfig.dbSchemaVersion,
            })
            .option("label-set-id", {
              type: "string",
              description: "Label set id to download (falls back to LABEL_SET_ID env var)",
              default: process.env.LABEL_SET_ID,
              demandOption: !process.env.LABEL_SET_ID,
            })
            .coerce("label-set-id", buildLabelSetId)
            .option("label-set-version", {
              type: "number",
              description:
                "Label set version to download (falls back to LABEL_SET_VERSION env var)",
              default: process.env.LABEL_SET_VERSION,
              demandOption: !process.env.LABEL_SET_VERSION,
            })
            .coerce("label-set-version", buildLabelSetVersion)
            .option("download-temp-dir", {
              type: "string",
              description:
                "Temporary directory used to stage downloaded archives before extraction " +
                "(defaults to <data-dir>/.download-temp)",
              default: process.env.DOWNLOAD_TEMP_DIR,
            });
        },
        async (argv: ArgumentsCamelCase<EntrypointCommandCliArgs>) => {
          const dataDir = parseDataDirFromCli(argv["data-dir"]);
          await entrypointCommand({
            port: argv.port,
            dataDir,
            dbSchemaVersion: argv["db-schema-version"],
            labelSetId: argv["label-set-id"],
            labelSetVersion: argv["label-set-version"],
            downloadTempDir: argv["download-temp-dir"],
            labelsetServerUrl: process.env.ENSRAINBOW_LABELSET_SERVER_URL,
          });
        },
      )
      .command(
        "validate",
        "Validate the integrity of the LevelDB database",
        (yargs: Argv) => {
          return yargs
            .option("data-dir", {
              type: "string",
              description: "Directory containing LevelDB data",
              default: envConfig.dataDir,
            })
            .option("lite", {
              type: "boolean",
              description:
                "Perform a faster, less thorough validation by skipping hash verification and record count validation",
              default: false,
            });
        },
        async (argv: ArgumentsCamelCase<ValidateCommandCliArgs>) => {
          const dataDir = parseDataDirFromCli(argv["data-dir"]);
          await validateCommand({
            dataDir,
            lite: argv.lite,
          });
        },
      )
      .command(
        "purge",
        "Completely wipe all files from the specified data directory",
        (yargs: Argv) => {
          return yargs.option("data-dir", {
            type: "string",
            description: "Directory containing LevelDB data",
            default: envConfig.dataDir,
          });
        },
        async (argv: ArgumentsCamelCase<PurgeCommandCliArgs>) => {
          const dataDir = parseDataDirFromCli(argv["data-dir"]);
          await purgeCommand({
            dataDir,
          });
        },
      )
      .command(
        "convert",
        "Convert rainbow tables from CSV format to ensrainbow format",
        (yargs: Argv) => {
          return yargs
            .option("input-file", {
              type: "string",
              description: "Path to the CSV input file",
              demandOption: true,
            })
            .option("label-set-id", {
              type: "string",
              description: "Label set id for the generated ensrainbow file",
              demandOption: true,
            })
            .coerce("label-set-id", buildLabelSetId)
            .option("output-file", {
              type: "string",
              description:
                "Path to where the resulting ensrainbow file will be output (if not provided, will be generated automatically)",
            })
            .option("progress-interval", {
              type: "number",
              description: "Number of records to process before logging progress",
              default: 50000,
            })
            .option("existing-db-path", {
              type: "string",
              description:
                "Path to existing ENSRainbow database to filter out existing labels and determine the next label set version (if not provided, version will be 0)",
            })
            .option("silent", {
              type: "boolean",
              description: "Disable progress bar (useful for scripts)",
              default: false,
            });
        },
        async (argv: ArgumentsCamelCase<ConvertCsvCommandCliArgs>) => {
          await convertCsvCommand({
            inputFile: argv["input-file"],
            outputFile: argv["output-file"],
            labelSetId: argv["label-set-id"],
            progressInterval: argv["progress-interval"],
            existingDbPath: argv["existing-db-path"],
            silent: argv.silent,
          });
        },
      )
      .command(
        "convert-sql",
        "Convert rainbow tables from legacy SQL dump to ensrainbow format",
        (yargs: Argv) => {
          return yargs
            .option("input-file", {
              type: "string",
              description: "Path to the gzipped SQL dump file",
              default: join(process.cwd(), "ens_names.sql.gz"),
            })
            .option("label-set-id", {
              type: "string",
              description: "Label set id for the generated ensrainbow file",
              demandOption: true,
            })
            .coerce("label-set-id", buildLabelSetId)
            .option("output-file", {
              type: "string",
              description: "Path to where the resulting ensrainbow file will be output",
            });
        },
        async (argv: ArgumentsCamelCase<ConvertSqlCommandCliArgs>) => {
          const outputFile =
            argv["output-file"] ?? join(process.cwd(), `${argv["label-set-id"]}_0.ensrainbow`);
          await convertCommand({
            inputFile: argv["input-file"],
            outputFile,
            labelSetId: argv["label-set-id"],
            labelSetVersion: 0,
          });
        },
      )
      .demandCommand(1, "You must specify a command")
      .fail((msg, err, yargs) => {
        if (process.env.VITEST) {
          // the test functions expect the default behavior of cli.parse to throw
          if (err) throw err;
          if (msg) throw new Error(msg);
        } else {
          // but we want to override yargs' default printing to stdout/stderr with console printing,
          // such that it can be silenced with vitest --silent
          yargs.showHelp();

          if (msg) console.error(msg);
          if (err) console.error(err);
        }
      })
      .strict()
      .help()
  );
}

// Only execute if this is the main module
const isMainModule = resolve(process.argv[1]) === fileURLToPath(import.meta.url);
if (isMainModule) {
  createCLI().parse(hideBin(process.argv));
}