@apollion-dsi/scripts 0.7.7

package/src/command/create/index.ts

@@ -0,0 +1,200 @@
+import os from 'os';
+import path from 'path';
+
+import chalk from 'chalk';
+import spawn from 'cross-spawn';
+import fs from 'fs-extra';
+
+import {
+  projectNameInput,
+  shouldUseYarn,
+  templateDependencies,
+  templateFolder,
+  tryGitCommit,
+  tryGitInit,
+  validProjectName,
+} from './helper';
+
+export async function createTemplate(projectName: string) {
+  return getProjectName({ projectName })
+    .then(createProjectFolder)
+    .then(copyTemplate)
+    .then(createPackageJson)
+    .then(changeCurrentDirectory)
+    .then(installDependencies)
+    .then(startGitRepo)
+    .then(successMessage);
+}
+
+async function getProjectName(config) {
+  const { projectName } = config;
+
+  const [result, reason] = validProjectName(projectName);
+
+  const isValidName = result && !!projectName;
+
+  if (!isValidName) {
+    if (projectName) {
+      console.error(chalk.red(`Nome Invalido: ${reason}`));
+    }
+
+    const { inputName } = await projectNameInput();
+
+    config.projectName = inputName;
+  }
+
+  return config;
+}
+
+async function createProjectFolder(config) {
+  const projectFolder = path.resolve(config.projectName);
+
+  await fs.ensureDir(projectFolder);
+
+  config.projectFolder = projectFolder;
+
+  return config;
+}
+
+async function copyTemplate(config) {
+  const { projectFolder } = config;
+
+  await fs.copy(templateFolder, projectFolder);
+
+  console.log(chalk.green(`Criando novo projeto em:\n${chalk.cyan(projectFolder)}\n`));
+
+  return config;
+}
+
+async function createPackageJson(config) {
+  const { projectName, projectFolder } = config;
+
+  await fs.writeJson(
+    path.join(projectFolder, 'package.json'),
+    {
+      name: projectName,
+      version: '0.1.0',
+      private: true,
+      author: process.env.USER || os.hostname(),
+      license: 'MIT',
+      scripts: {
+        start: 'scripts dev',
+        build: 'scripts build',
+        test: 'scripts test -- --config=jest.config.js',
+        lint: 'eslint --quiet src --ext ts,tsx',
+        'lint:full': 'eslint src --ext ts,tsx',
+        'lint:fix': 'eslint --fix src --ext ts,tsx',
+        'prettier:write': 'prettier src/ --write',
+        'audit-dependencies': 'audit-ci --config audit-ci.json',
+      },
+      husky: {
+        hooks: {
+          'pre-commit': 'lint-staged',
+          'commit-msg': 'commitlint -E HUSKY_GIT_PARAMS',
+        },
+      },
+      'lint-staged': {
+        '*.{json,css,md}': ['yarn prettier:write'],
+        '*.{ts,tsx}': ['yarn audit-dependencies', 'yarn lint', 'yarn prettier:write'],
+      },
+    },
+    {
+      spaces: 2,
+    },
+  );
+
+  return config;
+}
+
+async function changeCurrentDirectory(config) {
+  process.chdir(config.projectFolder);
+
+  return config;
+}
+
+async function installDependencies(config) {
+  const useYarn = shouldUseYarn();
+
+  const displayCommand = useYarn ? 'yarn' : 'npm';
+
+  console.log(`Instalando dependencias com ${chalk.yellow(useYarn ? 'yarn' : 'npm')}\n`);
+
+  config.useYarn = useYarn;
+  config.displayCommand = displayCommand;
+
+  return new Promise((resolve, reject) => {
+    let command = 'npm';
+
+    let args = ['install', '--save', '--loglevel', 'error'].concat(templateDependencies);
+
+    if (useYarn) {
+      command = 'yarnpkg';
+
+      args = ['add', '--exact'].concat(templateDependencies);
+    }
+
+    const child = spawn(command, args, { stdio: 'inherit' });
+
+    child.on('close', (code) => {
+      if (code !== 0) {
+        reject(new Error(`${command} ${args.join(' ')}`));
+      } else {
+        resolve(config);
+      }
+    });
+  });
+}
+
+async function startGitRepo(config) {
+  const success = tryGitInit();
+
+  config.gitStarted = success;
+
+  if (success) {
+    const { useYarn, projectFolder } = config;
+
+    const hooks = ['lint-staged', 'husky', '@commitlint/cli', '@commitlint/config-conventional'];
+
+    let command = 'npm';
+
+    let args = ['install', '--save', '--loglevel', 'error'].concat(hooks);
+
+    if (useYarn) {
+      command = 'yarnpkg';
+
+      args = ['add', '--dev', '--exact'].concat(hooks);
+    }
+
+    console.log(`Iniciando Git Hooks\n`);
+
+    return new Promise((resolve, reject) => {
+      const child = spawn(command, args, { stdio: 'inherit' });
+
+      child.on('close', (code) => {
+        if (code !== 0) {
+          reject(new Error(`${command} ${args.join(' ')}`));
+        } else {
+          config.gitInitialCommit = tryGitCommit(projectFolder);
+
+          resolve(config);
+        }
+      });
+    });
+  }
+
+  return config;
+}
+
+async function successMessage(config) {
+  if (config.gitStarted && config.gitInitialCommit) {
+    const { projectName, projectFolder, displayCommand, useYarn } = config;
+
+    console.log();
+    console.log(chalk.green(`Sucesso! Projeto ${chalk.white(projectName)} Criado em:\n${chalk.white(projectFolder)}`));
+    console.log();
+    console.log('Comandos:\n');
+    console.log(chalk.cyan(`${displayCommand} start`));
+    console.log(chalk.cyan(`${displayCommand} ${useYarn ? '' : 'run '}build`));
+    console.log(`\n\n`);
+  }
+}

package/src/command/dev.ts

@@ -0,0 +1,95 @@
+process.env.BABEL_ENV = 'development';
+process.env.NODE_ENV = 'development';
+
+// Makes the script crash on unhandled rejections instead of silently
+// ignoring them.
+process.on('unhandledRejection', (err) => {
+  throw err;
+});
+
+import fs from 'fs';
+
+import chalk from 'chalk';
+import merge from 'deepmerge';
+import webpack, { Configuration } from 'webpack';
+import WebpackDevServer from 'webpack-dev-server';
+
+import { getEnviroment } from '../config/env';
+import defaultPaths, { AppPaths } from '../config/paths';
+import { CustomConfigType, defaultDevConfig } from '../config/shared';
+import configFactory from '../config/webpack.config';
+import createDevServerConfig from '../config/webpackDevServer.config';
+import checkRequiredFiles from '../utils/checkRequiredFiles';
+import { choosePort, createCompiler, prepareProxy, prepareUrls } from '../utils/WebpackDevServerUtils';
+
+export async function createDevServer(paths: AppPaths, userConfig: CustomConfigType = defaultDevConfig) {
+  const useCustomConfig = fs.existsSync(paths.appCustomConfig);
+
+  const { configureWebpack, ...customConfig }: CustomConfigType = useCustomConfig
+    ? merge.all([defaultDevConfig, userConfig, require(paths.appCustomConfig) ?? {}])
+    : Object.assign(defaultDevConfig, userConfig);
+
+  const { port: devPort, host: devHost, ...devOptions } = customConfig;
+  const resolvedHost = devHost || 'localhost';
+  const PORT = await choosePort(resolvedHost, devPort ?? 3000);
+
+  if (PORT == null) {
+    return;
+  }
+
+  try {
+    if (!checkRequiredFiles([paths.appHtml, paths.appIndexJs])) {
+      process.exit(1);
+    }
+
+    const baseConfig = configFactory('development', paths, devOptions) as Configuration;
+
+    const config =
+      configureWebpack && typeof configureWebpack === 'function'
+        ? configureWebpack(baseConfig, 'development')
+        : baseConfig;
+
+    const tscCompileOnError = process.env.TSC_COMPILE_ON_ERROR === 'true';
+    const protocol = process.env.HTTPS === 'true' ? 'https' : 'http';
+    const urls = prepareUrls(protocol, resolvedHost, PORT!, paths.publicUrlOrPath.slice(0, -1));
+
+    const appName = require(paths.appPackageJson).name;
+    const compiler = createCompiler({
+      appName,
+      config,
+      urls,
+      useYarn: true,
+      useTypeScript: true,
+      tscCompileOnError,
+      webpack,
+    });
+
+    const proxySetting = require(paths.appPackageJson).proxy;
+    const proxyConfig = prepareProxy(proxySetting, paths.appPublic, paths.publicUrlOrPath);
+    const serverConfig = createDevServerConfig(proxyConfig, urls.lanUrlForConfig, paths);
+    const devServer = new WebpackDevServer({ ...serverConfig, host: resolvedHost, port: PORT! }, compiler);
+
+    await devServer.start();
+    if (useCustomConfig) {
+      console.log(`${chalk.cyan('Using custom config from:')} ${chalk.yellow(paths.appCustomConfig)}\n`);
+    }
+    console.log(chalk.cyan('Starting the development server...\n'));
+
+    (['SIGINT', 'SIGTERM'] as const).forEach((sig) => {
+      process.on(sig, async () => {
+        await devServer.stop();
+        process.exit();
+      });
+    });
+  } catch (err: any) {
+    if (err && err.message) {
+      console.log(err.message);
+    }
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  getEnviroment(defaultPaths);
+  createDevServer(defaultPaths);
+}

package/src/command/test.ts

@@ -0,0 +1,33 @@
+process.env.BABEL_ENV = 'test';
+process.env.NODE_ENV = 'test';
+process.env.PUBLIC_URL = '';
+
+process.on('unhandledRejection', (err) => {
+  throw err;
+});
+
+require('../config/env');
+
+import { execSync } from 'child_process';
+
+import jestRunner from 'jest-cli';
+
+const argv = process.argv.slice(2);
+
+function isInGitRepository() {
+  try {
+    execSync('git rev-parse --is-inside-work-tree', { stdio: 'ignore' });
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+// Watch unless on CI or explicitly running all tests
+if (!process.env.CI && argv.indexOf('--watchAll') === -1 && argv.indexOf('--watchAll=false') === -1) {
+  // https://github.com/facebook/create-react-app/issues/5210
+  const hasSourceControl = isInGitRepository();
+  argv.push(hasSourceControl ? '--watch' : '--watchAll');
+}
+
+jestRunner.run(argv);

package/src/config/env.ts

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import path from 'path';
+
+import { CustomConfigType } from './shared';
+
+export function getEnviroment(paths) {
+  const { NODE_ENV, ENV } = process.env;
+
+  if (!NODE_ENV) {
+    throw new Error('The NODE_ENV environment variable is required but was not specified.');
+  }
+
+  const dotenvFiles = [
+    `${paths.dotenv}.${NODE_ENV}.local`,
+    `${paths.dotenv}.${ENV}.local`,
+    // Don't include `.env.local` for `test` environment
+    // since normally you expect tests to produce the same
+    // results for everyone
+    NODE_ENV !== 'test' && `${paths.dotenv}.local`,
+    `${paths.dotenv}.${NODE_ENV}`,
+    `${paths.dotenv}.${ENV}`,
+    paths.dotenv,
+  ].filter(Boolean) as Array<string>;
+
+  // Load environment variables from .env* files. Suppress warnings using silent
+  // if this file is missing. dotenv will never modify any environment variables
+  // that have already been set.  Variable expansion is supported in .env files.
+  dotenvFiles.forEach((dotenvFile) => {
+    if (fs.existsSync(dotenvFile)) {
+      require('dotenv-expand')(
+        require('dotenv').config({
+          path: dotenvFile,
+        }),
+      );
+    }
+  });
+
+  const appDirectory = fs.realpathSync(process.cwd());
+  process.env.NODE_PATH = (process.env.NODE_PATH || '')
+    .split(path.delimiter)
+    .filter((folder) => folder && !path.isAbsolute(folder))
+    .map((folder) => path.resolve(appDirectory, folder))
+    .join(path.delimiter);
+}
+
+export default function getClientEnvironment(publicUrl: string, config: CustomConfigType) {
+  // Grab NODE_ENV and REACT_APP_* environment variables and prepare them to be
+  // injected into the application via DefinePlugin in webpack configuration.
+  const REACT_APP = /^REACT_APP_/i;
+
+  const raw = Object.keys(process.env)
+    .filter((key) => REACT_APP.test(key))
+    .reduce((env, key) => Object.assign(env, { [key]: process.env[key] }), {
+      // Useful for determining whether we’re running in production mode.
+      // Most importantly, it switches React into the correct mode.
+      NODE_ENV: process.env.NODE_ENV || 'development',
+      // Useful for resolving the correct path to static assets in `public`.
+      // For example, <img src={process.env.PUBLIC_URL + '/img/logo.png'} />.
+      // This should only be used as an escape hatch. Normally you would put
+      // images into the `src` and `import` them in code to get their paths.
+      PUBLIC_URL: publicUrl,
+      // We support configuring the sockjs pathname during development.
+      // These settings let a developer run multiple simultaneous projects.
+      // They are used as the connection `hostname`, `pathname` and `port`
+      // in webpackHotDevClient. They are used as the `sockHost`, `sockPath`
+      // and `sockPort` options in webpack-dev-server.
+      WDS_SOCKET_HOST: process.env.WDS_SOCKET_HOST,
+      WDS_SOCKET_PATH: process.env.WDS_SOCKET_PATH,
+      WDS_SOCKET_PORT: process.env.WDS_SOCKET_PORT,
+      // Whether or not react-refresh is enabled.
+      // react-refresh is not 100% stable at this time,
+      // which is why it's disabled by default.
+      // It is defined here so it is available in the webpackHotDevClient.
+      FAST_REFRESH: !!config.useFastRefresh,
+    });
+  // Stringify all values so we can feed into webpack DefinePlugin
+  const stringified = {
+    'process.env': Object.keys(raw).reduce((env, key) => Object.assign(env, { [key]: JSON.stringify(raw[key]) }), {}),
+  };
+
+  return { raw, stringified };
+}

package/src/config/modules.ts

@@ -0,0 +1,115 @@
+import path from 'path';
+
+import chalk from 'chalk';
+import resolve from 'resolve';
+
+import paths from './paths';
+
+// Check if TypeScript is setup
+const ts = require(
+  resolve.sync('typescript', {
+    basedir: paths.appNodeModules,
+  }),
+);
+
+/**
+ * Get additional module paths based on the baseUrl of a compilerOptions object.
+ *
+ * @param {Object} options
+ */
+function getAdditionalModulePaths(options: any = {}) {
+  const { baseUrl } = options;
+
+  if (!baseUrl) {
+    return '';
+  }
+
+  const baseUrlResolved = path.resolve(paths.appPath, baseUrl);
+
+  // We don't need to do anything if `baseUrl` is set to `node_modules`. This is
+  // the default behavior.
+  if (path.relative(paths.appNodeModules, baseUrlResolved) === '') {
+    return null;
+  }
+
+  // Allow the user set the `baseUrl` to `appSrc`.
+  if (path.relative(paths.appSrc, baseUrlResolved) === '') {
+    return [paths.appSrc];
+  }
+
+  // If the path is equal to the root directory we ignore it here.
+  // We don't want to allow importing from the root directly as source files are
+  // not transpiled outside of `src`. We do allow importing them with the
+  // absolute path (e.g. `src/Components/Button.js`) but we set that up with
+  // an alias.
+  if (path.relative(paths.appPath, baseUrlResolved) === '') {
+    return null;
+  }
+
+  // Otherwise, throw an error.
+  throw new Error(
+    chalk.red.bold(
+      "Your project's `baseUrl` can only be set to `src` or `node_modules`." +
+        ' Create React App does not support other values at this time.',
+    ),
+  );
+}
+
+/**
+ * Get webpack aliases based on the baseUrl of a compilerOptions object.
+ *
+ * @param {*} options
+ */
+function getWebpackAliases(options: any = {}) {
+  const { baseUrl } = options;
+
+  if (!baseUrl) {
+    return {};
+  }
+
+  const baseUrlResolved = path.resolve(paths.appPath, baseUrl);
+
+  if (path.relative(paths.appPath, baseUrlResolved) === '') {
+    return {
+      src: paths.appSrc,
+    };
+  }
+}
+
+/**
+ * Get jest aliases based on the baseUrl of a compilerOptions object.
+ *
+ * @param {*} options
+ */
+function getJestAliases(options: any = {}) {
+  const { baseUrl } = options;
+
+  if (!baseUrl) {
+    return {};
+  }
+
+  const baseUrlResolved = path.resolve(paths.appPath, baseUrl);
+
+  if (path.relative(paths.appPath, baseUrlResolved) === '') {
+    return {
+      '^src/(.*)$': '<rootDir>/src/$1',
+    };
+  }
+}
+
+function getModules() {
+  const config = ts.readConfigFile(paths.appTsConfig, ts.sys.readFile).config || {};
+
+  const options = config.compilerOptions || {};
+
+  const additionalModulePaths = getAdditionalModulePaths(options);
+
+  return {
+    additionalModulePaths,
+    webpackAliases: getWebpackAliases(options),
+    jestAliases: getJestAliases(options),
+    hasTsConfig: true,
+  };
+}
+
+export default getModules();

package/src/config/paths.ts

@@ -0,0 +1,88 @@
+import fs from 'fs';
+import path from 'path';
+
+import getPublicUrlOrPath from '../utils/getPublicUrlOrPath';
+
+export type AppPaths = {
+  dotenv: string;
+  appPath: string;
+  appBuild: string;
+  appPublic: string;
+  appHtml: string;
+  appIndexJs: string;
+  appSrc: string;
+  appCustomConfig: string;
+  appTsConfig: string;
+  yarnLockFile: string;
+  testsSetup: string;
+  proxySetup: string;
+  appNodeModules: string;
+  appPackageJson: string;
+  publicUrlOrPath: string;
+  moduleFileExtensions: string[];
+};
+
+export const moduleFileExtensions = [
+  'web.mjs',
+  'mjs',
+  'web.js',
+  'js',
+  'web.ts',
+  'ts',
+  'web.tsx',
+  'tsx',
+  'json',
+  'web.jsx',
+  'jsx',
+];
+
+export function createAppPaths(basePath: string = process.cwd()): AppPaths {
+  const appDirectory = fs.realpathSync(basePath);
+  const resolveApp = (relativePath) => path.resolve(appDirectory, relativePath);
+
+  const appPackageJson = resolveApp('package.json');
+
+  const publicUrlOrPath = getPublicUrlOrPath(
+    process.env.NODE_ENV === 'development',
+    require(appPackageJson).homepage,
+    process.env.PUBLIC_URL,
+  );
+
+  // Resolve file paths in the same order as webpack
+  const resolveModule = (resolveFn, filePath) => {
+    const extension = moduleFileExtensions.find((ext) => fs.existsSync(resolveFn(`${filePath}.${ext}`)));
+
+    if (extension) {
+      return resolveFn(`${filePath}.${extension}`);
+    }
+
+    return resolveFn(`${filePath}.js`);
+  };
+
+  const appCustomConfig = resolveApp('scriptsrc.js');
+  const customConfigExist = fs.existsSync(appCustomConfig);
+  const appBuildPathOutput = require(appCustomConfig).output;
+
+  const appBuildPath = customConfigExist && appBuildPathOutput ? appBuildPathOutput : 'build';
+
+  return {
+    dotenv: resolveApp('.env'),
+    appPath: resolveApp('.'),
+    appBuild: resolveApp(appBuildPath),
+    appPublic: resolveApp('public'),
+    appHtml: resolveApp('public/index.html'),
+    appIndexJs: resolveModule(resolveApp, 'src/index'),
+    appSrc: resolveApp('src'),
+    appTsConfig: resolveApp('tsconfig.json'),
+    yarnLockFile: resolveApp('yarn.lock'),
+    testsSetup: resolveModule(resolveApp, 'src/setupTests'),
+    proxySetup: resolveApp('src/setupProxy.js'),
+    appNodeModules: resolveApp('node_modules'),
+    appCustomConfig,
+    appPackageJson,
+    publicUrlOrPath,
+    moduleFileExtensions,
+  };
+}
+
+export default createAppPaths();

package/src/config/shared.ts

@@ -0,0 +1,27 @@
+import { Configuration } from 'webpack';
+
+export type CustomConfigType = {
+  port?: number;
+  host?: string;
+  head?: HeadConfigType;
+  constants?: Record<string, string>;
+  i18nConfig?: Record<string, any>;
+  useFastRefresh?: boolean;
+  relayArtifactDirectory?: string;
+  configureWebpack?: (config: Configuration, env: 'development' | 'production' | 'test') => Configuration;
+};
+
+export type HeadConfigType = {
+  title: string;
+};
+
+export const defaultDevConfig = {
+  port: 3000,
+  host: '0.0.0.0',
+  head: {
+    title: 'Apollion',
+  },
+  constants: {},
+  i18nConfig: {},
+  useFastRefresh: true,
+};