Implement notifications release file (#453)

* copy notifications file in variants dir

* remove unnecessary changes

* validate notifications file

* validate files props

* fix buildVariantMap test

---------

Co-authored-by: Pablo Mendez <pablo@dappnode.io>
Co-authored-by: Marketen <marcfont12@gmail.com>

Author: 3 people

src/files/index.ts

@@ -1,3 +1,4 @@
 export * from "./compose/index.js";
 export * from "./manifest/index.js";
 export * from "./setupWizard/index.js";
+export * from "./notifications/index.js";

src/files/manifest/index.ts

@@ -4,3 +4,4 @@ export { getRepoSlugFromManifest } from "./getRepoSlugFromManifest.js";
 export { readManifest } from "./readManifest.js";
 export { writeManifest } from "./writeManifest.js";
 export { stringifyJson } from "./stringifyJson.js";
+export { ManifestFormat, ManifestPaths } from "./types.js";

src/files/notifications/index.ts

@@ -0,0 +1,2 @@
+export { readNotificationsIfExists } from "./readNotificationsIfExists.js";
+export { NotificationsFormat, NotificationsPaths } from "./types.js";

src/files/notifications/readNotificationsIfExists.ts

@@ -0,0 +1,65 @@
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { defaultDir } from "../../params.js";
+import { readFile } from "../../utils/file.js";
+import { NotificationsConfig, releaseFiles } from "@dappnode/types";
+import { merge } from "lodash-es";
+import { NotificationsPaths } from "./types.js";
+
+/**
+ * Reads one or multiple notifications YAML files and merges them. Returns null if none exist.
+ * @param {NotificationsPaths[]} paths - Optional array of directory/file specs.
+ * @returns {NotificationsConfig | null}
+ * @throws {Error} Throws if parsing fails or non-YAML format is encountered.
+ */
+export function readNotificationsIfExists(
+  paths?: NotificationsPaths[]
+): NotificationsConfig | null {
+  try {
+    // Determine list of specs (default single spec if none provided)
+    const specs = paths && paths.length > 0 ? paths : [{}];
+
+    // Resolve existing file paths
+    const filePaths = specs
+      .map(spec => {
+        try {
+          return findNotificationsPath(spec);
+        } catch {
+          return undefined;
+        }
+      })
+      .filter((p): p is string => typeof p === "string");
+
+    if (filePaths.length === 0) return null;
+
+    // Load and validate YAML-only files
+    const configs = filePaths.map(fp => {
+      if (!/\.(yml|yaml)$/i.test(fp))
+        throw new Error("Only YAML format supported for notifications: " + fp);
+      const data = readFile(fp);
+      const parsed = yaml.load(data);
+      if (!parsed || typeof parsed === "string")
+        throw new Error(`Could not parse notifications: ${fp}`);
+      return parsed as NotificationsConfig;
+    });
+
+    // Merge all configurations
+    return merge({}, ...configs);
+  } catch (e) {
+    throw new Error(`Error parsing notifications: ${e.message}`);
+  }
+}
+
+// Find a notifications file, throws if not found
+function findNotificationsPath(spec?: NotificationsPaths): string {
+  const dirPath = spec?.dir || defaultDir;
+  if (spec?.notificationsFileName) {
+    return path.join(dirPath, spec.notificationsFileName);
+  }
+  const files: string[] = fs.readdirSync(dirPath);
+  const match = files.find(f => releaseFiles.notifications.regex.test(f));
+  if (!match)
+    throw new Error(`No notifications file found in directory ${dirPath}`);
+  return path.join(dirPath, match);
+}

src/files/notifications/types.ts

@@ -0,0 +1,12 @@
+export enum NotificationsFormat {
+  json = "json",
+  yml = "yml",
+  yaml = "yaml"
+}
+
+export interface NotificationsPaths {
+  /** './folder', [optional] directory to load the notifications from */
+  dir?: string;
+  /** 'notifications-admin.json', [optional] name of the notifications file */
+  notificationsFileName?: string;
+}

src/files/setupWizard/index.ts

@@ -1 +1,2 @@
 export { readSetupWizardIfExists } from "./readSetupWizardIfExists.js";
+export { SetupWizardFormat, SetupWizardPaths } from "./types.js";

src/files/setupWizard/readSetupWizardIfExists.ts

@@ -1,23 +1,64 @@
 import fs from "fs";
 import path from "path";
 import yaml from "js-yaml";
+import { merge } from "lodash-es";
 import { defaultDir } from "../../params.js";
 import { readFile } from "../../utils/file.js";
 import { SetupWizard, releaseFiles } from "@dappnode/types";
+import { SetupWizardPaths } from "./types.js";
 
-export function readSetupWizardIfExists(dir?: string): SetupWizard | null {
-  const dirPath = dir || defaultDir;
-  const setupWizardFileName = fs
-    .readdirSync(dirPath)
-    .find(file => releaseFiles.setupWizard.regex.test(file));
+/**
+ * Reads one or multiple setup-wizard YAML files and merges them. Returns null if none exist.
+ * @param {SetupWizardPaths[]} paths - Optional array of directory/file specs.
+ * @returns {SetupWizard | null}
+ * @throws {Error} Throws if parsing fails or non-YAML format is encountered.
+ */
+export function readSetupWizardIfExists(
+  paths?: SetupWizardPaths[]
+): SetupWizard | null {
+  try {
+    // Determine list of file specs (default spec if no paths provided)
+    const specs = paths && paths.length > 0 ? paths : [{}];
 
-  if (!setupWizardFileName) return null;
-  const data = readFile(path.join(dirPath, setupWizardFileName));
+    // Resolve existing file paths
+    const filePaths = specs
+      .map(spec => {
+        try {
+          return findSetupWizardPath(spec);
+        } catch {
+          return undefined;
+        }
+      })
+      .filter((p): p is string => typeof p === "string");
 
-  // Parse setupWizard in try catch block to show a comprehensive error message
-  try {
-    return yaml.load(data);
+    if (filePaths.length === 0) return null;
+
+    // Load and validate YAML-only files
+    const wizards = filePaths.map(fp => {
+      if (!/\.(yml|yaml)$/i.test(fp))
+        throw new Error("Only YAML format supported for setup-wizard: " + fp);
+      const data = readFile(fp);
+      const parsed = yaml.load(data);
+      if (!parsed || typeof parsed === "string")
+        throw new Error(`Could not parse setup-wizard: ${fp}`);
+      return parsed as SetupWizard;
+    });
+
+    // Merge all specs
+    return merge({}, ...wizards);
   } catch (e) {
-    throw Error(`Error parsing setup-wizard: ${e.message}`);
+    throw new Error(`Error parsing setup-wizard: ${e.message}`);
   }
 }
+
+// Find a setup-wizard file, throws if not found
+function findSetupWizardPath(spec?: SetupWizardPaths): string {
+  const dirPath = spec?.dir || defaultDir;
+  if (spec?.setupWizardFileName)
+    return path.join(dirPath, spec.setupWizardFileName);
+  const files: string[] = fs.readdirSync(dirPath);
+  const match = files.find(f => releaseFiles.setupWizard.regex.test(f));
+  if (!match)
+    throw new Error(`No setup-wizard file found in directory ${dirPath}`);
+  return path.join(dirPath, match);
+}

src/files/setupWizard/types.ts

@@ -0,0 +1,12 @@
+export enum SetupWizardFormat {
+  json = "json",
+  yml = "yml",
+  yaml = "yaml"
+}
+
+export interface SetupWizardPaths {
+  /** './folder', [optional] directory to load the setup-wizard from */
+  dir?: string;
+  /** 'setup-wizard-admin.json', [optional] name of the setup-wizard file */
+  setupWizardFileName?: string;
+}

src/tasks/buildAndUpload/generatePackagesProps.ts

@@ -4,7 +4,9 @@ import {
   readCompose,
   getComposePackageImages,
   parseComposeUpstreamVersion,
-  readManifest
+  readManifest,
+  readNotificationsIfExists,
+  readSetupWizardIfExists
 } from "../../files/index.js";
 import { Compose, Manifest } from "@dappnode/types";
 import { defaultComposeFileName } from "../../params.js";
@@ -22,9 +24,16 @@ export function generatePackagesProps({
   composeFileName?: string;
 }): PackageToBuildProps[] {
   if (variants === null)
-    return [createPackagePropsItem({ rootDir, composeFileName, variant: null, variantsDirPath })];
-
-  return variants.map((variant) =>
+    return [
+      createPackagePropsItem({
+        rootDir,
+        composeFileName,
+        variant: null,
+        variantsDirPath
+      })
+    ];
+
+  return variants.map(variant =>
     createPackagePropsItem({
       rootDir,
       composeFileName,
@@ -47,16 +56,22 @@ function createPackagePropsItem({
 }): PackageToBuildProps {
   const manifestPaths = [{ dir: rootDir }];
   const composePaths = [{ dir: rootDir, composeFileName }];
+  const notificationsPaths = [{ dir: rootDir }];
+  const setupWizardPaths = [{ dir: rootDir }];
 
   if (variant) {
     const variantPath = path.join(variantsDirPath, variant);
 
     manifestPaths.push({ dir: variantPath });
     composePaths.push({ dir: variantPath, composeFileName });
+    notificationsPaths.push({ dir: variantPath });
+    setupWizardPaths.push({ dir: variantPath });
   }
 
   const { manifest, format: manifestFormat } = readManifest(manifestPaths);
   const compose = readCompose(composePaths);
+  const notifications = readNotificationsIfExists(notificationsPaths);
+  const setupWizard = readSetupWizardIfExists(setupWizardPaths);
 
   const { name: dnpName, version } = manifest;
 
@@ -66,18 +81,17 @@ function createPackagePropsItem({
 
   return {
     variant,
-
     manifest,
     manifestFormat,
-
     compose,
-
+    notifications,
+    setupWizard,
     releaseDir: getReleaseDirPath({ rootDir, dnpName, version }),
     manifestPaths,
     composePaths,
-
+    notificationsPaths,
+    setupWizardPaths,
     images: getComposePackageImages(compose, manifest),
-
     architectures: parseArchitectures({
       rawArchs: manifest.architectures
     })

src/tasks/buildAndUpload/getFileCopyTask.ts

@@ -111,6 +111,17 @@ async function copyVariantFilesToReleaseDir({
         }
         break;
 
+      case "notifications":
+        // Copy the notifications in root and in the variant dir
+        for (const dir of dirsToCopy) {
+          copyReleaseFile({
+            fileConfig: { ...fileConfig, id: fileId },
+            fromDir: dir,
+            toDir: releaseDir
+          });
+        }
+        break;
+
       default:
         copyReleaseFile({
           fileConfig: { ...fileConfig, id: fileId },