Ensure generation and related utils are sync

lib/Serverless.js

@@ -223,7 +223,7 @@ class Serverless {
       );
     }
     if (this.isLocallyInstalled) return;
-    const localServerlessPath = await resolveLocalServerlessPath();
+    const localServerlessPath = resolveLocalServerlessPath();
     if (!localServerlessPath) return;
     if (localServerlessPath === serverlessPath) {
       this.isLocallyInstalled = true;

lib/classes/PluginManager.js

@@ -615,8 +615,8 @@ class PluginManager {
     // TODO: Remove this logic with `v3.0.0` along with removal of `isTelemetryReportedExternally`
     // After we are ensured that local fallback from `v3` will always fall back to `v3` local installation
     if (!this.serverless.isTelemetryReportedExternally && !isTelemetryDisabled) {
-      await storeTelemetryLocally(
-        await generateTelemetryPayload({
+      storeTelemetryLocally(
+        generateTelemetryPayload({
           ...resolveCliInput(),
           serviceDir: this.serverless.serviceDir,
           configuration: this.serverless.configurationInput,

lib/cli/handle-error.js

@@ -60,8 +60,8 @@ module.exports = async (exception, options = {}) => {
 
   // If provided serverless instance is a local fallback, and we're not in context of it
   // Pass error handling to this local fallback implementation
-  if (isInvokedByGlobalInstallation && !(await resolveIsLocallyInstalled())) {
-    const localServerlessPath = await resolveLocalServerlessPath();
+  if (isInvokedByGlobalInstallation && !resolveIsLocallyInstalled()) {
+    const localServerlessPath = resolveLocalServerlessPath();
 
     try {
       // Attempt to use error handler from local version
@@ -135,7 +135,7 @@ module.exports = async (exception, options = {}) => {
   const installationModePostfix = await (async () => {
     if (isStandaloneExecutable) return ' (standalone)';
     if (isLocallyInstalled != null) return isLocallyInstalled ? ' (local)' : '';
-    return (await resolveIsLocallyInstalled()) ? ' (local)' : '';
+    return resolveIsLocallyInstalled() ? ' (local)' : '';
   })();
   consoleLog(
     chalk.yellow(`     Framework Version:         ${slsVersion}${installationModePostfix}`)
@@ -175,7 +175,7 @@ module.exports = async (exception, options = {}) => {
 
     if (commandSchema) {
       // Report only for recognized commands
-      const telemetryPayload = await generateTelemetryPayload({
+      const telemetryPayload = generateTelemetryPayload({
         command,
         options: cliOptions,
         commandSchema,
@@ -192,7 +192,7 @@ module.exports = async (exception, options = {}) => {
       if (!isUserError || !exception.code || !isErrorCodeNormative(exception.code)) {
         failureReason.location = resolveErrorLocation(exceptionTokens);
       }
-      await storeTelemetryLocally({ ...telemetryPayload, failureReason, outcome: 'failure' });
+      storeTelemetryLocally({ ...telemetryPayload, failureReason, outcome: 'failure' });
       await sendTelemetry();
     }
   }

lib/cli/render-version.js

@@ -13,7 +13,7 @@ const ServerlessError = require('../serverless-error');
 const serverlessPath = path.resolve(__dirname, '../..');
 
 module.exports = async () => {
-  const localServerlessPath = await resolveLocalServerlessPath();
+  const localServerlessPath = resolveLocalServerlessPath();
 
   if (localServerlessPath) {
     // If the version is already local, do not try to fallback for version resolution to avoid falling into the loop

lib/cli/resolve-local-serverless-path.js

@@ -2,18 +2,15 @@
 
 const path = require('path');
 const memoizee = require('memoizee');
-const resolve = require('ncjsm/resolve');
+const resolveSync = require('ncjsm/resolve/sync');
 
-module.exports = memoizee(
-  async () => {
-    try {
-      return path.resolve(
-        path.dirname((await resolve(process.cwd(), 'serverless')).realPath),
-        '..'
-      );
-    } catch {
-      return null;
-    }
-  },
-  { promise: true }
-);
+// This method should be kept as sync. The reason for it is the fact that
+// telemetry generation and persistence needs to be run in sync manner
+// and it depends on this function, either directly or indirectly.
+module.exports = memoizee(() => {
+  try {
+    return path.resolve(path.dirname(resolveSync(process.cwd(), 'serverless').realPath), '..');
+  } catch {
+    return null;
+  }
+});

lib/plugins/config.js

@@ -91,7 +91,7 @@ class Config {
           throw new ServerlessError(noSupportErrorMessage, 'AUTO_UPDATE_NOT_SUPPORTED');
         }
       } else {
-        if (!(await isNpmGlobalPackage())) {
+        if (!isNpmGlobalPackage()) {
           throw new ServerlessError(noSupportErrorMessage, 'AUTO_UPDATE_NOT_SUPPORTED');
         }
         if (!(await isNpmPackageWritable())) {

lib/utils/eventuallyUpdate.js

@@ -90,7 +90,7 @@ module.exports = async (serverless) => {
   if (serverless.isLocallyInstalled) return;
   if (serverless.isStandaloneExecutable) {
     if (process.platform === 'win32') return;
-  } else if (!(await isNpmGlobalPackage())) {
+  } else if (!isNpmGlobalPackage()) {
     return;
   }
   const currentVersionData = semver.parse(currentVersion);

lib/utils/is-locally-installed.js

@@ -5,7 +5,10 @@ const resolveLocalServerlessPath = require('../cli/resolve-local-serverless-path
 
 const serverlessPath = path.resolve(__dirname, '../..');
 
-module.exports = async () => {
-  const localServerlessPath = await resolveLocalServerlessPath();
+// This method should be kept as sync. The reason for it is the fact that
+// telemetry generation and persistence needs to be run in sync manner
+// and it depends on this function, either directly or indirectly.
+module.exports = () => {
+  const localServerlessPath = resolveLocalServerlessPath();
   return serverlessPath === localServerlessPath;
 };

lib/utils/npmPackage/isGlobal.js

@@ -2,21 +2,21 @@
 
 const memoizee = require('memoizee');
 const path = require('path');
-const spawn = require('child-process-ext/spawn');
+const { spawnSync } = require('child_process');
 
 const serverlessPackageRoot = path.resolve(__dirname, '../../../');
 
-module.exports = memoizee(
-  async () => {
-    const npmPackagesRoot = await (async () => {
-      try {
-        return String((await spawn('npm', ['root', '-g'])).stdoutBuffer).trim();
-      } catch {
-        return null;
-      }
-    })();
-    if (!npmPackagesRoot) return false;
-    return path.resolve(npmPackagesRoot, 'serverless') === serverlessPackageRoot;
-  },
-  { type: 'promise' }
-);
+// This method should be kept as sync. The reason for it is the fact that
+// telemetry generation and persistence needs to be run in sync manner
+// and it depends on this function, either directly or indirectly.
+module.exports = memoizee(() => {
+  const npmPackagesRoot = (() => {
+    try {
+      return String(spawnSync('npm', ['root', '-g']).stdout).trim();
+    } catch {
+      return null;
+    }
+  })();
+  if (!npmPackagesRoot) return false;
+  return path.resolve(npmPackagesRoot, 'serverless') === serverlessPackageRoot;
+});

lib/utils/telemetry/generatePayload.js

@@ -2,8 +2,8 @@
 
 const path = require('path');
 const os = require('os');
-const fs = require('fs').promises;
-const resolve = require('ncjsm/resolve');
+const fs = require('fs');
+const resolveSync = require('ncjsm/resolve/sync');
 const _ = require('lodash');
 const isPlainObject = require('type/plain-object/is');
 const isObject = require('type/object/is');
@@ -19,11 +19,11 @@ const AWS = require('aws-sdk');
 
 const configValidationModeValues = new Set(['off', 'warn', 'error']);
 
-const checkIsTabAutocompletionInstalled = async () => {
+const checkIsTabAutocompletionInstalled = () => {
   try {
-    return (await fs.readdir(path.resolve(os.homedir(), '.config/tabtab'))).some((filename) =>
-      filename.startsWith('serverless.')
-    );
+    return fs
+      .readdirSync(path.resolve(os.homedir(), '.config/tabtab'))
+      .some((filename) => filename.startsWith('serverless.'));
   } catch {
     return false;
   }
@@ -124,7 +124,9 @@ const getServiceConfig = ({ configuration, options }) => {
   return result;
 };
 
-module.exports = async ({
+// This method is explicitly kept as synchronous. The reason for it being the fact that it needs to
+// be executed in such manner due to its use in `process.on('SIGINT')` handler.
+module.exports = ({
   command,
   options,
   commandSchema,
@@ -176,39 +178,37 @@ module.exports = async ({
     return userConfig.get('userId');
   })();
 
-  const isLocallyInstalled = await (async () => {
+  const isLocallyInstalled = (() => {
     if (serverless) {
       return serverless.isLocallyInstalled;
     }
 
     return resolveIsLocallyInstalled();
   })();
 
-  const usedVersions = await (async () => {
-    if (!isLocallyInstalled || (await resolveIsLocallyInstalled())) {
+  const usedVersions = (() => {
+    if (!isLocallyInstalled || resolveIsLocallyInstalled()) {
       return {
         'serverless': require('../../../package').version,
         '@serverless/dashboard-plugin': require('@serverless/dashboard-plugin/package').version,
       };
     }
-    const localServerlessPath = await resolveLocalServerlessPath();
+    const localServerlessPath = resolveLocalServerlessPath();
     return {
       'serverless': require(path.resolve(localServerlessPath, 'package.json')).version,
       // Since v2.42.0 it's "@serverless/dashboard-plugin"
-      '@serverless/dashboard-plugin': await (async () => {
+      '@serverless/dashboard-plugin': (() => {
         try {
-          return require((
-            await resolve(localServerlessPath, '@serverless/dashboard-plugin/package')
-          ).realPath).version;
+          return require(resolveSync(localServerlessPath, '@serverless/dashboard-plugin/package')
+            .realPath).version;
         } catch {
           return undefined;
         }
       })(),
-      '@serverless/enterprise-plugin': await (async () => {
+      '@serverless/enterprise-plugin': (() => {
         try {
-          return require((
-            await resolve(localServerlessPath, '@serverless/enterprise-plugin/package')
-          ).realPath).version;
+          return require(resolveSync(localServerlessPath, '@serverless/enterprise-plugin/package')
+            .realPath).version;
         } catch {
           return undefined;
         }
@@ -230,19 +230,19 @@ module.exports = async ({
     },
     firstLocalInstallationTimestamp: userConfig.get('meta.created_at'),
     frameworkLocalUserId: userConfig.get('frameworkId'),
-    installationType: await (async () => {
+    installationType: (() => {
       if (isStandalone) {
         if (process.platform === 'win32') return 'global:standalone:windows';
         return 'global:standalone:other';
       }
       if (!isLocallyInstalled) {
-        return (await isNpmGlobal()) ? 'global:npm' : 'global:other';
+        return isNpmGlobal() ? 'global:npm' : 'global:other';
       }
       if (serverless && serverless.isInvokedByGlobalInstallation) return 'local:fallback';
       return 'local:direct';
     })(),
     isAutoUpdateEnabled: Boolean(userConfig.get('autoUpdate.enabled')),
-    isTabAutocompletionInstalled: await checkIsTabAutocompletionInstalled(),
+    isTabAutocompletionInstalled: checkIsTabAutocompletionInstalled(),
     timestamp: Date.now(),
     timezone,
     triggeredDeprecations: Array.from(triggeredDeprecations),

lib/utils/telemetry/index.js

@@ -89,21 +89,23 @@ async function request(payload, { ids, timeout } = {}) {
   return processResponseBody(response, ids, startTime);
 }
 
-async function storeLocally(payload, options = {}) {
+// This method is explicitly kept as synchronous. The reason for it being the fact that it needs to
+// be executed in such manner due to its use in `process.on('SIGINT')` handler.
+function storeLocally(payload, options = {}) {
   ensurePlainObject(payload);
   if (!telemetryUrl) return null;
   const isForced = options && options.isForced;
   if (isTelemetryDisabled && !isForced) return null;
   if (!cacheDirPath) return null;
   const id = uuid();
 
-  return (async function self() {
+  return (function self() {
     try {
-      return await fse.writeJson(join(cacheDirPath, id), { payload, timestamp: Date.now() });
+      return fse.writeJsonSync(join(cacheDirPath, id), { payload, timestamp: Date.now() });
     } catch (error) {
       if (error.code === 'ENOENT') {
         try {
-          await fse.ensureDir(cacheDirPath);
+          fse.ensureDirSync(cacheDirPath);
           return self();
         } catch (ensureDirError) {
           logError('Cache dir creation error:', ensureDirError);

scripts/postinstall.js

@@ -10,37 +10,35 @@ const truthyStr = (val) => val && !['0', 'false', 'f', 'n', 'no'].includes(val.t
 const { CI, ADBLOCK, SILENT } = process.env;
 const isNpmGlobalPackage = require('../lib/utils/npmPackage/isGlobal');
 
-(async () => {
-  if (!truthyStr(CI) && !truthyStr(ADBLOCK) && !truthyStr(SILENT)) {
-    const messageTokens = ['Serverless Framework successfully installed!'];
-
-    if (isStandaloneExecutable && !isWindows) {
-      messageTokens.push(
-        'To start your first project, please open another terminal and run “serverless”.'
-      );
-    } else {
-      messageTokens.push('To start your first project run “serverless”.');
-    }
-
-    if ((isStandaloneExecutable && !isWindows) || (await isNpmGlobalPackage())) {
-      messageTokens.push('Turn on automatic updates by running “serverless config --autoupdate”.');
-    }
-
-    if (isStandaloneExecutable && !isWindows) {
-      messageTokens.push('Uninstall at any time by running “serverless uninstall”.');
-    }
-
-    const message = messageTokens.join('\n\n');
-    process.stdout.write(
-      `${
-        isStandaloneExecutable && isWindows
-          ? message
-          : boxen(chalk.yellow(message), {
-              padding: 1,
-              margin: 1,
-              borderColor: 'yellow',
-            })
-      }\n`
+if (!truthyStr(CI) && !truthyStr(ADBLOCK) && !truthyStr(SILENT)) {
+  const messageTokens = ['Serverless Framework successfully installed!'];
+
+  if (isStandaloneExecutable && !isWindows) {
+    messageTokens.push(
+      'To start your first project, please open another terminal and run “serverless”.'
     );
+  } else {
+    messageTokens.push('To start your first project run “serverless”.');
+  }
+
+  if ((isStandaloneExecutable && !isWindows) || isNpmGlobalPackage()) {
+    messageTokens.push('Turn on automatic updates by running “serverless config --autoupdate”.');
   }
-})();
+
+  if (isStandaloneExecutable && !isWindows) {
+    messageTokens.push('Uninstall at any time by running “serverless uninstall”.');
+  }
+
+  const message = messageTokens.join('\n\n');
+  process.stdout.write(
+    `${
+      isStandaloneExecutable && isWindows
+        ? message
+        : boxen(chalk.yellow(message), {
+            padding: 1,
+            margin: 1,
+            borderColor: 'yellow',
+          })
+    }\n`
+  );
+}