@vamship/build-utils 1.6.1 → 2.0.0-1

package/src/task-builders/package-npm-task-builder.js

@@ -0,0 +1,83 @@
+'use strict';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import { execa as _execa } from 'execa';
+import _gulp from 'gulp';
+import _delete from 'delete';
+
+/**
+ * Builder function that can be used to generate a gulp task to package an
+ * project for publishing to an NPM registry.
+ */
+export class PackageNpmTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super('package-npm', `Package a project for publishing to NPM`);
+    }
+
+    /**
+     * Generates a gulp task to execute automated tests
+     *
+     * @protected
+     * @param {Object} project Reference to the project for which the task needs
+     * to be defined.
+     *
+     * @returns {Function} A gulp task.
+     */
+    _createTask(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+
+        const packageName = `${project.kebabCasedName}-${project.version}.tgz`;
+        const jsDir =
+            project.language === 'js'
+                ? project.rootDir
+                : project.rootDir.getChild('working');
+        const srcPath = jsDir.getFilePath(packageName);
+        const distDir = project.rootDir.getChild('dist');
+
+        const npmBin = 'npm';
+        const packTask = () =>
+            _execa(npmBin, ['pack'], {
+                stdio: 'inherit',
+                cwd: jsDir.absolutePath,
+            }).then(undefined, (err) => {
+                /*
+                 * Do nothing. This handler prevents the gulp task from
+                 * crashing with an unhandled error.
+                 */
+            });
+
+        const copyTask = () =>
+            _gulp.src(srcPath).pipe(_gulp.dest(distDir.absolutePath));
+        const deleteTask = () => _delete([srcPath]);
+
+        const task = _gulp.series([packTask, copyTask, deleteTask]);
+        return task;
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        const dirs = ['src', 'test', 'infra'];
+        const exts = ['md', 'html', 'json', 'js', 'jsx', 'ts', 'tsx'];
+        const rootDir =
+            project.language === 'ts'
+                ? project.rootDir.getChild('working')
+                : project.rootDir;
+
+        return dirs
+            .map((dir) =>
+                exts.map((ext) => rootDir.getChild(dir).getAllFilesGlob(ext)),
+            )
+            .flat();
+    }
+}

package/src/task-builders/package-task-builder.js

@@ -0,0 +1,101 @@
+'use strict';
+
+import _gulp from 'gulp';
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import { NotSupportedTaskBuilder } from './not-supported-task-builder.js';
+import { PackageAwsTaskBuilder } from './package-aws-task-builder.js';
+import { PackageNpmTaskBuilder } from './package-npm-task-builder.js';
+import { PackageContainerTaskBuilder } from './package-container-task-builder.js';
+
+/**
+ * General purpose packaging task that configures sub tasks for packaging based
+ * on the project. When a project is an API or container and has multiple container
+ * targets, this task will package the target named "default". When the project is
+ * a CLI and there is a "default" container defined, this task will package that,
+ * if there is no container defined, it will package using npm.
+ */
+export class PackageTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super(
+            'package',
+            `Packages project build files for publishing to a repository`,
+        );
+    }
+
+    /**
+     * Generates a gulp task to package a project for packaging a project.
+     *
+     * @protected
+     * @param {Object} project Reference to the project for which the task needs
+     * to be defined.
+     *
+     * @returns {Function} A gulp task.
+     */
+    _createTask(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+
+        const builders = this._getSubBuilders(project).map((builder) =>
+            builder.buildTask(project),
+        );
+
+        const task = _gulp.series(builders);
+        return task;
+    }
+
+    /**
+     * Returns a list of sub builders based on the project type and language.
+     * @private
+     */
+    _getSubBuilders(project) {
+        const { type } = project;
+        const containerTargetList = project.getContainerTargets();
+
+        // Type lib
+        if (type === 'lib') {
+            return [new PackageNpmTaskBuilder()];
+        }
+        // Type aws-microservice
+        else if (type === 'aws-microservice') {
+            return [new PackageAwsTaskBuilder()];
+        }
+        // Type container
+        else if (type === 'container') {
+            return [new PackageContainerTaskBuilder('default')];
+        }
+        // Type cli
+        else if (type === 'cli') {
+            if (containerTargetList.length > 0) {
+                return [new PackageContainerTaskBuilder('default')];
+            } else {
+                return [new PackageNpmTaskBuilder()];
+            }
+        }
+        // Type api
+        else if (type === 'api') {
+            return [new PackageContainerTaskBuilder('default')];
+        }
+        // Type ui (and potentially others that are not supported)
+        else {
+            return [new NotSupportedTaskBuilder()];
+        }
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        const paths = this._getSubBuilders(project)
+            .map((builder) => builder.getWatchPaths(project))
+            .flat();
+        return [...new Set(paths)];
+    }
+}

package/src/task-builders/publish-aws-task-builder.js

@@ -0,0 +1,111 @@
+'use strict';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import { execa as _execa } from 'execa';
+import { config as _dotenvConfig } from 'dotenv';
+import _dotenvExpand from 'dotenv-expand';
+
+/**
+ * Builder function that can be used to generate a gulp task to publish a CDK
+ * project to AWS.
+ */
+export class PublishAwsTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     *
+     * @param {String} target The name of the CDK stack target
+     * @param {String} environment The name of the environment to use for
+     * sourcing environment variables.
+     * @param {Boolean} requireApproval A flag that indicates whether or not the
+     * publish task requires interactive approval from the user.
+     */
+    constructor(target, environment, requireApproval) {
+        if (typeof target !== 'string' || target.length === 0) {
+            throw new Error('Invalid target (arg #1)');
+        }
+        if (typeof environment !== 'string' || environment.length === 0) {
+            throw new Error('Invalid environment (arg #2)');
+        }
+        if (typeof requireApproval !== 'boolean') {
+            throw new Error('Invalid requireApproval (arg #3)');
+        }
+        super('publish-aws', `Publish a CDK project to AWS`);
+
+        this._target = target;
+        this._environment = environment;
+        this._requireApproval = requireApproval;
+    }
+
+    /**
+     * Generates a gulp task to execute automated tests
+     *
+     * @protected
+     * @param {Object} project Reference to the project for which the task needs
+     * to be defined.
+     *
+     * @returns {Function} A gulp task.
+     */
+    _createTask(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+
+        const definition = project.getCdkStackDefinition(this._target);
+        const infraDir = project.rootDir.getChild('infra');
+        const jsDir =
+            project.language === 'js'
+                ? project.rootDir
+                : project.rootDir.getChild('working');
+
+        const task = () => {
+            [`.env.${this._environment}`, '.env']
+                .map((envFile) => infraDir.getFileGlob(envFile))
+                .forEach((envFile) => {
+                    _dotenvExpand(_dotenvConfig(envFile));
+                });
+
+            const undefinedVars = project.getUndefinedEnvironmentVariables();
+            if (undefinedVars.length > 0) {
+                throw new Error(
+                    `Missing required environment variables: [${undefinedVars.join(
+                        ',',
+                    )}]`,
+                );
+            }
+
+            const cdkBin = 'cdk';
+            const args = [
+                'deploy',
+                definition.name,
+                '--app',
+                jsDir.getChild('infra').getFilePath('index'),
+            ];
+
+            if (this._requireApproval) {
+                args.splice(1, 0, '--require-approval=never');
+            }
+
+            _execa(cdkBin, args, {
+                stdio: 'inherit',
+                cwd: jsDir.absolutePath,
+            }).then(undefined, (err) => {
+                /*
+                 * Do nothing. This handler prevents the gulp task from
+                 * crashing with an unhandled error.
+                 */
+            });
+        };
+        return task;
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        return [];
+    }
+}

package/src/task-builders/publish-container-task-builder.js

@@ -0,0 +1,103 @@
+'use strict';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import { execa as _execa } from 'execa';
+import _gulp from 'gulp';
+import { getSemverComponents } from '../utils/semver-utils.js';
+
+/**
+ * Builder function that can be used to generate a gulp task to publish a CDK
+ * project to CONTAINER.
+ */
+export class PublishContainerTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     *
+     * @param {String} target The name of the CDK stack target
+     * @param {String} [tag='latest'] An optional tag to apply to the container
+     * image.
+     */
+    constructor(target, tag = 'latest') {
+        if (typeof target !== 'string' || target.length === 0) {
+            throw new Error('Invalid target (arg #1)');
+        }
+        if (
+            typeof tag !== 'undefined' &&
+            (typeof tag !== 'string' || tag.length === 0)
+        ) {
+            throw new Error('Invalid tag (arg #2)');
+        }
+        super(
+            // When specifying the container target, if it is not called default, this
+            // will create a named task
+            `publish-container${target === 'default' ? '' : '-' + target}`,
+            `Publish container image for ${target}:${tag}`,
+        );
+
+        this._target = target;
+        this._tag = tag;
+    }
+
+    /**
+     * Generates a gulp task to execute automated tests
+     *
+     * @protected
+     * @param {Object} project Reference to the project for which the task needs
+     * to be defined.
+     *
+     * @returns {Function} A gulp task.
+     */
+    _createTask(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+
+        const definition = project.getContainerDefinition(this._target);
+
+        const semverComponents = getSemverComponents(this._tag);
+        const tagTaskList = semverComponents.map((tag) => {
+            const tagTask = () =>
+                // Per docker docs `docker tag SOURCE_IMAGE[:TAG] TARGET_IMAGE[:TAG]`
+                _execa(
+                    'docker',
+                    ['tag', definition.name, `${definition.name}:${tag}`],
+                    {
+                        stdio: 'inherit',
+                    },
+                ).then(undefined, (err) => {
+                    /*
+                     * Do nothing. This handler prevents the gulp task from
+                     * crashing with an unhandled error.
+                     */
+                });
+            return tagTask;
+        });
+        const pushTaskList = semverComponents.map((tag) => {
+            const pushTask = () =>
+                // Per docker docs `docker push [OPTIONS] NAME[:TAG]`
+                _execa('docker', ['push', `${definition.name}:${tag}`], {
+                    stdio: 'inherit',
+                }).then(undefined, (err) => {
+                    /*
+                     * Do nothing. This handler prevents the gulp task from
+                     * crashing with an unhandled error.
+                     */
+                });
+            return pushTask;
+        });
+
+        const task = _gulp.series([...tagTaskList, ...pushTaskList]);
+        return task;
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        return [];
+    }
+}

package/src/task-builders/publish-npm-task-builder.js

@@ -0,0 +1,60 @@
+'use strict';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import { execa as _execa } from 'execa';
+
+/**
+ * Builder function that can be used to generate a gulp task to publish an
+ * already packaged project to an NPM registry.
+ */
+export class PublishNpmTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super('publish-npm', `Publish a project to an NPM registry`);
+    }
+
+    /**
+     * Generates a gulp task to execute automated tests
+     *
+     * @protected
+     * @param {Object} project Reference to the project for which the task needs
+     * to be defined.
+     *
+     * @returns {Function} A gulp task.
+     */
+    _createTask(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+
+        const packageName = `${project.kebabCasedName}-${project.version}.tgz`;
+        const distDir = project.rootDir.getChild('dist');
+
+        const npmBin = 'npm';
+        const task = () =>
+            _execa(npmBin, ['publish', packageName], {
+                stdio: 'inherit',
+                cwd: distDir.absolutePath,
+            }).then(undefined, (err) => {
+                /*
+                 * Do nothing. This handler prevents the gulp task from
+                 * crashing with an unhandled error.
+                 */
+            });
+
+        return task;
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        return [];
+    }
+}

package/src/task-builders/publish-task-builder.js

@@ -0,0 +1,98 @@
+'use strict';
+
+import _gulp from 'gulp';
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import { NotSupportedTaskBuilder } from './not-supported-task-builder.js';
+import { PublishAwsTaskBuilder } from './publish-aws-task-builder.js';
+import { PublishNpmTaskBuilder } from './publish-npm-task-builder.js';
+import { PublishContainerTaskBuilder } from './publish-container-task-builder.js';
+
+/**
+ * General purpose publishing task that configures sub tasks for publishing based
+ * on the project. When a project is an API or container and has multiple container
+ * targets, this task will publish the target named "default". When the project is
+ * a CLI and there is a "default" container defined, this task will publish that,
+ * if there is no container defined, it will publish using npm.
+ */
+export class PublishTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super('publish', `Publishes project to a repository`);
+    }
+
+    /**
+     * Generates a gulp task to publish a project.
+     *
+     * @protected
+     * @param {Object} project Reference to the project for which the task needs
+     * to be defined.
+     *
+     * @returns {Function} A gulp task.
+     */
+    _createTask(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+
+        const builders = this._getSubBuilders(project).map((builder) =>
+            builder.buildTask(project),
+        );
+
+        const task = _gulp.series(builders);
+        return task;
+    }
+
+    /**
+     * Returns a list of sub builders based on the project type and language.
+     * @private
+     */
+    _getSubBuilders(project) {
+        const { type } = project;
+        const containerTargetList = project.getContainerTargets();
+
+        // Type lib
+        if (type === 'lib') {
+            return [new PublishNpmTaskBuilder()];
+        }
+        // Type aws-microservice
+        else if (type === 'aws-microservice') {
+            return [new PublishAwsTaskBuilder()];
+        }
+        // Type container
+        else if (type === 'container') {
+            return [new PublishContainerTaskBuilder('default')];
+        }
+        // Type cli
+        else if (type === 'cli') {
+            if (containerTargetList.length > 0) {
+                return [new PublishContainerTaskBuilder('default')];
+            } else {
+                return [new PublishNpmTaskBuilder()];
+            }
+        }
+        // Type api
+        else if (type === 'api') {
+            return [new PublishContainerTaskBuilder('default')];
+        }
+        // Type ui (and potentially others that are not supported)
+        else {
+            return [new NotSupportedTaskBuilder()];
+        }
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        const paths = this._getSubBuilders(project)
+            .map((builder) => builder.getWatchPaths(project))
+            .flat();
+        return [...new Set(paths)];
+    }
+}

package/src/task-builders/test-task-builder.js

@@ -0,0 +1,85 @@
+'use strict';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import { execa as _execa } from 'execa';
+
+/**
+ * Builder function that can be used to generate a gulp task to execute
+ * instrumented unit/api tests.
+ */
+export class TestTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     *
+     * @param {String} testType The type of test to execute. Must be one of
+     * "unit" or "api".
+     */
+    constructor(testType) {
+        if (['unit', 'api'].indexOf(testType) < 0) {
+            throw new Error('Invalid testType (arg #1)');
+        }
+        super(`test-${testType}`, `Execute ${testType} tests`);
+
+        this._testType = testType;
+    }
+
+    /**
+     * Generates a gulp task to execute automated tests
+     *
+     * @protected
+     * @param {Object} project Reference to the project for which the task needs
+     * to be defined.
+     *
+     * @returns {Function} A gulp task.
+     */
+    _createTask(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        const mochaBin = project.rootDir.getFilePath('node_modules/.bin/mocha');
+        const c8Bin = project.rootDir.getFilePath('node_modules/.bin/c8');
+        const jsRootDir =
+            project.language === 'ts'
+                ? project.rootDir.getChild('working')
+                : project.rootDir;
+
+        const args = [
+            '-x {working/,}test/**',
+            mochaBin,
+            '--no-config',
+            '--loader=esmock',
+            jsRootDir.getChild(`test/${this._testType}`).getAllFilesGlob('js'),
+        ];
+
+        const task = () =>
+            _execa(c8Bin, args, { stdio: 'inherit' }).then(undefined, () => {
+                /*
+                 * Do nothing. This handler prevents the gulp task from
+                 * crashing with an unhandled error.
+                 */
+            });
+        return task;
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        const dirs = ['src', 'test', 'infra'];
+        const exts = ['md', 'html', 'json', 'js', 'jsx', 'ts', 'tsx'];
+        const rootDir =
+            project.language === 'ts'
+                ? project.rootDir.getChild('working')
+                : project.rootDir;
+
+        return dirs
+            .map((dir) =>
+                exts.map((ext) => rootDir.getChild(dir).getAllFilesGlob(ext)),
+            )
+            .flat();
+    }
+}