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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geode/opengeodeweb-front",
-  "version": "10.34.0-rc.2",
+  "version": "10.34.0-rc.21",
   "description": "OpenSource Vue/Nuxt/Pinia/Vuetify framework for web applications",
   "homepage": "https://github.com/Geode-solutions/OpenGeodeWeb-Front",
   "bugs": {
@@ -16,37 +16,60 @@
     "type": "git",
     "url": "git+https://github.com/Geode-solutions/OpenGeodeWeb-Front.git"
   },
+  "files": [
+    "app",
+    "internal",
+    "server",
+    "shared",
+    ".build",
+    "nuxt.config.ts",
+    "opengeodeweb_front_schemas.json",
+    "opengeodeweb_front_schemas.js",
+    "COPYLEFT",
+    "LICENSE",
+    "README.md"
+  ],
   "type": "module",
-  "main": "./nuxt.config.js",
+  "main": "./nuxt.config.ts",
   "exports": {
-    ".": "./nuxt.config.js",
+    ".": "./nuxt.config.ts",
+    "./server/utils/*.js": {
+      "types": "./server/utils/*.ts",
+      "default": "./.build/server/utils/*.js"
+    },
+    "./shared/*.js": {
+      "types": "./shared/*.ts",
+      "default": "./.build/shared/*.js"
+    },
     "./*": "./*"
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "lint": "eslint --fix --ext .js,.vue --ignore-path .gitignore .",
+    "lint": "oxlint --fix .",
+    "typecheck": "nuxt typecheck && tsc -p tsconfig.tests.json --noEmit",
     "build:back": "npx opengeodeweb-microservice-pyinstaller ../OpenGeodeWeb-Back",
     "build:viewer": "npx opengeodeweb-microservice-pyinstaller ../OpenGeodeWeb-Viewer",
     "build:microservices": "concurrently \"npm run build:back\" \"npm run build:viewer\"",
     "json": "npx opengeodeweb-microservice-generate --startDir server/api --key route --separator / --prefix api",
     "test": "npm run test:unit",
-    "tests": "vitest --config ./tests/vitest.config.js",
+    "tests": "nuxt prepare && vitest --config ./tests/vitest.config.ts",
     "test:unit": "npm run tests -- --project unit",
     "test:integration": "npm run tests -- --project integration",
-    "geode_objects": "node scripts/generate_geode_objects.js && prettier ./assets/geode_objects.js --write",
-    "build": ""
+    "geode_objects": "tsx scripts/generate_geode_objects.ts && prettier ./assets/geode_objects.ts --write",
+    "build": "nuxt prepare && rolldown -c rolldown.config.ts",
+    "prepublishOnly": "npm run build"
   },
   "dependencies": {
     "@geode/opengeodeweb-back": "next",
     "@geode/opengeodeweb-viewer": "next",
-    "@google-cloud/run": "3.2.0",
+    "@google-cloud/run": "4.1.0",
     "@kitware/vtk.js": "33.3.0",
     "@mdi/font": "7.4.47",
     "@pinia/nuxt": "1.0.1",
-    "@types/node": "22.15.3",
     "@vueuse/components": "13.1.0",
+    "@vueuse/core": "13.1.0",
     "@vueuse/nuxt": "13.1.0",
     "@vueuse/rxjs": "14.1.0",
     "ajv": "8.17.1",
@@ -54,12 +77,14 @@
     "conf": "15.1.0",
     "dexie": "4.2.1",
     "get-port-please": "3.2.0",
-    "google-auth-library": "10.6.1",
-    "googleapis": "171.4.0",
+    "google-auth-library": "11.0.2",
+    "googleapis": "181.0.0",
     "js-file-download": "0.4.12",
     "jszip": "3.10.1",
+    "lodash": "4.18.1",
     "node-stream-zip": "1.15.0",
     "nuxt": "4.5.1",
+    "ofetch": "1.5.1",
     "p-timeout": "7.0.1",
     "pinia": "4.0.2",
     "rimraf": "6.1.3",
@@ -72,23 +97,34 @@
     "vuetify": "4.2.0",
     "vuetify-nuxt-module": "1.0.0-rc.5",
     "ws": "8.21.2",
-    "wslink": "1.12.4"
+    "wslink": "1.12.4",
+    "zod": "4.4.3"
   },
   "devDependencies": {
     "@nuxt/test-utils": "4.1.0",
     "@pinia/testing": "2.0.1",
+    "@types/busboy": "1.5.4",
+    "@types/lodash": "4.17.25",
+    "@types/node": "22.20.3",
+    "@types/ws": "8.18.1",
     "@vitejs/plugin-vue": "6.0.8",
     "@vue/test-utils": "2.4.11",
     "happy-dom": "20.0.11",
     "msw": "2.11.1",
+    "oxlint": "1.82.0",
     "playwright-core": "1.52.0",
+    "prettier": "3.8.1",
     "resize-observer-polyfill": "1.5.1",
+    "rolldown": "1.2.8",
+    "tsx": "4.23.13",
+    "typescript": "5.9.3",
     "unplugin-auto-import": "20.0.0",
     "vite": "8.2.0",
     "vite-plugin-vuetify": "2.1.3",
     "vitest": "4.1.10",
     "vitest-environment-nuxt": "2.0.0",
-    "vitest-indexeddb": "0.0.1"
+    "vitest-indexeddb": "0.0.1",
+    "vue-tsc": "3.3.11"
   },
   "overrides": {
     "vue": "3.5.40"

package/server/api/cloud/extensions/{run.post.js → run.post.ts}

@@ -2,32 +2,36 @@
 import fs from "node:fs";
 
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import {
   addMicroserviceMetadatas,
   runExtension,
-} from "@geode/opengeodeweb-front/server/utils/microservices.js";
+} from "@geode/opengeodeweb-front/server/utils/microservices.ts";
 import {
   extensionBackendPath,
   extensionFolderPath,
-} from "@geode/opengeodeweb-front/server/utils/path.js";
+} from "@geode/opengeodeweb-front/server/utils/path.ts";
 import {
   readExtensionFrontend,
   readExtensionMetadata,
-} from "@geode/opengeodeweb-front/server/utils/extension.js";
-import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.js";
-import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.js";
+} from "@geode/opengeodeweb-front/server/utils/extension.ts";
+import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.ts";
+import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.ts";
 
-export default defineEventHandler(async (event) => {
+interface RunExtensionsBody {
+  projectFolderPath: string;
+  projectName: string;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
   try {
     console.log("NITRO: runExtensions", event);
-    const { projectFolderPath, projectName } = await readBody(event);
+    const { projectFolderPath, projectName } = await readBody<RunExtensionsBody>(event);
     const extensionsConfig = extensionsConf(projectName);
     const extensionsArray = await Promise.all(
-      Object.keys(extensionsConfig).map(async (extensionId) => {
-        const extensionPath = extensionsConfig[extensionId].path;
+      Object.entries(extensionsConfig).map(async ([extensionId, { path: extensionPath }]) => {
         const unzippedExtensionPath = await unzipFile(
           extensionPath,
           extensionFolderPath(projectFolderPath, extensionId),
@@ -43,7 +47,7 @@ export default defineEventHandler(async (event) => {
         const port = await runExtension(id, backendExecutable, unzippedExtensionPath, {
           projectFolderPath,
         });
-        await addMicroserviceMetadatas(projectFolderPath, {
+        addMicroserviceMetadatas(projectFolderPath, {
           type: "back",
           name,
           port,
@@ -66,7 +70,7 @@ export default defineEventHandler(async (event) => {
     console.error("Error running extensions:", error);
     throw createError({
       statusCode: 500,
-      statusMessage: error.message,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/local/app/project_folder_path.post.ts

@@ -0,0 +1,33 @@
+// Node imports
+
+// Third party imports
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import {
+  createPath,
+  generateProjectFolderPath,
+} from "@geode/opengeodeweb-front/server/utils/path.ts";
+
+interface ProjectFolderPathBody {
+  PROJECT: string;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  try {
+    const { PROJECT } = await readBody<ProjectFolderPathBody>(event);
+    const projectFolderPath = generateProjectFolderPath(PROJECT);
+    createPath(projectFolderPath);
+
+    return {
+      statusCode: 200,
+      projectFolderPath,
+    };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
+    });
+  }
+});

package/server/api/local/app/run_back.post.ts

@@ -0,0 +1,39 @@
+// Node imports
+
+// Third party imports
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import {
+  addMicroserviceMetadatas,
+  runBack,
+} from "@geode/opengeodeweb-front/server/utils/microservices.ts";
+
+interface RunBackBody {
+  COMMAND_BACK: string;
+  NUXT_ROOT_PATH: string;
+  args: { projectFolderPath: string; [key: string]: unknown };
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  try {
+    const { COMMAND_BACK, NUXT_ROOT_PATH, args } = await readBody<RunBackBody>(event);
+    const port = await runBack(COMMAND_BACK, NUXT_ROOT_PATH, args);
+    addMicroserviceMetadatas(args.projectFolderPath, {
+      type: "back",
+      name: COMMAND_BACK,
+      port,
+    });
+
+    return {
+      statusCode: 200,
+      port,
+    };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
+    });
+  }
+});

package/server/api/local/app/run_viewer.post.ts

@@ -0,0 +1,39 @@
+// Node imports
+
+// Third party imports
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import {
+  addMicroserviceMetadatas,
+  runViewer,
+} from "@geode/opengeodeweb-front/server/utils/microservices.ts";
+
+interface RunViewerBody {
+  COMMAND_VIEWER: string;
+  NUXT_ROOT_PATH: string;
+  args: { projectFolderPath: string; [key: string]: unknown };
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  try {
+    const { COMMAND_VIEWER, NUXT_ROOT_PATH, args } = await readBody<RunViewerBody>(event);
+    const port = await runViewer(COMMAND_VIEWER, NUXT_ROOT_PATH, args);
+    addMicroserviceMetadatas(args.projectFolderPath, {
+      type: "viewer",
+      name: COMMAND_VIEWER,
+      port,
+    });
+
+    return {
+      statusCode: 200,
+      port,
+    };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
+    });
+  }
+});

package/server/api/local/extensions/{kill.post.js → kill.post.ts}

@@ -1,7 +1,7 @@
 // Node imports
 
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import {
@@ -9,13 +9,19 @@ import {
   getMicroserviceByName,
   killMicroservice,
   projectMicroservices,
-} from "@geode/opengeodeweb-front/server/utils/cleanup.js";
-import { extensionFolderPath } from "@geode/opengeodeweb-front/server/utils/path.js";
-import { removeExtensionFromConf } from "@geode/opengeodeweb-front/server/utils/app_config.js";
+} from "@geode/opengeodeweb-front/server/utils/cleanup.ts";
+import { extensionFolderPath } from "@geode/opengeodeweb-front/server/utils/path.ts";
+import { removeExtensionFromConf } from "@geode/opengeodeweb-front/server/utils/app_config.ts";
 
-export default defineEventHandler(async (event) => {
+interface KillExtensionBody {
+  projectFolderPath: string;
+  projectName: string;
+  extensionId: string;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
   try {
-    const body = await readBody(event);
+    const body = await readBody<KillExtensionBody>(event);
     const { projectFolderPath, projectName, extensionId } = body;
 
     console.log({ projectFolderPath, projectName, extensionId });
@@ -27,7 +33,7 @@ export default defineEventHandler(async (event) => {
     }
 
     await removeExtensionFromConf(projectName, extensionId);
-    await killMicroservice(microservice, microservices);
+    await killMicroservice(microservice);
     await deleteFolderRecursive(extensionFolderPath(projectFolderPath, extensionId));
 
     return {
@@ -37,7 +43,8 @@ export default defineEventHandler(async (event) => {
     console.error("Error killing extension:", error);
     throw createError({
       statusCode: 500,
-      statusMessage: error.message,
+
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/local/extensions/{run.post.js → run.post.ts}

@@ -2,32 +2,36 @@
 import fs from "node:fs";
 
 // Third party imports
-import { createError, defineEventHandler, readBody } from "h3";
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
 
 // Local imports
 import {
   addMicroserviceMetadatas,
   runBack,
-} from "@geode/opengeodeweb-front/server/utils/microservices.js";
+} from "@geode/opengeodeweb-front/server/utils/microservices.ts";
 import {
   extensionBackendPath,
   extensionFolderPath,
-} from "@geode/opengeodeweb-front/server/utils/path.js";
+} from "@geode/opengeodeweb-front/server/utils/path.ts";
 import {
   readExtensionFrontend,
   readExtensionMetadata,
-} from "@geode/opengeodeweb-front/server/utils/extension.js";
-import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.js";
-import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.js";
+} from "@geode/opengeodeweb-front/server/utils/extension.ts";
+import { extensionsConf } from "@geode/opengeodeweb-front/server/utils/app_config.ts";
+import { unzipFile } from "@geode/opengeodeweb-front/server/utils/server.ts";
 
-export default defineEventHandler(async (event) => {
+interface RunExtensionsBody {
+  projectFolderPath: string;
+  projectName: string;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
   try {
     console.log("NITRO: runExtensions", event);
-    const { projectFolderPath, projectName } = await readBody(event);
+    const { projectFolderPath, projectName } = await readBody<RunExtensionsBody>(event);
     const extensionsConfig = extensionsConf(projectName);
     const extensionsArray = await Promise.all(
-      Object.keys(extensionsConfig).map(async (extensionId) => {
-        const extensionPath = extensionsConfig[extensionId].path;
+      Object.entries(extensionsConfig).map(async ([extensionId, { path: extensionPath }]) => {
         const unzippedExtensionPath = await unzipFile(
           extensionPath,
           extensionFolderPath(projectFolderPath, extensionId),
@@ -43,7 +47,7 @@ export default defineEventHandler(async (event) => {
         const port = await runBack(backendExecutable, unzippedExtensionPath, {
           projectFolderPath,
         });
-        await addMicroserviceMetadatas(projectFolderPath, {
+        addMicroserviceMetadatas(projectFolderPath, {
           type: "back",
           name,
           port,
@@ -66,7 +70,8 @@ export default defineEventHandler(async (event) => {
     console.error("Error running extensions:", error);
     throw createError({
       statusCode: 500,
-      statusMessage: error.message,
+
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/local/extensions/upload.put.ts

@@ -0,0 +1,71 @@
+// Node imports
+import { Readable } from "node:stream";
+import fs from "node:fs";
+import { pipeline } from "node:stream/promises";
+
+// Third party imports
+import { type H3Event, createError, defineEventHandler, getQuery, getRequestWebStream } from "h3";
+
+// Local imports
+import {
+  registerExtensionFile,
+  targetExtensionFilePath,
+} from "@geode/opengeodeweb-front/server/utils/app_config.ts";
+import { BYTES_PER_KIBIBYTE } from "@ogw_shared/utils/file.js";
+import { toNodeWebStream } from "@geode/opengeodeweb-front/server/utils/stream.ts";
+
+const CODE_200 = 200;
+const CODE_201 = 201;
+const MAX_FILE_MEGABYTES = 500;
+const FILE_SIZE_LIMIT = MAX_FILE_MEGABYTES * BYTES_PER_KIBIBYTE * BYTES_PER_KIBIBYTE;
+
+function requiredQueryString(event: H3Event, key: string): string {
+  const value = getQuery(event)[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw createError({ statusCode: 400, message: `Missing "${key}" query parameter` });
+  }
+  return value;
+}
+
+function requiredQueryInt(event: H3Event, key: string): number {
+  const parsed = Math.trunc(Number(requiredQueryString(event, key)));
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw createError({ statusCode: 400, message: `Invalid "${key}" query parameter` });
+  }
+  return parsed;
+}
+
+// The file is sent as a raw (non-multipart) body, split into sequential chunks the client uploads in order (see OpenGeodeWeb-Front's upload_file.ts and OpenGeodeWeb-Back's upload_file route, which use the same protocol). Each chunk is appended to a `.part` file; the last one triggers the existing zip-metadata registration.
+export default defineEventHandler(async (event: H3Event) => {
+  const projectName = requiredQueryString(event, "projectName");
+  const filename = requiredQueryString(event, "filename");
+  const totalChunks = requiredQueryInt(event, "total_chunks");
+  const chunkIndex = requiredQueryInt(event, "chunk_index");
+  if (chunkIndex >= totalChunks) {
+    throw createError({ statusCode: 400, message: "chunk_index must be less than total_chunks" });
+  }
+
+  const webStream = getRequestWebStream(event);
+  if (!webStream) {
+    throw createError({ statusCode: 400, message: "No request body received" });
+  }
+
+  const targetPath = targetExtensionFilePath(projectName, filename);
+  const partPath = `${targetPath}.part`;
+  const writeStream = fs.createWriteStream(partPath, { flags: chunkIndex === 0 ? "w" : "a" });
+  await pipeline(Readable.fromWeb(toNodeWebStream(webStream)), writeStream);
+
+  const { size } = await fs.promises.stat(partPath);
+  if (size > FILE_SIZE_LIMIT) {
+    await fs.promises.unlink(partPath);
+    throw createError({ statusCode: 400, message: "File too large" });
+  }
+
+  if (chunkIndex < totalChunks - 1) {
+    return { statusCode: CODE_200 };
+  }
+
+  await fs.promises.rename(partPath, targetPath);
+  await registerExtensionFile(projectName, targetPath);
+  return { statusCode: CODE_201 };
+});

package/server/api/microservice/app/{get_is_app_ready.get.js → get_is_app_ready.get.ts}

@@ -2,18 +2,18 @@
 import { createError, defineEventHandler } from "h3";
 
 // Local imports
-import { getIsAppReady } from "@geode/opengeodeweb-front/server/utils/server_config.js";
+import { getIsAppReady } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
 
-export default defineEventHandler(async () => {
+export default defineEventHandler(() => {
   try {
-    const isReady = await getIsAppReady();
+    const isReady = getIsAppReady();
     console.log(`IS_APP_READY is ${isReady}`);
     return { statusCode: 200, isReady };
   } catch (error) {
     console.log(error);
     throw createError({
-      statusCode: error.statusCode,
-      statusMessage: error.statusMessage ?? error.message,
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
     });
   }
 });

package/server/api/microservice/app/schemas/get_is_app_ready.json

@@ -1,5 +1,5 @@
 {
-  "route": "/api/microservice/app/get_is_app_ready",
+  "route": "/get_is_app_ready",
   "methods": ["GET"],
   "type": "object",
   "properties": {},

package/server/api/microservice/app/set_app_base_url.post.ts

@@ -0,0 +1,29 @@
+// Third party imports
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import { setAppBaseUrl } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
+
+interface SetAppBaseUrlBody {
+  baseUrl: string;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  try {
+    const { baseUrl } = await readBody<SetAppBaseUrlBody>(event);
+    if (!baseUrl) {
+      throw createError({ statusCode: 400, statusMessage: "baseUrl is required" });
+    }
+
+    setAppBaseUrl(baseUrl);
+    console.log(`Updated APP_BASE_URL to ${baseUrl}`);
+
+    return { statusCode: 200, baseUrl };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
+    });
+  }
+});

package/server/api/microservice/app/set_back_base_url.post.ts

@@ -0,0 +1,26 @@
+// Third party imports
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import { setBackBaseUrl } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
+
+interface SetBackBaseUrlBody {
+  baseUrl: string;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  try {
+    const { baseUrl } = await readBody<SetBackBaseUrlBody>(event);
+    if (!baseUrl) {
+      throw createError({ statusCode: 400, statusMessage: "baseUrl is required" });
+    }
+    setBackBaseUrl(baseUrl);
+    return { statusCode: 200, baseUrl };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
+    });
+  }
+});

package/server/api/microservice/app/set_is_app_ready.post.ts

@@ -0,0 +1,29 @@
+// Third party imports
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import { setIsAppReady } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
+
+interface SetIsAppReadyBody {
+  isReady: boolean;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  try {
+    const { isReady } = await readBody<SetIsAppReadyBody>(event);
+    if (!isReady) {
+      throw createError({ statusCode: 400, statusMessage: "isReady is required" });
+    }
+
+    setIsAppReady(isReady);
+    console.log(`Updated IS_APP_READY to ${isReady}`);
+
+    return { statusCode: 200, isReady };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
+    });
+  }
+});

package/server/api/microservice/app/set_viewer_base_url.post.ts

@@ -0,0 +1,26 @@
+// Third party imports
+import { type H3Event, createError, defineEventHandler, readBody } from "h3";
+
+// Local imports
+import { setViewerBaseUrl } from "@geode/opengeodeweb-front/server/utils/server_config.ts";
+
+interface SetViewerBaseUrlBody {
+  baseUrl: string;
+}
+
+export default defineEventHandler(async (event: H3Event) => {
+  try {
+    const { baseUrl } = await readBody<SetViewerBaseUrlBody>(event);
+    if (!baseUrl) {
+      throw createError({ statusCode: 400, statusMessage: "baseUrl is required" });
+    }
+    setViewerBaseUrl(baseUrl);
+    return { statusCode: 200, baseUrl };
+  } catch (error) {
+    console.log(error);
+    throw createError({
+      statusCode: 500,
+      statusMessage: error instanceof Error ? error.message : String(error),
+    });
+  }
+});