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

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

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.Renderer = void 0;
var _nodePath = /*#__PURE__*/_interopRequireDefault(/*#__PURE__*/require("node:path"));
var _ansis = /*#__PURE__*/_interopRequireDefault(/*#__PURE__*/require("ansis"));
var _lodashEs = /*#__PURE__*/require("lodash-es");
var _yaml = /*#__PURE__*/require("yaml");
var _utils = /*#__PURE__*/require("../../internal/utils.js");
var _version = /*#__PURE__*/require("../../version.js");
var _MetadataInjector = /*#__PURE__*/require("../MetadataInjector.js");
function _interopRequireDefault(e) {
  return e && e.__esModule ? e : {
    default: e
  };
}
const defaultMetadata = {
  inject: true,
  injectManagedAt: true,
  injectResourceHash: true,
  injectVersion: true
};
class Renderer {
  logger;
  metadata;
  constructor(globalOptions, logger) {
    this.logger = logger;
    this.metadata = (0, _lodashEs.merge)({}, defaultMetadata, globalOptions.metadata);
  }
  injectMetadata(resources, options) {
    const createInjector = resourceId => new _MetadataInjector.MetadataInjector({
      type: 'stack',
      kubricateVersion: _version.version,
      managedAt: new Date().toISOString(),
      stackId: options.stackId,
      stackName: options.stackName,
      resourceId,
      inject: {
        managedAt: this.metadata.injectManagedAt,
        resourceHash: this.metadata.injectResourceHash,
        version: this.metadata.injectVersion
      }
    });
    const output = {};
    for (const [resourceId, resource] of Object.entries(resources)) {
      const clone = (0, _lodashEs.cloneDeep)(resource);
      if (clone && typeof clone !== 'object') {
        this.logger.warn(_ansis.default.yellow('Warning: Resource is not an object, skipping metadata injection.'));
        continue;
      }
      const injector = createInjector(resourceId);
      injector.inject(clone);
      output[resourceId] = clone;
    }
    return output;
  }
  renderStacks(config) {
    const output = [];
    if (!config.stacks || Object.keys(config.stacks ?? {}).length === 0) {
      throw new Error('No stacks found in config');
    }
    for (const [stackId, stack] of Object.entries(config.stacks)) {
      let builtResources = {};
      const stackName = stack.getName() ?? (0, _utils.getClassName)(stack) ?? 'unknown';
      if (this.metadata.inject === true) {
        builtResources = this.injectMetadata(stack.build(), {
          stackId,
          stackName
        });
      } else {
        builtResources = stack.build();
        this.logger.debug(`Warning: Metadata injection is disabled, skipping metadata injection`);
      }
      for (const [resourceId, resource] of Object.entries(builtResources)) {
        const kind = resource?.kind || 'UnknownKind';
        const name = resource?.metadata?.name || 'unnamed';
        const content = (0, _yaml.stringify)(resource) + '---\n';
        output.push({
          stackName,
          kind,
          name,
          content,
          id: resourceId,
          stackId
        });
      }
    }
    return output;
  }
  resolveOutputPath(resource, mode, stdout) {
    if (stdout) {
      // Create canonical name for the resource groped by stackId and resourceId
      return `${resource.stackId}.${resource.id}`;
    }
    switch (mode) {
      case 'flat':
        return 'stacks.yml';
      case 'stack':
        return `${resource.stackId}.yml`;
      case 'resource':
        return _nodePath.default.join(resource.stackId, `${resource.kind}_${resource.id}.yml`);
    }
    throw new Error(`Unknown output mode: ${mode}`);
  }
}
exports.Renderer = Renderer;
//# sourceMappingURL=Renderer.js.map