@aws/ml-container-creator 0.2.0 → 0.2.2

package/src/lib/ci-stage-helpers.js

@@ -24,13 +24,13 @@ export const STAGE_ORDER = [
     'register',
     'teardown',
     'update'
-]
+];
 
 /**
  * Stages that always execute regardless of prior failures.
  * Teardown cleans up resources; Update writes results to DynamoDB.
  */
-export const ALWAYS_RUN_STAGES = ['teardown', 'update']
+export const ALWAYS_RUN_STAGES = ['teardown', 'update'];
 
 /**
  * Parse a DynamoDB-format stageResults map into plain JavaScript objects.
@@ -45,14 +45,14 @@ export const ALWAYS_RUN_STAGES = ['teardown', 'update']
  */
 export function parseStageResults(stageResultsMap) {
     if (!stageResultsMap || typeof stageResultsMap !== 'object') {
-        return {}
+        return {};
     }
 
-    const result = {}
+    const result = {};
 
     for (const [stageName, stageValue] of Object.entries(stageResultsMap)) {
         // Handle DynamoDB M (map) wrapper
-        const inner = stageValue && stageValue.M ? stageValue.M : stageValue
+        const inner = stageValue && stageValue.M ? stageValue.M : stageValue;
 
         if (!inner || typeof inner !== 'object') {
             result[stageName] = {
@@ -60,8 +60,8 @@ export function parseStageResults(stageResultsMap) {
                 durationSeconds: 0,
                 logPointer: '',
                 errorSummary: ''
-            }
-            continue
+            };
+            continue;
         }
 
         result[stageName] = {
@@ -69,10 +69,10 @@ export function parseStageResults(stageResultsMap) {
             durationSeconds: extractNumber(inner.durationSeconds, 0),
             logPointer: extractString(inner.logPointer, ''),
             errorSummary: extractString(inner.errorSummary, '')
-        }
+        };
     }
 
-    return result
+    return result;
 }
 
 /**
@@ -87,17 +87,17 @@ export function parseStageResults(stageResultsMap) {
  */
 export function computeTestStatus(stageResults) {
     if (!stageResults || typeof stageResults !== 'object') {
-        return 'pass'
+        return 'pass';
     }
 
     for (const stage of STAGE_ORDER) {
-        const result = stageResults[stage]
+        const result = stageResults[stage];
         if (result && result.status === 'fail') {
-            return `fail-${stage}`
+            return `fail-${stage}`;
         }
     }
 
-    return 'pass'
+    return 'pass';
 }
 
 /**
@@ -113,29 +113,29 @@ export function computeTestStatus(stageResults) {
  */
 export function applySkipLogic(stageResults, failedStage) {
     if (!failedStage || !stageResults) {
-        return stageResults || {}
+        return stageResults || {};
     }
 
-    const failedIndex = STAGE_ORDER.indexOf(failedStage)
+    const failedIndex = STAGE_ORDER.indexOf(failedStage);
     if (failedIndex === -1) {
-        return stageResults
+        return stageResults;
     }
 
     // Skip all stages after the failed one, except always-run stages
     for (let i = failedIndex + 1; i < STAGE_ORDER.length; i++) {
-        const stage = STAGE_ORDER[i]
+        const stage = STAGE_ORDER[i];
         if (ALWAYS_RUN_STAGES.includes(stage)) {
-            continue
+            continue;
         }
         stageResults[stage] = {
             status: 'skip',
             durationSeconds: 0,
             logPointer: '',
             errorSummary: ''
-        }
+        };
     }
 
-    return stageResults
+    return stageResults;
 }
 
 /**
@@ -151,66 +151,66 @@ export function applySkipLogic(stageResults, failedStage) {
  * @returns {string[]} return.errors - Array of validation error messages
  */
 export function validateStageResultStructure(stageResults) {
-    const errors = []
+    const errors = [];
 
     if (!stageResults || typeof stageResults !== 'object') {
-        return { valid: false, errors: ['stageResults is null or not an object'] }
+        return { valid: false, errors: ['stageResults is null or not an object'] };
     }
 
-    const stageKeys = Object.keys(stageResults)
+    const stageKeys = Object.keys(stageResults);
 
     // Check for exactly 7 entries
     if (stageKeys.length !== 7) {
-        errors.push(`Expected 7 stage entries, found ${stageKeys.length}`)
+        errors.push(`Expected 7 stage entries, found ${stageKeys.length}`);
     }
 
     // Check all required stages are present
     for (const stage of STAGE_ORDER) {
         if (!(stage in stageResults)) {
-            errors.push(`Missing required stage: ${stage}`)
+            errors.push(`Missing required stage: ${stage}`);
         }
     }
 
     // Check for unexpected stages
     for (const key of stageKeys) {
         if (!STAGE_ORDER.includes(key)) {
-            errors.push(`Unexpected stage: ${key}`)
+            errors.push(`Unexpected stage: ${key}`);
         }
     }
 
     // Validate each stage entry has required fields
     for (const stage of STAGE_ORDER) {
-        const entry = stageResults[stage]
-        if (!entry) continue
+        const entry = stageResults[stage];
+        if (!entry) continue;
 
         if (!('status' in entry)) {
-            errors.push(`Stage '${stage}' missing required field: status`)
+            errors.push(`Stage '${stage}' missing required field: status`);
         } else if (!['pass', 'fail', 'skip'].includes(entry.status)) {
-            errors.push(`Stage '${stage}' has invalid status: '${entry.status}'`)
+            errors.push(`Stage '${stage}' has invalid status: '${entry.status}'`);
         }
 
         if (!('durationSeconds' in entry)) {
-            errors.push(`Stage '${stage}' missing required field: durationSeconds`)
+            errors.push(`Stage '${stage}' missing required field: durationSeconds`);
         } else if (typeof entry.durationSeconds !== 'number' || entry.durationSeconds < 0) {
-            errors.push(`Stage '${stage}' has invalid durationSeconds: ${entry.durationSeconds}`)
+            errors.push(`Stage '${stage}' has invalid durationSeconds: ${entry.durationSeconds}`);
         }
 
         if (!('logPointer' in entry)) {
-            errors.push(`Stage '${stage}' missing required field: logPointer`)
+            errors.push(`Stage '${stage}' missing required field: logPointer`);
         }
 
         // errorSummary is required when status is 'fail'
         if (entry.status === 'fail' && !('errorSummary' in entry)) {
-            errors.push(`Stage '${stage}' has status 'fail' but missing errorSummary`)
+            errors.push(`Stage '${stage}' has status 'fail' but missing errorSummary`);
         }
 
         // errorSummary must be at most 500 characters
         if (entry.errorSummary && entry.errorSummary.length > 500) {
-            errors.push(`Stage '${stage}' errorSummary exceeds 500 characters (${entry.errorSummary.length})`)
+            errors.push(`Stage '${stage}' errorSummary exceeds 500 characters (${entry.errorSummary.length})`);
         }
     }
 
-    return { valid: errors.length === 0, errors }
+    return { valid: errors.length === 0, errors };
 }
 
 /**
@@ -223,20 +223,20 @@ export function validateStageResultStructure(stageResults) {
  */
 export function extractErrorSummaries(stageResults) {
     if (!stageResults || typeof stageResults !== 'object') {
-        return []
+        return [];
     }
 
-    const summaries = []
+    const summaries = [];
     for (const stage of STAGE_ORDER) {
-        const entry = stageResults[stage]
+        const entry = stageResults[stage];
         if (entry && entry.status === 'fail' && entry.errorSummary) {
             summaries.push({
                 stage,
                 errorSummary: entry.errorSummary
-            })
+            });
         }
     }
-    return summaries
+    return summaries;
 }
 
 // --- Internal helpers ---
@@ -248,10 +248,10 @@ export function extractErrorSummaries(stageResults) {
  * @returns {string}
  */
 function extractString(value, defaultValue) {
-    if (value === undefined || value === null) return defaultValue
-    if (typeof value === 'string') return value
-    if (value.S !== undefined) return value.S
-    return defaultValue
+    if (value === undefined || value === null) return defaultValue;
+    if (typeof value === 'string') return value;
+    if (value.S !== undefined) return value.S;
+    return defaultValue;
 }
 
 /**
@@ -261,8 +261,8 @@ function extractString(value, defaultValue) {
  * @returns {number}
  */
 function extractNumber(value, defaultValue) {
-    if (value === undefined || value === null) return defaultValue
-    if (typeof value === 'number') return value
-    if (value.N !== undefined) return Number(value.N)
-    return defaultValue
+    if (value === undefined || value === null) return defaultValue;
+    if (typeof value === 'number') return value;
+    if (value.N !== undefined) return Number(value.N);
+    return defaultValue;
 }

package/src/lib/comment-generator.js

@@ -48,7 +48,7 @@ export default class CommentGenerator {
             return '# No accelerator requirements specified';
         }
 
-        const frameworkLabel = config.backend || config.framework
+        const frameworkLabel = config.backend || config.framework;
         const lines = [
             '# Accelerator Compatibility Information',
             `# Framework: ${frameworkLabel} ${config.version}`,
@@ -108,7 +108,7 @@ export default class CommentGenerator {
         }
 
         // Group environment variables by category
-        const frameworkLabel = config.backend || config.framework
+        const frameworkLabel = config.backend || config.framework;
         const groups = this._groupEnvVars(config.envVars, frameworkLabel);
 
         for (const [category, vars] of Object.entries(groups)) {
@@ -196,7 +196,7 @@ export default class CommentGenerator {
         ];
 
         // Framework-specific tips
-        const frameworkLabel = config.backend || config.framework
+        const frameworkLabel = config.backend || config.framework;
         const frameworkTips = this._getFrameworkTroubleshootingTips(frameworkLabel);
         if (frameworkTips.length > 0) {
             lines.push(`# ${frameworkLabel} Common Issues:`);
@@ -260,7 +260,7 @@ export default class CommentGenerator {
      * @returns {string} Deployment header comment
      */
     generateDeploymentHeader(config) {
-        const frameworkLabel = config.backend || config.framework
+        const frameworkLabel = config.backend || config.framework;
         const lines = [
             '#!/bin/bash',
             '#',