@vibe-flats/booking-engine-common-server 1.0.1

package/build/index.d.ts

@@ -0,0 +1 @@
+export * from './src/units-models';

package/build/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./src/units-models"), exports);

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

@@ -0,0 +1,11 @@
+import mongoose from 'mongoose';
+import { CityDocument } from './cities';
+export interface AreaDocument extends mongoose.Document {
+    name: string;
+    externalName: string;
+    publicId: string;
+    city: CityDocument;
+}
+export declare const AreaModel: (connection: mongoose.Connection) => mongoose.Model<AreaDocument, {}, {}, {}, mongoose.Document<unknown, {}, AreaDocument> & AreaDocument & Required<{
+    _id: unknown;
+}>, any>;

package/build/src/models/areas.js

@@ -0,0 +1,52 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AreaModel = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const schema = new mongoose_1.default.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    externalName: {
+        type: String,
+        required: true
+    },
+    publicId: {
+        type: String,
+        required: true
+    },
+    city: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: 'City'
+    }
+});
+schema.index({ publicId: 1 });
+schema.index({ externalName: 1 });
+const AreaModel = (connection) => {
+    return connection.model('Area', schema);
+};
+exports.AreaModel = AreaModel;
+// export const AreaModel = connection.model<AreaDocument>('Area', schema);

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

@@ -0,0 +1,12 @@
+import mongoose from 'mongoose';
+import { UnitDocument } from './units';
+export interface AvailabilityDocument extends mongoose.Document {
+    unit: UnitDocument;
+    date: Date;
+    isAvailable: boolean;
+    price: number;
+    minNights: number;
+}
+export declare const AvailabilityModel: (connection: mongoose.Connection) => mongoose.Model<AvailabilityDocument, {}, {}, {}, mongoose.Document<unknown, {}, AvailabilityDocument> & AvailabilityDocument & Required<{
+    _id: unknown;
+}>, any>;

package/build/src/models/availability.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AvailabilityModel = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const schema = new mongoose_1.default.Schema({
+    unit: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: 'Unit',
+        required: true
+    },
+    date: {
+        type: Date,
+        required: true
+    },
+    isAvailable: {
+        type: Boolean,
+        required: true
+    },
+    price: {
+        type: Number,
+        required: true
+    },
+    minNights: {
+        type: Number,
+        required: true
+    }
+}, {
+    timestamps: true,
+    versionKey: false
+});
+schema.index({ unit: 1, date: 1 });
+const AvailabilityModel = (connection) => {
+    return connection.model('Availability', schema);
+};
+exports.AvailabilityModel = AvailabilityModel;
+// export const AvailabilityModel = unitsDbConnection.model<AvailabilityDocument>('Availability', schema);

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

@@ -0,0 +1,21 @@
+import mongoose from 'mongoose';
+import { AreaDocument } from './areas';
+import { CityDocument } from './cities';
+export interface BuildingDocument extends mongoose.Document {
+    name: string;
+    externalName: string;
+    publicId: string;
+    hubspotId: string;
+    area: AreaDocument;
+    city: CityDocument;
+    address: string;
+    state: string;
+    zip: string;
+    position: {
+        lat: number;
+        lng: number;
+    };
+}
+export declare const BuildingModel: (connection: mongoose.Connection) => mongoose.Model<BuildingDocument, {}, {}, {}, mongoose.Document<unknown, {}, BuildingDocument> & BuildingDocument & Required<{
+    _id: unknown;
+}>, any>;

package/build/src/models/building.js

@@ -0,0 +1,87 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildingModel = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const schema = new mongoose_1.default.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    externalName: {
+        type: String,
+        required: true
+    },
+    publicId: {
+        type: String,
+        required: false
+    },
+    hubspotId: {
+        type: String,
+        required: false
+    },
+    area: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: 'Area',
+        required: false
+    },
+    city: {
+        type: mongoose_1.Schema.Types.ObjectId,
+        ref: 'City',
+        required: false
+    },
+    address: {
+        type: String,
+        required: false
+    },
+    state: {
+        type: String,
+        required: false
+    },
+    zip: {
+        type: String,
+        required: false
+    },
+    position: {
+        // coming from guesty
+        type: new mongoose_1.default.Schema({
+            lat: { type: Number, required: true },
+            lng: { type: Number, required: true }
+        }),
+        required: true,
+        _id: false
+    }
+}, {
+    timestamps: true,
+    versionKey: false
+});
+// Unique index
+schema.index({ publicId: 1 });
+schema.index({ hubspotId: 1 });
+const BuildingModel = (connection) => {
+    return connection.model('Building', schema);
+};
+exports.BuildingModel = BuildingModel;
+// export const BuildingModel = unitsDbConnection.model<BuildingDocument>('Building', schema);

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

@@ -0,0 +1,8 @@
+import mongoose from 'mongoose';
+export interface CityDocument extends mongoose.Document {
+    name: string;
+    publicId: string;
+}
+export declare const CityModel: (connection: mongoose.Connection) => mongoose.Model<CityDocument, {}, {}, {}, mongoose.Document<unknown, {}, CityDocument> & CityDocument & Required<{
+    _id: unknown;
+}>, any>;

package/build/src/models/cities.js

@@ -0,0 +1,28 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CityModel = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+const schema = new mongoose_1.default.Schema({
+    name: {
+        type: String,
+        required: true
+    },
+    externalName: {
+        type: String,
+        required: true
+    },
+    publicId: {
+        type: String,
+        required: true
+    }
+});
+schema.index({ publicId: 1 });
+schema.index({ externalName: 1 });
+const CityModel = (connection) => {
+    return connection.model('City', schema);
+};
+exports.CityModel = CityModel;
+// export const CityModel = unitsDbConnection.model<CityDocument>('City', schema);

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

@@ -0,0 +1,55 @@
+import mongoose from 'mongoose';
+import { AreaDocument } from './areas';
+import { BuildingDocument } from './building';
+import { CityDocument } from './cities';
+export interface UnitDocument extends mongoose.Document {
+    name: string;
+    code: number;
+    building?: BuildingDocument;
+    city?: CityDocument;
+    area?: AreaDocument;
+    isActive: boolean;
+    publicId: string;
+    guestyId: string;
+    hubspotId?: string;
+    image: string;
+    images: string[];
+    guestyAddress: {
+        street: string;
+        city: string;
+        state: string;
+        zipcode: string;
+        country: string;
+        lat: number;
+        lng: number;
+        full: string;
+    };
+    bedrooms: number;
+    bathrooms: number;
+    elevator: boolean;
+    laundry: boolean;
+    floor: number;
+    gym: boolean;
+    parking: boolean;
+    pool: boolean;
+    beds: {
+        type: string;
+        qty: number;
+    }[];
+    prices: {
+        monthlyPriceFactor: number;
+        weeklyPriceFactor: number;
+        cleaningFee: number;
+    };
+    fees: {
+        name: string;
+        value: number;
+        multiplier: 'PER_NIGHT' | 'PER_STAY' | 'PER_GUEST' | 'PER_GUEST_PER_NIGHT';
+        isOptional: boolean;
+        isPercentage: boolean;
+    }[];
+    lastSyncedAt?: Date;
+}
+export declare const UnitModel: (connection: mongoose.Connection) => mongoose.Model<UnitDocument, {}, {}, {}, mongoose.Document<unknown, {}, UnitDocument> & UnitDocument & Required<{
+    _id: unknown;
+}>, any>;

package/build/src/models/units.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnitModel = void 0;
+const mongoose_1 = __importStar(require("mongoose"));
+const schema = new mongoose_1.default.Schema({
+    name: { type: String, required: true },
+    code: { type: Number, required: true },
+    building: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Building', required: false },
+    city: { type: mongoose_1.Schema.Types.ObjectId, ref: 'City', required: false },
+    area: { type: mongoose_1.Schema.Types.ObjectId, ref: 'Area', required: false },
+    isActive: { type: Boolean, required: true, default: true },
+    publicId: { type: String, required: false },
+    guestyId: { type: String, required: true },
+    hubspotId: { type: String, required: true },
+    image: { type: String, required: true },
+    images: [{ type: String, required: true }],
+    guestyAddress: {
+        type: new mongoose_1.default.Schema({
+            street: { type: String, required: true },
+            city: { type: String, required: true },
+            state: { type: String, required: true },
+            zipcode: { type: String, required: true },
+            country: { type: String, required: true },
+            lat: { type: Number, required: true },
+            lng: { type: Number, required: true },
+            full: { type: String, required: true }
+        }),
+        required: true,
+        _id: false
+    },
+    bedrooms: { type: Number, required: true },
+    bathrooms: { type: Number, required: true },
+    elevator: { type: Boolean, required: true },
+    laundry: { type: Boolean, required: true },
+    floor: { type: Number, required: true },
+    gym: { type: Boolean, required: true },
+    parking: { type: Boolean, required: true },
+    pool: { type: Boolean, required: true },
+    beds: [{ type: { type: String, required: true }, qty: { type: Number, required: true }, _id: false }],
+    prices: {
+        type: new mongoose_1.default.Schema({
+            monthlyPriceFactor: { type: Number, required: true },
+            weeklyPriceFactor: { type: Number, required: true },
+            cleaningFee: { type: Number, required: true }
+        }),
+        required: true,
+        _id: false
+    },
+    fees: [
+        {
+            name: { type: String, required: true },
+            value: { type: Number, required: true },
+            multiplier: { type: String, required: true },
+            isOptional: { type: Boolean, required: true },
+            isPercentage: { type: Boolean, required: true },
+            _id: false
+        }
+    ],
+    lastSyncedAt: { type: Boolean, required: false }
+}, {
+    timestamps: true,
+    versionKey: false,
+    strict: false
+});
+// Unique index
+schema.index({ publicId: 1 });
+schema.index({ code: 1 });
+schema.index({ hubspotId: 1 });
+const UnitModel = (connection) => {
+    return connection.model('Unit', schema);
+};
+exports.UnitModel = UnitModel;
+// export const UnitModel = unitsDbConnection.model<UnitDocument>('Unit', schema);

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

@@ -0,0 +1,18 @@
+import mongoose from 'mongoose';
+export declare const unitsModels: (connection: mongoose.Connection) => {
+    CityModel: mongoose.Model<import("./models/cities").CityDocument, {}, {}, {}, mongoose.Document<unknown, {}, import("./models/cities").CityDocument> & import("./models/cities").CityDocument & Required<{
+        _id: unknown;
+    }>, any>;
+    UnitModel: mongoose.Model<import("./models/units").UnitDocument, {}, {}, {}, mongoose.Document<unknown, {}, import("./models/units").UnitDocument> & import("./models/units").UnitDocument & Required<{
+        _id: unknown;
+    }>, any>;
+    AvailabilityModel: mongoose.Model<import("./models/availability").AvailabilityDocument, {}, {}, {}, mongoose.Document<unknown, {}, import("./models/availability").AvailabilityDocument> & import("./models/availability").AvailabilityDocument & Required<{
+        _id: unknown;
+    }>, any>;
+    BuildingModel: mongoose.Model<import("./models/building").BuildingDocument, {}, {}, {}, mongoose.Document<unknown, {}, import("./models/building").BuildingDocument> & import("./models/building").BuildingDocument & Required<{
+        _id: unknown;
+    }>, any>;
+    AreaModel: mongoose.Model<import("./models/areas").AreaDocument, {}, {}, {}, mongoose.Document<unknown, {}, import("./models/areas").AreaDocument> & import("./models/areas").AreaDocument & Required<{
+        _id: unknown;
+    }>, any>;
+};

package/build/src/units-models.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unitsModels = void 0;
+const cities_1 = require("./models/cities");
+const units_1 = require("./models/units");
+const availability_1 = require("./models/availability");
+const building_1 = require("./models/building");
+const areas_1 = require("./models/areas");
+const unitsModels = (connection) => ({
+    CityModel: (0, cities_1.CityModel)(connection),
+    UnitModel: (0, units_1.UnitModel)(connection),
+    AvailabilityModel: (0, availability_1.AvailabilityModel)(connection),
+    BuildingModel: (0, building_1.BuildingModel)(connection),
+    AreaModel: (0, areas_1.AreaModel)(connection)
+});
+exports.unitsModels = unitsModels;

package/package.json

@@ -0,0 +1,26 @@
+{
+	"name": "@vibe-flats/booking-engine-common-server",
+	"version": "1.0.1",
+	"description": "",
+	"main": "./build/index.js",
+	"types": "./build/index.d.ts",
+	"files": [
+		"build/**/*"
+	],
+	"scripts": {
+		"clean": "del ./build/*",
+		"build": "npm run clean && tsc",
+		"pub": "npm version patch && npm run build && npm publish"
+	},
+	"keywords": [],
+	"author": "Omri Regev",
+	"license": "ISC",
+	"devDependencies": {
+		"@types/node": "^22.1.0",
+		"del-cli": "^5.1.0",
+		"typescript": "^5.1.6"
+	},
+	"dependencies": {
+		"mongoose": "^8.5.2"
+	}
+}

package/readme.md

@@ -0,0 +1 @@
+# Common Tools