Update files on build (#439)

* Update fileson build

* Update tests

* Edit external images on compose update

* Add isMultiVariant variable

src/commands/publish/handler.ts

@@ -37,6 +37,7 @@ export async function publishHandler({
 }: PublishCommandOptions): Promise<ListrContextPublish> {
   let ethProvider = provider || eth_provider;
   let contentProvider = provider || content_provider;
+  const isMultiVariant = Boolean(allVariants) || Boolean(variants);
 
   const isCi = process.env.CI;
 
@@ -80,7 +81,8 @@ export async function publishHandler({
         rootDir: dir,
         variantsDirName,
         composeFileName
-      })
+      }),
+      isMultiVariant
     }),
     verbosityOptions
   );

src/params.ts

@@ -3,8 +3,8 @@ import { ManifestFormat } from "./files/manifest/types.js";
 
 export * from "./files/compose/params.js";
 
-export class CliError extends Error {}
-export class YargsError extends Error {}
+export class CliError extends Error { }
+export class YargsError extends Error { }
 
 // Github Actions params
 
@@ -14,6 +14,7 @@ export const branchNameRoot = "dappnodebot/bump-upstream/";
 
 export const defaultDir = "./";
 export const defaultVariantsDirName = "package_variants";
+export const singleVariantName = "single-variant";
 // This is the default name of the environment variable that will be used to select each of the variants
 export const defaultVariantsEnvName = "NETWORK";
 export const defaultVariantsEnvValues = ["mainnet", "testnet"];

src/tasks/buildAndUpload/buildVariantMap.ts

@@ -1,14 +1,13 @@
 import path from "path";
 import { parseArchitectures } from "../../utils/parseArchitectures.js";
 import {
-  getComposePath,
   readCompose,
   getComposePackageImages,
   parseComposeUpstreamVersion,
   readManifest
 } from "../../files/index.js";
 import { Compose, Manifest } from "@dappnode/types";
-import { defaultComposeFileName } from "../../params.js";
+import { defaultComposeFileName, singleVariantName } from "../../params.js";
 import { BuildVariantsMap, BuildVariantsMapEntry } from "../../types.js";
 
 export function buildVariantMap({
@@ -23,7 +22,7 @@ export function buildVariantMap({
   composeFileName?: string;
 }): BuildVariantsMap {
   if (!variants || variants.length === 0)
-    return { default: createVariantMapEntry({ rootDir, composeFileName }) };
+    return { [singleVariantName]: createVariantMapEntry({ rootDir, composeFileName }) };
 
   const map: BuildVariantsMap = {};
 
@@ -48,35 +47,31 @@ export function createVariantMapEntry({
   composeFileName: string;
   variantPath?: string;
 }): BuildVariantsMapEntry {
-  const { manifest, format } = variantPath
-    ? readManifest([{ dir: rootDir }, { dir: variantPath }])
-    : readManifest([{ dir: rootDir }]);
+  const manifestPaths = [{ dir: rootDir }];
+  const composePaths = [{ dir: rootDir, composeFileName }];
 
-  const { name: dnpName, version } = manifest;
-
-  const composePaths = [getComposePath({ dir: rootDir, composeFileName })];
+  if (variantPath) {
+    manifestPaths.push({ dir: variantPath });
+    composePaths.push({ dir: variantPath, composeFileName });
+  }
 
-  if (variantPath)
-    composePaths.push(getComposePath({ dir: variantPath, composeFileName }));
+  const { manifest, format: manifestFormat } = readManifest(manifestPaths);
+  const compose = readCompose(composePaths);
 
-  const compose = variantPath
-    ? readCompose([
-      { dir: rootDir, composeFileName },
-      { dir: variantPath, composeFileName }
-    ])
-    : readCompose([{ dir: rootDir, composeFileName }]);
+  const { name: dnpName, version } = manifest;
 
   // TODO: Handle upstream object defined case
   if (!manifest.upstream)
     manifest.upstreamVersion = getUpstreamVersion({ compose, manifest });
 
   return {
     manifest,
-    manifestFormat: format,
+    manifestFormat,
 
     compose,
 
     releaseDir: getReleaseDirPath({ rootDir, dnpName, version }),
+    manifestPaths,
     composePaths,
 
     images: getComposePackageImages(compose, manifest),

src/tasks/buildAndUpload/getFileValidationTask.ts

@@ -6,7 +6,7 @@ import {
   validateSetupWizardSchema,
   validateDappnodeCompose
 } from "@dappnode/schemas";
-import { readSetupWizardIfExists } from "../../files/index.js";
+import { getComposePath, readSetupWizardIfExists } from "../../files/index.js";
 import { CliError } from "../../params.js";
 
 export function getFileValidationTask({
@@ -53,7 +53,7 @@ async function validateVariantFiles(
   validatePackageVersion(manifest.version);
 
   // Validate compose file using docker compose
-  await validateComposeSchema(composePaths);
+  await validateComposeSchema(composePaths.map(pathObj => getComposePath(pathObj)));
 
   // Validate compose file specifically for Dappnode requirements
   validateDappnodeCompose(compose, manifest);

src/tasks/buildAndUpload/getSaveUploadResultsTask.ts

@@ -9,51 +9,32 @@ export function getSaveUploadResultsTask({
   rootDir,
   variantsDirPath,
   contentProvider,
-  skipUpload
+  skipUpload,
+  isMultiVariant
 }: {
   variantsMap: BuildVariantsMap;
   rootDir: string;
   variantsDirPath: string;
   contentProvider: string;
   skipUpload?: boolean;
+  isMultiVariant?: boolean;
 }): ListrTask<ListrContextBuild> {
   return {
     title: "Save upload results",
     skip: () => skipUpload,
     task: async ctx => {
-      // Single package
-      if (variantsMap.default) {
-        const { name, version } = variantsMap.default.manifest;
-        const { releaseMultiHash: hash } = ctx[name];
-
-        if (hash)
-          addReleaseRecord({
-            dir: rootDir,
-            version,
-            hash,
-            to: contentProvider
-          });
 
-        // Multi-variant package
-      } else {
-        for (const [
-          variant,
-          {
-            manifest: { name, version }
-          }
-        ] of Object.entries(variantsMap)) {
-          const variantDir = path.join(variantsDirPath, variant);
-          const { releaseMultiHash: hash } = ctx[name];
+      for (const [variant, { manifest: { name, version } }] of Object.entries(variantsMap)) {
+        const { releaseMultiHash: hash } = ctx[name];
 
-          if (!hash) continue;
+        if (!hash) continue;
 
-          addReleaseRecord({
-            dir: variantDir,
-            version,
-            hash,
-            to: contentProvider
-          });
-        }
+        addReleaseRecord({
+          dir: isMultiVariant ? path.join(variantsDirPath, variant) : rootDir,
+          version,
+          hash,
+          to: contentProvider
+        });
       }
 
       try {

src/tasks/publish/index.ts

@@ -1,11 +1,12 @@
 import { ListrTask } from "listr";
 import { PublishOptions } from "./types.js";
 import { ListrContextPublish } from "../../types.js";
-import { getFetchApmVersionsTask } from "./subtasks/getFetchApmVersionsTask.js";
+import { getFetchNextVersionsFromApmTask } from "./subtasks/getFetchApmVersionsTask.js";
 import { getBuildAndUploadTask } from "./subtasks/getBuildAndUploadTask.js";
 import { getGenerateTxTask } from "./subtasks/getGenerateTxsTask.js";
 import { getCreateGithubReleaseTask } from "./subtasks/getCreateGithubReleaseTask.js";
 import { getVerifyEthConnectionTask } from "./subtasks/getVerifyEthConnectionTask.js";
+import { getUpdateFilesTask } from "./subtasks/getUpdateFilesTask.js";
 
 export function publish({
   releaseType,
@@ -21,17 +22,22 @@ export function publish({
   githubRelease,
   verbosityOptions,
   variantsDirPath,
-  variantsMap
+  variantsMap,
+  isMultiVariant
 }: PublishOptions): ListrTask<ListrContextPublish>[] {
   return [
     getVerifyEthConnectionTask({ ethProvider }),
-    getFetchApmVersionsTask({
+    getFetchNextVersionsFromApmTask({
       releaseType,
       ethProvider,
+      variantsMap
+    }),
+    getUpdateFilesTask({
       rootDir: dir,
       variantsDirPath,
       composeFileName,
-      variantsMap
+      variantsMap,
+      isMultiVariant
     }),
     getBuildAndUploadTask({
       buildOptions: {