orita-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,268 @@
+// src/errors.ts
+var OritaError = class extends Error {
+  constructor(message, statusCode, response) {
+    super(message);
+    this.name = "OritaError";
+    this.statusCode = statusCode;
+    this.response = response;
+    const ErrCtor = Error;
+    if (ErrCtor.captureStackTrace) {
+      ErrCtor.captureStackTrace(this, this.constructor);
+    }
+  }
+};
+var OritaAuthError = class extends OritaError {
+  constructor(message = "Invalid or missing API key", response) {
+    super(message, 401, response);
+    this.name = "OritaAuthError";
+  }
+};
+var OritaNotFoundError = class extends OritaError {
+  constructor(message = "Resource not found", response) {
+    super(message, 404, response);
+    this.name = "OritaNotFoundError";
+  }
+};
+var OritaSlotUnavailableError = class extends OritaError {
+  constructor(message = "Slot is no longer available", response) {
+    super(message, 409, response);
+    this.name = "OritaSlotUnavailableError";
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://orita.online/api/v1";
+var OritaClient = class {
+  constructor(options) {
+    const { apiKey, baseUrl = DEFAULT_BASE_URL } = options;
+    if (!apiKey.startsWith("orita_")) {
+      throw new OritaAuthError("API key must start with 'orita_'");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+  }
+  // ── Private helpers ────────────────────────────────────────────────────────
+  buildUrl(path, params) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        url.searchParams.set(key, value);
+      }
+    }
+    return url.toString();
+  }
+  async request(method, path, options = {}) {
+    const url = this.buildUrl(path, options.params);
+    const init = {
+      method,
+      headers: {
+        Authorization: `Bearer ${this.apiKey}`,
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      }
+    };
+    if (options.body !== void 0) {
+      init.body = JSON.stringify(options.body);
+    }
+    let res;
+    try {
+      res = await fetch(url, init);
+    } catch (err) {
+      throw new OritaError(
+        `Network error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch {
+      throw new OritaError(`Invalid JSON response (HTTP ${res.status})`);
+    }
+    if (res.status === 401) {
+      const msg = json?.error ?? "Invalid or missing API key";
+      throw new OritaAuthError(msg, json);
+    }
+    if (res.status === 404) {
+      const msg = json?.error ?? "Resource not found";
+      throw new OritaNotFoundError(msg, json);
+    }
+    if (res.status === 409) {
+      const msg = json?.error ?? "Slot is no longer available";
+      throw new OritaSlotUnavailableError(msg, json);
+    }
+    if (!res.ok) {
+      const msg = json?.error ?? `HTTP ${res.status}`;
+      throw new OritaError(msg, res.status, json);
+    }
+    return json;
+  }
+  // ── Public API ─────────────────────────────────────────────────────────────
+  /**
+   * List all active event types for your account.
+   *
+   * @example
+   * const eventTypes = await orita.getEventTypes();
+   * // [{ id: "evt_abc123", title: "Initial Consultation", duration: 30, ... }]
+   */
+  async getEventTypes() {
+    const res = await this.request("GET", "/event-types");
+    return res.data;
+  }
+  /**
+   * Get available time slots for an event type on a given date.
+   *
+   * @param eventTypeId - Event type ID from `getEventTypes()`
+   * @param date - Date in `YYYY-MM-DD` format
+   *
+   * @example
+   * const { slots } = await orita.getSlots('evt_abc123', '2026-08-01');
+   * // [{ label: "09:00 AM", value: "09:00" }, ...]
+   */
+  async getSlots(eventTypeId, date) {
+    const res = await this.request(
+      "GET",
+      "/slots",
+      { params: { eventTypeId, date } }
+    );
+    return res;
+  }
+  /**
+   * Book an appointment. Returns the created booking object.
+   *
+   * @example
+   * const booking = await orita.book({
+   *   eventTypeId: 'evt_abc123',
+   *   date: '2026-08-01',
+   *   time: '10:00',
+   *   clientName: 'Ana',
+   *   clientLastname: 'López',
+   *   clientEmail: 'ana@example.com',
+   * });
+   * console.log(booking.id); // "book_xyz789"
+   */
+  async book(params) {
+    const body = {
+      eventTypeId: params.eventTypeId,
+      date: params.date,
+      time: params.time,
+      clientName: params.clientName,
+      clientLastname: params.clientLastname,
+      clientEmail: params.clientEmail
+    };
+    if (params.clientPhone) body.clientPhone = params.clientPhone;
+    if (params.clientTimezone) body.clientTimezone = params.clientTimezone;
+    if (params.notes) body.notes = params.notes;
+    const res = await this.request("POST", "/bookings", { body });
+    return res.data;
+  }
+  /**
+   * List your bookings with optional filtering.
+   *
+   * @example
+   * const bookings = await orita.getBookings({ status: 'confirmed' });
+   */
+  async getBookings(params = {}) {
+    const query = {};
+    if (params.page !== void 0) query.page = String(params.page);
+    if (params.limit !== void 0) query.limit = String(params.limit);
+    if (params.status) query.status = params.status;
+    const res = await this.request("GET", "/bookings", { params: query });
+    return res.data;
+  }
+  /**
+   * Retrieve a single booking by ID.
+   *
+   * @example
+   * const booking = await orita.getBooking('book_xyz789');
+   * console.log(booking.status); // "confirmed"
+   */
+  async getBooking(bookingId) {
+    const res = await this.request("GET", `/bookings/${bookingId}`);
+    return res.data;
+  }
+  /**
+   * Cancel a booking by ID.
+   *
+   * @param bookingId - The booking ID to cancel
+   * @param reason - Optional cancellation reason
+   *
+   * @example
+   * const result = await orita.cancelBooking('book_xyz789', 'Client requested reschedule');
+   */
+  async cancelBooking(bookingId, reason) {
+    const body = {};
+    if (reason) body.reason = reason;
+    const res = await this.request(
+      "POST",
+      `/bookings/${bookingId}/cancel`,
+      { body: Object.keys(body).length ? body : void 0 }
+    );
+    return res.data;
+  }
+  /**
+   * Get your own Capability Manifest (your profile).
+   * Requires authentication.
+   *
+   * @example
+   * const profile = await orita.getMyProfile();
+   * console.log(profile.username);
+   */
+  async getMyProfile() {
+    const res = await this.request("GET", "/profile");
+    return res.data;
+  }
+  /**
+   * Update your profile fields.
+   *
+   * @example
+   * const updated = await orita.updateProfile({ bio: 'AI-native therapist' });
+   */
+  async updateProfile(fields) {
+    const res = await this.request("PUT", "/profile", { body: fields });
+    return res.data;
+  }
+  /**
+   * Fetch the **public** Capability Manifest for any professional by username.
+   * No API key is needed for this request.
+   *
+   * @param username - The professional's username (e.g. "dra-martinez")
+   *
+   * @example
+   * const manifest = await orita.getProfile('dra-martinez');
+   * console.log(manifest.eventTypes);
+   */
+  async getProfile(username) {
+    const url = this.buildUrl("/profile", { username });
+    let res;
+    try {
+      res = await fetch(url, {
+        headers: { Accept: "application/json" }
+      });
+    } catch (err) {
+      throw new OritaError(
+        `Network error: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    let json;
+    try {
+      json = await res.json();
+    } catch {
+      throw new OritaError(`Invalid JSON response (HTTP ${res.status})`);
+    }
+    if (res.status === 404) {
+      throw new OritaNotFoundError(`Professional '${username}' not found`, json);
+    }
+    if (!res.ok) {
+      const msg = json?.error ?? `HTTP ${res.status}`;
+      throw new OritaError(msg, res.status, json);
+    }
+    return json.data;
+  }
+};
+export {
+  OritaAuthError,
+  OritaClient,
+  OritaError,
+  OritaNotFoundError,
+  OritaSlotUnavailableError
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "orita-sdk",
+  "version": "1.0.0",
+  "description": "The scheduling infrastructure for AI agents — official Node.js / TypeScript SDK",
+  "keywords": [
+    "orita",
+    "scheduling",
+    "ai",
+    "agents",
+    "booking",
+    "appointments",
+    "sdk"
+  ],
+  "homepage": "https://orita.online",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Alkilo-do/orita-node.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Alkilo-do/orita-node/issues"
+  },
+  "license": "MIT",
+  "author": "Alkilo-do",
+  "type": "module",
+  "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",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "typecheck": "tsc --noEmit",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}