klasik 1.0.0 → 1.0.2

package/example.md

@@ -90,11 +90,11 @@ To test the package locally with the linked `openapi-class-transformer`:
 
 ```bash
 # In openapi-class-transformer directory
-cd /Users/eyald/koalaops/openapi-class-transformer
+cd folder
 npm link
 
 # In klasik directory
-cd /Users/eyald/koalaops/klasik
+cd folder
 npm link openapi-class-transformer
 
 # Build and test

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "klasik",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Download OpenAPI specs from remote URLs and generate TypeScript clients with class-transformer support",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -27,7 +27,7 @@
   "dependencies": {
     "axios": "^1.6.0",
     "commander": "^11.0.0",
-    "openapi-class-transformer": "file:../openapi-class-transformer"
+    "openapi-class-transformer": "1.0.1"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",

package/jest.config.js

@@ -1,10 +0,0 @@
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  roots: ['<rootDir>/test'],
-  testMatch: ['**/*.test.ts'],
-  collectCoverageFrom: [
-    'src/**/*.ts',
-    '!src/**/*.d.ts',
-  ],
-};

package/src/cli.ts

@@ -1,103 +0,0 @@
-#!/usr/bin/env node
-
-import { Command } from 'commander';
-import { K8sClientGenerator } from './k8s-client-generator';
-import * as path from 'path';
-
-const program = new Command();
-
-program
-  .name('klasik')
-  .description('Download OpenAPI specs from remote URLs and generate TypeScript clients with class-transformer support')
-  .version('1.0.0');
-
-program
-  .command('generate')
-  .description('Generate TypeScript client from a remote OpenAPI spec')
-  .requiredOption('-u, --url <url>', 'Remote URL to download the OpenAPI spec from')
-  .requiredOption('-o, --output <dir>', 'Output directory for generated client code')
-  .option('-m, --mode <mode>', 'Generation mode: "full" (models + APIs + config) or "models-only"', 'full')
-  .option('-H, --header <header...>', 'Custom headers for the request (format: "Key: Value")')
-  .option('-t, --template <dir>', 'Custom template directory')
-  .option('-k, --keep-spec', 'Keep the downloaded spec file after generation', false)
-  .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
-  .action(async (options) => {
-    try {
-      // Validate mode
-      if (options.mode !== 'full' && options.mode !== 'models-only') {
-        console.error('Error: --mode must be either "full" or "models-only"');
-        process.exit(1);
-      }
-
-      // Parse headers if provided
-      const headers: Record<string, string> = {};
-      if (options.header) {
-        for (const header of options.header) {
-          const [key, ...valueParts] = header.split(':');
-          const value = valueParts.join(':').trim();
-          if (key && value) {
-            headers[key.trim()] = value;
-          }
-        }
-      }
-
-      // Resolve output directory to absolute path
-      const outputDir = path.resolve(options.output);
-
-      const generator = new K8sClientGenerator();
-      await generator.generate({
-        specUrl: options.url,
-        outputDir,
-        mode: options.mode,
-        headers: Object.keys(headers).length > 0 ? headers : undefined,
-        templateDir: options.template,
-        keepSpec: options.keepSpec,
-        timeout: parseInt(options.timeout, 10),
-      });
-
-      process.exit(0);
-    } catch (error) {
-      console.error('Error:', error instanceof Error ? error.message : error);
-      process.exit(1);
-    }
-  });
-
-program
-  .command('download')
-  .description('Download an OpenAPI spec from a remote URL (without generating)')
-  .requiredOption('-u, --url <url>', 'Remote URL to download the OpenAPI spec from')
-  .requiredOption('-o, --output <file>', 'Output file path for the downloaded spec')
-  .option('-H, --header <header...>', 'Custom headers for the request (format: "Key: Value")')
-  .option('--timeout <ms>', 'Request timeout in milliseconds', '30000')
-  .action(async (options) => {
-    try {
-      const { SpecDownloader } = await import('./spec-downloader');
-
-      // Parse headers if provided
-      const headers: Record<string, string> = {};
-      if (options.header) {
-        for (const header of options.header) {
-          const [key, ...valueParts] = header.split(':');
-          const value = valueParts.join(':').trim();
-          if (key && value) {
-            headers[key.trim()] = value;
-          }
-        }
-      }
-
-      const downloader = new SpecDownloader();
-      await downloader.download({
-        url: options.url,
-        outputPath: path.resolve(options.output),
-        headers: Object.keys(headers).length > 0 ? headers : undefined,
-        timeout: parseInt(options.timeout, 10),
-      });
-
-      process.exit(0);
-    } catch (error) {
-      console.error('Error:', error instanceof Error ? error.message : error);
-      process.exit(1);
-    }
-  });
-
-program.parse();

package/src/index.ts

@@ -1,2 +0,0 @@
-export { K8sClientGenerator, K8sClientGeneratorOptions, GenerationMode } from './k8s-client-generator';
-export { SpecDownloader, DownloadOptions } from './spec-downloader';

package/src/k8s-client-generator.ts

@@ -1,145 +0,0 @@
-import { Generator, GeneratorOptions } from 'openapi-class-transformer';
-import { SpecDownloader, DownloadOptions } from './spec-downloader';
-import * as fs from 'fs';
-
-export type GenerationMode = 'full' | 'models-only';
-
-export interface K8sClientGeneratorOptions {
-  /**
-   * Remote URL to download the OpenAPI spec from
-   */
-  specUrl: string;
-
-  /**
-   * Output directory for generated client code
-   */
-  outputDir: string;
-
-  /**
-   * Generation mode
-   * - 'full': Generate models, APIs, and configuration (default)
-   * - 'models-only': Generate only model classes
-   * @default 'full'
-   */
-  mode?: GenerationMode;
-
-  /**
-   * Optional headers to include in the spec download request
-   */
-  headers?: Record<string, string>;
-
-  /**
-   * Optional custom template directory
-   */
-  templateDir?: string;
-
-  /**
-   * Whether to keep the downloaded spec file after generation
-   * @default false
-   */
-  keepSpec?: boolean;
-
-  /**
-   * Request timeout for downloading spec in milliseconds
-   * @default 30000
-   */
-  timeout?: number;
-}
-
-export class K8sClientGenerator {
-  private downloader: SpecDownloader;
-
-  constructor() {
-    this.downloader = new SpecDownloader();
-  }
-
-  /**
-   * Generate TypeScript client from a remote OpenAPI spec URL
-   */
-  async generate(options: K8sClientGeneratorOptions): Promise<void> {
-    const {
-      specUrl,
-      outputDir,
-      mode = 'full',
-      headers,
-      templateDir,
-      keepSpec = false,
-      timeout,
-    } = options;
-
-    let specPath: string | undefined;
-
-    try {
-      // Step 1: Download the OpenAPI spec
-      console.log('Step 1: Downloading OpenAPI specification...');
-      const downloadOptions: DownloadOptions = {
-        url: specUrl,
-        headers,
-        timeout,
-      };
-
-      specPath = await this.downloader.download(downloadOptions);
-
-      // Step 2: Validate output directory
-      console.log('Step 2: Preparing output directory...');
-      this.prepareOutputDirectory(outputDir);
-
-      // Step 3: Generate client using openapi-class-transformer
-      const modeLabel = mode === 'models-only' ? 'models only' : 'full client';
-      console.log(`Step 3: Generating TypeScript ${modeLabel}...`);
-      const generatorOptions: GeneratorOptions = {
-        inputSpec: specPath,
-        outputDir,
-        modelsOnly: mode === 'models-only',
-      };
-
-      // Only add templateDir if it's provided
-      if (templateDir) {
-        generatorOptions.templateDir = templateDir;
-      }
-
-      const generator = new Generator(generatorOptions);
-      await generator.generate();
-
-      console.log('✅ Client generation completed successfully!');
-      console.log(`📁 Generated files location: ${outputDir}`);
-    } catch (error) {
-      console.error('❌ Client generation failed:', error);
-      throw error;
-    } finally {
-      // Cleanup
-      if (!keepSpec && specPath) {
-        this.cleanupSpecFile(specPath);
-      }
-    }
-  }
-
-  /**
-   * Prepare the output directory
-   */
-  private prepareOutputDirectory(outputDir: string): void {
-    if (!fs.existsSync(outputDir)) {
-      fs.mkdirSync(outputDir, { recursive: true });
-      console.log(`Created output directory: ${outputDir}`);
-    } else {
-      console.log(`Using existing output directory: ${outputDir}`);
-    }
-  }
-
-  /**
-   * Clean up the downloaded spec file
-   */
-  private cleanupSpecFile(specPath: string): void {
-    try {
-      if (fs.existsSync(specPath)) {
-        fs.unlinkSync(specPath);
-        console.log(`Cleaned up downloaded spec file: ${specPath}`);
-      }
-
-      // Also cleanup temp directory if empty
-      this.downloader.cleanupTemp();
-    } catch (error) {
-      console.warn('Warning: Failed to cleanup spec file:', error);
-    }
-  }
-}

package/src/spec-downloader.ts

@@ -1,233 +0,0 @@
-import axios from 'axios';
-import * as fs from 'fs';
-import * as path from 'path';
-
-export interface DownloadOptions {
-  /**
-   * URL or file path to the OpenAPI spec
-   * Supports:
-   * - HTTP/HTTPS URLs: https://example.com/spec.json
-   * - File URLs: file:///path/to/spec.json
-   * - Absolute paths: /path/to/spec.json
-   * - Relative paths: ./spec.json, ../specs/api.json
-   */
-  url: string;
-
-  /**
-   * Optional output path to save the downloaded spec
-   * If not provided, will save to a temp file (for HTTP) or use the source path (for files)
-   */
-  outputPath?: string;
-
-  /**
-   * Optional headers to include in the request (only used for HTTP/HTTPS)
-   */
-  headers?: Record<string, string>;
-
-  /**
-   * Request timeout in milliseconds (only used for HTTP/HTTPS)
-   * @default 30000
-   */
-  timeout?: number;
-}
-
-export class SpecDownloader {
-  /**
-   * Download an OpenAPI specification from a URL or load from a local file
-   * @param options Download options
-   * @returns Path to the spec file
-   */
-  async download(options: DownloadOptions): Promise<string> {
-    const { url, outputPath, headers, timeout = 30000 } = options;
-
-    // Check if it's a local file path
-    if (this.isLocalFile(url)) {
-      return this.loadLocalFile(url, outputPath);
-    }
-
-    // Otherwise, download from HTTP/HTTPS
-    console.log(`Downloading OpenAPI spec from ${url}...`);
-
-    try {
-      const response = await axios.get(url, {
-        headers,
-        timeout,
-        responseType: 'text',
-      });
-
-      // Determine output path
-      const specPath = outputPath || this.generateTempPath(url);
-
-      // Ensure directory exists
-      const dir = path.dirname(specPath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-
-      // Parse and validate the spec
-      let specContent: string;
-      if (typeof response.data === 'string') {
-        // Try to parse as JSON to validate
-        try {
-          const parsed = JSON.parse(response.data);
-          specContent = JSON.stringify(parsed, null, 2);
-        } catch {
-          // If not JSON, might be YAML - save as-is
-          specContent = response.data;
-        }
-      } else {
-        specContent = JSON.stringify(response.data, null, 2);
-      }
-
-      // Validate it's an OpenAPI spec
-      this.validateSpec(specContent);
-
-      // Write to file
-      fs.writeFileSync(specPath, specContent, 'utf-8');
-
-      console.log(`OpenAPI spec downloaded successfully to ${specPath}`);
-      return specPath;
-    } catch (error) {
-      if (axios.isAxiosError(error)) {
-        throw new Error(
-          `Failed to download OpenAPI spec from ${url}: ${error.message}`
-        );
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Check if the URL is a local file path
-   */
-  private isLocalFile(url: string): boolean {
-    // Check for file:// protocol
-    if (url.startsWith('file://')) {
-      return true;
-    }
-
-    // Check for HTTP/HTTPS protocols
-    if (url.startsWith('http://') || url.startsWith('https://')) {
-      return false;
-    }
-
-    // Check if it's an absolute or relative path
-    // Absolute paths start with / (Unix) or C:\ (Windows)
-    // Relative paths start with ./ or ../
-    return (
-      url.startsWith('/') ||
-      url.startsWith('./') ||
-      url.startsWith('../') ||
-      /^[a-zA-Z]:[\\\/]/.test(url) // Windows paths like C:\
-    );
-  }
-
-  /**
-   * Load and validate an OpenAPI spec from a local file
-   */
-  private loadLocalFile(filePath: string, outputPath?: string): string {
-    // Handle file:// URLs
-    let resolvedPath = filePath;
-    if (filePath.startsWith('file://')) {
-      resolvedPath = filePath.replace('file://', '');
-      // On Windows, file URLs might be file:///C:/path
-      if (process.platform === 'win32' && resolvedPath.startsWith('/')) {
-        resolvedPath = resolvedPath.substring(1);
-      }
-    }
-
-    // Resolve to absolute path
-    resolvedPath = path.resolve(resolvedPath);
-
-    console.log(`Loading OpenAPI spec from local file: ${resolvedPath}...`);
-
-    // Check if file exists
-    if (!fs.existsSync(resolvedPath)) {
-      throw new Error(`File not found: ${resolvedPath}`);
-    }
-
-    // Read the file
-    const content = fs.readFileSync(resolvedPath, 'utf-8');
-
-    // Validate it's an OpenAPI spec
-    this.validateSpec(content);
-
-    // If outputPath is provided, copy to that location
-    if (outputPath) {
-      const dir = path.dirname(outputPath);
-      if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
-      }
-
-      // Parse and format if it's JSON
-      let formattedContent = content;
-      try {
-        const parsed = JSON.parse(content);
-        formattedContent = JSON.stringify(parsed, null, 2);
-      } catch {
-        // Not JSON, keep original
-      }
-
-      fs.writeFileSync(outputPath, formattedContent, 'utf-8');
-      console.log(`OpenAPI spec copied to ${outputPath}`);
-      return outputPath;
-    }
-
-    console.log(`OpenAPI spec loaded successfully from ${resolvedPath}`);
-    return resolvedPath;
-  }
-
-  /**
-   * Generate a temporary file path based on the URL
-   */
-  private generateTempPath(url: string): string {
-    const urlObj = new URL(url);
-    const hostname = urlObj.hostname.replace(/\./g, '-');
-    const timestamp = Date.now();
-    const filename = `openapi-${hostname}-${timestamp}.json`;
-    return path.join(process.cwd(), '.tmp', filename);
-  }
-
-  /**
-   * Validate that the downloaded content is an OpenAPI spec
-   */
-  private validateSpec(content: string): void {
-    try {
-      const spec = JSON.parse(content);
-
-      // Check for OpenAPI version
-      if (!spec.openapi && !spec.swagger) {
-        throw new Error(
-          'Invalid OpenAPI spec: missing "openapi" or "swagger" field'
-        );
-      }
-
-      // Check for required fields
-      if (!spec.info) {
-        throw new Error('Invalid OpenAPI spec: missing "info" field');
-      }
-
-      if (!spec.paths && !spec.components) {
-        throw new Error(
-          'Invalid OpenAPI spec: must have either "paths" or "components"'
-        );
-      }
-    } catch (error) {
-      if (error instanceof SyntaxError) {
-        throw new Error('Invalid OpenAPI spec: not valid JSON');
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * Clean up temporary files
-   */
-  cleanupTemp(): void {
-    const tempDir = path.join(process.cwd(), '.tmp');
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-      console.log('Cleaned up temporary files');
-    }
-  }
-}

package/test/k8s-client-generator.test.ts

@@ -1,257 +0,0 @@
-import { K8sClientGenerator } from '../src/k8s-client-generator';
-import { SpecDownloader } from '../src/spec-downloader';
-import * as fs from 'fs';
-import * as path from 'path';
-
-describe('K8sClientGenerator', () => {
-  const testOutputDir = path.join(__dirname, '../test-output');
-
-  beforeEach(() => {
-    // Clean up test output directory
-    if (fs.existsSync(testOutputDir)) {
-      fs.rmSync(testOutputDir, { recursive: true, force: true });
-    }
-  });
-
-  afterEach(() => {
-    // Cleanup after each test
-    if (fs.existsSync(testOutputDir)) {
-      fs.rmSync(testOutputDir, { recursive: true, force: true });
-    }
-
-    // Clean up temp files
-    const tempDir = path.join(process.cwd(), '.tmp');
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('generate', () => {
-    it('should download spec and generate client from a valid URL', async () => {
-      const generator = new K8sClientGenerator();
-
-      // Use a simple test OpenAPI spec
-      const testSpec = {
-        openapi: '3.0.0',
-        info: { title: 'Test API', version: '1.0.0' },
-        paths: {
-          '/test': {
-            get: {
-              responses: {
-                '200': {
-                  description: 'Success',
-                  content: {
-                    'application/json': {
-                      schema: {
-                        type: 'object',
-                        properties: {
-                          message: { type: 'string' }
-                        }
-                      }
-                    }
-                  }
-                }
-              }
-            }
-          }
-        }
-      };
-
-      // Create a mock server would be ideal, but for now we'll test with a file URL
-      // or skip this test in favor of integration tests
-      const specPath = path.join(testOutputDir, 'test-spec.json');
-      fs.mkdirSync(testOutputDir, { recursive: true });
-      fs.writeFileSync(specPath, JSON.stringify(testSpec, null, 2));
-
-      const outputDir = path.join(testOutputDir, 'generated');
-
-      // Note: This test would need a real HTTP server or mock
-      // For now, we'll test the structure
-      expect(generator).toBeDefined();
-      expect(typeof generator.generate).toBe('function');
-    }, 60000);
-
-    it('should create output directory if it does not exist', async () => {
-      const generator = new K8sClientGenerator();
-      expect(generator).toBeDefined();
-    });
-
-    it('should handle download errors gracefully', async () => {
-      const generator = new K8sClientGenerator();
-
-      await expect(
-        generator.generate({
-          specUrl: 'http://invalid-url-that-does-not-exist.com/spec.json',
-          outputDir: testOutputDir,
-          timeout: 1000,
-        })
-      ).rejects.toThrow();
-    }, 60000);
-  });
-});
-
-describe('SpecDownloader', () => {
-  const testOutputDir = path.join(__dirname, '../test-output');
-
-  beforeEach(() => {
-    if (fs.existsSync(testOutputDir)) {
-      fs.rmSync(testOutputDir, { recursive: true, force: true });
-    }
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(testOutputDir)) {
-      fs.rmSync(testOutputDir, { recursive: true, force: true });
-    }
-
-    const tempDir = path.join(process.cwd(), '.tmp');
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('download', () => {
-    it('should throw error for invalid URL', async () => {
-      const downloader = new SpecDownloader();
-
-      await expect(
-        downloader.download({
-          url: 'http://invalid-url-that-does-not-exist.com/spec.json',
-          timeout: 1000,
-        })
-      ).rejects.toThrow();
-    }, 60000);
-
-    it('should validate OpenAPI spec format', async () => {
-      // This test validates the validation logic
-      const downloader = new SpecDownloader();
-      expect(downloader).toBeDefined();
-      expect(typeof downloader.download).toBe('function');
-    });
-
-    it('should load OpenAPI spec from local file path', async () => {
-      const downloader = new SpecDownloader();
-
-      // Create a test spec file
-      const testSpec = {
-        openapi: '3.0.0',
-        info: { title: 'Local Test API', version: '1.0.0' },
-        paths: {}
-      };
-
-      const testSpecPath = path.join(testOutputDir, 'local-spec.json');
-      fs.mkdirSync(testOutputDir, { recursive: true });
-      fs.writeFileSync(testSpecPath, JSON.stringify(testSpec, null, 2));
-
-      const result = await downloader.download({
-        url: testSpecPath,
-      });
-
-      expect(result).toBe(path.resolve(testSpecPath));
-      expect(fs.existsSync(result)).toBe(true);
-    });
-
-    it('should load OpenAPI spec from relative file path', async () => {
-      const downloader = new SpecDownloader();
-
-      // Create a test spec file
-      const testSpec = {
-        openapi: '3.0.0',
-        info: { title: 'Relative Test API', version: '1.0.0' },
-        paths: {}
-      };
-
-      const testSpecPath = path.join(testOutputDir, 'relative-spec.json');
-      fs.mkdirSync(testOutputDir, { recursive: true });
-      fs.writeFileSync(testSpecPath, JSON.stringify(testSpec, null, 2));
-
-      // Use relative path
-      const relativePath = path.relative(process.cwd(), testSpecPath);
-
-      const result = await downloader.download({
-        url: `./${relativePath}`,
-      });
-
-      expect(fs.existsSync(result)).toBe(true);
-    });
-
-    it('should load OpenAPI spec from file:// URL', async () => {
-      const downloader = new SpecDownloader();
-
-      // Create a test spec file
-      const testSpec = {
-        openapi: '3.0.0',
-        info: { title: 'File URL Test API', version: '1.0.0' },
-        paths: {}
-      };
-
-      const testSpecPath = path.join(testOutputDir, 'file-url-spec.json');
-      fs.mkdirSync(testOutputDir, { recursive: true });
-      fs.writeFileSync(testSpecPath, JSON.stringify(testSpec, null, 2));
-
-      // Use file:// URL
-      const fileUrl = `file://${path.resolve(testSpecPath)}`;
-
-      const result = await downloader.download({
-        url: fileUrl,
-      });
-
-      expect(fs.existsSync(result)).toBe(true);
-      const content = JSON.parse(fs.readFileSync(result, 'utf-8'));
-      expect(content.info.title).toBe('File URL Test API');
-    });
-
-    it('should copy local file to output path if specified', async () => {
-      const downloader = new SpecDownloader();
-
-      // Create a test spec file
-      const testSpec = {
-        openapi: '3.0.0',
-        info: { title: 'Copy Test API', version: '1.0.0' },
-        paths: {}
-      };
-
-      const sourceSpecPath = path.join(testOutputDir, 'source-spec.json');
-      const targetSpecPath = path.join(testOutputDir, 'target-spec.json');
-      fs.mkdirSync(testOutputDir, { recursive: true });
-      fs.writeFileSync(sourceSpecPath, JSON.stringify(testSpec, null, 2));
-
-      const result = await downloader.download({
-        url: sourceSpecPath,
-        outputPath: targetSpecPath,
-      });
-
-      expect(result).toBe(targetSpecPath);
-      expect(fs.existsSync(targetSpecPath)).toBe(true);
-      const content = JSON.parse(fs.readFileSync(targetSpecPath, 'utf-8'));
-      expect(content.info.title).toBe('Copy Test API');
-    });
-
-    it('should throw error for non-existent local file', async () => {
-      const downloader = new SpecDownloader();
-
-      await expect(
-        downloader.download({
-          url: '/non/existent/file.json',
-        })
-      ).rejects.toThrow('File not found');
-    });
-  });
-
-  describe('cleanupTemp', () => {
-    it('should clean up temporary directory', () => {
-      const downloader = new SpecDownloader();
-
-      // Create temp directory
-      const tempDir = path.join(process.cwd(), '.tmp');
-      fs.mkdirSync(tempDir, { recursive: true });
-      fs.writeFileSync(path.join(tempDir, 'test.txt'), 'test');
-
-      expect(fs.existsSync(tempDir)).toBe(true);
-
-      downloader.cleanupTemp();
-
-      expect(fs.existsSync(tempDir)).toBe(false);
-    });
-  });
-});

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
-    "declaration": true,
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true,
-    "moduleResolution": "node",
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "test"]
-}