Merge pull request #325 from ef4/discovery-protocol

updating discovery protocol

Author: ef4

.vscode/launch.json

@@ -41,10 +41,10 @@
             "name": "Build sample-merged",
             "program": "${workspaceFolder}/node_modules/.bin/ember",
             "cwd": "${workspaceFolder}/packages/sample-merged",
-            "preLaunchTask": "tsc: build - tsconfig.json",
             "args": [
                 "build"
-            ]
+            ],
+            "outputCapture": "std"
         },
         {
             "type": "node",

packages/ember-auto-import/package.json

@@ -52,6 +52,7 @@
     "pkg-up": "^2.0.0",
     "resolve": "^1.7.1",
     "rimraf": "^2.6.2",
+    "semver": "^7.3.4",
     "symlink-or-copy": "^1.2.0",
     "typescript-memoize": "^1.0.0-alpha.3",
     "walk-sync": "^0.3.3",
@@ -73,6 +74,7 @@
     "@types/node": "^10.7.1",
     "@types/pkg-up": "^2.0.0",
     "@types/resolve": "^0.0.8",
+    "@types/semver": "^7.3.4",
     "@types/webpack": "^4.4.20",
     "babel-eslint": "^8.2.5",
     "broccoli": "^3.2.0",

packages/ember-auto-import/ts/auto-import.ts

@@ -6,54 +6,59 @@ import { buildDebugCallback } from 'broccoli-debug';
 import BundleConfig from './bundle-config';
 import Append from './broccoli-append';
 import { Node } from 'broccoli-node-api';
+import { LeaderChooser } from './leader';
+import { AddonInstance, AppInstance, findTopmostAddon } from './ember-cli-models';
 
 const debugTree = buildDebugCallback('ember-auto-import');
-const protocol = '__ember_auto_import_protocol_v1__';
 
-export default class AutoImport {
-  private primaryPackage: any;
+// This interface must be stable across all versions of ember-auto-import that
+// speak the same leader-election protocol. So don't change this unless you know
+// what you're doing.
+export interface AutoImportSharedAPI {
+  isPrimary(addonInstance: AddonInstance): boolean;
+  analyze(tree: Node, addon: AddonInstance): Node;
+  included(addonInstance: AddonInstance): void;
+  updateFastBootManifest(manifest: { vendorFiles: string[] }): void;
+}
+
+export default class AutoImport implements AutoImportSharedAPI {
+  private primaryPackage: AddonInstance;
   private packages: Set<Package> = new Set();
   private env: 'development' | 'test' | 'production';
   private consoleWrite: (msg: string) => void;
   private analyzers: Map<Analyzer, Package> = new Map();
   private bundles: BundleConfig;
   private targets: unknown;
 
-  static lookup(appOrAddon: any): AutoImport {
-    let g = global as any;
-    if (!g[protocol]) {
-      g[protocol] = new this(appOrAddon);
-    }
-    return g[protocol];
+  static register(addon: AddonInstance) {
+    LeaderChooser.for(addon).register(addon, () => new AutoImport(addon));
   }
 
-  constructor(appOrAddon: any) {
-    function findHostContext(appOrAddon: any): any {
-      return appOrAddon.parent.parent
-        ? findHostContext(appOrAddon.parent)
-        : appOrAddon;
-    }
+  static lookup(addon: AddonInstance): AutoImportSharedAPI {
+    return LeaderChooser.for(addon).leader;
+  }
 
-    this.primaryPackage = appOrAddon;
-    let hostContext = findHostContext(appOrAddon);
-    this.packages.add(Package.lookup(hostContext));
-    let host = hostContext.app;
+  constructor(addonInstance: AddonInstance) {
+    this.primaryPackage = addonInstance;
+    let topmostAddon = findTopmostAddon(addonInstance);
+    this.packages.add(Package.lookupParentOf(topmostAddon));
+    let host = topmostAddon.app;
     this.env = host.env;
     this.targets = host.project.targets;
     this.bundles = new BundleConfig(host);
     if (!this.env) {
       throw new Error('Bug in ember-auto-import: did not discover environment');
     }
 
-    this.consoleWrite = (...args) => appOrAddon.project.ui.write(...args);
+    this.consoleWrite = (...args) => addonInstance.project.ui.write(...args);
   }
 
-  isPrimary(appOrAddon: any) {
-    return this.primaryPackage === appOrAddon;
+  isPrimary(addon: AddonInstance) {
+    return this.primaryPackage === addon;
   }
 
-  analyze(tree: Node, appOrAddon: any) {
-    let pack = Package.lookup(appOrAddon);
+  analyze(tree: Node, addon: AddonInstance) {
+    let pack = Package.lookupParentOf(addon);
     this.packages.add(pack);
     let analyzer = new Analyzer(
       debugTree(tree, `preprocessor:input-${this.analyzers.size}`),
@@ -63,7 +68,7 @@ export default class AutoImport {
     return analyzer;
   }
 
-  makeBundler(allAppTree: Node) {
+  private makeBundler(allAppTree: Node) {
     // The Splitter takes the set of imports from the Analyzer and
     // decides which ones to include in which bundles
     let splitter = new Splitter({
@@ -105,8 +110,8 @@ export default class AutoImport {
     });
   }
 
-  included(addonInstance: any) {
-    let host = addonInstance._findHost();
+  included(addonInstance: AddonInstance) {
+    let host = findTopmostAddon(addonInstance).app;
     this.configureFingerprints(host);
 
     // ember-cli as of 3.4-beta has introduced architectural changes that make
@@ -132,7 +137,7 @@ export default class AutoImport {
   // We need to disable fingerprinting of chunks, because (1) they already
   // have their own webpack-generated hashes and (2) the runtime loader code
   // can't easily be told about broccoli-asset-rev's hashes.
-  private configureFingerprints(host: any) {
+  private configureFingerprints(host: AppInstance) {
     let pattern = 'assets/chunk.*.js';
     if (!host.options.fingerprint) {
       host.options.fingerprint = {};

packages/ember-auto-import/ts/bundle-config.ts

@@ -4,10 +4,11 @@
 */
 
 import { dirname } from 'path';
+import { AppInstance } from './ember-cli-models';
 const testsPattern = new RegExp(`^/?[^/]+/(tests|test-support)/`);
 
 export default class BundleConfig {
-  constructor(private emberApp: any) {}
+  constructor(private emberApp: AppInstance) {}
 
   // This list of valid bundles, in priority order. The first one in the list that
   // needs a given import will end up with that import.

packages/ember-auto-import/ts/ember-cli-models.ts

@@ -0,0 +1,53 @@
+import { Node } from 'broccoli-node-api';
+export interface Project {
+  targets: unknown;
+  ui: {
+    write(...args: any[]): void;
+  };
+  pkg: { name: string; version: string };
+  root: string;
+  addons: AddonInstance[];
+}
+
+export interface AppInstance {
+  env: "development" | "test" | "production";
+  project: Project;
+  options: any;
+  addonPostprocessTree: (which: string, tree: Node) => Node;
+}
+
+interface BaseAddonInstance {
+  project: Project;
+  pkg: { name: string; version: string };
+  root: string;
+  options: any;
+  addons: AddonInstance[];
+  name: string;
+}
+
+export interface DeepAddonInstance extends BaseAddonInstance {
+  // this is how it looks when an addon is beneath another addon
+  parent: AddonInstance;
+}
+
+export interface ShallowAddonInstance extends BaseAddonInstance {
+  // this is how it looks when an addon is directly beneath the app
+  parent: Project;
+  app: AppInstance;
+}
+
+export type AddonInstance = DeepAddonInstance | ShallowAddonInstance;
+
+export function isDeepAddonInstance(
+  addon: AddonInstance
+): addon is DeepAddonInstance {
+  return addon.parent !== addon.project;
+}
+
+export function findTopmostAddon(addon: AddonInstance): ShallowAddonInstance {
+  if (isDeepAddonInstance(addon)) {
+    return findTopmostAddon(addon.parent);
+  } else {
+    return addon;
+  }
+}

packages/ember-auto-import/ts/index.ts

@@ -1,8 +1,15 @@
 import AutoImport from './auto-import';
 import { Node } from 'broccoli-node-api';
+// @ts-ignore
+import pkg from '../package';
 
 module.exports = {
-  name: 'ember-auto-import',
+  name: pkg.name,
+
+  init(...args: any[]) {
+    this._super.init.apply(this, args);
+    AutoImport.register(this);
+  },
 
   setupPreprocessorRegistry(type: string, registry: any) {
     // we register on our parent registry (so we will process code

packages/ember-auto-import/ts/leader.ts

@@ -0,0 +1,97 @@
+import { gt } from "semver";
+import type AutoImport from "./auto-import";
+import { Project, AddonInstance } from "./ember-cli-models";
+import { Node } from "broccoli-node-api";
+
+const protocolV1 = "__ember_auto_import_protocol_v1__";
+const protocolV2 = "__ember_auto_import_protocol_v2__";
+const g = (global as any) as {
+  [protocolV1]: any;
+  [protocolV2]: WeakMap<Project, LeaderChooser> | undefined;
+};
+
+export class LeaderChooser {
+  static for(addon: AddonInstance): LeaderChooser {
+    let g = global as any;
+    let map: WeakMap<Project, LeaderChooser> = g[protocolV2];
+    if (!map) {
+      map = g[protocolV2] = new WeakMap();
+    }
+    // this needs to be based on project and not app instance because at the
+    // early stage where we're doing `register`, the app instance isn't
+    // available on the addons yet
+    let project = addon.project;
+    let chooser = map.get(project);
+    if (!chooser) {
+      chooser = new this();
+      map.set(project, chooser);
+    }
+    return chooser;
+  }
+
+  private tentative: { create: () => AutoImport; version: string } | undefined;
+  private locked: AutoImport | undefined;
+
+  register(addon: AddonInstance, create: () => AutoImport) {
+    if (this.locked) {
+      throw new Error(`bug: LeaderChooser already locked`);
+    }
+    let version = addon.pkg.version;
+    if (!this.tentative || gt(version, this.tentative.version)) {
+      this.tentative = { create, version };
+    }
+  }
+
+  get leader(): AutoImport {
+    if (!this.locked) {
+      if (!this.tentative) {
+        throw new Error(`bug: no candidates added`);
+      }
+      this.locked = this.tentative.create();
+      let v1 = g[protocolV1];
+      if (v1?.isV1Placeholder) {
+        v1.leader = this.locked;
+      }
+    }
+    return this.locked;
+  }
+}
+
+class V1Placeholder {
+  isV1Placeholder = true;
+  leader: AutoImport | undefined;
+
+  // we never want v1-speaking copies of ember-auto-import to consider
+  // themselves primary, so if they're asking here, the answer is no.
+  isPrimary() {
+    return false;
+  }
+
+  // this is the only method that is called after isPrimary returns false. So we
+  // need to implement this one and don't need to implement the other public API
+  // of AutoImport.
+  analyze(tree: Node, addon: AddonInstance) {
+    if (!this.leader) {
+      throw new Error(
+        `bug: expected some protcol v2 copy of ember-auto-import to take charge before any v1 copy started trying to analyze trees`
+      );
+    }
+    return this.leader.analyze(tree, addon);
+  }
+}
+
+// at module load time, preempt all earlier versions of ember-auto-import that
+// don't use our v2 leadership protocol. This ensures that the v2 protocol will
+// pick which version is in charge (and v1-speaking copies won't be eligible).
+(function v1ProtocolCompat() {
+  let v1 = g[protocolV1];
+  if (v1) {
+    if (!v1.isV1Placeholder) {
+      throw new Error(
+        `bug: an old version of ember-auto-import has already taken over. This is unexpected.`
+      );
+    }
+  } else {
+    g[protocolV1] = new V1Placeholder;
+  }
+})();