index.js

'use strict';

/**
 * Serverless AWS alias plugin
 */

const BbPromise = require('bluebird')
	, _ = require('lodash')
	, Path = require('path')
	, validate = require('./lib/validate')
	, configureAliasStack = require('./lib/configureAliasStack')
	, createAliasStack = require('./lib/createAliasStack')
	, updateAliasStack = require('./lib/updateAliasStack')
	, aliasRestructureStack = require('./lib/aliasRestructureStack')
	, stackInformation = require('./lib/stackInformation')
	, listAliases = require('./lib/listAliases')
	, removeAlias = require('./lib/removeAlias')
	, logs = require('./lib/logs')
	, collectUserResources = require('./lib/collectUserResources')
	, uploadAliasArtifacts = require('./lib/uploadAliasArtifacts')
	, updateFunctionAlias = require('./lib/updateFunctionAlias')
	, deferredOutputs = require('./lib/deferredOutputs');

const aliasStageCommonOptions = {
	type: 'object',
	properties: {
		'cacheDataEncrypted': { type: 'boolean' },
		'cacheTtlInSeconds': { type: 'integer' },
		'cachingEnabled': { type: 'boolean' },
		'dataTraceEnabled': { type: 'boolean' },
		'loggingLevel': { type: 'string' },
		'metricsEnabled': { type: 'boolean' },
		'throttlingBurstLimit': { type: 'integer' },
		'throttlingRateLimit': { type: 'number' },
	},
	additionalProperties: false,
};

const aliasStageCustomOptions = {
	type: 'object',
	properties: {
		'cacheDataEncrypted': { type: 'boolean' },
		'cacheTtlInSeconds': { type: 'integer' },
		'cachingEnabled': { type: 'boolean' },
		'dataTraceEnabled': { type: 'boolean' },
		'loggingLevel': { type: 'string' },
		'metricsEnabled': { type: 'boolean' },
		'throttlingBurstLimit': { type: 'integer' },
		'throttlingRateLimit': { type: 'number' },
		'cacheClusterEnabled': { type: 'boolean' },
		'cacheClusterSize': { type: 'integer' },
	},
	additionalProperties: false,
};


/**
 * serverless v3 changes the plugin lib naming convention from camelCase to
 * kebab-case. this function takes a version param and returns the correct lib
 * key mappings for the version.
 * 
 * @typedef {Object} KeyMapV2
 * @property {'monitorStack'} monitorStack 
 * @property {'setBucketName'} setBucketName
 *
 * @typedef {Object} KeyMapV3
 * @property {'monitor-stack'} monitorStack 
 * @property {'set-bucket-name'} setBucketName
 *
 * @param {string} version
 * @returns {KeyMapV2 | KeyMapV3}
 */
const resolveAwsLibKeys = version =>
	// test first char of version string
	version[0] === '3'
		? {
			monitorStack: 'monitor-stack',
			setBucketName: 'set-bucket-name',
		}
		: {
			monitorStack: 'monitorStack',
			setBucketName: 'setBucketName',
		};

class AwsAlias {

	constructor(serverless, options) {
		this._serverless = serverless;
		// serverless.version resolves from serverless.yml:frameworkVersion
		this._awsLibKeys = resolveAwsLibKeys(this._serverless.version);
		this._options = options || {};
		this._provider = this._serverless.getProvider('aws');

		/**
		 * Set preliminary stage and alias. This is needed to enable the injection
		 * of the stage into the system variables. The values are overwritten by
		 * validate with their actually evaluated and substituted values.
		 */
		this._stage = this._provider.getStage();
		this._alias = this._options.alias || this._stage;

		/**
		 * (new) register custom variable source--preferred method to define
		 * plugin variables
		 * @see https://www.serverless.com/framework/docs/guides/plugins/custom-variables
		 */
		this.configurationVariablesSources = {
			pluginDibsAwsAlias: {
				resolve: async ({ address }) =>
					address === 'alias' ? { value: this._alias } : null,
			},
		};


		/**
		 * Load stack helpers from Serverless installation.
		 */
		const monitorStack = require(
			Path.join(this._serverless.config.serverlessPath,
				'plugins',
				'aws',
				'lib',
				this._awsLibKeys.monitorStack)
		);
		const setBucketName = require(
			Path.join(this._serverless.config.serverlessPath,
				'plugins',
				'aws',
				'lib',
				this._awsLibKeys.setBucketName)
		);

		_.assign(
			this,
			validate,
			collectUserResources,
			configureAliasStack,
			createAliasStack,
			updateAliasStack,
			listAliases,
			logs,
			removeAlias,
			aliasRestructureStack,
			stackInformation,
			uploadAliasArtifacts,
			updateFunctionAlias,
			setBucketName,
			monitorStack,
			deferredOutputs
		);

		this._commands = {
			alias: {
				commands: {
					remove: {
						usage: 'Remove a deployed alias',
						lifecycleEvents: [
							'remove'
						],
						options: {
							alias: {
								usage: 'Name of the alias',
								shortcut: 'a',
								required: true,
								type: 'string'
							},
							verbose: {
								usage: 'Enable verbose output',
								shortcut: 'v',
								required: false,
								type: 'boolean'
							}
						}
					}
				}
			},
			package: {
				options: {
					alias: {
						usage: 'Name of the alias',
						shortcut: 'a',
						required: false,
						type: 'string'
					},
				}
			},
			deploy: {
				options: {
					alias: {
						usage: 'Name of the alias',
						shortcut: 'a',
						required: false,
						type: 'string'
					},
				}
			},
			s3deploy: {
				options: {
					alias: {
						usage: 'Name of the alias',
						shortcut: 'a',
						required: false,
						type: 'string'
					},
				}
			},
		};

		this._serverless.configSchemaHandler.defineCustomProperties({
			properties: { aliasStage: aliasStageCustomOptions },
		});

		this._serverless.configSchemaHandler.defineFunctionProperties('aws', {
			properties: { aliasStage: aliasStageCommonOptions },
		});

		this._serverless.configSchemaHandler.defineFunctionEventProperties('aws', 'http', {
			properties: { aliasStage: aliasStageCommonOptions },
		});

		/**
		 * register alias property with provider schema to maintain old
		 * functionality while meeting new variable resolution standards
		 */
		this._serverless.configSchemaHandler.schema.properties.provider.properties.alias =
			{ type: 'string' };

		/**
		 * (old/bad) set alias property
		 */
		this._serverless.service.provider.alias = this._alias;

		this._hooks = {
			'before:package:initialize': () => BbPromise.bind(this)
				.then(this.validate),

			'before:aws:package:finalize:mergeCustomProviderResources': () => BbPromise.bind(this)
				.then(this.collectUserResources),

			'before:deploy:deploy': () => BbPromise.bind(this)
				.then(this.validate)
				.then(this.configureAliasStack),

			'before:aws:deploy:deploy:createStack': () => BbPromise.bind(this)
				.then(this.aliasStackLoadCurrentCFStackAndDependencies)
				.spread(this.aliasRestructureStack),

			'after:aws:deploy:deploy:createStack': () => BbPromise.bind(this)
				.then(this.createAliasStack),

			'after:aws:deploy:deploy:uploadArtifacts': () => BbPromise.bind(this)
				.then(() => BbPromise.resolve()),

			'after:aws:deploy:deploy:updateStack': () => BbPromise.bind(this)
				.then(this.setBucketName)
				.then(this.uploadAliasArtifacts)
				.then(this.updateAliasStack),

			'before:deploy:function:initialize': () => BbPromise.bind(this)
				.then(this.validate)
				.then(() => {
					// Force forced deploy
					if (!this._options.force) {
						return BbPromise.reject(new this.serverless.classes.Error("You must deploy single functions using --force with the alias plugin."));
					}
					return BbPromise.resolve();
				}),

			'after:deploy:function:deploy': () => BbPromise.bind(this)
				.then(this.updateFunctionAlias),

			'after:info:info': () => BbPromise.bind(this)
				.then(this.validate)
				.then(this.listAliases),

			'before:remove:remove': () => {
				if (!this._validated) {
					return BbPromise.reject(new this._serverless.classes.Error(`Use "serverless alias remove --alias=${this._stage}" to remove the service.`));
				}
				return BbPromise.resolve();
			},

			// Override the logs command - must be, because the $LATEST filter
			// in the original logs command is not easy to change without hacks.
			'logs:logs': () => BbPromise.bind(this)
				.then(this.validate)
				.then(this.logsValidate)
				.then(this.logsGetLogStreams)
				.then(this.functionLogsShowLogs),

			'logs:api:logs': () => BbPromise.bind(this)
				.then(this.validate)
				.then(this.apiLogsValidate)
				.then(this.apiLogsGetLogStreams)
				.then(this.apiLogsShowLogs),

			'alias:remove:remove': () => BbPromise.bind(this)
				.then(this.validate)
				.then(this.aliasStackLoadCurrentCFStackAndDependencies)
				.spread(this.removeAlias)
		};

		// Patch hooks to override our event replacements
		const pluginManager = this.serverless.pluginManager;
		const logHooks = pluginManager.hooks['logs:logs'];
		_.pullAllWith(logHooks, ['AwsLogs'], (a, b) => a.pluginName === b);

		// Extend the logs command if available
		try {
			const logCommand = pluginManager.getCommand(['logs']);
			logCommand.options.alias = {
				usage: 'Alias'
			};
			logCommand.options.version = {
				usage: 'Logs a specific version of the function'
			};
			logCommand.commands = _.assign({}, logCommand.commands, {
				api: {
					usage: 'Output the logs of a deployed APIG stage (alias)',
					lifecycleEvents: [
						'logs',
					],
					options: {
						alias: {
							usage: 'Alias'
						},
						stage: {
							usage: 'Stage of the service',
							shortcut: 's',
						},
						region: {
							usage: 'Region of the service',
							shortcut: 'r',
						},
						tail: {
							usage: 'Tail the log output',
							shortcut: 't',
						},
						startTime: {
							usage: 'Logs before this time will not be displayed',
						},
						filter: {
							usage: 'A filter pattern',
						},
						interval: {
							usage: 'Tail polling interval in milliseconds. Default: `1000`',
							shortcut: 'i',
						},
					},
					key: 'logs:api',
					pluginName: 'Logs',
					commands: {},
				}
			});
		} catch (e) {
			// Do nothing
		}
	}

	/**
	 * Expose the supported commands as read-only property.
	 */
	get commands() {
		return this._commands;
	}

	/**
	 * Expose the supported hooks as read-only property.
	 */
	get hooks() {
		return this._hooks;
	}

	/**
	 * Expose the options as read-only property.
	 */
	get options() {
		return this._options;
	}

	/**
	 * Expose the supported provider as read-only property.
	 */
	get provider() {
		return this._provider;
	}

	/**
	 * Expose the serverless object as read-only property.
	 */
	get serverless() {
		return this._serverless;
	}

	/**
	 * Expose the stack name as read-only property.
	 */
	get stackName() {
		return this._stackName;
	}

	_cleanup() {
		this._serverless.cli.log('Cleanup !!!!');
	}

}

module.exports = AwsAlias;