cloudbridge-sdk/dist/index.cjs

CloudBridge Node.js + TypeScript SDK (simple file upload)

'use strict';

var axios = require('axios');
var crypto = require('crypto');
var fs = require('fs');
var path = require('path');
var FormData = require('form-data');
var mimeTypes = require('mime-types');
var http = require('http');
var https = require('https');

function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }

var axios__default = /*#__PURE__*/_interopDefault(axios);
var fs__default = /*#__PURE__*/_interopDefault(fs);
var path__default = /*#__PURE__*/_interopDefault(path);
var FormData__default = /*#__PURE__*/_interopDefault(FormData);

// src/index.ts
var CloudBridgeError = class extends Error {
  status;
  statusCode;
  errors;
  constructor(message, opts) {
    super(message);
    this.name = "CloudBridgeError";
    this.status = opts?.status;
    this.statusCode = opts?.statusCode;
    this.errors = opts?.errors;
  }
};
var CloudBridgeClient = class _CloudBridgeClient {
  static BASE_URL = "https://api.cloudbridge.nugitech.com";
  accessKey;
  secretKey;
  axios;
  constructor(options) {
    const envAccess = process.env.CLOUDBRIDGE_ACCESS_KEY;
    const envSecret = process.env.CLOUDBRIDGE_SECRET_KEY;
    this.accessKey = options?.accessKey ?? envAccess;
    this.secretKey = options?.secretKey ?? envSecret;
    const httpAgent = new http.Agent({ keepAlive: true });
    const httpsAgent = new https.Agent({ keepAlive: true });
    this.axios = axios__default.default.create({
      baseURL: _CloudBridgeClient.BASE_URL,
      timeout: options?.timeoutMs ?? 6e4,
      httpAgent,
      httpsAgent,
      // Allow reading structured error responses without axios throwing
      validateStatus: (status) => status >= 200 && status < 600,
      maxBodyLength: Infinity,
      maxContentLength: Infinity
    });
  }
  async uploadFiles(filePaths, opts) {
    if (!Array.isArray(filePaths) || filePaths.length === 0) {
      throw new CloudBridgeError("filePaths must be a non-empty array of paths");
    }
    if (!opts?.folder) {
      throw new CloudBridgeError("opts.folder is required");
    }
    if (!this.accessKey || !this.secretKey) {
      throw new CloudBridgeError(
        "Missing credentials: accessKey and secretKey are required (via constructor or environment)",
        { status: "error" }
      );
    }
    const signature = crypto.createHmac("sha256", this.secretKey).update(this.accessKey).digest("hex");
    const form = new FormData__default.default();
    form.append("folder", opts.folder);
    for (const filePath of filePaths) {
      const stream = fs__default.default.createReadStream(filePath);
      const filename = path__default.default.basename(filePath);
      const contentType = mimeTypes.lookup(filePath) || void 0;
      form.append("files", stream, { filename, contentType });
    }
    const headers = {
      ...form.getHeaders(),
      "x-access-key": this.accessKey,
      "x-signature": signature
    };
    const url = `${_CloudBridgeClient.BASE_URL}/api/v1/public/upload`;
    try {
      const response = await this.axios.post(url, form, { headers });
      const data = response.data;
      if (data && data.status === "success" && data.data?.files) {
        return data.data.files;
      }
      if (data && data.status === "error") {
        const message = data.message || `Request failed with status ${response.status}`;
        throw new CloudBridgeError(message, {
          status: data.status,
          statusCode: response.status,
          errors: data.errors
        });
      }
      throw new CloudBridgeError(`Unexpected response (status ${response.status})`);
    } catch (err) {
      if (err instanceof CloudBridgeError) {
        throw err;
      }
      const anyErr = err;
      const statusCode = anyErr?.response?.status;
      const data = anyErr?.response?.data;
      if (data && data.status === "error") {
        throw new CloudBridgeError(data.message || "Request failed", {
          status: data.status,
          statusCode,
          errors: data.errors
        });
      }
      const message = anyErr?.message || `Request failed${statusCode ? ` with status ${statusCode}` : ""}`;
      throw new CloudBridgeError(message, { statusCode });
    }
  }
};

exports.CloudBridgeClient = CloudBridgeClient;
exports.CloudBridgeError = CloudBridgeError;
//# sourceMappingURL=index.cjs.map
//# sourceMappingURL=index.cjs.map