@vamship/build-utils 1.6.1 → 2.0.0-1

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

@@ -0,0 +1,65 @@
+'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 web UI tests.
+ */
+export class TestUiTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super('test-ui', `Execute web UI tests`);
+    }
+
+    /**
+     * 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 jestBin = project.rootDir.getFilePath('node_modules/.bin/jest');
+        const task = () =>
+            _execa(jestBin, ['--config', 'jest.config.js', '--coverage'], {
+                stdio: 'inherit',
+            }).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)');
+        }
+        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/watch-task-builder.js

@@ -0,0 +1,109 @@
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import _gulp from 'gulp';
+import _fancyLog from 'fancy-log';
+import _colors from 'ansi-colors';
+
+/**
+ * Builder that adds a watcher to an existing task.
+ */
+export class WatchTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     *
+     * @param {Function} task Reference to the task that needs to be watched.
+     * @param {Array} paths An array of paths to monitor for changes and trigger
+     * the task on change.
+     */
+    constructor(task, paths) {
+        if (typeof task !== 'function') {
+            throw new Error('Invalid task (arg #1)');
+        }
+        if (!(paths instanceof Array)) {
+            throw new Error('Invalid paths (arg #2)');
+        }
+        super(
+            `watch-${task.displayName}`,
+            `[Monitor and execute] ${task.description}`,
+        );
+
+        this._task = task;
+        this._paths = paths.concat([]);
+    }
+
+    /**
+     * Generates a gulp task to clean up temporary project files.
+     *
+     * @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 taskRunner = (done) => {
+            const result = this._task();
+            if (!result) {
+                _fancyLog(
+                    'Task returned no result. Skipping. Will rerun on next change.',
+                );
+                done();
+            } else if (result.then) {
+                return result.then(
+                    () => {
+                        _fancyLog(
+                            'Task was resolved successfully. Will rerun on next change.',
+                        );
+                        done();
+                    },
+                    (err) => {
+                        _fancyLog(
+                            'Task was rejected with errors. Will rerun on next change.',
+                        );
+                        done();
+                    },
+                );
+            } else if (result.on) {
+                return result
+                    .on('error', (err) => {
+                        _fancyLog(
+                            'Task stream reported errors. Will rerun on next change.',
+                        );
+                        done();
+                    })
+                    .on('end', () => {
+                        _fancyLog(
+                            'Task stream completed successfully. Will rerun on next change.',
+                        );
+                        done();
+                    });
+            } else {
+                _fancyLog(
+                    'Task is neither promise nor stream. Skipping. Will rerun on next change.',
+                );
+                done();
+            }
+        };
+        taskRunner.description = this._task.description;
+        const taskName = _colors.cyan(this._task.displayName);
+        const task = _gulp.series(
+            async () => _fancyLog(`Running task ${taskName}`),
+            taskRunner,
+            async () => _fancyLog('Task completed'),
+        );
+        return () => _gulp.watch(this._paths, task);
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        return [];
+    }
+}

package/src/task-factories/api-task-factory.js

@@ -0,0 +1,67 @@
+import TaskFactory from '../task-factory.js';
+
+import { CleanTaskBuilder } from '../task-builders/clean-task-builder.js';
+import { FormatTaskBuilder } from '../task-builders/format-task-builder.js';
+import { LintTaskBuilder } from '../task-builders/lint-task-builder.js';
+import { LintFixTaskBuilder } from '../task-builders/lint-fix-task-builder.js';
+import { BuildTaskBuilder } from '../task-builders/build-task-builder.js';
+import { PackageTaskBuilder } from '../task-builders/package-task-builder.js';
+import { PublishTaskBuilder } from '../task-builders/publish-task-builder.js';
+import { DocsTaskBuilder } from '../task-builders/docs-task-builder.js';
+import { PackageContainerTaskBuilder } from '../task-builders/package-container-task-builder.js';
+import { PublishContainerTaskBuilder } from '../task-builders/publish-container-task-builder.js';
+import { generateAdditionalContainerTasks } from '../utils/task-factory-utils.js';
+import { TestTaskBuilder } from '../task-builders/test-task-builder.js';
+
+/**
+ * Represents a factory that generates a set of build tasks for an api type project
+ */
+export class ApiTaskFactory extends TaskFactory {
+    /**
+     * Creates a new instance of TaskFactory, initialized for a given project.
+     * @param {Project} project The project to generate build tasks for.
+     */
+    constructor(project) {
+        super(project);
+    }
+
+    /**
+     * Protected abstract method that can be overridden to provide the
+     * necessary tasks for a given project type.
+     *
+     * @returns {Array} An array of task builders.
+     */
+    _createTaskBuilders() {
+        const { type } = this._project;
+        if (type !== 'api') {
+            return [];
+        }
+
+        // Helper function to generate the set of tasks for each additional container
+        // if needed
+        const additionalTaskList = (target) => {
+            return [
+                new PackageContainerTaskBuilder(target),
+                new PublishContainerTaskBuilder(target),
+            ];
+        };
+        const additionalTasks = generateAdditionalContainerTasks(
+            this._project,
+            additionalTaskList,
+        );
+
+        return [
+            new CleanTaskBuilder(),
+            new FormatTaskBuilder(),
+            new LintTaskBuilder(),
+            new LintFixTaskBuilder(),
+            new TestTaskBuilder('unit'),
+            new TestTaskBuilder('api'),
+
+            new DocsTaskBuilder(this._project),
+            new BuildTaskBuilder(this._project),
+            new PackageTaskBuilder(this._project),
+            new PublishTaskBuilder(this._project),
+        ].concat(additionalTasks);
+    }
+}

package/src/task-factories/aws-microservice-task-factory.js

@@ -0,0 +1,53 @@
+import TaskFactory from '../task-factory.js';
+
+import { CleanTaskBuilder } from '../task-builders/clean-task-builder.js';
+import { FormatTaskBuilder } from '../task-builders/format-task-builder.js';
+import { LintTaskBuilder } from '../task-builders/lint-task-builder.js';
+import { LintFixTaskBuilder } from '../task-builders/lint-fix-task-builder.js';
+import { BuildTaskBuilder } from '../task-builders/build-task-builder.js';
+import { PackageTaskBuilder } from '../task-builders/package-task-builder.js';
+import { PublishTaskBuilder } from '../task-builders/publish-task-builder.js';
+import { DocsTaskBuilder } from '../task-builders/docs-task-builder.js';
+import { TestTaskBuilder } from '../task-builders/test-task-builder.js';
+
+/**
+ * Represents a factory that generates a set of build tasks for a given project
+ * type. This is an abstract class that must be extended to provide a list of
+ * task builders for a given project type.
+ */
+export class AwsMicroserviceTaskFactory extends TaskFactory {
+    /**
+     * Creates a new instance of TaskFactory, initialized for a given project.
+     * @param {Project} project The project to generate build tasks for.
+     */
+    constructor(project) {
+        super(project);
+    }
+
+    /**
+     * Protected abstract method that can be overridden to provide the
+     * necessary tasks for a given project type.
+     *
+     * @returns {Array} An array of task builders.
+     */
+    _createTaskBuilders() {
+        const { type } = this._project;
+        if (type !== 'aws-microservice') {
+            return [];
+        }
+
+        return [
+            new CleanTaskBuilder(),
+            new FormatTaskBuilder(),
+            new LintTaskBuilder(),
+            new LintFixTaskBuilder(),
+            new TestTaskBuilder('unit'),
+            new TestTaskBuilder('api'),
+
+            new DocsTaskBuilder(this._project),
+            new BuildTaskBuilder(this._project),
+            new PackageTaskBuilder(this._project),
+            new PublishTaskBuilder(this._project),
+        ];
+    }
+}

package/src/task-factories/cli-task-factory.js

@@ -0,0 +1,68 @@
+import TaskFactory from '../task-factory.js';
+
+import { CleanTaskBuilder } from '../task-builders/clean-task-builder.js';
+import { FormatTaskBuilder } from '../task-builders/format-task-builder.js';
+import { LintTaskBuilder } from '../task-builders/lint-task-builder.js';
+import { LintFixTaskBuilder } from '../task-builders/lint-fix-task-builder.js';
+import { BuildTaskBuilder } from '../task-builders/build-task-builder.js';
+import { PackageTaskBuilder } from '../task-builders/package-task-builder.js';
+import { PublishTaskBuilder } from '../task-builders/publish-task-builder.js';
+import { DocsTaskBuilder } from '../task-builders/docs-task-builder.js';
+import { PackageContainerTaskBuilder } from '../task-builders/package-container-task-builder.js';
+import { PublishContainerTaskBuilder } from '../task-builders/publish-container-task-builder.js';
+import { generateAdditionalContainerTasks } from '../utils/task-factory-utils.js';
+import { TestTaskBuilder } from '../task-builders/test-task-builder.js';
+
+/**
+ * Represents a factory that generates a set of build tasks for a given project
+ * type. This is an abstract class that must be extended to provide a list of
+ * task builders for a given project type.
+ */
+export class CliTaskFactory extends TaskFactory {
+    /**
+     * Creates a new instance of TaskFactory, initialized for a given project.
+     * @param {Project} project The project to generate build tasks for.
+     */
+    constructor(project) {
+        super(project);
+    }
+
+    /**
+     * Protected abstract method that can be overridden to provide the
+     * necessary tasks for a given project type.
+     *
+     * @returns {Array} An array of task builders.
+     */
+    _createTaskBuilders() {
+        const { type } = this._project;
+        if (type !== 'cli') {
+            return [];
+        }
+
+        // Helper function to generate the set of tasks for each additional container
+        // if needed
+        const additionalTaskList = (target) => {
+            return [
+                new PackageContainerTaskBuilder(target),
+                new PublishContainerTaskBuilder(target),
+            ];
+        };
+        const additionalTasks = generateAdditionalContainerTasks(
+            this._project,
+            additionalTaskList,
+        );
+
+        return [
+            new CleanTaskBuilder(),
+            new FormatTaskBuilder(),
+            new LintTaskBuilder(),
+            new LintFixTaskBuilder(),
+            new TestTaskBuilder('unit'),
+
+            new DocsTaskBuilder(this._project),
+            new BuildTaskBuilder(this._project),
+            new PackageTaskBuilder(this._project),
+            new PublishTaskBuilder(this._project),
+        ].concat(additionalTasks);
+    }
+}

package/src/task-factories/container-task-factory.js

@@ -0,0 +1,64 @@
+import TaskFactory from '../task-factory.js';
+
+import { CleanTaskBuilder } from '../task-builders/clean-task-builder.js';
+import { FormatTaskBuilder } from '../task-builders/format-task-builder.js';
+import { LintTaskBuilder } from '../task-builders/lint-task-builder.js';
+import { LintFixTaskBuilder } from '../task-builders/lint-fix-task-builder.js';
+import { PackageTaskBuilder } from '../task-builders/package-task-builder.js';
+import { PublishTaskBuilder } from '../task-builders/publish-task-builder.js';
+import { DocsTaskBuilder } from '../task-builders/docs-task-builder.js';
+import { PackageContainerTaskBuilder } from '../task-builders/package-container-task-builder.js';
+import { PublishContainerTaskBuilder } from '../task-builders/publish-container-task-builder.js';
+import { generateAdditionalContainerTasks } from '../utils/task-factory-utils.js';
+
+/**
+ * Represents a factory that generates a set of build tasks for a given project
+ * type. This is an abstract class that must be extended to provide a list of
+ * task builders for a given project type.
+ */
+export class ContainerTaskFactory extends TaskFactory {
+    /**
+     * Creates a new instance of TaskFactory, initialized for a given project.
+     * @param {Project} project The project to generate build tasks for.
+     */
+    constructor(project) {
+        super(project);
+    }
+
+    /**
+     * Protected abstract method that can be overridden to provide the
+     * necessary tasks for a given project type.
+     *
+     * @returns {Array} An array of task builders.
+     */
+    _createTaskBuilders() {
+        const { type } = this._project;
+        if (type !== 'container') {
+            return [];
+        }
+
+        // Helper function to generate the set of tasks for each additional container
+        // if needed
+        const additionalTaskList = (target) => {
+            return [
+                new PackageContainerTaskBuilder(target),
+                new PublishContainerTaskBuilder(target),
+            ];
+        };
+        const additionalTasks = generateAdditionalContainerTasks(
+            this._project,
+            additionalTaskList,
+        );
+
+        return [
+            new CleanTaskBuilder(),
+            new FormatTaskBuilder(),
+            new LintTaskBuilder(),
+            new LintFixTaskBuilder(),
+
+            new DocsTaskBuilder(this._project),
+            new PackageTaskBuilder(this._project),
+            new PublishTaskBuilder(this._project),
+        ].concat(additionalTasks);
+    }
+}

package/src/task-factories/index.js

@@ -0,0 +1,8 @@
+'use strict';
+
+export * from './lib-task-factory.js';
+export * from './api-task-factory.js';
+export * from './cli-task-factory.js';
+export * from './ui-task-factory.js';
+export * from './container-task-factory.js';
+export * from './aws-microservice-task-factory.js';

package/src/task-factories/lib-task-factory.js

@@ -0,0 +1,52 @@
+import TaskFactory from '../task-factory.js';
+
+import { CleanTaskBuilder } from '../task-builders/clean-task-builder.js';
+import { FormatTaskBuilder } from '../task-builders/format-task-builder.js';
+import { LintTaskBuilder } from '../task-builders/lint-task-builder.js';
+import { LintFixTaskBuilder } from '../task-builders/lint-fix-task-builder.js';
+import { TestTaskBuilder } from '../task-builders/test-task-builder.js';
+import { BuildTaskBuilder } from '../task-builders/build-task-builder.js';
+import { PackageTaskBuilder } from '../task-builders/package-task-builder.js';
+import { PublishTaskBuilder } from '../task-builders/publish-task-builder.js';
+import { DocsTaskBuilder } from '../task-builders/docs-task-builder.js';
+
+/**
+ * Represents a factory that generates a set of build tasks for a given project
+ * type. This is an abstract class that must be extended to provide a list of
+ * task builders for a given project type.
+ */
+export class LibTaskFactory extends TaskFactory {
+    /**
+     * Creates a new instance of TaskFactory, initialized for a given project.
+     * @param {Project} project The project to generate build tasks for.
+     */
+    constructor(project) {
+        super(project);
+    }
+
+    /**
+     * Protected abstract method that can be overridden to provide the
+     * necessary tasks for a given project type.
+     *
+     * @returns {Array} An array of task builders.
+     */
+    _createTaskBuilders() {
+        const { type } = this._project;
+        if (type !== 'lib') {
+            return [];
+        }
+
+        return [
+            new CleanTaskBuilder(),
+            new FormatTaskBuilder(),
+            new LintTaskBuilder(),
+            new LintFixTaskBuilder(),
+            new TestTaskBuilder('unit'),
+
+            new DocsTaskBuilder(this._project),
+            new BuildTaskBuilder(this._project),
+            new PackageTaskBuilder(this._project),
+            new PublishTaskBuilder(this._project),
+        ];
+    }
+}

package/src/task-factories/ui-task-factory.js

@@ -0,0 +1,48 @@
+import TaskFactory from '../task-factory.js';
+
+import { CleanTaskBuilder } from '../task-builders/clean-task-builder.js';
+import { FormatTaskBuilder } from '../task-builders/format-task-builder.js';
+import { LintTaskBuilder } from '../task-builders/lint-task-builder.js';
+import { LintFixTaskBuilder } from '../task-builders/lint-fix-task-builder.js';
+import { BuildTaskBuilder } from '../task-builders/build-task-builder.js';
+import { DocsTaskBuilder } from '../task-builders/docs-task-builder.js';
+import { TestUiTaskBuilder } from '../task-builders/test-ui-task-builder.js';
+
+/**
+ * Represents a factory that generates a set of build tasks for a given project
+ * type. This is an abstract class that must be extended to provide a list of
+ * task builders for a given project type.
+ */
+export class UiTaskFactory extends TaskFactory {
+    /**
+     * Creates a new instance of TaskFactory, initialized for a given project.
+     * @param {Project} project The project to generate build tasks for.
+     */
+    constructor(project) {
+        super(project);
+    }
+
+    /**
+     * Protected abstract method that can be overridden to provide the
+     * necessary tasks for a given project type.
+     *
+     * @returns {Array} An array of task builders.
+     */
+    _createTaskBuilders() {
+        const { type } = this._project;
+        if (type !== 'ui') {
+            return [];
+        }
+
+        return [
+            new CleanTaskBuilder(),
+            new FormatTaskBuilder(),
+            new LintTaskBuilder(),
+            new LintFixTaskBuilder(),
+            new TestUiTaskBuilder(),
+
+            new DocsTaskBuilder(this._project),
+            new BuildTaskBuilder(this._project),
+        ];
+    }
+}

package/src/task-factory.js

@@ -0,0 +1,52 @@
+import { Project } from './project.js';
+import { WatchTaskBuilder } from './task-builders/watch-task-builder.js';
+
+/**
+ * Represents a factory that generates a set of build tasks for a given project
+ * type. This is an abstract class that must be extended to provide a list of
+ * task builders for a given project type.
+ */
+export default class TaskFactory {
+    /**
+     * Creates a new instance of TaskFactory, initialized for a given project.
+     * @param {Project} project The project to generate build tasks for.
+     */
+    constructor(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        this._project = project;
+    }
+
+    /**
+     * Protected abstract method that can be overridden to provide the
+     * necessary tasks for a given project type.
+     *
+     * @returns {Array} An array of task builders.
+     */
+    _createTaskBuilders() {
+        return [];
+    }
+
+    /**
+     * Creates a set of build tasks for the project.
+     *
+     * @returns {Array} An array of gulp tasks.
+     */
+    createTasks() {
+        const project = this._project;
+        const builders = this._createTaskBuilders();
+        const watchBuilders = builders
+            .filter((builder) => builder.getWatchPaths(project).length > 0)
+            .map(
+                (builder) =>
+                    new WatchTaskBuilder(
+                        builder.buildTask(project),
+                        builder.getWatchPaths(project),
+                    ),
+            );
+        return builders
+            .concat(watchBuilders)
+            .map((builder) => builder.buildTask(project));
+    }
+}

package/src/utils/semver-utils.js

@@ -0,0 +1,29 @@
+import semver from 'semver';
+
+/**
+ * Checks if a given input tag is a valid semantic version, and returns an array
+ * of the four corresponding tags (ex. tag = '1.2.3' => ['1.2.3', '1.2', '1', 'latest']).
+ * If tag = '1.2' => ['1.2.0', '1.2', '1', 'latest'].
+ * If tag = '1' => ['1.0.0', '1.0', '1', 'latest'].
+ * If the tag is not a semantic version, such as 'latest' simply returns ['latest']
+ *
+ * @param {String} tag String input for tag name of docker image
+ * @returns {Array} Array of tag strings
+ */
+export function getSemverComponents(tag) {
+    const semTag = semver.coerce(tag);
+    if (!semver.valid(semTag)) {
+        return [tag];
+    }
+
+    const major = semver.major(semTag);
+    const minor = semver.minor(semTag);
+    const patch = semver.patch(semTag);
+
+    return [
+        `${major}.${minor}.${patch}`,
+        `${major}.${minor}`,
+        `${major}`,
+        'latest',
+    ];
+}