enablement-build-template-generate 1.0.17 → 1.0.20

package/README.md

@@ -101,6 +101,9 @@ Each job snippet template is expanded once per package. The following placeholde
 | `{full}` | Full npm package name including scope (e.g. `@scope/my-component`) |
 | `{path}` | The package folder root (from `cicd[pkg].packageFolder`, e.g. `packages`) |
 | `{other}` | Expands to a comma-separated list of paths to every **other** package in the same variable — useful for pipeline dependency declarations |
+| `{metadataKey}` | Custom placeholders like `{owner}` or `{tier}` are replaced from `manifest.cicd[packageName].metadata` (**manifest.json mode only**) |
+
+In `templated.json` legacy mode, custom metadata placeholders are not supported and remain unchanged in output.
 
 ---
 

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "enablement-build-template-generate",
-  "version": "1.0.17",
+  "version": "1.0.20",
   "description": "Generates build yaml for mono repos",
   "type": "module",
   "module": "./src/index.mjs",
   "main": "./src/index.mjs",
+  "bin": "./src/index.mjs",
   "dependencies": {
     "globby": "^16.2.0",
     "user": "^0.0.0"
@@ -12,6 +13,11 @@
   "devDependencies": {
     "jest": "^30.4.2"
   },
+  "scripts": {
+    "start": "node src/index.mjs",
+    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
+    "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch"
+  },
   "jest": {
     "testEnvironment": "node",
     "testMatch": [
@@ -19,13 +25,5 @@
     ]
   },
   "license": "MIT",
-  "author": "Contributors",
-  "scripts": {
-    "start": "node src/index.mjs",
-    "test": "node --experimental-vm-modules node_modules/jest/bin/jest.js",
-    "test:watch": "node --experimental-vm-modules node_modules/jest/bin/jest.js --watch"
-  },
-  "bin": {
-    "enablement-build-template-generate": "./src/index.mjs"
-  }
+  "author": "Contributors"
 }

package/src/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import * as url from 'url';
 import path from 'path';
-import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { readFileSync, writeFileSync, existsSync, readdirSync } from 'fs';
 import { globby } from 'globby';
 
 import {
@@ -32,6 +32,38 @@ function readJobTemplate(templateFile, templatePath, fallbackTemplatePath) {
   throw new Error(`Template file not found: ${templateFile} (looked in ${templatePath}${fallbackTemplatePath ? ' and ' + fallbackTemplatePath : ''})`);
 }
 
+
+// Resolve package folder name for {name}: prefer cicd.folderName, otherwise infer from disk.
+function resolveFolderName(pkgName, info = {}) {
+  if (info.folderName) return info.folderName;
+
+  const packageFolder = info.packageFolder || 'packages';
+  const packageRoot = path.join(process.cwd(), packageFolder);
+  if (!existsSync(packageRoot)) return resolvePackageName(pkgName);
+
+  const dirs = readdirSync(packageRoot, { withFileTypes: true })
+    .filter(entry => entry.isDirectory())
+    .map(entry => entry.name);
+
+  for (const dirName of dirs) {
+    const base = path.join(packageRoot, dirName);
+    const candidates = ['package.json', 'version.json', 'pyproject.toml'];
+
+    for (const candidate of candidates) {
+      const manifestPath = path.join(base, candidate);
+      if (!existsSync(manifestPath)) continue;
+
+      const ext = path.extname(candidate).substring(1).toLowerCase();
+      const content = readFileSync(manifestPath, 'utf8');
+      const parsedName = parseManifestName(content, ext);
+
+      if (parsedName === pkgName) return dirName;
+    }
+  }
+
+  return resolvePackageName(pkgName);
+}
+
 // ---------------------------------------------------------------------------
 // Expand using manifest.json "templated" section (new format)
 // ---------------------------------------------------------------------------
@@ -40,11 +72,11 @@ function expandVarFromManifest(varname, packageMap, cicd, templatePath, fallback
     try {
       const packageNames = Object.keys(packageMap).filter(pkg => {
         if (packageMap[pkg] === false) return false;
-        const folderName = (cicd[pkg] || {}).folderName || pkg;
+        const folderName = resolveFolderName(pkg, cicd[pkg] || {});
         return !options.exclude.includes(folderName);
       });
 
-      const allFolderNames = packageNames.map(pkg => (cicd[pkg] || {}).folderName || pkg);
+      const allFolderNames = packageNames.map(pkg => resolveFolderName(pkg, cicd[pkg] || {}));
 
       const folderCounts = {};
       packageNames.forEach(pkg => {
@@ -60,7 +92,7 @@ function expandVarFromManifest(varname, packageMap, cicd, templatePath, fallback
           : [packageMap[pkgName]];
 
         const info = cicd[pkgName] || {};
-        const name = info.folderName || pkgName;
+        const name = resolveFolderName(pkgName, info);
         const jobRoot = info.packageFolder || 'packages';
         const safe = makeSafe(name);
         const packageName = resolvePackageName(pkgName);
@@ -94,8 +126,8 @@ function expandVarFromTemplatedJson(varname, jobConfig, templatePath, fallbackTe
       const allNames = Object.keys(folderBest).sort().filter(n => !options.exclude.includes(n));
 
       const expandedJobs = allNames.map(name => {
-        const content = readFileSync(path.join(cwd, folderBest[name]), 'utf8');
-        const ext = path.extname(folderBest[name]).substring(1).toLowerCase();
+        const content = readFileSync(path.join(cwd, folderBest[name].filePath), 'utf8');
+        const ext = path.extname(folderBest[name].filePath).substring(1).toLowerCase();
         const fullName = parseManifestName(content, ext) || name;
         const safe = makeSafe(name);
         const packageName = resolvePackageName(fullName);

package/tests/index.test.mjs

@@ -0,0 +1,185 @@
+import { describe, it, expect } from '@jest/globals';
+import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from 'fs';
+import os from 'os';
+import path from 'path';
+import { execFileSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+function writeJson(filePath, data) {
+  writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
+}
+
+function createFixtureWorkspace(mode, options = {}) {
+  const tmpRoot = mkdtempSync(path.join(os.tmpdir(), 'template-generate-'));
+
+  const defaultJobTemplateLines = [
+    '- job: build_{safe}',
+    '  displayName: NAME={name}',
+    '  safe: SAFE={safe}',
+    '  package: PKG={package}',
+    '  full: FULL={full}',
+    '  other: OTHER={other}',
+    "  script: cd ./{path}/{name}",
+    "  condition: contains(variables['changed'], '{name}')",
+    '',
+  ];
+
+  const jobTemplateLines = options.jobTemplateLines || defaultJobTemplateLines;
+
+  mkdirSync(path.join(tmpRoot, '.cicd', 'templates'), { recursive: true });
+  mkdirSync(path.join(tmpRoot, 'packages', 'alpha-lib'), { recursive: true });
+  mkdirSync(path.join(tmpRoot, 'packages', 'beta-tool'), { recursive: true });
+
+  writeJson(path.join(tmpRoot, 'packages', 'alpha-lib', 'package.json'), {
+    name: '@scope/enablement-build-alpha-lib',
+    version: '1.0.0',
+  });
+  writeJson(path.join(tmpRoot, 'packages', 'beta-tool', 'package.json'), {
+    name: 'enablement-build-beta-tool',
+    version: '1.0.0',
+  });
+
+  writeFileSync(
+    path.join(tmpRoot, '.cicd', 'templates', 'build.yml'),
+    'jobs:\n{PACKAGES}\n',
+    'utf8'
+  );
+
+  writeFileSync(
+    path.join(tmpRoot, '.cicd', 'templates', 'job.yml'),
+    jobTemplateLines.join('\n'),
+    'utf8'
+  );
+
+  const cicdEntries = {
+    '@scope/enablement-build-alpha-lib': {
+      packageFolder: 'packages',
+      ...(options.metadataByPackage?.['@scope/enablement-build-alpha-lib'] || {}),
+    },
+    'enablement-build-beta-tool': {
+      packageFolder: 'packages',
+      ...(options.metadataByPackage?.['enablement-build-beta-tool'] || {}),
+    },
+  };
+
+  if (mode === 'manifest') {
+    writeJson(path.join(tmpRoot, '.cicd', 'manifest.json'), {
+      templated: {
+        'build.yml': {
+          PACKAGES: {
+            '@scope/enablement-build-alpha-lib': 'job.yml',
+            'enablement-build-beta-tool': 'job.yml',
+          },
+        },
+      },
+      cicd: cicdEntries,
+    });
+  } else {
+    writeJson(path.join(tmpRoot, '.cicd', 'templates', 'templated.json'), {
+      'build.yml': {
+        PACKAGES: {
+          rootPath: '../../packages',
+          template: 'job.yml',
+        },
+      },
+    });
+  }
+
+  return tmpRoot;
+}
+
+function runGenerator(cwd) {
+  const scriptPath = fileURLToPath(new URL('../src/index.mjs', import.meta.url));
+  execFileSync(process.execPath, [scriptPath, '--platform', 'ado'], {
+    cwd,
+    stdio: 'pipe',
+  });
+
+  return readFileSync(path.join(cwd, '.cicd', 'build.yml'), 'utf8');
+}
+
+function stripBanner(content) {
+  return content
+    .split('\n')
+    .filter(
+      (line) =>
+        line !== '#######################################' &&
+        line !== '### DO NOT EDIT - THIS IS GENERATED ###'
+    )
+    .join('\n')
+    .trim();
+}
+
+function normalizeOutput(content, root) {
+  return stripBanner(content).split(root).join('<ROOT>');
+}
+
+describe('template-generate mode parity', () => {
+  it('expands placeholders consistently between manifest and templated.json modes', () => {
+    const manifestRoot = createFixtureWorkspace('manifest');
+    const legacyRoot = createFixtureWorkspace('legacy');
+
+    try {
+      const manifestOut = runGenerator(manifestRoot);
+      const legacyOut = runGenerator(legacyRoot);
+
+      expect(manifestOut).toContain('NAME=alpha-lib');
+      expect(manifestOut).toContain('NAME=beta-tool');
+      expect(manifestOut).toContain('SAFE=alphalib');
+      expect(manifestOut).toContain('SAFE=betatool');
+      expect(manifestOut).toContain('PKG=enablement-build-alpha-lib');
+      expect(manifestOut).toContain('PKG=enablement-build-beta-tool');
+      expect(manifestOut).toContain('FULL=@scope/enablement-build-alpha-lib');
+      expect(manifestOut).toContain('FULL=enablement-build-beta-tool');
+      expect(manifestOut).toContain(`OTHER=${manifestRoot}/packages/beta-tool`);
+      expect(manifestOut).toContain(`OTHER=${manifestRoot}/packages/alpha-lib`);
+      expect(manifestOut).toContain('script: cd ./packages/alpha-lib');
+      expect(manifestOut).toContain('script: cd ./packages/beta-tool');
+      expect(manifestOut).toContain("condition: contains(variables['changed'], 'alpha-lib')");
+      expect(manifestOut).toContain("condition: contains(variables['changed'], 'beta-tool')");
+
+      expect(normalizeOutput(manifestOut, manifestRoot)).toBe(normalizeOutput(legacyOut, legacyRoot));
+    } finally {
+      rmSync(manifestRoot, { recursive: true, force: true });
+      rmSync(legacyRoot, { recursive: true, force: true });
+    }
+  });
+
+  it('applies custom metadata placeholders only in manifest mode', () => {
+    const options = {
+      jobTemplateLines: [
+        '- job: meta_{safe}',
+        '  owner: OWNER={owner}',
+        '  tier: TIER={tier}',
+        '  name: NAME={name}',
+        '',
+      ],
+      metadataByPackage: {
+        '@scope/enablement-build-alpha-lib': {
+          metadata: { owner: 'team-alpha', tier: 'gold' },
+        },
+      },
+    };
+
+    const manifestRoot = createFixtureWorkspace('manifest', options);
+    const legacyRoot = createFixtureWorkspace('legacy', options);
+
+    try {
+      const manifestOut = runGenerator(manifestRoot);
+      const legacyOut = runGenerator(legacyRoot);
+
+      expect(manifestOut).toContain('owner: OWNER=team-alpha');
+      expect(manifestOut).toContain('tier: TIER=gold');
+      expect(manifestOut).toContain('owner: OWNER={owner}');
+      expect(manifestOut).toContain('tier: TIER={tier}');
+
+      expect(legacyOut).not.toContain('owner: OWNER=team-alpha');
+      expect(legacyOut).not.toContain('tier: TIER=gold');
+      expect(legacyOut).toContain('owner: OWNER={owner}');
+      expect(legacyOut).toContain('tier: TIER={tier}');
+    } finally {
+      rmSync(manifestRoot, { recursive: true, force: true });
+      rmSync(legacyRoot, { recursive: true, force: true });
+    }
+  });
+});