@bundleup/sdk 0.0.1

package/README.md

@@ -0,0 +1,4 @@
+# Official Bundle Up SDK Library
+
+[![npm version](https://img.shields.io/npm/v/@bundleup/sdk.svg)](https://www.npmjs.com/package/@bundleup/sdk)
+[![Documentation](https://img.shields.io/badge/documentation-bundleup.io-green.svg)](https://bundleup.io/docs/sdk)

package/dist/chunk-B6T6V2FR.mjs

@@ -0,0 +1,24 @@
+// src/utils.ts
+function isClient() {
+  return typeof window !== "undefined";
+}
+function logger(isDebug) {
+  return (message, ...args) => {
+    if (!isDebug) {
+      return;
+    }
+    console.log("%c[BundleUp]", "color: #00f;", message, ...args);
+  };
+}
+function isTrue(val) {
+  if (!val) {
+    return false;
+  }
+  return val.toLowerCase() === "true";
+}
+
+export {
+  isClient,
+  logger,
+  isTrue
+};

package/dist/chunk-GKEHPYLJ.mjs

@@ -0,0 +1,17 @@
+// src/utils.ts
+function isClient() {
+  return typeof window !== "undefined";
+}
+function logger(isDebug) {
+  return (message, ...args) => {
+    if (!isDebug) {
+      return;
+    }
+    console.log("%c[BundleUp]", "color: #00f;", message, ...args);
+  };
+}
+
+export {
+  isClient,
+  logger
+};

package/dist/chunk-U6VVRHFA.mjs

@@ -0,0 +1,17 @@
+// src/utils.ts
+function isClient() {
+  return typeof window !== "undefined";
+}
+function logger(isDebug) {
+  return (message, ...args) => {
+    if (!isDebug) {
+      return;
+    }
+    console.log("%c[BundleUp]", "color: #00f;", message, ...args);
+  };
+}
+
+export {
+  isClient,
+  logger
+};

package/dist/client.d.mts

@@ -0,0 +1,8 @@
+interface AuthenticateWithPopupOptions {
+    width?: number;
+    height?: number;
+    debug?: boolean;
+}
+declare function authenticateWithPopup(token: string, options?: AuthenticateWithPopupOptions): Promise<Record<string, any>>;
+
+export { AuthenticateWithPopupOptions, authenticateWithPopup };

package/dist/client.d.ts

@@ -0,0 +1,8 @@
+interface AuthenticateWithPopupOptions {
+    width?: number;
+    height?: number;
+    debug?: boolean;
+}
+declare function authenticateWithPopup(token: string, options?: AuthenticateWithPopupOptions): Promise<Record<string, any>>;
+
+export { AuthenticateWithPopupOptions, authenticateWithPopup };

package/dist/client.js

@@ -0,0 +1,119 @@
+"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/client.ts
+var client_exports = {};
+__export(client_exports, {
+  authenticateWithPopup: () => authenticateWithPopup
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/utils.ts
+function isClient() {
+  return typeof window !== "undefined";
+}
+function logger(isDebug) {
+  return (message, ...args) => {
+    if (!isDebug) {
+      return;
+    }
+    console.log("%c[BundleUp]", "color: #00f;", message, ...args);
+  };
+}
+
+// src/client.ts
+function authenticateWithPopup(token, options = {}) {
+  return new Promise((resolve, reject) => {
+    if (!token) {
+      return reject(new Error("Token is required"));
+    }
+    const width = options?.width ?? 500;
+    const height = options?.height ?? 600;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2.5;
+    const debug = options?.debug ?? false;
+    const client = isClient();
+    const log = logger(debug);
+    if (!client) {
+      log("Authentication failed: not in client environment");
+      return reject(
+        new Error(
+          "authenticateWithPopup can only be used in a client environment"
+        )
+      );
+    }
+    log("Starting authentication with popup");
+    const popup = window.open(
+      `https://auth.bundleup.io/${token}`,
+      "bundleup-auth",
+      `width=${width},height=${height},left=${left},top=${top},scrollbars=yes,resizable=yes`
+    );
+    if (!popup) {
+      log("Failed to open popup window. Please check popup blocker settings.");
+      return reject(
+        new Error(
+          "Failed to open popup window. Please check popup blocker settings."
+        )
+      );
+    }
+    const handleMessage = (event) => {
+      if (event.origin !== "https://auth.bundleup.io") {
+        return;
+      }
+      if (!event.data?.type) {
+        return;
+      }
+      cleanup();
+      popup.close();
+      if (event.data.type === "bundleup:success") {
+        log("Authentication successful");
+        return resolve(event.data.data);
+      }
+      if (event.data.type === "bundleup:error") {
+        log("Authentication failed", event.data.message);
+        return reject(new Error(event.data.message || "Authentication failed"));
+      }
+    };
+    const checkClosed = setInterval(() => {
+      if (!popup.closed) {
+        return;
+      }
+      cleanup();
+      log("Authentication popup closed by user");
+      reject(new Error("Authentication popup was closed by user"));
+    }, 1e3);
+    const cleanup = () => {
+      window.removeEventListener("message", handleMessage);
+      clearInterval(checkClosed);
+    };
+    window.addEventListener("message", handleMessage);
+    setTimeout(() => {
+      if (!popup.closed) {
+        return;
+      }
+      cleanup();
+      log("Authentication popup was blocked or closed immediately");
+      reject(new Error("Popup was blocked or closed immediately"));
+    }, 100);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  authenticateWithPopup
+});

package/dist/client.mjs

@@ -0,0 +1,84 @@
+import {
+  isClient,
+  logger
+} from "./chunk-B6T6V2FR.mjs";
+
+// src/client.ts
+function authenticateWithPopup(token, options = {}) {
+  return new Promise((resolve, reject) => {
+    if (!token) {
+      return reject(new Error("Token is required"));
+    }
+    const width = options?.width ?? 500;
+    const height = options?.height ?? 600;
+    const left = window.screenX + (window.outerWidth - width) / 2;
+    const top = window.screenY + (window.outerHeight - height) / 2.5;
+    const debug = options?.debug ?? false;
+    const client = isClient();
+    const log = logger(debug);
+    if (!client) {
+      log("Authentication failed: not in client environment");
+      return reject(
+        new Error(
+          "authenticateWithPopup can only be used in a client environment"
+        )
+      );
+    }
+    log("Starting authentication with popup");
+    const popup = window.open(
+      `https://auth.bundleup.io/${token}`,
+      "bundleup-auth",
+      `width=${width},height=${height},left=${left},top=${top},scrollbars=yes,resizable=yes`
+    );
+    if (!popup) {
+      log("Failed to open popup window. Please check popup blocker settings.");
+      return reject(
+        new Error(
+          "Failed to open popup window. Please check popup blocker settings."
+        )
+      );
+    }
+    const handleMessage = (event) => {
+      if (event.origin !== "https://auth.bundleup.io") {
+        return;
+      }
+      if (!event.data?.type) {
+        return;
+      }
+      cleanup();
+      popup.close();
+      if (event.data.type === "bundleup:success") {
+        log("Authentication successful");
+        return resolve(event.data.data);
+      }
+      if (event.data.type === "bundleup:error") {
+        log("Authentication failed", event.data.message);
+        return reject(new Error(event.data.message || "Authentication failed"));
+      }
+    };
+    const checkClosed = setInterval(() => {
+      if (!popup.closed) {
+        return;
+      }
+      cleanup();
+      log("Authentication popup closed by user");
+      reject(new Error("Authentication popup was closed by user"));
+    }, 1e3);
+    const cleanup = () => {
+      window.removeEventListener("message", handleMessage);
+      clearInterval(checkClosed);
+    };
+    window.addEventListener("message", handleMessage);
+    setTimeout(() => {
+      if (!popup.closed) {
+        return;
+      }
+      cleanup();
+      log("Authentication popup was blocked or closed immediately");
+      reject(new Error("Popup was blocked or closed immediately"));
+    }, 100);
+  });
+}
+export {
+  authenticateWithPopup
+};

package/dist/index.d.mts

@@ -0,0 +1,75 @@
+declare abstract class Base<T> {
+    protected abstract path: string;
+    protected apiKey: string;
+    protected baseUrl: string;
+    protected version: string;
+    constructor(apiKey: string);
+    protected get apiUrl(): string;
+    protected get headers(): Record<string, string>;
+    list<K extends Record<string, any>>(params?: K): Promise<T[]>;
+    create<K extends Record<string, any>>(body: K): Promise<T>;
+    retrieve(id: string): Promise<T>;
+    update<K extends Record<string, any>>(id: string, body: K): Promise<T>;
+    del(id: string): Promise<void>;
+}
+
+interface Connection {
+    id: string;
+    externalId?: string;
+    expiresAt: Date;
+    integrationId: string;
+    isValid: boolean;
+    refreshedAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare class Connections extends Base<Connection> {
+    protected path: string;
+}
+
+interface Integration {
+    id: true;
+    identifier: true;
+    createdAt: true;
+    updatedAt: true;
+}
+declare class Integrations extends Base<Integration> {
+    protected path: string;
+}
+
+interface Webhook {
+    id: string;
+    name: string;
+    url: string;
+    events: Record<string, boolean>;
+    createdAt: Date;
+    updatedAt: Date;
+    lastTriggeredAt?: Date;
+}
+declare class Webhooks extends Base<Webhook> {
+    protected path: string;
+}
+
+declare class BURequest {
+    private apiKey;
+    private connectionId;
+    constructor(apiKey: string, connectionId: string);
+    protected get baseUrl(): string;
+    protected get headers(): Record<string, string>;
+    get(path: string, params?: Record<string, any>): Promise<any>;
+    post(path: string, body?: Record<string, any>): Promise<any>;
+    put(path: string, body?: Record<string, any>): Promise<any>;
+    patch(path: string, body?: Record<string, any>): Promise<any>;
+    delete(path: string): Promise<any>;
+}
+
+declare class BundleUp {
+    private apiKey;
+    constructor(apiKey: string);
+    connections(): Connections;
+    integrations(): Integrations;
+    webhooks(): Webhooks;
+    request(connectionId: string): BURequest;
+}
+
+export { BundleUp };

package/dist/index.d.ts

@@ -0,0 +1,75 @@
+declare abstract class Base<T> {
+    protected abstract path: string;
+    protected apiKey: string;
+    protected baseUrl: string;
+    protected version: string;
+    constructor(apiKey: string);
+    protected get apiUrl(): string;
+    protected get headers(): Record<string, string>;
+    list<K extends Record<string, any>>(params?: K): Promise<T[]>;
+    create<K extends Record<string, any>>(body: K): Promise<T>;
+    retrieve(id: string): Promise<T>;
+    update<K extends Record<string, any>>(id: string, body: K): Promise<T>;
+    del(id: string): Promise<void>;
+}
+
+interface Connection {
+    id: string;
+    externalId?: string;
+    expiresAt: Date;
+    integrationId: string;
+    isValid: boolean;
+    refreshedAt?: Date;
+    createdAt: Date;
+    updatedAt: Date;
+}
+declare class Connections extends Base<Connection> {
+    protected path: string;
+}
+
+interface Integration {
+    id: true;
+    identifier: true;
+    createdAt: true;
+    updatedAt: true;
+}
+declare class Integrations extends Base<Integration> {
+    protected path: string;
+}
+
+interface Webhook {
+    id: string;
+    name: string;
+    url: string;
+    events: Record<string, boolean>;
+    createdAt: Date;
+    updatedAt: Date;
+    lastTriggeredAt?: Date;
+}
+declare class Webhooks extends Base<Webhook> {
+    protected path: string;
+}
+
+declare class BURequest {
+    private apiKey;
+    private connectionId;
+    constructor(apiKey: string, connectionId: string);
+    protected get baseUrl(): string;
+    protected get headers(): Record<string, string>;
+    get(path: string, params?: Record<string, any>): Promise<any>;
+    post(path: string, body?: Record<string, any>): Promise<any>;
+    put(path: string, body?: Record<string, any>): Promise<any>;
+    patch(path: string, body?: Record<string, any>): Promise<any>;
+    delete(path: string): Promise<any>;
+}
+
+declare class BundleUp {
+    private apiKey;
+    constructor(apiKey: string);
+    connections(): Connections;
+    integrations(): Integrations;
+    webhooks(): Webhooks;
+    request(connectionId: string): BURequest;
+}
+
+export { BundleUp };

package/dist/index.js

@@ -0,0 +1,227 @@
+"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 src_exports = {};
+__export(src_exports, {
+  BundleUp: () => BundleUp
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/base.ts
+var Base = class {
+  constructor(apiKey) {
+    this.baseUrl = "https://api.bundleup.io";
+    this.version = "v1";
+    this.apiKey = apiKey;
+  }
+  get apiUrl() {
+    return `${this.baseUrl}/${this.version}`;
+  }
+  get headers() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  async list(params = {}) {
+    const response = await fetch(`${this.apiUrl}${this.path}`, {
+      method: "GET",
+      headers: this.headers,
+      body: JSON.stringify({
+        ...params
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${this.path}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async create(body) {
+    const response = await fetch(`${this.apiUrl}${this.path}`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create ${this.path}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async retrieve(id) {
+    const response = await fetch(`${this.apiUrl}${this.path}/${id}`, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to retrieve ${this.path}/${id}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async update(id, body) {
+    const response = await fetch(`${this.apiUrl}${this.path}/${id}`, {
+      method: "PATCH",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to update ${this.path}/${id}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async del(id) {
+    const response = await fetch(`${this.apiUrl}${this.path}/${id}`, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete ${this.path}/${id}: ${response.statusText}`);
+    }
+  }
+};
+
+// src/connection.ts
+var Connections = class extends Base {
+  constructor() {
+    super(...arguments);
+    this.path = "/connections";
+  }
+};
+
+// src/integration.ts
+var Integrations = class extends Base {
+  constructor() {
+    super(...arguments);
+    this.path = "/integrations";
+  }
+};
+
+// src/webhooks.ts
+var Webhooks = class extends Base {
+  constructor() {
+    super(...arguments);
+    this.path = "/webhooks";
+  }
+};
+
+// src/request.ts
+var BURequest = class {
+  constructor(apiKey, connectionId) {
+    this.apiKey = apiKey;
+    this.connectionId = connectionId;
+  }
+  get baseUrl() {
+    return "https://req.bundleup.io";
+  }
+  get headers() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      "BU-Connection-Id": this.connectionId
+    };
+  }
+  async get(path, params = {}) {
+    const queryString = new URLSearchParams(params).toString();
+    const url = queryString ? `${path}?${queryString}` : path;
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async post(path, body = {}) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to post to ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async put(path, body = {}) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "PUT",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to put to ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async patch(path, body = {}) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "PATCH",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to patch ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async delete(path) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+};
+
+// src/index.ts
+var BundleUp = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  connections() {
+    return new Connections(this.apiKey);
+  }
+  integrations() {
+    return new Integrations(this.apiKey);
+  }
+  webhooks() {
+    return new Webhooks(this.apiKey);
+  }
+  request(connectionId) {
+    if (!connectionId) {
+      throw new Error("Connection ID is required to create a Request instance.");
+    }
+    return new BURequest(this.apiKey, connectionId);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BundleUp
+});

package/dist/index.mjs

@@ -0,0 +1,200 @@
+// src/base.ts
+var Base = class {
+  constructor(apiKey) {
+    this.baseUrl = "https://api.bundleup.io";
+    this.version = "v1";
+    this.apiKey = apiKey;
+  }
+  get apiUrl() {
+    return `${this.baseUrl}/${this.version}`;
+  }
+  get headers() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`
+    };
+  }
+  async list(params = {}) {
+    const response = await fetch(`${this.apiUrl}${this.path}`, {
+      method: "GET",
+      headers: this.headers,
+      body: JSON.stringify({
+        ...params
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${this.path}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async create(body) {
+    const response = await fetch(`${this.apiUrl}${this.path}`, {
+      method: "POST",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to create ${this.path}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async retrieve(id) {
+    const response = await fetch(`${this.apiUrl}${this.path}/${id}`, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to retrieve ${this.path}/${id}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async update(id, body) {
+    const response = await fetch(`${this.apiUrl}${this.path}/${id}`, {
+      method: "PATCH",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to update ${this.path}/${id}: ${response.statusText}`);
+    }
+    const data = await response.json();
+    return data;
+  }
+  async del(id) {
+    const response = await fetch(`${this.apiUrl}${this.path}/${id}`, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete ${this.path}/${id}: ${response.statusText}`);
+    }
+  }
+};
+
+// src/connection.ts
+var Connections = class extends Base {
+  constructor() {
+    super(...arguments);
+    this.path = "/connections";
+  }
+};
+
+// src/integration.ts
+var Integrations = class extends Base {
+  constructor() {
+    super(...arguments);
+    this.path = "/integrations";
+  }
+};
+
+// src/webhooks.ts
+var Webhooks = class extends Base {
+  constructor() {
+    super(...arguments);
+    this.path = "/webhooks";
+  }
+};
+
+// src/request.ts
+var BURequest = class {
+  constructor(apiKey, connectionId) {
+    this.apiKey = apiKey;
+    this.connectionId = connectionId;
+  }
+  get baseUrl() {
+    return "https://req.bundleup.io";
+  }
+  get headers() {
+    return {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${this.apiKey}`,
+      "BU-Connection-Id": this.connectionId
+    };
+  }
+  async get(path, params = {}) {
+    const queryString = new URLSearchParams(params).toString();
+    const url = queryString ? `${path}?${queryString}` : path;
+    const response = await fetch(`${this.baseUrl}${url}`, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async post(path, body = {}) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to post to ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async put(path, body = {}) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "PUT",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to put to ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async patch(path, body = {}) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "PATCH",
+      headers: this.headers,
+      body: JSON.stringify(body)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to patch ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+  async delete(path) {
+    const response = await fetch(`${this.baseUrl}${path}`, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete ${path}: ${response.statusText}`);
+    }
+    return response.json();
+  }
+};
+
+// src/index.ts
+var BundleUp = class {
+  constructor(apiKey) {
+    this.apiKey = apiKey;
+  }
+  connections() {
+    return new Connections(this.apiKey);
+  }
+  integrations() {
+    return new Integrations(this.apiKey);
+  }
+  webhooks() {
+    return new Webhooks(this.apiKey);
+  }
+  request(connectionId) {
+    if (!connectionId) {
+      throw new Error("Connection ID is required to create a Request instance.");
+    }
+    return new BURequest(this.apiKey, connectionId);
+  }
+};
+export {
+  BundleUp
+};

package/dist/server.d.mts

@@ -0,0 +1,21 @@
+interface BundleUpConfig {
+    apiKey?: string;
+    debug?: boolean;
+}
+interface BundleUpResponse {
+    token: string;
+    expires_in: number;
+    externalId: string;
+}
+interface ConnectionOptions {
+    externalId?: string;
+    metadata?: Record<string, unknown>;
+}
+declare class BundleUp {
+    private config;
+    constructor(config?: BundleUpConfig);
+    private log;
+    createConnection(integrationId: string, options: ConnectionOptions): Promise<BundleUpResponse>;
+}
+
+export { BundleUp, BundleUpConfig, BundleUpResponse, ConnectionOptions };

package/dist/server.d.ts

@@ -0,0 +1,21 @@
+interface BundleUpConfig {
+    apiKey?: string;
+    debug?: boolean;
+}
+interface BundleUpResponse {
+    token: string;
+    expires_in: number;
+    externalId: string;
+}
+interface ConnectionOptions {
+    externalId?: string;
+    metadata?: Record<string, unknown>;
+}
+declare class BundleUp {
+    private config;
+    constructor(config?: BundleUpConfig);
+    private log;
+    createConnection(integrationId: string, options: ConnectionOptions): Promise<BundleUpResponse>;
+}
+
+export { BundleUp, BundleUpConfig, BundleUpResponse, ConnectionOptions };

package/dist/server.js

@@ -0,0 +1,94 @@
+"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/server.ts
+var server_exports = {};
+__export(server_exports, {
+  BundleUp: () => BundleUp
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/utils.ts
+function logger(isDebug) {
+  return (message, ...args) => {
+    if (!isDebug) {
+      return;
+    }
+    console.log("%c[BundleUp]", "color: #00f;", message, ...args);
+  };
+}
+
+// src/server.ts
+var BundleUp = class {
+  constructor(config = {}) {
+    if (!config.apiKey) {
+      throw new Error("API key is required for authentication");
+    }
+    this.config = {
+      apiKey: config.apiKey,
+      debug: config.debug ?? false
+    };
+  }
+  log(message, ...args) {
+    return logger(!!this.config.debug)(message, ...args);
+  }
+  async createConnection(integrationId, options) {
+    this.log(`Creating connection for integration: ${integrationId}`);
+    if (!integrationId) {
+      this.log("Integration ID is missing");
+      throw new Error("Integration ID is required to create a connection");
+    }
+    try {
+      const response = await fetch("https://auth.bundleup.io/authorize", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          integrationId,
+          externalId: options.externalId || void 0,
+          metadata: options.metadata || {}
+        })
+      });
+      if (!response.ok) {
+        this.log(
+          `Authentication request failed: ${response.status} ${response.statusText}`
+        );
+        throw new Error(
+          `Authentication request failed: ${response.status} ${response.statusText}`
+        );
+      }
+      const data = await response.json();
+      if (!data.token) {
+        this.log("Invalid response: could not create token", data);
+        throw new Error("Invalid response: could not create token");
+      }
+      this.log("Authentication token received successfully");
+      return data;
+    } catch (error) {
+      this.log("Error creating connection", error);
+      throw error;
+    }
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BundleUp
+});

package/dist/server.mjs

@@ -0,0 +1,61 @@
+import {
+  logger
+} from "./chunk-B6T6V2FR.mjs";
+
+// src/server.ts
+var BundleUp = class {
+  constructor(config = {}) {
+    if (!config.apiKey) {
+      throw new Error("API key is required for authentication");
+    }
+    this.config = {
+      apiKey: config.apiKey,
+      debug: config.debug ?? false
+    };
+  }
+  log(message, ...args) {
+    return logger(!!this.config.debug)(message, ...args);
+  }
+  async createConnection(integrationId, options) {
+    this.log(`Creating connection for integration: ${integrationId}`);
+    if (!integrationId) {
+      this.log("Integration ID is missing");
+      throw new Error("Integration ID is required to create a connection");
+    }
+    try {
+      const response = await fetch("https://auth.bundleup.io/authorize", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          Authorization: `Bearer ${this.config.apiKey}`
+        },
+        body: JSON.stringify({
+          integrationId,
+          externalId: options.externalId || void 0,
+          metadata: options.metadata || {}
+        })
+      });
+      if (!response.ok) {
+        this.log(
+          `Authentication request failed: ${response.status} ${response.statusText}`
+        );
+        throw new Error(
+          `Authentication request failed: ${response.status} ${response.statusText}`
+        );
+      }
+      const data = await response.json();
+      if (!data.token) {
+        this.log("Invalid response: could not create token", data);
+        throw new Error("Invalid response: could not create token");
+      }
+      this.log("Authentication token received successfully");
+      return data;
+    } catch (error) {
+      this.log("Error creating connection", error);
+      throw error;
+    }
+  }
+};
+export {
+  BundleUp
+};

package/dist/utils.d.mts

@@ -0,0 +1,5 @@
+declare function isClient(): boolean;
+declare function logger(isDebug: boolean): (message: string, ...args: any[]) => void;
+declare function isTrue(val?: string): boolean;
+
+export { isClient, isTrue, logger };

package/dist/utils.d.ts

@@ -0,0 +1,5 @@
+declare function isClient(): boolean;
+declare function logger(isDebug: boolean): (message: string, ...args: any[]) => void;
+declare function isTrue(val?: string): boolean;
+
+export { isClient, isTrue, logger };

package/dist/utils.js

@@ -0,0 +1,50 @@
+"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/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  isClient: () => isClient,
+  isTrue: () => isTrue,
+  logger: () => logger
+});
+module.exports = __toCommonJS(utils_exports);
+function isClient() {
+  return typeof window !== "undefined";
+}
+function logger(isDebug) {
+  return (message, ...args) => {
+    if (!isDebug) {
+      return;
+    }
+    console.log("%c[BundleUp]", "color: #00f;", message, ...args);
+  };
+}
+function isTrue(val) {
+  if (!val) {
+    return false;
+  }
+  return val.toLowerCase() === "true";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  isClient,
+  isTrue,
+  logger
+});

package/dist/utils.mjs

@@ -0,0 +1,10 @@
+import {
+  isClient,
+  isTrue,
+  logger
+} from "./chunk-B6T6V2FR.mjs";
+export {
+  isClient,
+  isTrue,
+  logger
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "@bundleup/sdk",
+  "version": "0.0.1",
+  "description": "SDK package for BundleUp",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src/",
+    "test": "jest",
+    "clean": "rm -rf dist"
+  },
+  "devDependencies": {
+    "tsup": "^7.0.0",
+    "typescript": "^5.0.0",
+    "eslint": "^8.0.0",
+    "jest": "^29.0.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "author": "BundleUp",
+  "license": "ISC"
+}