enablement-build-manifest 1.0.0 → 1.0.2

package/README.md

@@ -10,6 +10,8 @@ npx enablement-build-manifest [options]
 
 Run from the root of your monorepo. The manifest is printed to stdout and optionally saved to disk.
 
+When using `--save`, existing `templated` package mappings and existing `cicd` hash/version fields in the target manifest are preserved.
+
 ## Options
 
 | Flag | Description |
@@ -29,7 +31,7 @@ Pass `--platform github` or `--platform ado` to override.
 
 ## Output
 
-The manifest is a JSON object with five top-level keys:
+The manifest is a JSON object with six top-level keys:
 
 ```json
 {
@@ -37,6 +39,7 @@ The manifest is a JSON object with five top-level keys:
   "dependencies": { "<package-name>": ["<local-dep>", ...], ... },
   "dependents":   { "<package-name>": ["<consumer>", ...], ... },
   "pipelines":    { "<template-file>": [ <stage>, ... ], ... },
+  "templated":    { "<template-file>": { "<placeholder>": { "<package-name>": "<job-template>", ... } } },
   "cicd":         { "<package-name>": { "output": "...", "language": "...", "tier": "...", ... }, ... }
 }
 ```
@@ -54,6 +57,22 @@ Maps every local package name to its current version from `package.json`.
 
 Populated when `{configDir}/templates/templated.json` exists. Each key is a pipeline template filename; the value is an ordered list of resolved stages with their associated package lists.
 
+### `templated`
+
+Stores the template routing that used to live in `templated.json`. The first key is the output file name, the second key is the placeholder name, and the innermost map assigns each package name to the job template file or files it should use.
+
+Example:
+
+```json
+{
+  "build.yml": {
+    "PACKAGES": {
+      "enablement-build-deploy-version": "build_node_component.yml"
+    }
+  }
+}
+```
+
 ### `cicd`
 
 CI/CD metadata for each package. Sourced from the `.cicd` field in `package.json` when present; otherwise auto-detected by inspecting the package:
@@ -68,7 +87,6 @@ CI/CD metadata for each package. Sourced from the `.cicd` field in `package.json
 | `pyproject.toml` present | `pypi` | `Python` | `api` |
 | `Dockerfile` in image/container path | `docker` | `Dockerfile` | `infra` |
 
-Template filenames are also resolved and attached to each `cicd` entry based on the package type.
 
 ## Example
 

package/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import fs from 'fs';
-import { glob } from 'glob';
+import { globbySync } from 'globby';
 import YAML from 'yaml'
 import path from 'path';
 
@@ -13,8 +13,8 @@ const main = async (options) => {
   const configDir = options.platform === 'github' ? '.github' : '.cicd';
 
   // Find all package.json files, excluding node_modules
-  const packageJsonPaths = glob.sync('*/**/package.json', {
-    ignore: ['**/node_modules/**'],
+  const packageJsonPaths = globbySync('*/**/package.json', {
+    ignore: ['**/node_modules/**', '**/tests/**'],
     cwd: process.cwd(),
     absolute: true
   });
@@ -44,8 +44,19 @@ const main = async (options) => {
 
       versions[pkgJson.name] = pkgJson.version;
       dependents[pkgJson.name] = []; // Initialize reverse dependency map
+      const folderName = path.basename(path.dirname(pkgPath));
+      const packageFolder = path.basename(path.dirname(path.dirname(pkgPath)));
       if (pkgJson['.cicd']) {
-        cicd[pkgJson.name] = pkgJson['.cicd'];
+        const cicdEntry = { ...pkgJson['.cicd'] };
+        delete cicdEntry.templates;
+        cicdEntry.folderName = folderName;
+        cicdEntry.packageFolder = packageFolder;
+        cicd[pkgJson.name] = cicdEntry;
+      }
+      // Always ensure folderName/packageFolder are present if cicd entry exists
+      if (cicd[pkgJson.name]) {
+        if (!cicd[pkgJson.name].folderName) cicd[pkgJson.name].folderName = folderName;
+        if (!cicd[pkgJson.name].packageFolder) cicd[pkgJson.name].packageFolder = packageFolder;
       }
     }
   });
@@ -110,9 +121,9 @@ const main = async (options) => {
         } else {
           // ok it is not node
           var folderName = path.dirname(pkgPath);
-          const csproj = glob.sync('*.csproj', { cwd: folderName, absolute: true });
-          const toml = glob.sync('pyproject.toml', { cwd: folderName, absolute: true });
-          const docker = glob.sync('Dockerfile', { cwd: folderName, absolute: true });
+          const csproj = globbySync('*.csproj', { cwd: folderName, absolute: true });
+          const toml = globbySync('pyproject.toml', { cwd: folderName, absolute: true });
+          const docker = globbySync('Dockerfile', { cwd: folderName, absolute: true });
 
           if (csproj.length > 0) {
             cicd[pkgName] = {
@@ -143,9 +154,19 @@ const main = async (options) => {
     }
   });
 
+  // Ensure folderName and packageFolder are set on every cicd entry
+  Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
+    if (cicd[pkgName]) {
+      if (!cicd[pkgName].folderName)
+        cicd[pkgName].folderName = path.basename(path.dirname(pkgPath));
+      if (!cicd[pkgName].packageFolder)
+        cicd[pkgName].packageFolder = path.basename(path.dirname(path.dirname(pkgPath)));
+    }
+  });
+
   // now find all packages where templates are missing
   // first load the templated.json
-  let templated = {};
+  let templatedConfig = {};
   if (fs.existsSync(`./${configDir}/templates/templated.json`)) {
     let data = JSON.parse(fs.readFileSync(`./${configDir}/templates/templated.json`, 'utf-8'));
     let innerNames ={};
@@ -158,8 +179,8 @@ const main = async (options) => {
         rootPath = rootPath.replace(/\.\.\/+/g, ''); // remove leading ../
 
         innerNames[innerKey] = rootPath;
-        templated[rootPath] = templated[rootPath] || [];
-        templated[rootPath].push(template);
+        templatedConfig[rootPath] = templatedConfig[rootPath] || [];
+        templatedConfig[rootPath].push(template);
       });
     }
 
@@ -171,8 +192,9 @@ const main = async (options) => {
 
         let i = 0;
         for (const innerKey of Object.keys(innerNames)) {
-          const regex = new RegExp(`\\{\\s*${innerKey.toUpperCase()}\\s*\\}`, 'g');
-          if(i==0) tpl = tpl.replace(regex, `  blocks:\n  - ${innerKey.toUpperCase()}`);
+          const regex = new RegExp(`\{\s*${innerKey.toUpperCase()}\s*\}`, 'g');
+          if(i==0) tpl = tpl.replace(regex, `  blocks:
+  - ${innerKey.toUpperCase()}`);
           else tpl = tpl.replace(regex, `  - ${innerKey.toUpperCase()}`);
           i++;
         }
@@ -199,7 +221,7 @@ const main = async (options) => {
     }
   }
 
-  const templates = glob.sync(`./${configDir}/templates/*.yml`);
+  const templates = globbySync(`./${configDir}/templates/*.yml`);
   const withUnderscore = templates
                           .filter(file => file.includes('_'))
                           .map(file => path.basename(file));
@@ -207,11 +229,33 @@ const main = async (options) => {
   const codeScan = withUnderscore.filter(file => file.includes('scan') || file.includes('check'));
   const build = withUnderscore.filter(file => !file.includes('scan') && !file.includes('check'));
 
+  // Load existing manifest to preserve any already-set templated values
+  const manifestPath = `./${configDir}/manifest.json`;
+  const existingManifest = fs.existsSync(manifestPath)
+    ? JSON.parse(fs.readFileSync(manifestPath, 'utf-8'))
+    : {};
+  const existingTemplated = existingManifest.templated || {};
+  const existingPackages = (existingTemplated["build.yml"] || {})["PACKAGES"] || {};
+  const existingCicd = existingManifest.cicd || {};
+
+  const templated = {
+    "build.yml": {
+      "PACKAGES": {}
+    }
+  };
+
   Object.entries(nameToPath).forEach(([pkgName, pkgPath]) => {
-    if (cicd[pkgName] && !cicd[pkgName]["templates"]) {
+    if (cicd[pkgName]) {
+      // Preserve any existing templated assignment for this package
+      if (existingPackages[pkgName] !== undefined) {
+        templated["build.yml"]["PACKAGES"][pkgName] = existingPackages[pkgName];
+        return;
+      }
       const pkgDir = path.basename(path.dirname(path.dirname(pkgPath)));
-      if(templated[pkgDir]) {
-        cicd[pkgName]["templates"] = templated[pkgDir];
+      if(templatedConfig[pkgDir]) {
+        templated["build.yml"]["PACKAGES"][pkgName] = templatedConfig[pkgDir].length === 1
+          ? templatedConfig[pkgDir][0]
+          : templatedConfig[pkgDir];
       } else {
         let lookfor="node";
         if(cicd[pkgName]["output"]=="pypi") lookfor = "python";
@@ -232,17 +276,30 @@ const main = async (options) => {
           }
         });
         if(!found && templates.length>0) templates.push("build_scan.yml");
-        cicd[pkgName]["templates"] = templates;
+        templated["build.yml"]["PACKAGES"][pkgName] = templates.length === 1 ? templates[0] : templates;
       }
     }
   });
 
+  // Merge in any pre-existing cicd fields (hash, folderName, packageFolder set by release:finalize)
+  Object.keys(existingCicd).forEach(pkgName => {
+    if (cicd[pkgName]) {
+      // Preserve fields from the existing entry that we don't regenerate
+      if (existingCicd[pkgName].hash) cicd[pkgName].hash = existingCicd[pkgName].hash;
+      if (existingCicd[pkgName].version) cicd[pkgName].version = existingCicd[pkgName].version;
+    } else {
+      // If package was in cicd before but not now, preserve entire entry
+      cicd[pkgName] = existingCicd[pkgName];
+    }
+  });
+
   // Final output structure
   const output = {
     versions,
     dependencies,
     dependents,
     pipelines,
+    templated,
     cicd
   };
 

package/package.json

@@ -1,17 +1,19 @@
 {
   "name": "enablement-build-manifest",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "This builds a dependency tree.",
   "type": "module",
   "module": "./index.mjs",
-  "bin": "./index.mjs",
   "license": "MIT",
   "author": "Contributors",
   "dependencies": {
-    "glob": "^11.0.3",
+    "globby": "^16.2.0",
     "yaml": "^2.8.1"
   },
   "scripts": {
     "start": "node index.mjs"
+  },
+  "bin": {
+    "enablement-build-manifest": "./index.mjs"
   }
 }