validate files props

Author: Pablo Mendez

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

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

src/files/notifications/readNotificationsIfExists.ts

@@ -3,21 +3,63 @@ 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 { NotificationsConfig, releaseFiles } from "@dappnode/types";
+import { merge } from "lodash-es";
+import { NotificationsPaths } from "./types.js";
 
-export function readNotificationsIfExists(dir?: string): NotificationsConfig | null {
-  const dirPath = dir || defaultDir;
-  const notificationsFileName = fs
-    .readdirSync(dirPath)
-    .find(file => releaseFiles.notifications.regex.test(file));
+/**
+ * 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 : [{}];
 
-  if (!notificationsFileName) return null;
-  const data = readFile(path.join(dirPath, notificationsFileName));
+    // Resolve existing file paths
+    const filePaths = specs
+      .map(spec => {
+        try {
+          return findNotificationsPath(spec);
+        } catch {
+          return undefined;
+        }
+      })
+      .filter((p): p is string => typeof p === "string");
 
-  // Parse notifications 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 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 Error(`Error parsing notifications: ${e.message}`);
+    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/getFileValidationTask.ts

@@ -7,43 +7,39 @@ import {
   validateDappnodeCompose,
   validateNotificationsSchema
 } from "@dappnode/schemas";
-import { getComposePath, readNotificationsIfExists, readSetupWizardIfExists } from "../../files/index.js";
+import { getComposePath } from "../../files/index.js";
 import { CliError } from "../../params.js";
 
 export function getFileValidationTask({
-  packagesToBuildProps,
-  rootDir
+  packagesToBuildProps
 }: {
   packagesToBuildProps: PackageToBuildProps[];
-  rootDir: string;
 }): ListrTask<ListrContextBuild> {
   return {
     title: `Validate files`,
-    task: async () => await validatePackageFiles({ packagesToBuildProps, rootDir })
+    task: async () => await validatePackageFiles({ packagesToBuildProps })
   };
 }
 
 async function validatePackageFiles({
-  packagesToBuildProps,
-  rootDir
+  packagesToBuildProps
 }: {
   packagesToBuildProps: PackageToBuildProps[];
-  rootDir: string;
 }): Promise<void> {
-  const setupWizard = readSetupWizardIfExists(rootDir);
-  if (setupWizard) validateSetupWizardSchema(setupWizard);
-
-  const notifications = readNotificationsIfExists(rootDir);
-  if (notifications) validateNotificationsSchema(notifications);
-
   for (const pkgProps of packagesToBuildProps)
     await validateVariantFiles(pkgProps);
 }
 
 async function validateVariantFiles(
   pkgProps: PackageToBuildProps
 ): Promise<void> {
-  const { manifest, compose, composePaths } = pkgProps;
+  const {
+    manifest,
+    compose,
+    composePaths,
+    notifications,
+    setupWizard
+  } = pkgProps;
 
   console.log(
     `Validating files for ${manifest.name} (version ${manifest.version})`
@@ -56,10 +52,18 @@ async function validateVariantFiles(
   validatePackageVersion(manifest.version);
 
   // Validate compose file using docker compose
-  await validateComposeSchema(composePaths.map(pathObj => getComposePath(pathObj)));
+  await validateComposeSchema(
+    composePaths.map(pathObj => getComposePath(pathObj))
+  );
 
   // Validate compose file specifically for Dappnode requirements
   validateDappnodeCompose(compose, manifest);
+
+  // Validate notifications schema
+  if (notifications) validateNotificationsSchema(notifications);
+
+  // Validate setup wizard schema
+  if (setupWizard) validateSetupWizardSchema(setupWizard);
 }
 
 function validatePackageName(name: string): void {

src/tasks/buildAndUpload/index.ts

@@ -39,7 +39,7 @@ export function buildAndUpload({
   const releaseUploader = getReleaseUploader(releaseUploaderProvider);
 
   return [
-    getFileValidationTask({ packagesToBuildProps, rootDir: dir }),
+    getFileValidationTask({ packagesToBuildProps }),
     getVerifyConnectionTask({ releaseUploader, skipUpload }),
     getReleaseDirCreationTask({ packagesToBuildProps }),
     getFileCopyTask({
@@ -49,7 +49,12 @@ export function buildAndUpload({
       composeFileName,
       requireGitData
     }),
-    ...getBuildTasks({ packagesToBuildProps, buildTimeout, skipSave, rootDir: dir }),
+    ...getBuildTasks({
+      packagesToBuildProps,
+      buildTimeout,
+      skipSave,
+      rootDir: dir
+    }),
     ...getUploadTasks({
       packagesToBuildProps,
       releaseUploader,