add build:types and build:types:watch commands to main package.json

Author: lobsterkatie

package.json

@@ -8,8 +8,10 @@
     "build:dev:filter": "lerna run --stream --concurrency 1 --sort build:dev --include-filtered-dependencies --include-filtered-dependents --scope",
     "build:es5": "yarn lerna run --stream --concurrency 1 --sort build:cjs # *** backwards compatibility - remove in v7 ***",
     "build:esm": "lerna run --stream --concurrency 1 --sort build:esm",
+    "build:types": "lerna run --stream --concurrency 1 --sort build:types",
     "build:watch": "lerna run --parallel build:watch",
     "build:dev:watch": "lerna run --parallel build:dev:watch",
+    "build:types:watch": "node scripts/buildTypesWatch.js",
     "circularDepCheck": "lerna run --parallel circularDepCheck",
     "clean": "lerna run --parallel clean && lerna clean --yes",
     "codecov": "codecov",

scripts/buildTypesWatch.js

@@ -0,0 +1,48 @@
+/**
+ * If `yarn build:types:watch` is run without types files previously having been created, the build will get stuck in an
+ * errored state. This happens because lerna runs all of the packages' `yarn build:types:watch` statements in parallel,
+ * and so packages like `@sentry/browser` will at first be missing types they import from packages like `@sentry/utils`
+ * and `@sentry/types`, causing errors to be thrown. Normally this is fine, because as the dependencies' types get
+ * built, file changes will be detected and the dependent packages' types will try again to build themselves. There
+ * might be several rounds of this, but in theory, eventually all packages should end up with an error-free build. For
+ * whatever reason, though, at a certain point the process hangs, either because changes stop being detected or because
+ * recompiles stop being triggered by detected changes.
+ *
+ * Either way, the process gets stuck. The solution is to run a sequential build first, because as long as there are
+ * existing files the first time the watch command runs, no subsequent changes ever cause a hang, no matter how many
+ * rounds of recompilation are needed. (It's not entirely clear why this is the case.) We only want to take the time to
+ * do that if we have to, though, so we first check all of the relevant packages to see if there are pre-existing types
+ * files.
+ */
+
+const childProcess = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+if (!process.cwd().endsWith('sentry-javascript')) {
+  console.error('Error: This script can only be run from the root level of the repo.');
+  exit(-1);
+}
+
+const packages = fs.readdirSync('./packages');
+
+for (const pkg of packages) {
+  const packagePath = path.resolve('./packages', pkg);
+
+  if (!fs.lstatSync(packagePath).isDirectory() || !fs.readdirSync(packagePath).includes('package.json')) {
+    continue;
+  }
+
+  const packageJSON = JSON.parse(fs.readFileSync(path.resolve(packagePath, 'package.json')));
+
+  if ('build:types' in packageJSON.scripts && !fs.existsSync(path.resolve(packagePath, 'build/types'))) {
+    console.warn(
+      `\nWarning: Found no pre-existing types in package \`${pkg}\`. Performing a sequential types build before starting the watch process.\n`,
+    );
+    childProcess.execSync('yarn build:types', { stdio: 'inherit' });
+    break;
+  }
+}
+
+console.log('\nStarting `yarn build:types:watch`.\n');
+childProcess.execSync('yarn lerna run --parallel build:types:watch', { stdio: 'inherit' });