@storm-software/k8s-tools 0.18.0 → 0.19.0

package/dist/chunk-EAQFLLRB.js

@@ -0,0 +1,23 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// src/utils/ensure-init.ts
+var ensureInitialized = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (target, propertyKey, descriptor) => {
+  const originalMethod = descriptor.value;
+  descriptor.value = async function(...arguments_) {
+    const self = this;
+    if (self.initialized === void 0 || typeof self.initialize !== "function") {
+      throw new TypeError(`The ensureInitialized decorator can only be applied in classes with an 'initialized' property and 'initialize' method.`);
+    }
+    if (!self.initialized) {
+      await self.initialize();
+    }
+    return originalMethod.apply(this, arguments_);
+  };
+  return descriptor;
+}, "ensureInitialized");
+
+
+
+exports.ensureInitialized = ensureInitialized;

package/dist/chunk-EISL3C34.js

@@ -0,0 +1,169 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+var _chunkUWJTAL4Wjs = require('./chunk-UWJTAL4W.js');
+
+
+var _chunkAFPEYAYKjs = require('./chunk-AFPEYAYK.js');
+
+
+
+
+
+
+
+
+
+
+
+
+var _chunkGDXB64KGjs = require('./chunk-GDXB64KG.js');
+
+
+var _chunk2GAU2GHGjs = require('./chunk-2GAU2GHG.js');
+
+
+var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+
+// ../workspace-tools/src/base/base-executor.ts
+var withRunExecutor = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (name, executorFn, executorOptions = {}) => async (_options, context) => {
+  const stopwatch = _chunkGDXB64KGjs.getStopwatch.call(void 0, name);
+  let options = _options;
+  let config = {};
+  try {
+    _chunkGDXB64KGjs.writeInfo.call(void 0, `\u26A1 Running the ${name} executor...
+`, config);
+    if (!_optionalChain([context, 'access', _ => _.projectsConfigurations, 'optionalAccess', _2 => _2.projects]) || !context.projectName || !context.projectsConfigurations.projects[context.projectName]) {
+      throw new Error("The Build process failed because the context is not valid. Please run this command from a workspace.");
+    }
+    const workspaceRoot = _chunkGDXB64KGjs.findWorkspaceRoot.call(void 0, );
+    const projectRoot = _nullishCoalesce(_optionalChain([context, 'access', _3 => _3.projectsConfigurations, 'access', _4 => _4.projects, 'access', _5 => _5[context.projectName], 'optionalAccess', _6 => _6.root]), () => ( workspaceRoot));
+    const sourceRoot = _nullishCoalesce(_optionalChain([context, 'access', _7 => _7.projectsConfigurations, 'access', _8 => _8.projects, 'access', _9 => _9[context.projectName], 'optionalAccess', _10 => _10.sourceRoot]), () => ( workspaceRoot));
+    const projectName = _nullishCoalesce(_optionalChain([context, 'access', _11 => _11.projectsConfigurations, 'access', _12 => _12.projects, 'access', _13 => _13[context.projectName], 'optionalAccess', _14 => _14.name]), () => ( context.projectName));
+    config.workspaceRoot = workspaceRoot;
+    if (!executorOptions.skipReadingConfig) {
+      _chunkGDXB64KGjs.writeTrace.call(void 0, `Loading the Storm Config from environment variables and storm.config.js file...
+ - workspaceRoot: ${workspaceRoot}
+ - projectRoot: ${projectRoot}
+ - sourceRoot: ${sourceRoot}
+ - projectName: ${projectName}
+`, config);
+      config = await _chunkGDXB64KGjs.loadStormConfig.call(void 0, workspaceRoot);
+    }
+    if (_optionalChain([executorOptions, 'optionalAccess', _15 => _15.hooks, 'optionalAccess', _16 => _16.applyDefaultOptions])) {
+      _chunkGDXB64KGjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(executorOptions.hooks.applyDefaultOptions(options, config));
+      _chunkGDXB64KGjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
+    }
+    _chunkGDXB64KGjs.writeTrace.call(void 0, `Executor schema options \u2699\uFE0F 
+${Object.keys(options).map((key) => ` - ${key}=${_isFunction(options[key]) ? "<function>" : JSON.stringify(options[key])}`).join("\n")}`, config);
+    const tokenized = await _chunkAFPEYAYKjs.applyWorkspaceTokens.call(void 0, options, {
+      config,
+      workspaceRoot,
+      projectRoot,
+      sourceRoot,
+      projectName,
+      ...context.projectsConfigurations.projects[context.projectName],
+      ...executorOptions
+    }, _chunkUWJTAL4Wjs.applyWorkspaceExecutorTokens);
+    if (_optionalChain([executorOptions, 'optionalAccess', _17 => _17.hooks, 'optionalAccess', _18 => _18.preProcess])) {
+      _chunkGDXB64KGjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
+      await Promise.resolve(executorOptions.hooks.preProcess(tokenized, config));
+      _chunkGDXB64KGjs.writeDebug.call(void 0, "Completed the preProcess hook", config);
+    }
+    const ret = executorFn(tokenized, context, config);
+    if (_isFunction(_optionalChain([ret, 'optionalAccess', _19 => _19.next]))) {
+      const asyncGen = ret;
+      for await (const iter of asyncGen) {
+      }
+    }
+    const result = await Promise.resolve(ret);
+    if (result && (!result.success || result.error && _optionalChain([result, 'optionalAccess', _20 => _20.error, 'optionalAccess', _21 => _21.message]) && typeof _optionalChain([result, 'optionalAccess', _22 => _22.error, 'optionalAccess', _23 => _23.message]) === "string" && _optionalChain([result, 'optionalAccess', _24 => _24.error, 'optionalAccess', _25 => _25.name]) && typeof _optionalChain([result, 'optionalAccess', _26 => _26.error, 'optionalAccess', _27 => _27.name]) === "string")) {
+      _chunkGDXB64KGjs.writeTrace.call(void 0, `Failure determined by the ${name} executor 
+${_chunkGDXB64KGjs.formatLogMessage.call(void 0, result)}`, config);
+      console.error(result);
+      throw new Error(`The ${name} executor failed to run`, {
+        cause: _optionalChain([result, 'optionalAccess', _28 => _28.error])
+      });
+    }
+    if (_optionalChain([executorOptions, 'optionalAccess', _29 => _29.hooks, 'optionalAccess', _30 => _30.postProcess])) {
+      _chunkGDXB64KGjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
+      await Promise.resolve(executorOptions.hooks.postProcess(config));
+      _chunkGDXB64KGjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
+    }
+    _chunkGDXB64KGjs.writeSuccess.call(void 0, `Completed running the ${name} task executor!
+`, config);
+    return {
+      success: true
+    };
+  } catch (error) {
+    _chunkGDXB64KGjs.writeFatal.call(void 0, "A fatal error occurred while running the executor - the process was forced to terminate", config);
+    _chunkGDXB64KGjs.writeError.call(void 0, `An exception was thrown in the executor's process 
+ - Details: ${error.message}
+ - Stacktrace: ${error.stack}`, config);
+    return {
+      success: false
+    };
+  } finally {
+    stopwatch();
+  }
+}, "withRunExecutor");
+var _isFunction = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (value) => {
+  try {
+    return value instanceof Function || typeof value === "function" || !!(_optionalChain([value, 'optionalAccess', _31 => _31.constructor]) && _optionalChain([value, 'optionalAccess', _32 => _32.call]) && _optionalChain([value, 'optionalAccess', _33 => _33.apply]));
+  } catch (e) {
+    return false;
+  }
+}, "_isFunction");
+
+// src/executors/helm-package/executor.ts
+async function serveExecutor(options, context, config) {
+  if (!_optionalChain([context, 'optionalAccess', _34 => _34.projectName]) || !_optionalChain([context, 'optionalAccess', _35 => _35.projectsConfigurations, 'optionalAccess', _36 => _36.projects, 'optionalAccess', _37 => _37[context.projectName], 'optionalAccess', _38 => _38.root])) {
+    throw new Error("Nx executor context was invalid");
+  }
+  const helm = _chunk2GAU2GHGjs.createHelmClient.call(void 0, );
+  if (_optionalChain([options, 'access', _39 => _39.dependencies, 'optionalAccess', _40 => _40.repositories])) {
+    for (const repository of options.dependencies.repositories) {
+      if (repository.name && repository.url) {
+        helm.addRepository(repository.name, repository.url);
+      } else {
+        throw new Error("Repository name and url are required");
+      }
+    }
+  }
+  if (_optionalChain([options, 'access', _41 => _41.dependencies, 'optionalAccess', _42 => _42.update])) {
+    helm.dependencyUpdate(options.chartFolder);
+  }
+  if (_optionalChain([options, 'access', _43 => _43.dependencies, 'optionalAccess', _44 => _44.build])) {
+    helm.dependencyBuild(options.chartFolder);
+  }
+  const chartPath = await helm.package({
+    chartFolder: options.chartFolder,
+    outputFolder: options.outputFolder
+  });
+  if (options.push && chartPath && options.remote) {
+    helm.push({
+      chartPath,
+      remote: options.remote
+    });
+  } else {
+    _chunkGDXB64KGjs.writeWarning.call(void 0, `Chart packaged at: ${chartPath}`, config);
+  }
+  return {
+    success: true
+  };
+}
+_chunk3GQAWCBQjs.__name.call(void 0, serveExecutor, "serveExecutor");
+var executor_default = withRunExecutor("Helm Chart Package executor", serveExecutor, {
+  skipReadingConfig: false,
+  hooks: {
+    applyDefaultOptions: /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (options) => {
+      options.port ??= 4500;
+      return options;
+    }, "applyDefaultOptions")
+  }
+});
+
+
+
+
+exports.serveExecutor = serveExecutor; exports.executor_default = executor_default;