Consolidate rc logic

Author: tjlav5

firebase-vscode/package.json

@@ -114,28 +114,13 @@
     },
     "views": {
       "firebase-data-connect": [
-        {
-          "type": "webview",
-          "id": "fdc_sidebar",
-          "name": "Studio",
-          "initialSize": 2
-        },
-        {
-          "id": "firebase.dataConnect.explorerView",
-          "name": "Schema explorer",
-          "when": "firebase-vscode.fdc.enabled",
-          "visibility": "collapsed",
-          "initialSize": 1
-        },
         {
           "id": "firebase.session",
-          "name": "Account and Project",
-          "initialSize": 1
+          "name": "Account and Project"
         },
         {
           "id": "firebase.emulators",
-          "name": "Emulator Suite",
-          "initialSize": 1
+          "name": "Emulator Suite"
         }
       ],
       "firebase-data-connect-execution-view": [

firebase-vscode/src/core/index.ts

@@ -15,7 +15,7 @@ import { registerWebhooks } from "./webhook";
 import { createE2eMockable } from "../utils/test_hooks";
 import { runTerminalTask } from "../data-connect/terminal";
 import { AnalyticsLogger } from "../analytics";
-import { EmulatorsProvider } from "./emulators-provider";
+import { EmulatorsProvider } from "../emulators/emulators-provider";
 
 export async function registerCore(
   broker: ExtensionBrokerImpl,

firebase-vscode/src/core/emulators-provider.ts firebase-vscode/src/emulators/emulators-provider.ts

@@ -14,7 +14,7 @@ export class EmulatorsProvider
   ): Promise<EmulatorItem[]> | EmulatorItem[] {
     return [
       new EmulatorItem("Emulator 1", vscode.TreeItemCollapsibleState.None),
-      new EmulatorItem("Emulator 2", vscode.TreeItemCollapsibleState.None),
+      new EmulatorItem("Emulator 123", vscode.TreeItemCollapsibleState.None),
     ];
   }
 

firebase-vscode/src/emulators/index.ts

@@ -0,0 +1,25 @@
+import * as vscode from "vscode";
+import { EmulatorsStatus, RunningEmulatorInfo } from "../messaging/types";
+import { Signal, ReadonlySignal } from "@preact/signals-core";
+import { RC } from "../rc";
+import { Result } from "../result";
+import { EmulatorsProvider } from "./emulators-provider";
+
+export type Emulators = {
+  status: EmulatorsStatus;
+  infos?: RunningEmulatorInfo;
+};
+
+export function registerEmulators(
+  emulators: Signal<Emulators>,
+  rc: ReadonlySignal<Result<RC | undefined>>,
+): vscode.Disposable {
+  const tree = new EmulatorsProvider();
+
+  return vscode.Disposable.from(
+    vscode.window.createStatusBarItem("emulators"),
+    vscode.window.createTreeView("firebase.emulators", {
+      treeDataProvider: tree,
+    }),
+  );
+}

firebase-vscode/src/extension.ts

@@ -1,6 +1,7 @@
 import * as vscode from "vscode";
 import { spawnSync } from "child_process";
 import * as semver from "semver";
+import * as path from "path";
 
 import { ExtensionBroker } from "./extension-broker";
 import { createBroker } from "../common/messaging/broker";
@@ -23,62 +24,68 @@ import { env } from "./core/env";
 
 import { suggestGraphqlSyntaxExtension } from "./data-connect/graphql-syntax-highlighter";
 import { registerSession } from "./session";
+import { computed, ReadonlySignal, Signal, signal } from "@preact/signals-core";
+import { checkLogin, User } from "./core/user";
+import { requireAuthWrapper } from "./cli";
+import { _readRC, getConfigPath } from "./core/config";
+import { RC } from "../src/rc";
+import { Result, ResultValue } from "./result";
+import { Emulators, registerEmulators } from "./emulators";
 
 // This method is called when your extension is activated
-export async function activate(context: vscode.ExtensionContext) {
-  const analyticsLogger = new AnalyticsLogger(context);
-
-  // Suggest installing the GraphQL syntax highlighter extension
-  await suggestGraphqlSyntaxExtension();
-
-  await setupFirebasePath(analyticsLogger);
+export async function activate(ctx: vscode.ExtensionContext) {
+  await setupFirebasePath();
   const settings = getSettings();
+
   logSetup();
   pluginLogger.debug("Activating Firebase extension.");
 
-  const broker = createBroker<
-    ExtensionToWebviewParamsMap,
-    WebviewToExtensionParamsMap,
-    vscode.Webview
-  >(new ExtensionBroker());
+  await checkCLIInstallation();
 
-  const authService = new AuthService(broker);
+  const user = await createUser();
+  const rc = await createRC(ctx);
+  const project = await createProject(rc);
+  const emulators = signal<Emulators>({ status: "stopped" });
 
-  // show IDX data collection notice
-  if (settings.shouldShowIdxMetricNotice && env.value.isMonospace) {
-    // don't await/block on this
-    vscode.window.showInformationMessage(IDX_METRIC_NOTICE, "Ok").then(() => {
-      updateIdxSetting(false); // don't show message again
-    });
-  }
+  ctx.subscriptions.push(
+    registerEmulators(emulators, rc),
+    registerSession(user, project),
+  );
+}
 
-  await checkCLIInstallation();
+async function createUser(): Promise<Signal<User | undefined>> {
+  const user = await requireAuthWrapper();
+  return signal(user ?? undefined);
+}
 
-  const [emulatorsController, coreDisposable] = await registerCore(
-    broker,
-    context,
-    analyticsLogger,
+async function createRC(
+  ctx: vscode.ExtensionContext,
+): Promise<Signal<Result<RC | undefined>>> {
+  // const folderPath = path.dirname(getConfigPath() ?? "");
+  const rcUri = vscode.Uri.file(
+    path.join(getConfigPath() ?? "", ".firebaserc"),
   );
+  console.log("WOWOWOWOWOW");
+  console.log(rcUri.fsPath);
+  const watcher = vscode.workspace.createFileSystemWatcher(rcUri.fsPath);
+  ctx.subscriptions.push(watcher);
 
-  context.subscriptions.push(
-    { dispose: analyticsLogger.endSession },
-    { dispose: analyticsLogger.onDispose },
-    coreDisposable,
-    registerWebview({
-      name: "fdc_sidebar",
-      broker,
-      context,
-    }),
-    authService,
-    registerSession(),
-    registerFdc(
-      context,
-      broker,
-      authService,
-      emulatorsController,
-      analyticsLogger,
-    ),
-  );
+  const rc = signal<Result<RC | undefined>>(_readRC(rcUri));
+  watcher.onDidChange(() => (rc.value = _readRC(rcUri)));
+  watcher.onDidCreate(() => (rc.value = _readRC(rcUri)));
+  watcher.onDidDelete(() => (rc.value = new ResultValue(undefined)));
+
+  return rc;
+}
+
+async function createProject(
+  rc: Signal<Result<RC | undefined>>,
+): Promise<ReadonlySignal<string | undefined>> {
+  return computed(() => {
+    if (rc.value.tryReadValue) {
+      return rc.value.tryReadValue.projects.default;
+    }
+  });
 }
 
 async function checkCLIInstallation(): Promise<void> {

firebase-vscode/src/session/index.ts

@@ -1,21 +1,25 @@
-import { effect } from "@preact/signals-core";
+import { effect, ReadonlySignal } from "@preact/signals-core";
 import * as vscode from "vscode";
 import { SessionProvider } from "./session-provider";
-import { currentUser } from "../core/user";
+import { checkLogin, User } from "../core/user";
 import { currentProjectId } from "../core/project";
 
-export function registerSession(): vscode.Disposable {
+export function registerSession(
+  user: ReadonlySignal<User | undefined>,
+  project: ReadonlySignal<string | undefined>,
+): vscode.Disposable {
   const sessionProvider = new SessionProvider();
 
   return vscode.Disposable.from(
     {
       dispose: effect(() => {
-        sessionProvider.updateEmail(currentUser.value?.email);
+        sessionProvider.updateEmail(user.value?.email);
       }),
     },
     {
       dispose: effect(() => {
-        sessionProvider.updateProjectId(currentProjectId.value);
+        sessionProvider.updateProjectId(project.value);
+        console.log("project.value", project.value);
       }),
     },
     vscode.window.createTreeView("firebase.session", {

firebase-vscode/src/utils/settings.ts

@@ -46,7 +46,7 @@ export function updateIdxSetting(shouldShow: boolean) {
 }
 
 // Persist env var as path setting when path setting doesn't exist
-export function setupFirebasePath(analyticsLogger: AnalyticsLogger) {
+export function setupFirebasePath() {
   const config = workspace.getConfiguration("firebase");
   if (process.env.FIREBASE_BINARY && !config.get<string>("firebasePath")) {
     config.update(
@@ -55,5 +55,5 @@ export function setupFirebasePath(analyticsLogger: AnalyticsLogger) {
       ConfigurationTarget.Global,
     );
   }
-  analyticsLogger.logger.logUsage(DATA_CONNECT_EVENT_NAME.SETUP_FIREBASE_BINARY);
+  // analyticsLogger.logger.logUsage(DATA_CONNECT_EVENT_NAME.SETUP_FIREBASE_BINARY);
 }