@geode/opengeodeweb-front 10.30.0-rc.4 → 10.30.0-rc.6

package/app/stores/cloud.js

@@ -1,4 +1,5 @@
 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";
@@ -26,7 +27,7 @@ export const useCloudStore = defineStore("cloud", {
       console.log("[CLOUD] params", params);
       const appStore = useAppStore();
       const feedbackStore = useFeedbackStore();
-      return appStore.request(
+      return fetchSchema(
         { schema, params },
         {
           request_error_function: () => {

package/package.json

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

package/shared/utils/fetch_raw.js

@@ -0,0 +1,60 @@
+// Third party imports
+import _ from "lodash";
+import pTimeout from "p-timeout";
+
+// Local imports
+import { hasBody } from "./file.js";
+
+function fetchRaw(
+  { route, method, params = {}, baseURL, headers = {}, max_retry, timeout, expectEvent = false },
+  { request_error_function, response_function, response_error_function } = {},
+) {
+  if (expectEvent) {
+    const value = "text/event-stream";
+    if (_.isEmpty(headers)) {
+      headers["Accept"] = value;
+    } else {
+      headers["Accept"] = `${headers["Accept"]}, ${value}`;
+    }
+  }
+
+  const request_options = { method, headers };
+  if (hasBody(params)) {
+    request_options.body = params;
+  }
+  if (max_retry) {
+    request_options.max_retry = max_retry;
+  }
+
+  function doFetch() {
+    return $fetch(route, {
+      baseURL,
+      ...request_options,
+      onRequestError({ error }) {
+        if (request_error_function) {
+          request_error_function(error);
+        }
+      },
+      onResponse({ response }) {
+        if (response.ok && response_function) {
+          response_function(response._data);
+        }
+      },
+      onResponseError({ response }) {
+        if (response_error_function) {
+          response_error_function(response);
+        }
+      },
+    });
+  }
+
+  if (timeout > 0) {
+    return pTimeout(doFetch(), {
+      milliseconds: timeout,
+      message: `${route}: Timed out after ${timeout}ms`,
+    });
+  }
+  return doFetch();
+}
+
+export { fetchRaw };

package/shared/utils/fetch_schema.js

@@ -0,0 +1,46 @@
+// Third party imports
+
+// Local imports
+import { fetchRaw } from "./fetch_raw.js";
+import { validate_schema } from "./validate_schema.js";
+
+const ERROR_400 = 400;
+
+function fetchSchema(
+  { schema, params = {}, baseURL, headers, timeout, expectEvent = false },
+  {
+    request_error_function,
+    response_function,
+    response_error_function,
+    validation_error_function,
+  } = {},
+) {
+  console.log("fetchSchema", { schema, baseURL, params, headers, timeout });
+  const { valid, error: schema_error } = validate_schema(schema, params);
+
+  if (!valid) {
+    if (process.env.NODE_ENV !== "production") {
+      console.log("Bad request", schema_error, schema, params);
+    }
+    if (validation_error_function) {
+      validation_error_function({ code: ERROR_400, name: "Bad request", error: schema_error });
+    }
+    throw new Error(`${schema.$id}: ${schema_error}`);
+  }
+
+  return fetchRaw(
+    {
+      route: schema.$id,
+      method: schema.methods.find((method) => method !== "OPTIONS"),
+      params,
+      baseURL,
+      headers,
+      max_retry: schema.max_retry,
+      timeout,
+      expectEvent,
+    },
+    { request_error_function, response_function, response_error_function },
+  );
+}
+
+export { fetchSchema };

package/shared/utils/file.js

@@ -0,0 +1,16 @@
+import _ from "lodash";
+
+function assertFile(file) {
+  console.log("[ASSERT_FILE] Asserting file", { file });
+  if (!(file instanceof File)) {
+    throw new Error("file must be an instance of File");
+  }
+}
+
+function hasBody(params) {
+  if (params instanceof FormData || params instanceof Blob) {
+    return true;
+  }
+  return !_.isEmpty(params);
+}
+export { assertFile, hasBody };

package/shared/utils/validate_schema.js

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