@geode/opengeodeweb-front 10.34.0-rc.8 → 10.34.0

package/app/stores/app.ts

@@ -1,11 +1,9 @@
-// This file grew past the 310-line limit purely from added type annotations/interfaces during the TypeScript migration, with no new logic.
-// oxlint-disable eslint/max-lines
 // Local imports
 import { getRestApiPort, getRestApiProtocol, isCloudMode } from "@ogw_front/utils/stores.js";
 import { Status } from "@ogw_front/utils/status";
 import { api_fetch } from "@ogw_internal/utils/api_fetch.js";
-import { killExtension } from "@ogw_front/utils/extension.js";
 import { upload_file } from "@ogw_internal/utils/upload_file.js";
+import { useAppExtensions } from "./app_helpers/extension.js";
 import { useInfraStore } from "@ogw_front/stores/infra";
 
 import type { JsonRpcSchema, RequestHandlers } from "@ogw_shared/utils/types.js";
@@ -27,31 +25,11 @@ interface RegisterableStore {
   $patch?: (partial: Record<string, unknown>) => void;
   exportStores?: (params?: Record<string, unknown>) => Promise<unknown>;
   importStores?: (snapshot: unknown) => Promise<void> | void;
+  connect?: () => Promise<void>;
+  kill?: () => Promise<void>;
   [key: string]: unknown;
 }
 
-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 const useAppStore = defineStore("app", () => {
   const stores: RegisterableStore[] = [];
@@ -79,9 +57,6 @@ export const useAppStore = defineStore("app", () => {
       globalComponents.value.set(extensionId, new Map());
     }
     globalComponents.value.get(extensionId)?.set(componentId, component);
-    console.log(
-      `[AppStore] Registered global component ${componentId} for extension ${extensionId}`,
-    );
   }
 
   function unregisterGlobalComponent(extensionId: string, componentId: string): void {
@@ -91,12 +66,12 @@ export const useAppStore = defineStore("app", () => {
   }
 
   function registerStore(store: RegisterableStore): void {
-    const isAlreadyRegistered = stores.some((registeredStore) => registeredStore.$id === store.$id);
+    const isAlreadyRegistered = stores.some(
+      (registeredStore: RegisterableStore) => registeredStore.$id === store.$id,
+    );
     if (isAlreadyRegistered) {
-      console.log(`[AppStore] Store "${store.$id}" already registered, skipping`);
       return;
     }
-    console.log("[AppStore] Registering store", store.$id);
     stores.push(store);
   }
 
@@ -104,212 +79,106 @@ export const useAppStore = defineStore("app", () => {
     params: Record<string, unknown> = {},
   ): Promise<Record<string, unknown>> {
     const snapshot: Record<string, unknown> = {};
-    let exportCount = 0;
 
-    console.log(`[AppStore] Exporting stores, total registered: ${stores.length}`);
     await Promise.all(
-      stores.map(async (store) => {
+      stores.map(async (store: RegisterableStore) => {
         if (!store.exportStores) {
           return;
         }
         const storeId = store.$id;
         try {
           snapshot[storeId] = await store.exportStores(params);
-          exportCount += 1;
-        } catch (error) {
-          console.error(`[AppStore] Error exporting store "${storeId}":`, error);
+        } catch {
+          // Ignore stores that fail to export; other stores still complete independently.
         }
       }),
     );
-    console.log(`[AppStore] Exported ${exportCount} stores; snapshot keys:`, Object.keys(snapshot));
     return snapshot;
   }
 
   async function importStores(snapshot: Record<string, unknown> | undefined): Promise<void> {
     if (!snapshot) {
-      console.warn("[AppStore] import called with invalid snapshot");
       return;
     }
-    console.log("[AppStore] Import snapshot keys:", Object.keys(snapshot || {}));
 
-    let importedCount = 0;
-    const notFoundStores: string[] = [];
+    const missingStoreIds: string[] = [];
+
     await Promise.all(
-      stores.map(async (store) => {
+      stores.map(async (store: RegisterableStore) => {
         if (!store.importStores) {
           return;
         }
         const storeId = store.$id;
-        if (!snapshot[storeId]) {
-          notFoundStores.push(storeId);
+        if (snapshot[storeId] === undefined) {
+          missingStoreIds.push(storeId);
           return;
         }
         try {
           await store.importStores(snapshot[storeId]);
-          importedCount += 1;
-        } catch (error) {
-          console.error(`[AppStore] Error importing store "${storeId}":`, error);
+        } catch {
+          // Ignore stores that fail to import; other stores still complete independently.
         }
       }),
     );
-    if (notFoundStores.length > 0) {
-      console.warn(`[AppStore] Stores not found in snapshot: ${notFoundStores.join(", ")}`);
-    }
-    console.log(`[AppStore] Imported ${importedCount} stores`);
-  }
-
-  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 | undefined = undefined,
-  ): 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
-      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) {
-        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;
+    if (missingStoreIds.length > 0) {
+      console.warn(`Stores not found in snapshot: ${missingStoreIds.join(", ")}`);
     }
   }
 
-  function getLoadedExtensions(): ExtensionData[] {
-    return [...loadedExtensions.value.values()];
-  }
-
-  async function unloadExtension(extensionId: string): Promise<boolean> {
-    console.log(`[AppStore] Unloading extension: ${extensionId}`);
-    const infraStore = useInfraStore();
-    await 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;
-  }
+  const {
+    loadedExtensions,
+    extensionAPI,
+    setExtensionAPI,
+    setCodeTransformer,
+    getExtension,
+    loadExtension,
+    getLoadedExtensions,
+    unloadExtension,
+    toggleExtension,
+    setExtensionEnabled,
+    getExtensionEnabled,
+  } = useAppExtensions();
 
-  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;
+  const request_counter = ref(0);
+  function start_request(): void {
+    request_counter.value += 1;
   }
-
-  function getExtensionEnabled(extensionId: string): boolean {
-    return getExtension(extensionId)?.enabled ?? false;
+  function stop_request(): void {
+    request_counter.value -= 1;
   }
+  const is_busy = computed(() => request_counter.value > 0);
 
-  function upload(file: File, callbacks: RequestHandlers = {}) {
-    const store = useAppStore();
+  async function upload(file: Readonly<File>, callbacks: RequestHandlers = {}): Promise<unknown> {
     const schema = opengeodeweb_front_schemas.api.local.extensions.upload;
     const { PROJECT: projectName } = useRuntimeConfig().public;
     const params = { projectName };
-    return upload_file(
-      store,
+    const result = await upload_file(
+      { $id: "app", base_url: base_url.value, start_request, stop_request },
       { schema, file, params },
       {
         ...callbacks,
         response_function: async (response: unknown) => {
-          console.log("[APP] Request completed:", schema.$id);
           if (callbacks.response_function) {
             await callbacks.response_function(response);
           }
         },
       },
     );
+    return result;
   }
 
-  function request(
+  // `TResult` is asserted, not verified, at the single `return result as TResult` boundary below: the backend response is only checked against `schema` at runtime, so callers' `TResult` is a contract with the schema, not something this function can prove.
+  // oxlint-disable-next-line unicorn/consistent-function-scoping
+  // oxlint-disable-next-line unicorn/consistent-function-scoping
+  async function request<TResult = unknown>(
     { schema, params }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
     callbacks: RequestHandlers = {},
-  ) {
-    const store = useAppStore();
-    return api_fetch(
-      store,
+  ): Promise<TResult> {
+    const result = await api_fetch(
+      { $id: "app", base_url: base_url.value, start_request, stop_request },
       // The app store is only ever used with HTTP ("front") schemas, which always carry `methods`; the wider JsonRpcSchema param above is kept as-is to match this action's public signature (e.g. relayed from get_version-style callers that only know about the shared, looser schema shape).
+      // oxlint-disable-next-line no-unsafe-type-assertion -- narrowing optional `methods` to required is safe here; see comment above.
       { schema: schema as JsonRpcSchema & { methods: string[] }, params },
       {
         ...callbacks,
@@ -320,35 +189,29 @@ export const useAppStore = defineStore("app", () => {
         },
       },
     );
+    // oxlint-disable-next-line no-unsafe-type-assertion -- this is the trusted API boundary; see comment above.
+    return result as TResult;
   }
 
-  const request_counter = ref(0);
-  function start_request(): void {
-    request_counter.value += 1;
-  }
-  function stop_request(): void {
-    request_counter.value -= 1;
-  }
-  const is_busy = computed(() => request_counter.value > 0);
-
   const projectFolderPath = ref("");
 
-  function createProjectFolder() {
+  async function createProjectFolder(): Promise<unknown> {
     const { PROJECT } = useRuntimeConfig().public;
     const schema = opengeodeweb_front_schemas.api.local.app.project_folder_path;
     const params = { PROJECT };
-    return request(
+    const result = await request(
       { schema, params },
       {
         response_function: (response: unknown) => {
+          // oxlint-disable-next-line no-unsafe-type-assertion
           const { projectFolderPath: newProjectFolderPath } = response as {
             projectFolderPath: string;
           };
-          console.log(`[APP] ${newProjectFolderPath} created`);
           projectFolderPath.value = newProjectFolderPath;
         },
       },
     );
+    return result;
   }
 
   return {
@@ -385,3 +248,5 @@ export const useAppStore = defineStore("app", () => {
     unregisterGlobalComponent,
   };
 });
+
+export type { RegisterableStore };

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.ts

@@ -42,15 +42,17 @@ export const useBackStore = defineStore("back", {
   },
   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: () => {
@@ -67,6 +69,7 @@ export const useBackStore = defineStore("back", {
           },
         },
       );
+      return result;
     },
     start_request() {
       this.request_counter += 1;
@@ -74,39 +77,43 @@ export const useBackStore = defineStore("back", {
     stop_request() {
       this.request_counter -= 1;
     },
-    launch(args: Record<string, unknown>) {
-      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: unknown) => {
-            const { port } = response as { port: string };
-            console.log(`[GEODE] Back launched on port ${port}`);
-            this.default_local_port = port;
+            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(
+    async request(
       { schema, params = {} }: { schema: JsonRpcSchema; params?: Record<string, unknown> },
       callbacks: RequestHandlers = {},
     ) {
-      return api_fetch(
+      const result = await api_fetch(
         this,
         // 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,
@@ -117,10 +124,11 @@ export const useBackStore = defineStore("back", {
           },
         },
       );
+      return result;
     },
-    upload(file: File, callbacks: RequestHandlers = {}) {
+    async upload(file: File, callbacks: RequestHandlers = {}) {
       const schema = back_schemas.opengeodeweb_back.upload_file;
-      return upload_file(
+      const result = await upload_file(
         this,
         {
           schema,
@@ -135,20 +143,28 @@ export const useBackStore = defineStore("back", {
           },
         },
       );
+      return result;
     },
-    get_version(schema: JsonRpcSchema | undefined) {
+    async get_version(schema: JsonRpcSchema | undefined) {
       if (!schema) {
-        return;
+        return undefined;
       }
-      return this.request(
+      const result = await this.request(
         { schema },
         {
           response_function: (response: unknown) => {
-            const { microservice_version } = response as { microservice_version: string };
-            this.version = microservice_version;
+            if (
+              typeof response === "object" &&
+              response !== null &&
+              "microservice_version" in response &&
+              typeof response.microservice_version === "string"
+            ) {
+              this.version = response.microservice_version;
+            }
           },
         },
       );
+      return result;
     },
   },
   share: {