From 02c254f15fa9299df6ea2b35d5cb06606d55d1a1 Mon Sep 17 00:00:00 2001 From: Jeremy Benoist Date: Fri, 18 Oct 2024 10:25:28 +0200 Subject: [PATCH] Re-add `${param:...}` variable It was part of the dashboard plugin because I guess some values might come from it. I extracted only the interesting part without the dashboard stuff. Unit tests are ok. I tested it on few projects and it works as expected. --- .../sources/instance-dependent/param.js | 64 ++++++++++ scripts/serverless.js | 11 +- .../sources/instance-dependent/param.test.js | 114 ++++++++++++++++++ 3 files changed, 183 insertions(+), 6 deletions(-) create mode 100644 lib/configuration/variables/sources/instance-dependent/param.js create mode 100644 test/unit/lib/configuration/variables/sources/instance-dependent/param.test.js diff --git a/lib/configuration/variables/sources/instance-dependent/param.js b/lib/configuration/variables/sources/instance-dependent/param.js new file mode 100644 index 0000000000..802c1b7844 --- /dev/null +++ b/lib/configuration/variables/sources/instance-dependent/param.js @@ -0,0 +1,64 @@ +'use strict'; + +const _ = require('lodash'); +const memoizee = require('memoizee'); +const ensureString = require('type/string/ensure'); +const ServerlessError = require('../../../../serverless-error'); + +const resolveParams = memoizee(async (stage, serverlessInstance) => { + const configParams = new Map( + Object.entries(_.get(serverlessInstance.configurationInput, 'params') || {}) + ); + + const resultParams = Object.create(null); + + for (const [name, value] of Object.entries(configParams.get(stage) || {})) { + if (value == null) continue; + if (resultParams[name] != null) continue; + resultParams[name] = { value, type: 'configServiceStage' }; + } + + for (const [name, value] of new Map(Object.entries(configParams.get('default') || {}))) { + if (value == null) continue; + if (resultParams[name] != null) continue; + resultParams[name] = { value, type: 'configService' }; + } + + return resultParams; +}); + +module.exports = (serverlessInstance) => { + return { + resolve: async ({ address, resolveConfigurationProperty, options }) => { + if (!address) { + throw new ServerlessError( + 'Missing address argument in variable "param" source', + 'MISSING_PARAM_SOURCE_ADDRESS' + ); + } + address = ensureString(address, { + Error: ServerlessError, + errorMessage: 'Non-string address argument in variable "param" source: %v', + errorCode: 'INVALID_PARAM_SOURCE_ADDRESS', + }); + if (!serverlessInstance) return { value: null, isPending: true }; + + let stage = options.stage; + if (!stage) stage = await resolveConfigurationProperty(['provider', 'stage']); + if (!stage) stage = 'dev'; + + const params = await resolveParams(stage, serverlessInstance); + const value = params[address] ? params[address].value : null; + const result = { value }; + + if (value == null) { + throw new ServerlessError( + `The param "${address}" cannot be resolved from stage params. If you are using Serverless Framework Compose, make sure to run commands via Compose so that all parameters can be resolved`, + 'MISSING_PARAM_SOURCE_ADDRESS' + ); + } + + return result; + }, + }; +}; diff --git a/scripts/serverless.js b/scripts/serverless.js index 696ab37521..f39f72095b 100755 --- a/scripts/serverless.js +++ b/scripts/serverless.js @@ -46,7 +46,7 @@ const finalize = async ({ error, shouldBeSync } = {}) => { hasBeenFinalized = true; clearTimeout(keepAliveTimer); progress.clear(); - if (error) (handleError(error, { serverless })); + if (error) handleError(error, { serverless }); if (!shouldBeSync) { await logDeprecation.printSummary(); } @@ -474,11 +474,7 @@ process.once('uncaughtException', (error) => { // Names of the commands which are configured independently in root `commands` folder // and not in Serverless class internals - const notIntegratedCommands = new Set([ - 'doctor', - 'plugin install', - 'plugin uninstall', - ]); + const notIntegratedCommands = new Set(['doctor', 'plugin install', 'plugin uninstall']); const isStandaloneCommand = notIntegratedCommands.has(command); if (!isHelpRequest) { @@ -564,6 +560,7 @@ process.once('uncaughtException', (error) => { self: require('../lib/configuration/variables/sources/self'), strToBool: require('../lib/configuration/variables/sources/str-to-bool'), sls: require('../lib/configuration/variables/sources/instance-dependent/get-sls')(), + param: require('../lib/configuration/variables/sources/instance-dependent/param')(), }, options: filterSupportedOptions(options, { commandSchema, providerName }), fulfilledSources: new Set(['env', 'file', 'self', 'strToBool']), @@ -588,6 +585,8 @@ process.once('uncaughtException', (error) => { require('../lib/configuration/variables/sources/instance-dependent/get-sls')(serverless); resolverConfiguration.fulfilledSources.add('sls'); + resolverConfiguration.sources.param = + require('../lib/configuration/variables/sources/instance-dependent/param')(serverless); resolverConfiguration.fulfilledSources.add('param'); // Register AWS provider specific variable sources diff --git a/test/unit/lib/configuration/variables/sources/instance-dependent/param.test.js b/test/unit/lib/configuration/variables/sources/instance-dependent/param.test.js new file mode 100644 index 0000000000..8d715938ce --- /dev/null +++ b/test/unit/lib/configuration/variables/sources/instance-dependent/param.test.js @@ -0,0 +1,114 @@ +'use strict'; + +const { expect } = require('chai'); +const _ = require('lodash'); + +const resolveMeta = require('../../../../../../../lib/configuration/variables/resolve-meta'); +const resolve = require('../../../../../../../lib/configuration/variables/resolve'); +const selfSource = require('../../../../../../../lib/configuration/variables/sources/self'); +const getParamSource = require('../../../../../../../lib/configuration/variables/sources/instance-dependent/param'); +const Serverless = require('../../../../../../../lib/serverless'); + +describe('test/unit/lib/configuration/variables/sources/instance-dependent/param.test.js', () => { + let configuration; + let variablesMeta; + let serverlessInstance; + + const initializeServerless = async ({ configExt, options, setupOptions = {} } = {}) => { + configuration = { + service: 'foo', + provider: { + name: 'aws', + deploymentBucket: '${param:bucket}', + timeout: '${param:timeout}', + }, + custom: { + missingAddress: '${param:}', + unsupportedAddress: '${param:foo}', + nonStringAddress: '${param:${self:custom.someObject}}', + someObject: {}, + }, + params: { + default: { + bucket: 'global.bucket', + timeout: 10, + }, + dev: { + bucket: 'my.bucket', + }, + }, + }; + if (configExt) { + configuration = _.merge(configuration, configExt); + } + variablesMeta = resolveMeta(configuration); + serverlessInstance = new Serverless({ + configuration, + serviceDir: process.cwd(), + configurationFilename: 'serverless.yml', + commands: ['package'], + options: options || {}, + }); + serverlessInstance.init(); + await resolve({ + serviceDir: process.cwd(), + configuration, + variablesMeta, + sources: { + self: selfSource, + param: getParamSource(setupOptions.withoutInstance ? null : serverlessInstance), + }, + options: options || {}, + fulfilledSources: new Set(['self', 'param']), + }); + }; + + it('should resolve ${param:timeout}', async () => { + await initializeServerless(); + if (variablesMeta.get('param\0timeout')) throw variablesMeta.get('param\0timeout').error; + expect(configuration.provider.timeout).to.equal(10); + }); + + it('should resolve ${param:bucket} for different stages', async () => { + // Dev by default + await initializeServerless(); + expect(configuration.provider.deploymentBucket).to.equal('my.bucket'); + + // Forced prod + await initializeServerless({ + configExt: { + provider: { + stage: 'prod', + }, + }, + }); + expect(configuration.provider.deploymentBucket).to.equal('global.bucket'); + }); + + it('should resolve ${param:bucket} when no serverless instance available', async () => { + await initializeServerless({ setupOptions: { withoutInstance: true } }); + expect(variablesMeta.get('provider\0timeout')).to.have.property('variables'); + expect(variablesMeta.get('provider\0timeout')).to.not.have.property('error'); + }); + + it('should report with an error missing address', async () => { + await initializeServerless(); + expect(variablesMeta.get('custom\0missingAddress').error.code).to.equal( + 'VARIABLE_RESOLUTION_ERROR' + ); + }); + + it('should report with an error unsupported address', async () => { + await initializeServerless(); + expect(variablesMeta.get('custom\0unsupportedAddress').error.code).to.equal( + 'VARIABLE_RESOLUTION_ERROR' + ); + }); + + it('should report with an error a non-string address', async () => { + await initializeServerless(); + expect(variablesMeta.get('custom\0nonStringAddress').error.code).to.equal( + 'VARIABLE_RESOLUTION_ERROR' + ); + }); +});