hospitable 0.1.0

package/dist/index.js

@@ -0,0 +1,622 @@
+// src/auth/token-manager.ts
+var TokenManager = class {
+  constructor(config) {
+    this.config = config;
+    this.expiresAt = 0;
+    this.refreshPromise = null;
+    if (config.token && !config.refreshToken && !config.clientId) {
+      this.accessToken = config.token;
+      this.expiresAt = Infinity;
+    } else if (config.token) {
+      this.accessToken = config.token;
+      this.refreshToken = config.refreshToken;
+      this.expiresAt = Date.now() + 6e4;
+    } else {
+      const envPat = process.env["HOSPITABLE_PAT"];
+      if (envPat) {
+        this.accessToken = envPat;
+        this.expiresAt = Infinity;
+      }
+    }
+  }
+  async getAuthHeader() {
+    if (this.needsRefresh()) {
+      await this.ensureRefreshed();
+    }
+    if (!this.accessToken) {
+      throw new Error("No access token available. Provide token or clientId+clientSecret.");
+    }
+    return `Bearer ${this.accessToken}`;
+  }
+  needsRefresh() {
+    if (this.expiresAt === Infinity) return false;
+    return Date.now() >= this.expiresAt - 6e4;
+  }
+  async ensureRefreshed() {
+    if (this.refreshPromise) {
+      await this.refreshPromise;
+      return;
+    }
+    this.refreshPromise = this.doRefresh().finally(() => {
+      this.refreshPromise = null;
+    });
+    await this.refreshPromise;
+  }
+  async doRefresh() {
+    const { clientId, clientSecret, baseURL } = this.config;
+    if (!clientId || !clientSecret) {
+      throw new Error("Cannot refresh token: clientId and clientSecret are required");
+    }
+    const body = this.refreshToken ? new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: this.refreshToken,
+      client_id: clientId,
+      client_secret: clientSecret
+    }) : new URLSearchParams({
+      grant_type: "client_credentials",
+      client_id: clientId,
+      client_secret: clientSecret
+    });
+    const response = await fetch(`${baseURL}/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: body.toString()
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`Token refresh failed (${response.status}): ${text}`);
+    }
+    const data = await response.json();
+    this.accessToken = data.access_token;
+    if (data.refresh_token) this.refreshToken = data.refresh_token;
+    this.expiresAt = Date.now() + data.expires_in * 1e3;
+  }
+  async handleUnauthorized() {
+    this.expiresAt = 0;
+    await this.ensureRefreshed();
+  }
+};
+
+// src/errors.ts
+var HospitableError = class extends Error {
+  constructor(message, statusCode, requestId) {
+    super(message);
+    this.name = "HospitableError";
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+var AuthenticationError = class extends HospitableError {
+  constructor(message = "Authentication failed", requestId) {
+    super(message, 401, requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var RateLimitError = class extends HospitableError {
+  constructor(retryAfter, requestId) {
+    super(`Rate limit exceeded. Retry after ${retryAfter}s`, 429, requestId);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NotFoundError = class extends HospitableError {
+  constructor(message = "Resource not found", requestId, resource) {
+    super(message, 404, requestId);
+    this.name = "NotFoundError";
+    this.resource = resource;
+  }
+};
+var ValidationError = class extends HospitableError {
+  constructor(message, fields = {}, requestId) {
+    super(message, 422, requestId);
+    this.name = "ValidationError";
+    this.fields = fields;
+  }
+};
+var ForbiddenError = class extends HospitableError {
+  constructor(message = "Forbidden", requestId) {
+    super(message, 403, requestId);
+    this.name = "ForbiddenError";
+  }
+};
+var ServerError = class extends HospitableError {
+  constructor(message, statusCode, attempts, requestId) {
+    super(message, statusCode, requestId);
+    this.name = "ServerError";
+    this.attempts = attempts;
+  }
+};
+function createErrorFromResponse(statusCode, body, requestId, attempts = 1) {
+  const message = body["message"] ?? `HTTP ${statusCode}`;
+  switch (statusCode) {
+    case 401:
+      return new AuthenticationError(message, requestId);
+    case 403:
+      return new ForbiddenError(message, requestId);
+    case 404:
+      return new NotFoundError(message, requestId);
+    case 422: {
+      const errors = body["errors"] ?? {};
+      return new ValidationError(message, errors, requestId);
+    }
+    case 429: {
+      const retryAfter = body["retryAfter"] ?? 60;
+      return new RateLimitError(retryAfter, requestId);
+    }
+    default:
+      return new ServerError(message, statusCode, attempts, requestId);
+  }
+}
+
+// src/http/retry.ts
+var RETRYABLE_STATUS_CODES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+function jitteredDelay(base, attempt, max) {
+  const exponential = Math.min(base * Math.pow(2, attempt - 1), max);
+  const jitter = exponential * 0.25 * (Math.random() * 2 - 1);
+  return Math.max(0, exponential + jitter);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function withRetry(fn, endpoint, config = {}) {
+  const {
+    maxAttempts = 4,
+    baseDelay = 1e3,
+    maxDelay = 6e4,
+    onRateLimit
+  } = config;
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      const statusCode2 = getStatusCode(error);
+      if (statusCode2 === null || !RETRYABLE_STATUS_CODES.has(statusCode2)) {
+        throw error;
+      }
+      if (attempt === maxAttempts) {
+        break;
+      }
+      let delay;
+      if (statusCode2 === 429 && error instanceof Error) {
+        const retryAfter = extractRetryAfter(error);
+        delay = retryAfter > 0 ? retryAfter * 1e3 : jitteredDelay(baseDelay, attempt, maxDelay);
+        onRateLimit?.({ retryAfter, endpoint, attempt });
+      } else {
+        delay = jitteredDelay(baseDelay, attempt, maxDelay);
+      }
+      await sleep(delay);
+    }
+  }
+  const statusCode = getStatusCode(lastError) ?? 500;
+  const message = lastError instanceof Error ? lastError.message : `Request failed after ${maxAttempts} attempts`;
+  throw new ServerError(message, statusCode, maxAttempts);
+}
+function getStatusCode(error) {
+  if (error != null && typeof error === "object" && "statusCode" in error) {
+    const code = error.statusCode;
+    if (typeof code === "number") return code;
+  }
+  return null;
+}
+function extractRetryAfter(error) {
+  if ("retryAfter" in error && typeof error.retryAfter === "number") {
+    return error.retryAfter;
+  }
+  return 60;
+}
+
+// src/utils/sanitize.ts
+var PII_FIELD_PATTERN = /^(email|phone|firstName|lastName|passportNumber|fullName|dateOfBirth)$/i;
+var SENSITIVE_PATTERN = /token|secret|password|credential|apiKey|api_key/i;
+function sanitize(value, depth = 0) {
+  if (depth > 10) return value;
+  if (value === null || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map((item) => sanitize(item, depth + 1));
+  const result = {};
+  for (const [key, val] of Object.entries(value)) {
+    if (PII_FIELD_PATTERN.test(key) || SENSITIVE_PATTERN.test(key)) {
+      result[key] = "***";
+    } else {
+      result[key] = sanitize(val, depth + 1);
+    }
+  }
+  return result;
+}
+
+// src/http/client.ts
+var HttpError = class extends Error {
+  constructor(statusCode, message, requestId, body, attempts = 1) {
+    super(message);
+    this.statusCode = statusCode;
+    this.requestId = requestId;
+    this.body = body;
+    this.attempts = attempts;
+    this.name = "HttpError";
+  }
+};
+function buildURL(base, path, params) {
+  const url = new URL(path, base);
+  if (params) {
+    for (const [key, value] of Object.entries(params)) {
+      if (value === void 0) continue;
+      if (Array.isArray(value)) {
+        value.forEach((v) => url.searchParams.append(key, v));
+      } else {
+        url.searchParams.set(key, String(value));
+      }
+    }
+  }
+  return url.toString();
+}
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+  }
+  async request(path, options = {}) {
+    const { method = "GET", params, body, headers: extraHeaders = {} } = options;
+    const url = buildURL(this.config.baseURL, path, params);
+    return withRetry(
+      async () => {
+        const authHeader = await this.config.getAuthHeader();
+        const headers = {
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          Authorization: authHeader,
+          "User-Agent": `hospitable-ts/${VERSION}`,
+          ...extraHeaders
+        };
+        if (this.config.debug) {
+          console.debug(`[hospitable] ${method} ${url}`);
+          if (body !== void 0) {
+            console.debug("[hospitable] body:", sanitize(body));
+          }
+        }
+        const response = await fetch(url, {
+          method,
+          headers,
+          ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+        });
+        const requestId = response.headers.get("x-request-id") ?? void 0;
+        if (!response.ok) {
+          let errorBody = {};
+          try {
+            errorBody = await response.json();
+          } catch {
+          }
+          const message = errorBody["message"] ?? `HTTP ${response.status}`;
+          if (this.config.debug) {
+            console.debug("[hospitable] error body:", sanitize(errorBody));
+          }
+          if (response.status === 401 && this.config.onUnauthorized) {
+            await this.config.onUnauthorized();
+            const freshAuth = await this.config.getAuthHeader();
+            const retryResponse = await fetch(url, {
+              method,
+              headers: { ...headers, Authorization: freshAuth },
+              ...body !== void 0 ? { body: JSON.stringify(body) } : {}
+            });
+            if (retryResponse.ok) {
+              if (retryResponse.status === 204) return void 0;
+              return retryResponse.json();
+            }
+            let retryBody = {};
+            try {
+              retryBody = await retryResponse.json();
+            } catch {
+            }
+            const retryMessage = retryBody["message"] ?? `HTTP ${retryResponse.status}`;
+            throw new HttpError(retryResponse.status, retryMessage, retryResponse.headers.get("x-request-id") ?? void 0, retryBody);
+          }
+          throw new HttpError(response.status, message, requestId, errorBody);
+        }
+        if (response.status === 204) {
+          return void 0;
+        }
+        return response.json();
+      },
+      url,
+      this.config.retryConfig
+    );
+  }
+  get(path, params) {
+    return this.request(path, { method: "GET", ...params !== void 0 ? { params } : {} });
+  }
+  post(path, body) {
+    return this.request(path, { method: "POST", body });
+  }
+  put(path, body) {
+    return this.request(path, { method: "PUT", body });
+  }
+  patch(path, body) {
+    return this.request(path, { method: "PATCH", body });
+  }
+  delete(path) {
+    return this.request(path, { method: "DELETE" });
+  }
+};
+
+// src/resources/calendar.ts
+var CalendarResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async get(propertyId, startDate, endDate) {
+    return this.http.get(
+      `/v2/properties/${propertyId}/calendar`,
+      { startDate, endDate }
+    );
+  }
+  async update(propertyId, updates) {
+    await this.http.put(`/v2/properties/${propertyId}/calendar`, { data: updates });
+  }
+  async block(propertyId, startDate, endDate, reason) {
+    const body = { startDate, endDate };
+    if (reason !== void 0) body["reason"] = reason;
+    await this.http.post(`/v2/properties/${propertyId}/calendar/block`, body);
+  }
+  async unblock(propertyId, startDate, endDate) {
+    await this.http.post(`/v2/properties/${propertyId}/calendar/unblock`, {
+      startDate,
+      endDate
+    });
+  }
+};
+
+// src/resources/messages.ts
+var MessagesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(reservationId) {
+    return this.http.get(`/v2/reservations/${reservationId}/messages`);
+  }
+  async send(reservationId, body) {
+    const payload = { body };
+    return this.http.post(`/v2/reservations/${reservationId}/messages`, payload);
+  }
+  async listTemplates() {
+    const response = await this.http.get("/v2/message-templates");
+    return response.data;
+  }
+  async sendTemplate(reservationId, templateId, variables = {}) {
+    return this.http.post(
+      `/v2/reservations/${reservationId}/messages/template`,
+      { templateId, variables }
+    );
+  }
+};
+
+// src/resources/properties.ts
+var PropertiesResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params = {}) {
+    return this.http.get("/v2/properties", params);
+  }
+  async get(id) {
+    return this.http.get(`/v2/properties/${id}`);
+  }
+  async listTags(id) {
+    const response = await this.http.get(`/v2/properties/${id}/tags`);
+    return response.data;
+  }
+  async getCalendar(id, startDate, endDate) {
+    return this.http.get(`/v2/properties/${id}/calendar`, {
+      startDate,
+      endDate
+    });
+  }
+  async updateCalendar(id, updates) {
+    await this.http.put(`/v2/properties/${id}/calendar`, { data: updates });
+  }
+  async *iter(params = {}) {
+    let cursor = null;
+    do {
+      const listParams = { ...params };
+      if (cursor !== null) {
+        listParams.cursor = cursor;
+      }
+      const page = await this.list(listParams);
+      for (const item of page.data) {
+        yield item;
+      }
+      cursor = page.meta.nextCursor;
+    } while (cursor !== null);
+  }
+};
+
+// src/resources/reservations.ts
+var ReservationsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params = {}) {
+    const normalized = {
+      ...params,
+      properties: params.properties,
+      status: Array.isArray(params.status) ? params.status.join(",") : params.status
+    };
+    return this.http.get("/v2/reservations", normalized);
+  }
+  async get(id, include) {
+    return this.http.get(`/v2/reservations/${id}`, include ? { include } : void 0);
+  }
+  async getUpcoming(propertyIds, options = {}) {
+    const today = (/* @__PURE__ */ new Date()).toISOString().split("T")[0];
+    return this.list({
+      properties: propertyIds,
+      startDate: today,
+      status: "confirmed",
+      include: options.include ?? "guest,properties"
+    });
+  }
+  async *iter(params = {}) {
+    let cursor;
+    do {
+      const pageParams = { ...params };
+      if (cursor !== void 0) pageParams.cursor = cursor;
+      const page = await this.list(pageParams);
+      for (const item of page.data) {
+        yield item;
+      }
+      cursor = page.meta.nextCursor ?? void 0;
+    } while (cursor !== void 0);
+  }
+};
+
+// src/resources/reviews.ts
+var ReviewsResource = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async list(params = {}) {
+    const normalized = {
+      propertyId: params.propertyId,
+      responded: params.responded,
+      cursor: params.cursor,
+      perPage: params.perPage
+    };
+    return this.http.get("/v2/reviews", normalized);
+  }
+  async get(id) {
+    return this.http.get(`/v2/reviews/${id}`);
+  }
+  async respond(id, responseText) {
+    return this.http.post(`/v2/reviews/${id}/response`, { response: responseText });
+  }
+  async *iter(params = {}) {
+    let cursor = null;
+    do {
+      const pageParams = { ...params };
+      if (cursor !== null) pageParams.cursor = cursor;
+      const page = await this.list(pageParams);
+      for (const item of page.data) yield item;
+      cursor = page.meta.nextCursor;
+    } while (cursor !== null);
+  }
+};
+
+// src/client.ts
+var HospitableClient = class {
+  constructor(config = {}) {
+    const baseURL = config.baseURL ?? "https://api.hospitable.com";
+    const tokenConfig = {
+      ...config.token !== void 0 ? { token: config.token } : {},
+      ...config.refreshToken !== void 0 ? { refreshToken: config.refreshToken } : {},
+      ...config.clientId !== void 0 ? { clientId: config.clientId } : {},
+      ...config.clientSecret !== void 0 ? { clientSecret: config.clientSecret } : {},
+      baseURL
+    };
+    const tokenManager = new TokenManager(tokenConfig);
+    const httpClient = new HttpClient({
+      baseURL,
+      getAuthHeader: () => tokenManager.getAuthHeader(),
+      onUnauthorized: () => tokenManager.handleUnauthorized(),
+      ...config.debug !== void 0 ? { debug: config.debug } : {},
+      ...config.retry !== void 0 ? { retryConfig: config.retry } : {}
+    });
+    this.properties = new PropertiesResource(httpClient);
+    this.reservations = new ReservationsResource(httpClient);
+    this.calendar = new CalendarResource(httpClient);
+    this.messages = new MessagesResource(httpClient);
+    this.reviews = new ReviewsResource(httpClient);
+  }
+};
+
+// src/http/paginate.ts
+async function* paginate(fetcher, params, perPage = 100) {
+  let cursor = null;
+  do {
+    const page = await fetcher({
+      ...params,
+      cursor: cursor ?? void 0,
+      perPage
+    });
+    for (const item of page.data) {
+      yield item;
+    }
+    cursor = page.meta.nextCursor;
+  } while (cursor !== null);
+}
+async function collectAll(fetcher, params, perPage = 100) {
+  const results = [];
+  for await (const item of paginate(fetcher, params, perPage)) {
+    results.push(item);
+  }
+  return results;
+}
+
+// src/filters/reservation-filter.ts
+var ReservationFilter = class _ReservationFilter {
+  constructor(params = {}) {
+    this.params = params;
+  }
+  checkinAfter(date) {
+    return new _ReservationFilter({ ...this.params, startDate: date });
+  }
+  checkinBefore(date) {
+    return new _ReservationFilter({ ...this.params, endDate: date });
+  }
+  status(status) {
+    return new _ReservationFilter({ ...this.params, status });
+  }
+  properties(ids) {
+    return new _ReservationFilter({ ...this.params, properties: ids });
+  }
+  include(...fields) {
+    return new _ReservationFilter({ ...this.params, include: fields.join(",") });
+  }
+  perPage(n) {
+    return new _ReservationFilter({ ...this.params, perPage: n });
+  }
+  toParams() {
+    return { ...this.params };
+  }
+};
+
+// src/filters/property-filter.ts
+var PropertyFilter = class _PropertyFilter {
+  constructor(params = {}) {
+    this.params = params;
+  }
+  tags(tagIds) {
+    return new _PropertyFilter({ ...this.params, tags: tagIds });
+  }
+  perPage(n) {
+    return new _PropertyFilter({ ...this.params, perPage: n });
+  }
+  toParams() {
+    return { ...this.params };
+  }
+};
+
+// src/index.ts
+var VERSION = "0.1.0";
+export {
+  AuthenticationError,
+  CalendarResource,
+  ForbiddenError,
+  HospitableClient,
+  HospitableError,
+  MessagesResource,
+  NotFoundError,
+  PropertiesResource,
+  PropertyFilter,
+  RateLimitError,
+  ReservationFilter,
+  ReservationsResource,
+  ReviewsResource,
+  ServerError,
+  TokenManager,
+  VERSION,
+  ValidationError,
+  collectAll,
+  createErrorFromResponse,
+  paginate,
+  sanitize
+};
+//# sourceMappingURL=index.js.map