Add embroider telemetry option

Author: gitKrystan

bin/cli.js

@@ -7,15 +7,27 @@ const {
   analyzeEmberObject,
   getTelemetry,
 } = require('ember-codemods-telemetry-helpers');
-const appLocation = process.argv[2];
-const args = process.argv.slice(3);
 
 (async () => {
-  debug('Gathering telemetry data from %s ...', appLocation);
-  await gatherTelemetryForUrl(appLocation, analyzeEmberObject);
+  let args = process.argv;
 
-  let telemetry = getTelemetry();
-  debug('Gathered telemetry on %d modules', Object.keys(telemetry).length);
+  // FIXME
+  if (args.includes('--telemetry=runtime')) {
+    const appLocation = args[2];
+
+    debug('Gathering telemetry data from %s ...', appLocation);
+    await gatherTelemetryForUrl(appLocation, analyzeEmberObject);
+
+    let telemetry = getTelemetry();
+    debug('Gathered telemetry on %d modules', Object.keys(telemetry).length);
+
+    args = args.slice(3);
+  } else {
+    args = args.slice(2);
+  }
 
   require('codemod-cli').runTransform(__dirname, 'no-implicit-this', args, 'hbs');
-})();
+})().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package.json

@@ -26,6 +26,8 @@
     "test": "jest",
     "pretest:integration": "yarn build",
     "test:integration": "ts-node ./test/run-test.ts",
+    "test:integration:embroider": "yarn test:integration --embroider",
+    "test:integration:runtime": "yarn test:integration --runtime",
     "update-docs": "codemod-cli update-docs",
     "coveralls": "cat ./coverage/lcov.info | node node_modules/.bin/coveralls",
     "lint:js": "eslint .",
@@ -44,6 +46,7 @@
   "dependencies": {
     "@babel/core": "^7.21.8",
     "@babel/preset-env": "^7.21.5",
+    "@embroider/core": "^3.0.0",
     "codemod-cli": "^3.2.0",
     "debug": "^4.1.1",
     "ember-codemods-telemetry-helpers": "^2.1.0",

test/helpers/sequence.ts

@@ -1,22 +1,35 @@
 import { TestRunner } from './test-runner';
 import { log } from './utils';
 
-export async function runTestIntegrationSequence(version: string) {
+export async function runTestIntegrationSequence(
+  version: string,
+  mode: 'runtime' | 'embroider'
+): Promise<void> {
+  switch (mode) {
+    case 'runtime':
+      return runTestIntegrationSequenceWithRuntimeTelemetry(version);
+
+    case 'embroider':
+      return runTestIntegrationSequenceWithEmbroider(version);
+  }
+}
+
+async function runTestIntegrationSequenceWithRuntimeTelemetry(version: string): Promise<void> {
   const runner = new TestRunner(version);
 
-  log(`Running Integration Test for Ember ${version}`);
+  log(`Running Integration Test for Ember ${version} Using Runtime Telemetry`);
   log(`Installing Dependencies`);
   await runner.installDeps();
 
   try {
-    log(`Starting the Ember Dev Server`);
+    log(`Starting Ember Dev Server`);
     await runner.startEmber();
     log(`Running Codemod`);
-    await runner.runCodemod();
-    log(`Stopping the Ember Dev Server`);
+    await runner.runCodemodRuntime();
+    log(`Stopping Ember Dev Server`);
     await runner.stopEmber();
   } catch (e) {
-    log(`Stopping the Ember Dev Server`);
+    log(`Stopping Ember Dev Server`);
     await runner.stopEmber();
     throw e;
   }
@@ -25,3 +38,18 @@ export async function runTestIntegrationSequence(version: string) {
   await runner.compare();
   log(`Success`);
 }
+
+async function runTestIntegrationSequenceWithEmbroider(version: string): Promise<void> {
+  const runner = new TestRunner(version);
+
+  log(`Running Integration Test for Ember ${version} Using Embroider`);
+  log(`Installing Dependencies`);
+  await runner.installDeps();
+  log(`Running Build`);
+  await runner.runEmbroiderStage2Build();
+  log(`Running Codemod`);
+  await runner.runCodemodEmbroider();
+  log(`Comparing Results`);
+  await runner.compare();
+  log(`Success`);
+}

test/helpers/test-runner.ts

@@ -26,8 +26,37 @@ export class TestRunner {
     await execa('yarn', ['install'], { cwd: this.inputDir });
   }
 
-  async runCodemod() {
-    await execa('../../../../bin/cli.js', ['http://localhost:4200', 'app'], this.execOpts);
+  async runCodemodRuntime() {
+    await execa(
+      '../../../../bin/cli.js',
+      ['http://localhost:4200', 'app', '--telemetry=runtime'],
+      this.execOpts
+    );
+  }
+
+  async runCodemodEmbroider() {
+    await execa('../../../../bin/cli.js', ['app', '--telemetry=embroider'], this.execOpts);
+  }
+
+  async runEmbroiderStage2Build(): Promise<void> {
+    const process = await execa('yarn', ['ember', 'build'], {
+      cwd: this.inputDir,
+      env: {
+        STAGE2_ONLY: 'true',
+      },
+    });
+
+    if (process.exitCode !== 0) {
+      const output = [
+        `Build failed: STAGE2_ONLY=true yarn ember build exited with ${process.exitCode}\n`,
+        `=== STDOUT ===\n`,
+        process.stdout || '(EMPTY)',
+        `=== STDERR ===\n`,
+        process.stderr || '(EMPTY)',
+      ];
+
+      throw new Error(output.join('\n'));
+    }
   }
 
   async startEmber(): Promise<void> {

test/run-test.ts

@@ -20,11 +20,13 @@ const allVersions = ['3.10', '3.13'];
     process.exit(1);
   }
 
+  const mode = process.argv.includes('--runtime') ? 'runtime' : 'embroider';
+
   let didSucceed = false;
 
   try {
     process.env['DEBUG'] = 'true'; // hacks for now
-    await runTestIntegrationSequence(emberVersion);
+    await runTestIntegrationSequence(emberVersion, mode);
     didSucceed = true;
   } catch (e) {
     error(e);

transforms/no-implicit-this/helpers/options.ts

@@ -2,7 +2,7 @@ import { getOptions as getCLIOptions } from 'codemod-cli';
 import fs from 'node:fs';
 import path from 'node:path';
 import { ZodError, ZodType, z } from 'zod';
-import Resolver, { RuntimeResolver } from './resolver';
+import Resolver, { EmbroiderResolver, RuntimeResolver } from './resolver';
 
 export interface Options {
   customHelpers: string[];
@@ -34,7 +34,7 @@ export function getOptions(): Options {
   return {
     customHelpers: getCustomHelpersFromConfig(cliOptions.config),
     resolver:
-      cliOptions.telemetry === 'runtime' ? RuntimeResolver.build() : (null as unknown as Resolver),
+      cliOptions.telemetry === 'runtime' ? RuntimeResolver.build() : EmbroiderResolver.build(),
   };
 }
 

transforms/no-implicit-this/helpers/resolver.ts

@@ -1,4 +1,8 @@
+// FIXME: Make these optional dependencies
 import { Telemetry, getTelemetry } from './telemetry';
+import { Resolver as _EmbroiderResolver } from '@embroider/core';
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
 
 export default abstract class Resolver {
   has(type: 'component' | 'helper' | 'ambiguous', name: string): boolean {
@@ -57,3 +61,46 @@ function populateInvokeables(telemetry: Telemetry): [components: string[], helpe
 
   return [components, helpers];
 }
+
+const EMBROIDER_COMPONENTS = '#embroider_compat/components';
+const EMBROIDER_HELPERS = '#embroider_compat/helpers';
+const EMBROIDER_AMBIGUOUS = '#embroider_compat/ambiguous';
+
+export class EmbroiderResolver extends Resolver {
+  static build(): EmbroiderResolver {
+    // FIXME: Run build via execa ???
+    const stage2Output = readFileSync('dist/.stage2-output', 'utf8');
+    const resolver = new _EmbroiderResolver(
+      JSON.parse(readFileSync(resolve(stage2Output, '.embroider/resolver.json'), 'utf8'))
+    );
+    return new EmbroiderResolver(resolver, resolve(stage2Output, 'app.js'));
+  }
+
+  constructor(private _resolver: _EmbroiderResolver, private entryPoint: string) {
+    super();
+  }
+
+  override hasComponent(name: string): boolean {
+    return this.resolve(`${EMBROIDER_COMPONENTS}/${name}`);
+  }
+
+  override hasHelper(name: string): boolean {
+    return this.resolve(`${EMBROIDER_HELPERS}/${name}`);
+  }
+
+  override hasAmbiguous(name: string): boolean {
+    return this.resolve(`${EMBROIDER_AMBIGUOUS}/${name}`);
+  }
+
+  private resolve(specifier: string): boolean {
+    console.log(`Resolving ${specifier}`);
+    const resolution = this._resolver.nodeResolve(specifier, this.entryPoint);
+    switch (resolution.type) {
+      case 'real':
+      case 'virtual':
+        return true;
+      case 'not_found':
+        return false;
+    }
+  }
+}