feat: rewrite to use config store to no be reliant on program for options

Author: Swiftwork

packages/cli/commands/apps.ts

@@ -1,12 +1,13 @@
 import chalk from "chalk";
-import { Command, program } from "commander";
+import { Command } from "commander";
 import ora from "ora";
 
 import { listApps } from "../services/bootstrap.js";
-import { handleError } from "../utils/error.js";
+import { configStore } from "../stores/config.js";
+import { handleError } from "../utils/errors.js";
 
 export const listAppsAction = async () => {
-  const { baseUrl } = program.opts();
+  const baseUrl = configStore.getConfig("baseUrl");
   const spinner = ora(`Loading apps from ${chalk.cyan(baseUrl)}...`).start();
   try {
     const apps = await listApps();

packages/cli/commands/auth.ts

@@ -1,12 +1,14 @@
 import chalk from "chalk";
-import { Command, program } from "commander";
+import { Command } from "commander";
 import ora from "ora";
 
-import { authenticateUser, setToken } from "../utils/auth.js";
-import { handleError } from "../utils/error.js";
+import { authStore } from "../stores/auth.js";
+import { configStore } from "../stores/config.js";
+import { authenticateUser } from "../utils/auth.js";
+import { handleError } from "../utils/errors.js";
 
 export const loginAction = async () => {
-  const { baseUrl } = program.opts();
+  const baseUrl = configStore.getConfig("baseUrl");
   const spinner = ora(`Logging in to ${chalk.cyan(baseUrl)}...`).start();
   try {
     await authenticateUser(baseUrl);
@@ -18,10 +20,10 @@ export const loginAction = async () => {
 };
 
 export const logoutAction = async () => {
-  const { baseUrl } = program.opts();
+  const baseUrl = configStore.getConfig("baseUrl");
   const spinner = ora("Logging out...").start();
   try {
-    await setToken(baseUrl, undefined);
+    await authStore.setToken(baseUrl, undefined);
     spinner.succeed("Logged out successfully! 👋");
   } catch (error) {
     spinner.fail("Logout failed");

packages/cli/commands/features.ts

@@ -1,36 +1,35 @@
 import { input } from "@inquirer/prompts";
 import chalk from "chalk";
-import { Command, program } from "commander";
+import { Command } from "commander";
 import { mkdir, writeFile } from "node:fs/promises";
 import { dirname, isAbsolute, join } from "node:path";
 import ora, { Ora } from "ora";
 
 import { createFeature, listFeatures } from "../services/features.js";
-import { getConfig, getProjectPath } from "../utils/config.js";
-import { handleError } from "../utils/error.js";
+import { configStore } from "../stores/config.js";
+import { handleError, MissingAppIdError } from "../utils/errors.js";
 import { genDTS, genFeatureKey, KeyFormatPatterns } from "../utils/gen.js";
-import { options } from "../utils/options.js";
-
-type AppIdArgs = {
-  appId: string;
-};
-
-type CreateFeatureArgs = AppIdArgs & {
+import {
+  appIdOption,
+  featureKeyOption,
+  featureNameArgument,
+  typesOutOption,
+} from "../utils/options.js";
+
+type CreateFeatureArgs = {
   key?: string;
 };
 
-type GenerateTypesArgs = AppIdArgs & {
-  out: string;
-};
-
 export const createFeatureAction = async (
   name: string | undefined,
-  { appId, key }: CreateFeatureArgs,
+  { key }: CreateFeatureArgs,
 ) => {
-  const { baseUrl } = program.opts();
+  const { baseUrl, appId } = configStore.getConfig();
   let spinner: Ora | undefined;
   let existingKeys: string[] = [];
+
   try {
+    if (!appId) throw new MissingAppIdError();
     spinner = ora(
       `Loading features of app ${chalk.cyan(appId)} at ${chalk.cyan(baseUrl)}...`,
     ).start();
@@ -42,6 +41,7 @@ export const createFeatureAction = async (
   } catch (error) {
     spinner?.fail("Loading features failed");
     void handleError(error, "Features Create");
+    return;
   }
 
   try {
@@ -53,7 +53,7 @@ export const createFeatureAction = async (
     }
 
     if (!key) {
-      const keyFormat = getConfig("keyFormat") ?? "custom";
+      const keyFormat = configStore.getConfig("keyFormat") ?? "custom";
       key = await input({
         message: "New feature key:",
         default: genFeatureKey(name, keyFormat, existingKeys),
@@ -72,31 +72,32 @@ export const createFeatureAction = async (
   }
 };
 
-export const listFeaturesAction = async ({ appId }: AppIdArgs) => {
-  const { baseUrl } = program.opts();
-  const spinner = ora(
-    `Loading features of app ${chalk.cyan(appId)} at ${chalk.cyan(baseUrl)}...`,
-  ).start();
+export const listFeaturesAction = async () => {
+  const { baseUrl, appId } = configStore.getConfig();
+  let spinner: Ora | undefined;
+
   try {
+    if (!appId) throw new MissingAppIdError();
+    spinner = ora(
+      `Loading features of app ${chalk.cyan(appId)} at ${chalk.cyan(baseUrl)}...`,
+    ).start();
     const features = await listFeatures(appId);
     spinner.succeed(
       `Loaded features of app ${chalk.cyan(appId)} at ${chalk.cyan(baseUrl)}`,
     );
     console.table(features);
   } catch (error) {
-    spinner.fail("Loading features failed");
+    spinner?.fail("Loading features failed");
     void handleError(error, "Features List");
   }
 };
 
-export const generateTypesAction = async ({
-  appId,
-  out,
-}: GenerateTypesArgs) => {
-  const { baseUrl } = program.opts();
+export const generateTypesAction = async () => {
+  const { baseUrl, appId, typesPath } = configStore.getConfig();
   let spinner: Ora | undefined;
   let featureKeys: string[] = [];
   try {
+    if (!appId) throw new MissingAppIdError();
     spinner = ora(
       `Loading features of app ${chalk.cyan(appId)} at ${chalk.cyan(baseUrl)}...`,
     ).start();
@@ -107,12 +108,15 @@ export const generateTypesAction = async ({
   } catch (error) {
     spinner?.fail("Loading features failed");
     void handleError(error, "Features Types");
+    return;
   }
 
   try {
     spinner = ora("Generating feature types...").start();
     const types = genDTS(featureKeys);
-    const outPath = isAbsolute(out) ? out : join(getProjectPath(), out);
+    const outPath = isAbsolute(typesPath)
+      ? typesPath
+      : join(configStore.getProjectPath(), typesPath);
     await mkdir(dirname(outPath), { recursive: true });
     await writeFile(outPath, types);
     spinner.succeed("Generated feature types successfully");
@@ -131,39 +135,29 @@ export function registerFeatureCommands(cli: Command) {
   featuresCommand
     .command("create")
     .description("Create a new feature")
-    .requiredOption(
-      options.appId.flags,
-      options.appId.description,
-      getConfig(options.appId.configKey),
-    )
-    .option(options.featureKey.flags, options.featureKey.description)
-    .argument(options.featureName.flags, options.featureName.description)
+    .addOption(appIdOption)
+    .addOption(featureKeyOption)
+    .addArgument(featureNameArgument)
     .action(createFeatureAction);
 
   featuresCommand
     .command("list")
     .description("List all features")
-    .requiredOption(
-      options.appId.flags,
-      options.appId.description,
-      getConfig(options.appId.configKey),
-    )
+    .addOption(appIdOption)
     .action(listFeaturesAction);
 
   featuresCommand
     .command("types")
     .description("Generate feature types")
-    .requiredOption(
-      options.appId.flags,
-      options.appId.description,
-      getConfig(options.appId.configKey),
-    )
-    .requiredOption(
-      options.typesOut.flags,
-      options.typesOut.description,
-      getConfig(options.typesOut.configKey) ?? options.typesOut.fallback,
-    )
+    .addOption(appIdOption)
+    .addOption(typesOutOption)
     .action(generateTypesAction);
 
+  // Update the config with the cli override values
+  featuresCommand.hook("preAction", (command) => {
+    const { appId, out } = command.opts();
+    configStore.setConfig({ appId, typesPath: out });
+  });
+
   cli.addCommand(featuresCommand);
 }

packages/cli/commands/init.ts

@@ -1,34 +1,34 @@
 import { input, select } from "@inquirer/prompts";
 import chalk from "chalk";
-import { Command, program } from "commander";
+import { Command } from "commander";
 import { relative } from "node:path";
 import ora, { Ora } from "ora";
 
 import { App, listApps } from "../services/bootstrap.js";
-import { createConfigFile, getConfigPath } from "../utils/config.js";
+import { configStore } from "../stores/config.js";
 import { chalkBrand, DEFAULT_TYPES_PATH } from "../utils/constants.js";
-import { handleError } from "../utils/error.js";
-import { options } from "../utils/options.js";
+import { handleError } from "../utils/errors.js";
+import { initOverrideOption } from "../utils/options.js";
 
 type InitArgs = {
   force?: boolean;
 };
 
-export const initAction = async (args: InitArgs) => {
+export const initAction = async (args: InitArgs = {}) => {
   let spinner: Ora | undefined;
   let apps: App[] = [];
 
   try {
-    // Check if already initialized
-    const configPath = getConfigPath();
+    // Check if config already exists
+    const configPath = configStore.getConfigPath();
     if (configPath && !args.force) {
       throw new Error(
         "Bucket is already initialized. Use --force to overwrite.",
       );
     }
 
     console.log(chalkBrand("\nWelcome to Bucket! 🪣\n"));
-    const { baseUrl } = program.opts();
+    const baseUrl = configStore.getConfig("baseUrl");
 
     // Load apps
     spinner = ora(`Loading apps from ${chalk.cyan(baseUrl)}...`).start();
@@ -37,15 +37,17 @@ export const initAction = async (args: InitArgs) => {
   } catch (error) {
     spinner?.fail("Loading apps failed");
     void handleError(error, "Initialization");
+    return;
   }
 
   try {
-    const { baseUrl, apiUrl } = program.opts();
     let appId: string | undefined;
     const nonDemoApps = apps.filter((app) => !app.demo);
 
     // If there is only one non-demo app, select it automatically
-    if (nonDemoApps.length === 1) {
+    if (apps.length === 0) {
+      throw new Error("You don't have any apps yet. Please create one.");
+    } else if (nonDemoApps.length === 1) {
       appId = nonDemoApps[0].id;
       console.log(
         chalk.gray(
@@ -72,20 +74,18 @@ export const initAction = async (args: InitArgs) => {
       default: DEFAULT_TYPES_PATH,
     });
 
+    // Update config
+    configStore.setConfig({
+      appId,
+      keyFormat,
+      typesPath,
+    });
+
     // Create config file
     spinner = ora("Creating configuration...").start();
-    await createConfigFile(
-      {
-        baseUrl,
-        apiUrl,
-        appId,
-        typesPath,
-        keyFormat,
-      },
-      args.force,
-    );
+    await configStore.saveConfigFile(args.force);
     spinner.succeed(
-      `Configuration created at ${chalk.cyan(relative(process.cwd(), getConfigPath()!))}`,
+      `Configuration created at ${chalk.cyan(relative(process.cwd(), configStore.getConfigPath()!))}`,
     );
   } catch (error) {
     spinner?.fail("Configuration creation failed");
@@ -97,6 +97,6 @@ export function registerInitCommand(cli: Command) {
   cli
     .command("init")
     .description("Initialize a new Bucket configuration")
-    .option(options.initOverride.flags, options.initOverride.description)
+    .addOption(initOverrideOption)
     .action(initAction);
 }