@config-bound/cli 0.1.0

package/src/services/file-writer.service.spec.ts

@@ -0,0 +1,139 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { FileWriterService } from './file-writer.service.js';
+import {
+  describe,
+  beforeEach,
+  afterEach,
+  it,
+  expect,
+  jest
+} from '@jest/globals';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('FileWriterService', () => {
+  let service: FileWriterService;
+  let tempDir: string;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [FileWriterService]
+    }).compile();
+
+    service = module.get<FileWriterService>(FileWriterService);
+
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'configbound-test-'));
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(tempDir)) {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('writeToFile', () => {
+    it('should write content to file', () => {
+      const filePath = path.join(tempDir, 'test.txt');
+      const content = 'Hello, World!';
+
+      service.writeToFile(filePath, content);
+
+      expect(fs.existsSync(filePath)).toBe(true);
+      const writtenContent = fs.readFileSync(filePath, 'utf8');
+      expect(writtenContent).toBe(content);
+    });
+
+    it('should create directories if they do not exist', () => {
+      const filePath = path.join(tempDir, 'nested', 'dir', 'test.txt');
+      const content = 'Test content';
+
+      service.writeToFile(filePath, content);
+
+      expect(fs.existsSync(filePath)).toBe(true);
+      const writtenContent = fs.readFileSync(filePath, 'utf8');
+      expect(writtenContent).toBe(content);
+    });
+
+    it('should overwrite existing file', () => {
+      const filePath = path.join(tempDir, 'test.txt');
+
+      service.writeToFile(filePath, 'First content');
+      service.writeToFile(filePath, 'Second content');
+
+      const writtenContent = fs.readFileSync(filePath, 'utf8');
+      expect(writtenContent).toBe('Second content');
+    });
+  });
+
+  describe('writeToStdout', () => {
+    let stdoutWriteSpy: ReturnType<typeof jest.spyOn>;
+
+    beforeEach(() => {
+      stdoutWriteSpy = jest
+        .spyOn(process.stdout, 'write')
+        .mockImplementation(() => true);
+    });
+
+    afterEach(() => {
+      stdoutWriteSpy.mockRestore();
+    });
+
+    it('should write content to stdout', () => {
+      const content = 'Test output';
+
+      service.writeToStdout(content);
+
+      expect(stdoutWriteSpy).toHaveBeenCalledWith(content);
+    });
+
+    it('should add newline if content does not end with one', () => {
+      const content = 'No newline';
+
+      service.writeToStdout(content);
+
+      expect(stdoutWriteSpy).toHaveBeenCalledWith(content);
+      expect(stdoutWriteSpy).toHaveBeenCalledWith('\n');
+    });
+
+    it('should not add extra newline if content already ends with one', () => {
+      const content = 'With newline\n';
+
+      service.writeToStdout(content);
+
+      expect(stdoutWriteSpy).toHaveBeenCalledWith(content);
+      expect(stdoutWriteSpy).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('write', () => {
+    it('should write to file when output path is provided', () => {
+      const filePath = path.join(tempDir, 'output.txt');
+      const content = 'File output';
+
+      service.write(content, filePath);
+
+      expect(fs.existsSync(filePath)).toBe(true);
+      const writtenContent = fs.readFileSync(filePath, 'utf8');
+      expect(writtenContent).toBe(content);
+    });
+
+    it('should write to stdout when output path is not provided', () => {
+      const stdoutWriteSpy = jest
+        .spyOn(process.stdout, 'write')
+        .mockImplementation(() => true);
+
+      const content = 'Stdout output';
+
+      service.write(content);
+
+      expect(stdoutWriteSpy).toHaveBeenCalledWith(content);
+
+      stdoutWriteSpy.mockRestore();
+    });
+  });
+});

package/src/services/file-writer.service.ts

@@ -0,0 +1,32 @@
+import { Injectable } from '@nestjs/common';
+import * as fs from 'fs';
+import * as path from 'path';
+
+@Injectable()
+export class FileWriterService {
+  writeToFile(filePath: string, content: string): void {
+    const absolutePath = path.resolve(filePath);
+    const directory = path.dirname(absolutePath);
+
+    if (!fs.existsSync(directory)) {
+      fs.mkdirSync(directory, { recursive: true });
+    }
+
+    fs.writeFileSync(absolutePath, content, 'utf8');
+  }
+
+  writeToStdout(content: string): void {
+    process.stdout.write(content);
+    if (!content.endsWith('\n')) {
+      process.stdout.write('\n');
+    }
+  }
+
+  write(content: string, outputPath?: string): void {
+    if (outputPath) {
+      this.writeToFile(outputPath, content);
+    } else {
+      this.writeToStdout(content);
+    }
+  }
+}

package/src/services/schema-export.service.spec.ts

@@ -0,0 +1,124 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { SchemaExportService } from './schema-export.service.js';
+import { describe, beforeEach, it, expect } from '@jest/globals';
+import { ConfigBound } from '@config-bound/config-bound';
+import { Section } from '@config-bound/config-bound/section';
+import { Element } from '@config-bound/config-bound/element';
+import Joi from 'joi';
+
+describe('SchemaExportService', () => {
+  let service: SchemaExportService;
+  let mockConfigInstance: ConfigBound;
+  let mockSections: Section[];
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [SchemaExportService]
+    }).compile();
+
+    service = module.get<SchemaExportService>(SchemaExportService);
+
+    const hostElement = new Element<string>(
+      'host',
+      'Database host',
+      'localhost',
+      undefined,
+      false,
+      false,
+      Joi.string()
+    );
+
+    const portElement = new Element<number>(
+      'port',
+      'Database port',
+      5432,
+      undefined,
+      false,
+      false,
+      Joi.number()
+    );
+
+    const databaseSection = new Section(
+      'database',
+      [hostElement, portElement],
+      'Database configuration'
+    );
+
+    mockSections = [databaseSection];
+
+    mockConfigInstance = new ConfigBound('TestConfig', [], [], undefined);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+
+  describe('exportToString', () => {
+    it('should export to JSON format', () => {
+      const result = service.exportToString(
+        'TestConfig',
+        mockSections,
+        mockConfigInstance,
+        {
+          format: 'json',
+          pretty: true
+        }
+      );
+
+      expect(result).toContain('"name": "TestConfig"');
+      expect(result).toContain('"database"');
+      const parsed = JSON.parse(result);
+      expect(parsed.name).toBe('TestConfig');
+    });
+
+    it('should export to YAML format', () => {
+      const result = service.exportToString(
+        'TestConfig',
+        mockSections,
+        mockConfigInstance,
+        {
+          format: 'yaml'
+        }
+      );
+
+      expect(result).toContain('name: TestConfig');
+      expect(result).toContain('- name: database');
+    });
+
+    it('should export to env format', () => {
+      const result = service.exportToString(
+        'TestConfig',
+        mockSections,
+        mockConfigInstance,
+        {
+          format: 'env'
+        }
+      );
+
+      expect(result).toContain('DATABASE_HOST=');
+      expect(result).toContain('DATABASE_PORT=');
+    });
+
+    it('should throw error for unsupported format', () => {
+      expect(() =>
+        service.exportToString('TestConfig', mockSections, mockConfigInstance, {
+          format: 'xml' as any
+        })
+      ).toThrow('Unsupported format: xml');
+    });
+  });
+
+  describe('getFileExtension', () => {
+    it('should return correct extension for json', () => {
+      expect(service.getFileExtension('json')).toBe('.json');
+    });
+
+    it('should return correct extension for yaml', () => {
+      expect(service.getFileExtension('yaml')).toBe('.yaml');
+    });
+
+    it('should return correct extension for env', () => {
+      expect(service.getFileExtension('env')).toBe('.env.example');
+    });
+  });
+});

package/src/services/schema-export.service.ts

@@ -0,0 +1,85 @@
+import { Injectable } from '@nestjs/common';
+import {
+  exportSchema,
+  formatAsJSON,
+  formatAsYAML,
+  formatAsEnvExample
+} from '@config-bound/schema-export';
+import {
+  ConfigBound,
+  TypedConfigBound,
+  ConfigSchema
+} from '@config-bound/config-bound';
+import { Section } from '@config-bound/config-bound/section';
+import { EnvVarBind } from '@config-bound/config-bound/bind/binds/envVar';
+
+export type ExportFormat = 'json' | 'yaml' | 'env';
+
+export interface ExportSchemaOptions {
+  format: ExportFormat;
+  includeOmitted?: boolean;
+  pretty?: boolean;
+}
+
+@Injectable()
+export class SchemaExportService {
+  exportToString(
+    configName: string,
+    sections: Section[],
+    configInstance: ConfigBound | TypedConfigBound<ConfigSchema>,
+    options: ExportSchemaOptions
+  ): string {
+    const includeOmitted = options.includeOmitted || false;
+
+    const schema = exportSchema(configName, sections, includeOmitted);
+
+    switch (options.format) {
+      case 'json':
+        return formatAsJSON(schema, options.pretty !== false);
+
+      case 'yaml':
+        return formatAsYAML(schema);
+
+      case 'env': {
+        // Extract prefix from EnvVarBind if present
+        const prefix = this.extractEnvVarPrefix(configInstance);
+        return formatAsEnvExample(schema, prefix);
+      }
+
+      default:
+        throw new Error(`Unsupported format: ${options.format}`);
+    }
+  }
+
+  private extractEnvVarPrefix(
+    configInstance: ConfigBound | TypedConfigBound<ConfigSchema>
+  ): string | undefined {
+    if (!configInstance || !configInstance.binds) {
+      return undefined;
+    }
+
+    for (const bind of configInstance.binds) {
+      if (bind instanceof EnvVarBind) {
+        const envVarBind = bind as EnvVarBind;
+        if (envVarBind.envVarPrefix) {
+          return envVarBind.envVarPrefix;
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  getFileExtension(format: ExportFormat): string {
+    switch (format) {
+      case 'json':
+        return '.json';
+      case 'yaml':
+        return '.yaml';
+      case 'env':
+        return '.env.example';
+      default:
+        return '';
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "@config-bound/typescript-config/cli.tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "types": ["node", "jest"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}