refactor: small updates

Add JSDoc types and comments.

Split code.

Rename `build` to `buildServer`.

Rename `pathToIndex` to `projectRootPath`.

Change `npm run dev` to `npm start` in the `directories.js` comment.

Author: nakrovati

server/app.js

@@ -8,7 +8,7 @@ import staticRouter from "./src/static/staticRouter.js";
  * @param {import("fastify").FastifyServerOptions} options
  * @returns {import("fastify").FastifyInstance}
  */
-function build(options = {}) {
+function buildServer(options = {}) {
   const fastify = Fastify(options);
 
   fastify.addHook("onRequest", (request, reply, done) => {
@@ -26,4 +26,4 @@ function build(options = {}) {
   return fastify;
 }
 
-export { build };
+export { buildServer };

server/index.js

@@ -1,8 +1,8 @@
-import { build } from "./app.js";
+import { buildServer } from "./app.js";
 
 const PORT = 8080;
 
-const server = build();
+const server = buildServer();
 
 try {
   await server.listen({ port: PORT });

server/src/config/directories.js

@@ -1,13 +1,13 @@
-import { join } from "path";
+import path from "path";
 import process from "process";
 
 // Checks if the directory is explicitly specified.
-// It can be specified by writing for example `npm run dev other-frameworks-directory`.
+// It can be specified by writing for example `npm start other-frameworks-directory`.
 const isFrameworksDirectorySpecifies = process.argv.length === 3;
 
 const frameworksDirectory = isFrameworksDirectorySpecifies
-  ? join(process.cwd(), "..", process.argv[2])
-  : join(process.cwd(), "..", "frameworks");
+  ? path.join(process.cwd(), "..", process.argv[2])
+  : path.join(process.cwd(), "..", "frameworks");
 
 if (isFrameworksDirectorySpecifies) {
   console.log(`Changing working directory to ${process.argv[2]}`);

server/src/csp/cspRouter.js

@@ -3,13 +3,12 @@ import { addCSP, disableCSP, enableCSP, getCSP } from "./cspControllers.js";
 /**
  * A plugin that provide encapsulated routes
  * @param {import("fastify").FastifyInstance} fastify
- * @param {import("fastify").RegisterOptions} options
  */
-async function routes(fastify, _options) {
+async function routes(fastify) {
   fastify.addContentTypeParser(
     "application/csp-report",
     { parseAs: "string" },
-    fastify.getDefaultJsonParser("ignore", "ignore")
+    fastify.getDefaultJsonParser("ignore", "ignore"),
   );
 
   fastify.get("/enable", enableCSP);

server/src/frameworks/frameworksControllers.js

@@ -1,32 +1,28 @@
-import path from "path";
-import fs from "fs";
+import { loadFrameworkVersions } from "./frameworksServices.js";
 
-import { frameworksDirectory } from "../config/directories.js";
-import isFrameworkDir from "./utils/isFrameworkDir.js";
-import { loadFrameworkInfo } from "./helpers/index.js";
+/**
+ * @typedef {import("fastify").FastifyRequest} Request
+ * @typedef {import("fastify").FastifyReply} Reply
+ */
 
-export async function loadFrameworkVersionInformation(filterForFramework) {
-  const resultsProm = [];
-  const frameworksPath = path.resolve(frameworksDirectory);
-  const keyedTypes = ["keyed", "non-keyed"];
+/**
+ * @param {Request} request
+ * @param {Reply} reply
+ */
+export async function getFrameworksVersions(_request, reply) {
+  performance.mark("Start");
 
-  for (const keyedType of keyedTypes) {
-    const directories = fs.readdirSync(path.resolve(frameworksPath, keyedType));
+  const frameworks = await loadFrameworkVersions();
 
-    for (const directory of directories) {
-      const pathInFrameworksDir = `${keyedType}/${directory}`;
+  performance.mark("End");
 
-      if (filterForFramework && filterForFramework !== pathInFrameworksDir) {
-        continue;
-      }
+  const executionTime = performance.measure(
+    "/ls duration measurement",
+    "Start",
+    "End",
+  ).duration;
 
-      if (!isFrameworkDir(keyedType, directory)) {
-        continue;
-      }
+  console.log(`/ls duration: ${executionTime}ms`);
 
-      const frameworkInfo = loadFrameworkInfo(keyedType, directory);
-      resultsProm.push(frameworkInfo);
-    }
-  }
-  return Promise.all(resultsProm);
+  return reply.send(frameworks);
 }

server/src/frameworks/frameworksRouter.js

@@ -1,27 +1,11 @@
-import { loadFrameworkVersionInformation } from "./frameworksControllers.js";
+import { getFrameworksVersions } from "./frameworksControllers.js";
 
 /**
  * A plugin that provide encapsulated routes
  * @param {import("fastify").FastifyInstance} fastify
- * @param {import("fastify").RegisterOptions} options
  */
-async function routes(fastify, _options) {
-  fastify.get("/ls", async function (_request, reply) {
-    performance.mark("Start");
-
-    const frameworks = await loadFrameworkVersionInformation();
-    reply.send(frameworks);
-
-    performance.mark("End");
-    const executionTime = performance.measure(
-      "/ls duration measurement",
-      "Start",
-      "End",
-    ).duration;
-
-    console.log(`/ls duration: ${executionTime}ms`);
-    return;
-  });
+async function routes(fastify) {
+  fastify.get("/ls", getFrameworksVersions);
 }
 
 export default routes;

server/src/frameworks/frameworksServices.js

@@ -0,0 +1,178 @@
+import path from "path";
+import fs from "fs";
+
+import { frameworksDirectory } from "../config/directories.js";
+import { buildFrameworkVersionString, copyProps } from "./helpers/index.js";
+
+const keyedTypes = ["keyed", "non-keyed"];
+
+class PackageJSONProvider {
+  #frameworksDir;
+
+  /** @param {string} frameworksDir */
+  constructor(frameworksDir) {
+    this.#frameworksDir = frameworksDir;
+  }
+
+  /**
+   * Returns the parsed package.json
+   * @param {string} keyedDir
+   * @param {string} framework
+   * @returns {Promise<unknown>}
+   */
+  async getPackageJSON(keyedDir, framework) {
+    try {
+      const packageJSONPath = path.join(
+        this.#frameworksDir,
+        keyedDir,
+        framework,
+        "package.json",
+      );
+      const packageJSON = await fs.promises.readFile(packageJSONPath, "utf-8");
+      return JSON.parse(packageJSON);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Package.json not found for ${framework}.`);
+      }
+      console.error(error);
+    }
+  }
+
+  /**
+   * Returns the parsed package-lock.json
+   * @param {string} keyedDir
+   * @param {string} framework
+   * @returns {Promise<unknown>}
+   */
+  async getPackageLockJSON(keyedDir, framework) {
+    try {
+      const packageLockJSONPath = path.join(
+        this.#frameworksDir,
+        keyedDir,
+        framework,
+        "package-lock.json",
+      );
+      const packageLockJSON = await fs.promises.readFile(
+        packageLockJSONPath,
+        "utf-8",
+      );
+      return JSON.parse(packageLockJSON);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`Package-lock.json not found for ${framework}.`);
+      }
+      console.error(error);
+    }
+  }
+}
+
+/**
+ * @param {string} keyedDir
+ * @param {string} framework
+ * @returns {boolean}
+ */
+async function isFrameworkDir(keyedDir, framework) {
+  const frameworkPath = path.resolve(frameworksDirectory, keyedDir, framework);
+  const packageJSONPath = path.resolve(frameworkPath, "package.json");
+  const packageLockJSONPath = path.resolve(frameworkPath, "package-lock.json");
+  const exists =
+    fs.existsSync(packageJSONPath) && fs.existsSync(packageLockJSONPath);
+
+  return exists;
+}
+
+const packageJSONProvider = new PackageJSONProvider(frameworksDirectory);
+
+/**
+ * Load framework information from package.json and package-lock.json files.
+ * @param {string} keyedDir - The type of the framework directory (e.g., "keyed" or "non-keyed").
+ * @param {string} framework - The name of the framework directory.
+ * @returns {Promise<object>} - The loaded framework information.
+ */
+export async function loadFrameworkInfo(keyedDir, framework) {
+  const result = {
+    type: keyedDir,
+    directory: framework,
+  };
+  const packageJSON = await packageJSONProvider.getPackageJSON(
+    keyedDir,
+    framework,
+  );
+  const packageLockJSON = await packageJSONProvider.getPackageLockJSON(
+    keyedDir,
+    framework,
+  );
+
+  const benchmarkData = packageJSON["js-framework-benchmark"];
+  if (!benchmarkData) {
+    result.error =
+      "package.json must contain a 'js-framework-benchmark' property";
+    return result;
+  }
+
+  if (benchmarkData.frameworkVersionFromPackage) {
+    const packageNames = benchmarkData.frameworkVersionFromPackage.split(":");
+
+    result.versions = {};
+
+    for (const packageName of packageNames) {
+      if (packageLockJSON.dependencies?.[packageName]) {
+        result.versions[packageName] =
+          packageLockJSON.dependencies[packageName].version;
+      } else if (packageLockJSON.packages?.[`node_modules/${packageName}`]) {
+        result.versions[packageName] =
+          packageLockJSON.packages[`node_modules/${packageName}`].version;
+      } else {
+        result.versions[packageName] = "ERROR: Not found in package-lock";
+      }
+    }
+
+    result.frameworkVersionString = buildFrameworkVersionString(
+      framework,
+      packageNames.map((name) => result.versions[name]).join(" + "),
+      keyedDir,
+    );
+
+    copyProps(result, benchmarkData);
+  } else if (typeof benchmarkData.frameworkVersion === "string") {
+    result.version = benchmarkData.frameworkVersion;
+    result.frameworkVersionString = buildFrameworkVersionString(
+      framework,
+      result.version,
+      keyedDir,
+    );
+
+    copyProps(result, benchmarkData);
+  } else {
+    result.error =
+      "package.json must contain a 'frameworkVersionFromPackage' or 'frameworkVersion' in the 'js-framework-benchmark'.property";
+  }
+
+  return result;
+}
+
+export async function loadFrameworkVersions(filterForFramework) {
+  const resultsProm = [];
+
+  for (const keyedType of keyedTypes) {
+    const directories = await fs.promises.readdir(
+      path.resolve(frameworksDirectory, keyedType),
+    );
+
+    for (const directory of directories) {
+      const frameworkPath = path.join(keyedType, directory);
+
+      if (filterForFramework && filterForFramework !== frameworkPath) {
+        continue;
+      }
+
+      if (!isFrameworkDir(keyedType, directory)) {
+        continue;
+      }
+
+      const frameworkInfoPromise = loadFrameworkInfo(keyedType, directory);
+      resultsProm.push(frameworkInfoPromise);
+    }
+  }
+  return Promise.all(resultsProm);
+}

server/src/frameworks/helpers/buildFrameworkVersionString.js

@@ -0,0 +1,9 @@
+/**
+ * @param {string} directoryName
+ * @param {string} version
+ * @param {string} keyedDir
+ * @returns
+ */
+export function buildFrameworkVersionString(directoryName, version, keyedDir) {
+  return `${directoryName}${version ? `-v${version}` : ""}-${keyedDir}`;
+}

server/src/frameworks/helpers/copyProps.js

@@ -0,0 +1,38 @@
+/**
+ * @typedef {Object} BenchmarkData
+ * @prop {string} issues
+ * @prop {string} customURL
+ * @prop {string} frameworkHomeURL
+ * @prop {string} useShadowRoot
+ * @prop {string} useRowShadowRoot
+ * @prop {string} shadowRootName
+ * @prop {string} buttonsInShadowRoot
+ */
+
+/**
+ * @param {unknown} result
+ * @param {BenchmarkData} benchmarkData
+ */
+export function copyProps(result, benchmarkData) {
+  const {
+    issues,
+    customURL,
+    frameworkHomeURL,
+    useShadowRoot,
+    useRowShadowRoot,
+    shadowRootName,
+    buttonsInShadowRoot,
+  } = benchmarkData;
+
+  result.issues = issues;
+  result.customURL = customURL;
+  result.frameworkHomeURL = frameworkHomeURL;
+  result.useShadowRoot = useShadowRoot;
+  result.useRowShadowRoot = useRowShadowRoot;
+  result.shadowRootName = useShadowRoot
+    ? shadowRootName ?? "main-element"
+    : undefined;
+  result.buttonsInShadowRoot = useShadowRoot
+    ? buttonsInShadowRoot ?? true
+    : undefined;
+}