@geode/opengeodeweb-front 10.34.0-rc.2 → 10.34.0-rc.21

package/app/stores/app_helpers/extension.ts

@@ -0,0 +1,179 @@
+import { killExtension } from "@ogw_front/utils/extension.js";
+import { useInfraStore } from "@ogw_front/stores/infra";
+
+import type { RegisterableStore } from "@ogw_front/stores/app";
+
+interface ExtensionMetadata {
+  id: string;
+  store: () => RegisterableStore;
+  [key: string]: unknown;
+}
+
+interface ExtensionModule {
+  metadata: ExtensionMetadata;
+  install: (api: unknown, backendPath?: string) => Promise<void>;
+  [key: string]: unknown;
+}
+
+interface ExtensionData {
+  module: ExtensionModule;
+  id: string;
+  path: string;
+  backendPath: string | undefined;
+  loadedAt: string;
+  metadata: ExtensionMetadata;
+  enabled: boolean;
+}
+
+// oxlint-disable-next-line max-lines-per-function, max-statements
+export function useAppExtensions(): {
+  loadedExtensions: typeof loadedExtensions;
+  extensionAPI: typeof extensionAPI;
+  setExtensionAPI: typeof setExtensionAPI;
+  setCodeTransformer: typeof setCodeTransformer;
+  getExtension: typeof getExtension;
+  loadExtension: typeof loadExtension;
+  getLoadedExtensions: typeof getLoadedExtensions;
+  unloadExtension: typeof unloadExtension;
+  toggleExtension: typeof toggleExtension;
+  setExtensionEnabled: typeof setExtensionEnabled;
+  getExtensionEnabled: typeof getExtensionEnabled;
+} {
+  const loadedExtensions = ref<Map<string, ExtensionData>>(new Map());
+  const extensionAPI = ref<unknown>(undefined);
+  const codeTransformer = ref<((code: string) => string) | undefined>(undefined);
+
+  function setExtensionAPI(api: unknown): void {
+    extensionAPI.value = api;
+  }
+
+  function setCodeTransformer(transformer: (code: string) => string): void {
+    codeTransformer.value = transformer;
+  }
+
+  function getExtension(id: string): ExtensionData | undefined {
+    return loadedExtensions.value.get(id);
+  }
+
+  async function loadExtension(
+    path: string,
+    extensionPort: string,
+    backendPath?: string,
+  ): Promise<ExtensionModule> {
+    try {
+      let finalURL = path;
+
+      if (codeTransformer.value && path.startsWith("blob:")) {
+        const response = await fetch(path);
+        const code = await response.text();
+        const transformedCode = codeTransformer.value(code);
+
+        const newBlob = new Blob([transformedCode], {
+          type: "application/javascript",
+        });
+        finalURL = URL.createObjectURL(newBlob);
+      }
+      // 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 });
+
+      if (finalURL !== path && finalURL.startsWith("blob:")) {
+        URL.revokeObjectURL(finalURL);
+      }
+
+      if (!extensionModule.metadata?.id) {
+        throw new Error("Extension must have metadata.id");
+      }
+
+      const extensionId = extensionModule.metadata.id;
+
+      if (loadedExtensions.value.has(extensionId)) {
+        console.warn(`[AppStore] Extension "${extensionId}" is already loaded`);
+        throw new Error(`Extension "${extensionId}" is already loaded.`);
+      }
+
+      if (extensionAPI.value === undefined) {
+        throw new Error("Extension API not initialized");
+      }
+
+      if (typeof extensionModule.install !== "function") {
+        throw new TypeError("Extension must export an install function");
+      }
+
+      await extensionModule.install(extensionAPI.value, backendPath);
+
+      const extensionData: ExtensionData = {
+        module: extensionModule,
+        id: extensionId,
+        path,
+        backendPath,
+        loadedAt: new Date().toISOString(),
+        metadata: extensionModule.metadata,
+        enabled: true,
+      };
+      loadedExtensions.value.set(extensionId, extensionData);
+
+      console.log(`[AppStore] Extension loaded successfully: ${extensionId}`);
+      return extensionModule;
+    } catch (error) {
+      console.error(`[AppStore] Failed to load extension from ${path}:`, error);
+      throw error;
+    }
+  }
+
+  function getLoadedExtensions(): ExtensionData[] {
+    return [...loadedExtensions.value.values()];
+  }
+
+  async function unloadExtension(extensionId: string): Promise<boolean> {
+    console.log(`[AppStore] Unloading extension: ${extensionId}`);
+    const infraStore = useInfraStore();
+    infraStore.unregister_microservice(extensionId);
+    await killExtension(extensionId);
+
+    loadedExtensions.value.delete(extensionId);
+    console.log(`[AppStore] Extension unloaded: ${extensionId}`);
+    return true;
+  }
+
+  function toggleExtension(extensionId: string): boolean {
+    const extensionData = getExtension(extensionId);
+    if (!extensionData) {
+      return false;
+    }
+    extensionData.enabled = !extensionData.enabled;
+    console.log(
+      `[AppStore] Extension ${extensionData.enabled ? "enabled" : "disabled"}: ${extensionId}`,
+    );
+    return extensionData.enabled;
+  }
+
+  function setExtensionEnabled(extensionId: string, enabled: boolean): boolean {
+    const extensionData = getExtension(extensionId);
+    if (!extensionData) {
+      return false;
+    }
+    extensionData.enabled = enabled;
+    console.log(`[AppStore] Extension ${enabled ? "enabled" : "disabled"}: ${extensionId}`);
+    return true;
+  }
+
+  function getExtensionEnabled(extensionId: string): boolean {
+    return getExtension(extensionId)?.enabled ?? false;
+  }
+
+  return {
+    loadedExtensions,
+    extensionAPI,
+    setExtensionAPI,
+    setCodeTransformer,
+    getExtension,
+    loadExtension,
+    getLoadedExtensions,
+    unloadExtension,
+    toggleExtension,
+    setExtensionEnabled,
+    getExtensionEnabled,
+  };
+}

package/app/stores/{back.js → back.ts}

@@ -7,6 +7,8 @@ import { useAppStore } from "@ogw_front/stores/app";
 import { useFeedbackStore } from "@ogw_front/stores/feedback";
 import { useInfraStore } from "@ogw_front/stores/infra";
 
+import type { JsonRpcSchema, RequestHandlers } from "@ogw_shared/utils/types.js";
+
 import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
 
 const MILLISECONDS_IN_SECOND = 1000;
@@ -20,13 +22,13 @@ export const useBackStore = defineStore("back", {
     version: "0.0.0",
   }),
   getters: {
-    protocol() {
+    protocol(): string {
       return getRestApiProtocol();
     },
-    port() {
+    port(): string {
       return getRestApiPort(this.default_local_port);
     },
-    base_url() {
+    base_url(): string {
       const infraStore = useInfraStore();
       let back_url = `${this.protocol}://${infraStore.domain_name}:${this.port}`;
       if (isCloudMode()) {
@@ -34,21 +36,23 @@ export const useBackStore = defineStore("back", {
       }
       return back_url;
     },
-    is_busy() {
+    is_busy(): boolean {
       return this.request_counter > 0;
     },
   },
   actions: {
     set_ping() {
+      // oxlint-disable-next-line typescript/no-floating-promises
       this.ping();
       setInterval(() => {
+        // oxlint-disable-next-line typescript/no-floating-promises
         this.ping();
       }, DEFAULT_PING_INTERVAL_SECONDS * MILLISECONDS_IN_SECOND);
     },
-    ping() {
+    async ping() {
       const feedbackStore = useFeedbackStore();
       const schema = back_schemas.opengeodeweb_back.ping;
-      return this.request(
+      const result = await this.request(
         { schema },
         {
           request_error_function: () => {
@@ -65,6 +69,7 @@ export const useBackStore = defineStore("back", {
           },
         },
       );
+      return result;
     },
     start_request() {
       this.request_counter += 1;
@@ -72,46 +77,58 @@ export const useBackStore = defineStore("back", {
     stop_request() {
       this.request_counter -= 1;
     },
-    launch(args) {
-      console.log("[GEODE] Launching back microservice...", { args });
+    async launch(args: Record<string, unknown>) {
       const appStore = useAppStore();
       const { COMMAND_BACK, NUXT_ROOT_PATH } = useRuntimeConfig().public;
       const schema = opengeodeweb_front_schemas.api.local.app.run_back;
       const params = { COMMAND_BACK, NUXT_ROOT_PATH, args };
 
-      console.log("[GEODE] params", params);
-      return appStore.request(
+      const result = await appStore.request(
         { schema, params },
         {
-          response_function: (response) => {
-            console.log(`[GEODE] Back launched on port ${response.port}`);
-            this.default_local_port = response.port;
+          response_function: (response: unknown) => {
+            if (
+              typeof response === "object" &&
+              response !== null &&
+              "port" in response &&
+              (typeof response.port === "string" || typeof response.port === "number")
+            ) {
+              this.default_local_port = String(response.port);
+            }
           },
         },
       );
+      return result;
     },
-    connect() {
-      console.log("[GEODE] Connecting to geode microservice...");
+    async connect(): Promise<void> {
       this.set_ping();
-      return Promise.resolve();
+      await Promise.resolve();
     },
-    request({ schema, params = {} }, callbacks = {}) {
-      return api_fetch(
+    async request(
+      { schema, params = {} }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
+      callbacks: RequestHandlers = {},
+    ) {
+      const result = await api_fetch(
         this,
-        { schema, params, headers: {} },
+        // The back store is only ever used with HTTP ("front"/"back") schemas,
+        // Which always carry `methods`; the wider JsonRpcSchema param above is
+        // Kept as-is to match this action's public signature.
+        // oxlint-disable-next-line typescript/no-unsafe-type-assertion
+        { schema: schema as JsonRpcSchema & { methods: string[] }, params, headers: {} },
         {
           ...callbacks,
-          response_function: async (response) => {
+          response_function: async (response: unknown) => {
             if (callbacks.response_function) {
               await callbacks.response_function(response);
             }
           },
         },
       );
+      return result;
     },
-    upload(file, callbacks = {}) {
+    async upload(file: File, callbacks: RequestHandlers = {}) {
       const schema = back_schemas.opengeodeweb_back.upload_file;
-      return upload_file(
+      const result = await upload_file(
         this,
         {
           schema,
@@ -119,26 +136,35 @@ export const useBackStore = defineStore("back", {
         },
         {
           ...callbacks,
-          response_function: async (response) => {
+          response_function: async (response: unknown) => {
             if (callbacks.response_function) {
               await callbacks.response_function(response);
             }
           },
         },
       );
+      return result;
     },
-    get_version(schema) {
+    async get_version(schema: JsonRpcSchema | undefined) {
       if (!schema) {
-        return;
+        return undefined;
       }
-      return this.request(
+      const result = await this.request(
         { schema },
         {
-          response_function: (response) => {
-            this.version = response.microservice_version;
+          response_function: (response: unknown) => {
+            if (
+              typeof response === "object" &&
+              response !== null &&
+              "microservice_version" in response &&
+              typeof response.microservice_version === "string"
+            ) {
+              this.version = response.microservice_version;
+            }
           },
         },
       );
+      return result;
     },
   },
   share: {

package/app/stores/camera_manager.ts

@@ -0,0 +1,80 @@
+import { type Table, liveQuery } from "dexie";
+import type { Observable } from "rxjs";
+import { useObservable } from "@vueuse/rxjs";
+
+// Local imports
+import type { CameraOptions } from "@ogw_internal/stores/hybrid_viewer/vtk_types.js";
+import { database } from "@ogw_internal/database/database.js";
+import { useViewerStore } from "@ogw_front/stores/viewer";
+import viewer_schemas from "@geode/opengeodeweb-viewer/opengeodeweb_viewer_schemas.json";
+
+interface CameraPositionRecord {
+  id?: number;
+  name: string;
+  camera_options: CameraOptions;
+}
+
+// oxlint-disable-next-line max-lines-per-function
+export const useCameraManagerStore = defineStore("camera_manager", () => {
+  const viewerStore = useViewerStore();
+  // Database's table map is assembled dynamically at runtime (see internal/database/database.ts),
+  // So it's typed as `{}`; this store's table is registered before use, hence the cast.
+  // oxlint-disable-next-line no-unsafe-type-assertion -- trusted database table boundary.
+  const camera_positions_db = database.camera_positions as unknown as Table<
+    CameraPositionRecord,
+    number
+  >;
+
+  function refAllCameraPositions(): Ref<CameraPositionRecord[]> {
+    // Dexie's liveQuery() returns Dexie's own minimal Observable shape, not an
+    // Actual rxjs Observable instance (useObservable's declared parameter type);
+    // The two are structurally close enough at runtime (vueuse only calls
+    // `.subscribe`) but not identical, hence the cast.
+    return useObservable(
+      liveQuery(async () => {
+        const positions = await camera_positions_db.toArray();
+        return positions;
+        // oxlint-disable-next-line no-unsafe-type-assertion -- trusted vueuse/Dexie Observable boundary; see comment above.
+      }) as unknown as Observable<CameraPositionRecord[]>,
+      { initialValue: [] as CameraPositionRecord[] },
+    );
+  }
+
+  async function getCameraPosition(id: number): Promise<CameraPositionRecord | undefined> {
+    const position = await camera_positions_db.get(id);
+    return position;
+  }
+
+  async function saveCameraPosition(name: string, camera_options: CameraOptions): Promise<void> {
+    await camera_positions_db.put({
+      name,
+      camera_options,
+    });
+  }
+
+  async function restoreCameraPosition(id: number): Promise<void> {
+    const position = await camera_positions_db.get(id);
+    if (position) {
+      const schema = viewer_schemas.opengeodeweb_viewer.viewer.update_camera;
+      const params = { camera_options: position.camera_options };
+      await viewerStore.request({ schema, params });
+    }
+  }
+
+  async function deleteCameraPosition(id: number): Promise<void> {
+    await camera_positions_db.delete(id);
+  }
+
+  async function renameCameraPosition(id: number, newName: string): Promise<void> {
+    await camera_positions_db.update(id, { name: newName });
+  }
+
+  return {
+    refAllCameraPositions,
+    getCameraPosition,
+    saveCameraPosition,
+    restoreCameraPosition,
+    deleteCameraPosition,
+    renameCameraPosition,
+  };
+});

package/app/stores/{cloud.js → cloud.ts}

@@ -1,9 +1,6 @@
 import { Status } from "@ogw_front/utils/status";
 import { fetchSchema } from "@ogw_shared/utils/fetch_schema";
 import { setAppBaseUrl } from "@ogw_shared/scripts";
-import { useAppStore } from "./app";
-import { useFeedbackStore } from "./feedback";
-import { useInfraStore } from "./infra";
 
 import opengeodeweb_front_schemas from "@geode/opengeodeweb-front/opengeodeweb_front_schemas.json" with { type: "json" };
 
@@ -12,30 +9,39 @@ export const useCloudStore = defineStore("cloud", {
     status: Status.NOT_CONNECTED,
   }),
   actions: {
-    launch(email) {
+    async launch(email: string) {
       this.status = Status.CONNECTING;
-      console.log("[CLOUD] Launching cloud backend...");
       const schema = opengeodeweb_front_schemas.api.serverless.run_cloud;
       const params = { email };
-      console.log("[CLOUD] params", params);
+      const { useAppStore } = await import("./app");
+      const { useFeedbackStore } = await import("./feedback");
       const appStore = useAppStore();
       const feedbackStore = useFeedbackStore();
-      return fetchSchema(
+      const result = await fetchSchema(
         { schema, params },
         {
           request_error_function: () => {
             feedbackStore.$patch({ server_error: true });
             this.status = Status.NOT_CONNECTED;
           },
-          response_function: (response) => {
+          response_function: async (response: unknown) => {
+            if (
+              typeof response !== "object" ||
+              response === null ||
+              !("url" in response) ||
+              typeof response.url !== "string"
+            ) {
+              return;
+            }
+            const { url } = response;
             feedbackStore.$patch({ server_error: false });
-            console.log(`[CLOUD] Cloud launched on ${response.url}`);
             this.status = Status.CONNECTED;
+            const { useInfraStore } = await import("./infra");
             const infraStore = useInfraStore();
             infraStore.$patch({
-              domain_name: response.url,
+              domain_name: url,
             });
-            setAppBaseUrl(appStore.base_url);
+            setAppBaseUrl(appStore.base_url).catch(() => undefined);
             appStore.$patch({
               projectFolderPath: "/project",
             });
@@ -46,11 +52,10 @@ export const useCloudStore = defineStore("cloud", {
           },
         },
       );
+      return result;
     },
     connect() {
-      console.log("[CLOUD] Cloud connected");
       this.status = Status.CONNECTED;
-      return Promise.resolve();
     },
   },
   share: {