kubricate/dist/cjs/commands/generate/GenerateCommand.js

A TypeScript framework for building reusable, type-safe Kubernetes infrastructure — without the YAML mess.

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.GenerateCommand = void 0;
var _nodePath = /*#__PURE__*/_interopRequireDefault(/*#__PURE__*/require("node:path"));
var _ansis = /*#__PURE__*/_interopRequireDefault(/*#__PURE__*/require("ansis"));
var _lodashEs = /*#__PURE__*/require("lodash-es");
var _constant = /*#__PURE__*/require("../../internal/constant.js");
var _utils = /*#__PURE__*/require("../../internal/utils.js");
var _GenerateRunner = /*#__PURE__*/require("./GenerateRunner.js");
var _Renderer = /*#__PURE__*/require("./Renderer.js");
function _interopRequireDefault(e) {
  return e && e.__esModule ? e : {
    default: e
  };
}
class GenerateCommand {
  options;
  logger;
  constructor(options, logger) {
    this.options = options;
    this.logger = logger;
  }
  resolveDefaultGenerateOptions(config) {
    const defaultOptions = {
      outputDir: 'output',
      outputMode: 'stack',
      cleanOutputDir: true
    };
    const result = (0, _lodashEs.merge)({}, defaultOptions, config.generate);
    return result;
  }
  async execute(config) {
    const logger = this.logger;
    const generateOptions = this.resolveDefaultGenerateOptions(config);
    logger.info('Generating stacks for Kubernetes...');
    const renderedFiles = this.getRenderedFiles(config, generateOptions.outputMode);
    const runner = new _GenerateRunner.GenerateRunner(this.options, generateOptions, renderedFiles, this.logger);
    this.showStacks(config);
    this.logger.log('');
    await runner.run();
    logger.log(_ansis.default.green`${_constant.MARK_CHECK} Done!`);
  }
  getRenderedFiles(config, outputMode) {
    const renderer = new _Renderer.Renderer(config, this.logger);
    const rendered = renderer.renderStacks(config);
    const files = {};
    const renderedFiles = [];
    for (const r of rendered) {
      const outPath = renderer.resolveOutputPath(r, outputMode, this.options.stdout);
      if (!files[outPath]) files[outPath] = [];
      files[outPath].push(r.content);
    }
    for (const [filePath, contents] of Object.entries(files)) {
      const relatePath = _nodePath.default.join(this.options.outDir, filePath);
      renderedFiles.push({
        filePath: relatePath,
        originalPath: filePath,
        content: contents.join('\n')
      });
    }
    if (this.options.filter) {
      return this.filterResources(renderedFiles, this.options.filter);
    }
    return renderedFiles;
  }
  filterResources(renderedFiles, filters) {
    if (filters.length === 0) return renderedFiles;
    const filterSet = new Set(filters);
    const matchedFilters = new Set();
    const stackIds = new Set();
    const fullResourceIds = new Set();
    const filtered = renderedFiles.filter(file => {
      const originalPath = file.originalPath; // e.g., myApp.deployment
      const [stackId] = originalPath.split('.');
      stackIds.add(stackId);
      fullResourceIds.add(originalPath);
      const matched = filterSet.has(stackId) || filterSet.has(originalPath);
      if (matched) {
        if (filterSet.has(stackId)) matchedFilters.add(stackId);
        if (filterSet.has(originalPath)) matchedFilters.add(originalPath);
      }
      return matched;
    });
    const unmatchedFilters = filters.filter(f => !matchedFilters.has(f));
    if (unmatchedFilters.length > 0) {
      const stacksList = Array.from(stackIds).sort().join('\n     - ');
      const resourcesList = Array.from(fullResourceIds).sort().join('\n     - ');
      const stacksSection = stackIds.size > 0 ? `  • Stacks: \n` + `     - ${stacksList}\n` : '';
      const resourcesSection = fullResourceIds.size > 0 ? `  • Resources: \n` + `     - ${resourcesList}\n` : '';
      throw new Error(`The following filters did not match any resource: ${unmatchedFilters.join(', ')}.\n\n` + `Available filters:\n` + stacksSection + resourcesSection + `\nPlease check your --filter values and try again.`);
    }
    return filtered;
  }
  showStacks(config) {
    const logger = this.logger;
    const stacksLength = Object.keys(config.stacks ?? {}).length;
    if (!config.stacks || stacksLength === 0) {
      throw new Error('No stacks found in config');
    }
    logger.info(`Found ${stacksLength} stacks in config:`);
    const renderListTree = kinds => {
      const lastIndex = kinds.length - 1;
      for (let i = 0; i < kinds.length; i++) {
        const kind = kinds[i];
        const marker = i === lastIndex ? _constant.MARK_TREE_END : _constant.MARK_TREE_LEAF;
        logger.log(_ansis.default.blue`      ${marker} ${kind.kind}` + _ansis.default.dim` (id: ${kind.id})`);
      }
    };
    for (const stack of (0, _utils.extractStackInfoFromConfig)(config)) {
      logger.log(_ansis.default.blue`  ${_constant.MARK_NODE} ${stack.name}` + _ansis.default.dim` (type: ${stack.type})`);
      renderListTree(stack.kinds);
      logger.log('');
    }
  }
}
exports.GenerateCommand = GenerateCommand;
//# sourceMappingURL=GenerateCommand.js.map