@beepsdev/sdk 0.0.3

package/dist/index.js

@@ -0,0 +1,767 @@
+// src/version.ts
+var SDK_VERSION = "0.0.1";
+
+// src/errors.ts
+var BeepsError = class extends Error {
+  code;
+  status;
+  requestId;
+  retryable;
+  cause;
+  constructor(message, options) {
+    super(message);
+    this.name = "BeepsError";
+    this.code = options?.code;
+    this.status = options?.status;
+    this.requestId = options?.requestId;
+    this.retryable = options?.retryable ?? false;
+    this.cause = options?.cause;
+  }
+  toString() {
+    const parts = [
+      `BeepsError`,
+      this.code ? `Code=${this.code}` : null,
+      this.status ? `status=${this.status}` : null,
+      this.requestId ? `requestId=${this.requestId}` : null,
+      this.retryable ? `retryable=true` : null
+    ].filter(Boolean);
+    return `${parts.join(" ")}: ${this.message}`;
+  }
+};
+var AuthError = class extends BeepsError {
+  constructor(message = "Unauthorized", opts) {
+    super(message, { ...opts, status: opts?.status ?? 401 });
+    this.name = "AuthError";
+  }
+};
+var ValidationError = class extends BeepsError {
+  details;
+  constructor(message = "Validation error", opts) {
+    super(message, { ...opts, status: opts?.status ?? 400 });
+    this.name = "ValidationError";
+    this.details = opts?.details;
+  }
+};
+var NotFoundError = class extends BeepsError {
+  constructor(message = "Not found", opts) {
+    super(message, { ...opts, status: opts?.status ?? 404 });
+    this.name = "NotFoundError";
+  }
+};
+var RateLimitError = class extends BeepsError {
+  constructor(message = "Rate limited", opts) {
+    super(message, { ...opts, status: opts?.status ?? 429, retryable: true });
+    this.name = "RateLimitError";
+  }
+};
+var ServerError = class extends BeepsError {
+  constructor(message = "Server error", opts) {
+    super(message, { ...opts, status: opts?.status ?? 500, retryable: true });
+    this.name = "ServerError";
+  }
+};
+var NetworkError = class extends BeepsError {
+  constructor(message = "Network error", opts) {
+    super(message, { ...opts });
+    this.name = "NetworkError";
+  }
+};
+var HttpError = class extends BeepsError {
+  constructor(message = "HTTP error", opts) {
+    super(message, { ...opts });
+    this.name = "HttpError";
+  }
+};
+function mapHttpError(status, message, requestId) {
+  if (status === 401 || status === 403)
+    return new AuthError(message, { status, requestId });
+  if (status === 400)
+    return new ValidationError(message, { status, requestId });
+  if (status === 404) return new NotFoundError(message, { status, requestId });
+  if (status === 429) return new RateLimitError(message, { status, requestId });
+  if (status >= 500) return new ServerError(message, { status, requestId });
+  return new HttpError(message, { status, requestId });
+}
+
+// src/http.ts
+var HttpClient = class {
+  cfg;
+  _fetch;
+  constructor(config) {
+    const baseURL = config.baseURL ?? "https://api.beeps.dev/v0";
+    const timeoutMs = config.timeoutMs ?? 1e4;
+    const retries = config.retries ?? { attempts: 2, backoffMs: 300 };
+    this.cfg = { ...config, baseURL, timeoutMs, retries };
+    this._fetch = config.fetch ?? fetch;
+  }
+  async post(path, body) {
+    return this.request("POST", path, body);
+  }
+  async get(path) {
+    return this.request("GET", path);
+  }
+  async put(path, body) {
+    return this.request("PUT", path, body);
+  }
+  async patch(path, body) {
+    return this.request("PATCH", path, body);
+  }
+  async delete(path) {
+    return this.request("DELETE", path);
+  }
+  async request(method, path, body) {
+    const url = this.cfg.baseURL.replace(/\/+$/, "") + "/" + path.replace(/^\/+/, "");
+    const controller = new AbortController();
+    const id = setTimeout(() => controller.abort(), this.cfg.timeoutMs);
+    try {
+      let attempt = 0;
+      while (true) {
+        try {
+          const res = await this._fetch(url, {
+            method,
+            headers: {
+              "Content-Type": "application/json",
+              "X-API-Key": this.cfg.apiKey,
+              "User-Agent": `beepsdev-sdk/${SDK_VERSION}`
+            },
+            body: body !== void 0 ? JSON.stringify(body) : void 0,
+            signal: controller.signal
+          });
+          const requestId = res.headers.get("x-request-id") ?? void 0;
+          const isJson = (res.headers.get("content-type") || "").includes(
+            "application/json"
+          );
+          const payload = isJson ? await res.json().catch(() => ({})) : {};
+          if (res.ok) {
+            return payload;
+          }
+          const msg = typeof payload.error === "string" ? payload.error : typeof payload.message === "string" ? payload.message : "Request failed";
+          const err = mapHttpError(res.status, msg, requestId);
+          if (this.shouldRetry(res.status) && attempt < this.cfg.retries.attempts) {
+            attempt++;
+            await this.sleep(this.jitterBackoff(attempt));
+            continue;
+          }
+          throw err;
+        } catch (e) {
+          if (e instanceof BeepsError) {
+            throw e;
+          }
+          if (e instanceof Error && e.name === "AbortError") {
+            throw new NetworkError("Request timed out", { cause: e });
+          }
+          if (e instanceof TypeError) {
+            if (attempt < this.cfg.retries.attempts) {
+              attempt++;
+              await this.sleep(this.jitterBackoff(attempt));
+              continue;
+            }
+            throw new NetworkError("Network error", { cause: e });
+          }
+          throw e;
+        }
+      }
+    } finally {
+      clearTimeout(id);
+    }
+  }
+  shouldRetry(status) {
+    if (status === 429) return true;
+    if (status >= 500 && status !== 501 && status !== 505) return true;
+    return false;
+  }
+  jitterBackoff(attempt) {
+    const base = this.cfg.retries.backoffMs * Math.pow(2, attempt - 1);
+    const jitter = Math.random() * 100;
+    return base + jitter;
+  }
+  sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+  }
+};
+
+// src/resources/relay-rules.ts
+var RelayRulesResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list(relayId, params) {
+    const qs = new URLSearchParams();
+    if (params?.enabled !== void 0) {
+      qs.set("enabled", params.enabled.toString());
+    }
+    if (params?.ruleType) {
+      qs.set("ruleType", params.ruleType);
+    }
+    const path = qs.toString() ? `/relay/${relayId}/rules?${qs.toString()}` : `/relay/${relayId}/rules`;
+    const res = await this.http.get(path);
+    return res.rules;
+  }
+  async create(relayId, input) {
+    const res = await this.http.post(`/relay/${relayId}/rules`, input);
+    return res.rule;
+  }
+  async get(relayId, ruleId) {
+    const res = await this.http.get(`/relay/${relayId}/rules/${ruleId}`);
+    return res.rule;
+  }
+  async update(relayId, ruleId, input) {
+    const res = await this.http.put(`/relay/${relayId}/rules/${ruleId}`, input);
+    return res.rule;
+  }
+  async delete(relayId, ruleId) {
+    const res = await this.http.delete(`/relay/${relayId}/rules/${ruleId}`);
+    return res;
+  }
+  async reorder(relayId, input) {
+    const res = await this.http.put(`/relay/${relayId}/rules/reorder`, input);
+    return res.rules;
+  }
+  // Safe versions that return Result<T> instead of throwing
+  async listSafe(relayId, params) {
+    try {
+      const data = await this.list(relayId, params);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async createSafe(relayId, input) {
+    try {
+      const data = await this.create(relayId, input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async getSafe(relayId, ruleId) {
+    try {
+      const data = await this.get(relayId, ruleId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async updateSafe(relayId, ruleId, input) {
+    try {
+      const data = await this.update(relayId, ruleId, input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async deleteSafe(relayId, ruleId) {
+    try {
+      const data = await this.delete(relayId, ruleId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async reorderSafe(relayId, input) {
+    try {
+      const data = await this.reorder(relayId, input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+};
+
+// src/resources/relay.ts
+var RelayResource = class {
+  http;
+  rules;
+  constructor(http) {
+    this.http = http;
+    this.rules = new RelayRulesResource(http);
+  }
+  async create(input) {
+    const res = await this.http.post("/relay", input);
+    return res.relay;
+  }
+  async list() {
+    const res = await this.http.get("/relay");
+    return res.relays;
+  }
+  async lint(relayId, input = {}) {
+    const res = await this.http.post(
+      `/relay/${relayId}/lint`,
+      input
+    );
+    return res;
+  }
+  async simulate(relayId, input) {
+    const res = await this.http.post(
+      `/relay/${relayId}/simulate`,
+      input
+    );
+    return res;
+  }
+  async createSafe(input) {
+    try {
+      const data = await this.create(input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async lintSafe(relayId, input = {}) {
+    try {
+      const data = await this.lint(relayId, input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async simulateSafe(relayId, input) {
+    try {
+      const data = await this.simulate(relayId, input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+};
+
+// src/utils/date.ts
+function formatUTCDate(date) {
+  return date.toISOString();
+}
+function isIsoZ(value) {
+  return value.endsWith("Z") && !isNaN(Date.parse(value));
+}
+function normalizeDateParam(date) {
+  if (date instanceof Date) {
+    return formatUTCDate(date);
+  }
+  if (typeof date === "string") {
+    if (!isIsoZ(date)) {
+      throw new Error(
+        `Invalid date format. Date must be a valid ISO 8601 timestamp with Z suffix (e.g., "2024-01-29T00:00:00.000Z"). Received: "${date}"`
+      );
+    }
+    return date;
+  }
+  throw new Error(
+    `Invalid date type. Expected Date object or ISO 8601 string with Z suffix, received: ${typeof date}`
+  );
+}
+
+// src/resources/schedule.ts
+var ScheduleResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async create(input) {
+    const res = await this.http.post("/schedule", input);
+    return res.schedule;
+  }
+  async list() {
+    const res = await this.http.get("/schedule");
+    return res.schedules;
+  }
+  async addMember(scheduleId, input) {
+    const res = await this.http.post(
+      `/schedule/${scheduleId}/members`,
+      input
+    );
+    return res.member;
+  }
+  async listMembers(scheduleId) {
+    const res = await this.http.get(
+      `/schedule/${scheduleId}/members`
+    );
+    return res.members;
+  }
+  async listMembersSafe(scheduleId) {
+    try {
+      const data = await this.listMembers(scheduleId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async removeMember(scheduleId, userId) {
+    const res = await this.http.delete(
+      `/schedule/${scheduleId}/members/${userId}`
+    );
+    return res.member;
+  }
+  async getAssignments(scheduleId, params) {
+    const qs = new URLSearchParams();
+    if (params) {
+      if (params.type === "until") {
+        qs.set("type", "until");
+        const normalizedDate = normalizeDateParam(params.date);
+        qs.set("date", normalizedDate);
+      } else if (params.type === "days") {
+        qs.set("type", "days");
+        qs.set("count", String(params.count));
+      } else {
+        if (params.type) {
+          qs.set("type", params.type);
+        }
+        if (params.count !== void 0) {
+          qs.set("count", String(params.count));
+        }
+      }
+    }
+    const path = qs.toString() ? `/schedule/${scheduleId}/assignments?${qs.toString()}` : `/schedule/${scheduleId}/assignments`;
+    const res = await this.http.get(path);
+    return res.assignments;
+  }
+  async getOnCall(scheduleId) {
+    const res = await this.http.get(
+      `/schedule/${scheduleId}/on-call`
+    );
+    return res.onCall;
+  }
+  async getOnCallSafe(scheduleId) {
+    try {
+      const data = await this.getOnCall(scheduleId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async createOverride(scheduleId, input) {
+    const body = {
+      userId: input.userId,
+      startAt: normalizeDateParam(input.startAt),
+      endAt: normalizeDateParam(input.endAt),
+      reason: input.reason
+    };
+    const res = await this.http.post(
+      `/schedule/${scheduleId}/overrides`,
+      body
+    );
+    return res.override;
+  }
+  async listOverrides(scheduleId, params) {
+    const qs = new URLSearchParams();
+    if (params) {
+      if (params.startAt) {
+        qs.set("startAt", normalizeDateParam(params.startAt));
+      }
+      if (params.endAt) {
+        qs.set("endAt", normalizeDateParam(params.endAt));
+      }
+    }
+    const path = qs.toString() ? `/schedule/${scheduleId}/overrides?${qs.toString()}` : `/schedule/${scheduleId}/overrides`;
+    const res = await this.http.get(path);
+    return res.overrides;
+  }
+  async cancelOverride(scheduleId, overrideId) {
+    const res = await this.http.delete(
+      `/schedule/${scheduleId}/overrides/${overrideId}`
+    );
+    return res.override;
+  }
+  async updateOverride(scheduleId, overrideId, input) {
+    const body = {};
+    if (input.startAt !== void 0) {
+      body.startAt = normalizeDateParam(input.startAt);
+    }
+    if (input.endAt !== void 0) {
+      body.endAt = normalizeDateParam(input.endAt);
+    }
+    if (input.reason !== void 0) {
+      body.reason = input.reason;
+    }
+    const res = await this.http.patch(
+      `/schedule/${scheduleId}/overrides/${overrideId}`,
+      body
+    );
+    return res.override;
+  }
+};
+
+// src/resources/contact-method.ts
+var ContactMethodResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params) {
+    const qs = new URLSearchParams();
+    qs.set("userId", params.userId);
+    const res = await this.http.get(
+      `/contact-methods?${qs.toString()}`
+    );
+    return res.contactMethods;
+  }
+  async create(input) {
+    const res = await this.http.post(
+      "/contact-methods",
+      input
+    );
+    return res.contactMethod;
+  }
+  async delete(id, params) {
+    const qs = new URLSearchParams();
+    qs.set("userId", params.userId);
+    const res = await this.http.delete(
+      `/contact-methods/${id}?${qs.toString()}`
+    );
+    return res;
+  }
+  async listSafe(params) {
+    try {
+      const data = await this.list(params);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async createSafe(input) {
+    try {
+      const data = await this.create(input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async deleteSafe(id, params) {
+    try {
+      const data = await this.delete(id, params);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+};
+
+// src/resources/alert.ts
+var AlertResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const res = await this.http.get("/alerts");
+    return res.alerts;
+  }
+  async listActive() {
+    const res = await this.http.get("/alerts/active");
+    return res.alerts;
+  }
+  async listResolved() {
+    const res = await this.http.get("/alerts/resolved");
+    return res.alerts;
+  }
+  async get(alertId) {
+    const res = await this.http.get(`/alerts/${alertId}`);
+    return res.alert;
+  }
+  async acknowledge(alertId, input) {
+    const res = await this.http.post(
+      `/alerts/${alertId}/acknowledge`,
+      input || {}
+    );
+    return res.alert;
+  }
+  async resolve(alertId) {
+    const res = await this.http.post(
+      `/alerts/${alertId}/resolve`,
+      {}
+    );
+    return res.alert;
+  }
+  async assign(alertId, userId) {
+    const res = await this.http.post(
+      `/alerts/${alertId}/assign`,
+      { userId }
+    );
+    return res.alert;
+  }
+  async listSafe() {
+    try {
+      const data = await this.list();
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async listActiveSafe() {
+    try {
+      const data = await this.listActive();
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async listResolvedSafe() {
+    try {
+      const data = await this.listResolved();
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async getSafe(alertId) {
+    try {
+      const data = await this.get(alertId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async acknowledgeSafe(alertId, input) {
+    try {
+      const data = await this.acknowledge(alertId, input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async resolveSafe(alertId) {
+    try {
+      const data = await this.resolve(alertId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async assignSafe(alertId, userId) {
+    try {
+      const data = await this.assign(alertId, userId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+};
+
+// src/resources/integration.ts
+var IntegrationResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const res = await this.http.get("/integrations");
+    return res.integrations;
+  }
+  async create(input) {
+    const res = await this.http.post("/integrations", input);
+    return res.integration;
+  }
+  async get(integrationId) {
+    const res = await this.http.get(`/integrations/${integrationId}`);
+    return res.integration;
+  }
+  async update(integrationId, input) {
+    const res = await this.http.put(`/integrations/${integrationId}`, input);
+    return res.integration;
+  }
+  async delete(integrationId) {
+    const res = await this.http.delete(`/integrations/${integrationId}`);
+    return res;
+  }
+  async listSafe() {
+    try {
+      const data = await this.list();
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async createSafe(input) {
+    try {
+      const data = await this.create(input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async getSafe(integrationId) {
+    try {
+      const data = await this.get(integrationId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async updateSafe(integrationId, input) {
+    try {
+      const data = await this.update(integrationId, input);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async deleteSafe(integrationId) {
+    try {
+      const data = await this.delete(integrationId);
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+};
+
+// src/resources/member.ts
+var MemberResource = class {
+  http;
+  constructor(http) {
+    this.http = http;
+  }
+  async list() {
+    const res = await this.http.get("/members");
+    return res.members;
+  }
+  async listSafe() {
+    try {
+      const data = await this.list();
+      return { data };
+    } catch (error) {
+      return { error };
+    }
+  }
+};
+
+// src/client.ts
+var BeepsClient = class {
+  relay;
+  schedule;
+  contactMethod;
+  alert;
+  integration;
+  member;
+  constructor(config) {
+    if (!config.apiKey) {
+      throw new Error("apiKey is required");
+    }
+    const http = new HttpClient(config);
+    this.relay = new RelayResource(http);
+    this.schedule = new ScheduleResource(http);
+    this.contactMethod = new ContactMethodResource(http);
+    this.alert = new AlertResource(http);
+    this.integration = new IntegrationResource(http);
+    this.member = new MemberResource(http);
+  }
+};
+export {
+  AlertResource,
+  AuthError,
+  BeepsClient,
+  BeepsError,
+  ContactMethodResource,
+  HttpError,
+  MemberResource,
+  NetworkError,
+  NotFoundError,
+  RateLimitError,
+  RelayRulesResource,
+  ScheduleResource,
+  ServerError,
+  ValidationError,
+  formatUTCDate,
+  isIsoZ,
+  mapHttpError,
+  normalizeDateParam
+};
+//# sourceMappingURL=index.js.map