@eddye68/studio-client/dist/http-client/index.js

The AWS service Studio client

"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/http-client/index.ts
var http_client_exports = {};
__export(http_client_exports, {
  HttpClient: () => HttpClient,
  HttpError: () => HttpError,
  HttpResponseError: () => HttpResponseError
});
module.exports = __toCommonJS(http_client_exports);

// src/client/client-error.ts
var ClientError = class extends Error {
  constructor(msg) {
    super(msg);
    this.name = "ClientError";
  }
};

// src/http-client/http-error.ts
var HttpError = class extends Error {
  /**
   *
   * @param {string} message
   */
  constructor(message) {
    super(message);
    this.name = "HttpError";
  }
};

// src/http-client/http-response-error.ts
var HttpResponseError = class _HttpResponseError extends HttpError {
  /**
   *
   * @param {Response} response
   */
  constructor(message, response) {
    super(_HttpResponseError.buildMessage(message, response));
    this.code = response.status;
    this.name = "HttpResponseError";
  }
  static buildMessage(message, response) {
    if (message) {
      return `HTTP Error: ${message}: ${response.status} ${response.statusText}`;
    } else {
      return `HTTP Error: ${response.status} ${response.statusText}`;
    }
  }
};

// src/http-client/http-client.ts
var import_uuid = require("uuid");
var HttpClient = class {
  constructor(logger) {
    this.headers = {};
    this.baseUrl = ".";
    this.logger = logger;
  }
  /**
   * 
   * @returns The configuration service base URL
   */
  getBaseUrl() {
    return this.baseUrl;
  }
  setBaseUrl(baseUrl) {
    this.baseUrl = baseUrl;
  }
  setCommonHeaders(headers) {
    this.headers = headers;
  }
  async request(httpMethod, path, query, body) {
    httpMethod = httpMethod.toUpperCase();
    if (query === void 0) {
      query = new URLSearchParams();
    }
    const url = this.getBaseUrl() + "/" + path + (query.size > 0 ? "?" + query.toString() : "");
    const request = {
      method: httpMethod.toUpperCase(),
      headers: { ...this.headers }
      // Clone headers
    };
    console.log(`HttpClient::_request: httpMethod=[${httpMethod}], url=[${url}]`);
    if (httpMethod === "POST") {
      this.logger.debug(`HttpClient::_request: body=[${JSON.stringify(body)}]`);
      console.log("HttpClient::_request: body:", body);
      request.body = JSON.stringify(body);
      request.headers["Content-Type"] = "application/json";
    }
    const response = await fetch(url, request);
    let data = null;
    const contentType = response.headers.get("Content-Type");
    switch (contentType) {
      case "application/json":
        data = await response.json();
        break;
      default:
        throw new HttpResponseError(`Unsupported content type: ${contentType}`, response);
    }
    data = this._checkResponse(data);
    return data.Result;
  }
  /**
   *
   * @param url
   * @returns 
   */
  async downloadFile(url, query) {
    if (query === void 0) {
      query = new URLSearchParams();
    }
    const parsedUrl = new URL(url);
    query.forEach((value, key) => {
      parsedUrl.searchParams.set(key, value);
    });
    url = parsedUrl.toString();
    const response = await fetch(url);
    if (!response.ok) {
      throw new HttpResponseError("Object cannot be downloaded from Studio.", response);
    }
    const buffer = await response.arrayBuffer();
    console.log(`Downloaded ${buffer.byteLength} bytes`);
    return buffer;
  }
  /**
   * Upload a file to the Studio transfer server.
   * 
   * 
   * @param body 
   * @param size
   * @param contentType 
   * @param ticket 
   * @param studiobaseUrl The Studio base url
   *
   * @returns The url to the uploaded file
   */
  async uploadFile(body, size, contentType, ticket, studiobaseUrl) {
    this.logger.debug(`HttpClient::uploadFile: ticket=[${ticket}], studiobaseUrl=[${studiobaseUrl}]`);
    const url = `${studiobaseUrl}/transferindex.php?ticket=${ticket}&fileguid=${(0, import_uuid.v4)()}`;
    const headers = {
      "Content-Type": contentType
    };
    if (size !== null) {
      headers["Content-Length"] = String(size);
    }
    const response = await fetch(url, {
      method: "PUT",
      // To prevent the error: RequestInit: duplex option is required when sending a body
      // Note: The order is important!!!! The 'duplex' setting must be set before the body otherwise it will be ignored.
      duplex: "half",
      body,
      headers
    });
    if (!response.ok) {
      throw new HttpResponseError("Unable to upload file.", response);
    }
    return url;
  }
  /**
   * @param {object} data
   * @private
   */
  _checkResponse(data) {
    console.log("HttpClient::_checkResponse: ", data);
    if (data === null) {
      throw new HttpError("No JSON data received");
    }
    if (data.hasOwnProperty("Status")) {
      if (data.Status !== "ok") {
        if (data.StatusMessage !== void 0) {
          throw new ClientError(`The status is not 'ok': ${data.Status}: ${data.StatusMessage}`);
        } else {
          throw new ClientError(`The status is not 'ok': ${data.Status}`);
        }
      }
    } else {
      throw new HttpError("No 'Status' property found in response");
    }
    if (!data.hasOwnProperty("Result")) {
      throw new HttpError("No 'Result' property found in response");
    }
    return data;
  }
  _sanitizeUrl(url) {
    return url.replace(/\/$/, "");
  }
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  HttpClient,
  HttpError,
  HttpResponseError
});
//# sourceMappingURL=index.js.map