@spoot/hostfully-api 1.0.0

package/dist/src/FeesApi.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FeesApi = void 0;
+const zod_1 = require("zod");
+const enums_1 = require("./enums");
+const PropertyFeeSchema = zod_1.z.object({
+    uid: zod_1.z.string().uuid(),
+    propertyUid: zod_1.z.string().uuid(),
+    amount: zod_1.z.number(),
+    amountType: zod_1.z.enum(["TAX", "AMOUNT"]),
+    name: zod_1.z.string(),
+    optional: zod_1.z.boolean(),
+    scope: zod_1.z.enum(["PER_STAY", "PER_GUEST", "PER_NIGHT", "PER_GUEST_PER_NIGHT"]),
+    taxationRate: zod_1.z.number(),
+    type: zod_1.z.enum([
+        "CLEANING",
+        "EARLY_ARRIVAL",
+        "LATE_ARRIVAL",
+        "PET",
+        "TAX",
+        "CUSTOM",
+    ]),
+    airbnbType: enums_1.AirbnbFeeTypeSchema.nullable(),
+    bookingDotComType: enums_1.BookingDotComFeeTypeSchema.nullable(),
+    hostfullyType: zod_1.z.literal("DEFAULT").nullable(),
+    hvmiType: enums_1.MarriottFeeTypeSchema.nullable(),
+    vrboType: enums_1.VrboFeeTypeSchema.nullable(),
+});
+const GetPropertyFeeRepsonseSchema = zod_1.z.object({
+    fees: zod_1.z.array(PropertyFeeSchema),
+    _metadata: zod_1.z.object({
+        count: zod_1.z.number(),
+    }),
+});
+class FeesApi {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    async list(property) {
+        const resp = await this.api.transport.fetch({
+            method: "GET",
+            path: "/api/v3.1/fees",
+            query: { propertyUid: property.uid },
+            response: GetPropertyFeeRepsonseSchema,
+        });
+        if (resp._metadata.count > resp.fees.length) {
+            throw new Error(`Expected API to return ${resp._metadata.count} fees, got ${resp.fees.length}`);
+        }
+        return resp.fees;
+    }
+    async create(property, fields) {
+        const body = {
+            propertyUid: property.uid,
+            amount: fields.amount,
+            amountType: fields.amountType,
+            name: fields.name,
+            optional: fields.optional,
+            scope: fields.scope,
+            taxationRate: fields.taxationRate,
+            type: fields.type,
+            // OTS stuff
+            airbnbType: fields.airbnbType ?? null,
+            bookingDotComType: fields.bookingDotComType ?? null,
+            hostfullyType: fields.hostfullyType ?? null,
+            hvmiType: fields.hvmiType ?? null,
+            vrboType: "TAX",
+            // required, even though it's not used
+            attestation: false,
+            longTermStayExemption: 30,
+        };
+        await this.api.transport.fetch({
+            method: "POST",
+            path: "/api/v3.1/fees",
+            body: body,
+            response: null,
+        });
+    }
+    async delete(uid) {
+        await this.api.transport.fetch({
+            path: `/api/v3.1/fees/${uid}`,
+            method: "DELETE",
+            response: null,
+        });
+    }
+}
+exports.FeesApi = FeesApi;

package/dist/src/FetchTransport.d.ts

@@ -0,0 +1,17 @@
+import { GqlQuery } from "@spoot/gql";
+import { z } from "zod";
+import { FetchOptions } from "./Transport";
+export declare class FetchTransport {
+    private readonly graphqlUrl;
+    private readonly headers;
+    private readonly rateLimiting;
+    private readonly apiHost;
+    private readonly _fetch;
+    constructor(options: {
+        apiHost: URL;
+        apiKey: string;
+        globalFetch?: FetchTransport["_fetch"];
+    });
+    fetchGql<Response>(query: GqlQuery, schema: z.Schema<Response>): Promise<Response>;
+    fetch<Response>(options: FetchOptions<Response>): Promise<Response>;
+}

package/dist/src/FetchTransport.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchTransport = void 0;
+const gql_1 = require("@spoot/gql");
+const zod_1 = require("zod");
+const RateLimiting_1 = require("./RateLimiting");
+class FetchTransport {
+    graphqlUrl;
+    headers;
+    rateLimiting = new RateLimiting_1.RateLimiting();
+    apiHost;
+    _fetch;
+    constructor(options) {
+        this.apiHost = options.apiHost;
+        this._fetch =
+            options.globalFetch ??
+                (async (url, init) => {
+                    return await global.fetch(url, init).then(async (resp) => {
+                        const headers = {};
+                        resp.headers.forEach((v, k) => {
+                            headers[`${k}`.toLocaleLowerCase()] = `${v}`;
+                        });
+                        return {
+                            ok: resp.ok,
+                            status: resp.status,
+                            statusText: resp.statusText,
+                            headers,
+                            async json() {
+                                return await resp.json();
+                            },
+                            async text() {
+                                return await resp.text();
+                            },
+                        };
+                    });
+                });
+        this.graphqlUrl = new URL("/api/v3/graphql", options.apiHost);
+        this.headers = {
+            "X-HOSTFULLY-APIKEY": options.apiKey,
+            "content-type": "application/json",
+        };
+    }
+    async fetchGql(query, schema) {
+        await this.rateLimiting.take();
+        const reqBody = JSON.stringify({
+            query: (0, gql_1.printGql)(query),
+        }, null, 2);
+        const resp = await this._fetch(this.graphqlUrl, {
+            method: "POST",
+            headers: this.headers,
+            body: reqBody,
+        });
+        this.rateLimiting.onResponse(resp.headers);
+        if (!resp.ok) {
+            throw new Error(`GraphQL query failed: ${reqBody}\n-- Response --\n ${resp.status} ${resp.statusText}: ${await resp.text()}`);
+        }
+        const respBody = zod_1.z
+            .object({
+            errors: zod_1.z.unknown().optional(),
+            data: zod_1.z.unknown().optional(),
+        })
+            .parse(await resp.json());
+        if (respBody.errors) {
+            const errs = JSON.stringify(respBody.errors, null, 2);
+            throw new Error(`GraphQL query failed: ${reqBody}\n-- Errors --\n ${errs}`);
+        }
+        return schema.parse(respBody.data);
+    }
+    async fetch(options) {
+        await this.rateLimiting.take();
+        const url = new URL(options.path, this.apiHost);
+        if (options.query) {
+            for (const [key, value] of Object.entries(options.query)) {
+                if (value != null) {
+                    url.searchParams.set(key, value);
+                }
+            }
+        }
+        const resp = await this._fetch(url, {
+            method: options.method,
+            headers: this.headers,
+            body: options.body ? JSON.stringify(options.body) : undefined,
+        });
+        this.rateLimiting.onResponse(resp.headers);
+        if (!resp.ok) {
+            throw new Error(`Failed to fetch ${options.path}: ${resp.statusText}: ${await resp.text()}`);
+        }
+        if (!options.response) {
+            return {};
+        }
+        const parsed = options.response.safeParse(await resp.json());
+        if (parsed.success) {
+            return parsed.data;
+        }
+        throw new Error(`Failed to ${options.method} ${options.path}: ${JSON.stringify(parsed.error, null, 2)}`);
+    }
+}
+exports.FetchTransport = FetchTransport;

package/dist/src/HostfullyApi.d.ts

@@ -0,0 +1,22 @@
+import { PropertiesApi } from "./PropertiesApi";
+import { FeesApi } from "./FeesApi";
+import { PricingApi } from "./PricingApi";
+import { LeadsApi } from "./LeadsApi";
+import { MessagesApi } from "./MessagesApi";
+import { AgenciesApi } from "./AgenciesApi";
+import { Transport } from "./Transport";
+import { OrderApi } from "./OrderApi";
+import { AmenitiesApi } from "./AmenitiesApi";
+export declare class HostfullyApi {
+    readonly agencyUid: string;
+    readonly transport: Transport;
+    constructor(agencyUid: string, transport: Transport);
+    get agencies(): AgenciesApi;
+    get properties(): PropertiesApi;
+    get fees(): FeesApi;
+    get pricing(): PricingApi;
+    get leads(): LeadsApi;
+    get messages(): MessagesApi;
+    get orders(): OrderApi;
+    get amenities(): AmenitiesApi;
+}

package/dist/src/HostfullyApi.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HostfullyApi = void 0;
+const PropertiesApi_1 = require("./PropertiesApi");
+const FeesApi_1 = require("./FeesApi");
+const PricingApi_1 = require("./PricingApi");
+const LeadsApi_1 = require("./LeadsApi");
+const MessagesApi_1 = require("./MessagesApi");
+const AgenciesApi_1 = require("./AgenciesApi");
+const OrderApi_1 = require("./OrderApi");
+const AmenitiesApi_1 = require("./AmenitiesApi");
+class HostfullyApi {
+    agencyUid;
+    transport;
+    constructor(agencyUid, transport) {
+        this.agencyUid = agencyUid;
+        this.transport = transport;
+    }
+    get agencies() {
+        return new AgenciesApi_1.AgenciesApi(this);
+    }
+    get properties() {
+        return new PropertiesApi_1.PropertiesApi(this);
+    }
+    get fees() {
+        return new FeesApi_1.FeesApi(this);
+    }
+    get pricing() {
+        return new PricingApi_1.PricingApi(this);
+    }
+    get leads() {
+        return new LeadsApi_1.LeadsApi(this);
+    }
+    get messages() {
+        return new MessagesApi_1.MessagesApi(this);
+    }
+    get orders() {
+        return new OrderApi_1.OrderApi(this);
+    }
+    get amenities() {
+        return new AmenitiesApi_1.AmenitiesApi(this);
+    }
+}
+exports.HostfullyApi = HostfullyApi;