@config-bound/cli 0.1.0

package/src/commands/export.command.ts

@@ -0,0 +1,253 @@
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { ConfigLoaderService } from '../services/config-loader.service.js';
+import { ConfigDiscoveryService } from '../services/config-discovery.service.js';
+import {
+  SchemaExportService,
+  type ExportFormat
+} from '../services/schema-export.service.js';
+import { FileWriterService } from '../services/file-writer.service.js';
+import chalk from 'chalk';
+import * as readline from 'readline';
+
+interface ExportCommandOptions {
+  config?: string;
+  format: ExportFormat;
+  output?: string;
+  includeOmitted?: boolean;
+  pretty?: boolean;
+  name?: string;
+}
+
+@Command({
+  name: 'export',
+  description: 'Export ConfigBound schema in various formats'
+})
+export class ExportCommand extends CommandRunner {
+  constructor(
+    private readonly loaderService: ConfigLoaderService,
+    private readonly discoveryService: ConfigDiscoveryService,
+    private readonly exportService: SchemaExportService,
+    private readonly writerService: FileWriterService
+  ) {
+    super();
+  }
+
+  async run(
+    _passedParams: string[],
+    options?: ExportCommandOptions
+  ): Promise<void> {
+    try {
+      let configPath: string;
+      let exportName: string | undefined;
+
+      // If no explicit --config, auto-discover
+      if (!options?.config) {
+        const discovered = await this.discoverAndSelect();
+        if (!discovered) {
+          console.log(chalk.yellow('Export cancelled.'));
+          return;
+        }
+        configPath = discovered.filePath;
+        exportName =
+          discovered.exportName === 'default'
+            ? undefined
+            : discovered.exportName;
+      } else {
+        // Explicit config path provided
+        configPath = options.config;
+        exportName = options.name;
+      }
+
+      const format = options?.format || 'json';
+      const includeOmitted = options?.includeOmitted || false;
+      const pretty = options?.pretty !== false;
+      const output = options?.output;
+
+      console.log(chalk.blue('Loading configuration...'));
+      const config = await this.loaderService.loadConfig(
+        configPath,
+        exportName
+      );
+
+      console.log(chalk.green(`Loaded config: ${chalk.bold(config.name)}`));
+
+      const exportedSchema = this.exportService.exportToString(
+        config.name,
+        config.sections,
+        config.instance,
+        {
+          format,
+          includeOmitted,
+          pretty
+        }
+      );
+
+      if (output) {
+        this.writerService.writeToFile(output, exportedSchema);
+        console.log(chalk.green(`Schema exported to: ${output}`));
+      } else {
+        console.log(chalk.blue('\nExported schema:\n'));
+        this.writerService.writeToStdout(exportedSchema);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else {
+        console.error(chalk.red(`Error: ${String(error)}`));
+      }
+      process.exit(1);
+    }
+  }
+
+  private async discoverAndSelect(): Promise<{
+    filePath: string;
+    exportName: string;
+  } | null> {
+    const startTime = Date.now();
+    console.log(chalk.blue('Searching for ConfigBound configurations...'));
+
+    const configs = await this.discoveryService.discoverConfigs(
+      process.cwd(),
+      true
+    );
+
+    const elapsed = ((Date.now() - startTime) / 1000).toFixed(2);
+    console.log(chalk.gray(`Search completed in ${elapsed}s`));
+
+    if (configs.length === 0) {
+      console.log(
+        chalk.yellow('\nNo ConfigBound configurations found in project.')
+      );
+      console.log(
+        chalk.gray(
+          'Tip: Use --config <path> to specify a config file explicitly.'
+        )
+      );
+      return null;
+    }
+
+    // Auto-select if only one config found
+    if (configs.length === 1) {
+      const selected = configs[0];
+      const exportType = selected.isDefault ? 'default' : 'named';
+      const relativePath = selected.filePath.replace(process.cwd() + '/', '');
+      console.log(
+        chalk.green(
+          `\nFound 1 configuration - auto-selected: ${chalk.bold(selected.configName || 'unnamed')} (${exportType} export: ${selected.exportName})`
+        )
+      );
+      console.log(chalk.gray(`  from ${relativePath}\n`));
+
+      return {
+        filePath: selected.filePath,
+        exportName: selected.exportName
+      };
+    }
+
+    // Multiple configs - show menu
+    console.log(chalk.green(`\nFound ${configs.length} configurations:\n`));
+
+    configs.forEach((config: (typeof configs)[0], index: number) => {
+      const exportType = config.isDefault ? '(default)' : '(named)';
+      const configNamePart = config.configName
+        ? chalk.bold(config.configName)
+        : chalk.gray('unnamed');
+      const relativePath = config.filePath.replace(process.cwd() + '/', '');
+      console.log(
+        `${chalk.cyan((index + 1).toString().padStart(2))}. ${configNamePart} ${chalk.gray(exportType + ' - ' + config.exportName)}`
+      );
+      console.log(`    ${chalk.gray(relativePath)}`);
+    });
+
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const answer = await new Promise<string>((resolve) => {
+      rl.question(
+        chalk.yellow(
+          `\nSelect configuration (1-${configs.length}) or Ctrl+C to cancel: `
+        ),
+        (answer) => {
+          rl.close();
+          resolve(answer);
+        }
+      );
+    });
+
+    const selectedIndex = parseInt(answer, 10) - 1;
+
+    if (
+      isNaN(selectedIndex) ||
+      selectedIndex < 0 ||
+      selectedIndex >= configs.length
+    ) {
+      console.log(chalk.red('Invalid selection.'));
+      return null;
+    }
+
+    const selected = configs[selectedIndex];
+    console.log();
+    return {
+      filePath: selected.filePath,
+      exportName: selected.exportName
+    };
+  }
+
+  @Option({
+    flags: '-c, --config <path>',
+    description: 'Path to config file'
+  })
+  parseConfig(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '-f, --format <format>',
+    description: 'Output format: json, yaml, env (default: json)',
+    defaultValue: 'json'
+  })
+  parseFormat(val: string): ExportFormat {
+    const validFormats: ExportFormat[] = ['json', 'yaml', 'env'];
+    if (!validFormats.includes(val as ExportFormat)) {
+      throw new Error(
+        `Invalid format: ${val}. Valid formats: ${validFormats.join(', ')}`
+      );
+    }
+    return val as ExportFormat;
+  }
+
+  @Option({
+    flags: '-o, --output <path>',
+    description: 'Output file path (default: stdout)'
+  })
+  parseOutput(val: string): string {
+    return val;
+  }
+
+  @Option({
+    flags: '--include-omitted',
+    description: 'Include elements marked with omitFromSchema: true'
+  })
+  parseIncludeOmitted(): boolean {
+    return true;
+  }
+
+  @Option({
+    flags: '--pretty [boolean]',
+    description: 'Pretty-print JSON output (default: true)',
+    defaultValue: true
+  })
+  parsePretty(val: string): boolean {
+    return val !== 'false';
+  }
+
+  @Option({
+    flags: '--name <name>',
+    description: 'Export named variable when file has multiple exports'
+  })
+  parseName(val: string): string {
+    return val;
+  }
+}

package/src/commands/list.command.ts

@@ -0,0 +1,108 @@
+import { Command, CommandRunner, Option } from 'nest-commander';
+import { ConfigDiscoveryService } from '../services/config-discovery.service.js';
+import chalk from 'chalk';
+import * as path from 'path';
+
+interface ListCommandOptions {
+  recursive?: boolean;
+}
+
+@Command({
+  name: 'list',
+  description: 'List all discovered ConfigBound configurations',
+  arguments: '[path]',
+  argsDescription: {
+    path: 'Directory to search (default: current directory)'
+  }
+})
+export class ListCommand extends CommandRunner {
+  constructor(private readonly discoveryService: ConfigDiscoveryService) {
+    super();
+  }
+
+  async run(
+    passedParams: string[],
+    options?: ListCommandOptions
+  ): Promise<void> {
+    const searchPath = passedParams[0] || process.cwd();
+    const recursive = options?.recursive !== false;
+
+    try {
+      console.log(
+        chalk.blue(`Searching for ConfigBound configurations in: ${searchPath}`)
+      );
+      console.log(chalk.gray(`Recursive: ${recursive ? 'yes' : 'no'}`));
+      console.log();
+
+      const configs = await this.discoveryService.discoverConfigs(
+        searchPath,
+        recursive
+      );
+
+      if (configs.length === 0) {
+        console.log(chalk.yellow('No ConfigBound configurations found.'));
+        return;
+      }
+
+      console.log(
+        chalk.green(
+          `Found ${configs.length} ConfigBound configuration${configs.length === 1 ? '' : 's'}:`
+        )
+      );
+      console.log();
+
+      // Group by file
+      const groupedByFile = configs.reduce(
+        (acc: Record<string, typeof configs>, config: (typeof configs)[0]) => {
+          if (!acc[config.filePath]) {
+            acc[config.filePath] = [];
+          }
+          acc[config.filePath].push(config);
+          return acc;
+        },
+        {} as Record<string, typeof configs>
+      );
+
+      for (const [filePath, fileConfigs] of Object.entries(groupedByFile)) {
+        const relativePath = path.relative(process.cwd(), filePath);
+        console.log(chalk.cyan(`📄 ${relativePath}`));
+
+        for (const config of fileConfigs as typeof configs) {
+          const exportType = config.isDefault
+            ? chalk.gray('(default)')
+            : chalk.gray('(named)');
+          const configNamePart = config.configName
+            ? chalk.magenta(` - ${config.configName}`)
+            : '';
+          const linePart = chalk.gray(`:${config.lineNumber}`);
+
+          console.log(
+            `   ${chalk.white(config.exportName)} ${exportType}${configNamePart}${linePart}`
+          );
+        }
+        console.log();
+      }
+
+      console.log(
+        chalk.gray(
+          'Tip: Use `configbound export --config <file> --name <export>` to export a specific configuration.'
+        )
+      );
+    } catch (error) {
+      if (error instanceof Error) {
+        console.error(chalk.red(`Error: ${error.message}`));
+      } else {
+        console.error(chalk.red(`Error: ${String(error)}`));
+      }
+      process.exit(1);
+    }
+  }
+
+  @Option({
+    flags: '-r, --recursive [boolean]',
+    description: 'Search subdirectories (default: true)'
+  })
+  parseRecursive(val: string): boolean {
+    return val !== 'false';
+  }
+}

package/src/main.ts

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+
+import { CommandFactory } from 'nest-commander';
+import { CliModule } from './cli.module.js';
+
+async function bootstrap() {
+  await CommandFactory.run(CliModule, {
+    logger: false,
+    errorHandler: (err) => {
+      if (err && typeof err === 'object' && 'code' in err && err.code === 'commander.help') {
+        process.exit(0);
+      }
+      console.error('Unexpected error:', err);
+      process.exit(1);
+    }
+  });
+}
+
+bootstrap();

package/src/services/config-discovery.service.spec.ts

@@ -0,0 +1,209 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { ConfigDiscoveryService } from './config-discovery.service.js';
+import { describe, beforeEach, afterEach, it, expect } from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('ConfigDiscoveryService', () => {
+  let service: ConfigDiscoveryService;
+  let tempDir: string;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [ConfigDiscoveryService]
+    }).compile();
+
+    service = module.get<ConfigDiscoveryService>(ConfigDiscoveryService);
+
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'configbound-test-'));
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  function createTempFile(relativePath: string, content: string): string {
+    const filePath = path.join(tempDir, relativePath);
+    const dir = path.dirname(filePath);
+
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, content, 'utf8');
+    return filePath;
+  }
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  it('should discover named export with ConfigBound.createConfig', async () => {
+    createTempFile(
+      'config.ts',
+      `
+      import { ConfigBound } from '@config-bound/config-bound';
+      
+      export const appConfig = ConfigBound.createConfig({
+        name: 'MyApp',
+        sections: {}
+      });
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, false);
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].exportName).toBe('appConfig');
+    expect(configs[0].configName).toBe('MyApp');
+    expect(configs[0].isDefault).toBe(false);
+  });
+
+  it('should discover named export with createConfig from named import', async () => {
+    createTempFile(
+      'config.ts',
+      `
+      import { createConfig } from '@config-bound/config-bound';
+      
+      export const dbConfig = createConfig({
+        name: 'Database',
+        sections: {}
+      });
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, false);
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].exportName).toBe('dbConfig');
+    expect(configs[0].configName).toBe('Database');
+  });
+
+  it('should discover default export', async () => {
+    createTempFile(
+      'config.ts',
+      `
+      import { ConfigBound } from '@config-bound/config-bound';
+      
+      export default ConfigBound.createConfig({
+        name: 'DefaultConfig',
+        sections: {}
+      });
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, false);
+
+    expect(configs).toHaveLength(1);
+    expect(configs[0].exportName).toBe('default');
+    expect(configs[0].isDefault).toBe(true);
+    expect(configs[0].configName).toBe('DefaultConfig');
+  });
+
+  it('should discover multiple exports in same file', async () => {
+    createTempFile(
+      'configs.ts',
+      `
+      import { createConfig } from '@config-bound/config-bound';
+      
+      export const config1 = createConfig({ name: 'Config1', sections: {} });
+      export const config2 = createConfig({ name: 'Config2', sections: {} });
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, false);
+
+    expect(configs).toHaveLength(2);
+    expect(
+      configs.map((c: (typeof configs)[0]) => c.exportName).sort()
+    ).toEqual(['config1', 'config2']);
+  });
+
+  it('should discover configs recursively', async () => {
+    createTempFile(
+      'config1.ts',
+      `
+      import { createConfig } from '@config-bound/config-bound';
+      export const config1 = createConfig({ name: 'Config1', sections: {} });
+    `
+    );
+
+    createTempFile(
+      'subdir/config2.ts',
+      `
+      import { createConfig } from '@config-bound/config-bound';
+      export const config2 = createConfig({ name: 'Config2', sections: {} });
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, true);
+
+    expect(configs).toHaveLength(2);
+  });
+
+  it('should not discover configs when recursive is false', async () => {
+    createTempFile(
+      'config1.ts',
+      `
+      import { createConfig } from '@config-bound/config-bound';
+      export const config1 = createConfig({ name: 'Config1', sections: {} });
+    `
+    );
+
+    createTempFile(
+      'subdir/config2.ts',
+      `
+      import { createConfig } from '@config-bound/config-bound';
+      export const config2 = createConfig({ name: 'Config2', sections: {} });
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, false);
+
+    expect(configs).toHaveLength(1);
+  });
+
+  it('should skip non-exported configs', async () => {
+    createTempFile(
+      'config.ts',
+      `
+      import { createConfig } from '@config-bound/config-bound';
+      const privateConfig = createConfig({ name: 'Private', sections: {} });
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, false);
+
+    expect(configs).toHaveLength(0);
+  });
+
+  it('should skip test files', async () => {
+    createTempFile(
+      'config.spec.ts',
+      `
+      import { createConfig } from '@config-bound/config-bound';
+      export const testConfig = createConfig({ name: 'Test', sections: {} });
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, false);
+
+    expect(configs).toHaveLength(0);
+  });
+
+  it('should handle files without configs', async () => {
+    createTempFile(
+      'other.ts',
+      `
+      export const someValue = 42;
+    `
+    );
+
+    const configs = await service.discoverConfigs(tempDir, false);
+
+    expect(configs).toHaveLength(0);
+  });
+});