Discovery: Discover runtime commands.

src/frameworks/compose/discover/filesystem.ts

@@ -0,0 +1,55 @@
+import { FileSystem } from "./types";
+import { pathExists, readFile } from "fs-extra";
+import * as path from "path";
+import { FirebaseError } from "../../../error";
+import { logger } from "../../../../src/logger";
+
+/**
+ * Find files or read file contents present in the directory.
+ */
+export class LocalFileSystem implements FileSystem {
+  private readonly existsCache: Record<string, boolean> = {};
+  private readonly contentCache: Record<string, string> = {};
+
+  constructor(private readonly cwd: string) {}
+
+  async exists(file: string): Promise<boolean> {
+    try {
+      if (!(file in this.contentCache)) {
+        this.existsCache[file] = await pathExists(path.resolve(this.cwd, file));
+      }
+
+      return this.existsCache[file];
+    } catch (error) {
+      throw new FirebaseError(`Error occured while searching for file: ${error}`);
+    }
+  }
+
+  async read(file: string): Promise<string> {
+    try {
+      if (!(file in this.contentCache)) {
+        const fileContents = await readFile(path.resolve(this.cwd, file), "utf-8");
+        this.contentCache[file] = fileContents;
+      }
+      return this.contentCache[file];
+    } catch (error) {
+      logger.error("Error occured while reading file contents.");
+      throw error;
+    }
+  }
+}
+
+/**
+ * Convert ENOENT errors into null
+ */
+export async function readOrNull(fs: FileSystem, path: string): Promise<string | null> {
+  try {
+    return fs.read(path);
+  } catch (err: any) {
+    if (err && typeof err === "object" && err?.code === "ENOENT") {
+      logger.debug("ENOENT error occured while reading file.");
+      return null;
+    }
+    throw new Error(`Unknown error occured while reading file: ${err}`);
+  }
+}

src/frameworks/compose/discover/frameworkMatcher.ts

@@ -0,0 +1,103 @@
+import { FirebaseError } from "../../../error";
+import { FrameworkSpec, FileSystem } from "./types";
+import { logger } from "../../../logger";
+
+export function filterFrameworksWithDependencies(
+  allFrameworkSpecs: FrameworkSpec[],
+  dependencies: Record<string, string>
+): FrameworkSpec[] {
+  return allFrameworkSpecs.filter((framework) => {
+    return framework.requiredDependencies.every((dependency) => {
+      return dependency.name in dependencies;
+    });
+  });
+}
+
+export async function filterFrameworksWithFiles(
+  allFrameworkSpecs: FrameworkSpec[],
+  fs: FileSystem
+): Promise<FrameworkSpec[]> {
+  try {
+    const filteredFrameworks = [];
+    for (const framework of allFrameworkSpecs) {
+      if (!framework.requiredFiles) {
+        filteredFrameworks.push(framework);
+        continue;
+      }
+      let isRequired = true;
+      for (let files of framework.requiredFiles) {
+        files = Array.isArray(files) ? files : [files];
+        for (const file of files) {
+          isRequired = isRequired && (await fs.exists(file));
+          if (!isRequired) {
+            break;
+          }
+        }
+      }
+      if (isRequired) {
+        filteredFrameworks.push(framework);
+      }
+    }
+
+    return filteredFrameworks;
+  } catch (error) {
+    logger.error("Error: Unable to filter frameworks based on required files", error);
+    throw error;
+  }
+}
+
+/**
+ * Embeded frameworks help to resolve tiebreakers when multiple frameworks are discovered.
+ * Ex: "next" embeds "react", so if both frameworks are discovered,
+ * we can suggest "next" commands by removing its embeded framework (react).
+ */
+export function removeEmbededFrameworks(allFrameworkSpecs: FrameworkSpec[]): FrameworkSpec[] {
+  const embededFrameworkSet: Set<string> = new Set<string>();
+
+  for (const framework of allFrameworkSpecs) {
+    if (!framework.embedsFrameworks) {
+      continue;
+    }
+    for (const item of framework.embedsFrameworks) {
+      embededFrameworkSet.add(item);
+    }
+  }
+
+  return allFrameworkSpecs.filter((item) => !embededFrameworkSet.has(item.id));
+}
+
+/**
+ * Identifies the best FrameworkSpec for the codebase.
+ */
+export async function frameworkMatcher(
+  runtime: string,
+  fs: FileSystem,
+  frameworks: FrameworkSpec[],
+  dependencies: Record<string, string>
+): Promise<FrameworkSpec | null> {
+  try {
+    const filterRuntimeFramework = frameworks.filter((framework) => framework.runtime === runtime);
+    const frameworksWithDependencies = filterFrameworksWithDependencies(
+      filterRuntimeFramework,
+      dependencies
+    );
+    const frameworkWithFiles = await filterFrameworksWithFiles(frameworksWithDependencies, fs);
+    const allMatches = removeEmbededFrameworks(frameworkWithFiles);
+
+    if (allMatches.length === 0) {
+      return null;
+    }
+    if (allMatches.length > 1) {
+      const frameworkNames = allMatches.map((framework) => framework.id);
+      throw new FirebaseError(
+        `Multiple Frameworks are matched: ${frameworkNames.join(
+          ", "
+        )} Manually set up override commands in firebase.json`
+      );
+    }
+
+    return allMatches[0];
+  } catch (error: any) {
+    throw new FirebaseError(`Failed to match the correct framework: ${error}`);
+  }
+}

src/frameworks/compose/discover/frameworkSpec.ts

@@ -0,0 +1,38 @@
+import { FrameworkSpec } from "./types";
+
+export const frameworkSpecs: FrameworkSpec[] = [
+  {
+    id: "express",
+    runtime: "nodejs",
+    webFrameworkId: "Express.js",
+    requiredDependencies: [
+      {
+        name: "express",
+      },
+    ],
+  },
+  {
+    id: "nextjs",
+    runtime: "nodejs",
+    webFrameworkId: "Next.js",
+    requiredFiles: ["next.config.js", "next.config.ts"],
+    requiredDependencies: [
+      {
+        name: "next",
+      },
+    ],
+    commands: {
+      build: {
+        cmd: "next build",
+      },
+      dev: {
+        cmd: "next dev",
+        env: { NODE_ENV: "dev" },
+      },
+      run: {
+        cmd: "next run",
+        env: { NODE_ENV: "production" },
+      },
+    },
+  },
+];