@vamship/build-utils 1.0.0-0

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

@@ -0,0 +1,54 @@
+'use strict';
+
+const _gulp = require('gulp');
+const _execa = require('execa');
+const _path = require('path');
+const _fs = require('fs');
+
+const { createNpmPackageTask } = require('./utils');
+
+/**
+ * Sub builder that packages the types exported by a project using npm pack. A
+ * custom package.json file is generated for the types.
+ *
+ * @private
+ * @param {Object} project Reference to an object that contains project metadata
+ *        that can be used to customize build outputs.
+ * @param {Object} options An options object that can be used to customize the
+ *        task.
+ *
+ * @returns {Function} A gulp task.
+ */
+module.exports = (project, options) => {
+    const { name, snakeCasedName, version, license, keywords, rootDir } =
+        project;
+
+    const packageName = `${snakeCasedName}-types-${version}.tgz`;
+    const packageDir = rootDir
+        .getChild('working')
+        .getChild(project.exportedTypes);
+    const distDir = rootDir.getChild('dist');
+
+    const createPackageJsonTask = (cb) =>
+        _fs.writeFile(
+            packageDir.getFilePath('package.json'),
+            JSON.stringify({
+                name: `${name}-types`,
+                version,
+                description: `Types for project ${name}`,
+                license,
+                keywords,
+            }),
+            cb
+        );
+    createPackageJsonTask.displayName = 'package-types-packagejson';
+    createPackageJsonTask.description =
+        'Creates a package.json file for the types';
+
+    const packTask = createNpmPackageTask(packageDir, packageName, distDir);
+    packTask.displayName = 'package-types-npm';
+    packTask.description =
+        'Creates an NPM package for the types exported by the project';
+
+    return _gulp.series([createPackageJsonTask, packTask]);
+};

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

@@ -0,0 +1,50 @@
+'use strict';
+
+const _delete = require('delete');
+const _execa = require('execa');
+const _gulp = require('gulp');
+
+/**
+ * Utility function that initializes and returns an array of tasks for npm
+ * package/publish operations.
+ *
+ * @param {Directory} packageDir The directory in which the package will be
+ *        created.
+ * @param {String} packageName The name of the package that is being created.
+ * @param {Directory} targetDir The directory to which the package will be
+ *        deployed.
+ *
+ * @returns {Function} A gulp task that creates the package.
+ */
+module.exports.createNpmPackageTask = function (
+    packageDir,
+    packageName,
+    targetDir
+) {
+    const npmBin = 'npm';
+    const args = ['pack'];
+    const packageFile = packageDir.getFileGlob(packageName);
+
+    const packTask = () =>
+        _execa(npmBin, args, {
+            stdio: 'inherit',
+            cwd: packageDir.absolutePath,
+        });
+
+    packTask.displayName = 'package-npm';
+    packTask.description = 'Create a project distribution using npm';
+
+    const copyTask = () =>
+        _gulp.src(packageFile).pipe(_gulp.dest(targetDir.absolutePath));
+
+    copyTask.displayName = 'package-npm-copy';
+    copyTask.description =
+        'Copies the project package to the distribution directory';
+
+    const deleteTask = () => _delete(packageFile);
+    deleteTask.displayName = 'package-npm-delete';
+    deleteTask.description =
+        'Deletes the original packge, leaving just the one in the distribution directory';
+
+    return _gulp.series([packTask, copyTask, deleteTask]);
+};

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

@@ -0,0 +1,50 @@
+'use strict';
+
+const _gulp = require('gulp');
+
+/**
+ * Builder function that can be used to generate a gulp task to publish a
+ * package. The task takes on different implementations based on project types.
+ * For example, javascript libraries will be published to an npm registry, using
+ * `npm publish`, while docker enabled projects will result in a docker image
+ * being published to a docker registry.
+ *
+ * @param {Object} project Reference to an object that contains project metadata
+ *        that can be used to customize build outputs.
+ * @param {Object} options An options object that can be used to customize the
+ *        task.
+ *
+ * @returns {Function} A gulp task.
+ */
+module.exports = (project, options) => {
+    const { types } = options;
+    let createTask = null;
+
+    if (types) {
+        if (!project.hasExportedTypes) {
+            return;
+        }
+        createTask = require('./publish-types');
+    } else if (project.projectType === 'aws-microservice') {
+        createTask = require('./publish-aws');
+    } else if (project.hasDocker) {
+        createTask = require('./publish-docker');
+    } else if (project.projectType === 'lib' || project.projectType === 'cli') {
+        createTask = require('./publish-npm');
+    }
+
+    const task = createTask(project, options);
+
+    if (!(task instanceof Array)) {
+        if (types) {
+            task.displayName = 'publish-types';
+            task.description =
+                'Publish the types exported by this project to a repository';
+        } else {
+            task.displayName = 'publish';
+            task.description = 'Publish the package to a repository';
+        }
+    }
+
+    return task;
+};

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

@@ -0,0 +1,62 @@
+'use strict';
+
+const _gulp = require('gulp');
+const _zip = require('gulp-zip');
+const _execa = require('execa');
+
+/**
+ * Sub builder that packages an aws-microservice project for deployment. This
+ * follows the build steps described for
+ * [lambda deployments](https://docs.aws.amazon.com/lambda/latest/dg/nodejs-create-deployment-pkg.html#nodejs-package-dependencies)
+ *
+ * @private
+ * @param {Object} project Reference to an object that contains project metadata
+ *        that can be used to customize build outputs.
+ * @param {Object} options An options object that can be used to customize the
+ *        task.
+ *
+ * @returns {Function} A gulp task.
+ */
+module.exports = (project, options) => {
+    const { name, version, rootDir } = project;
+    const infraDir = rootDir.getChild('infra');
+    const workingDir = rootDir.getChild('working');
+
+    const packageName = `${name.replace(/\//g, '-')}-${version}.zip`;
+
+    const cdkBin = 'cdk';
+
+    const tasks = project.getCdkStacks().map((key) => {
+        const envFiles = [
+            infraDir.getFileGlob(`.env.${process.env.INFRA_ENV}`),
+            infraDir.getFileGlob('.env'),
+        ];
+
+        const args = [
+            'deploy',
+            project.getCdkStackName(key),
+            '--app',
+            `"node ${workingDir.getFileGlob('infra/index')}"`,
+        ];
+
+        if (process.env.INFRA_NO_PROMPT === 'true') {
+            args.splice(1, 0, '--require-approval=never');
+        }
+
+        const task = () => {
+            project.initEnv(envFiles);
+            project.validateRequiredEnv();
+
+            return _execa(cdkBin, args, {
+                stdio: 'inherit',
+            });
+        };
+
+        task.displayName = `publish-${key}`;
+        task.description = `Publishes the ${key} stack to AWS using CDK`;
+
+        return task;
+    });
+
+    return tasks;
+};

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

@@ -0,0 +1,78 @@
+'use strict';
+
+const _execa = require('execa');
+const _gulp = require('gulp');
+const _log = require('fancy-log');
+const _semver = require('semver');
+
+/**
+ * Sub builder that builds a docker image based on a predefined dockerfile.
+ *
+ * @private
+ * @param {Object} project Reference to an object that contains project metadata
+ *        that can be used to customize build outputs.
+ * @param {Object} options An options object that can be used to customize the
+ *        task.
+ *
+ * @returns {Function} A gulp task.
+ */
+module.exports = (project, options) => {
+    const { version } = project;
+
+    const dockerBin = 'docker';
+    const major = _semver.major(version);
+    const minor = _semver.minor(version);
+
+    const tasks = project.getDockerTargets().map((target) => {
+        const { name, isDefault, isDeprecated } = target;
+        const { latestOnly } = options;
+
+        let repo = target.repo;
+        if (typeof process.env.BUILD_DOCKER_REPO !== 'undefined') {
+            repo = process.env.BUILD_DOCKER_REPO;
+            _log.warn(`Docker repo override specified: [${repo}]`);
+        }
+
+        let suffix = `${isDefault ? '' : '-name'}${
+            latestOnly ? '-latest' : ''
+        }`;
+
+        const tagList = latestOnly
+            ? ['latest']
+            : [version, major, `${major}.${minor}`];
+
+        const tags = tagList.map((tag) => `${repo}:${tag}`);
+
+        const tasks = tags.map((tag) => {
+            const tagTask = () =>
+                _execa(dockerBin, ['tag', tag], {
+                    stdio: 'inherit',
+                });
+            tagTask.displayName = `publish-docker-tag-${tag}${suffix}`;
+            tagTask.description = `Tag image with ${tag} (${name})`;
+
+            const pushTask = () =>
+                _execa(dockerBin, ['push', tag], {
+                    stdio: 'inherit',
+                });
+            pushTask.displayName = `publish-docker-push-${tag}${suffix}`;
+            pushTask.description = `Publish docker image with ${tag} (${name}) to registry`;
+
+            const task = _gulp.series([tagTask, pushTask]);
+            task.displayName = `publish-docker-${tag}${suffix}`;
+            task.description = `Tag and push image with ${tag} (${name})`;
+
+            return task;
+        });
+
+        const task = _gulp.parallel(tasks);
+        task.displayName = `publish${suffix}`;
+        task.description = latestOnly
+            ? `Tags image ${name} with latest tag and pushes to registry`
+            : `Tags image ${name} with version tags, and pushes to registry`;
+
+        return task;
+    });
+
+    return tasks;
+};

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

@@ -0,0 +1,36 @@
+'use strict';
+
+const _gulp = require('gulp');
+const _execa = require('execa');
+
+/**
+ * Sub builder that publishes a project using npm publish.
+ *
+ * @private
+ * @param {Object} project Reference to an object that contains project metadata
+ *        that can be used to customize build outputs.
+ * @param {Object} options An options object that can be used to customize the
+ *        task.
+ *
+ * @returns {Function} A gulp task.
+ */
+module.exports = (project, options) => {
+    const { snakeCasedName, version, rootDir } = project;
+
+    const packageName = `${snakeCasedName}-${version}.tgz`;
+
+    const npmBin = 'npm';
+    const args = ['publish', packageName];
+
+    const publishTask = () =>
+        _execa(npmBin, args, {
+            stdio: 'inherit',
+            cwd: rootDir.getChild('dist').absolutePath,
+        });
+
+    publishTask.displayName = 'publish-npm';
+    publishTask.description =
+        'Publish an existing package to an npm repository';
+
+    return _gulp.parallel(publishTask);
+};

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

@@ -0,0 +1,36 @@
+'use strict';
+
+const _gulp = require('gulp');
+const _execa = require('execa');
+
+/**
+ * Sub builder that publishes a project using npm publish.
+ *
+ * @private
+ * @param {Object} project Reference to an object that contains project metadata
+ *        that can be used to customize build outputs.
+ * @param {Object} options An options object that can be used to customize the
+ *        task.
+ *
+ * @returns {Function} A gulp task.
+ */
+module.exports = (project, options) => {
+    const { snakeCasedName, version, rootDir } = project;
+
+    const packageName = `${snakeCasedName}-types-${version}.tgz`;
+
+    const npmBin = 'npm';
+    const args = ['publish', packageName];
+
+    const publishTask = () =>
+        _execa(npmBin, args, {
+            stdio: 'inherit',
+            cwd: rootDir.getChild('dist').absolutePath,
+        });
+
+    publishTask.displayName = 'publish-npm-types';
+    publishTask.description =
+        'Publish an existing package to an npm repository';
+
+    return _gulp.parallel([publishTask]);
+};

package/src/task-builders/test.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const _gulp = require('gulp');
+const _execa = require('execa');
+
+/**
+ * Builder function that can be used to generate a gulp task to execute
+ * instrumented unit/api tests.
+ *
+ * @param {Object} project Reference to an object that contains project metadata
+ *        that can be used to customize build outputs.
+ * @param {Object} options An options object that can be used to customize the
+ *        task.
+ *
+ * @returns {Function} A gulp task.
+ */
+module.exports = (project, options) => {
+    const { testType, watch } = Object.assign(
+        { testType: 'unit', watch: false },
+        options
+    );
+
+    if (testType === 'api' && project.projectType === 'lib') {
+        return;
+    }
+
+    const rootDir = project.jsRootDir;
+    const mochaBin = project.rootDir.getFilePath('node_modules/.bin/mocha');
+    const nycBin = project.rootDir.getFilePath('node_modules/.bin/nyc');
+
+    const paths = rootDir.getChild(`test/${testType}`).getAllFilesGlob('js');
+
+    const args = [
+        '--reporter',
+        'text-summary',
+        '--reporter',
+        'html',
+        '--temp-dir',
+        rootDir.getFilePath('coverage'),
+    ];
+
+    if (project.hasTypescript) {
+        ['--extension', '.ts'].map((arg) => args.push(arg));
+    }
+
+    [mochaBin, '--color', '-R', 'spec', '--recursive', paths].map((arg) =>
+        args.push(arg)
+    );
+
+    const task = () => _execa(nycBin, args, { stdio: 'inherit' });
+    task.displayName = `test-${testType}`;
+    task.description = `Execute ${testType} tests`;
+
+    if (watch) {
+        const watchPaths = ['src', 'test']
+            .map((dir) => rootDir.getChild(dir))
+            .map((dir) => dir.getAllFilesGlob('js'));
+
+        const watchTask = () => _gulp.watch(watchPaths, task);
+        watchTask.displayName = `watch-test-${testType}`;
+        watchTask.description = `Automatically execute ${testType} tests on change`;
+
+        return watchTask;
+    }
+
+    return task;
+};