@spoot/hostfully-api 1.0.0

package/dist/src/PricingApi.d.ts

@@ -0,0 +1,137 @@
+import { z } from "zod";
+import { Day } from "@spoot/day";
+import { Schedule, Segment } from "@spoot/schedule";
+import { Property } from "./PropertiesApi";
+import { HostfullyApi } from "./HostfullyApi";
+export declare function batches<T>(size: number, array: T[]): Generator<T[], void, unknown>;
+interface PropertyPricingConfig {
+    dailyRate: string;
+    minimumStay: number;
+    minimumWeekendStay: number;
+    weekendRate: string;
+    daysOfTheWeekToCheckInOn: Set<number>;
+}
+interface PricingOverride {
+    day: Day;
+    price: string;
+    minNights: number;
+    canCheckin: boolean;
+    canCheckout: boolean;
+}
+export type PricingScheduleData = {
+    price: string;
+    minNights: number;
+    canCheckin: boolean;
+    canCheckout: boolean;
+};
+export type PricingSchedule = Schedule<PricingScheduleData>;
+export type PricingSegment = Segment<PricingScheduleData>;
+declare const PricingRulePricingRuleSchema: z.ZodObject<{
+    uid: z.ZodString;
+    ruleType: z.ZodEnum<["LAST_MINUTE_DISCOUNT", "EARLY_BIRD_DISCOUNT"]>;
+    threshold: z.ZodNumber;
+    priceChange: z.ZodNumber;
+    priceChangeType: z.ZodLiteral<"PERCENT">;
+}, "strip", z.ZodTypeAny, {
+    uid: string;
+    ruleType: "LAST_MINUTE_DISCOUNT" | "EARLY_BIRD_DISCOUNT";
+    threshold: number;
+    priceChange: number;
+    priceChangeType: "PERCENT";
+}, {
+    uid: string;
+    ruleType: "LAST_MINUTE_DISCOUNT" | "EARLY_BIRD_DISCOUNT";
+    threshold: number;
+    priceChange: number;
+    priceChangeType: "PERCENT";
+}>;
+declare const PricingRulesSchema: z.ZodObject<{
+    increaseRate: z.ZodNullable<z.ZodNumber>;
+    increaseRateLowerBound: z.ZodNullable<z.ZodNumber>;
+    decreaseRate: z.ZodNullable<z.ZodNumber>;
+    decreaseRateHigherBound: z.ZodNullable<z.ZodNumber>;
+    decreaseRateMonthly: z.ZodNullable<z.ZodNumber>;
+    decreaseRateHigherBoundMonthly: z.ZodNullable<z.ZodNumber>;
+    enabledForAirbnb: z.ZodBoolean;
+    pricingRules: z.ZodArray<z.ZodObject<{
+        uid: z.ZodString;
+        ruleType: z.ZodEnum<["LAST_MINUTE_DISCOUNT", "EARLY_BIRD_DISCOUNT"]>;
+        threshold: z.ZodNumber;
+        priceChange: z.ZodNumber;
+        priceChangeType: z.ZodLiteral<"PERCENT">;
+    }, "strip", z.ZodTypeAny, {
+        uid: string;
+        ruleType: "LAST_MINUTE_DISCOUNT" | "EARLY_BIRD_DISCOUNT";
+        threshold: number;
+        priceChange: number;
+        priceChangeType: "PERCENT";
+    }, {
+        uid: string;
+        ruleType: "LAST_MINUTE_DISCOUNT" | "EARLY_BIRD_DISCOUNT";
+        threshold: number;
+        priceChange: number;
+        priceChangeType: "PERCENT";
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    increaseRate: number | null;
+    increaseRateLowerBound: number | null;
+    decreaseRate: number | null;
+    decreaseRateHigherBound: number | null;
+    decreaseRateMonthly: number | null;
+    decreaseRateHigherBoundMonthly: number | null;
+    enabledForAirbnb: boolean;
+    pricingRules: {
+        uid: string;
+        ruleType: "LAST_MINUTE_DISCOUNT" | "EARLY_BIRD_DISCOUNT";
+        threshold: number;
+        priceChange: number;
+        priceChangeType: "PERCENT";
+    }[];
+}, {
+    increaseRate: number | null;
+    increaseRateLowerBound: number | null;
+    decreaseRate: number | null;
+    decreaseRateHigherBound: number | null;
+    decreaseRateMonthly: number | null;
+    decreaseRateHigherBoundMonthly: number | null;
+    enabledForAirbnb: boolean;
+    pricingRules: {
+        uid: string;
+        ruleType: "LAST_MINUTE_DISCOUNT" | "EARLY_BIRD_DISCOUNT";
+        threshold: number;
+        priceChange: number;
+        priceChangeType: "PERCENT";
+    }[];
+}>;
+export type PricingRules = z.infer<typeof PricingRulesSchema>;
+export type PricingRulesPricingRule = z.infer<typeof PricingRulePricingRuleSchema>;
+export type PricingRulesUpdate = Omit<PricingRules, "pricingRules"> & {
+    pricingRules: Array<Omit<PricingRulesPricingRule, "uid"> & {
+        uid?: string;
+    }>;
+};
+export declare class PricingApi {
+    private readonly api;
+    constructor(api: HostfullyApi);
+    get(property: Property): Promise<PropertyPricingConfig>;
+    getOverrides(property: Property, forMonthOf: Day): Promise<PricingOverride[]>;
+    scan(property: Property, startingAt: Day, endingBefore: Day): AsyncGenerator<PricingSegment>;
+    getRules(property: Property): Promise<{
+        increaseRate: number | null;
+        increaseRateLowerBound: number | null;
+        decreaseRate: number | null;
+        decreaseRateHigherBound: number | null;
+        decreaseRateMonthly: number | null;
+        decreaseRateHigherBoundMonthly: number | null;
+        enabledForAirbnb: boolean;
+        pricingRules: {
+            uid: string;
+            ruleType: "LAST_MINUTE_DISCOUNT" | "EARLY_BIRD_DISCOUNT";
+            threshold: number;
+            priceChange: number;
+            priceChangeType: "PERCENT";
+        }[];
+    }>;
+    setRules(property: Property, rules: PricingRulesUpdate): Promise<void>;
+}
+export {};

package/dist/src/PricingApi.js

@@ -0,0 +1,204 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PricingApi = void 0;
+exports.batches = batches;
+const zod_1 = require("zod");
+const gql_1 = require("@spoot/gql");
+const day_1 = require("@spoot/day");
+const DAYS_OF_WEEK = "sunday monday tuesday wednesday thursday friday saturday".split(" ");
+function* batches(size, array) {
+    for (let cursor = 0, batch = array.slice(cursor, size); batch.length > 0; cursor += size, batch = array.slice(cursor, size)) {
+        yield batch;
+    }
+}
+const PricingConfigQuery = (uid) => (0, gql_1.gql) `
+  query {
+    property(uid: ${JSON.stringify(uid)}) {
+      name
+      availability {
+        minimumStay
+        minimumWeekendStay
+        daysOfTheWeekToCheckInOn
+      }
+      pricing {
+        dailyRate
+        weekendAdjustmentRate
+      }
+    }
+  }
+`;
+const PricingOverrideResponseSchema = zod_1.z.object({
+    pricingPeriods: zod_1.z.array(zod_1.z.object({
+        propertyUid: zod_1.z.string(),
+        date: zod_1.z.string(),
+        price: zod_1.z.number(),
+        minimumStay: zod_1.z.number(),
+        availableForCheckIn: zod_1.z.boolean(),
+        availableForCheckOut: zod_1.z.boolean(),
+        name: zod_1.z.string().nullable(),
+    })),
+});
+const PricingRulePricingRuleSchema = zod_1.z.object({
+    uid: zod_1.z.string(),
+    ruleType: zod_1.z.enum(["LAST_MINUTE_DISCOUNT", "EARLY_BIRD_DISCOUNT"]),
+    threshold: zod_1.z.number(),
+    priceChange: zod_1.z.number(),
+    priceChangeType: zod_1.z.literal("PERCENT"),
+});
+const PricingRulesSchema = zod_1.z.object({
+    increaseRate: zod_1.z.number().nullable(),
+    increaseRateLowerBound: zod_1.z.number().nullable(),
+    decreaseRate: zod_1.z.number().nullable(),
+    decreaseRateHigherBound: zod_1.z.number().nullable(),
+    decreaseRateMonthly: zod_1.z.number().nullable(),
+    decreaseRateHigherBoundMonthly: zod_1.z.number().nullable(),
+    enabledForAirbnb: zod_1.z.boolean(),
+    pricingRules: zod_1.z.array(PricingRulePricingRuleSchema),
+});
+class PricingApi {
+    api;
+    constructor(api) {
+        this.api = api;
+    }
+    async get(property) {
+        const resp = await this.api.transport.fetchGql(PricingConfigQuery(property.uid), zod_1.z.object({
+            property: zod_1.z
+                .object({
+                name: zod_1.z.string(),
+                availability: zod_1.z.object({
+                    minimumStay: zod_1.z.number(),
+                    minimumWeekendStay: zod_1.z.number(),
+                    daysOfTheWeekToCheckInOn: zod_1.z.array(zod_1.z.string()),
+                }),
+                pricing: zod_1.z.object({
+                    dailyRate: zod_1.z.string(),
+                    weekendAdjustmentRate: zod_1.z.string(),
+                }),
+            })
+                .optional(),
+        }));
+        if (!resp.property) {
+            throw new Error(`Unable to find property with uid: ${property.uid}`);
+        }
+        const { availability: { daysOfTheWeekToCheckInOn, minimumStay, minimumWeekendStay, }, pricing: { dailyRate: dailyRateString, weekendAdjustmentRate: weekendAdjustmentRateString, }, } = resp.property;
+        const dailyRate = Number(dailyRateString);
+        const weekendAdjustmentRate = Number(weekendAdjustmentRateString);
+        return {
+            dailyRate: dailyRate.toFixed(2),
+            minimumStay,
+            minimumWeekendStay: minimumWeekendStay > 0 ? minimumWeekendStay : minimumStay,
+            weekendRate: (weekendAdjustmentRate > 0
+                ? dailyRate + dailyRate * weekendAdjustmentRate
+                : dailyRate).toFixed(2),
+            daysOfTheWeekToCheckInOn: new Set(daysOfTheWeekToCheckInOn.map((day) => {
+                const index = DAYS_OF_WEEK.indexOf(day.toLowerCase());
+                if (index === -1) {
+                    throw new Error(`Invalid day of the week: ${day}`);
+                }
+                return index;
+            })),
+        };
+    }
+    async getOverrides(property, forMonthOf) {
+        const { pricingPeriods } = await this.api.transport.fetch({
+            path: "/api/v3.1/pricing-periods",
+            method: "GET",
+            query: {
+                propertyUid: property.uid,
+                from: forMonthOf.startOfMonth.toJSON(),
+                to: forMonthOf.endOfMonth.toJSON(),
+            },
+            response: PricingOverrideResponseSchema,
+        });
+        return pricingPeriods
+            .map((p) => {
+            const match = p.date.match(/(\d{4})-(\d{2})-(\d{2})/);
+            if (!match) {
+                throw new Error(`Invalid date format from Hostfully API: ${p.date}`);
+            }
+            return {
+                day: new day_1.Day(Number(match[1]), Number(match[2]) - 1, Number(match[3])),
+                price: p.price.toFixed(2),
+                minNights: p.minimumStay,
+                canCheckin: p.availableForCheckIn,
+                canCheckout: p.availableForCheckOut,
+            };
+        })
+            .sort((a, b) => a.day.valueOf() - b.day.valueOf());
+    }
+    async *scan(property, startingAt, endingBefore) {
+        const pricingConfig = await this.get(property);
+        let cursor = startingAt;
+        let pricingOverrides = null;
+        while (cursor < endingBefore) {
+            // when we move to a new month, fetch the pricing overrides for that month
+            if (!pricingOverrides ||
+                pricingOverrides.startOfMonth.neq(cursor.startOfMonth)) {
+                pricingOverrides = {
+                    startOfMonth: cursor.startOfMonth,
+                    periods: await this.getOverrides(property, cursor.startOfMonth),
+                };
+            }
+            const override = pricingOverrides.periods.find((p) => p.day.eq(cursor));
+            const canCheckin = pricingConfig.daysOfTheWeekToCheckInOn.has(cursor.dayOfWeek);
+            if (override) {
+                yield {
+                    startingAt: cursor,
+                    endingBefore: cursor.nextDay,
+                    data: {
+                        price: Number(override.price).toFixed(2),
+                        minNights: override.minNights,
+                        canCheckin: override.canCheckin,
+                        canCheckout: override.canCheckout,
+                    },
+                };
+            }
+            else {
+                if (cursor.isFridayOrSaturday) {
+                    yield {
+                        startingAt: cursor,
+                        endingBefore: cursor.nextDay,
+                        data: {
+                            price: Number(pricingConfig.weekendRate).toFixed(2),
+                            minNights: pricingConfig.minimumWeekendStay,
+                            canCheckin: canCheckin,
+                            canCheckout: canCheckin,
+                        },
+                    };
+                }
+                else {
+                    yield {
+                        startingAt: cursor,
+                        endingBefore: cursor.nextDay,
+                        data: {
+                            price: pricingConfig.dailyRate,
+                            minNights: pricingConfig.minimumStay,
+                            canCheckin: canCheckin,
+                            canCheckout: canCheckin,
+                        },
+                    };
+                }
+            }
+            cursor = cursor.nextDay;
+        }
+    }
+    async getRules(property) {
+        const resp = await this.api.transport.fetch({
+            method: "GET",
+            path: `/api/v3.1/property-pricing-rules/${property.uid}`,
+            response: zod_1.z.object({
+                propertyPricingRules: PricingRulesSchema,
+            }),
+        });
+        return resp.propertyPricingRules;
+    }
+    async setRules(property, rules) {
+        await this.api.transport.fetch({
+            method: "PUT",
+            path: `/api/v3.1/property-pricing-rules/${property.uid}`,
+            body: rules,
+            response: null,
+        });
+    }
+}
+exports.PricingApi = PricingApi;

package/dist/src/PropertiesApi.d.ts

@@ -0,0 +1,251 @@
+import { z } from "zod";
+import { HostfullyApi } from "./HostfullyApi";
+declare const PropertySchema: z.ZodObject<{
+    name: z.ZodString;
+    isActive: z.ZodBoolean;
+    uid: z.ZodString;
+    showPropertyExactLocation: z.ZodBoolean;
+    cancellationPolicy: z.ZodNullable<z.ZodString>;
+    availability: z.ZodObject<{
+        allowBookingRequestsAboveMaximumStay: z.ZodNullable<z.ZodBoolean>;
+        allowBookingRequestWhenOutOfLeadTime: z.ZodNullable<z.ZodBoolean>;
+        baseGuests: z.ZodNumber;
+        bookingLeadTime: z.ZodNullable<z.ZodNumber>;
+        bookingWindow: z.ZodNullable<z.ZodNumber>;
+        checkInTimeEnd: z.ZodNullable<z.ZodNumber>;
+        checkInTimeEndFlexible: z.ZodNullable<z.ZodBoolean>;
+        checkInTimeStart: z.ZodNullable<z.ZodNumber>;
+        checkOutTime: z.ZodNullable<z.ZodNumber>;
+        daysOfTheWeekToCheckInOn: z.ZodArray<z.ZodString, "many">;
+        maxGuests: z.ZodNumber;
+        maximumStay: z.ZodNullable<z.ZodNumber>;
+        minimumStay: z.ZodNullable<z.ZodNumber>;
+        minimumWeekendStay: z.ZodNullable<z.ZodNumber>;
+        turnOverDays: z.ZodNullable<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        allowBookingRequestsAboveMaximumStay: boolean | null;
+        allowBookingRequestWhenOutOfLeadTime: boolean | null;
+        baseGuests: number;
+        bookingLeadTime: number | null;
+        bookingWindow: number | null;
+        checkInTimeEnd: number | null;
+        checkInTimeEndFlexible: boolean | null;
+        checkInTimeStart: number | null;
+        checkOutTime: number | null;
+        daysOfTheWeekToCheckInOn: string[];
+        maxGuests: number;
+        maximumStay: number | null;
+        minimumStay: number | null;
+        minimumWeekendStay: number | null;
+        turnOverDays: number | null;
+    }, {
+        allowBookingRequestsAboveMaximumStay: boolean | null;
+        allowBookingRequestWhenOutOfLeadTime: boolean | null;
+        baseGuests: number;
+        bookingLeadTime: number | null;
+        bookingWindow: number | null;
+        checkInTimeEnd: number | null;
+        checkInTimeEndFlexible: boolean | null;
+        checkInTimeStart: number | null;
+        checkOutTime: number | null;
+        daysOfTheWeekToCheckInOn: string[];
+        maxGuests: number;
+        maximumStay: number | null;
+        minimumStay: number | null;
+        minimumWeekendStay: number | null;
+        turnOverDays: number | null;
+    }>;
+    address: z.ZodObject<{
+        address: z.ZodNullable<z.ZodString>;
+        address2: z.ZodNullable<z.ZodString>;
+        city: z.ZodNullable<z.ZodString>;
+        state: z.ZodNullable<z.ZodString>;
+        zipCode: z.ZodNullable<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        address: string | null;
+        address2: string | null;
+        city: string | null;
+        state: string | null;
+        zipCode: string | null;
+    }, {
+        address: string | null;
+        address2: string | null;
+        city: string | null;
+        state: string | null;
+        zipCode: string | null;
+    }>;
+    pricing: z.ZodObject<{
+        taxRate: z.ZodNullable<z.ZodNumber>;
+        ignoreTaxRateChargeOverXDays: z.ZodNullable<z.ZodBoolean>;
+        daysOverWhichTaxRateChargeShouldBeIgnored: z.ZodNullable<z.ZodNumber>;
+        cleaningFeeTaxRate: z.ZodNullable<z.ZodNumber>;
+        extraGuestFee: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        taxRate: number | null;
+        ignoreTaxRateChargeOverXDays: boolean | null;
+        daysOverWhichTaxRateChargeShouldBeIgnored: number | null;
+        cleaningFeeTaxRate: number | null;
+        extraGuestFee: number;
+    }, {
+        taxRate: number | null;
+        ignoreTaxRateChargeOverXDays: boolean | null;
+        daysOverWhichTaxRateChargeShouldBeIgnored: number | null;
+        cleaningFeeTaxRate: number | null;
+        extraGuestFee: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    isActive: boolean;
+    uid: string;
+    showPropertyExactLocation: boolean;
+    cancellationPolicy: string | null;
+    availability: {
+        allowBookingRequestsAboveMaximumStay: boolean | null;
+        allowBookingRequestWhenOutOfLeadTime: boolean | null;
+        baseGuests: number;
+        bookingLeadTime: number | null;
+        bookingWindow: number | null;
+        checkInTimeEnd: number | null;
+        checkInTimeEndFlexible: boolean | null;
+        checkInTimeStart: number | null;
+        checkOutTime: number | null;
+        daysOfTheWeekToCheckInOn: string[];
+        maxGuests: number;
+        maximumStay: number | null;
+        minimumStay: number | null;
+        minimumWeekendStay: number | null;
+        turnOverDays: number | null;
+    };
+    address: {
+        address: string | null;
+        address2: string | null;
+        city: string | null;
+        state: string | null;
+        zipCode: string | null;
+    };
+    pricing: {
+        taxRate: number | null;
+        ignoreTaxRateChargeOverXDays: boolean | null;
+        daysOverWhichTaxRateChargeShouldBeIgnored: number | null;
+        cleaningFeeTaxRate: number | null;
+        extraGuestFee: number;
+    };
+}, {
+    name: string;
+    isActive: boolean;
+    uid: string;
+    showPropertyExactLocation: boolean;
+    cancellationPolicy: string | null;
+    availability: {
+        allowBookingRequestsAboveMaximumStay: boolean | null;
+        allowBookingRequestWhenOutOfLeadTime: boolean | null;
+        baseGuests: number;
+        bookingLeadTime: number | null;
+        bookingWindow: number | null;
+        checkInTimeEnd: number | null;
+        checkInTimeEndFlexible: boolean | null;
+        checkInTimeStart: number | null;
+        checkOutTime: number | null;
+        daysOfTheWeekToCheckInOn: string[];
+        maxGuests: number;
+        maximumStay: number | null;
+        minimumStay: number | null;
+        minimumWeekendStay: number | null;
+        turnOverDays: number | null;
+    };
+    address: {
+        address: string | null;
+        address2: string | null;
+        city: string | null;
+        state: string | null;
+        zipCode: string | null;
+    };
+    pricing: {
+        taxRate: number | null;
+        ignoreTaxRateChargeOverXDays: boolean | null;
+        daysOverWhichTaxRateChargeShouldBeIgnored: number | null;
+        cleaningFeeTaxRate: number | null;
+        extraGuestFee: number;
+    };
+}>;
+export type BookingLeadTime = "-15" | "-14" | "-13" | "-12" | "-11" | "-10" | "-9" | "-8" | "-7" | "-6" | "-5" | "-4" | "-3" | "-2" | "-1" | "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" | "10" | "11" | "12" | "13" | "14" | "15" | "16" | "17" | "18" | "19" | "20" | "21" | "22" | "23" | "24" | "48" | "72" | "168";
+export type Property = z.infer<typeof PropertySchema>;
+export interface PropertyPropertiesPatch {
+    name?: string;
+    showPropertyExactLocation?: boolean;
+    cancellationPolicy?: string;
+    pricing?: {
+        taxRate?: number | null;
+        ignoreTaxRateChargeOverXDays?: boolean | null;
+        daysOverWhichTaxRateChargeShouldBeIgnored?: number | null;
+        cleaningFeeTaxRate?: number | null;
+        extraGuestFee?: number | null;
+    };
+    availability?: {
+        baseGuests?: number;
+        maxGuests?: number;
+        bookingLeadTime?: BookingLeadTime;
+    };
+}
+declare const PropertyDescriptionsSchema: z.ZodObject<{
+    name: z.ZodNullable<z.ZodString>;
+    shortSummary: z.ZodNullable<z.ZodString>;
+    summary: z.ZodNullable<z.ZodString>;
+    notes: z.ZodNullable<z.ZodString>;
+    access: z.ZodNullable<z.ZodString>;
+    transit: z.ZodNullable<z.ZodString>;
+    interaction: z.ZodNullable<z.ZodString>;
+    neighbourhood: z.ZodNullable<z.ZodString>;
+    space: z.ZodNullable<z.ZodString>;
+    houseManual: z.ZodNullable<z.ZodString>;
+    locale: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string | null;
+    shortSummary: string | null;
+    summary: string | null;
+    notes: string | null;
+    access: string | null;
+    transit: string | null;
+    interaction: string | null;
+    neighbourhood: string | null;
+    space: string | null;
+    houseManual: string | null;
+    locale: string;
+}, {
+    name: string | null;
+    shortSummary: string | null;
+    summary: string | null;
+    notes: string | null;
+    access: string | null;
+    transit: string | null;
+    interaction: string | null;
+    neighbourhood: string | null;
+    space: string | null;
+    houseManual: string | null;
+    locale: string;
+}>;
+export type PropertyDescriptions = z.infer<typeof PropertyDescriptionsSchema>;
+export declare class PropertiesApi {
+    private readonly api;
+    constructor(api: HostfullyApi);
+    list(): Promise<Property[]>;
+    patch(property: Property, update: PropertyPropertiesPatch): Promise<void>;
+    getCustomData(property: Property): Promise<Map<string, string>>;
+    setCustomData(property: Property, fieldUid: string, value: string): Promise<void>;
+    deleteCustomData(property: Property, fieldUid: string): Promise<void>;
+    getDescriptions(property: Property): Promise<{
+        name: string | null;
+        shortSummary: string | null;
+        summary: string | null;
+        notes: string | null;
+        access: string | null;
+        transit: string | null;
+        interaction: string | null;
+        neighbourhood: string | null;
+        space: string | null;
+        houseManual: string | null;
+        locale: string;
+    }>;
+    updateDescriptions(property: Property, updates: Partial<PropertyDescriptions>): Promise<void>;
+}
+export {};