Merge branch 'nakrovati-update-server'

Author: krausest

server/config/directories.js

@@ -0,0 +1,14 @@
+import { join } from "path";
+import process from "process";
+
+const isFrameworksDirectorySpecifies = process.argv.length === 3;
+
+const frameworksDirectory = isFrameworksDirectorySpecifies
+  ? join(process.cwd(), "..", process.argv[2])
+  : join(process.cwd(), "..", "frameworks");
+
+if (isFrameworksDirectorySpecifies) {
+  console.log(`Changing working directory to ${process.argv[2]}`);
+}
+
+export { frameworksDirectory };

server/csp/cspControllers.js

@@ -0,0 +1,55 @@
+let violations = [];
+let isCSPEnabled = false;
+
+/**
+ * @typedef {import("express").Request} Request
+ * @typedef {import("express").Response} Response
+ */
+
+/**
+ * @param {Request} req
+ * @param {Response} res
+ */
+export function getCSP(req, res) {
+  console.log("CSP violations recorded for", violations);
+  res.send(violations);
+}
+
+/**
+ * @param {Request} req
+ * @param {Response} res
+ */
+export function addCSP(req, res) {
+  console.log("/CSP ", req.body);
+  const uri = req.body["csp-report"]["document-uri"];
+  const frameworkRegEx = /((non-)?keyed\/.*?\/)/;
+  const framework = uri.match(frameworkRegEx)[0];
+  if (!violations.includes(framework)) {
+    violations.push(framework);
+  }
+  res.sendStatus(201);
+}
+
+/**
+ * @param {Request} req
+ * @param {Response} res
+ */
+export function enableCSP(req, res) {
+  console.log("/startCSP");
+  violations = [];
+  isCSPEnabled = true;
+  res.send("OK");
+}
+
+/**
+ * @param {Request} req
+ * @param {Response} res
+ */
+export function disableCSP(req, res) {
+  console.log("/endCSP");
+  violations = [];
+  isCSPEnabled = false;
+  res.send("OK");
+}
+
+export { isCSPEnabled };

server/csp/cspRouter.js

@@ -0,0 +1,18 @@
+import express from "express";
+import bodyParser from "body-parser";
+
+import { addCSP, disableCSP, enableCSP, getCSP } from "./cspControllers.js";
+
+const router = express.Router();
+
+router.use("/csp", bodyParser.json({ type: "application/csp-report" }));
+
+router.get("/startCSP", enableCSP);
+
+router.get("/endCSP", disableCSP);
+
+router.get("/csp", getCSP);
+
+router.post("/csp", addCSP);
+
+export default router;

server/frameworks/frameworksControllers.js

@@ -0,0 +1,32 @@
+import path from "path";
+import fs from "fs";
+
+import { frameworksDirectory } from "../config/directories.js";
+import isFrameworkDir from "./utils/isFrameworkDir.js";
+import { loadFrameworkInfo } from "./helpers/index.js";
+
+export async function loadFrameworkVersionInformation(filterForFramework) {
+  const resultsProm = [];
+  const frameworksPath = path.resolve(frameworksDirectory);
+  const keyedTypes = ["keyed", "non-keyed"];
+
+  for (const keyedType of keyedTypes) {
+    const directories = fs.readdirSync(path.resolve(frameworksPath, keyedType));
+
+    for (const directory of directories) {
+      const pathInFrameworksDir = `${keyedType}/${directory}`;
+
+      if (filterForFramework && filterForFramework !== pathInFrameworksDir) {
+        continue;
+      }
+
+      if (!isFrameworkDir(keyedType, directory)) {
+        continue;
+      }
+
+      const frameworkInfo = loadFrameworkInfo(keyedType, directory);
+      resultsProm.push(frameworkInfo);
+    }
+  }
+  return Promise.all(resultsProm);
+}

server/frameworks/frameworksRouter.js

@@ -0,0 +1,23 @@
+import express from "express";
+
+import { loadFrameworkVersionInformation } from "./frameworksControllers.js";
+
+const router = express.Router();
+
+router.get("/ls", async (req, res) => {
+  performance.mark("Start");
+
+  const frameworks = await loadFrameworkVersionInformation();
+  res.send(frameworks);
+
+  performance.mark("End");
+  const executionTime = performance.measure(
+    "/ls duration measurement",
+    "Start",
+    "End"
+  ).duration;
+
+  console.log(`/ls duration: ${executionTime}ms`);
+});
+
+export default router;

server/frameworks/helpers/index.js

@@ -0,0 +1,97 @@
+import fs from "fs";
+import fsp from "fs/promises";
+import path from "path";
+
+import { frameworksDirectory } from "../../config/directories.js";
+
+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;
+}
+
+export async function loadFrameworkInfo(keyedDir, directoryName) {
+  const result = {
+    type: keyedDir,
+    directory: directoryName,
+  };
+
+  const frameworkPath = path.resolve(
+    frameworksDirectory,
+    keyedDir,
+    directoryName
+  );
+  const packageJSONPath = path.resolve(frameworkPath, "package.json");
+  const packageLockJSONPath = path.resolve(frameworkPath, "package-lock.json");
+
+  if (!fs.existsSync(packageJSONPath)) {
+    result.error = "No package.json found";
+    return result;
+  }
+
+  const packageJSON = JSON.parse(await fsp.readFile(packageJSONPath, "utf8"));
+  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(":");
+    const packageLockJSON = JSON.parse(
+      await fsp.readFile(packageLockJSONPath, "utf8")
+    );
+
+    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 = `${directoryName}-v${packageNames
+      .map((p) => result.versions[p])
+      .join(" + ")}-${keyedDir}`;
+
+    copyProps(result, benchmarkData);
+  } else if (typeof benchmarkData.frameworkVersion === "string") {
+    result.version = benchmarkData.frameworkVersion;
+    result.frameworkVersionString = `${directoryName}${
+      result.version ? `-v${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;
+}

server/frameworks/utils/isFrameworkDir.js

@@ -0,0 +1,24 @@
+import fs from "fs";
+import path from "path";
+import { frameworksDirectory } from "../../config/directories.js";
+
+/**
+ * @param {string} keyedDir
+ * @param {string} directoryName
+ * @returns {boolean}
+ */
+function isFrameworkDir(keyedDir, directoryName) {
+  const frameworkPath = path.resolve(
+    frameworksDirectory,
+    keyedDir,
+    directoryName
+  );
+  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;
+}
+
+export default isFrameworkDir;