@storm-software/k8s-tools 0.25.19 → 0.25.21

package/dist/{chunk-3OATAJ3B.js → chunk-A7ARE63F.js}

@@ -1,7 +1,7 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true}); 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 _chunkOIKG7EMCjs = require('./chunk-OIKG7EMC.js');
+var _chunkDD5DCADPjs = require('./chunk-DD5DCADP.js');
 
 
 
@@ -14,61 +14,75 @@ var _chunkOIKG7EMCjs = require('./chunk-OIKG7EMC.js');
 
 
 
-var _chunkARMCUBMYjs = require('./chunk-ARMCUBMY.js');
+var _chunkUWVOFPSWjs = require('./chunk-UWVOFPSW.js');
 
 
-var _chunk2GAU2GHGjs = require('./chunk-2GAU2GHG.js');
-
-
-var _chunk3GQAWCBQjs = require('./chunk-3GQAWCBQ.js');
+var _chunk4AADQIGWjs = require('./chunk-4AADQIGW.js');
 
 // ../workspace-tools/src/base/base-executor.ts
 var _defu = require('defu');
-var withRunExecutor = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (name, executorFn, executorOptions = {}) => async (_options, context) => {
-  const stopwatch = _chunkARMCUBMYjs.getStopwatch.call(void 0, name);
+var withRunExecutor = (name, executorFn, executorOptions = {}) => async (_options, context) => {
+  const stopwatch = _chunkUWVOFPSWjs.getStopwatch.call(void 0, name);
   let options = _options;
   let config = {};
   try {
     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.");
+      throw new Error(
+        "The Build process failed because the context is not valid. Please run this command from a workspace."
+      );
     }
-    const workspaceRoot = _chunkARMCUBMYjs.findWorkspaceRoot.call(void 0, );
+    const workspaceRoot = _chunkUWVOFPSWjs.findWorkspaceRoot.call(void 0, );
     const projectRoot = context.projectsConfigurations.projects[context.projectName].root || workspaceRoot;
     const sourceRoot = context.projectsConfigurations.projects[context.projectName].sourceRoot || projectRoot || workspaceRoot;
     const projectName = context.projectName;
     config.workspaceRoot = workspaceRoot;
-    _chunkARMCUBMYjs.writeInfo.call(void 0, `\u26A1 Running the ${name} executor for ${projectName} `, config);
+    _chunkUWVOFPSWjs.writeInfo.call(void 0, `\u26A1 Running the ${name} executor for ${projectName} `, config);
     if (!executorOptions.skipReadingConfig) {
-      _chunkARMCUBMYjs.writeTrace.call(void 0, `Loading the Storm Config from environment variables and storm.config.js file...
+      _chunkUWVOFPSWjs.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 _chunkARMCUBMYjs.getConfig.call(void 0, workspaceRoot);
+`,
+        config
+      );
+      config = await _chunkUWVOFPSWjs.getConfig.call(void 0, workspaceRoot);
     }
     if (_optionalChain([executorOptions, 'optionalAccess', _3 => _3.hooks, 'optionalAccess', _4 => _4.applyDefaultOptions])) {
-      _chunkARMCUBMYjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
-      options = await Promise.resolve(executorOptions.hooks.applyDefaultOptions(options, config));
-      _chunkARMCUBMYjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
+      _chunkUWVOFPSWjs.writeDebug.call(void 0, "Running the applyDefaultOptions hook...", config);
+      options = await Promise.resolve(
+        executorOptions.hooks.applyDefaultOptions(options, config)
+      );
+      _chunkUWVOFPSWjs.writeDebug.call(void 0, "Completed the applyDefaultOptions hook", config);
     }
-    _chunkARMCUBMYjs.writeTrace.call(void 0, `Executor schema options \u2699\uFE0F
-${_chunkARMCUBMYjs.formatLogMessage.call(void 0, options)}
-`, config);
-    const tokenized = await _chunkOIKG7EMCjs.applyWorkspaceTokens.call(void 0, options, _defu.defu.call(void 0, {
-      workspaceRoot,
-      projectRoot,
-      sourceRoot,
-      projectName,
+    _chunkUWVOFPSWjs.writeTrace.call(void 0, 
+      `Executor schema options \u2699\uFE0F
+${_chunkUWVOFPSWjs.formatLogMessage.call(void 0, options)}
+`,
       config
-    }, config, context.projectsConfigurations.projects[context.projectName]), _chunkOIKG7EMCjs.applyWorkspaceProjectTokens);
-    _chunkARMCUBMYjs.writeTrace.call(void 0, `Executor schema tokenized options \u2699\uFE0F
-${_chunkARMCUBMYjs.formatLogMessage.call(void 0, tokenized)}
-`, config);
+    );
+    const tokenized = await _chunkDD5DCADPjs.applyWorkspaceTokens.call(void 0, 
+      options,
+      _defu.defu.call(void 0, 
+        { workspaceRoot, projectRoot, sourceRoot, projectName, config },
+        config,
+        context.projectsConfigurations.projects[context.projectName]
+      ),
+      _chunkDD5DCADPjs.applyWorkspaceProjectTokens
+    );
+    _chunkUWVOFPSWjs.writeTrace.call(void 0, 
+      `Executor schema tokenized options \u2699\uFE0F
+${_chunkUWVOFPSWjs.formatLogMessage.call(void 0, tokenized)}
+`,
+      config
+    );
     if (_optionalChain([executorOptions, 'optionalAccess', _5 => _5.hooks, 'optionalAccess', _6 => _6.preProcess])) {
-      _chunkARMCUBMYjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
-      await Promise.resolve(executorOptions.hooks.preProcess(tokenized, config));
-      _chunkARMCUBMYjs.writeDebug.call(void 0, "Completed the preProcess hook", config);
+      _chunkUWVOFPSWjs.writeDebug.call(void 0, "Running the preProcess hook...", config);
+      await Promise.resolve(
+        executorOptions.hooks.preProcess(tokenized, config)
+      );
+      _chunkUWVOFPSWjs.writeDebug.call(void 0, "Completed the preProcess hook", config);
     }
     const ret = executorFn(tokenized, context, config);
     if (_isFunction(_optionalChain([ret, 'optionalAccess', _7 => _7.next]))) {
@@ -77,51 +91,62 @@ ${_chunkARMCUBMYjs.formatLogMessage.call(void 0, tokenized)}
         void iter;
       }
     }
-    const result = await Promise.resolve(ret);
+    const result = await Promise.resolve(
+      ret
+    );
     if (result && (!result.success || result.error && _optionalChain([result, 'optionalAccess', _8 => _8.error, 'optionalAccess', _9 => _9.message]) && typeof _optionalChain([result, 'optionalAccess', _10 => _10.error, 'optionalAccess', _11 => _11.message]) === "string" && _optionalChain([result, 'optionalAccess', _12 => _12.error, 'optionalAccess', _13 => _13.name]) && typeof _optionalChain([result, 'optionalAccess', _14 => _14.error, 'optionalAccess', _15 => _15.name]) === "string")) {
-      _chunkARMCUBMYjs.writeTrace.call(void 0, `Failure determined by the ${name} executor 
-${_chunkARMCUBMYjs.formatLogMessage.call(void 0, result)}`, config);
+      _chunkUWVOFPSWjs.writeTrace.call(void 0, 
+        `Failure determined by the ${name} executor 
+${_chunkUWVOFPSWjs.formatLogMessage.call(void 0, result)}`,
+        config
+      );
       console.error(result);
       throw new Error(`The ${name} executor failed to run`, {
         cause: _optionalChain([result, 'optionalAccess', _16 => _16.error])
       });
     }
     if (_optionalChain([executorOptions, 'optionalAccess', _17 => _17.hooks, 'optionalAccess', _18 => _18.postProcess])) {
-      _chunkARMCUBMYjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
+      _chunkUWVOFPSWjs.writeDebug.call(void 0, "Running the postProcess hook...", config);
       await Promise.resolve(executorOptions.hooks.postProcess(config));
-      _chunkARMCUBMYjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
+      _chunkUWVOFPSWjs.writeDebug.call(void 0, "Completed the postProcess hook", config);
     }
-    _chunkARMCUBMYjs.writeSuccess.call(void 0, `Completed running the ${name} task executor!
+    _chunkUWVOFPSWjs.writeSuccess.call(void 0, `Completed running the ${name} task executor!
 `, config);
     return {
       success: true
     };
   } catch (error) {
-    _chunkARMCUBMYjs.writeFatal.call(void 0, "A fatal error occurred while running the executor - the process was forced to terminate", config);
-    _chunkARMCUBMYjs.writeError.call(void 0, `An exception was thrown in the executor's process 
+    _chunkUWVOFPSWjs.writeFatal.call(void 0, 
+      "A fatal error occurred while running the executor - the process was forced to terminate",
+      config
+    );
+    _chunkUWVOFPSWjs.writeError.call(void 0, 
+      `An exception was thrown in the executor's process 
  - Details: ${error.message}
- - Stacktrace: ${error.stack}`, config);
+ - Stacktrace: ${error.stack}`,
+      config
+    );
     return {
       success: false
     };
   } finally {
     stopwatch();
   }
-}, "withRunExecutor");
-var _isFunction = /* @__PURE__ */ _chunk3GQAWCBQjs.__name.call(void 0, (value) => {
+};
+var _isFunction = (value) => {
   try {
     return value instanceof Function || typeof value === "function" || !!(_optionalChain([value, 'optionalAccess', _19 => _19.constructor]) && _optionalChain([value, 'optionalAccess', _20 => _20.call]) && _optionalChain([value, 'optionalAccess', _21 => _21.apply]));
   } catch (e) {
     return false;
   }
-}, "_isFunction");
+};
 
 // src/executors/helm-package/executor.ts
 async function serveExecutor(options, context, config) {
   if (!_optionalChain([context, 'optionalAccess', _22 => _22.projectName]) || !_optionalChain([context, 'optionalAccess', _23 => _23.projectsConfigurations, 'optionalAccess', _24 => _24.projects, 'optionalAccess', _25 => _25[context.projectName], 'optionalAccess', _26 => _26.root])) {
     throw new Error("Nx executor context was invalid");
   }
-  const helm = _chunk2GAU2GHGjs.createHelmClient.call(void 0, );
+  const helm = _chunk4AADQIGWjs.createHelmClient.call(void 0, );
   if (_optionalChain([options, 'access', _27 => _27.dependencies, 'optionalAccess', _28 => _28.repositories])) {
     for (const repository of options.dependencies.repositories) {
       if (repository.name && repository.url) {
@@ -147,22 +172,25 @@ async function serveExecutor(options, context, config) {
       remote: options.remote
     });
   } else {
-    _chunkARMCUBMYjs.writeWarning.call(void 0, `Chart packaged at: ${chartPath}`, config);
+    _chunkUWVOFPSWjs.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")
+var executor_default = withRunExecutor(
+  "Helm Chart Package executor",
+  serveExecutor,
+  {
+    skipReadingConfig: false,
+    hooks: {
+      applyDefaultOptions: (options) => {
+        options.port ??= 4500;
+        return options;
+      }
+    }
   }
-});
+);
 
 
 

package/dist/chunk-ARIMP3W4.mjs

@@ -0,0 +1,155 @@
+// ../workspace-tools/src/utils/package-helpers.ts
+import {
+  joinPathFragments,
+  readJsonFile
+} from "@nx/devkit";
+import { existsSync } from "node:fs";
+
+// ../workspace-tools/src/utils/project-tags.ts
+var ProjectTagConstants = {
+  Language: {
+    TAG_ID: "language",
+    TYPESCRIPT: "typescript",
+    RUST: "rust"
+  },
+  ProjectType: {
+    TAG_ID: "type",
+    LIBRARY: "library",
+    APPLICATION: "application"
+  },
+  DistStyle: {
+    TAG_ID: "dist-style",
+    NORMAL: "normal",
+    CLEAN: "clean"
+  },
+  Provider: {
+    TAG_ID: "provider"
+  },
+  Platform: {
+    TAG_ID: "platform",
+    NODE: "node",
+    BROWSER: "browser",
+    NEUTRAL: "neutral",
+    WORKER: "worker"
+  },
+  Registry: {
+    TAG_ID: "registry",
+    CARGO: "cargo",
+    NPM: "npm",
+    CONTAINER: "container",
+    CYCLONE: "cyclone"
+  },
+  Plugin: {
+    TAG_ID: "plugin"
+  }
+};
+var formatProjectTag = (variant, value) => {
+  return `${variant}:${value}`;
+};
+var hasProjectTag = (project, variant) => {
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  return project.tags.some(
+    (tag) => tag.startsWith(prefix) && tag.length > prefix.length
+  );
+};
+var getProjectTag = (project, variant) => {
+  if (!hasProjectTag(project, variant)) {
+    return void 0;
+  }
+  project.tags = project.tags ?? [];
+  const prefix = formatProjectTag(variant, "");
+  const tag = project.tags.find((tag2) => tag2.startsWith(prefix));
+  return tag?.replace(prefix, "");
+};
+var isEqualProjectTag = (project, variant, value) => {
+  const tag = getProjectTag(project, variant);
+  return !!(tag && tag?.toUpperCase() === value.toUpperCase());
+};
+var addProjectTag = (project, variant, value, options = {
+  overwrite: false
+}) => {
+  project.tags = project.tags ?? [];
+  if (options.overwrite || !hasProjectTag(project, variant)) {
+    project.tags = project.tags.filter(
+      (tag) => !tag.startsWith(formatProjectTag(variant, ""))
+    );
+    project.tags.push(formatProjectTag(variant, value));
+  }
+};
+var addPluginProjectTag = (project, plugin) => {
+  project.tags = project.tags ?? [];
+  project.tags.push(
+    formatProjectTag(ProjectTagConstants.Plugin.TAG_ID, plugin)
+  );
+};
+var setDefaultProjectTags = (project, plugin) => {
+  project.tags = project.tags ?? [];
+  addProjectTag(
+    project,
+    ProjectTagConstants.ProjectType.TAG_ID,
+    project.projectType === "application" ? ProjectTagConstants.ProjectType.APPLICATION : ProjectTagConstants.ProjectType.LIBRARY,
+    { overwrite: true }
+  );
+  addProjectTag(
+    project,
+    ProjectTagConstants.DistStyle.TAG_ID,
+    project.targets && Object.keys(project.targets).includes("clean-package") ? ProjectTagConstants.DistStyle.CLEAN : ProjectTagConstants.DistStyle.NORMAL,
+    { overwrite: true }
+  );
+  addProjectTag(
+    project,
+    ProjectTagConstants.Platform.TAG_ID,
+    project.targets?.build?.options.platform === "node" ? ProjectTagConstants.Platform.NODE : project.targets?.build?.options.platform === "worker" ? ProjectTagConstants.Platform.WORKER : project.targets?.build?.options.platform === "browser" ? ProjectTagConstants.Platform.BROWSER : ProjectTagConstants.Platform.NEUTRAL,
+    { overwrite: false }
+  );
+  if (plugin) {
+    addPluginProjectTag(project, plugin);
+  }
+};
+
+// ../workspace-tools/src/utils/toml.ts
+import TOML from "@ltd/j-toml";
+import { logger } from "@nx/devkit";
+function parseCargoToml(cargoString) {
+  if (!cargoString) {
+    throw new Error("Cargo.toml is empty");
+  }
+  return TOML.parse(cargoString, {
+    x: { comment: true }
+  });
+}
+
+// ../workspace-tools/src/utils/package-helpers.ts
+var getPackageInfo = (project) => {
+  if (isEqualProjectTag(
+    project,
+    ProjectTagConstants.Language.TAG_ID,
+    ProjectTagConstants.Language.RUST
+  ) && existsSync(joinPathFragments(project.root, "Cargo.toml"))) {
+    return {
+      type: "Cargo.toml",
+      content: parseCargoToml(joinPathFragments(project.root, "Cargo.toml"))
+    };
+  } else if (isEqualProjectTag(
+    project,
+    ProjectTagConstants.Language.TAG_ID,
+    ProjectTagConstants.Language.TYPESCRIPT
+  ) && existsSync(joinPathFragments(project.root, "package.json"))) {
+    return {
+      type: "package.json",
+      content: readJsonFile(
+        joinPathFragments(project.root, "package.json")
+      )
+    };
+  }
+  return null;
+};
+
+export {
+  ProjectTagConstants,
+  hasProjectTag,
+  isEqualProjectTag,
+  setDefaultProjectTags,
+  getPackageInfo
+};

package/dist/{chunk-TNVATOCF.mjs → chunk-BBY7MXHG.mjs}

@@ -1,22 +1,22 @@
 import {
   getPackageInfo
-} from "./chunk-5JZUTREX.mjs";
+} from "./chunk-ARIMP3W4.mjs";
 import {
   applyWorkspaceTokens
-} from "./chunk-QKTRYJDT.mjs";
+} from "./chunk-MDGD27YL.mjs";
 import {
   findWorkspaceRoot,
   getConfig
-} from "./chunk-F37JQGEZ.mjs";
-import {
-  __name
-} from "./chunk-L2DHGVS5.mjs";
+} from "./chunk-MWMS7P7U.mjs";
 
 // src/executors/container-publish/executor.ts
-import { parseTargetString, runExecutor } from "@nx/devkit";
+import {
+  parseTargetString,
+  runExecutor
+} from "@nx/devkit";
 
 // ../workspace-tools/src/utils/apply-workspace-tokens.ts
-var applyWorkspaceExecutorTokens = /* @__PURE__ */ __name(async (option, tokenizerOptions) => {
+var applyWorkspaceExecutorTokens = async (option, tokenizerOptions) => {
   let result = option;
   if (!result) {
     return result;
@@ -44,7 +44,10 @@ var applyWorkspaceExecutorTokens = /* @__PURE__ */ __name(async (option, tokeniz
     if (configKeys.some((configKey) => result.includes(`{${configKey}}`))) {
       for (const configKey of configKeys) {
         if (result.includes(`{${configKey}}`)) {
-          result = result.replaceAll(`{${configKey}}`, tokenizerOptions.config[configKey]);
+          result = result.replaceAll(
+            `{${configKey}}`,
+            tokenizerOptions.config[configKey]
+          );
         }
       }
     }
@@ -59,10 +62,13 @@ var applyWorkspaceExecutorTokens = /* @__PURE__ */ __name(async (option, tokeniz
     result = result.replaceAll("{sourceRoot}", sourceRoot);
   }
   if (result.includes("{workspaceRoot}")) {
-    result = result.replaceAll("{workspaceRoot}", tokenizerOptions.workspaceRoot ?? findWorkspaceRoot());
+    result = result.replaceAll(
+      "{workspaceRoot}",
+      tokenizerOptions.workspaceRoot ?? findWorkspaceRoot()
+    );
   }
   return result;
-}, "applyWorkspaceExecutorTokens");
+};
 
 // src/executors/container-publish/executor.ts
 import https from "node:https";
@@ -71,30 +77,40 @@ async function* publishExecutor(options, context) {
   if (!context.projectName) {
     throw new Error("The executor requires a projectName.");
   }
-  console.info(`\u{1F680}  Running Storm Container Registry Publish executor on the ${context.projectName} crate`);
+  console.info(
+    `\u{1F680}  Running Storm Container Registry Publish executor on the ${context.projectName} crate`
+  );
   const workspaceRoot = findWorkspaceRoot();
   const config = await getConfig(workspaceRoot);
   const projectConfig = context.projectsConfigurations?.projects[context.projectName];
   if (!projectConfig) {
-    throw new Error(`The executor requires a valid projectsConfiguration - No configuration found for project ${context.projectName}`);
+    throw new Error(
+      `The executor requires a valid projectsConfiguration - No configuration found for project ${context.projectName}`
+    );
   }
   const projectRoot = projectConfig?.root ?? workspaceRoot;
   const sourceRoot = projectConfig?.sourceRoot ?? workspaceRoot;
   const projectName = projectConfig?.name ?? context.projectName;
   config.workspaceRoot = workspaceRoot;
-  const tokenized = await applyWorkspaceTokens(options, {
-    config,
-    workspaceRoot,
-    projectRoot,
-    sourceRoot,
-    projectName,
-    ...projectConfig
-  }, applyWorkspaceExecutorTokens);
+  const tokenized = await applyWorkspaceTokens(
+    options,
+    {
+      config,
+      workspaceRoot,
+      projectRoot,
+      sourceRoot,
+      projectName,
+      ...projectConfig
+    },
+    applyWorkspaceExecutorTokens
+  );
   tokenized.engine ??= "docker";
   tokenized.registry ??= config.registry.container;
   try {
     if (isDryRun) {
-      console.log(`Would publish to ${tokenized.registry}, but [dry-run] was set`);
+      console.log(
+        `Would publish to ${tokenized.registry}, but [dry-run] was set`
+      );
     } else {
       console.log(`Published to ${tokenized.registry}`);
       const packageManager = getPackageInfo(projectConfig);
@@ -118,25 +134,30 @@ async function* publishExecutor(options, context) {
         tokenized["labels"].push(`org.opencontainers.image.version=${version}`);
         const tags = await getRegistryVersion(projectName, config);
         if (tags.length === 0) {
-          tokenized["labels"].push(`org.opencontainers.image.created=${(/* @__PURE__ */ new Date()).toISOString()}`);
+          tokenized["labels"].push(
+            `org.opencontainers.image.created=${(/* @__PURE__ */ new Date()).toISOString()}`
+          );
         } else if (tags.includes(version)) {
-          console.warn(`Skipped package "${projectName}" because v${version} already exists in ${tokenized.registry}`);
+          console.warn(
+            `Skipped package "${projectName}" because v${version} already exists in ${tokenized.registry}`
+          );
           return {
             success: true
           };
         }
       } else {
-        console.warn(`No package manager found for project "${projectName}" - Skipping container publishing`);
+        console.warn(
+          `No package manager found for project "${projectName}" - Skipping container publishing`
+        );
         return {
           success: true
         };
       }
-      const { project, target, configuration } = parseTargetString("container", context);
-      for await (const output of await runExecutor({
-        project,
-        target,
-        configuration
-      }, tokenized, context)) {
+      const { project, target, configuration } = parseTargetString(
+        "container",
+        context
+      );
+      for await (const output of await runExecutor({ project, target, configuration }, tokenized, context)) {
         if (!output.success) {
           throw new Error("Could not compile application files");
         }
@@ -155,39 +176,57 @@ async function* publishExecutor(options, context) {
     };
   }
 }
-__name(publishExecutor, "publishExecutor");
-var getRegistryVersion = /* @__PURE__ */ __name((name, config) => {
+var getRegistryVersion = (name, config) => {
   if (!name) {
-    throw new Error("The `getRegistryVersion` function requires a container name.");
+    throw new Error(
+      "The `getRegistryVersion` function requires a container name."
+    );
   }
   try {
-    const tagsApiUrl = `${config.registry.container}/v2/namespaces/${encodeURIComponent(config.namespace ? config.namespace : "storm-software")}/repositories/${encodeURIComponent(name.replace(`${config.namespace}-`, ""))}/tags`;
+    const tagsApiUrl = `${config.registry.container}/v2/namespaces/${encodeURIComponent(config.namespace ? config.namespace : "storm-software")}/repositories/${encodeURIComponent(
+      name.replace(`${config.namespace}-`, "")
+    )}/tags`;
     console.log(`Checking for existing version at ${tagsApiUrl}`);
-    return new Promise((resolve, reject) => https.get(tagsApiUrl, (res) => {
-      if (res.statusCode === 404) {
-        console.log(`No existing version found at ${tagsApiUrl}`);
-        return resolve([]);
-      }
-      res.on("data", (data) => {
-        if (data) {
-          console.log(`Existing versions found at ${tagsApiUrl} - ${data}`);
-          const json = JSON.parse(data.toString());
-          return resolve(json.results.filter((result) => result.status === "active" && result.name && result.name !== "latest").map((result) => result.name));
+    return new Promise(
+      (resolve, reject) => https.get(tagsApiUrl, (res) => {
+        if (res.statusCode === 404) {
+          console.log(`No existing version found at ${tagsApiUrl}`);
+          return resolve([]);
         }
-        return reject(new Error("No data returned from container registry, expected a 404 if no tags exist"));
-      });
-    }).on("error", (e) => {
-      throw e;
-    }));
+        res.on("data", (data) => {
+          if (data) {
+            console.log(
+              `Existing versions found at ${tagsApiUrl} - ${data}`
+            );
+            const json = JSON.parse(data.toString());
+            return resolve(
+              json.results.filter(
+                (result) => result.status === "active" && result.name && result.name !== "latest"
+              ).map((result) => result.name)
+            );
+          }
+          return reject(
+            new Error(
+              "No data returned from container registry, expected a 404 if no tags exist"
+            )
+          );
+        });
+      }).on("error", (e) => {
+        throw e;
+      })
+    );
   } catch (error) {
     console.error(`Failed to get version from ${config.registry.container}`);
     console.error(error);
     console.log("");
-    throw new Error(`Could not get version from container registry - ${config.registry.container}`, {
-      cause: error
-    });
+    throw new Error(
+      `Could not get version from container registry - ${config.registry.container}`,
+      {
+        cause: error
+      }
+    );
   }
-}, "getRegistryVersion");
+};
 
 export {
   publishExecutor,