@geowiki/cms-proxy 0.0.0

package/dist/index.mjs

@@ -0,0 +1,566 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve2, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve2(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// core/ApiError.ts
+var ApiError = class extends Error {
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var _isResolved, _isRejected, _isCancelled, _cancelHandlers, _promise, _resolve, _reject;
+var CancelablePromise = class {
+  constructor(executor) {
+    __privateAdd(this, _isResolved);
+    __privateAdd(this, _isRejected);
+    __privateAdd(this, _isCancelled);
+    __privateAdd(this, _cancelHandlers);
+    __privateAdd(this, _promise);
+    __privateAdd(this, _resolve);
+    __privateAdd(this, _reject);
+    __privateSet(this, _isResolved, false);
+    __privateSet(this, _isRejected, false);
+    __privateSet(this, _isCancelled, false);
+    __privateSet(this, _cancelHandlers, []);
+    __privateSet(this, _promise, new Promise((resolve2, reject) => {
+      __privateSet(this, _resolve, resolve2);
+      __privateSet(this, _reject, reject);
+      const onResolve = (value) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateSet(this, _isResolved, true);
+        if (__privateGet(this, _resolve)) __privateGet(this, _resolve).call(this, value);
+      };
+      const onReject = (reason) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateSet(this, _isRejected, true);
+        if (__privateGet(this, _reject)) __privateGet(this, _reject).call(this, reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateGet(this, _cancelHandlers).push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => __privateGet(this, _isResolved)
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => __privateGet(this, _isRejected)
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => __privateGet(this, _isCancelled)
+      });
+      return executor(onResolve, onReject, onCancel);
+    }));
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return __privateGet(this, _promise).then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return __privateGet(this, _promise).catch(onRejected);
+  }
+  finally(onFinally) {
+    return __privateGet(this, _promise).finally(onFinally);
+  }
+  cancel() {
+    if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+      return;
+    }
+    __privateSet(this, _isCancelled, true);
+    if (__privateGet(this, _cancelHandlers).length) {
+      try {
+        for (const cancelHandler of __privateGet(this, _cancelHandlers)) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    __privateGet(this, _cancelHandlers).length = 0;
+    if (__privateGet(this, _reject)) __privateGet(this, _reject).call(this, new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return __privateGet(this, _isCancelled);
+  }
+};
+_isResolved = new WeakMap();
+_isRejected = new WeakMap();
+_isCancelled = new WeakMap();
+_cancelHandlers = new WeakMap();
+_promise = new WeakMap();
+_resolve = new WeakMap();
+_reject = new WeakMap();
+
+// core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "http://cms.geowiki.iiasa.ac.at/geoquest",
+  VERSION: "1.0.0",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0
+};
+
+// models/FlowAlignment.ts
+var FlowAlignment = /* @__PURE__ */ ((FlowAlignment2) => {
+  FlowAlignment2[FlowAlignment2["_0"] = 0] = "_0";
+  FlowAlignment2[FlowAlignment2["_1"] = 1] = "_1";
+  FlowAlignment2[FlowAlignment2["_2"] = 2] = "_2";
+  FlowAlignment2[FlowAlignment2["_3"] = 3] = "_3";
+  return FlowAlignment2;
+})(FlowAlignment || {});
+
+// core/request.ts
+import axios from "axios";
+import FormData from "form-data";
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var isSuccess = (status) => {
+  return status >= 200 && status < 300;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    var _a;
+    if ((_a = options.path) == null ? void 0 : _a.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = (options, resolver) => __async(null, null, function* () {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+});
+var getHeaders = (config, options, formData) => __async(null, null, function* () {
+  const [token, username, password, additionalHeaders] = yield Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const formHeaders = typeof (formData == null ? void 0 : formData.getHeaders) === "function" && (formData == null ? void 0 : formData.getHeaders()) || {};
+  const headers = Object.entries(__spreadValues(__spreadValues(__spreadValues({
+    Accept: "application/json"
+  }, additionalHeaders), options.headers), formHeaders)).filter(([_, value]) => isDefined(value)).reduce(
+    (headers2, [key, value]) => __spreadProps(__spreadValues({}, headers2), {
+      [key]: String(value)
+    }),
+    {}
+  );
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return headers;
+});
+var getRequestBody = (options) => {
+  if (options.body) {
+    return options.body;
+  }
+  return void 0;
+};
+var sendRequest = (config, options, url, body, formData, headers, onCancel, axiosClient) => __async(null, null, function* () {
+  const source = axios.CancelToken.source();
+  const requestConfig = {
+    url,
+    headers,
+    data: body != null ? body : formData,
+    method: options.method,
+    withCredentials: config.WITH_CREDENTIALS,
+    cancelToken: source.token
+  };
+  onCancel(() => source.cancel("The user aborted a request."));
+  try {
+    return yield axiosClient.request(requestConfig);
+  } catch (error) {
+    const axiosError = error;
+    if (axiosError.response) {
+      return axiosError.response;
+    }
+    throw error;
+  }
+});
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers[responseHeader];
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = (response) => {
+  if (response.status !== 204) {
+    return response.data;
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  var _a, _b;
+  const errors = __spreadValues({
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable"
+  }, options.errors);
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = (_a = result.status) != null ? _a : "unknown";
+    const errorStatusText = (_b = result.statusText) != null ? _b : "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options, axiosClient = axios) => {
+  return new CancelablePromise((resolve2, reject, onCancel) => __async(null, null, function* () {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = yield getHeaders(config, options, formData);
+      if (!onCancel.isCancelled) {
+        const response = yield sendRequest(
+          config,
+          options,
+          url,
+          body,
+          formData,
+          headers,
+          onCancel,
+          axiosClient
+        );
+        const responseBody = getResponseBody(response);
+        const responseHeader = getResponseHeader(
+          response,
+          options.responseHeader
+        );
+        const result = {
+          url,
+          ok: isSuccess(response.status),
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader != null ? responseHeader : responseBody
+        };
+        catchErrorCodes(options, result);
+        resolve2(result.body);
+      }
+    } catch (error) {
+      reject(error);
+    }
+  }));
+};
+
+// services/DefaultService.ts
+var DefaultService = class {
+  /**
+   * @param contentItemId
+   * @returns any
+   * @throws ApiError
+   */
+  static getApiContent(contentItemId) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/content/{contentItemId}",
+      path: {
+        contentItemId
+      }
+    });
+  }
+  /**
+   * @param contentItemId
+   * @returns any
+   * @throws ApiError
+   */
+  static deleteApiContent(contentItemId) {
+    return request(OpenAPI, {
+      method: "DELETE",
+      url: "/api/content/{contentItemId}",
+      path: {
+        contentItemId
+      }
+    });
+  }
+  /**
+   * @param draft
+   * @param requestBody
+   * @returns any
+   * @throws ApiError
+   */
+  static postApiContent(draft = false, requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/content",
+      query: {
+        draft
+      },
+      body: requestBody,
+      mediaType: "application/json"
+    });
+  }
+};
+
+// services/QueryApiService.ts
+var QueryApiService = class {
+  /**
+   * @param name
+   * @param parameters
+   * @returns QueriesItemsDto
+   * @throws ApiError
+   */
+  static apiQueryPost(name, parameters) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/api/queries/{name}",
+      path: {
+        name
+      },
+      query: {
+        parameters
+      }
+    });
+  }
+  /**
+   * @param name
+   * @param parameters
+   * @returns QueriesItemsDto
+   * @throws ApiError
+   */
+  static apiQueryGet(name, parameters) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/queries/{name}",
+      path: {
+        name
+      },
+      query: {
+        parameters
+      }
+    });
+  }
+};
+
+// services/SettingsService.ts
+var SettingsService = class {
+  /**
+   * @param settingsType
+   * @returns binary
+   * @throws ApiError
+   */
+  static settingsGetSiteSettings(settingsType) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/settings/{settingsType}",
+      path: {
+        settingsType
+      }
+    });
+  }
+  /**
+   * @returns binary
+   * @throws ApiError
+   */
+  static settingsGetDefaultSiteSettings() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/settings/default"
+    });
+  }
+  /**
+   * @returns binary
+   * @throws ApiError
+   */
+  static settingsGetMenu() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/api/settings/menu"
+    });
+  }
+};
+export {
+  ApiError,
+  CancelError,
+  CancelablePromise,
+  DefaultService,
+  FlowAlignment,
+  OpenAPI,
+  QueryApiService,
+  SettingsService
+};

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@geowiki/cms-proxy",
+  "version": "0.0.0",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "axios": "^1.15.2",
+    "form-data": "^4.0.4"
+  },
+  "devDependencies": {
+    "eslint": "^8.57.1",
+    "tsup": "^8.5.1",
+    "typescript": "5.4.2",
+    "eslint-config-custom": "0.0.0",
+    "tsconfig": "0.0.0"
+  },
+  "scripts": {
+    "build": "tsup index.ts --format cjs,esm --dts",
+    "lint": "eslint \"**/*.ts*\"",
+    "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
+    "type-check": "tsc --noEmit"
+  },
+  "module": "./dist/index.mjs",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  }
+}