@vamship/build-utils 1.6.1 → 2.0.0-1

package/src/project.js

@@ -1,274 +1,100 @@
-'use strict';
+import semver from 'semver';
+import { camelCase as _camelCase } from 'change-case';
+import Ajv from 'ajv';
+import _colors from 'ansi-colors';
 
-const _camelcase = require('camelcase');
-const Directory = require('./directory');
-const _dotEnv = require('dotenv');
-const _dotEnvExpand = require('dotenv-expand');
-const _fs = require('fs');
+import _projectDataSchema from './schema/project-definition.js';
+import { Directory } from './directory.js';
 
-const SUPPORTED_PROJECT_TYPES = [
-    'lib',
-    'cli',
-    'api',
-    'aws-microservice',
-    'container',
-    'ui',
-];
-const SUPPORTED_LANGUAGES = ['js', 'ts'];
+const _validateProjectData = new Ajv().compile(_projectDataSchema);
 
 /**
- * Represents project configuration. This class will encapsulate information
- * about projects that should help automate the build/test/deploy toolchain for
- * a project.
+ * Represents a build project that encapsulates one or more relavent build
+ * tasks.
  */
-module.exports = class Project {
+export class Project {
     /**
-     * @param {Object} packageConfig Reference to the project configuration.
-     *        This is typically the contents of package.json, with an additional
-     *        set of properties called `buildMetadata`.
-     * @param {Object} [buildMetadata] An optional build metadata object that
-     *        will override the build metadata defined within packageConfig.
-     */
-    constructor(packageConfig, buildMetadata) {
-        if (!packageConfig || typeof packageConfig !== 'object') {
-            throw new Error('Invalid packageConfig (arg #1)');
-        }
-
-        const config = Object.assign({}, packageConfig);
-        config.buildMetadata = Object.assign(
-            {},
-            config.buildMetadata,
-            buildMetadata
-        );
-
-        this._name = config.name;
-        this._license = config.license;
-        this._keywords = (config.keywords || []).slice();
-        this._unscopedName = config.name.replace(/^@[^/]*\//, '');
-        this._snakeCasedName = config.name
-            .replace(/^@/, '')
-            .replace(/\//g, '-');
-        this._version = config.version;
-        this._description = config.description;
-        this._initProjectProperties(config.buildMetadata);
-
-        const tree = {
-            src: null,
-            test: {
-                unit: null,
-                api: null,
-            },
-            infra: null,
-            working: {
-                src: null,
-                test: {
-                    unit: null,
-                    api: null,
-                },
-                infra: null,
-                node_modules: null,
-            },
-            dist: null,
-            docs: null,
-            node_modules: null,
-            coverage: null,
-            '.gulp': null,
-            '.tscache': null,
-            logs: null,
-            'cdk.out': null,
-        };
-
-        if (this._hasExportedTypes) {
-            let rootParentDir = tree;
-            let workingParentDir = tree.working;
-
-            const exportedTypesDirs = this._exportedTypes.split('/');
-            const lastIndex = exportedTypesDirs.length - 1;
-
-            exportedTypesDirs.forEach((dirName, index) => {
-                const isLastIndex = index === lastIndex;
-
-                if (!rootParentDir[dirName]) {
-                    rootParentDir[dirName] = isLastIndex ? null : {};
-                }
-                rootParentDir = rootParentDir[dirName];
-
-                if (!workingParentDir[dirName]) {
-                    workingParentDir[dirName] = isLastIndex ? null : {};
-                }
-                workingParentDir = workingParentDir[dirName];
-            });
-        }
-
-        this._rootDir = Directory.createTree('./', tree);
-    }
-
-    /**
-     * Initializes project properties using values from a metadata object.
+     * Creates a new project based on the specified build metadata.
      *
-     * @private
-     * @param {Object} buildMetadata The metadata to use when initializing
-     *        properties.
+     * @param {Object} projectDefinition An object that contains the project
+     * definition.
      */
-    _initProjectProperties(buildMetadata) {
-        if (!buildMetadata || typeof buildMetadata !== 'object') {
-            throw new Error('Invalid buildMetadata (arg #1)');
+    constructor(projectDefinition) {
+        if (
+            !projectDefinition ||
+            projectDefinition instanceof Array ||
+            typeof projectDefinition !== 'object'
+        ) {
+            throw new Error('Invalid project definition (arg #1)');
         }
 
-        const {
-            projectType,
-            language,
-            docker,
-            requiredEnv,
-            exportedTypes,
-            aws,
-            staticFilePatterns,
-        } = buildMetadata;
-
-        if (SUPPORTED_PROJECT_TYPES.indexOf(projectType) < 0) {
+        if (!_validateProjectData(projectDefinition)) {
+            const { instancePath, message } = _validateProjectData.errors[0];
             throw new Error(
-                `Invalid projectType (buildMetadata.projectType).\n\tMust be one of: [${SUPPORTED_PROJECT_TYPES}]`
+                `Schema validation failed [${instancePath
+                    .replace(/\//g, '.')
+                    .trim()} ${message}]`,
             );
         }
 
-        if (SUPPORTED_LANGUAGES.indexOf(language) < 0) {
+        const {
+            name,
+            version,
+            description,
+            buildMetadata: {
+                type,
+                language,
+                requiredEnv,
+                staticFilePatterns,
+                aws,
+                container,
+            },
+        } = projectDefinition;
+
+        if (!semver.valid(version)) {
             throw new Error(
-                `Invalid language (buildMetadata.language)\n\tMust be one of: [${SUPPORTED_LANGUAGES}]`
+                `Schema validation failed [.version is not a valid semantic version]`,
             );
         }
 
-        this._requiredEnv = [];
-        if (requiredEnv instanceof Array) {
-            this._requiredEnv = requiredEnv.concat([]);
+        if (aws && aws.stacks && Object.keys(aws.stacks).length <= 0) {
+            throw new Error(`No AWS stacks defined`);
         }
 
-        this._projectType = projectType;
+        this._name = name;
+        this._description = description;
+        this._unscopedName = name.replace(/^@[^/]*\//, '');
+        this._kebabCasedName = name.replace(/^@/, '').replace(/\//g, '-');
+        this._version = version;
+        this._type = type;
         this._language = language;
-        this._exportedTypes = exportedTypes;
-        this._staticFilePatterns =
-            staticFilePatterns instanceof Array ? staticFilePatterns : [];
-
-        this._hasTypescript = this._language === 'ts';
-        this._hasServer = this._projectType === 'api';
-        this._hasExportedTypes =
-            typeof exportedTypes === 'string' && exportedTypes.length > 0;
-
-        if (this._projectType === 'aws-microservice') {
-            if (!aws || typeof aws !== 'object') {
-                throw new Error(
-                    'The project is an AWS microservice, but does not define AWS configuration'
-                );
-            }
-
-            if (!aws.stacks || typeof aws.stacks !== 'object') {
-                throw new Error(
-                    'The project is an AWS microservice, but does not define AWS stacks'
-                );
-            }
-
-            this._awsRegion = aws.region;
-            this._awsProfile = aws.profile;
-            this._cdkStacks = aws.stacks;
-        } else {
-            this._awsRegion = undefined;
-            this._awsProfile = undefined;
-            this._cdkStacks = {};
-        }
-
-        this._hasDocker =
-            this._projectType !== 'lib' &&
-            this._projectType !== 'aws-microservice' &&
-            docker &&
-            typeof docker === 'object';
-
-        this._dockerTargets = this._initDockerTargets(docker);
-    }
-
-    /**
-     * Initialize docker targets for the project.
-     *
-     * @param docker The docker configuration section for the project.
-     */
-    _initDockerTargets(docker) {
-        if (!this._hasDocker) return [];
+        this._staticFilePatterns = staticFilePatterns || [];
+        this._requiredEnv = requiredEnv || [];
+        this._aws = aws || { stacks: {} };
+        this._cdkTargets = Object.keys(this._aws.stacks).reduce(
+            (result, key) => {
+                result[key] = { name: this._aws.stacks[key] };
+                return result;
+            },
+            {},
+        );
+        this._container = container || {};
 
-        if (docker.repo || docker.registry || docker.buildArgs) {
-            // Deprecated settings
-            let repo = docker.repo;
-            if (!repo) {
-                repo = docker.registry
-                    ? `${docker.registry}/${this._unscopedName}`
-                    : this._unscopedName;
-            }
-            return [
-                {
+        this._containerTargets = Object.keys(this._container).reduce(
+            (result, key) => {
+                const { repo, buildFile, buildArgs } = this._container[key];
+                result[key] = {
+                    name: key,
                     repo,
-                    name: 'default',
-                    buildFile: 'Dockerfile',
-                    buildArgs: this._initializeFromEnv(docker.buildArgs),
-                    isDefault: true,
-                    isDeprecated: true,
-                },
-            ];
-        }
-
-        return Object.keys(docker).map((key) => {
-            const config = docker[key];
-            if (!config || typeof config !== 'object') {
-                throw new Error(
-                    `Docker target configuration is invalid for target: [${key}]`
-                );
-            }
-            if (typeof config.repo !== 'string' || config.repo.length <= 0) {
-                throw new Error(
-                    `Docker target does not define a valid repo: [${key}]`
-                );
-            }
-
-            const { repo, buildFile, buildArgs } = config;
-            return {
-                repo,
-                name: key,
-                buildFile: buildFile || 'Dockerfile',
-                buildArgs: this._initializeFromEnv(buildArgs),
-                isDefault: key === 'default',
-                isDeprecated: false,
-            };
-        });
-    }
-
-    /**
-     * Loops through the specified object, and replaces specific values from
-     * those defined in the current environment. Returns a new object with the
-     * replaced values. Only properties whose values are '__ENV__' will be
-     * replaced with environment equivalents.
-     *
-     * @param map The initial set of key value mappings.
-     *
-     * @returns {Array} An array of objects containing "name" and "value"
-     *          properties that contain the key and the values (replaced from
-     *          environment if applicable)
-     */
-    _initializeFromEnv(map) {
-        if (!map || map instanceof Array || typeof map !== 'object') {
-            return [];
-        }
-        return Object.keys(map).map((name) => {
-            let value = map[name];
-            if (value == '__ENV__') {
-                value = process.env[name];
-            }
-            return { name, value };
-        });
-    }
+                    buildFile,
+                    buildArgs,
+                };
+                return result;
+            },
+            {},
+        );
 
-    /**
-     * Initializes a directory tree for the project based on project properties.
-     *
-     * @private
-     */
-    _initProjectTree() {
-        const tree = {
+        this._rootDir = Directory.createTree('./', {
             src: null,
             test: {
                 unit: null,
@@ -292,251 +118,149 @@ module.exports = class Project {
             '.tscache': null,
             logs: null,
             'cdk.out': null,
-        };
-
-        if (this._projectType === 'aws-microservice') {
-            tree.infra = null;
-            tree.working.infra = null;
-            tree.working.node_modules = null;
-            tree['cdk.out'] = null;
-        }
-    }
-
-    /**
-     * An object representation of the project's root directory.
-     *
-     * @returns {Directory}
-     */
-    get rootDir() {
-        return this._rootDir;
-    }
-
-    /**
-     * An object representation of the root directory for all javascript files.
-     * For typescript projects, this would be the directory containing the
-     * transpiled files.
-     *
-     * @returns {Directory}
-     */
-    get jsRootDir() {
-        return this._hasTypescript
-            ? this._rootDir.getChild('working')
-            : this._rootDir;
+        });
+        this._banner = `${_colors.cyan(this._name)}@${_colors.green(
+            this._version,
+        )} (${_colors.blue(this._type)} - ${_colors.yellow(this._language)})`;
     }
 
     /**
-     * The name of the project as defined in package.json.
+     * Gets the name of the project.
      *
-     * @return {String}
+     * @returns {String} The project name.
      */
     get name() {
         return this._name;
     }
 
     /**
-     * The license of the project as defined in package.json.
-     *
-     * @return {String}
-     */
-    get license() {
-        return this._license;
-    }
-
-    /**
-     * The keywords for the project as defined in package.json.
+     * Gets the description of the project.
      *
-     * @return {String}
+     * @returns {String} The project description.
      */
-    get keywords() {
-        return this._keywords;
+    get description() {
+        return this._description;
     }
 
     /**
-     * The name of the project without including its scope. IF the project has
-     * no scope, the unscoped name will match the project name.
+     * Gets the name of the project without any scoping prefixes.
      *
-     * @return {String}
+     * @returns {String} The project name (without scope).
      */
     get unscopedName() {
         return this._unscopedName;
     }
 
     /**
-     * The name of the project formatted in snake case. Ideal for use when
-     * generating package names. This property does not include the file
-     * extension (.tgz).
-     */
-    get snakeCasedName() {
-        return this._snakeCasedName;
-    }
-
-    /**
-     * The version of the project as defined in package.json.
-     *
-     * @return {String}
-     */
-    get version() {
-        return this._version;
-    }
-
-    /**
-     * The description of the project as defined in package.json.
+     * Gets the name of the project in kebab case.
      *
-     * @return {String}
+     * @returns {String} The project name in kebab case.
      */
-    get description() {
-        return this._description;
+    get kebabCasedName() {
+        return this._kebabCasedName;
     }
 
     /**
      * Gets the name of the expected configuration file name based on the name
      * of the project.
-     */
-    get configFileName() {
-        return `.${_camelcase(this._unscopedName)}rc`;
-    }
-
-    /**
-     * The project type of the project (lib/api/cli).
-     *
-     * @return {String}
-     */
-    get projectType() {
-        return this._projectType;
-    }
-
-    /**
-     * The language used by the project (js/ts).
      *
-     * @return {String}
+     * @returns {String} The expected config file name.
      */
-    get language() {
-        return this._language;
+    get configFileName() {
+        return `.${_camelCase(this._unscopedName)}rc`;
     }
 
     /**
-     * Returns the AWS region configured for the project.
+     * Gets the version of the project.
      *
-     * @return {String}
+     * @returns {String} The project version.
      */
-    get awsRegion() {
-        return this._awsRegion;
+    get version() {
+        return this._version;
     }
 
     /**
-     * Returns the AWS profile configured for the project.
+     * Gets the type of the project.
      *
-     * @return {String}
+     * @returns {String} The project type.
      */
-    get awsProfile() {
-        return this._awsProfile;
+    get type() {
+        return this._type;
     }
 
     /**
-     * The path to the directory that contains the types exported by this
-     * project.
+     * Gets the language of the project.
      *
-     * @return {String}
+     * @returns {String} The project language.
      */
-    get exportedTypes() {
-        return this._exportedTypes;
+    get language() {
+        return this._language;
     }
 
     /**
-     * Additional files to copy from the source directory to the build
-     * directory.
+     * Gets the root directory of the project.
      *
-     * @return {String}
+     * @returns {Directory} The project root directory
      */
-    get staticFilePatterns() {
-        return this._staticFilePatterns;
+    get rootDir() {
+        return this._rootDir;
     }
 
     /**
-     * Determines whether or not the project can be packaged up as a docker
-     * image.
+     * Gets a colorized banner for the project.
      *
-     * @return {Boolean}
+     * @returns {String} The colorized banner text.
      */
-    get hasDocker() {
-        return this._hasDocker;
+    get banner() {
+        return this._banner;
     }
 
     /**
-     * Determines whether or not the project contains typescript files.
+     * Returns a list of static file patterns configured for the project.
      *
-     * @return {Boolean}
+     * @returns {Array} An array of glob strings used to identify static files
+     * copied over during a build.
      */
-    get hasTypescript() {
-        return this._hasTypescript;
+    getStaticFilePatterns() {
+        return this._staticFilePatterns.concat([]);
     }
 
     /**
-     * Determines whether or not the project has a server component that might
-     * require API tests or the ability to host a local server.
+     * Returns a list of environment variables that must be defined for the
+     * build.
      *
-     * @return {Boolean}
+     * @returns {Array} An array of environment variable names.
      */
-    get hasServer() {
-        return this._hasServer;
+    getRequiredEnv() {
+        return this._requiredEnv.concat([]);
     }
 
     /**
-     * Determines if the project has any types to export.
+     * Returns a list of CDK stack keys defined for the project. These stack
+     * keys will be used to generate deploy tasks for each. Each key maps to a
+     * specific CDK stack that can be deployed.
      *
-     * @return {String}
+     * @return {Array} A list of stack keys
      */
-    get hasExportedTypes() {
-        return this._hasExportedTypes;
+    getCdkTargets() {
+        return Object.keys(this._cdkTargets);
     }
 
     /**
-     * Initializes a list of environment variables from the specified files.
-     * If environment variables are repeated in files, the declaration in the
-     * first file takes precedence over the others.
+     * Gets CDK stack information based on the cdk stack key.
      *
-     * @param {Array} [files=[]] A list of files to load environment variables
-     *        from.
+     * @param {String} target The CDK target name
+     * @returns {Object} The CDK definition corresponding to the target.
      */
-    initEnv(envFiles) {
-        if (!(envFiles instanceof Array)) {
-            envFiles = [];
+    getCdkStackDefinition(target) {
+        if (typeof target !== 'string' || target.length <= 0) {
+            throw new Error('Invalid CDK target (arg #1)');
         }
-        envFiles
-            .filter((file) => _fs.existsSync(file))
-            .forEach((file) =>
-                _dotEnvExpand.expand(_dotEnv.config({ path: file }))
-            );
-    }
-
-    /**
-     * Returns a list of required environment variables. These parameters can
-     * be checked during build/package time to ensure that they exist, before
-     * performing any actions.
-     *
-     * @return {Array}
-     */
-    getRequiredEnv() {
-        return this._requiredEnv.concat([]);
-    }
-
-    /**
-     * Checks to see if all required variables have been defined in the
-     * environment. This is typically a runtime call, executed prior to
-     * building/packaging a project.
-     */
-    validateRequiredEnv() {
-        const missingVars = [];
-        this._requiredEnv.forEach((param) => {
-            if (!process.env[param]) {
-                missingVars.push(param);
-            }
-        });
-        if (missingVars.length > 0) {
-            throw new Error(
-                `Required environment variables not defined: ${missingVars}`
-            );
+        const stack = this._cdkTargets[target];
+        if (!stack) {
+            throw new Error(`CDK target has not been defined (${target})`);
         }
+        return Object.assign({}, stack);
     }
 
     /**
@@ -545,36 +269,39 @@ module.exports = class Project {
      * - repo: The docker repo
      * - buildFile: The name of the build file to use
      * - buildArgs: Arguments to be passed to the docker build
-     * - isDefault: Determines if the current target is the default one
-     * - isDeprecated: Determines if the target uses a deprecated configuration.
      *
      * @return {Array}
      */
-    getDockerTargets() {
-        return this._dockerTargets.concat([]);
+    getContainerTargets() {
+        return Object.keys(this._containerTargets);
     }
 
     /**
-     * Returns a list of CDK stack keys defined for the project. These stack
-     * keys will be used to generate deploy tasks for each. Each key maps to a
-     * specific CDK stack that can be deployed.
+     * Gets CDK stack information based on the cdk stack key.
      *
-     * @return {Array} A list of stack keys
+     * @param {String} target The CDK target name
+     * @returns {Object} The container definition corresponding to the target.
      */
-    getCdkStacks() {
-        return Object.keys(this._cdkStacks);
+    getContainerDefinition(target) {
+        if (typeof target !== 'string' || target.length <= 0) {
+            throw new Error('Invalid container target (arg #1)');
+        }
+        const container = this._containerTargets[target];
+        if (!container) {
+            throw new Error(
+                `Container target has not been defined (${target})`,
+            );
+        }
+        return Object.assign({}, container);
     }
 
     /**
-     * Returns the name of the stack corresponding to the stack key.
+     * Returns a list of project enviornment variables that are not defined in
+     * the current execution environment.
      *
-     * @param {String} key The CDK stack key to use when looking up the name.
-     * @return {String} The stack name that maps to the key.
+     * @return {Array} An array of missing environment variables.
      */
-    getCdkStackName(key) {
-        if (typeof key !== 'string' || key.length <= 0) {
-            throw new Error('Invalid stack key (arg #1)');
-        }
-        return this._cdkStacks[key];
+    getUndefinedEnvironmentVariables() {
+        return this._requiredEnv.filter((env) => !process.env[env]);
     }
-};
+}