@aws/ml-container-creator 0.2.1 → 0.2.2

package/src/lib/config-manager.js

@@ -151,10 +151,10 @@ export default class ConfigManager {
         // Ensure env var collections are properly merged (CLI over config file over registry)
         // this.config already has the fully merged result from all sources
         if (this.config.modelEnvVars && typeof this.config.modelEnvVars === 'object') {
-            finalConfig.modelEnvVars = { ...this.config.modelEnvVars }
+            finalConfig.modelEnvVars = { ...this.config.modelEnvVars };
         }
         if (this.config.serverEnvVars && typeof this.config.serverEnvVars === 'object') {
-            finalConfig.serverEnvVars = { ...this.config.serverEnvVars }
+            finalConfig.serverEnvVars = { ...this.config.serverEnvVars };
         }
 
         // Ensure all parameters from the matrix are included in final config
@@ -169,16 +169,16 @@ export default class ConfigManager {
         // In prompted mode the PromptRunner may do this, but in --skip-prompts
         // mode we need to do it here so the values are available for downstream logic.
         if (finalConfig.deploymentConfig) {
-            const parts = this.deploymentConfigResolver.decompose(finalConfig.deploymentConfig)
-            finalConfig.architecture = parts.architecture
-            finalConfig.backend = parts.backend
+            const parts = this.deploymentConfigResolver.decompose(finalConfig.deploymentConfig);
+            finalConfig.architecture = parts.architecture;
+            finalConfig.backend = parts.backend;
             // For http architecture, engine comes from the --engine CLI option or prompt
             if (parts.architecture === 'http') {
                 if (!finalConfig.engine) {
-                    finalConfig.engine = parts.engine
+                    finalConfig.engine = parts.engine;
                 }
             } else {
-                finalConfig.engine = parts.engine
+                finalConfig.engine = parts.engine;
             }
         }
 
@@ -191,23 +191,23 @@ export default class ConfigManager {
                     // Provide reasonable defaults for missing required parameters
                     if (param === 'modelFormat') {
                         // Infer model format from architecture/engine (skip for transformers/triton)
-                        const architecture = finalConfig.architecture || 'http'
+                        const architecture = finalConfig.architecture || 'http';
                         if (architecture === 'http') {
-                            const engine = finalConfig.engine || 'sklearn'
+                            const engine = finalConfig.engine || 'sklearn';
                             const formatMap = {
                                 'sklearn': 'pkl',
                                 'xgboost': 'json',
                                 'tensorflow': 'keras'
-                            }
-                            finalConfig[param] = formatMap[engine] || 'pkl'
+                            };
+                            finalConfig[param] = formatMap[engine] || 'pkl';
                         }
                     } else if (param === 'instanceType') {
                         // Default to ml.m5.large for http, ml.g5.xlarge for transformers/triton
-                        const architecture = finalConfig.architecture || 'http'
-                        finalConfig[param] = architecture === 'http' ? 'ml.m5.large' : 'ml.g5.xlarge'
+                        const architecture = finalConfig.architecture || 'http';
+                        finalConfig[param] = architecture === 'http' ? 'ml.m5.large' : 'ml.g5.xlarge';
                     } else if (param === 'projectName') {
                         // Generate project name
-                        finalConfig[param] = this._generateProjectName(finalConfig.architecture)
+                        finalConfig[param] = this._generateProjectName(finalConfig.architecture);
                     } else if (config.default !== null) {
                         // Use default value if available
                         finalConfig[param] = config.default;
@@ -327,30 +327,30 @@ export default class ConfigManager {
             'endpointDataCapturePercent',
             'endpointVariantName',
             'endpointVolumeSize'
-        ]
+        ];
         const icParams = [
             'icCpuCount',
             'icMemorySize',
             'icGpuCount',
             'icCopyCount',
             'icModelWeight'
-        ]
+        ];
 
-        const endpointConfig = {}
+        const endpointConfig = {};
         for (const param of endpointParams) {
-            const shortKey = param.replace('endpoint', '')
-            const key = shortKey.charAt(0).toLowerCase() + shortKey.slice(1)
+            const shortKey = param.replace('endpoint', '');
+            const key = shortKey.charAt(0).toLowerCase() + shortKey.slice(1);
             if (this.config[param] !== undefined && this.config[param] !== null) {
-                endpointConfig[key] = this.config[param]
+                endpointConfig[key] = this.config[param];
             }
         }
 
-        const icConfig = {}
+        const icConfig = {};
         for (const param of icParams) {
-            const shortKey = param.replace('ic', '')
-            const key = shortKey.charAt(0).toLowerCase() + shortKey.slice(1)
+            const shortKey = param.replace('ic', '');
+            const key = shortKey.charAt(0).toLowerCase() + shortKey.slice(1);
             if (this.config[param] !== undefined && this.config[param] !== null) {
-                icConfig[key] = this.config[param]
+                icConfig[key] = this.config[param];
             }
         }
 
@@ -360,11 +360,11 @@ export default class ConfigManager {
             ...icParams,
             'modelEnvVars',
             'serverEnvVars'
-        ])
-        const core = {}
+        ]);
+        const core = {};
         for (const [key, value] of Object.entries(this.config)) {
             if (!excludedFromCore.has(key) && key !== '_sourceManifest') {
-                core[key] = value
+                core[key] = value;
             }
         }
 
@@ -375,7 +375,7 @@ export default class ConfigManager {
             modelEnvVars: { ...(this.config.modelEnvVars || {}) },
             serverEnvVars: { ...(this.config.serverEnvVars || {}) },
             manifest: [...this._sourceManifest]
-        }
+        };
     }
 
     /**
@@ -388,27 +388,27 @@ export default class ConfigManager {
     mergeRegistryEnvVars(registryModelEnvVars = {}, registryServerEnvVars = {}) {
         // Initialize collections if needed
         if (!this.config.modelEnvVars || typeof this.config.modelEnvVars !== 'object') {
-            this.config.modelEnvVars = {}
+            this.config.modelEnvVars = {};
         }
         if (!this.config.serverEnvVars || typeof this.config.serverEnvVars !== 'object') {
-            this.config.serverEnvVars = {}
+            this.config.serverEnvVars = {};
         }
 
         // Merge registry model env vars (CLI takes precedence)
         Object.entries(registryModelEnvVars).forEach(([key, value]) => {
             if (!(key in this.config.modelEnvVars)) {
-                this.config.modelEnvVars[key] = value
-                this._recordSource(`modelEnvVars.${key}`, value, 'registry')
+                this.config.modelEnvVars[key] = value;
+                this._recordSource(`modelEnvVars.${key}`, value, 'registry');
             }
-        })
+        });
 
         // Merge registry server env vars (CLI takes precedence)
         Object.entries(registryServerEnvVars).forEach(([key, value]) => {
             if (!(key in this.config.serverEnvVars)) {
-                this.config.serverEnvVars[key] = value
-                this._recordSource(`serverEnvVars.${key}`, value, 'registry')
+                this.config.serverEnvVars[key] = value;
+                this._recordSource(`serverEnvVars.${key}`, value, 'registry');
             }
-        })
+        });
     }
 
     /**
@@ -978,16 +978,16 @@ export default class ConfigManager {
         // 1. The default is already a number (e.g. endpointInitialInstanceCount default: 1)
         // 2. The parameter is schema-validated, default is null, and the value is purely numeric
         //    (string defaults like 'AllTraffic' won't match since their default type is string)
-        const paramConfig = this.parameterMatrix[parameter]
+        const paramConfig = this.parameterMatrix[parameter];
         if (paramConfig && typeof value === 'string') {
-            const hasNumericDefault = (typeof paramConfig.default === 'number')
+            const hasNumericDefault = (typeof paramConfig.default === 'number');
             const isNullDefaultNumericParam = (paramConfig.default === null &&
                 paramConfig.schemaValidated &&
-                /^-?\d+(\.\d+)?$/.test(value))
+                /^-?\d+(\.\d+)?$/.test(value));
             if (hasNumericDefault || isNullDefaultNumericParam) {
-                const num = Number(value)
+                const num = Number(value);
                 if (!isNaN(num)) {
-                    return num
+                    return num;
                 }
             }
         }
@@ -1006,7 +1006,7 @@ export default class ConfigManager {
         Object.entries(this.parameterMatrix).forEach(([param, config]) => {
             if (config.default !== null) {
                 defaults[param] = config.default;
-                this._recordSource(param, config.default, 'default')
+                this._recordSource(param, config.default, 'default');
             } else {
                 defaults[param] = null;
             }
@@ -1228,15 +1228,15 @@ export default class ConfigManager {
                     dataCapturePercent: 'endpointDataCapturePercent',
                     variantName: 'endpointVariantName',
                     volumeSize: 'endpointVolumeSize'
-                }
+                };
                 Object.entries(value).forEach(([nestedKey, nestedValue]) => {
-                    const flatKey = endpointMapping[nestedKey]
+                    const flatKey = endpointMapping[nestedKey];
                     if (flatKey && this._isSourceSupported(flatKey, 'configFile')) {
-                        filteredConfig[flatKey] = nestedValue
-                        this._recordSource(flatKey, nestedValue, 'config-file')
+                        filteredConfig[flatKey] = nestedValue;
+                        this._recordSource(flatKey, nestedValue, 'config-file');
                     }
-                })
-                return
+                });
+                return;
             }
 
             // Handle nested icConfig object
@@ -1247,52 +1247,52 @@ export default class ConfigManager {
                     gpuCount: 'icGpuCount',
                     copyCount: 'icCopyCount',
                     modelWeight: 'icModelWeight'
-                }
+                };
                 Object.entries(value).forEach(([nestedKey, nestedValue]) => {
-                    const flatKey = icMapping[nestedKey]
+                    const flatKey = icMapping[nestedKey];
                     if (flatKey && this._isSourceSupported(flatKey, 'configFile')) {
-                        filteredConfig[flatKey] = nestedValue
-                        this._recordSource(flatKey, nestedValue, 'config-file')
+                        filteredConfig[flatKey] = nestedValue;
+                        this._recordSource(flatKey, nestedValue, 'config-file');
                     }
-                })
-                return
+                });
+                return;
             }
 
             // Handle modelEnvVars object (merge with CLI, CLI takes precedence)
             if (key === 'modelEnvVars' && typeof value === 'object' && value !== null) {
                 if (!this.config.modelEnvVars) {
-                    this.config.modelEnvVars = {}
+                    this.config.modelEnvVars = {};
                 }
                 // Only set keys not already provided by CLI (CLI has higher precedence)
-                const cliModelEnvVars = (this.explicitConfig && this.explicitConfig.modelEnvVars) || {}
+                const cliModelEnvVars = (this.explicitConfig && this.explicitConfig.modelEnvVars) || {};
                 Object.entries(value).forEach(([envKey, envValue]) => {
                     if (!(envKey in cliModelEnvVars)) {
-                        this.config.modelEnvVars[envKey] = envValue
-                        this._recordSource(`modelEnvVars.${envKey}`, envValue, 'config-file')
+                        this.config.modelEnvVars[envKey] = envValue;
+                        this._recordSource(`modelEnvVars.${envKey}`, envValue, 'config-file');
                     }
-                })
-                return
+                });
+                return;
             }
 
             // Handle serverEnvVars object (merge with CLI, CLI takes precedence)
             if (key === 'serverEnvVars' && typeof value === 'object' && value !== null) {
                 if (!this.config.serverEnvVars) {
-                    this.config.serverEnvVars = {}
+                    this.config.serverEnvVars = {};
                 }
                 // Only set keys not already provided by CLI (CLI has higher precedence)
-                const cliServerEnvVars = (this.explicitConfig && this.explicitConfig.serverEnvVars) || {}
+                const cliServerEnvVars = (this.explicitConfig && this.explicitConfig.serverEnvVars) || {};
                 Object.entries(value).forEach(([envKey, envValue]) => {
                     if (!(envKey in cliServerEnvVars)) {
-                        this.config.serverEnvVars[envKey] = envValue
-                        this._recordSource(`serverEnvVars.${envKey}`, envValue, 'config-file')
+                        this.config.serverEnvVars[envKey] = envValue;
+                        this._recordSource(`serverEnvVars.${envKey}`, envValue, 'config-file');
                     }
-                })
-                return
+                });
+                return;
             }
 
             if (this._isSourceSupported(key, 'configFile')) {
                 filteredConfig[key] = this._parseValue(key, value);
-                this._recordSource(key, this._parseValue(key, value), 'config-file')
+                this._recordSource(key, this._parseValue(key, value), 'config-file');
             }
         });
         this._mergeConfig(filteredConfig);
@@ -1315,7 +1315,7 @@ export default class ConfigManager {
             const value = process.env[envVar];
             if (value !== undefined && value !== '' && this._isSourceSupported(configKey, 'envVar')) {
                 this.config[configKey] = this._parseValue(configKey, value);
-                this._recordSource(configKey, this._parseValue(configKey, value), 'env-var')
+                this._recordSource(configKey, this._parseValue(configKey, value), 'env-var');
                 // Track as explicit configuration — unless the env var is ambient
                 // (e.g. AWS_REGION is commonly set in shells as a default, not an override)
                 if (!ambient) {
@@ -1357,7 +1357,7 @@ export default class ConfigManager {
         Object.entries(this.parameterMatrix).forEach(([param, config]) => {
             if (config.cliOption && options[config.cliOption] !== undefined) {
                 this.config[param] = this._parseValue(param, options[config.cliOption]);
-                this._recordSource(param, this._parseValue(param, options[config.cliOption]), 'cli')
+                this._recordSource(param, this._parseValue(param, options[config.cliOption]), 'cli');
                 // Track as explicit configuration
                 if (!this.explicitConfig) {
                     this.explicitConfig = {};
@@ -1401,7 +1401,7 @@ export default class ConfigManager {
             }
             const { key, value } = parseKeyValue(entry);
             this.config[configKey][key] = value;
-            this._recordSource(`${configKey}.${key}`, value, 'cli')
+            this._recordSource(`${configKey}.${key}`, value, 'cli');
         }
 
         // Track as explicit configuration
@@ -1539,11 +1539,11 @@ export default class ConfigManager {
      * @private
      */
     _recordSource(param, value, source) {
-        const existingIndex = this._sourceManifest.findIndex(entry => entry.param === param)
+        const existingIndex = this._sourceManifest.findIndex(entry => entry.param === param);
         if (existingIndex >= 0) {
-            this._sourceManifest[existingIndex] = { param, value, source }
+            this._sourceManifest[existingIndex] = { param, value, source };
         } else {
-            this._sourceManifest.push({ param, value, source })
+            this._sourceManifest.push({ param, value, source });
         }
     }
 
@@ -1561,9 +1561,9 @@ export default class ConfigManager {
         // Special case: modelFormat is not required for transformers/triton/diffusors architectures
         const requiredForConfig = promptableRequired.filter(param => {
             if (param === 'modelFormat') {
-                const architecture = this.config.architecture
+                const architecture = this.config.architecture;
                 if (architecture === 'transformers' || architecture === 'triton' || architecture === 'diffusors') {
-                    return false
+                    return false;
                 }
             }
             return true;
@@ -1590,38 +1590,38 @@ export default class ConfigManager {
             'xgboost-fastapi': 'Use --deployment-config=http-fastapi --engine=xgboost instead',
             'tensorflow-flask': 'Use --deployment-config=http-flask --engine=tensorflow instead',
             'tensorflow-fastapi': 'Use --deployment-config=http-fastapi --engine=tensorflow instead'
-        }
+        };
 
         // Validate deployment-config
         if (this.config.deploymentConfig) {
-            const migrationMsg = oldFormatMigration[this.config.deploymentConfig]
+            const migrationMsg = oldFormatMigration[this.config.deploymentConfig];
             if (migrationMsg) {
-                errors.push(`Unsupported deployment-config: ${this.config.deploymentConfig}. This value has been replaced. ${migrationMsg}`)
+                errors.push(`Unsupported deployment-config: ${this.config.deploymentConfig}. This value has been replaced. ${migrationMsg}`);
             } else if (!this.deploymentConfigResolver.isValid(this.config.deploymentConfig)) {
-                const valid = this.deploymentConfigResolver.getAllConfigs().join(', ')
-                errors.push(`Unsupported deployment-config: ${this.config.deploymentConfig}. Valid configs: ${valid}`)
+                const valid = this.deploymentConfigResolver.getAllConfigs().join(', ');
+                errors.push(`Unsupported deployment-config: ${this.config.deploymentConfig}. Valid configs: ${valid}`);
             }
         }
 
         // Validate engine (only valid for http architecture)
         if (this.config.engine) {
-            const validEngines = ['sklearn', 'xgboost', 'tensorflow']
+            const validEngines = ['sklearn', 'xgboost', 'tensorflow'];
             if (!validEngines.includes(this.config.engine)) {
-                errors.push(`Unsupported engine: ${this.config.engine}. Supported: ${validEngines.join(', ')}`)
+                errors.push(`Unsupported engine: ${this.config.engine}. Supported: ${validEngines.join(', ')}`);
             }
         }
 
         // Validate model format based on architecture/engine
         if (this.config.modelFormat && this.config.deploymentConfig) {
             try {
-                const parts = this.deploymentConfigResolver.decompose(this.config.deploymentConfig)
+                const parts = this.deploymentConfigResolver.decompose(this.config.deploymentConfig);
                 if (parts.architecture === 'http') {
-                    const engine = this.config.engine || parts.engine
+                    const engine = this.config.engine || parts.engine;
                     if (engine) {
-                        const supportedOptions = this._getSupportedOptions()
-                        const validFormats = supportedOptions.modelFormats[engine] || []
+                        const supportedOptions = this._getSupportedOptions();
+                        const validFormats = supportedOptions.modelFormats[engine] || [];
                         if (validFormats.length > 0 && !validFormats.includes(this.config.modelFormat)) {
-                            errors.push(`Unsupported model format '${this.config.modelFormat}' for engine '${engine}'. Supported: ${validFormats.join(', ')}`)
+                            errors.push(`Unsupported model format '${this.config.modelFormat}' for engine '${engine}'. Supported: ${validFormats.join(', ')}`);
                         }
                     }
                 }
@@ -1672,13 +1672,13 @@ export default class ConfigManager {
                     // Special case: modelFormat is not required for transformers/triton/diffusors
                     if (param === 'modelFormat') {
                         try {
-                            const parts = this.deploymentConfigResolver.decompose(this.config.deploymentConfig)
+                            const parts = this.deploymentConfigResolver.decompose(this.config.deploymentConfig);
                             if (parts.architecture === 'transformers' || parts.architecture === 'triton' || parts.architecture === 'diffusors') {
-                                return
+                                return;
                             }
                         } catch {
                             // If deploymentConfig is invalid, skip this check
-                            return
+                            return;
                         }
                     }
                     
@@ -1692,11 +1692,11 @@ export default class ConfigManager {
             // Validate that modelName is provided for diffusors architecture
             if (this.config.deploymentConfig) {
                 try {
-                    const parts = this.deploymentConfigResolver.decompose(this.config.deploymentConfig)
+                    const parts = this.deploymentConfigResolver.decompose(this.config.deploymentConfig);
                     if (parts.architecture === 'diffusors') {
-                        const explicitModelName = this.explicitConfig && this.explicitConfig.modelName
+                        const explicitModelName = this.explicitConfig && this.explicitConfig.modelName;
                         if (!explicitModelName) {
-                            errors.push('Model name is required for diffusors architecture. Use --model-name to specify a HuggingFace diffusion model.')
+                            errors.push('Model name is required for diffusors architecture. Use --model-name to specify a HuggingFace diffusion model.');
                         }
                     }
                 } catch {
@@ -1708,12 +1708,12 @@ export default class ConfigManager {
         // Validate schema-validated parameters (endpoint, iC)
         Object.entries(this.parameterMatrix).forEach(([param, config]) => {
             if (config.schemaValidated && this.config[param] !== null && this.config[param] !== undefined) {
-                const result = this.schemaValidator.validate(param, this.config[param], this.config.deploymentTarget)
+                const result = this.schemaValidator.validate(param, this.config[param], this.config.deploymentTarget);
                 if (!result.valid) {
-                    errors.push(result.error)
+                    errors.push(result.error);
                 }
             }
-        })
+        });
 
         return errors;
     }
@@ -1914,38 +1914,38 @@ export default class ConfigManager {
                     'xgboost-fastapi': 'Use --deployment-config=http-fastapi --engine=xgboost instead',
                     'tensorflow-flask': 'Use --deployment-config=http-flask --engine=tensorflow instead',
                     'tensorflow-fastapi': 'Use --deployment-config=http-fastapi --engine=tensorflow instead'
-                }
-                const migrationMsg = oldFormatMigration[value]
+                };
+                const migrationMsg = oldFormatMigration[value];
                 if (migrationMsg) {
                     throw new ValidationError(
                         `Unsupported deployment-config: ${value}. This value has been replaced. ${migrationMsg}`,
                         parameter,
                         value
-                    )
+                    );
                 }
                 if (!this.deploymentConfigResolver.isValid(value)) {
-                    const valid = this.deploymentConfigResolver.getAllConfigs().join(', ')
+                    const valid = this.deploymentConfigResolver.getAllConfigs().join(', ');
                     throw new ValidationError(
                         `Unsupported deployment-config: ${value}. Valid configs: ${valid}`,
                         parameter,
                         value
-                    )
+                    );
                 }
             }
-            break
+            break;
 
         case 'engine':
             if (value) {
-                const validEngines = ['sklearn', 'xgboost', 'tensorflow']
+                const validEngines = ['sklearn', 'xgboost', 'tensorflow'];
                 if (!validEngines.includes(value)) {
                     throw new ValidationError(
                         `Unsupported engine: ${value}. Supported: ${validEngines.join(', ')}`,
                         parameter,
                         value
-                    )
+                    );
                 }
             }
-            break
+            break;
                 
         case 'modelFormat':
             if (value && context.architecture === 'http' && context.engine) {

package/src/lib/deployment-config-resolver.js

@@ -36,8 +36,8 @@ const CANONICAL_CONFIGS = new Map([
     ['triton-python',           { architecture: 'triton',       backend: 'python',        engine: null }],
 
     // Diffusors architecture (1)
-    ['diffusors-vllm-omni',     { architecture: 'diffusors',    backend: 'vllm-omni',     engine: null }],
-])
+    ['diffusors-vllm-omni',     { architecture: 'diffusors',    backend: 'vllm-omni',     engine: null }]
+]);
 
 export default class DeploymentConfigResolver {
     /**
@@ -48,14 +48,14 @@ export default class DeploymentConfigResolver {
      * @throws {Error} if the deployment-config is not one of the 15 canonical values
      */
     decompose(deploymentConfig) {
-        const parts = CANONICAL_CONFIGS.get(deploymentConfig)
+        const parts = CANONICAL_CONFIGS.get(deploymentConfig);
         if (!parts) {
-            const valid = this.getAllConfigs().join(', ')
+            const valid = this.getAllConfigs().join(', ');
             throw new Error(
                 `Unsupported deployment-config: ${deploymentConfig}. Valid configs: ${valid}`
-            )
+            );
         }
-        return { ...parts }
+        return { ...parts };
     }
 
     /**
@@ -66,7 +66,7 @@ export default class DeploymentConfigResolver {
      * @returns {string}
      */
     compose(parts) {
-        return `${parts.architecture}-${parts.backend}`
+        return `${parts.architecture}-${parts.backend}`;
     }
 
     /**
@@ -75,7 +75,7 @@ export default class DeploymentConfigResolver {
      * @returns {string[]}
      */
     getAllConfigs() {
-        return [...CANONICAL_CONFIGS.keys()]
+        return [...CANONICAL_CONFIGS.keys()];
     }
 
     /**
@@ -87,7 +87,7 @@ export default class DeploymentConfigResolver {
     getConfigsForArchitecture(architecture) {
         return this.getAllConfigs().filter(
             (dc) => CANONICAL_CONFIGS.get(dc).architecture === architecture
-        )
+        );
     }
 
     /**
@@ -98,6 +98,6 @@ export default class DeploymentConfigResolver {
      * @returns {boolean}
      */
     isValid(deploymentConfig) {
-        return CANONICAL_CONFIGS.has(deploymentConfig)
+        return CANONICAL_CONFIGS.has(deploymentConfig);
     }
 }