feat: support building block run URL input with fallback to payload

JohannesRudolph · JohannesRudolph · commit c21e3e560483 · 2025-12-09T22:26:10.000+01:00
- Add buildingBlockRunUrl input to action.yml for fetching building block run data
- Update index.ts to handle both URL-based and payload-based inputs
- URL-based input makes a GET request to fetch the building block run object
- Maintains backward compatibility with existing buildingBlockRun payload input
- Extract common logic for parsing building block run data from both sources
- Add tests for building block run parsing from URL and payload sources
diff --git a/action.yml b/action.yml
@@ -5,6 +5,10 @@ inputs:
     description: 'The steps to register'
     required: true
     type: string
+  buildingBlockRunUrl:
+    description: 'URL to fetch the building block run object from (alternative to buildingBlockRun input via payload)'
+    required: false
+    type: string
 outputs:
   token_file:
     description: 'Path to the file containing the authentication token'
diff --git a/dist/main/index.js b/dist/main/index.js
@@ -32289,16 +32289,71 @@ const os = __importStar(__nccwpck_require__(2037));
 async function run() {
     try {
         const stepsInput = core.getInput('steps');
+        const buildingBlockRunUrl = core.getInput('buildingBlockRunUrl');
         core.debug(`Steps Input: ${stepsInput}`);
-        // Extract buildingBlockRun from the GitHub event payload
-        const buildingBlockRun = github.context.payload.inputs.buildingBlockRun;
-        core.debug(`Building Block Run: ${buildingBlockRun}`);
-        // Decode and parse the buildingBlockRun input
-        const decodedBuildingBlockRun = Buffer.from(buildingBlockRun, 'base64').toString('utf-8');
-        const buildingBlockRunJson = JSON.parse(decodedBuildingBlockRun);
-        const bbRunUuid = buildingBlockRunJson.metadata.uuid;
-        const baseUrl = buildingBlockRunJson._links.meshstackBaseUrl.href;
-        const inputs = buildingBlockRunJson.spec.buildingBlock.spec.inputs;
+        core.debug(`Building Block Run URL: ${buildingBlockRunUrl}`);
+        let buildingBlockRunJson;
+        let bbRunUuid;
+        let baseUrl;
+        let inputs;
+        // Determine input source: URL or payload
+        if (buildingBlockRunUrl) {
+            // Fetch building block run from URL
+            core.debug('Using buildingBlockRunUrl input');
+            // Read token from file for authorization
+            const tempDir = process.env.RUNNER_TEMP || os.tmpdir();
+            const tokenFilePath = path.join(tempDir, 'meshstack_token.json');
+            if (!fs.existsSync(tokenFilePath)) {
+                throw new Error(`Token file does not exist at ${tokenFilePath}`);
+            }
+            const tokenData = JSON.parse(fs.readFileSync(tokenFilePath, 'utf8'));
+            const token = tokenData.token;
+            if (!token) {
+                throw new Error('Token not found in token file');
+            }
+            core.debug(`Token: ${token}`);
+            // Fetch the building block run from the URL
+            const headers = {
+                'Accept': 'application/vnd.meshcloud.api.meshbuildingblockrun.v1.hal+json',
+                'Authorization': `Bearer ${token}`
+            };
+            try {
+                const response = await axios_1.default.get(buildingBlockRunUrl, { headers });
+                buildingBlockRunJson = response.data;
+                core.debug(`Fetched Building Block Run: ${JSON.stringify(buildingBlockRunJson)}`);
+            }
+            catch (fetchError) {
+                if (axios_1.default.isAxiosError(fetchError)) {
+                    if (fetchError.response) {
+                        core.error(`Failed to fetch building block run: ${JSON.stringify(fetchError.response.data)}`);
+                        core.error(`Status code: ${fetchError.response.status}`);
+                    }
+                    else {
+                        core.error(`Fetch error message: ${fetchError.message}`);
+                    }
+                }
+                else {
+                    core.error(`Unexpected error during fetch: ${fetchError}`);
+                }
+                throw fetchError;
+            }
+        }
+        else {
+            // Use buildingBlockRun from GitHub event payload
+            core.debug('Using buildingBlockRun from GitHub event payload');
+            const buildingBlockRun = github.context.payload.inputs.buildingBlockRun;
+            core.debug(`Building Block Run: ${buildingBlockRun}`);
+            if (!buildingBlockRun) {
+                throw new Error('Neither buildingBlockRunUrl input nor buildingBlockRun payload provided');
+            }
+            // Decode and parse the buildingBlockRun input
+            const decodedBuildingBlockRun = Buffer.from(buildingBlockRun, 'base64').toString('utf-8');
+            buildingBlockRunJson = JSON.parse(decodedBuildingBlockRun);
+        }
+        // Extract common data from buildingBlockRunJson
+        bbRunUuid = buildingBlockRunJson.metadata.uuid;
+        baseUrl = buildingBlockRunJson._links.meshstackBaseUrl.href;
+        inputs = buildingBlockRunJson.spec.buildingBlock.spec.inputs;
         core.debug(`Base URL: ${baseUrl}`);
         core.debug(`BB Run UUID: ${bbRunUuid}`);
         // Extract additional inputs
diff --git a/src/index.ts b/src/index.ts
@@ -8,19 +8,80 @@ import * as os from 'os';
 async function run() {
   try {
     const stepsInput = core.getInput('steps');
+    const buildingBlockRunUrl = core.getInput('buildingBlockRunUrl');
 
     core.debug(`Steps Input: ${stepsInput}`);
+    core.debug(`Building Block Run URL: ${buildingBlockRunUrl}`);
+
+    let buildingBlockRunJson: any;
+    let bbRunUuid: string;
+    let baseUrl: string;
+    let inputs: any[];
+
+    // Determine input source: URL or payload
+    if (buildingBlockRunUrl) {
+      // Fetch building block run from URL
+      core.debug('Using buildingBlockRunUrl input');
+      
+      // Read token from file for authorization
+      const tempDir = process.env.RUNNER_TEMP || os.tmpdir();
+      const tokenFilePath = path.join(tempDir, 'meshstack_token.json');
+
+      if (!fs.existsSync(tokenFilePath)) {
+        throw new Error(`Token file does not exist at ${tokenFilePath}`);
+      }
+
+      const tokenData = JSON.parse(fs.readFileSync(tokenFilePath, 'utf8'));
+      const token = tokenData.token;
+
+      if (!token) {
+        throw new Error('Token not found in token file');
+      }
+
+      core.debug(`Token: ${token}`);
+
+      // Fetch the building block run from the URL
+      const headers = {
+        'Accept': 'application/vnd.meshcloud.api.meshbuildingblockrun.v1.hal+json',
+        'Authorization': `Bearer ${token}`
+      };
+
+      try {
+        const response = await axios.get(buildingBlockRunUrl, { headers });
+        buildingBlockRunJson = response.data;
+        core.debug(`Fetched Building Block Run: ${JSON.stringify(buildingBlockRunJson)}`);
+      } catch (fetchError) {
+        if (axios.isAxiosError(fetchError)) {
+          if (fetchError.response) {
+            core.error(`Failed to fetch building block run: ${JSON.stringify(fetchError.response.data)}`);
+            core.error(`Status code: ${fetchError.response.status}`);
+          } else {
+            core.error(`Fetch error message: ${fetchError.message}`);
+          }
+        } else {
+          core.error(`Unexpected error during fetch: ${fetchError}`);
+        }
+        throw fetchError;
+      }
+    } else {
+      // Use buildingBlockRun from GitHub event payload
+      core.debug('Using buildingBlockRun from GitHub event payload');
+      const buildingBlockRun = github.context.payload.inputs.buildingBlockRun;
+      core.debug(`Building Block Run: ${buildingBlockRun}`);
 
-    // Extract buildingBlockRun from the GitHub event payload
-    const buildingBlockRun = github.context.payload.inputs.buildingBlockRun;
-    core.debug(`Building Block Run: ${buildingBlockRun}`);
+      if (!buildingBlockRun) {
+        throw new Error('Neither buildingBlockRunUrl input nor buildingBlockRun payload provided');
+      }
+
+      // Decode and parse the buildingBlockRun input
+      const decodedBuildingBlockRun = Buffer.from(buildingBlockRun, 'base64').toString('utf-8');
+      buildingBlockRunJson = JSON.parse(decodedBuildingBlockRun);
+    }
 
-    // Decode and parse the buildingBlockRun input
-    const decodedBuildingBlockRun = Buffer.from(buildingBlockRun, 'base64').toString('utf-8');
-    const buildingBlockRunJson = JSON.parse(decodedBuildingBlockRun);
-    const bbRunUuid = buildingBlockRunJson.metadata.uuid;
-    const baseUrl = buildingBlockRunJson._links.meshstackBaseUrl.href;
-    const inputs = buildingBlockRunJson.spec.buildingBlock.spec.inputs;
+    // Extract common data from buildingBlockRunJson
+    bbRunUuid = buildingBlockRunJson.metadata.uuid;
+    baseUrl = buildingBlockRunJson._links.meshstackBaseUrl.href;
+    inputs = buildingBlockRunJson.spec.buildingBlock.spec.inputs;
 
     core.debug(`Base URL: ${baseUrl}`);
     core.debug(`BB Run UUID: ${bbRunUuid}`);
diff --git a/tests/token.test.ts b/tests/token.test.ts
@@ -113,4 +113,119 @@ describe('register-source token file reading', () => {
       assert(expectedPath.includes(tempDir));
     });
   });
+
+  describe('building block run parsing from URL vs payload', () => {
+    const mockBuildingBlockRun = {
+      kind: 'meshBuildingBlockRun',
+      apiVersion: 'v1',
+      metadata: {
+        uuid: 'b3116611-e08b-4b00-91c5-10365b25a6ef'
+      },
+      spec: {
+        runNumber: 1,
+        buildingBlock: {
+          uuid: '68ce5455-2a4a-4a4b-a324-6a6c18cab85a',
+          spec: {
+            displayName: 'block',
+            workspaceIdentifier: 'my-workspace',
+            projectIdentifier: 'my-project',
+            fullPlatformIdentifier: 'my-platform.my-location',
+            inputs: [
+              {
+                key: 'variable-name',
+                value: 'some-value',
+                type: 'STRING',
+                isSensitive: false,
+                isEnvironment: false
+              }
+            ],
+            parentBuildingBlocks: []
+          }
+        },
+        buildingBlockDefinition: {
+          uuid: 'b23cfb9a-6974-444f-9d33-62134a632373',
+          spec: {
+            version: 1,
+            implementation: {
+              type: 'TERRAFORM',
+              terraformVersion: 'v1',
+              repositoryUrl: 'https://example.com',
+              async: true,
+              useMeshHttpBackendFallback: false
+            }
+          }
+        },
+        behavior: 'APPLY'
+      },
+      status: 'IN_PROGRESS',
+      _links: {
+        self: {
+          href: 'https://mesh-backend-url/api/meshobjects/meshbuildingblockruns/b3116611-e08b-4b00-91c5-10365b25a6ef'
+        },
+        registerSource: {
+          href: 'https://mesh-backend-url/api/meshobjects/meshbuildingblockruns/b3116611-e08b-4b00-91c5-10365b25a6ef/status/source'
+        },
+        updateSource: {
+          href: 'https://mesh-backend-url/api/meshobjects/meshbuildingblockruns/b3116611-e08b-4b00-91c5-10365b25a6ef/status/source/{sourceId}',
+          templated: true
+        },
+        meshstackBaseUrl: {
+          href: 'https://mesh-backend-url'
+        }
+      }
+    };
+
+    it('should extract uuid from building block run', () => {
+      const uuid = mockBuildingBlockRun.metadata.uuid;
+      assert.strictEqual(uuid, 'b3116611-e08b-4b00-91c5-10365b25a6ef');
+    });
+
+    it('should extract base URL from building block run', () => {
+      const baseUrl = mockBuildingBlockRun._links.meshstackBaseUrl.href;
+      assert.strictEqual(baseUrl, 'https://mesh-backend-url');
+    });
+
+    it('should extract inputs from building block spec', () => {
+      const inputs = mockBuildingBlockRun.spec.buildingBlock.spec.inputs;
+      assert.strictEqual(inputs.length, 1);
+      assert.strictEqual(inputs[0].key, 'variable-name');
+      assert.strictEqual(inputs[0].value, 'some-value');
+    });
+
+    it('should encode building block run as base64 for payload', () => {
+      const encoded = Buffer.from(JSON.stringify(mockBuildingBlockRun)).toString('base64');
+      const decoded = Buffer.from(encoded, 'base64').toString('utf-8');
+      const parsed = JSON.parse(decoded);
+
+      assert.strictEqual(parsed.metadata.uuid, mockBuildingBlockRun.metadata.uuid);
+      assert.strictEqual(parsed._links.meshstackBaseUrl.href, mockBuildingBlockRun._links.meshstackBaseUrl.href);
+    });
+
+    it('should handle multiple inputs in building block spec', () => {
+      const multiInputRun = {
+        ...mockBuildingBlockRun,
+        spec: {
+          ...mockBuildingBlockRun.spec,
+          buildingBlock: {
+            ...mockBuildingBlockRun.spec.buildingBlock,
+            spec: {
+              ...mockBuildingBlockRun.spec.buildingBlock.spec,
+              inputs: [
+                { key: 'input1', value: 'value1', type: 'STRING', isSensitive: false, isEnvironment: false },
+                { key: 'input2', value: 'value2', type: 'STRING', isSensitive: false, isEnvironment: false },
+                { key: 'input3', value: 'value3', type: 'STRING', isSensitive: false, isEnvironment: false }
+              ]
+            }
+          }
+        }
+      };
+
+      const inputs = multiInputRun.spec.buildingBlock.spec.inputs;
+      assert.strictEqual(inputs.length, 3);
+      assert.strictEqual(inputs[0].key, 'input1');
+      assert.strictEqual(inputs[1].key, 'input2');
+      assert.strictEqual(inputs[2].key, 'input3');
+    });
+  });
 });
+
