@geode/opengeodeweb-front 10.6.2 → 10.6.3-rc.1

package/app/utils/local/microservices.js

@@ -1,26 +1,26 @@
 // Node imports
-import child_process from "node:child_process"
-import fs from "node:fs"
-import path from "node:path"
+import child_process from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
 
 // Third party imports
-import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" }
-import { getPort } from "get-port-please"
-import pTimeout from "p-timeout"
+import back_schemas from "@geode/opengeodeweb-back/opengeodeweb_back_schemas.json" with { type: "json" };
+import { getPort } from "get-port-please";
+import pTimeout from "p-timeout";
 
 // Local imports
-import { commandExistsSync, waitForReady } from "./scripts.js"
-import { executableName, executablePath } from "./path.js"
-import { microservicesMetadatasPath } from "./cleanup.js"
+import { commandExistsSync, waitForReady } from "./scripts.js";
+import { executableName, executablePath } from "./path.js";
+import { microservicesMetadatasPath } from "./cleanup.js";
 
-const DEFAULT_TIMEOUT_SECONDS = 30
-const MILLISECONDS_PER_SECOND = 1000
+const DEFAULT_TIMEOUT_SECONDS = 30;
+const MILLISECONDS_PER_SECOND = 1000;
 
 function getAvailablePort() {
   return getPort({
     host: "localhost",
     random: true,
-  })
+  });
 }
 
 async function runScript(
@@ -30,126 +30,116 @@ async function runScript(
   expectedResponse,
   timeoutSeconds = DEFAULT_TIMEOUT_SECONDS,
 ) {
-  let command = ""
+  let command = "";
   if (commandExistsSync(execName)) {
-    command = execName
+    command = execName;
   } else {
-    command = path.join(executablePath(execPath), executableName(execName))
+    command = path.join(executablePath(execPath), executableName(execName));
   }
-  console.log("runScript", command, args)
+  console.log("runScript", command, args);
   const child = child_process.spawn(command, args, {
     encoding: "utf8",
     shell: true,
-  })
+  });
 
-  child.stdout.on("data", (data) =>
-    console.log(`[${execName}] ${data.toString()}`),
-  )
-  child.stderr.on("data", (data) =>
-    console.log(`[${execName}] ${data.toString()}`),
-  )
+  child.stdout.on("data", (data) => console.log(`[${execName}] ${data.toString()}`));
+  child.stderr.on("data", (data) => console.log(`[${execName}] ${data.toString()}`));
 
   child.on("error", async (error) => {
-    const electron = await import("electron")
+    const electron = await import("electron");
     electron.dialog.showMessageBox({
       title: "Title",
       type: "warning",
       message: `Error occured.\r\n${error}`,
-    })
-  })
+    });
+  });
 
-  child.on("close", (code) =>
-    console.log(`[${execName}] exited with code ${code}`),
-  )
+  child.on("close", (code) => console.log(`[${execName}] exited with code ${code}`));
   child.on("kill", () => {
-    console.log(`[${execName}] process killed`)
-  })
-  child.name = command.replace(/^.*[\\/]/, "")
+    console.log(`[${execName}] process killed`);
+  });
+  child.name = command.replace(/^.*[\\/]/, "");
 
   try {
     return await pTimeout(waitForReady(child, expectedResponse), {
       milliseconds: timeoutSeconds * MILLISECONDS_PER_SECOND,
       message: `Timed out after ${timeoutSeconds} seconds`,
-    })
+    });
   } catch (error) {
-    child.kill()
-    throw error
+    child.kill();
+    throw error;
   }
 }
 
 async function runBack(execName, execPath, args = {}) {
-  const { projectFolderPath } = args
+  const { projectFolderPath } = args;
   if (!projectFolderPath) {
-    throw new Error("projectFolderPath is required")
+    throw new Error("projectFolderPath is required");
   }
-  let { uploadFolderPath } = args
+  let { uploadFolderPath } = args;
   if (!uploadFolderPath) {
-    uploadFolderPath = path.join(projectFolderPath, "uploads")
+    uploadFolderPath = path.join(projectFolderPath, "uploads");
   }
-  const port = await getAvailablePort()
+  const port = await getAvailablePort();
   const backArgs = [
     `--port ${port}`,
     `--data_folder_path ${projectFolderPath}`,
     `--upload_folder_path ${uploadFolderPath}`,
     `--allowed_origin http://localhost:*`,
     `--timeout ${0}`,
-  ]
+  ];
   if (process.env.NODE_ENV === "development" || !process.env.NODE_ENV) {
-    backArgs.push("--debug")
+    backArgs.push("--debug");
   }
-  console.log("runBack", execName, execPath, backArgs)
-  await runScript(execName, execPath, backArgs, "Serving Flask app")
-  return port
+  console.log("runBack", execName, execPath, backArgs);
+  await runScript(execName, execPath, backArgs, "Serving Flask app");
+  return port;
 }
 
 async function runViewer(execName, execPath, args = {}) {
-  const { projectFolderPath } = args
+  const { projectFolderPath } = args;
   if (!projectFolderPath) {
-    throw new Error("projectFolderPath is required")
+    throw new Error("projectFolderPath is required");
   }
-  const port = await getAvailablePort()
+  const port = await getAvailablePort();
   const viewerArgs = [
     `--port ${port}`,
     `--data_folder_path ${projectFolderPath}`,
     `--timeout ${0}`,
-  ]
-  console.log("runViewer", execName, execPath, viewerArgs)
-  await runScript(execName, execPath, viewerArgs, "Starting factory")
-  return port
+  ];
+  console.log("runViewer", execName, execPath, viewerArgs);
+  await runScript(execName, execPath, viewerArgs, "Starting factory");
+  return port;
 }
 
 function projectMicroservices(projectFolderPath) {
-  console.log("projectMicroservices", { projectFolderPath })
-  const filePath = microservicesMetadatasPath(projectFolderPath)
+  console.log("projectMicroservices", { projectFolderPath });
+  const filePath = microservicesMetadatasPath(projectFolderPath);
 
   if (!fs.existsSync(filePath)) {
-    const microservicesMetadatas = { microservices: [] }
-    fs.writeFileSync(
-      filePath,
-      JSON.stringify(microservicesMetadatas, undefined, 2),
-      "utf8",
-    )
+    const microservicesMetadatas = { microservices: [] };
+    fs.writeFileSync(filePath, JSON.stringify(microservicesMetadatas, undefined, 2), "utf8");
   }
-  const content = JSON.parse(fs.readFileSync(filePath, "utf8"))
-  return content.microservices
+  const content = JSON.parse(fs.readFileSync(filePath, "utf8"));
+  return content.microservices;
 }
 
 function addMicroserviceMetadatas(projectFolderPath, serviceObj) {
-  const microservices = projectMicroservices(projectFolderPath)
+  const microservices = projectMicroservices(projectFolderPath);
   if (serviceObj.type === "back") {
-    const schema = back_schemas.opengeodeweb_back.kill
-    serviceObj.url = `http://localhost:${serviceObj.port}/${schema.$id}`
-    const [method] = schema.methods
-    serviceObj.method = method
+    const schema = back_schemas.opengeodeweb_back.kill;
+    serviceObj.url = `http://localhost:${serviceObj.port}/${schema.$id}`;
+    const [method] = schema.methods;
+    serviceObj.method = method;
   } else if (serviceObj.type === "viewer") {
-    serviceObj.url = `ws://localhost:${serviceObj.port}/ws`
+    serviceObj.url = `ws://localhost:${serviceObj.port}/ws`;
   }
 
-  microservices.push(serviceObj)
+  microservices.push(serviceObj);
   fs.writeFileSync(
     microservicesMetadatasPath(projectFolderPath),
     JSON.stringify({ microservices }, undefined, 2),
-  )
+  );
 }
 
-export { addMicroserviceMetadatas, getAvailablePort, runBack, runViewer }
+export { addMicroserviceMetadatas, getAvailablePort, runBack, runViewer };

package/app/utils/local/path.js

@@ -1,42 +1,39 @@
 // Node imports
-import fs from "node:fs"
-import os from "node:os"
-import path from "node:path"
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
 // Third party imports
-import { v4 as uuidv4 } from "uuid"
+import { v4 as uuidv4 } from "uuid";
 
 // Local imports
-import { appMode } from "./app_mode.js"
+import { appMode } from "./app_mode.js";
 
 function executablePath(microservicePath) {
-  console.log("[executablePath]", { microservicePath }, process.env.NODE_ENV)
-  if (
-    useRuntimeConfig().public.MODE === appMode.DESKTOP &&
-    process.env.NODE_ENV === "production"
-  ) {
-    return process.env.RESOURCES_PATH
+  console.log("[executablePath]", { microservicePath }, process.env.NODE_ENV);
+  if (useRuntimeConfig().public.MODE === appMode.DESKTOP && process.env.NODE_ENV === "production") {
+    return process.env.RESOURCES_PATH;
   }
-  return microservicePath
+  return microservicePath;
 }
 
 function executableName(name) {
   if (process.platform === "win32") {
-    return `${name}.exe`
+    return `${name}.exe`;
   }
-  return name
+  return name;
 }
 
 function createPath(dirPath) {
   if (!fs.existsSync(dirPath)) {
-    fs.mkdirSync(dirPath, { recursive: true })
-    console.log(`${dirPath} directory created successfully!`)
+    fs.mkdirSync(dirPath, { recursive: true });
+    console.log(`${dirPath} directory created successfully!`);
   }
-  return dirPath
+  return dirPath;
 }
 
 function generateProjectFolderPath(projectName) {
-  return path.join(os.tmpdir(), projectName.replace(/\//g, "_"), uuidv4())
+  return path.join(os.tmpdir(), projectName.replaceAll("/", "_"), uuidv4());
 }
 
-export { createPath, executablePath, executableName, generateProjectFolderPath }
+export { createPath, executablePath, executableName, generateProjectFolderPath };

package/app/utils/local/scripts.js

@@ -1,51 +1,51 @@
 // Node imports
-import child_process from "node:child_process"
-import fs from "node:fs"
-import { on } from "node:events"
-import path from "node:path"
+import child_process from "node:child_process";
+import fs from "node:fs";
+import { on } from "node:events";
+import path from "node:path";
 
-import { appMode } from "./app_mode.js"
+import { appMode } from "./app_mode.js";
 
 function commandExistsSync(execName) {
-  const envPath = process.env.PATH || ""
+  const envPath = process.env.PATH || "";
   return envPath.split(path.delimiter).some((dir) => {
-    const filePath = path.join(dir, execName)
-    return fs.existsSync(filePath) && fs.statSync(filePath).isFile()
-  })
+    const filePath = path.join(dir, execName);
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+  });
 }
 
 async function waitForReady(child, expectedResponse) {
   for await (const [data] of on(child.stdout, "data")) {
     if (data.toString().includes(expectedResponse)) {
-      return child
+      return child;
     }
   }
-  throw new Error("Process closed before signal")
+  throw new Error("Process closed before signal");
 }
 
 async function waitNuxt(nuxtProcess) {
   for await (const [data] of on(nuxtProcess.stdout, "data")) {
-    const output = data.toString()
-    console.log("Nuxt:", output)
-    const portMatch = output.match(/Listening on http:\/\/\[::\]:(\d+)/)
+    const output = data.toString();
+    console.log("Nuxt:", output);
+    const portMatch = output.match(/Listening on http:\/\/\[::\]:(\d+)/);
     if (portMatch) {
-      const [, nuxtPort] = portMatch
+      const [, nuxtPort] = portMatch;
 
-      console.log("Nuxt listening on port", nuxtPort)
-      return nuxtPort
+      console.log("Nuxt listening on port", nuxtPort);
+      return nuxtPort;
     }
   }
-  throw new Error("Nuxt process closed without accepting connections")
+  throw new Error("Nuxt process closed without accepting connections");
 }
 
 async function runBrowser(scriptName) {
-  process.env.MODE = appMode.BROWSER
+  process.env.MODE = appMode.BROWSER;
 
   const nuxtProcess = child_process.spawn("npm", ["run", scriptName], {
     shell: true,
     FORCE_COLOR: true,
-  })
-  return await waitNuxt(nuxtProcess)
+  });
+  return await waitNuxt(nuxtProcess);
 }
 
-export { runBrowser, waitForReady, commandExistsSync }
+export { runBrowser, waitForReady, commandExistsSync };

package/app/utils/recaptcha.js

@@ -1,24 +1,24 @@
 function check_recaptcha_params(name, email, launch) {
-  console.log("check_recaptcha_params", { name, email, launch })
+  console.log("check_recaptcha_params", { name, email, launch });
   if (name !== "") {
     return {
       statusCode: 500,
       body: JSON.stringify({ message: "INTERNAL_ERROR" }),
-    }
+    };
   }
   if (email !== "") {
     return {
       statusCode: 500,
       body: JSON.stringify({ message: "INTERNAL_ERROR" }),
-    }
+    };
   }
   if (launch !== false) {
     return {
       statusCode: 500,
       body: JSON.stringify({ message: "INTERNAL_ERROR" }),
-    }
+    };
   }
-  return { statusCode: 200, body: JSON.stringify({ message: "OK" }) }
+  return { statusCode: 200, body: JSON.stringify({ message: "OK" }) };
 }
 
-export { check_recaptcha_params }
+export { check_recaptcha_params };

package/app/utils/server.js

@@ -1,46 +1,43 @@
 // Node imports
-import fs from "node:fs"
-import path from "node:path"
+import fs from "node:fs";
+import path from "node:path";
 
 // Third party imports
-import JSZip from "jszip"
+import JSZip from "jszip";
 
-async function unzipFile(
-  zipFilePath,
-  outputDir = zipFilePath.replace(/\.[^/.]+$/, ""), // Remove the file extension
-) {
-  console.log("Unzipping file...", zipFilePath, outputDir)
+async function unzipFile(zipFilePath, outputDir = zipFilePath.replace(/\.[^/.]+$/, "")) {
+  console.log("Unzipping file...", zipFilePath, outputDir);
   try {
-    const data = await fs.promises.readFile(zipFilePath)
-    const zip = await JSZip.loadAsync(data)
-    await fs.promises.mkdir(outputDir, { recursive: true })
-    const promises = []
+    const data = await fs.promises.readFile(zipFilePath);
+    const zip = await JSZip.loadAsync(data);
+    await fs.promises.mkdir(outputDir, { recursive: true });
+    const promises = [];
 
     for (const [relativePath, zipEntry] of Object.entries(zip.files)) {
-      const outputPath = path.join(outputDir, relativePath)
+      const outputPath = path.join(outputDir, relativePath);
 
       if (zipEntry.dir) {
-        promises.push(fs.promises.mkdir(outputPath, { recursive: true }))
+        promises.push(fs.promises.mkdir(outputPath, { recursive: true }));
       } else {
         promises.push(
           (async () => {
-            const content = await zipEntry.async("nodebuffer")
+            const content = await zipEntry.async("nodebuffer");
             await fs.promises.mkdir(path.dirname(outputPath), {
               recursive: true,
-            })
-            await fs.promises.writeFile(outputPath, content)
+            });
+            await fs.promises.writeFile(outputPath, content);
           })(),
-        )
+        );
       }
     }
 
-    await Promise.all(promises)
-    console.log("Extraction complete!")
-    return outputDir
+    await Promise.all(promises);
+    console.log("Extraction complete!");
+    return outputDir;
   } catch (error) {
-    console.error("Error unzipping file:", error)
-    throw error
+    console.error("Error unzipping file:", error);
+    throw error;
   }
 }
 
-export { unzipFile }
+export { unzipFile };

package/app/utils/status.js

@@ -5,6 +5,6 @@ const Status = {
   NOT_CONNECTED: "NOT_CONNECTED",
   CONNECTING: "CONNECTING",
   CONNECTED: "CONNECTED",
-}
+};
 
-export { Status }
+export { Status };

package/app/utils/treeview.js

@@ -1,7 +1,7 @@
 function compareSelections(current, previous) {
-  const added = current.filter((item) => !previous.includes(item))
-  const removed = previous.filter((item) => !current.includes(item))
-  return { added, removed }
+  const added = current.filter((item) => !previous.includes(item));
+  const removed = previous.filter((item) => !current.includes(item));
+  return { added, removed };
 }
 
-export { compareSelections }
+export { compareSelections };

package/app/utils/validate_schema.js

@@ -1,13 +1,13 @@
-import Ajv from "ajv"
+import Ajv from "ajv";
 
 function validate_schema(schema, body) {
-  const ajv = new Ajv()
-  const list_keywords = ["methods", "route", "max_retry", "rpc"]
+  const ajv = new Ajv();
+  const list_keywords = ["methods", "route", "max_retry", "rpc"];
   for (const keyword of list_keywords) {
-    ajv.addKeyword(keyword)
+    ajv.addKeyword(keyword);
   }
-  const valid = ajv.validate(schema, body)
-  return { valid, error: ajv.errorsText() }
+  const valid = ajv.validate(schema, body);
+  return { valid, error: ajv.errorsText() };
 }
 
-export { validate_schema }
+export { validate_schema };

package/commitlint.config.js

@@ -14,6 +14,6 @@ const Configuration = {
     "type-empty": [0],
     "type-enum": [2, "always", ["feat", "fix", "perf"]],
   },
-}
+};
 
-export default Configuration
+export default Configuration;

package/eslint.config.js

@@ -1,6 +1,6 @@
-import nuxt from "eslint-plugin-nuxt"
-import vue from "eslint-plugin-vue"
-import vuetify from "eslint-plugin-vuetify"
+import nuxt from "eslint-plugin-nuxt";
+import vue from "eslint-plugin-vue";
+import vuetify from "eslint-plugin-vuetify";
 
 // oxlint-disable-next-line import/no-anonymous-default-export
 export default [
@@ -25,4 +25,4 @@ export default [
       ...nuxt.configs.recommended.rules,
     },
   },
-]
+];

package/internal/database/database.js

@@ -1,92 +1,84 @@
-import { Dexie } from "dexie"
-import { ExtendedDatabase } from "./extended_database"
-import { dataTable } from "./tables/data"
-import { modelComponentsRelationTable } from "./tables/model_components_relation"
-import { modelComponentsTable } from "./tables/model_components"
+import { Dexie } from "dexie";
+import { ExtendedDatabase } from "./extended_database";
+import { dataTable } from "./tables/data";
+import { modelComponentsRelationTable } from "./tables/model_components_relation";
+import { modelComponentsTable } from "./tables/model_components";
 
 class Database extends Dexie {
   constructor() {
-    super("Database")
+    super("Database");
 
     this.version(1).stores({
       [dataTable.name]: dataTable.schema,
       [modelComponentsTable.name]: modelComponentsTable.schema,
       [modelComponentsRelationTable.name]: modelComponentsRelationTable.schema,
-    })
+    });
   }
 
   static async addTable(tableName, schemaDefinition) {
-    await this.addTables({ [tableName]: schemaDefinition })
+    await this.addTables({ [tableName]: schemaDefinition });
   }
 
   static async addTables(newTables) {
-    const tempDb = new Dexie("Database")
-    await tempDb.open()
+    const tempDb = new Dexie("Database");
+    await tempDb.open();
 
-    const currentVersion = tempDb.verno
-    const currentStores = {}
-
-    currentStores[dataTable.name] = dataTable.schema
-    currentStores[modelComponentsTable.name] = modelComponentsTable.schema
-    currentStores[modelComponentsRelationTable.name] =
-      modelComponentsRelationTable.schema
+    const currentVersion = tempDb.verno;
+    const currentStores = {
+      [dataTable.name]: dataTable.schema,
+      [modelComponentsTable.name]: modelComponentsTable.schema,
+      [modelComponentsRelationTable.name]: modelComponentsRelationTable.schema,
+    };
 
     for (const table of tempDb.tables) {
-      const keyPath = table.schema.primKey.src
-      const indexes = table.schema.indexes.map((index) => index.src)
-      const parts = keyPath ? [keyPath, ...indexes] : indexes
-      currentStores[table.name] = parts.join(",")
+      const keyPath = table.schema.primKey.src;
+      const indexes = table.schema.indexes.map((index) => index.src);
+      const parts = keyPath ? [keyPath, ...indexes] : indexes;
+      currentStores[table.name] = parts.join(",");
     }
 
-    tempDb.close()
+    tempDb.close();
 
-    const allExisting = Object.keys(newTables).every(
-      (tableName) => currentStores[tableName],
-    )
+    const allExisting = Object.keys(newTables).every((tableName) => currentStores[tableName]);
 
-    databaseContainer.instance.close()
+    databaseContainer.instance.close();
 
     if (allExisting) {
-      const existingDb = new Dexie("Database")
+      const existingDb = new Dexie("Database");
       for (let version = 1; version <= currentVersion; version += 1) {
         if (version === 1) {
           existingDb.version(1).stores({
             [dataTable.name]: dataTable.schema,
             [modelComponentsTable.name]: modelComponentsTable.schema,
-            [modelComponentsRelationTable.name]:
-              modelComponentsRelationTable.schema,
-          })
+            [modelComponentsRelationTable.name]: modelComponentsRelationTable.schema,
+          });
         } else {
-          existingDb.version(version).stores(currentStores)
+          existingDb.version(version).stores(currentStores);
         }
       }
-      await existingDb.open()
-      databaseContainer.instance = existingDb
+      await existingDb.open();
+      databaseContainer.instance = existingDb;
     } else {
-      const newDb = new ExtendedDatabase(
-        currentVersion,
-        currentStores,
-        newTables,
-      )
-      await newDb.open()
-      databaseContainer.instance = newDb
+      const newDb = new ExtendedDatabase(currentVersion, currentStores, newTables);
+      await newDb.open();
+      databaseContainer.instance = newDb;
     }
   }
 }
 
-const databaseContainer = { instance: new Database() }
+const databaseContainer = { instance: new Database() };
 
 const database = new Proxy(
   {},
   {
     get(target, prop) {
-      const value = databaseContainer.instance[prop]
+      const value = databaseContainer.instance[prop];
       if (typeof value === "function") {
-        return value.bind(databaseContainer.instance)
+        return value.bind(databaseContainer.instance);
       }
-      return value
+      return value;
     },
   },
-)
+);
 
-export { Database, database }
+export { Database, database };