@air/api-core 0.1.1

package/dist/index.cjs

@@ -0,0 +1,363 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  APIError: () => APIError,
+  AirBase: () => AirBase,
+  AuthenticationError: () => AuthenticationError,
+  BadRequestError: () => BadRequestError,
+  ConnectionError: () => ConnectionError,
+  CursorPage: () => CursorPage,
+  InternalServerError: () => InternalServerError,
+  NotFoundError: () => NotFoundError,
+  PagePromise: () => PagePromise,
+  PermissionError: () => PermissionError,
+  RateLimitError: () => RateLimitError,
+  TimeoutError: () => TimeoutError,
+  VERSION: () => VERSION,
+  getRetryDelay: () => getRetryDelay,
+  isRetryableError: () => isRetryableError,
+  retryWithBackoff: () => retryWithBackoff
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var APIError = class _APIError extends Error {
+  status;
+  headers;
+  body;
+  constructor(status, body, message, headers) {
+    super(message);
+    this.name = "APIError";
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+  }
+  static async fromResponse(response) {
+    const headers = response.headers;
+    let body;
+    let message;
+    try {
+      body = await response.json();
+      message = typeof body === "object" && body !== null && "message" in body ? String(body.message) : `Request failed with status ${response.status}`;
+    } catch {
+      body = await response.text().catch(() => "");
+      message = `Request failed with status ${response.status}`;
+    }
+    const status = response.status;
+    switch (status) {
+      case 400:
+        return new BadRequestError(status, body, message, headers);
+      case 401:
+        return new AuthenticationError(status, body, message, headers);
+      case 403:
+        return new PermissionError(status, body, message, headers);
+      case 404:
+        return new NotFoundError(status, body, message, headers);
+      case 429:
+        return new RateLimitError(status, body, message, headers);
+      default:
+        if (status >= 500) {
+          return new InternalServerError(status, body, message, headers);
+        }
+        return new _APIError(status, body, message, headers);
+    }
+  }
+};
+var BadRequestError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "BadRequestError";
+  }
+};
+var AuthenticationError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends APIError {
+  retryAfter;
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "RateLimitError";
+    const retryAfterHeader = headers.get("retry-after");
+    this.retryAfter = retryAfterHeader ? Number(retryAfterHeader) : null;
+  }
+};
+var InternalServerError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "InternalServerError";
+  }
+};
+var ConnectionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectionError";
+  }
+};
+var TimeoutError = class extends ConnectionError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/pagination.ts
+var CursorPage = class {
+  data;
+  pagination;
+  total;
+  _fetchNextPage;
+  constructor(response, fetchNextPage) {
+    this.data = response.data;
+    this.pagination = response.pagination;
+    this.total = response.total;
+    this._fetchNextPage = fetchNextPage;
+  }
+  hasNextPage() {
+    return this.pagination.hasMore && this.pagination.cursor !== null;
+  }
+  async getNextPage() {
+    if (!this.hasNextPage() || !this._fetchNextPage) {
+      throw new Error("No more pages available");
+    }
+    return this._fetchNextPage(this.pagination.cursor);
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = this;
+    while (true) {
+      for (const item of page.data) {
+        yield item;
+      }
+      if (!page.hasNextPage()) break;
+      page = await page.getNextPage();
+    }
+  }
+};
+var PagePromise = class extends Promise {
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    yield* page;
+  }
+};
+
+// src/retry.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var SERVER_ERROR_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+function isRetryableError(error, method) {
+  if (error instanceof APIError) {
+    if (method === "POST" && SERVER_ERROR_CODES.has(error.status)) {
+      return false;
+    }
+    return RETRYABLE_STATUS_CODES.has(error.status);
+  }
+  if (error instanceof ConnectionError) {
+    return true;
+  }
+  return false;
+}
+function getRetryDelay(error, attempt, baseDelay = 500) {
+  if (error instanceof RateLimitError && error.retryAfter !== null) {
+    const retryAfterMs = error.retryAfter * 1e3;
+    const jitter2 = retryAfterMs * 0.2 * Math.random();
+    return retryAfterMs + jitter2;
+  }
+  const exponentialDelay = baseDelay * Math.pow(2, attempt);
+  const jitter = exponentialDelay * 0.2 * Math.random();
+  return exponentialDelay + jitter;
+}
+async function retryWithBackoff(fn, maxRetries, method) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxRetries || !isRetryableError(error, method)) {
+        throw error;
+      }
+      const delay = getRetryDelay(error, attempt);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/base-client.ts
+var AirBase = class {
+  apiKey;
+  workspaceId;
+  baseURL;
+  maxRetries;
+  timeout;
+  _fetch;
+  _defaultHeaders;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? process.env.AIR_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "API key is required. Pass it as `apiKey` option or set the AIR_API_KEY environment variable."
+      );
+    }
+    const workspaceId = options.workspaceId ?? process.env.AIR_WORKSPACE_ID;
+    if (!workspaceId) {
+      throw new Error(
+        "Workspace ID is required. Pass it as `workspaceId` option or set the AIR_WORKSPACE_ID environment variable."
+      );
+    }
+    this.apiKey = apiKey;
+    this.workspaceId = workspaceId;
+    this.baseURL = (options.baseURL ?? "https://api.air.inc/v1").replace(/\/$/, "");
+    this.maxRetries = options.maxRetries ?? 3;
+    this.timeout = options.timeout ?? 6e4;
+    this._fetch = options.fetch ?? globalThis.fetch;
+    this._defaultHeaders = options.defaultHeaders ?? {};
+  }
+  get fetchFn() {
+    return this._fetch;
+  }
+  async request(options) {
+    return retryWithBackoff(
+      () => this._executeRequest(options),
+      this.maxRetries,
+      options.method
+    );
+  }
+  requestCursorPage(options, query) {
+    return new PagePromise((resolve, reject) => {
+      this.request(options).then((response) => {
+        resolve(
+          new CursorPage(
+            response,
+            (cursor) => this.requestCursorPage(
+              {
+                ...options,
+                query: { ...query, ...options.query, cursor }
+              },
+              query
+            )
+          )
+        );
+      }).catch(reject);
+    });
+  }
+  async _executeRequest(options) {
+    const url = this._buildURL(options.path, options.query);
+    const headers = {
+      "x-api-key": this.apiKey,
+      "x-air-workspace-id": this.workspaceId,
+      "user-agent": `air-api-sdk/${VERSION}`,
+      ...this._defaultHeaders,
+      ...options.headers
+    };
+    if (options.body !== void 0) {
+      headers["content-type"] = "application/json";
+    }
+    const timeout = options.timeout ?? this.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => controller.abort());
+    }
+    let response;
+    try {
+      response = await this._fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new TimeoutError();
+      }
+      throw new ConnectionError(error instanceof Error ? error.message : "Connection failed");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+      throw await APIError.fromResponse(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const contentType = response.headers.get("content-type");
+    if (!contentType?.includes("application/json")) {
+      return void 0;
+    }
+    return await response.json();
+  }
+  _buildURL(path, query) {
+    const url = new URL(`${this.baseURL}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0) continue;
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            url.searchParams.append(key, v);
+          }
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APIError,
+  AirBase,
+  AuthenticationError,
+  BadRequestError,
+  ConnectionError,
+  CursorPage,
+  InternalServerError,
+  NotFoundError,
+  PagePromise,
+  PermissionError,
+  RateLimitError,
+  TimeoutError,
+  VERSION,
+  getRetryDelay,
+  isRetryableError,
+  retryWithBackoff
+});

package/dist/index.d.cts

@@ -0,0 +1,111 @@
+interface CursorPageParams {
+    limit?: number;
+    cursor?: string;
+}
+interface CursorPageResponse<T> {
+    data: T[];
+    pagination: {
+        hasMore: boolean;
+        cursor: string | null;
+    };
+    total?: number;
+}
+
+declare class CursorPage<T> implements AsyncIterable<T> {
+    readonly data: T[];
+    readonly pagination: {
+        hasMore: boolean;
+        cursor: string | null;
+    };
+    readonly total: number | undefined;
+    private _fetchNextPage;
+    constructor(response: CursorPageResponse<T>, fetchNextPage: ((cursor: string) => Promise<CursorPage<T>>) | null);
+    hasNextPage(): boolean;
+    getNextPage(): Promise<CursorPage<T>>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+/**
+ * A Promise that resolves to a CursorPage, but is also directly async-iterable.
+ * This allows both patterns:
+ *   - `for await (const item of client.assets.list())` (auto-paginate)
+ *   - `const page = await client.assets.list()` (manual pagination)
+ */
+declare class PagePromise<T> extends Promise<CursorPage<T>> implements AsyncIterable<T> {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+interface RequestOptions {
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    query?: Record<string, string | string[] | number | boolean | undefined>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+
+interface AirBaseOptions {
+    apiKey?: string;
+    workspaceId?: string;
+    baseURL?: string;
+    maxRetries?: number;
+    timeout?: number;
+    fetch?: typeof globalThis.fetch;
+    defaultHeaders?: Record<string, string>;
+}
+declare class AirBase {
+    readonly apiKey: string;
+    workspaceId: string;
+    readonly baseURL: string;
+    readonly maxRetries: number;
+    readonly timeout: number;
+    private _fetch;
+    private _defaultHeaders;
+    constructor(options?: AirBaseOptions);
+    get fetchFn(): typeof globalThis.fetch;
+    request<T>(options: RequestOptions): Promise<T>;
+    requestCursorPage<T>(options: RequestOptions, query?: Record<string, string | string[] | number | boolean | undefined>): PagePromise<T>;
+    private _executeRequest;
+    private _buildURL;
+}
+
+declare class APIError extends Error {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+    static fromResponse(response: Response): Promise<APIError>;
+}
+declare class BadRequestError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class AuthenticationError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class PermissionError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class NotFoundError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class RateLimitError extends APIError {
+    readonly retryAfter: number | null;
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class InternalServerError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class ConnectionError extends Error {
+    constructor(message: string);
+}
+declare class TimeoutError extends ConnectionError {
+    constructor(message?: string);
+}
+
+declare function isRetryableError(error: unknown, method?: string): boolean;
+declare function getRetryDelay(error: unknown, attempt: number, baseDelay?: number): number;
+declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries: number, method?: string): Promise<T>;
+
+declare const VERSION = "0.1.0";
+
+export { APIError, AirBase, type AirBaseOptions, AuthenticationError, BadRequestError, ConnectionError, CursorPage, type CursorPageParams, type CursorPageResponse, InternalServerError, NotFoundError, PagePromise, PermissionError, RateLimitError, type RequestOptions, TimeoutError, VERSION, getRetryDelay, isRetryableError, retryWithBackoff };

package/dist/index.d.ts

@@ -0,0 +1,111 @@
+interface CursorPageParams {
+    limit?: number;
+    cursor?: string;
+}
+interface CursorPageResponse<T> {
+    data: T[];
+    pagination: {
+        hasMore: boolean;
+        cursor: string | null;
+    };
+    total?: number;
+}
+
+declare class CursorPage<T> implements AsyncIterable<T> {
+    readonly data: T[];
+    readonly pagination: {
+        hasMore: boolean;
+        cursor: string | null;
+    };
+    readonly total: number | undefined;
+    private _fetchNextPage;
+    constructor(response: CursorPageResponse<T>, fetchNextPage: ((cursor: string) => Promise<CursorPage<T>>) | null);
+    hasNextPage(): boolean;
+    getNextPage(): Promise<CursorPage<T>>;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+/**
+ * A Promise that resolves to a CursorPage, but is also directly async-iterable.
+ * This allows both patterns:
+ *   - `for await (const item of client.assets.list())` (auto-paginate)
+ *   - `const page = await client.assets.list()` (manual pagination)
+ */
+declare class PagePromise<T> extends Promise<CursorPage<T>> implements AsyncIterable<T> {
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+
+interface RequestOptions {
+    method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+    path: string;
+    query?: Record<string, string | string[] | number | boolean | undefined>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    timeout?: number;
+    signal?: AbortSignal;
+}
+
+interface AirBaseOptions {
+    apiKey?: string;
+    workspaceId?: string;
+    baseURL?: string;
+    maxRetries?: number;
+    timeout?: number;
+    fetch?: typeof globalThis.fetch;
+    defaultHeaders?: Record<string, string>;
+}
+declare class AirBase {
+    readonly apiKey: string;
+    workspaceId: string;
+    readonly baseURL: string;
+    readonly maxRetries: number;
+    readonly timeout: number;
+    private _fetch;
+    private _defaultHeaders;
+    constructor(options?: AirBaseOptions);
+    get fetchFn(): typeof globalThis.fetch;
+    request<T>(options: RequestOptions): Promise<T>;
+    requestCursorPage<T>(options: RequestOptions, query?: Record<string, string | string[] | number | boolean | undefined>): PagePromise<T>;
+    private _executeRequest;
+    private _buildURL;
+}
+
+declare class APIError extends Error {
+    readonly status: number;
+    readonly headers: Headers;
+    readonly body: unknown;
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+    static fromResponse(response: Response): Promise<APIError>;
+}
+declare class BadRequestError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class AuthenticationError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class PermissionError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class NotFoundError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class RateLimitError extends APIError {
+    readonly retryAfter: number | null;
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class InternalServerError extends APIError {
+    constructor(status: number, body: unknown, message: string, headers: Headers);
+}
+declare class ConnectionError extends Error {
+    constructor(message: string);
+}
+declare class TimeoutError extends ConnectionError {
+    constructor(message?: string);
+}
+
+declare function isRetryableError(error: unknown, method?: string): boolean;
+declare function getRetryDelay(error: unknown, attempt: number, baseDelay?: number): number;
+declare function retryWithBackoff<T>(fn: () => Promise<T>, maxRetries: number, method?: string): Promise<T>;
+
+declare const VERSION = "0.1.0";
+
+export { APIError, AirBase, type AirBaseOptions, AuthenticationError, BadRequestError, ConnectionError, CursorPage, type CursorPageParams, type CursorPageResponse, InternalServerError, NotFoundError, PagePromise, PermissionError, RateLimitError, type RequestOptions, TimeoutError, VERSION, getRetryDelay, isRetryableError, retryWithBackoff };

package/dist/index.js

@@ -0,0 +1,321 @@
+// src/errors.ts
+var APIError = class _APIError extends Error {
+  status;
+  headers;
+  body;
+  constructor(status, body, message, headers) {
+    super(message);
+    this.name = "APIError";
+    this.status = status;
+    this.body = body;
+    this.headers = headers;
+  }
+  static async fromResponse(response) {
+    const headers = response.headers;
+    let body;
+    let message;
+    try {
+      body = await response.json();
+      message = typeof body === "object" && body !== null && "message" in body ? String(body.message) : `Request failed with status ${response.status}`;
+    } catch {
+      body = await response.text().catch(() => "");
+      message = `Request failed with status ${response.status}`;
+    }
+    const status = response.status;
+    switch (status) {
+      case 400:
+        return new BadRequestError(status, body, message, headers);
+      case 401:
+        return new AuthenticationError(status, body, message, headers);
+      case 403:
+        return new PermissionError(status, body, message, headers);
+      case 404:
+        return new NotFoundError(status, body, message, headers);
+      case 429:
+        return new RateLimitError(status, body, message, headers);
+      default:
+        if (status >= 500) {
+          return new InternalServerError(status, body, message, headers);
+        }
+        return new _APIError(status, body, message, headers);
+    }
+  }
+};
+var BadRequestError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "BadRequestError";
+  }
+};
+var AuthenticationError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "AuthenticationError";
+  }
+};
+var PermissionError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "PermissionError";
+  }
+};
+var NotFoundError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends APIError {
+  retryAfter;
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "RateLimitError";
+    const retryAfterHeader = headers.get("retry-after");
+    this.retryAfter = retryAfterHeader ? Number(retryAfterHeader) : null;
+  }
+};
+var InternalServerError = class extends APIError {
+  constructor(status, body, message, headers) {
+    super(status, body, message, headers);
+    this.name = "InternalServerError";
+  }
+};
+var ConnectionError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConnectionError";
+  }
+};
+var TimeoutError = class extends ConnectionError {
+  constructor(message = "Request timed out") {
+    super(message);
+    this.name = "TimeoutError";
+  }
+};
+
+// src/pagination.ts
+var CursorPage = class {
+  data;
+  pagination;
+  total;
+  _fetchNextPage;
+  constructor(response, fetchNextPage) {
+    this.data = response.data;
+    this.pagination = response.pagination;
+    this.total = response.total;
+    this._fetchNextPage = fetchNextPage;
+  }
+  hasNextPage() {
+    return this.pagination.hasMore && this.pagination.cursor !== null;
+  }
+  async getNextPage() {
+    if (!this.hasNextPage() || !this._fetchNextPage) {
+      throw new Error("No more pages available");
+    }
+    return this._fetchNextPage(this.pagination.cursor);
+  }
+  async *[Symbol.asyncIterator]() {
+    let page = this;
+    while (true) {
+      for (const item of page.data) {
+        yield item;
+      }
+      if (!page.hasNextPage()) break;
+      page = await page.getNextPage();
+    }
+  }
+};
+var PagePromise = class extends Promise {
+  async *[Symbol.asyncIterator]() {
+    const page = await this;
+    yield* page;
+  }
+};
+
+// src/retry.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([408, 429, 500, 502, 503, 504]);
+var SERVER_ERROR_CODES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+function isRetryableError(error, method) {
+  if (error instanceof APIError) {
+    if (method === "POST" && SERVER_ERROR_CODES.has(error.status)) {
+      return false;
+    }
+    return RETRYABLE_STATUS_CODES.has(error.status);
+  }
+  if (error instanceof ConnectionError) {
+    return true;
+  }
+  return false;
+}
+function getRetryDelay(error, attempt, baseDelay = 500) {
+  if (error instanceof RateLimitError && error.retryAfter !== null) {
+    const retryAfterMs = error.retryAfter * 1e3;
+    const jitter2 = retryAfterMs * 0.2 * Math.random();
+    return retryAfterMs + jitter2;
+  }
+  const exponentialDelay = baseDelay * Math.pow(2, attempt);
+  const jitter = exponentialDelay * 0.2 * Math.random();
+  return exponentialDelay + jitter;
+}
+async function retryWithBackoff(fn, maxRetries, method) {
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt === maxRetries || !isRetryableError(error, method)) {
+        throw error;
+      }
+      const delay = getRetryDelay(error, attempt);
+      await sleep(delay);
+    }
+  }
+  throw lastError;
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/version.ts
+var VERSION = "0.1.0";
+
+// src/base-client.ts
+var AirBase = class {
+  apiKey;
+  workspaceId;
+  baseURL;
+  maxRetries;
+  timeout;
+  _fetch;
+  _defaultHeaders;
+  constructor(options = {}) {
+    const apiKey = options.apiKey ?? process.env.AIR_API_KEY;
+    if (!apiKey) {
+      throw new Error(
+        "API key is required. Pass it as `apiKey` option or set the AIR_API_KEY environment variable."
+      );
+    }
+    const workspaceId = options.workspaceId ?? process.env.AIR_WORKSPACE_ID;
+    if (!workspaceId) {
+      throw new Error(
+        "Workspace ID is required. Pass it as `workspaceId` option or set the AIR_WORKSPACE_ID environment variable."
+      );
+    }
+    this.apiKey = apiKey;
+    this.workspaceId = workspaceId;
+    this.baseURL = (options.baseURL ?? "https://api.air.inc/v1").replace(/\/$/, "");
+    this.maxRetries = options.maxRetries ?? 3;
+    this.timeout = options.timeout ?? 6e4;
+    this._fetch = options.fetch ?? globalThis.fetch;
+    this._defaultHeaders = options.defaultHeaders ?? {};
+  }
+  get fetchFn() {
+    return this._fetch;
+  }
+  async request(options) {
+    return retryWithBackoff(
+      () => this._executeRequest(options),
+      this.maxRetries,
+      options.method
+    );
+  }
+  requestCursorPage(options, query) {
+    return new PagePromise((resolve, reject) => {
+      this.request(options).then((response) => {
+        resolve(
+          new CursorPage(
+            response,
+            (cursor) => this.requestCursorPage(
+              {
+                ...options,
+                query: { ...query, ...options.query, cursor }
+              },
+              query
+            )
+          )
+        );
+      }).catch(reject);
+    });
+  }
+  async _executeRequest(options) {
+    const url = this._buildURL(options.path, options.query);
+    const headers = {
+      "x-api-key": this.apiKey,
+      "x-air-workspace-id": this.workspaceId,
+      "user-agent": `air-api-sdk/${VERSION}`,
+      ...this._defaultHeaders,
+      ...options.headers
+    };
+    if (options.body !== void 0) {
+      headers["content-type"] = "application/json";
+    }
+    const timeout = options.timeout ?? this.timeout;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    if (options.signal) {
+      options.signal.addEventListener("abort", () => controller.abort());
+    }
+    let response;
+    try {
+      response = await this._fetch(url, {
+        method: options.method,
+        headers,
+        body: options.body !== void 0 ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      });
+    } catch (error) {
+      if (error instanceof DOMException && error.name === "AbortError") {
+        throw new TimeoutError();
+      }
+      throw new ConnectionError(error instanceof Error ? error.message : "Connection failed");
+    } finally {
+      clearTimeout(timeoutId);
+    }
+    if (!response.ok) {
+      throw await APIError.fromResponse(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    const contentType = response.headers.get("content-type");
+    if (!contentType?.includes("application/json")) {
+      return void 0;
+    }
+    return await response.json();
+  }
+  _buildURL(path, query) {
+    const url = new URL(`${this.baseURL}${path}`);
+    if (query) {
+      for (const [key, value] of Object.entries(query)) {
+        if (value === void 0) continue;
+        if (Array.isArray(value)) {
+          for (const v of value) {
+            url.searchParams.append(key, v);
+          }
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return url.toString();
+  }
+};
+export {
+  APIError,
+  AirBase,
+  AuthenticationError,
+  BadRequestError,
+  ConnectionError,
+  CursorPage,
+  InternalServerError,
+  NotFoundError,
+  PagePromise,
+  PermissionError,
+  RateLimitError,
+  TimeoutError,
+  VERSION,
+  getRetryDelay,
+  isRetryableError,
+  retryWithBackoff
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@air/api-core",
+  "version": "0.1.1",
+  "type": "module",
+  "description": "Core HTTP engine for Air API SDK",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "prepublishOnly": "npm run build",
+    "build": "tsup",
+    "test": "vitest run",
+    "typecheck": "tsc -b",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AirLabsTeam/air-api-sdk.git",
+    "directory": "packages/core"
+  },
+  "license": "UNLICENSED"
+}