@vamship/build-utils 1.6.1 → 2.0.0-1

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

@@ -0,0 +1,74 @@
+'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 { DocsJsTaskBuilder } from './docs-js-task-builder.js';
+import { DocsTsTaskBuilder } from './docs-ts-task-builder.js';
+
+/**
+ * General purpose build task that configures sub tasks for build based on the
+ * project.
+ */
+export class DocsTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super(
+            'docs',
+            `Generates documentation from code comments in source files`,
+        );
+    }
+
+    /**
+     * Generates a gulp task to package a project for building 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, language } = project;
+        if (type === 'container') {
+            return [new NotSupportedTaskBuilder()];
+        } else if (language === 'ts') {
+            return [new DocsTsTaskBuilder()];
+        } else {
+            return [new DocsJsTaskBuilder()];
+        }
+    }
+
+    /**
+     * @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/docs-ts-task-builder.js

@@ -0,0 +1,52 @@
+import { execa as _execa } from 'execa';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+
+/**
+ * Builder that can be used to generate a gulp task to generate documentation
+ * from code comments in typescript files.
+ */
+export class DocsTsTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super(
+            'docs-ts',
+            'Generates documentation from code comments in typescript files',
+        );
+    }
+
+    /**
+     * Generates a gulp task to generate documentation from code comments in
+     * source code.
+     *
+     * @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 { rootDir } = project;
+        const docsDir = rootDir.getChild('docs').getFilePath(project.version);
+        const srcDir = rootDir.getChild('src');
+
+        const task = () =>
+            _execa('typedoc', ['--out', docsDir, srcDir.absolutePath], {
+                stdio: 'inherit',
+            }).then(undefined, (err) => {
+                /*
+                 * Do nothing. This handler prevents the gulp task from
+                 * crashing with an unhandled error.
+                 */
+                console.error(err);
+            });
+        return task;
+    }
+}

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

@@ -0,0 +1,61 @@
+import _gulp from 'gulp';
+import _prettier from 'gulp-prettier';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+
+/**
+ * Builder that can be used to generate a gulp task to format source/test files.
+ */
+export class FormatTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super(
+            'format',
+            'Formats all source files, README.md and build scripts',
+        );
+    }
+
+    /**
+     * Generates a gulp task to format source 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 dirs = ['src', 'test', 'infra', '.gulp'];
+        const extras = ['Gulpfile.js', 'README.md'];
+        const extensions = ['ts', 'js', 'json', 'py', 'tsx', 'jsx'];
+
+        const paths = dirs
+            .map((dir) => project.rootDir.getChild(dir))
+            .map((dir) => extensions.map((ext) => dir.getAllFilesGlob(ext)))
+            .reduce((result, arr) => result.concat(arr), [])
+            .concat(extras.map((file) => project.rootDir.getFileGlob(file)));
+
+        const task = () =>
+            _gulp
+                .src(paths, {
+                    allowEmpty: true,
+                    base: project.rootDir.globPath,
+                })
+                .pipe(_prettier())
+                .on('error', (err) => {
+                    /*
+                     * Do nothing. This handler prevents the gulp task from
+                     * crashing with an unhandled error.
+                     */
+                })
+                .pipe(_gulp.dest(project.rootDir.absolutePath));
+        return task;
+    }
+}

package/src/task-builders/index.js

@@ -1,19 +1,23 @@
 'use strict';
 
-/**
- * A collection of task builder functions that can be used to generate gulp
- * tasks based on project configuration.
- */
-module.exports = [
-    'clean',
-    'format',
-    'lint',
-    'build',
-    'test',
-    'docs',
-    'package',
-    'publish',
-].reduce((tasks, task) => {
-    tasks[task] = require(`./${task}`);
-    return tasks;
-}, {});
+export * from './build-js-task-builder.js';
+export * from './build-ts-task-builder.js';
+export * from './build-ui-task-builder.js';
+export * from './clean-task-builder.js';
+export * from './copy-files-task-builder.js';
+export * from './docs-js-task-builder.js';
+export * from './docs-ts-task-builder.js';
+export * from './format-task-builder.js';
+export * from './lint-fix-task-builder.js';
+export * from './lint-task-builder.js';
+export * from './package-aws-task-builder.js';
+export * from './package-container-task-builder.js';
+export * from './package-npm-task-builder.js';
+export * from './publish-aws-task-builder.js';
+export * from './publish-container-task-builder.js';
+export * from './publish-npm-task-builder.js';
+export * from './test-task-builder.js';
+export * from './test-ui-task-builder.js';
+export * from './watch-task-builder.js';
+export * from './build-task-builder.js';
+export * from './not-supported-task-builder.js';

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

@@ -0,0 +1,61 @@
+'use strict';
+
+import _gulp from 'gulp';
+import _eslint from 'gulp-eslint-new';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+
+/**
+ * Builder that can be used to generate a gulp task to lint source/test files,
+ * and implement any automatic fixes that are possible.
+ */
+export class LintFixTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super(
+            'lint-fix',
+            'Lints all source files and applies automatic fixes where possible',
+        );
+    }
+
+    /**
+     * 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 dirs = ['src', 'test', 'infra', '.gulp'];
+        const extras = ['Gulpfile.js'];
+        const extensions = ['ts', 'js', 'tsx', 'jsx'];
+
+        const paths = dirs
+            .map((dir) => project.rootDir.getChild(dir))
+            .map((dir) => extensions.map((ext) => dir.getAllFilesGlob(ext)))
+            .reduce((result, arr) => result.concat(arr), [])
+            .concat(extras.map((file) => project.rootDir.getFileGlob(file)));
+
+        const task = () =>
+            _gulp
+                .src(paths, {
+                    allowEmpty: true,
+                    base: project.rootDir.globPath,
+                })
+                .pipe(_eslint({ configType: 'flat', fix: true }))
+                .pipe(_eslint.fix())
+                .pipe(_eslint.format())
+                .pipe(_eslint.failAfterError());
+
+        return task;
+    }
+}

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

@@ -0,0 +1,56 @@
+'use strict';
+
+import _gulp from 'gulp';
+import _eslint from 'gulp-eslint-new';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+
+/**
+ * Builder that can be used to generate a gulp task to lint source/test files.
+ */
+export class LintTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super('lint', 'Lints all source files');
+    }
+
+    /**
+     * Generates a gulp task to lint 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 dirs = ['src', 'test', 'infra', '.gulp'];
+        const extras = ['Gulpfile.js'];
+        const extensions = ['ts', 'js', 'tsx', 'jsx'];
+
+        const paths = dirs
+            .map((dir) => project.rootDir.getChild(dir))
+            .map((dir) => extensions.map((ext) => dir.getAllFilesGlob(ext)))
+            .reduce((result, arr) => result.concat(arr), [])
+            .concat(extras.map((file) => project.rootDir.getFileGlob(file)));
+
+        const task = () =>
+            _gulp
+                .src(paths, {
+                    allowEmpty: true,
+                    base: project.rootDir.globPath,
+                })
+                .pipe(_eslint({ configType: 'flat' }))
+                .pipe(_eslint.format())
+                .pipe(_eslint.failAfterError());
+
+        return task;
+    }
+}

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

@@ -0,0 +1,48 @@
+'use strict';
+
+import _fancyLog from 'fancy-log';
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+
+/**
+ * Task builder that creates a task that displays a "not supported" message on
+ * the screen. Intended to indicate that the task does not apply for the
+ * specific project type.
+ */
+export class NotSupportedTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super(
+            'not-supported',
+            `Task that does nothing - used to indicate that a task is not supported for a project type.`,
+        );
+    }
+
+    /**
+     * Generates a gulp task to package a project for building 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)');
+        }
+        return () => _fancyLog.warn('Task not defined for project');
+    }
+
+    /**
+     * @override
+     */
+    getWatchPaths(project) {
+        if (!(project instanceof Project)) {
+            throw new Error('Invalid project (arg #1)');
+        }
+        return [];
+    }
+}

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

@@ -0,0 +1,105 @@
+'use strict';
+
+import TaskBuilder from '../task-builder.js';
+import { Project } from '../project.js';
+import { execa as _execa } from 'execa';
+import _gulp from 'gulp';
+import _zip from 'gulp-zip';
+
+/**
+ * Builder function that can be used to generate a gulp task to package a
+ * project for deployment to AWS.
+ */
+export class PackageAwsTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     */
+    constructor() {
+        super('package-aws', `Package a project for publishing to AWS`);
+    }
+
+    /**
+     * Generates a gulp task to package a project for deployment to AWS.
+     *
+     * @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 jsDir =
+            project.language === 'js'
+                ? project.rootDir
+                : project.rootDir.getChild('working');
+
+        const installTask = () => {
+            const npmBin = 'npm';
+            const args = ['install', '--production'];
+
+            return _execa(npmBin, args, {
+                stdio: 'inherit',
+                cwd: jsDir.absolutePath,
+            }).then(undefined, (err) => {
+                /*
+                 * Do nothing. This handler prevents the gulp task from
+                 * crashing with an unhandled error.
+                 */
+            });
+        };
+
+        const dirs = ['src', 'node_modules'];
+        const extras = ['package.json', project.configFileName];
+
+        const paths = dirs
+            .map((dir) => jsDir.getChild(dir))
+            .map((dir) => dir.getAllFilesGlob())
+            .concat(extras.map((file) => jsDir.getFileGlob(file)));
+        const packageName = `${project.kebabCasedName}-${project.version}.zip`;
+
+        const zipTask = () =>
+            _gulp
+                .src(paths, {
+                    allowEmpty: true,
+                    base: project.rootDir.globPath,
+                })
+                .pipe(_zip(packageName))
+                .on('error', (err) => {
+                    /*
+                     * Do nothing. This handler prevents the gulp task from
+                     * crashing with an unhandled error.
+                     */
+                })
+                .pipe(
+                    _gulp.dest(project.rootDir.getChild('dist').absolutePath),
+                );
+
+        const task = _gulp.series([installTask, zipTask]);
+        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-container-task-builder.js

@@ -0,0 +1,132 @@
+'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 package a
+ * container project for publishing to a container registry.
+ */
+export class PackageContainerTaskBuilder extends TaskBuilder {
+    /**
+     * Creates a new task builder.
+     *
+     * @param {String} target The name of the container build target
+     * @param {String} [repo=undefined] The name of the container repo
+     */
+    constructor(target, repo) {
+        if (typeof target !== 'string' || target.length === 0) {
+            throw new Error('Invalid target (arg #1)');
+        }
+        if (
+            typeof repo !== 'undefined' &&
+            (typeof repo !== 'string' || repo.length === 0)
+        ) {
+            throw new Error('Invalid repo (arg #2)');
+        }
+
+        super(
+            // When specifying the container target, if it is not called default, this
+            // will create a named task
+            `package-container${target === 'default' ? '' : '-' + target}`,
+            `Package a project for publishing to a container registry`,
+        );
+        this._target = target;
+        this._repo = repo;
+    }
+
+    /**
+     * Generates a gulp task to package a container image
+     *
+     * @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 undefinedVars = project.getUndefinedEnvironmentVariables();
+        if (undefinedVars.length > 0) {
+            throw new Error(
+                `Missing required environment variables: [${undefinedVars.join(
+                    ', ',
+                )}]`,
+            );
+        }
+
+        const jsDir =
+            project.language === 'js'
+                ? project.rootDir
+                : project.rootDir.getChild('working');
+        const definition = project.getContainerDefinition(this._target);
+
+        const repo =
+            typeof this._repo === 'undefined' ? definition.repo : this._repo;
+        const { buildFile, buildArgs } = definition;
+
+        const dockerBin = 'docker';
+        const args = [
+            'build',
+            '--rm',
+            '--file',
+            buildFile,
+            '--tag',
+            `${repo}:latest`,
+            '--build-arg',
+            `APP_NAME=${project.unscopedName}`,
+            '--build-arg',
+            `APP_VERSION=${project.version}`,
+            '--build-arg',
+            `APP_DESCRIPTION='${project.description}'`,
+            '--build-arg',
+            `CONFIG_FILE_NAME=${project.configFileName}`,
+            '--build-arg',
+            `BUILD_TIMESTAMP=${Date.now()}`,
+        ];
+
+        Object.keys(buildArgs).forEach((key) => {
+            args.push('--build-arg');
+            args.push(`${key}=${buildArgs[key]}`);
+        });
+
+        args.push('.');
+
+        const task = () =>
+            _execa(dockerBin, 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)');
+        }
+        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();
+    }
+}