11034 extend configuration

lib/serverless.js

@@ -2,6 +2,7 @@
 
 const path = require('path');
 const os = require('os');
+const _ = require('lodash');
 const ensureString = require('type/string/ensure');
 const ensureValue = require('type/value/ensure');
 const ensureArray = require('type/array/ensure');
@@ -23,6 +24,7 @@ const eventuallyUpdate = require('./utils/eventually-update');
 const commmandsSchema = require('./cli/commands-schema');
 const resolveCliInput = require('./cli/resolve-input');
 const isDashboardEnabled = require('./configuration/is-dashboard-enabled');
+const parseEntries = require('./configuration/variables/resolve-meta').parseEntries;
 
 // Old local fallback is triggered in older versions by Serverless constructor directly
 const isStackFromOldLocalFallback = RegExp.prototype.test.bind(
@@ -99,6 +101,7 @@ class Serverless {
     // Old variables resolver is dropped, yet some plugins access service properties through
     // `variables` class. Below patch ensures those plugins won't get broken
     this.variables = { service: this.service };
+    this.variablesMeta = config.variablesMeta;
     this.pluginManager = new PluginManager(this);
     this.configSchemaHandler = new ConfigSchemaHandler(this);
 
@@ -116,6 +119,7 @@ class Serverless {
     this.serverlessDirPath = path.join(os.homedir(), '.serverless');
     this.isStandaloneExecutable = isStandaloneExecutable;
     this.triggeredDeprecations = logDeprecation.triggeredDeprecations;
+    this.isConfigurationExtendable = true;
 
     // TODO: Remove once "@serverless/dashboard-plugin" is integrated into this repository
     this._commandsSchema = commmandsSchema;
@@ -136,6 +140,7 @@ class Serverless {
     await this.service.load(this.processedInput.options);
     // load all plugins
     await this.pluginManager.loadAllPlugins(this.service.plugins);
+    this.isConfigurationExtendable = false;
     // give the CLI the plugins and commands so that it can print out
     // information such as options when the user enters --help
     this.cli.setLoadedPlugins(this.pluginManager.getPlugins());
@@ -215,6 +220,49 @@ class Serverless {
   logDeprecation(code, message) {
     return this._logDeprecation(`EXT_${ensureString(code)}`, ensureString(message));
   }
+
+  extendConfiguration(configurationPathKeys, value) {
+    ensureArray(configurationPathKeys, {
+      ensureItem: ensureString,
+    });
+    if (configurationPathKeys.length < 1) {
+      throw new ServerlessError(
+        'ConfigurationPathKeys needs to contain at least one element.',
+        'INVALID_EXTEND_AFTER_INIT'
+      );
+    }
+
+    if (!this.isConfigurationExtendable) {
+      throw new ServerlessError(
+        'ExtendConfiguration cannot be used after init.',
+        'INVALID_EXTEND_AFTER_INIT'
+      );
+    }
+    try {
+      value = JSON.parse(JSON.stringify(value));
+    } catch (error) {
+      throw new ServerlessError(
+        'ExtendConfiguration called with invalid data. Value is not json-serializable. Error: ${error}',
+        'INVALID_EXTEND_VALUE'
+      );
+    }
+
+    const configurationPath = configurationPathKeys.join('.');
+    _.set(this.configurationInput, configurationPath, value);
+
+    const metaPathPrefix = configurationPathKeys.join('\0');
+    for (const key of this.variablesMeta.keys()) {
+      if (key.startsWith(metaPathPrefix)) {
+        this.variablesMeta.delete(key);
+      }
+    }
+    if (typeof value !== 'object') {
+      const lastKey = configurationPathKeys.pop();
+      parseEntries({ [lastKey]: value }, configurationPathKeys, this.variablesMeta);
+    } else {
+      parseEntries(Object.entries(value), configurationPathKeys, this.variablesMeta);
+    }
+  }
 }
 
 module.exports = Serverless;

scripts/serverless.js

@@ -598,6 +598,7 @@ processSpanPromise = (async () => {
         commands[0] === 'plugin' || Boolean(variablesMeta && !variablesMeta.size),
       commands,
       options,
+      variablesMeta,
     });
 
     try {

test/unit/lib/serverless.test.js

@@ -1,8 +1,10 @@
 'use strict';
 
 const chai = require('chai');
+const sinon = require('sinon');
 
 chai.use(require('chai-as-promised'));
+chai.use(require('sinon-chai'));
 
 const { expect } = chai;
 
@@ -174,4 +176,151 @@ describe('test/unit/lib/serverless.test.js', () => {
       expect(serverless.config).to.have.property('servicePath');
     });
   });
+
+  describe('Extend configuration', () => {
+    let serverless;
+    let parseEntriesStub;
+
+    before(async () => {
+      parseEntriesStub = sinon.stub().returns(new Map([]));
+      try {
+        await runServerless({
+          noService: true,
+          command: 'info',
+          modulesCacheStub: {
+            './lib/configuration/variables/resolve-meta': {
+              parseEntries: parseEntriesStub,
+            },
+          },
+          hooks: {
+            beforeInstanceInit: (serverlessInstance) => {
+              serverless = serverlessInstance;
+              throw Error('Stop serverless before init.');
+            },
+          },
+        });
+      } catch (error) {
+        // Not an error
+      }
+
+      serverless.pluginManager = sinon.createStubInstance(PluginManager);
+      serverless.classes.CLI = sinon.stub(serverless.classes.CLI);
+    });
+
+    after(() => {
+      sinon.restore();
+    });
+
+    beforeEach(async () => {
+      serverless.isConfigurationExtendable = true;
+      serverless.variablesMeta = new Map([]);
+    });
+
+    it('Should add configuration path if it not exists', async () => {
+      const initialConfig = {
+        'pre-existing': {
+          path: true,
+        },
+      };
+
+      const path = 'path.to.insert';
+      const value = {
+        newKey: 'value',
+      };
+      serverless.configurationInput = JSON.parse(JSON.stringify(initialConfig));
+      serverless.extendConfiguration(path.split('.'), value);
+
+      expect(serverless.configurationInput).to.deep.include(initialConfig);
+      expect(serverless.configurationInput).to.deep.nested.include({ [path]: value });
+    });
+
+    it('Should assign configuration object if it exists', async () => {
+      const path = 'pre-existing';
+      const initialConfig = {
+        [path]: {
+          path: true,
+        },
+      };
+
+      const value = {
+        newKey: 'value',
+      };
+      serverless.configurationInput = JSON.parse(JSON.stringify(initialConfig));
+      serverless.extendConfiguration(path.split('.'), value);
+
+      expect(serverless.configurationInput[path]).to.deep.include(value);
+    });
+
+    it('Should assign trivial types', async () => {
+      const path = 'pre-existing';
+      const initialConfig = {
+        [path]: 'some string',
+      };
+      const value = 'other string';
+      serverless.configurationInput = JSON.parse(JSON.stringify(initialConfig));
+      serverless.extendConfiguration(path.split('.'), value);
+      expect(serverless.configurationInput[path]).to.equal(value);
+    });
+
+    it('Should deeply copy the new value', async () => {
+      const path = 'level1';
+      const subpath = 'level2';
+      const subvalue = {
+        level3: 'copy',
+      };
+      const value = {
+        [subpath]: subvalue,
+      };
+      serverless.configurationInput = {};
+      serverless.extendConfiguration(path.split('.'), value);
+
+      expect(serverless.configurationInput[path]).to.not.equal(value);
+      expect(serverless.configurationInput[path][subpath]).to.not.equal(subvalue);
+    });
+
+    it('Should clean variables meta in configurationPath', async () => {
+      const path = 'path.to.insert';
+      const value = {
+        newKey: 'value',
+      };
+      serverless.configurationInput = {};
+      const metaToKeep = ['path.to.keep'].map((_) => _.replace(/\./g, '\0'));
+      const metaToDelete = [path, `${path}.child`].map((_) => _.replace(/\./g, '\0'));
+      const variablesMeta = metaToKeep.concat(metaToDelete);
+
+      const keyStub = sinon.stub(serverless.variablesMeta, 'keys');
+      keyStub.returns(variablesMeta);
+
+      const deleteStub = sinon.stub(serverless.variablesMeta, 'delete');
+
+      serverless.extendConfiguration(path.split('.'), value);
+
+      metaToDelete.forEach((meta) => {
+        expect(deleteStub).to.have.been.calledWith(meta);
+      });
+    });
+
+    it('Should throw if called after init', async () => {
+      let localServerless;
+      await runServerless({
+        config: {
+          service: 'test',
+          provider: {
+            name: 'aws',
+          },
+        },
+        command: 'print',
+        hooks: {
+          beforeInstanceInit: (serverlessInstance) => {
+            localServerless = serverlessInstance;
+            const { hooks: lifecycleHooks } = serverlessInstance.pluginManager;
+            for (const hookName of Object.keys(lifecycleHooks)) {
+              delete lifecycleHooks[hookName];
+            }
+          },
+        },
+      });
+      expect(() => localServerless.extendConfiguration([], {})).to.throw(ServerlessError);
+    });
+  });
 });