Making requests

# gem "qube_sync", ">= 0.4.0", require: ["qube_sync/webhooks", "qube_sync/client"]
qube = QubeSync::Client.new(api_key: ENV.fetch("QUBE_API_KEY"))

request = qube.customer.create(
  connection_id, { name: "Riverbend Electric" },
  webhook_url: "https://your-app.example/webhooks/qube",
  idempotency_key: customer.qube_idempotency_key
)

qube.customer.query(connection_id, { name_starts_with: "River" },
                    webhook_url: "https://your-app.example/webhooks/qube")

// npm install qubesync@^0.2.0
const { Client } = require("qubesync");
const qube = new Client({ apiKey: process.env.QUBE_API_KEY });

const request = await qube.customer.create(
  connectionId,
  { name: "Riverbend Electric" },
  {
    webhookUrl: "https://your-app.example/webhooks/qube",
    idempotencyKey: customer.qubeIdempotencyKey,
  },
);

await qube.customer.query(connectionId, { name_starts_with: "River" }, {
  webhookUrl: "https://your-app.example/webhooks/qube",
});

# pip install "qubesync>=0.3.0"
import os
from qubesync import Client

qube = Client(os.environ["QUBE_API_KEY"])

request = qube.customer.create(
    connection_id,
    {"name": "Riverbend Electric"},
    webhook_url="https://your-app.example/webhooks/qube",
    idempotency_key=customer.qube_idempotency_key,
)

qube.customer.query(
    connection_id,
    {"name_starts_with": "River"},
    webhook_url="https://your-app.example/webhooks/qube",
)

require "json"
require "net/http"

module Qube
  # A non-2xx answer: status is the HTTP status, and body what QuBe Sync
  # said (with errors.code).
  class Error < StandardError
    attr_reader :status, :body

    def initialize(status, body)
      @status = status
      @body = body
      super("QuBe Sync answered #{status}: #{body}")
    end
  end

  # JSON in, the response's data out: path is under /api/v2
  # ("/connections"), or a whole URL from a webhook's links.
  def self.api(method, path, body = nil, query: {}, headers: {})
    uri = URI(path)
    uri = URI("https://qubesync.com/api/v2#{path}") unless uri.host
    if query.any? # after a link's own query
      extra = URI.encode_www_form(query)
      uri.query = uri.query ? "#{uri.query}&#{extra}" : extra
    end
    req = Net::HTTP.const_get(method.to_s.capitalize).new(uri, headers)
    req.basic_auth(ENV.fetch("QUBE_API_KEY"), "")
    req["Accept"] = "application/json"
    if body
      req["Content-Type"] = "application/json"
      req.body = JSON.generate(body)
    end

    options = { use_ssl: uri.scheme == "https",
                open_timeout: 5, read_timeout: 30 }
    res = Net::HTTP.start(uri.host, uri.port, options) do |http|
      http.request(req)
    end
    unless res.is_a?(Net::HTTPSuccess)
      raise Error.new(res.code.to_i, res.body)
    end

    JSON.parse(res.body)["data"]
  end
end

/**
 * A non-2xx answer: `status` is the HTTP status, and `body` what QuBe
 * Sync said (with errors.code).
 */
class QubeSyncError extends Error {
  constructor(status, body) {
    super(`QuBe Sync answered ${status}: ${body}`);
    this.status = status;
    this.body = body;
  }
}

// JSON in, the response's data out: `path` is under /api/v2
// ("/connections"), or a whole URL from a webhook's links.
async function qube(method, path, body, options = {}) {
  const { query = {}, headers = {} } = options;
  const url = /^https?:\/\//.test(path)
    ? new URL(path)
    : new URL(`https://qubesync.com/api/v2${path}`);
  for (const [key, value] of Object.entries(query)) {
    url.searchParams.set(key, value);
  }
  const credentials = Buffer.from(`${process.env.QUBE_API_KEY}:`);
  const auth = `Basic ${credentials.toString("base64")}`;
  const hasBody = body !== undefined;
  const res = await fetch(url, {
    method,
    headers: {
      Authorization: auth,
      Accept: "application/json",
      ...(hasBody ? { "Content-Type": "application/json" } : {}),
      ...headers,
    },
    body: hasBody ? JSON.stringify(body) : undefined,
    signal: AbortSignal.timeout(30000),
  });
  const text = await res.text();
  if (!res.ok) throw new QubeSyncError(res.status, text);
  return JSON.parse(text).data;
}

import os
from typing import Any, Dict, Optional

import requests


class QubeSyncError(Exception):
    """A non-2xx answer: status is the HTTP status, and body what
    QuBe Sync said (with errors.code)."""

    def __init__(self, status: int, body: str) -> None:
        super().__init__(f"QuBe Sync answered {status}: {body}")
        self.status = status
        self.body = body


def qube(
    method: str,
    path: str,
    body: Optional[Dict[str, Any]] = None,
    headers: Optional[Dict[str, str]] = None,
    **query: Any,
) -> Any:
    """JSON in, the response's data out: path is under /api/v2
    ("/connections"), or a whole URL from a webhook's links."""
    url = path
    if not path.startswith(("http://", "https://")):
        url = f"https://qubesync.com/api/v2{path}"
    response = requests.request(
        method,
        url,
        params=query or None,
        json=body,
        headers={"Accept": "application/json", **(headers or {})},
        auth=(os.environ["QUBE_API_KEY"], ""),
        timeout=(5, 30),  # seconds: to connect, to read
    )
    if not 200 <= response.status_code < 300:
        raise QubeSyncError(response.status_code, response.text)
    return response.json()["data"]