@geode/opengeodeweb-front 10.22.0 → 10.22.1-rc.1

package/app/utils/local/microservices.js

@@ -10,8 +10,8 @@ import pTimeout from "p-timeout";
 
 // Local imports
 import { commandExistsSync, waitForReady } from "./scripts.js";
-import { executableName, executablePath } from "./path.js";
 import { microservicesMetadatasPath, projectMicroservices } from "./cleanup.js";
+import { executablePath } from "./path.js";
 
 const DEFAULT_TIMEOUT_SECONDS = 60;
 const MILLISECONDS_PER_SECOND = 1000;
@@ -24,8 +24,8 @@ function getAvailablePort() {
 }
 
 async function runScript(
-  execName,
   execPath,
+  execName,
   args,
   expectedResponse,
   timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
@@ -34,7 +34,7 @@ async function runScript(
   if (commandExistsSync(execName)) {
     command = execName;
   } else {
-    command = path.join(executablePath(execPath), executableName(execName));
+    command = path.join(executablePath(execPath, execName));
   }
   console.log("runScript", command, args);
 
@@ -82,8 +82,8 @@ async function runBack(execName, execPath, args = {}) {
   if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
     backArgs.push("--debug");
   }
-  console.log("runBack", execName, execPath, backArgs);
-  await runScript(execName, execPath, backArgs, "Serving Flask app");
+  console.log("runBack", execPath, execName, backArgs);
+  await runScript(execPath, execName, backArgs, "Serving Flask app");
   return port;
 }
 
@@ -98,8 +98,8 @@ async function runViewer(execName, execPath, args = {}) {
     `--data_folder_path ${projectFolderPath}`,
     `--timeout ${0}`,
   ];
-  console.log("runViewer", execName, execPath, viewerArgs);
-  await runScript(execName, execPath, viewerArgs, "Starting factory");
+  console.log("runViewer", execPath, execName, viewerArgs);
+  await runScript(execPath, execName, viewerArgs, "Starting factory");
   return port;
 }
 

package/app/utils/local/path.js

@@ -2,6 +2,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { setTimeout } from "node:timers/promises";
 
 // Third party imports
 import { v4 as uuidv4 } from "uuid";
@@ -9,22 +10,31 @@ import { v4 as uuidv4 } from "uuid";
 // Local imports
 import { appMode } from "./app_mode.js";
 
-function executablePath(microservicePath) {
+function executablePath(execPath, execName) {
   const resourcesPath = process.env.RESOURCES_PATH;
   const mode = process.env.MODE;
   const nodeEnv = process.env.NODE_ENV;
-  console.log("[executablePath]", { microservicePath, mode, nodeEnv, resourcesPath });
+  console.log("[executablePath]", { execPath, execName, mode, nodeEnv, resourcesPath });
   if (mode === appMode.DESKTOP && nodeEnv === "production") {
-    return resourcesPath;
+    const execPathInResources = path.join(resourcesPath, executableName(execName));
+    if (fs.existsSync(execPathInResources)) {
+      console.log(`[executablePath] Found executable in resources path: ${execPathInResources}`);
+      return execPathInResources;
+    }
   }
-  return microservicePath;
+  const localExecPath = path.join(execPath, executableName(execName));
+  if (fs.existsSync(localExecPath)) {
+    console.log(`[executablePath] Found executable in local path: ${localExecPath}`);
+    return localExecPath;
+  }
+  throw new Error(`Executable not found: ${execName}`);
 }
 
-function executableName(name) {
+function executableName(execName) {
   if (process.platform === "win32") {
-    return `${name}.exe`;
+    return `${execName}.exe`;
   }
-  return name;
+  return execName;
 }
 
 function createPath(dirPath) {
@@ -39,17 +49,62 @@ function generateProjectFolderPath(projectName) {
   return path.join(os.tmpdir(), projectName.replaceAll("/", "_"), uuidv4());
 }
 
-function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPath, extensionId) {
-  if (process.env.NODE_ENV === "production") {
-    return path.join(unzippedExtensionPath, frontendFile);
+async function lookForLocalExtensionDistPath(rootPath, extentionRepoName, frontendFile) {
+  const localExtensionPath = path.join(rootPath, "..", extentionRepoName);
+  const localExtensionDistPath = path.join(localExtensionPath, "dist");
+
+  if (!fs.existsSync(localExtensionDistPath)) {
+    return;
+  }
+  console.log(
+    `[extensionFrontendPath] Found existing folder: ${localExtensionDistPath}, deleting it...`,
+  );
+  fs.rmSync(localExtensionDistPath, { recursive: true, force: true });
+  const now = new Date();
+  fs.utimesSync(path.join(localExtensionPath, "package.json"), now, now);
+
+  const rebuiltFilePath = path.join(localExtensionDistPath, frontendFile);
+  const MAX_DELETE_FOLDER_RETRIES = 10;
+  const MILLISECONDS_PER_RETRY = 1000;
+
+  for (let i = 0; i <= MAX_DELETE_FOLDER_RETRIES; i += 1) {
+    if (fs.existsSync(rebuiltFilePath)) {
+      console.log(`Found rebuilt file: ${rebuiltFilePath}`);
+      return rebuiltFilePath;
+    }
+    console.log(`Waiting for rebuild... attempt ${i}/${MAX_DELETE_FOLDER_RETRIES}`);
+    // oxlint-disable-next-line no-await-in-loop
+    await setTimeout(MILLISECONDS_PER_RETRY);
   }
+
+  throw new Error(`Failed to find local extension dist path: ${rebuiltFilePath}`);
+}
+async function extensionFrontendPath(unzippedExtensionPath, frontendFile, rootPath, extensionId) {
+  console.log("[extensionFrontendPath]", {
+    unzippedExtensionPath,
+    frontendFile,
+    rootPath,
+    extensionId,
+  });
   const extentionRepoName = extensionId
     .split("-")
     .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
     .join("-");
-  const localExtensionPath = path.join(rootPath, "..", extentionRepoName, "dist", frontendFile);
-  console.log("runExtensions", { localExtensionPath });
-  return localExtensionPath;
+
+  const localFilePath = await lookForLocalExtensionDistPath(
+    rootPath,
+    extentionRepoName,
+    frontendFile,
+  );
+  if (localFilePath) {
+    return localFilePath;
+  }
+
+  const unzippedfrontendFilePath = path.join(unzippedExtensionPath, frontendFile);
+  if (fs.existsSync(unzippedfrontendFilePath)) {
+    return unzippedfrontendFilePath;
+  }
+  throw new Error(`Failed to find ${unzippedfrontendFilePath}`);
 }
 
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.22.0",
+  "version": "10.22.1-rc.1",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -34,8 +34,8 @@
     "build": ""
   },
   "dependencies": {
-    "@geode/opengeodeweb-back": "latest",
-    "@geode/opengeodeweb-viewer": "latest",
+    "@geode/opengeodeweb-back": "next",
+    "@geode/opengeodeweb-viewer": "next",
     "@google-cloud/run": "3.2.0",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",

package/server/api/extensions/run.post.js

@@ -57,12 +57,14 @@ export default defineEventHandler(async (event) => {
           });
         }
 
-        const frontendFilePath = extensionFrontendPath(
-          projectFolderPath,
+        const frontendFilePath = await extensionFrontendPath(
+          unzippedExtensionPath,
           frontendFile,
           path.resolve(),
           id,
         );
+
+        console.log("runExtensions", { frontendFilePath });
         const frontendContent = await fs.promises.readFile(frontendFilePath, "utf8");
 
         const backendExecutablePath = path.join(unzippedExtensionPath, backendExecutable);