@geode/opengeodeweb-front 10.36.0-rc.3 → 10.36.0-rc.4

package/.build/opengeodeweb_front_schemas.js

@@ -181,7 +181,8 @@ var api = {
 									"name": { "type": "string" },
 									"version": { "type": "string" },
 									"frontendContent": { "type": "string" },
-									"port": { "type": "integer" }
+									"port": { "type": "integer" },
+									"serverPort": { "type": "integer" }
 								},
 								"required": [
 									"id",

package/.build/server/utils/microservices.js

@@ -9,9 +9,10 @@ import child_process from "node:child_process";
 import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
 //#region server/utils/microservices.ts
 const MILLISECONDS_PER_SECOND = 1e3;
-const DEFAULT_TIMEOUT_SECONDS = 45;
+const DEFAULT_TIMEOUT_SECONDS = 120;
 const MAX_PORT_RETRIES = 1;
 const DEFAULT_RUN_ARGS = { projectFolderPath: "" };
+const LISTENING_LOG_PATTERN = /^Listening on https?:\/\/.+:\d+\/?\s*$/mu;
 async function runScript(execPath, execName, args, expectedResponse, timeoutSeconds = DEFAULT_TIMEOUT_SECONDS) {
 	const command = executablePath(execPath, execName);
 	consola.debug("runScript", command, args);
@@ -132,6 +133,47 @@ async function runExtension(extensionId, execName, execPath, args = DEFAULT_RUN_
 	}
 	throw new Error(`runExtension failed to run ${extensionId}`);
 }
+async function waitUntilListening(child) {
+	child.stderr.on("data", (data) => {
+		consola.info(`[${child.spawnfile}] STDERR:`, data.toString().trim());
+	});
+	child.on("close", (code) => {
+		consola.info(`[${child.spawnfile}] exited with code ${code}`);
+	});
+	for await (const chunk of child.stdout) {
+		const output = String(chunk);
+		consola.info(`[${child.spawnfile}] STDOUT:`, output.trim());
+		if (LISTENING_LOG_PATTERN.test(output)) {
+			child.stdout.on("data", (data) => {
+				consola.info(`[${child.spawnfile}] STDOUT:`, data.toString().trim());
+			});
+			return;
+		}
+	}
+	throw new Error(`${child.spawnfile} exited before becoming ready`);
+}
+async function runExtensionServer(entryPath, attempts = 0) {
+	let port = void 0;
+	try {
+		port = await getAvailablePort();
+		consola.info("runExtensionServer", entryPath, port);
+		await waitUntilListening(child_process.spawn("node", [entryPath], { env: {
+			...process.env,
+			PORT: String(port)
+		} }));
+		return port;
+	} catch (error) {
+		if (!isPortInUseError(error)) {
+			consola.error("runExtensionServer error", error);
+			throw error;
+		}
+		if (attempts <= MAX_PORT_RETRIES) {
+			consola.warn("Retrying runExtensionServer on conflicting port", port);
+			return await runExtensionServer(entryPath, attempts + 1);
+		}
+	}
+	throw new Error(`runExtensionServer failed to run ${entryPath}`);
+}
 function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
 	const microservices = projectMicroservices(projectFolderPath);
 	let enriched = { ...serviceObj };
@@ -151,4 +193,4 @@ function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
 	fs.writeFileSync(microservicesMetadatasPath(projectFolderPath), JSON.stringify({ microservices }, void 0, 2));
 }
 //#endregion
-export { addMicroserviceMetadatas, runBack, runExtension, runViewer };
+export { addMicroserviceMetadatas, runBack, runExtension, runExtensionServer, runViewer };

package/.build/server/utils/path.js

@@ -105,5 +105,8 @@ function extensionBackendPath(unzippedExtensionPath, backendExecutableName) {
 	consola.debug("runExtensions", { backendExecutablePath });
 	return backendExecutablePath;
 }
+function extensionServerEntryPath(unzippedExtensionPath, entry) {
+	return path.join(unzippedExtensionPath, entry);
+}
 //#endregion
-export { createPath, executableName, executablePath, extensionBackendPath, extensionFolderPath, extensionFrontendPath, generateProjectFolderPath };
+export { createPath, executableName, executablePath, extensionBackendPath, extensionFolderPath, extensionFrontendPath, extensionServerEntryPath, generateProjectFolderPath };

package/.build/server/utils/server_config.js

@@ -3,6 +3,7 @@ import { createServerWsRpcClient } from "./ws_client.js";
 const stringStorage = /* @__PURE__ */ new Map();
 const booleanStorage = /* @__PURE__ */ new Map();
 const clientStorage = /* @__PURE__ */ new Map();
+const extensionServerPorts = /* @__PURE__ */ new Map();
 function getAppBaseUrl() {
 	const value = stringStorage.get("APP_BASE_URL");
 	if (value === void 0) throw new Error("APP_BASE_URL is not set");
@@ -47,5 +48,14 @@ async function getViewerWebSocketClient() {
 	if (viewerClient !== void 0 && viewerClient.isOpen()) return viewerClient;
 	return await setViewerWebSocketClient(getViewerBaseUrl());
 }
+function setExtensionServerPort(extensionId, port) {
+	extensionServerPorts.set(extensionId, port);
+}
+function getExtensionServerPort(extensionId) {
+	return extensionServerPorts.get(extensionId);
+}
+function getExtensionServerPorts() {
+	return extensionServerPorts;
+}
 //#endregion
-export { getAppBaseUrl, getBackBaseUrl, getIsAppReady, getViewerBaseUrl, getViewerWebSocketClient, setAppBaseUrl, setBackBaseUrl, setIsAppReady, setViewerBaseUrl, setViewerWebSocketClient };
+export { getAppBaseUrl, getBackBaseUrl, getExtensionServerPort, getExtensionServerPorts, getIsAppReady, getViewerBaseUrl, getViewerWebSocketClient, setAppBaseUrl, setBackBaseUrl, setExtensionServerPort, setIsAppReady, setViewerBaseUrl, setViewerWebSocketClient };

package/app/stores/app_helpers/extension.ts

@@ -59,6 +59,7 @@ export function useAppExtensions(): {
   async function loadExtension(
     path: string,
     extensionPort: string,
+    serverPort?: string,
     backendPath?: string,
   ): Promise<ExtensionModule> {
     try {
@@ -77,7 +78,10 @@ export function useAppExtensions(): {
       // oxlint-disable-next-line no-inline-comments, no-unsafe-assignment
       const extensionModule: ExtensionModule = await import(/* @vite-ignore */ finalURL);
       const store = extensionModule.metadata.store();
-      store.$patch?.({ default_local_port: extensionPort });
+      store.$patch?.({
+        default_local_port: extensionPort,
+        ...(serverPort === undefined ? {} : { nitro_port: serverPort }),
+      });
 
       if (finalURL !== path && finalURL.startsWith("blob:")) {
         URL.revokeObjectURL(finalURL);

package/app/utils/extension.ts

@@ -15,6 +15,7 @@ interface ExtensionDescriptor {
   version: string;
   frontendContent: string;
   port: number;
+  serverPort?: number;
 }
 
 interface DownloadExtensionParams {
@@ -87,12 +88,16 @@ async function registerRunningExtensions(): Promise<RegisteredExtension[]> {
   const { extensionsArray } = await runExtensions();
   return Promise.all(
     extensionsArray.map(async (extension: ExtensionDescriptor) => {
-      const { id, name, version, frontendContent, port } = extension;
+      const { id, name, version, frontendContent, port, serverPort } = extension;
       const blob = new Blob([frontendContent], {
         type: "application/javascript",
       });
       const blobUrl = URL.createObjectURL(blob);
-      const extensionModule = await appStore.loadExtension(blobUrl, String(port));
+      const extensionModule = await appStore.loadExtension(
+        blobUrl,
+        String(port),
+        serverPort === undefined ? undefined : String(serverPort),
+      );
       consola.info("[ExtensionManager] Extension loaded:", id);
       const storeFactory = extensionModule.metadata.store;
       const store = storeFactory();

package/app/utils/import_workflow.ts

@@ -80,6 +80,9 @@ async function importFile(filename: string, geode_object_type: string): Promise<
 }
 
 async function importWorkflow(files: readonly FileToImport[]): Promise<string[]> {
+  const hybridViewerStore = useHybridViewerStore();
+  // Files are imported concurrently and the viewer only frames the first actor to arrive, so the camera is reset once everything is loaded
+  const wasSceneEmpty = Object.keys(hybridViewerStore.hybridDb).length === 0;
   const chunk_size = 5;
   const chunks: FileToImport[][] = [];
   for (let i = 0; i < files.length; i += chunk_size) {
@@ -102,7 +105,10 @@ async function importWorkflow(files: readonly FileToImport[]): Promise<string[]>
     await processChunk(chunkIndex + 1);
   }
   await processChunk(0);
-  const hybridViewerStore = useHybridViewerStore();
+  const isSceneFilled = Object.keys(hybridViewerStore.hybridDb).length > 0;
+  if (wasSceneEmpty && isSceneFilled) {
+    hybridViewerStore.resetCamera();
+  }
   await hybridViewerStore.remoteRender();
   return results;
 }

package/opengeodeweb_front_schemas.json

@@ -241,6 +241,9 @@
                     },
                     "port": {
                       "type": "integer"
+                    },
+                    "serverPort": {
+                      "type": "integer"
                     }
                   },
                   "required": ["id", "name", "version", "frontendContent", "port"],

package/opengeodeweb_front_typed_schemas.d.ts

@@ -90,6 +90,7 @@ export interface LocalExtensionsRunResponseExtensionsArray {
   id: string;
   name: string;
   port: number;
+  serverPort?: number;
   version: string;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.36.0-rc.3",
+  "version": "10.36.0-rc.4",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {

package/server/api/local/extensions/run.post.ts

@@ -7,54 +7,73 @@ import fs from "node:fs";
 import {
   addMicroserviceMetadatas,
   runBack,
+  runExtensionServer,
 } from "@geode/opengeodeweb-front/server/utils/microservices.ts";
 import {
   extensionBackendPath,
   extensionFolderPath,
+  extensionServerEntryPath,
 } from "@geode/opengeodeweb-front/server/utils/path.ts";
 import {
   readExtensionFrontend,
   readExtensionMetadata,
 } from "@geode/opengeodeweb-front/server/utils/extension.ts";
 import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.ts";
+import { setExtensionServerPort } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
 import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.ts";
 
 import { defineTypedEventHandler } from "@geode/opengeodeweb-front/server/utils/typed_handler.ts";
 import schemas from "@geode/opengeodeweb-front/opengeodeweb_front_typed_schemas.js";
 
+async function runSingleExtension(
+  extensionPath: string,
+  extensionId: string,
+  projectFolderPath: string,
+): Promise<{
+  id: string;
+  name: string;
+  version: string;
+  frontendContent: string;
+  port: number;
+  serverPort: number | undefined;
+}> {
+  const unzippedExtensionPath = await unzipFile(
+    extensionPath,
+    extensionFolderPath(projectFolderPath, extensionId),
+  );
+  const { id, name, version, backendExecutable, server, frontendFile } =
+    await readExtensionMetadata(unzippedExtensionPath);
+  const frontendContent = await readExtensionFrontend(unzippedExtensionPath, frontendFile, id);
+
+  fs.chmodSync(extensionBackendPath(unzippedExtensionPath, backendExecutable), "755");
+  const port = await runBack(backendExecutable, unzippedExtensionPath, {
+    projectFolderPath,
+  });
+  addMicroserviceMetadatas(projectFolderPath, {
+    type: "back",
+    name,
+    port,
+  });
+
+  const serverPort =
+    server === undefined
+      ? undefined
+      : await runExtensionServer(extensionServerEntryPath(unzippedExtensionPath, server.entry));
+  if (serverPort !== undefined) {
+    setExtensionServerPort(id, serverPort);
+  }
+
+  return { id, name, version, frontendContent, port, serverPort };
+}
+
 export default defineTypedEventHandler(
   schemas.api.local.extensions.run,
   async ({ projectFolderPath, projectName }) => {
     const extensionsConfig = extensionsConf(projectName);
     const extensionsArray = await Promise.all(
       Object.entries(extensionsConfig).map(async ([extensionId, { path: extensionPath }]) => {
-        const unzippedExtensionPath = await unzipFile(
-          extensionPath,
-          extensionFolderPath(projectFolderPath, extensionId),
-        );
-        const { id, name, version, backendExecutable, frontendFile } =
-          await readExtensionMetadata(unzippedExtensionPath);
-        const frontendContent = await readExtensionFrontend(
-          unzippedExtensionPath,
-          frontendFile,
-          id,
-        );
-        fs.chmodSync(extensionBackendPath(unzippedExtensionPath, backendExecutable), "755");
-        const port = await runBack(backendExecutable, unzippedExtensionPath, {
-          projectFolderPath,
-        });
-        addMicroserviceMetadatas(projectFolderPath, {
-          type: "back",
-          name,
-          port,
-        });
-        return {
-          id,
-          name,
-          version,
-          frontendContent,
-          port,
-        };
+        const result = await runSingleExtension(extensionPath, extensionId, projectFolderPath);
+        return result;
       }),
     );
 

package/server/api/local/extensions/schemas/run.json

@@ -37,6 +37,9 @@
             },
             "port": {
               "type": "integer"
+            },
+            "serverPort": {
+              "type": "integer"
             }
           },
           "required": ["id", "name", "version", "frontendContent", "port"],

package/server/utils/extension.ts

@@ -10,6 +10,10 @@ import { createError } from "h3";
 // Local imports
 import { extensionFrontendPath } from "@geode/opengeodeweb-front/server/utils/path.ts";
 
+const extensionServerMetadataSchema = z.object({
+  entry: z.string(),
+});
+
 const extensionMetadataSchema = z
   .object({
     id: z.string(),
@@ -17,6 +21,7 @@ const extensionMetadataSchema = z
     version: z.string(),
     frontendFile: z.string(),
     backendExecutable: z.string(),
+    server: extensionServerMetadataSchema.optional(),
   })
   .loose();
 

package/server/utils/microservices.ts

@@ -20,9 +20,10 @@ interface RunArgs {
 }
 
 const MILLISECONDS_PER_SECOND = 1000;
-const DEFAULT_TIMEOUT_SECONDS = 45;
+const DEFAULT_TIMEOUT_SECONDS = 120;
 const MAX_PORT_RETRIES = 1;
 const DEFAULT_RUN_ARGS: RunArgs = { projectFolderPath: "" };
+const LISTENING_LOG_PATTERN = /^Listening on https?:\/\/.+:\d+\/?\s*$/mu;
 
 async function runScript(
   execPath: string,
@@ -183,6 +184,56 @@ async function runExtension(
   }
   throw new Error(`runExtension failed to run ${extensionId}`);
 }
+async function waitUntilListening(
+  child: child_process.ChildProcessWithoutNullStreams,
+): Promise<void> {
+  child.stderr.on("data", (data: Buffer) => {
+    consola.info(`[${child.spawnfile}] STDERR:`, data.toString().trim());
+  });
+  child.on("close", (code) => {
+    consola.info(`[${child.spawnfile}] exited with code ${code}`);
+  });
+  // oxlint-disable-next-line typescript/no-unnecessary-condition
+  for await (const chunk of child.stdout) {
+    const output = String(chunk);
+    consola.info(`[${child.spawnfile}] STDOUT:`, output.trim());
+    if (LISTENING_LOG_PATTERN.test(output)) {
+      child.stdout.on("data", (data: Buffer) => {
+        consola.info(`[${child.spawnfile}] STDOUT:`, data.toString().trim());
+      });
+      return;
+    }
+  }
+  throw new Error(`${child.spawnfile} exited before becoming ready`);
+}
+
+async function runExtensionServer(entryPath: string, attempts = 0): Promise<number> {
+  let port: number | undefined = undefined;
+  try {
+    port = await getAvailablePort();
+    consola.info("runExtensionServer", entryPath, port);
+    const child = child_process.spawn("node", [entryPath], {
+      env: {
+        ...process.env,
+        PORT: String(port),
+      },
+    });
+    await waitUntilListening(child);
+    return port;
+  } catch (error) {
+    if (!isPortInUseError(error)) {
+      consola.error("runExtensionServer error", error);
+      throw error;
+    }
+    if (attempts <= MAX_PORT_RETRIES) {
+      consola.warn("Retrying runExtensionServer on conflicting port", port);
+      const newPort = await runExtensionServer(entryPath, attempts + 1);
+      return newPort;
+    }
+  }
+  throw new Error(`runExtensionServer failed to run ${entryPath}`);
+}
+
 function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microservice): void {
   const microservices = projectMicroservices(projectFolderPath);
   let enriched: Microservice = { ...serviceObj };
@@ -213,4 +264,4 @@ function addMicroserviceMetadatas(projectFolderPath: string, serviceObj: Microse
   );
 }
 
-export { addMicroserviceMetadatas, runBack, runExtension, runViewer };
+export { addMicroserviceMetadatas, runBack, runExtension, runExtensionServer, runViewer };

package/server/utils/path.ts

@@ -163,11 +163,15 @@ function extensionBackendPath(
   });
   return backendExecutablePath;
 }
+function extensionServerEntryPath(unzippedExtensionPath: string, entry: string): string {
+  return path.join(unzippedExtensionPath, entry);
+}
 export {
   createPath,
   extensionBackendPath,
   extensionFrontendPath,
   extensionFolderPath,
+  extensionServerEntryPath,
   executablePath,
   executableName,
   generateProjectFolderPath,

package/server/utils/server_config.ts

@@ -3,6 +3,7 @@ import { type ServerWsRpcClient, createServerWsRpcClient } from "./ws_client.js"
 const stringStorage = new Map<string, string>();
 const booleanStorage = new Map<string, boolean>();
 const clientStorage = new Map<string, ServerWsRpcClient>();
+const extensionServerPorts = new Map<string, number>();
 
 function getAppBaseUrl(): string {
   const value = stringStorage.get("APP_BASE_URL");
@@ -60,14 +61,27 @@ async function getViewerWebSocketClient(): Promise<ServerWsRpcClient> {
   const client = await setViewerWebSocketClient(viewerBaseUrl);
   return client;
 }
+function setExtensionServerPort(extensionId: string, port: number): void {
+  extensionServerPorts.set(extensionId, port);
+}
+function getExtensionServerPort(extensionId: string): number | undefined {
+  return extensionServerPorts.get(extensionId);
+}
+function getExtensionServerPorts(): ReadonlyMap<string, number> {
+  return extensionServerPorts;
+}
+
 export {
   getAppBaseUrl,
   getBackBaseUrl,
+  getExtensionServerPort,
+  getExtensionServerPorts,
   getIsAppReady,
   getViewerBaseUrl,
   getViewerWebSocketClient,
   setAppBaseUrl,
   setBackBaseUrl,
+  setExtensionServerPort,
   setIsAppReady,
   setViewerBaseUrl,
   setViewerWebSocketClient,