@hitc/netsuite-tools/gulptools.js

var ts = require('gulp-typescript');
var compile = require('./gulp-compile');
var oldCompile = require('./gulp-old-compile');
var amdToNetSuite = require('./gulp-amd-to-netsuite');
var path = require('path');
var fs = require('fs-extra');
var cp = require('child_process');
var https = require('https');
var os = require('os');
var webpack = require('webpack');
var walk = require('fs-walk');
var deepmerge = require('deepmerge');
var WrapperPlugin = require('wrapper-webpack-plugin');

function getCLIOpenCommand() {
  switch (os.platform()) {
    case 'darwin' :
      return 'open'; // Mac OS X
    case 'win32' :
      return 'start notepad'; // Windows - Use Notepad since the file doesn't technically have a registered extension
    default :
      return 'xdg-open'; // Linux/Sunos/UNIX
  }
}

function setupNSCredentialsFile() {
  var credFilePath = path.join(os.homedir(), '.netsuite-credentials');
  var credentialsTemplateString =
    ['{',
      '    "accountnumber": {',
      '        "email": "youremail@yourcompany.com",',
      '        "role": "18",',
      '        "password": "password"',
      '    }',
      '}'].join('\n');
  fs.stat(credFilePath, function (err) {
    if (!err) {
      console.log('.netsuite-credentials file already exists. Opening file using default application...');
      cp.exec(getCLIOpenCommand() + ' ' + credFilePath);
    } else if (err.code === 'ENOENT') {
      fs.writeFile(credFilePath, credentialsTemplateString);
      console.log('.netsuite-credentials file created. Opening file using default application...');
      cp.exec(getCLIOpenCommand() + ' ' + credFilePath);
    } else {
      console.log("Something went wrong. =(  Error details: " + err.code);
    }
  });
}


function getFileArguments() {
  var nextIsFile = false;
  var filePaths = [];
  for (var i = 0; i < process.argv.length; i++) {
    var arg = process.argv[i];
    if (nextIsFile) {
      var filePath = path.resolve(path.relative('', arg));
      filePaths.push(filePath);
      nextIsFile = false;
    } else if (arg.toLowerCase() === '--file') {
      nextIsFile = true;
    }
  }
  return filePaths;
}

function generateVinylPaths(basePath, extension, exclusions) {
  var excludedDirectories = ['library', 'lib', 'fragments', 'frags', 'vendor', 'externs', 'Fragments', 'Frags'];
  var fileArguments = getFileArguments();
  var paths = [];
  if (fileArguments.length > 0) {
    for (var i = 0; i < fileArguments.length; i++) {
      var relPath = path.relative(basePath, fileArguments[i]);
      if (relPath.split(path.sep).indexOf('..') === -1) {
        if (path.extname(fileArguments[i]) === '.' + extension) {
          paths.push(fileArguments[i]);
        }
      }
    }
  } else {
    paths = [basePath + '/**/*.' + extension];
  }
  if (paths.length === 0) return [];
  //Construct the final array of vinyl paths
  paths = paths.concat(
    excludedDirectories.map(
      function (exclude) {
        return '!' + basePath + '/**/*' + exclude + '*/**/*.' + extension;
      }
    )
  ).concat(exclusions.map(
    function (exclusion) {
      return '!' + exclusion;
    }
  ));
  return paths;
}

var paths = {
  out: './build',
  package: './package.json'
};

function doClean(callback) {
  fs.remove(paths.out, callback);
}

exports.setupHITCGulp = function (gulp, context, config) {
  var exclusions = [];
  if (config && config.length > 0) {
    config.forEach(function (configObj) {
      if (configObj['paths']) {
        exclusions = exclusions.concat(configObj['paths']);
      }
    });
  }

  gulp.task('clean', function (callback) {
    doClean(callback);
  });

  gulp.task('setup-ns-credentials-file', function () {
    setupNSCredentialsFile()
  });

  /* SSv1 */
  gulp.task('build-ssv1-browserify', function () {
    var p = './ssv1/browserify';
    var srcPaths = generateVinylPaths(p, 'js', exclusions)
      .concat(generateVinylPaths(p, 'coffee', exclusions));
    return gulp.src(srcPaths, {base: p})
      .pipe(compile())
      .pipe(gulp.dest(path.join(paths.out, p)));
  });

  gulp.task('build-ssv1-old-compiler', function () {
    var p = './ssv1/old-compiler';
    var srcPaths = generateVinylPaths(p, 'js', exclusions);
    return gulp.src(srcPaths, {base: p})
      .pipe(oldCompile())
      .pipe(gulp.dest(path.join(paths.out, p)));
  });

  gulp.task('build-ssv1', ['build-ssv1-browserify', 'build-ssv1-old-compiler']);

  /* SSv2 */
  gulp.task('build-ssv2-typescripts', function () {
    var p = 'ssv2';
    var tsProject = ts.createProject('tsconfig.json');
    return gulp.src(generateVinylPaths(p, 'ts', exclusions).concat(generateVinylPaths(p, 'tsx', exclusions)), {base: p})
      .pipe(tsProject())
      .js.pipe(amdToNetSuite())
      .pipe(gulp.dest(path.join(paths.out, p)));
  });

  gulp.task('build-ssv2-.d.ts', function () {
    var p = 'ssv2';
    var tsProject = ts.createProject('tsconfig.json', {declaration: true, allowJs: false});
    return gulp.src(generateVinylPaths(p, 'ts', exclusions).concat('typings/index.d.ts'), {base: p})
      .pipe(tsProject())
      .dts.pipe(gulp.dest(path.join(paths.out, p)));
  });

  gulp.task('build-ssv2-javascripts', function () {
    var p = 'ssv2';
    return gulp.src(generateVinylPaths(p, 'js', exclusions), {base: p})
      .pipe(gulp.dest(path.join(paths.out, p)));
  });

  gulp.task('build-ssv2-webpack', function (callback) {
    if (!config) return callback();

    const webpackConfigs = config.filter(function (configObj) {
      return configObj['compileMethod'] === 'webpack';
    });
    if (!webpackConfigs || webpackConfigs.length === 0) return callback();

    const externals = {};
    fs.readdirSync(path.resolve(context, "node_modules/@hitc/netsuite-types/N")).forEach(function (file) {
      if (file === '.' || file === '..') return;
      const module = 'N/' + file.replace('.d.ts', '');
      externals[module] = {amd: module};
    });

    const ssv2UtilitiesPath = path.resolve(context, "node_modules/@hitc/ssv2-utilities");
    walk.filesSync(ssv2UtilitiesPath, function (basedir, filename) {
      const moduleComponent = path.relative(ssv2UtilitiesPath, path.resolve(basedir, filename.replace(/(\.d)?\.(j|t)sx?$/, '')));
      const module = '/.bundle/121445/HITCSSV2Utilities/' + moduleComponent;
      externals[module] = {amd: module};
    });

    const ssv2VendorConfigPath = path.resolve(context, "node_modules/@hitc/ssv2-utilities/vendor/webpack.config.js");
    if (fs.existsSync(ssv2VendorConfigPath)) {
      const vendorConfig = require(ssv2VendorConfigPath);
      Object.keys(vendorConfig.entry).forEach(function (vendorModule) {
        externals[vendorModule] = {amd: '/.bundle/121445/HITCSSV2Utilities/vendor/' + vendorModule};
      });
    }

    const defaultWebpackConfig = {
      context: context,
      output: {
        libraryTarget: 'amd'
      },
      resolve: {
        extensions: ['.ts', '.tsx', '.js', '.jsx']
      },
      devtool: 'eval-source-map',
      module: {
        rules: [
          {
            test: /\.tsx?$/,
            loader: 'ts-loader'
          },
          {
            test: /\.css$/,
            loaders: ['style-loader', 'css-loader']
          }
        ]
      },
      externals,
      plugins: [
        new WrapperPlugin({
          header: "/**\n * @NAPIVersion 2.0\n * @NModuleScope Public\n */\n"
        }),
      ]
    };

    var count = 0;
    var anyFilesBeingProcessed = false;
    webpackConfigs.forEach(function (configObj) {
      configObj.paths.forEach(function (thisPath) {
        const fileArguments = getFileArguments();
        if (fileArguments.length > 0) {
          if (!~fileArguments.indexOf(path.resolve(path.relative('', thisPath)))) return;
        }
        const pathConfig = {
          entry: ['./' + path.relative(context, thisPath)],
          output: {
            filename: path.basename(thisPath, path.extname(thisPath)) + '.js',
            path: path.resolve(paths.out, path.dirname(path.relative(context, thisPath)))
          }
        };
        const webpackConfig = deepmerge.all([
          defaultWebpackConfig,
          configObj['webpackConfig'] || {},
          pathConfig,
        ]);
        if (configObj['devLibraries']) {
          configObj['devLibraries'].forEach(function (devLibrary) {
            delete webpackConfig.externals[devLibrary];
          });
        }
        count++;
        anyFilesBeingProcessed = true;
        webpack(webpackConfig, function (err) {
          if (err) console.error(err);
          if (--count === 0) callback();
        });
      });
    });
    if (!anyFilesBeingProcessed) return callback();
  });

  gulp.task('build-ssv2', ['build-ssv2-typescripts', 'build-ssv2-javascripts', 'build-ssv2-webpack']);

  gulp.task('build', ['build-ssv1', 'build-ssv2']);

  var extensionsToReplace = {
    ".ts": ".js",
    ".tsx": '.js',
    ".coffee": ".js"
  };

  function doUpload(environment, cb) {
    var netsuiteUploadPath = path.resolve(path.dirname(paths.package), "node_modules", "@hitc", "netsuite-upload", "release", "app.js");
    var pathsToUpload = [];
    var fileArguments = getFileArguments();
    for (var i = 0; i < fileArguments.length; i++) {
      var arg = fileArguments[i];
      var uploadPath = path.resolve(paths.out, path.relative('', arg));
      for (var ext in extensionsToReplace) {
        var thisExt = path.extname(uploadPath);
        if (thisExt === ext) {
          uploadPath = uploadPath.replace(thisExt, extensionsToReplace[ext]);
        }
      }
      pathsToUpload.push(uploadPath);
    }
    if (!pathsToUpload.length) {
      pathsToUpload.push(paths.out);
    }
    var command = [
      "node",
      "\"" + netsuiteUploadPath + "\"",
      "-p",
      "\"" + paths.package + "\"",
      "-e",
      "\"" + environment + "\"",
      "-b",
      "\"" + paths.out + "\""
    ];
    for (i = 0; i < pathsToUpload.length; i++) {
      command.push("\"" + pathsToUpload[i] + "\"");
    }
    cp.exec(
      command.join(' '),
      function (err, stdout, stderr) {
        console.log(stdout);
        console.log(stderr);
        cb(err);
      }
    );
  }

  gulp.task('upload', function (cb) {
    doUpload('PRODUCTION', cb);
  });

  gulp.task('upload-sandbox', function (cb) {
    doUpload('SANDBOX', cb);
  });

  gulp.task('upload-beta', function (cb) {
    doUpload('BETA', cb);
  });

  gulp.task('build-and-upload', ['build'], function (cb) {
    doUpload('PRODUCTION', cb)
  });

  gulp.task('build-and-upload-sandbox', ['build'], function (cb) {
    doUpload('SANDBOX', cb)
  });

  gulp.task('build-and-upload-beta', ['build'], function (cb) {
    doUpload('BETA', cb)
  });

  gulp.task('watch', ['build'], function () {
    gulp.watch(paths.scripts, ['build']);
  });

  gulp.task('install-ssv2-utilities', function (cb) {
    var data = "";
    https.get("https://raw.githubusercontent.com/headintheclouddev/ssv2-utilities/master/ssv2-utilities.d.ts", function (res) {
      res.on('data', function (chunk) {
        data += chunk;
      });
      res.on('end', function () {
        fs.writeFileSync('./typings/ssv2-utilities.d.ts', data);
        var indexContent = "" + fs.readFileSync('./typings/index.d.ts');
        if (indexContent.search('ssv2-utilities.d.ts') === -1) {
          indexContent += "\n/// <reference path=\"ssv2-utilities.d.ts\" />";
          fs.writeFileSync('./typings/index.d.ts', indexContent);
        }
        cb();
      });
    }).on('error', function (e) {
      console.error(e);
      cb();
    });
  });
};