fix(schematics): restore ng deploy under the CommonJS schematics bundle (#3729)

* fix(schematics): restore ng deploy under the CommonJS schematics bundle

`ng deploy` threw at module load in 21.0.0-rc.0, before any user code ran:

    TypeError [ERR_INVALID_ARG_TYPE]: The "path" argument must be of type
    string or an instance of URL. Received undefined
        at fileURLToPath (node:internal/url)

The schematics are bundled by esbuild with `format: "cjs"`, and esbuild
rewrites `import.meta` to an empty object in CommonJS output. The shipped
bundle therefore read `undefined.url`, so both `deploy/actions.js` and
`deploy/builder.js` failed to load. Every other shipped entry point (ng add,
both ng update migrations, the setup schematic) was unaffected.

The shim was introduced when `versions.json` moved from a compile-time import
to a runtime read. That move fixed a real bug of its own: because esbuild
bundles before the build copies and rewrites `versions.json`, the compile-time
import inlined the unreplaced `0.0.0` placeholders, and 20.0.1 generates a
Cloud Functions manifest pinning `0.0.0` that cannot install. So the runtime
read has to stay.

`typeof` on an undeclared identifier is the one form that does not throw under
ESM, so a single expression works under both loaders, and the CommonJS branch
comes first because `import.meta` is the substituted empty object there. The
alternatives were built and run, not assumed:

  - plain `__dirname` breaks `npm run test:node-esm`, which genuinely loads
    the compiled specs as ESM
  - `require('../versions.json')` reintroduces the `0.0.0` bug above
  - an esbuild define/banner works today but fails with "require is not
    defined in ES module scope" the moment `format: "esm"` is enabled, which
    tools/build.ts already has staged in a comment

Verified against the built package: all seven shipped entry points now load
via both `require()` and `await import()`, the builder exposes the Architect
builder symbols, and the runtime `versions.json` read resolves correctly.
`ng lint` also drops its only warning, which sat on the replaced line.

This is v21-only. v20 has no `import.meta` shim and must not take this change.

* build: load every compiled schematic before publishing

The load failure fixed in the previous commit reached a published release
because nothing in the build or the test suite ever loads what actually ships.
The jasmine suite runs against the TypeScript output, which is a different
module format from the CommonJS bundle in the package, so a bundle can be
completely unloadable while every test passes.

Requiring each compiled entry point at the end of the schematics build closes
that gap. Reverting the previous commit now fails the build with the real
error:

    Compiled schematics failed to load:
      deploy/actions.js: TypeError [ERR_INVALID_ARG_TYPE] ...
      deploy/builder.js: TypeError [ERR_INVALID_ARG_TYPE] ...

It catches the whole class, not just this instance: an unresolvable import, a
bad top-level require, or anything else that throws at module load.

* build: derive schematic entry points from a single list

compileSchematics and loadCompiledSchematics each carried their own
hardcoded copy of the seven entry points. An entry point added to the
esbuild list alone would compile but never be load-checked, which is
the exact failure the load check exists to catch.

Both now map one schematicEntryPoints array, to .ts for esbuild and to
.js for the require check. Emitted paths and failure strings are
unchanged: a build with a deliberate top-level throw added to
deploy/actions.ts still fails, and still names deploy/actions.js and
deploy/builder.js in the same format.

Author: armando-navarro

src/schematics/deploy/actions.ts

@@ -13,8 +13,9 @@ import * as winston from 'winston';
 import { BuildTarget, CloudRunOptions, DeployBuilderSchema, FSHost, FirebaseTools } from '../interfaces';
 import { DEFAULT_FUNCTION_NAME, defaultFunction, defaultPackage, dockerfile, functionGen2 } from './functions-templates.js';
 
-// @ts-ignore
-const __dirname = dirname(fileURLToPath(import.meta.url));
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore `import.meta` is rejected by the --module es2015 pass of `npm run build:jasmine`.
+const moduleDirectory = typeof __dirname === 'string' ? __dirname : dirname(fileURLToPath(import.meta.url));
 
 const { copySync, removeSync, readJsonSync } = fsExtra;
 
@@ -128,7 +129,7 @@ const findPackageVersion = (packageManager: string, name: string) => {
 const getPackageJson = (context: BuilderContext, workspaceRoot: string, options: DeployBuilderOptions, main?: string) => {
   const dependencies: Record<string, string> = {};
   const devDependencies: Record<string, string> = {};
-  const { firebaseFunctionsDependencies } = readJsonSync(join(__dirname, '..', 'versions.json'));
+  const { firebaseFunctionsDependencies } = readJsonSync(join(moduleDirectory, '..', 'versions.json'));
   if (options.ssr !== 'cloud-run') {
     Object.keys(firebaseFunctionsDependencies).forEach(name => {
       const { version, dev } = firebaseFunctionsDependencies[name];

tools/build.ts

@@ -313,17 +313,21 @@ function spawnPromise(command: string, args: string[]) {
   .on('error', reject));
 }
 
+// Path segments of each schematic entry point, relative to `schematics/` and without the file
+// extension: esbuild compiles the `.ts` and loadCompiledSchematics requires the emitted `.js`.
+const schematicEntryPoints = [
+  ['update', 'index'],
+  ['deploy', 'actions'],
+  ['deploy', 'builder'],
+  ['add', 'index'],
+  ['setup', 'index'],
+  ['update', 'v7', 'index'],
+  ['update', 'v21', 'index'],
+];
+
 async function compileSchematics() {
   await esbuild.build({
-    entryPoints: [
-      src('schematics', "update", "index.ts"),
-      src('schematics', "deploy", "actions.ts"),
-      src('schematics', "deploy", "builder.ts"),
-      src('schematics', "add", "index.ts"),
-      src('schematics', "setup", "index.ts"),
-      src('schematics', "update", "v7", "index.ts"),
-      src('schematics', "update", "v21", "index.ts"),
-    ],
+    entryPoints: schematicEntryPoints.map(segments => `${src('schematics', ...segments)}.ts`),
     format: "cjs",
     // turns out schematics don't support ESM, need to use webpack or shim these
     // format: "esm",
@@ -357,6 +361,25 @@ async function compileSchematics() {
     copy(src('schematics', 'setup', 'schema.json'), dest('schematics', 'setup', 'schema.json')),
   ]);
   await replaceSchematicVersions();
+  await loadCompiledSchematics();
+}
+
+/**
+ * Loads every compiled schematic entry point, so a bundle that cannot even be required fails the
+ * build instead of shipping.
+ */
+async function loadCompiledSchematics() {
+  const failures: string[] = [];
+  for (const segments of schematicEntryPoints) {
+    try {
+      require(`${dest('schematics', ...segments)}.js`);
+    } catch (error) {
+      failures.push(`  ${join(...segments)}.js: ${error}`);
+    }
+  }
+  if (failures.length) {
+    throw new Error(`Compiled schematics failed to load:\n${failures.join('\n')}`);
+  }
 }
 
 async function buildLibrary() {