@vibe-flats/booking-engine-common-server 1.0.155 → 1.0.157

package/build/index.d.ts

@@ -5,3 +5,4 @@ export * from './src/utils/monthly-diff';
 export * from './src/utils/purge-unit-cache';
 export * from './src/utils/cache';
 export * from './src/utils/guesty-total';
+export * from './src/types/guesty-reservation';

package/build/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./src/utils/monthly-diff"), exports);
 __exportStar(require("./src/utils/purge-unit-cache"), exports);
 __exportStar(require("./src/utils/cache"), exports);
 __exportStar(require("./src/utils/guesty-total"), exports);
+__exportStar(require("./src/types/guesty-reservation"), exports);

package/build/src/models/units.d.ts

@@ -6,6 +6,39 @@ import { MarketDocument } from './markets';
 import { GuestDocument } from './guests';
 export type UnitReviewCategory = 'cleanliness' | 'communication' | 'checkin' | 'accuracy' | 'location' | 'value' | 'service';
 export type UnitReviewPlatform = 'direct' | 'airbnb' | 'vrbo' | 'booking' | 'expedia';
+export type UnitReviewChannel = 'all' | 'airbnb' | 'booking' | 'vrbo';
+export interface UnitReview {
+    body: string;
+    isPublic: boolean;
+    isPublicOnChannel: boolean;
+    rating: number;
+    nativeRating?: number;
+    nativeScale?: 5 | 10;
+    createdAt: Date;
+    reservationId: string;
+    externalId: string;
+    platform: UnitReviewPlatform;
+    guest: GuestDocument;
+    categories: {
+        name: UnitReviewCategory;
+        rating: number;
+    }[];
+}
+export interface UnitRatingBucket {
+    rating: number;
+    count: number;
+}
+export interface UnitRatingsByWindow {
+    allTime: UnitRatingBucket;
+    last6Months: UnitRatingBucket;
+    last3Reviews: UnitRatingBucket;
+}
+export interface UnitRatings {
+    all: UnitRatingsByWindow;
+    airbnb: UnitRatingsByWindow;
+    booking: UnitRatingsByWindow;
+    vrbo: UnitRatingsByWindow;
+}
 export declare const UNIT_TYPES: {
     readonly SINGLE: "single";
     readonly MULTI_PARENT: "multi-listing-parent";
@@ -120,20 +153,8 @@ export interface UnitDocument extends mongoose.Document {
     updatedAt: Date;
     isTrue: boolean;
     rating: number;
-    reviews: {
-        body: string;
-        isPublic: boolean;
-        rating: number;
-        createdAt: Date;
-        reservationId: string;
-        externalId: string;
-        platform: UnitReviewPlatform;
-        guest: GuestDocument;
-        categories: {
-            name: UnitReviewCategory;
-            rating: number;
-        }[];
-    }[];
+    reviews: UnitReview[];
+    ratings: UnitRatings;
     salesBlockWarning: string;
     hasOpenExtensionLink: boolean;
     lengthOfStayType: 'monthly' | 'hybrid' | 'nightly';

package/build/src/models/units.js

@@ -38,6 +38,15 @@ exports.TAX_QUANTIFIERS = {
     PER_STAY: 'PER_STAY',
     PER_NIGHT: 'PER_NIGHT'
 };
+const ratingBucketSchema = new mongoose_1.default.Schema({
+    rating: { type: Number, required: true, default: 0 },
+    count: { type: Number, required: true, default: 0 }
+}, { _id: false });
+const ratingsByWindowSchema = new mongoose_1.default.Schema({
+    allTime: { type: ratingBucketSchema, required: true, default: () => ({}) },
+    last6Months: { type: ratingBucketSchema, required: true, default: () => ({}) },
+    last3Reviews: { type: ratingBucketSchema, required: true, default: () => ({}) }
+}, { _id: false });
 const schema = new mongoose_1.default.Schema({
     name: { type: String, required: true },
     code: { type: Number, required: true },
@@ -163,7 +172,10 @@ const schema = new mongoose_1.default.Schema({
             {
                 body: { type: String, required: true },
                 isPublic: { type: Boolean, required: true },
+                isPublicOnChannel: { type: Boolean, required: false },
                 rating: { type: Number, required: true },
+                nativeRating: { type: Number, required: false },
+                nativeScale: { type: Number, enum: [5, 10], required: false },
                 createdAt: { type: Date, required: true },
                 reservationId: { type: String, required: true },
                 externalId: { type: String, required: true },
@@ -184,6 +196,16 @@ const schema = new mongoose_1.default.Schema({
         required: false,
         _id: false
     },
+    ratings: {
+        type: new mongoose_1.default.Schema({
+            all: { type: ratingsByWindowSchema, required: true, default: () => ({}) },
+            airbnb: { type: ratingsByWindowSchema, required: true, default: () => ({}) },
+            booking: { type: ratingsByWindowSchema, required: true, default: () => ({}) },
+            vrbo: { type: ratingsByWindowSchema, required: true, default: () => ({}) }
+        }, { _id: false }),
+        required: false,
+        default: () => ({})
+    },
     salesBlockWarning: { type: String, required: false },
     hasOpenExtensionLink: { type: Boolean, required: false },
     lengthOfStayType: { type: String, required: false },

package/build/src/types/guesty-reservation.d.ts

@@ -0,0 +1,192 @@
+/**
+ * Consolidated shape of a Guesty reservation, merged from every variation
+ * previously duplicated across the booking-engine subprojects
+ * (pay, quotes, extensions, admin, sync).
+ *
+ * Fields are required when every variation had them as required,
+ * and optional when at least one variation marked them optional OR
+ * when Guesty only returns them for specific `?fields=` queries.
+ */
+export interface GuestyReservationCurrency {
+    rate?: number;
+    rateDate?: string;
+    from?: string;
+    to?: string;
+}
+export interface GuestyReservationChannelCommission {
+    manual?: any[];
+}
+export interface GuestyReservationSettingsSnapshot {
+    currency?: GuestyReservationCurrency;
+    monthlyPriceFactor?: number;
+    weeklyPriceFactor?: number;
+    taxes?: any[];
+    additionalFees?: any[];
+    markup?: any | null;
+    channelCommission?: GuestyReservationChannelCommission;
+    useAccountRevenueShare?: boolean;
+    useAccountAdditionalFees?: boolean;
+    guestsIncludedInRegularFee?: number;
+    extraPersonFee?: number;
+    cleaningFee?: number;
+}
+export interface GuestyReservationInvoiceItem {
+    _id?: string;
+    type?: string;
+    normalType?: string;
+    title: string;
+    amount: number;
+    isLocked?: boolean;
+    currency?: string;
+}
+export interface GuestyReservationChargebacksData {
+    chargebacks?: any[];
+}
+export interface GuestyReservationRefund {
+    status: string;
+    amount: number;
+}
+export interface GuestyReservationPayment {
+    _id: string;
+    paymentMethodStatus?: string;
+    isAuthorizationHold?: boolean;
+    status: string;
+    chargebacksData?: GuestyReservationChargebacksData;
+    paymentMethodId?: string;
+    amount: number;
+    shouldBePaidAt?: string;
+    currency?: string;
+    guestId?: string;
+    refunds?: GuestyReservationRefund[];
+    authorizationHoldCaptures?: any[];
+    createdAt?: string;
+    attempts?: any[];
+    receiptTargets?: any[];
+    paidAt?: string;
+    receiptId?: number;
+}
+export interface GuestyMoney {
+    _id?: string;
+    settingsSnapshot?: GuestyReservationSettingsSnapshot;
+    channelCommissionRules?: any | null;
+    paymentProviderIds?: string[];
+    altered?: boolean;
+    invoiceItems?: GuestyReservationInvoiceItem[];
+    payments?: GuestyReservationPayment[];
+    autoPaymentsPolicy?: any[];
+    transientOccupancyTax?: number;
+    hostOriginalPayout?: number;
+    fareAccommodation?: number;
+    hostServiceFee?: number;
+    fareCleaning?: number;
+    currency?: string;
+    version?: number;
+    fareAccommodationAdjustment?: number;
+    fareAccommodationDiscount?: number;
+    fareAccommodationAdjusted?: number;
+    hostServiceFeeTax?: number;
+    hostServiceFeeIncTax?: number;
+    totalFees?: number;
+    subTotalPrice: number;
+    hostPayout?: number;
+    hostPayoutUsd?: number;
+    totalTaxes: number;
+    useAccountRevenueShare?: boolean;
+    netIncomeFormula?: string;
+    netIncome?: number;
+    commissionFormula?: string;
+    commission?: number;
+    commissionTaxPercentage?: number;
+    commissionTax?: number;
+    commissionIncTax?: number;
+    ownerRevenueFormula?: string;
+    ownerRevenue?: number;
+    currencyConversionRateToAccount?: number;
+    fareAccommodationBundleFeesApplied?: number;
+    platform?: string;
+    reservationId?: string;
+    bundledFees?: any[];
+    createdAt?: string;
+    updatedAt?: string;
+    balanceDue: number;
+    isFullyPaid?: boolean;
+    paymentsDue?: number;
+    totalRefunded?: number;
+    totalPaid: number;
+    isTouchedPayments?: boolean;
+}
+export interface GuestyReservationListing {
+    _id: string;
+    picture?: {
+        thumbnail?: string;
+    };
+    prices?: {
+        currency?: string;
+    };
+    type?: string;
+    nickname?: string;
+    title?: string;
+    address?: {
+        full?: string;
+    };
+    timezone?: string;
+    defaultCheckInTime?: string;
+}
+export interface GuestyReservationNumberOfGuests {
+    numberOfAdults?: number;
+    numberOfChildren?: number;
+    numberOfInfants?: number;
+    numberOfPets?: number;
+}
+export interface GuestyReservationGuest {
+    _id: string;
+    phone?: string;
+    fullName?: string;
+    lastName?: string;
+    firstName?: string;
+    email?: string;
+}
+export interface GuestyReservationIntegration {
+    platform?: string;
+}
+export interface GuestyReservationBlockDayFlag {
+    blockDay?: boolean;
+}
+export interface GuestyReservation {
+    _id: string;
+    manuallyCreated?: boolean;
+    creationInfo?: any | null;
+    listingId: string;
+    confirmationCode?: string;
+    checkIn?: string;
+    checkInDateLocalized: string;
+    nightsCount: number;
+    guestsCount?: number;
+    cancellationPolicy?: string;
+    checkOut?: string;
+    checkOutDateLocalized: string;
+    source?: string;
+    listing: GuestyReservationListing;
+    numberOfGuests?: GuestyReservationNumberOfGuests;
+    plannedArrival?: string;
+    plannedDeparture?: string;
+    status: string;
+    guest: GuestyReservationGuest;
+    money: GuestyMoney;
+    accountId?: string;
+    importedAt?: string;
+    guestId?: string;
+    isReturningGuest?: boolean;
+    confirmedAt?: string;
+    createdAt?: string;
+    pendingTasks?: any[];
+    customFields?: any[];
+    integration?: GuestyReservationIntegration;
+    earlyCheckIn?: GuestyReservationBlockDayFlag;
+    lateCheckOut?: GuestyReservationBlockDayFlag;
+    reservedAt?: string;
+    reservedExpiresAt?: string;
+    createdBy?: string;
+    browserCheckIn?: string;
+    browserCheckOut?: string;
+}

package/build/src/types/guesty-reservation.js

@@ -0,0 +1,11 @@
+"use strict";
+/**
+ * Consolidated shape of a Guesty reservation, merged from every variation
+ * previously duplicated across the booking-engine subprojects
+ * (pay, quotes, extensions, admin, sync).
+ *
+ * Fields are required when every variation had them as required,
+ * and optional when at least one variation marked them optional OR
+ * when Guesty only returns them for specific `?fields=` queries.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/src/utils/guesty-total.d.ts

@@ -1,8 +1,4 @@
-export interface GuestyMoney {
-    subTotalPrice: number;
-    totalTaxes: number;
-    [key: string]: any;
-}
+import { GuestyMoney } from '../types/guesty-reservation';
 /**
  * Calculates the true Guesty reservation total including taxes.
  * Guesty's `subTotalPrice` excludes taxes, so this adds `totalTaxes` to get the full amount.

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vibe-flats/booking-engine-common-server",
-	"version": "1.0.155",
+	"version": "1.0.157",
 	"description": "",
 	"main": "./build/index.js",
 	"types": "./build/index.d.ts",