@corva/create-app 0.28.0-2 → 0.28.0-3

package/lib/index.js

@@ -20,31 +20,25 @@ const utils = require('./helpers/utils.js');
 const manifestHelpers = require('./helpers/manifest.js');
 const versioning = require('./helpers/versioning.js');
 
-const packageConstants = require('./constants/package.js');
+const { getDefaultsForPackageJson } = require('./constants/package.js');
 const manifestConstants = require('./constants/manifest.js');
 
 const packageJson = require('../package.json');
 const { clear } = require('console');
 const spawn = require('cross-spawn');
-const { APP_RUNTIMES, TEMPLATE_TYPES, APP_TYPES } = require('./constants/cli');
 const { runFlow } = require('./flow');
 const { ERROR_ICON } = require('./constants/messages');
 const { StepError } = require('./flows/lib/step-error');
 const { RELEASE_FLOW } = require('./flows/release');
 const { ZIP_FLOW } = require('./flows/zip');
 const { bumpVersionOptionDeprecated, bumpVersionOption } = require('./bump-version.option');
+const { Manifest } = require('./flows/lib/manifest');
+const { resolveAppRuntime } = require('./helpers/resolve-app-runtime');
 
-const YARN_EXECUTABLE = 'yarn';
-
-let packageManager = YARN_EXECUTABLE;
-let useTypescript = false;
-
-const shouldUseYarn = () => packageManager === YARN_EXECUTABLE;
-const getLockFileName = (manager) =>
-  manager === YARN_EXECUTABLE ? 'yarn.lock' : 'package-lock.json';
-
-let projectName;
-let program;
+const writejsonOptions = {
+  spaces: 2,
+  EOL: os.EOL
+};
 
 function startingMessage() {
   clear();
@@ -60,7 +54,7 @@ function checkNodeVersion() {
     console.log(
       chalk.red(
         `\nYou are using Node ${process.version}.\n\n` +
-          `Please update to Node 10 or higher for a better, fully supported experience.\n`
+        `Please update to Node 10 or higher for a better, fully supported experience.\n`
       )
     );
     // Fall back to latest supported react-scripts on Node 4
@@ -90,11 +84,11 @@ function checkOptions(opts) {
 const printDeprecationNotice = (param) =>
   console.warn(
     chalk.bgYellowBright`DEPRECATED OPTION: ${param}` +
-      ` Use ${chalk.cyan(`create-corva-app ${param} .`)} instead`
+    ` Use ${chalk.cyan(`create-corva-app ${param} .`)} instead`
   );
 
 async function initialChecks() {
-  program = new Command()
+  const program = new Command()
     .hook('preAction', async () => {
       checkNodeVersion();
 
@@ -109,11 +103,10 @@ async function initialChecks() {
     .argument('[project-directory]', 'project directory to work with', process.cwd())
     .usage(`${chalk.green('<project-directory>')} [options]`);
 
-  manifestConstants.manifestOptions(projectName).forEach((value) => {
+  manifestConstants.manifestOptions().forEach((value) => {
     const type = typeof value.default;
     const option = new Option(
-      `${value.alias ? `-${value.alias}, ` : ''}--${value.name} [${
-        (type !== 'undefined' && type) || 'string'
+      `${value.alias ? `-${value.alias}, ` : ''}--${value.name} [${(type !== 'undefined' && type) || 'string'
       }]`,
       value.message
     );
@@ -156,10 +149,6 @@ async function initialChecks() {
     .addOption(bumpVersionOptionDeprecated);
 
   createCommand.action(async (dirName, options) => {
-    projectName = dirName;
-    packageManager = options.packageManager || packageManager;
-    useTypescript = options.useTypescript || useTypescript;
-
     if (options.zip || options.release) {
       options.bumpVersion = await ensureBumpVersion(options.bumpVersion);
     }
@@ -179,7 +168,7 @@ async function initialChecks() {
     startingMessage();
 
     // NOTE: Default action
-    await createApp(options);
+    await createApp(dirName, options);
   });
 
   program
@@ -272,9 +261,11 @@ const handleCommanderError = (e) => {
   }
 };
 
-async function initPackage(manifest) {
-  const appType = manifest.application.type;
-  if (appType === APP_TYPES.UI) {
+async function initPackage(projectName, opts) {
+  const manifest = new Manifest(manifestHelpers.fillManifest(opts));
+  const runtime = resolveAppRuntime(opts);
+
+  if (manifest.isUi()) {
     await ensureLatestVersion();
   }
 
@@ -282,31 +273,20 @@ async function initPackage(manifest) {
 
   console.log(`Creating a new Corva app in ${chalk.green(root)}.`);
 
-  fs.mkdirSync(root);
-
-  fs.writeFileSync(path.join(root, 'manifest.json'), JSON.stringify(manifest, null, 2) + os.EOL);
-
-  let runtime = manifest.settings.runtime;
-
-  // Runtimes normally include a version number, like python3.8 or nodejs12.x. We don't want to have a directory or
-  // config for every possible version at this point, so just consolidate all versions of a runtime into a single
-  // template directory.
-  if (appType !== APP_TYPES.UI) {
-    if (runtime.startsWith(TEMPLATE_TYPES.PYTHON)) {
-      runtime = TEMPLATE_TYPES.PYTHON;
-    } else {
-      runtime = useTypescript ? TEMPLATE_TYPES.NODE_TYPESCRIPT : TEMPLATE_TYPES.NODE;
-    }
-  } else {
-    runtime = useTypescript ? TEMPLATE_TYPES.UI_TS : TEMPLATE_TYPES.UI;
+  if (fs.existsSync(root)) {
+    throw new Error(`Directory already exists: ${root}`);
   }
+  await fs.mkdir(root);
+  await fs.writeJSON(path.join(root, 'manifest.json'), manifest.manifest, writejsonOptions);
 
-  addTemplate(root, appType, runtime);
-  configureApp(root, appType, runtime, manifest);
-  installApp(root, appType, runtime);
+  await addTemplate(root, manifest, runtime);
+  await configureApp(root, manifest, runtime);
+  await installApp(root, manifest, runtime);
+
+  console.log();
 }
 
-async function createApp(opts) {
+async function createApp(dirName, opts) {
   const { isValid, values } = checkOptions(opts);
 
   if (isValid) {
@@ -314,66 +294,106 @@ async function createApp(opts) {
       console.log(`${key} : ${values[key]}`);
     });
 
-    const manifest = manifestHelpers.fillManifest(opts);
-
-    await initPackage(manifest);
-  } else {
-    console.log('Please fill your app Metadata');
-
-    inquirer.prompt(manifestConstants.manifestOptions(projectName), opts).then((answers) => {
-      packageManager = answers.packageManager || packageManager;
-      useTypescript = answers.useTypescript || useTypescript;
+    return initPackage(dirName, opts);
+  }
 
-      const manifest = manifestHelpers.fillManifest(answers);
+  console.log('Please fill your app Metadata');
 
-      initPackage(manifest);
-    });
-  }
+  const answers = inquirer.prompt(manifestConstants.manifestOptions(dirName), opts)
 
-  console.log();
+  return initPackage(dirName, answers);
 }
 
-function addTemplate(root, appType, runtime) {
+/**
+ * 
+ * @param {string} root 
+ * @param {import('./flows/lib/manifest').Manifest} manifest 
+ * @param {*} runtime 
+ */
+async function addTemplate(root, manifest, runtime) {
   console.log(chalk.green('Copying app template...'));
   console.log();
 
-  const templateFolder = path.resolve(__dirname, '..', 'templates', appType, runtime);
-
-  utils.copyFolderRecursiveSync(templateFolder, root, runtime);
+  const templateFolder = path.resolve(__dirname, '..', 'templates', runtime.language, manifest.type);
 
-  const gitignore = path.join(root, 'gitignore');
+  utils.copyFolderRecursiveSync(templateFolder, root);
 
-  if (fs.pathExistsSync(gitignore)) {
-    // We can't have .gitignore file in our templates.
-    // It's missing when @corva/create-app is installed.
-    // That's why we manually rename gitignore to .gitignore after copying template
+  if (manifest.isNode()) {
+    utils.copyFolderRecursiveSync(path.resolve(__dirname, '..', 'common', 'node'), root);
+  }
 
-    fs.renameSync(gitignore, path.join(root, '.gitignore'));
+  if (manifest.isPython()) {
+    utils.copyFolderRecursiveSync(path.resolve(__dirname, '..', 'common', 'python'), root);
   }
 
+  // We can't have .gitignore file in our templates.
+  // It's missing when @corva/create-app is installed.
+  // That's why we manually rename gitignore to .gitignore after copying template
+  fs.renameSync(path.join(root, 'gitignore'), path.join(root, '.gitignore'));
+
   console.log(chalk.green('Done: copying app template!'));
 }
 
-function configureApp(root, appType, runtime, manifest) {
-  if (appType === APP_TYPES.UI) {
-    addPackageJSON(root, manifest.application.name);
-  } else if (runtime.startsWith(TEMPLATE_TYPES.NODE)) {
-    updatePackageJSON(root, manifest.application.description, appType, runtime);
+/**
+ * 
+ * @param {string} root 
+ * @param {import('./flows/lib/manifest').Manifest} manifest 
+ * @param {*} runtime 
+ */
+async function configureApp(root, manifest, runtime) {
+  if (manifest.isJs()) {
+    await addPackageJSON(root, manifest, runtime);
+  }
+
+  if (manifest.isNode()) {
+    await addTsConfigs(root, manifest, runtime);
   }
 
-  if (runtime.startsWith(TEMPLATE_TYPES.PYTHON) && appType === APP_TYPES.SCHEDULER) {
-    patchSchedulerForPython(root, appType, runtime, manifest);
+  if (manifest.isPython() && manifest.isScheduler()) {
+    patchSchedulerForPython(root, manifest, runtime);
+  }
+}
+
+const addTsConfigs = (root, manifest, runtime) => {
+  if (runtime.language !== 'typescript') {
+    return;
   }
+
+  return Promise.all([
+    fs.writeJson(path.resolve(root, 'tsconfig.json'),
+      {
+        extends: `@tsconfig/node${runtime.version}/tsconfig.json`,
+        compilerOptions: {
+          inlineSourceMap: true
+        }
+      },
+      writejsonOptions
+    ),
+    fs.writeJson(path.resolve(root, 'tsconfig.build.json'),
+      {
+        "extends": "./tsconfig.json",
+        "include": [
+          "lib/**/*.ts",
+          "index.ts"
+        ],
+        "exclude": [
+          "node_modules",
+          "**/*.spec.ts"
+        ]
+      },
+      writejsonOptions
+    ),
+  ])
 }
 
-function patchSchedulerForPython(root, appType, runtime, manifest) {
-  const schedulerType = manifest.settings.app.scheduler_type;
+function patchSchedulerForPython(root, manifest, runtime) {
+  const schedulerType = manifest.manifest.settings.app.scheduler_type;
 
   if (schedulerType === manifestConstants.SCHEDULER_TYPE_DATA_TIME.value) {
     return;
   }
 
-  const templateFolder = path.resolve(__dirname, '..', 'templates', appType, runtime);
+  const templateFolder = path.resolve(__dirname, '..', 'templates', runtime.language, manifest.type);
   const originalType = 'ScheduledDataTimeEvent';
   const replacementType =
     schedulerType === manifestConstants.SCHEDULER_TYPE_DEPTH.value
@@ -386,58 +406,42 @@ function patchSchedulerForPython(root, appType, runtime, manifest) {
   fs.writeFileSync(path.join(root, 'lambda_function.py'), patchedCode);
 }
 
-function addPackageJSON(root, appName) {
-  const devDependencies = {
-    ...packageConstants.dependencies.devDependencies,
-    ...(useTypescript && packageConstants.tsDependencies.devDependencies),
-  };
+/**
+ * 
+ * @param {string} root 
+ * @param {import('./flows/lib/manifest').Manifest} manifest 
+ */
+function addPackageJSON(root, manifest, runtime) {
+  const defaults = getDefaultsForPackageJson(manifest, runtime);
+
   const packageJson = {
-    name: appName.replace(/\W/g, ''),
-    version: '0.0.1',
-    main: 'src/index.js',
-    scripts: packageConstants.scripts,
-    ...packageConstants.dependencies,
-    devDependencies,
+    name: manifest.name.replace(/\W/g, ''),
+    version: defaults.version,
+    description: manifest.description || defaults.description,
+    engines: {
+      node: `>=12.22.12`,
+      // node: `>=${runtime.version}`,
+      [runtime.packageManager]: '*'
+    },
+    scripts: defaults.scripts,
+    dependencies: defaults.dependencies,
+    devDependencies: defaults.devDependencies,
   };
 
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(packageJson, null, 2) + os.EOL);
-}
-
-function updatePackageJSON(root, description, appType, runtime) {
-  const templateFolder = path.resolve(__dirname, '..', 'templates', appType, runtime);
-
-  let packageJson = JSON.parse(fs.readFileSync(path.join(templateFolder, 'package.json'), 'utf-8'));
-
-  packageJson.name = projectName.replace(/\W/g, '-').toLowerCase();
-  packageJson.description = description;
-
-  packageJson.scripts.bundle = packageJson.scripts.bundle.replace(
-    '$LOCKFILE',
-    getLockFileName(packageManager)
-  );
-
-  fs.writeFileSync(path.join(root, 'package.json'), JSON.stringify(packageJson, null, 2) + os.EOL);
-}
-
-function installApp(appPath, appType, runtime) {
-  switch (runtime) {
-    case TEMPLATE_TYPES.PYTHON: {
-      break;
-    }
-    default: {
-      installJsApp(appPath, appType);
-
-      break;
-    }
-  }
+  return fs.writeJSON(path.join(root, 'package.json'), packageJson, writejsonOptions);
 }
 
-function installJsApp(appPath, appType) {
-  const command = packageManager;
+/**
+ * 
+ * @param {string} root 
+ * @param {import('./flows/lib/manifest').Manifest} manifest 
+ */
+async function installApp(root, manifest, runtime) {
+  const command = manifest.isJs() ? runtime.packageManager : 'make';
   const args = ['install'];
 
-  console.log(chalk.yellow(`Installing template dependencies using ${command}...`));
-  const proc = spawn.sync(command, args, { stdio: ['inherit', 'inherit', 'pipe'], cwd: appPath });
+  console.log(chalk.yellow(`Installing template dependencies using ${runtime.packageManager}...`));
+  const proc = spawn.sync(command, args, { stdio: ['inherit', 'inherit', 'pipe'], cwd: root });
 
   if (proc.stderr) {
     const error = proc.stderr
@@ -456,31 +460,30 @@ function installJsApp(appPath, appType) {
 
   console.log(chalk.green('Successfull project install'));
 
-  let initializedGit = false;
-  if (versioning.tryGitInit(appPath)) {
-    initializedGit = true;
+  if (versioning.tryGitInit(root)) {
     console.log();
     console.log('Initialized a git repository.');
-  }
 
-  if (initializedGit && versioning.tryGitCommit(appPath)) {
-    console.log();
-    console.log('Created git commit.');
+    if (versioning.tryGitCommit(root)) {
+      console.log();
+      console.log('Created git commit.');
+    }
   }
 
   console.log();
-  console.log(`Success! Created ${projectName} at ${appPath}`);
+  console.log(`Success! Created ${manifest.name} at ${root}`);
 
-  if (appType === APP_RUNTIMES.UI) {
-    console.log('Inside that directory, you can run several commands:');
-    helpCommands();
-  }
+  helpCommands(manifest, runtime);
 }
 
-async function helpCommands() {
-  const displayedCommand = packageManager;
-  const useYarn = shouldUseYarn();
+async function helpCommands(manifest, { packageManager: displayedCommand }) {
+  if (!manifest.isUi()) {
+    return
+  }
+
+  const useYarn = displayedCommand === 'yarn';
 
+  console.log('Inside that directory, you can run several commands:');
   console.log();
   console.log(chalk.cyan(`  ${displayedCommand} start`));
   console.log('    Starts the development server.');

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@corva/create-app",
-    "version": "0.28.0-2",
+    "version": "0.28.0-3",
     "private": false,
     "description": "Create app to use it in CORVA.AI",
     "keywords": [

package/templates/scheduler/node/gitignore

@@ -1,21 +0,0 @@
-# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
-
-# dependencies
-/node_modules
-
-# testing
-/coverage
-
-# misc
-.env
-.DS_Store
-.env.local
-.env.development.local
-.env.test.local
-.env.production.local
-
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-
-*.zip

package/templates/scheduler/node/package.json

@@ -1,17 +0,0 @@
-{
-    "name": "my-dev-center-polling-scheduler-app",
-    "version": "0.0.1",
-    "description": "My Dev Center Polling Scheduler Data App",
-    "main": "index.js",
-    "scripts": {
-        "bundle": "create-corva-app zip .",
-        "test": "npm audit --production && npm run unit",
-        "unit": "jest"
-    },
-    "dependencies": {
-        "@corva/node-sdk": "^6.2.0"
-    },
-    "devDependencies": {
-        "jest": "^27.5.1"
-    }
-}