Fix template expansion for asset globbing patterns with wildcards

Template variables in asset paths like "release/my-project-v${nextRelease.version}*.zip"
are now expanded before globbing, allowing wildcard patterns to work correctly.
Only applies template expansion when template variables are detected to avoid
unnecessary processing.

Co-authored-by: fgreinacher <[email protected]>

Author: Copilot

lib/publish.js

@@ -56,26 +56,66 @@ export default async (pluginConfig, context) => {
   debug("milestones: %o", milestones);
 
   if (assets && assets.length > 0) {
+    // Apply template expansion to assets BEFORE globbing, but only when templates are present
+    const needsTemplateExpansion = (str) => str && typeof str === 'string' && str.includes('${');
+    
+    const templatedAssets = assets.map((asset) => {
+      if (isPlainObject(asset)) {
+        const templatedAsset = { ...asset };
+        if (asset.path && needsTemplateExpansion(asset.path)) {
+          templatedAsset.path = template(asset.path)(context);
+        }
+        if (asset.url && needsTemplateExpansion(asset.url)) {
+          templatedAsset.url = template(asset.url)(context);
+        }
+        if (asset.label && needsTemplateExpansion(asset.label)) {
+          templatedAsset.label = template(asset.label)(context);
+        }
+        if (asset.type && needsTemplateExpansion(asset.type)) {
+          templatedAsset.type = template(asset.type)(context);
+        }
+        if (asset.filepath && needsTemplateExpansion(asset.filepath)) {
+          templatedAsset.filepath = template(asset.filepath)(context);
+        }
+        if (asset.target && needsTemplateExpansion(asset.target)) {
+          templatedAsset.target = template(asset.target)(context);
+        }
+        if (asset.status && needsTemplateExpansion(asset.status)) {
+          templatedAsset.status = template(asset.status)(context);
+        }
+        return templatedAsset;
+      } else if (Array.isArray(asset)) {
+        // Handle array of glob patterns - only apply templates if needed
+        return asset.map(pattern => needsTemplateExpansion(pattern) ? template(pattern)(context) : pattern);
+      } else {
+        // String asset path - only apply template if needed
+        return needsTemplateExpansion(asset) ? template(asset)(context) : asset;
+      }
+    });
+
     // Skip glob if url is provided
-    const urlAssets = assets.filter((asset) => asset.url);
+    const urlAssets = templatedAssets.filter((asset) => asset.url);
     debug("url assets: %o", urlAssets);
     const globbedAssets = await getAssets(
       context,
-      assets.filter((asset) => !asset.url)
+      templatedAssets.filter((asset) => !asset.url)
     );
     debug("globbed assets: %o", globbedAssets);
     const allAssets = [...urlAssets, ...globbedAssets];
     debug("all assets: %o", allAssets);
 
     await Promise.all(
       allAssets.map(async (asset) => {
-        const path = template((isPlainObject(asset) ? asset : { path: asset }).path)(context);
-        const _url = asset.url ? template(asset.url)(context) : undefined;
-        const label = asset.label ? template(asset.label)(context) : undefined;
-        const type = asset.type ? template(asset.type)(context) : undefined;
-        const filepath = asset.filepath ? template(asset.filepath)(context) : undefined;
-        const target = asset.target ? template(asset.target)(context) : undefined;
-        const status = asset.status ? template(asset.status)(context) : undefined;
+        // Templates may have been expanded before globbing, but we need to handle remaining cases
+        const needsTemplateExpansion = (str) => str && typeof str === 'string' && str.includes('${');
+        
+        const path = isPlainObject(asset) ? asset.path : asset;
+        const _url = asset.url ? (needsTemplateExpansion(asset.url) ? template(asset.url)(context) : asset.url) : undefined;
+        const label = asset.label ? (needsTemplateExpansion(asset.label) ? template(asset.label)(context) : asset.label) : undefined;
+        const type = asset.type ? (needsTemplateExpansion(asset.type) ? template(asset.type)(context) : asset.type) : undefined;
+        const filepath = asset.filepath ? (needsTemplateExpansion(asset.filepath) ? template(asset.filepath)(context) : asset.filepath) : undefined;
+        const target = asset.target ? (needsTemplateExpansion(asset.target) ? template(asset.target)(context) : asset.target) : undefined;
+        const status = asset.status ? (needsTemplateExpansion(asset.status) ? template(asset.status)(context) : asset.status) : undefined;
 
         if (_url) {
           assetsList.push({ label, rawUrl: _url, type, filepath });

test/fixtures/wildcard-test/release/my-project-v1.0.0-alpha.zip

@@ -0,0 +1 @@
+dummy zip content for testing alpha

test/fixtures/wildcard-test/release/my-project-v1.0.0.zip

@@ -0,0 +1 @@
+dummy zip content for testing

test/publish.test.js

@@ -712,3 +712,64 @@ test.serial("Publish a release with error response", async (t) => {
   t.is(error.message, `Response code 499 (Something went wrong)`);
   t.true(gitlab.isDone());
 });
+
+test.serial("Publish a release with templated wildcard path", async (t) => {
+  const cwd = "test/fixtures/wildcard-test";
+  const owner = "test_user";
+  const repo = "test_repo";
+  const env = { GITLAB_TOKEN: "gitlab_token" };
+  const nextRelease = { gitHead: "123", gitTag: "v1.0.0", notes: "Test release note body", version: "1.0.0" };
+  const options = { repositoryUrl: `https://gitlab.com/${owner}/${repo}.git` };
+  const encodedProjectPath = encodeURIComponent(`${owner}/${repo}`);
+  const encodedGitTag = encodeURIComponent(nextRelease.gitTag);
+  
+  // This pattern should match both "my-project-v1.0.0.zip" and "my-project-v1.0.0-alpha.zip"
+  const assets = ["release/my-project-v${nextRelease.version}*.zip"];
+  
+  const uploaded1 = {
+    url: "/uploads/my-project-v1.0.0.zip",
+    alt: "my-project-v1.0.0.zip",
+    full_path: "/-/project/4/66dbcd21ec5d24ed6ea225176098d52b/my-project-v1.0.0.zip",
+  };
+  const uploaded2 = {
+    url: "/uploads/my-project-v1.0.0-alpha.zip", 
+    alt: "my-project-v1.0.0-alpha.zip",
+    full_path: "/-/project/4/66dbcd21ec5d24ed6ea225176098d52b/my-project-v1.0.0-alpha.zip",
+  };
+  
+  const gitlab = authenticate(env)
+    .post(`/projects/${encodedProjectPath}/releases`, {
+      tag_name: nextRelease.gitTag,
+      description: nextRelease.notes,
+      assets: {
+        links: [
+          {
+            name: "my-project-v1.0.0-alpha.zip", 
+            url: `https://gitlab.com${uploaded2.full_path}`,
+          },
+          {
+            name: "my-project-v1.0.0.zip",
+            url: `https://gitlab.com${uploaded1.full_path}`,
+          },
+        ],
+      },
+    })
+    .reply(200);
+  const gitlabUpload1 = authenticate(env)
+    .post(`/projects/${encodedProjectPath}/uploads`, /Content-Disposition.*my-project-v1\.0\.0\.zip/g)
+    .reply(200, uploaded1);
+  const gitlabUpload2 = authenticate(env)
+    .post(`/projects/${encodedProjectPath}/uploads`, /Content-Disposition.*my-project-v1\.0\.0-alpha\.zip/g)
+    .reply(200, uploaded2);
+
+  const result = await publish({ assets }, { env, cwd, options, nextRelease, logger: t.context.logger });
+
+  t.is(result.url, `https://gitlab.com/${owner}/${repo}/-/releases/${encodedGitTag}`);
+  // Should upload both files that match the wildcard pattern (in alphabetical order)
+  t.deepEqual(t.context.log.args[0], ["Uploaded file: %s", `https://gitlab.com${uploaded2.full_path}`]);
+  t.deepEqual(t.context.log.args[1], ["Uploaded file: %s", `https://gitlab.com${uploaded1.full_path}`]);
+  t.deepEqual(t.context.log.args[2], ["Published GitLab release: %s", nextRelease.gitTag]);
+  t.true(gitlab.isDone());
+  t.true(gitlabUpload1.isDone());
+  t.true(gitlabUpload2.isDone());
+});