whitelabel-db 1.1.95 → 1.1.97

package/dist/libs/database.js

@@ -75,8 +75,9 @@ const connect = (connectionDetails) => __awaiter(void 0, void 0, void 0, functio
     try {
         yield connection.authenticate();
         console.log('Database connection has been established successfully.');
-        // Ensure sync completes and creates necessary tables including SequelizeMeta
-        yield connection.sync({ alter: false });
+        // Only create tables that don't exist, don't alter existing schema
+        // This prevents conflicts with migrations
+        yield connection.sync({ force: false, alter: false });
         console.log('Database sync completed successfully.');
         return connection;
     }

package/dist/libs/migration-utils.d.ts

@@ -0,0 +1,16 @@
+import { QueryInterface } from 'sequelize';
+/**
+ * Safely adds a column to a table, checking if it already exists first
+ */
+export declare function safeAddColumn(queryInterface: QueryInterface, tableName: string, columnName: string, columnDefinition: any): Promise<void>;
+/**
+ * Safely adds multiple columns to a table
+ */
+export declare function safeAddColumns(queryInterface: QueryInterface, tableName: string, columns: Array<{
+    name: string;
+    definition: any;
+}>): Promise<void>;
+/**
+ * Safely adds an index to a table, handling if it already exists
+ */
+export declare function safeAddIndex(queryInterface: QueryInterface, tableName: string, indexName: string, columns: string[], options?: any): Promise<void>;

package/dist/libs/migration-utils.js

@@ -0,0 +1,78 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.safeAddIndex = exports.safeAddColumns = exports.safeAddColumn = void 0;
+/**
+ * Safely adds a column to a table, checking if it already exists first
+ */
+function safeAddColumn(queryInterface, tableName, columnName, columnDefinition) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const tableDescription = yield queryInterface.describeTable(tableName);
+            const existingColumns = Object.keys(tableDescription);
+            if (existingColumns.includes(columnName)) {
+                console.log(`${columnName} column already exists in ${tableName}, skipping.`);
+                return;
+            }
+            yield queryInterface.addColumn(tableName, columnName, columnDefinition);
+            console.log(`${columnName} column added to ${tableName} successfully.`);
+        }
+        catch (error) {
+            console.error(`Error adding ${columnName} column to ${tableName}:`, error.message);
+            throw error;
+        }
+    });
+}
+exports.safeAddColumn = safeAddColumn;
+/**
+ * Safely adds multiple columns to a table
+ */
+function safeAddColumns(queryInterface, tableName, columns) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const tableDescription = yield queryInterface.describeTable(tableName);
+            const existingColumns = Object.keys(tableDescription);
+            const columnsToAdd = columns.filter((column) => !existingColumns.includes(column.name));
+            if (columnsToAdd.length === 0) {
+                console.log(`All columns already exist in ${tableName}, skipping migration.`);
+                return;
+            }
+            yield Promise.all(columnsToAdd.map((column) => queryInterface.addColumn(tableName, column.name, column.definition)));
+            console.log(`Added ${columnsToAdd.length} columns to ${tableName} successfully.`);
+        }
+        catch (error) {
+            console.error(`Error adding columns to ${tableName}:`, error.message);
+            throw error;
+        }
+    });
+}
+exports.safeAddColumns = safeAddColumns;
+/**
+ * Safely adds an index to a table, handling if it already exists
+ */
+function safeAddIndex(queryInterface, tableName, indexName, columns, options = {}) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            yield queryInterface.addIndex(tableName, columns, Object.assign({ name: indexName }, options));
+            console.log(`Index ${indexName} added to ${tableName} successfully.`);
+        }
+        catch (error) {
+            if (error.message.includes('already exists')) {
+                console.log(`Index ${indexName} already exists on ${tableName}, skipping.`);
+            }
+            else {
+                console.error(`Error adding index ${indexName} to ${tableName}:`, error.message);
+                throw error;
+            }
+        }
+    });
+}
+exports.safeAddIndex = safeAddIndex;

package/dist/migrations/010-add-user-resetToken.js

@@ -14,19 +14,36 @@ exports.down = exports.up = void 0;
 const sequelize_1 = require("sequelize");
 const up = (queryInterface) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        // Add all columns in parallel
-        yield queryInterface.addColumn('users', 'passwordResetToken', {
-            type: sequelize_1.DataTypes.STRING,
-            allowNull: true,
-        });
-        yield queryInterface.addColumn('users', 'passwordResetTokenExpiresAt', {
-            type: sequelize_1.DataTypes.DATE,
-            allowNull: true,
-        });
-        console.log('All columns added successfully.');
+        // Check which columns already exist
+        const tableDescription = yield queryInterface.describeTable('users');
+        const existingColumns = Object.keys(tableDescription);
+        // Add passwordResetToken if it doesn't exist
+        if (!existingColumns.includes('passwordResetToken')) {
+            yield queryInterface.addColumn('users', 'passwordResetToken', {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true,
+            });
+            console.log('passwordResetToken column added successfully.');
+        }
+        else {
+            console.log('passwordResetToken column already exists, skipping.');
+        }
+        // Add passwordResetTokenExpiresAt if it doesn't exist
+        if (!existingColumns.includes('passwordResetTokenExpiresAt')) {
+            yield queryInterface.addColumn('users', 'passwordResetTokenExpiresAt', {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+            });
+            console.log('passwordResetTokenExpiresAt column added successfully.');
+        }
+        else {
+            console.log('passwordResetTokenExpiresAt column already exists, skipping.');
+        }
+        console.log('Migration completed successfully.');
     }
     catch (error) {
         console.error('Error while adding columns:', error.message);
+        throw error;
     }
 });
 exports.up = up;

package/dist/migrations/011-add-guest-recommendation-tables.d.ts

@@ -0,0 +1,6 @@
+import { QueryInterface } from 'sequelize';
+declare const _default: {
+    up: (queryInterface: QueryInterface) => Promise<void>;
+    down: (queryInterface: QueryInterface) => Promise<void>;
+};
+export = _default;

package/dist/migrations/011-add-guest-recommendation-tables.js

@@ -0,0 +1,188 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+const sequelize_1 = require("sequelize");
+module.exports = {
+    up: (queryInterface) => __awaiter(void 0, void 0, void 0, function* () {
+        // Create guest_profiles table
+        yield queryInterface.createTable('guest_profiles', {
+            guest_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+            },
+            frequent_destinations: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true,
+            },
+            avg_budget_range: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true,
+            },
+            preferred_filters: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true,
+            },
+            family_traveler: {
+                type: sequelize_1.DataTypes.BOOLEAN,
+                allowNull: true,
+            },
+            avg_stay_duration: {
+                type: sequelize_1.DataTypes.INTEGER,
+                allowNull: true,
+            },
+            created_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+            updated_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+        });
+        // Create guest_search_history table
+        yield queryInterface.createTable('guest_search_history', {
+            search_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+            },
+            guest_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'guests',
+                    key: 'id',
+                },
+                onUpdate: 'CASCADE',
+                onDelete: 'SET NULL',
+            },
+            destination: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+            },
+            checkin_date: {
+                type: sequelize_1.DataTypes.DATEONLY,
+                allowNull: false,
+            },
+            checkout_date: {
+                type: sequelize_1.DataTypes.DATEONLY,
+                allowNull: false,
+            },
+            guests: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 1,
+            },
+            rooms: {
+                type: sequelize_1.DataTypes.SMALLINT,
+                allowNull: false,
+                defaultValue: 1,
+            },
+            budget_range: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true,
+            },
+            filters: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true,
+            },
+            search_timestamp: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+            search_context: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                defaultValue: 'exploration',
+            },
+            device_type: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                defaultValue: 'unknown',
+            },
+            travel_purpose: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                defaultValue: 'unspecified',
+            },
+            selected_hotel_ids: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.STRING),
+                allowNull: true,
+            },
+            place_id: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true,
+            },
+        });
+        // Create recommendations_cache table
+        yield queryInterface.createTable('recommendations_cache', {
+            cache_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                defaultValue: sequelize_1.DataTypes.UUIDV4,
+            },
+            guest_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: true,
+                references: {
+                    model: 'guests',
+                    key: 'id',
+                },
+                onUpdate: 'CASCADE',
+                onDelete: 'SET NULL',
+            },
+            hotels: {
+                type: sequelize_1.DataTypes.ARRAY(sequelize_1.DataTypes.STRING),
+                allowNull: false,
+            },
+            check_in: {
+                type: sequelize_1.DataTypes.DATEONLY,
+                allowNull: false,
+            },
+            check_out: {
+                type: sequelize_1.DataTypes.DATEONLY,
+                allowNull: false,
+            },
+            cached_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+            expiry: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+            },
+            search_params: {
+                type: sequelize_1.DataTypes.JSONB,
+                allowNull: true,
+            },
+            created_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+        });
+        // We won't add separate indexes since the foreign keys and primary keys are already indexed
+        // Also, Sequelize automatically creates indexes for foreign key references
+    }),
+    down: (queryInterface) => __awaiter(void 0, void 0, void 0, function* () {
+        // Drop tables in reverse order to avoid foreign key constraints
+        yield queryInterface.dropTable('recommendations_cache');
+        yield queryInterface.dropTable('guest_search_history');
+        yield queryInterface.dropTable('guest_profiles');
+    }),
+};

package/dist/migrations/011-add-project-resceotToke.js

@@ -14,16 +14,23 @@ exports.down = exports.up = void 0;
 const sequelize_1 = require("sequelize");
 const up = (queryInterface) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        // Add all columns in parallel
+        // Check if seo column already exists
+        const tableDescription = yield queryInterface.describeTable('projects');
+        const existingColumns = Object.keys(tableDescription);
+        if (existingColumns.includes('seo')) {
+            console.log('seo column already exists, skipping migration.');
+            return;
+        }
         yield queryInterface.addColumn('projects', 'seo', {
             type: sequelize_1.DataTypes.JSONB,
             allowNull: false,
             defaultValue: {},
         });
-        console.log('column added successfully.');
+        console.log('seo column added successfully.');
     }
     catch (error) {
-        console.error('Error while adding columns:', error.message);
+        console.error('Error while adding seo column:', error.message);
+        throw error;
     }
 });
 exports.up = up;

package/dist/migrations/012-add-guest-favorite-hotels.d.ts

@@ -0,0 +1,6 @@
+import { QueryInterface } from 'sequelize';
+declare const _default: {
+    up: (queryInterface: QueryInterface) => Promise<void>;
+    down: (queryInterface: QueryInterface) => Promise<void>;
+};
+export default _default;

package/dist/migrations/012-add-guest-favorite-hotels.js

@@ -0,0 +1,50 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sequelize_1 = require("sequelize");
+exports.default = {
+    up: (queryInterface) => __awaiter(void 0, void 0, void 0, function* () {
+        yield queryInterface.createTable('guest_favorite_hotels', {
+            guest_id: {
+                type: sequelize_1.DataTypes.UUID,
+                allowNull: false,
+                primaryKey: true,
+                references: {
+                    model: 'guests',
+                    key: 'id',
+                },
+                onDelete: 'CASCADE',
+                onUpdate: 'CASCADE',
+            },
+            hotel_id: {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: false,
+                primaryKey: true,
+            },
+            created_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+            updated_at: {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: false,
+                defaultValue: sequelize_1.DataTypes.NOW,
+            },
+        });
+        // Add indexes
+        yield queryInterface.addIndex('guest_favorite_hotels', ['guest_id']);
+        yield queryInterface.addIndex('guest_favorite_hotels', ['hotel_id']);
+    }),
+    down: (queryInterface) => __awaiter(void 0, void 0, void 0, function* () {
+        yield queryInterface.dropTable('guest_favorite_hotels');
+    }),
+};

package/dist/migrations/012-add-otp-expire.js

@@ -14,19 +14,38 @@ exports.down = exports.up = void 0;
 const sequelize_1 = require("sequelize");
 const up = (queryInterface) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        // Add all columns in parallel
-        yield queryInterface.addColumn('users', 'otpExpiresAt', {
-            type: sequelize_1.DataTypes.DATE,
-            allowNull: true,
-        });
-        yield queryInterface.addColumn('bookings', 'otpExpiresAt', {
-            type: sequelize_1.DataTypes.DATE,
-            allowNull: true,
-        });
-        console.log('column added successfully.');
+        // Check which columns already exist
+        const usersTableDescription = yield queryInterface.describeTable('users');
+        const bookingsTableDescription = yield queryInterface.describeTable('bookings');
+        const existingUsersColumns = Object.keys(usersTableDescription);
+        const existingBookingsColumns = Object.keys(bookingsTableDescription);
+        // Add otpExpiresAt to users if it doesn't exist
+        if (!existingUsersColumns.includes('otpExpiresAt')) {
+            yield queryInterface.addColumn('users', 'otpExpiresAt', {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+            });
+            console.log('otpExpiresAt column added to users table.');
+        }
+        else {
+            console.log('otpExpiresAt column already exists in users table, skipping.');
+        }
+        // Add otpExpiresAt to bookings if it doesn't exist
+        if (!existingBookingsColumns.includes('otpExpiresAt')) {
+            yield queryInterface.addColumn('bookings', 'otpExpiresAt', {
+                type: sequelize_1.DataTypes.DATE,
+                allowNull: true,
+            });
+            console.log('otpExpiresAt column added to bookings table.');
+        }
+        else {
+            console.log('otpExpiresAt column already exists in bookings table, skipping.');
+        }
+        console.log('Migration completed successfully.');
     }
     catch (error) {
         console.error('Error while adding columns:', error.message);
+        throw error;
     }
 });
 exports.up = up;

package/dist/migrations/013-add-bookings-payment.js

@@ -19,16 +19,25 @@ const columns = [
 ];
 const up = (queryInterface) => __awaiter(void 0, void 0, void 0, function* () {
     try {
-        // Add all columns in parallel
-        yield Promise.all(columns.map((column) => queryInterface.addColumn('bookings', column.name, {
+        // Check which columns already exist
+        const tableDescription = yield queryInterface.describeTable('bookings');
+        const existingColumns = Object.keys(tableDescription);
+        // Filter out columns that already exist
+        const columnsToAdd = columns.filter((column) => !existingColumns.includes(column.name));
+        if (columnsToAdd.length === 0) {
+            console.log('All columns already exist, skipping migration.');
+            return;
+        }
+        // Add only the columns that don't exist
+        yield Promise.all(columnsToAdd.map((column) => queryInterface.addColumn('bookings', column.name, {
             type: column.type,
             allowNull: column.allowNull,
         })));
-        console.log('All columns added successfully.');
-        console.log('All columns added successfully.');
+        console.log(`Added ${columnsToAdd.length} columns successfully.`);
     }
     catch (error) {
         console.error('Error while adding columns:', error.message);
+        throw error; // Re-throw to ensure migration fails properly
     }
 });
 exports.up = up;

package/dist/migrations/014-add-hotel-placeid.js

@@ -13,11 +13,25 @@ exports.down = exports.up = void 0;
 const sequelize_1 = require("sequelize");
 function up(queryInterface) {
     return __awaiter(this, void 0, void 0, function* () {
-        yield queryInterface.addColumn('static_hotels', 'placeId', {
-            type: sequelize_1.DataTypes.STRING,
-            allowNull: true,
-            comment: 'Google Place ID for the hotel',
-        });
+        try {
+            // Check if column already exists
+            const tableDescription = yield queryInterface.describeTable('static_hotels');
+            const existingColumns = Object.keys(tableDescription);
+            if (existingColumns.includes('placeId')) {
+                console.log('placeId column already exists, skipping migration.');
+                return;
+            }
+            yield queryInterface.addColumn('static_hotels', 'placeId', {
+                type: sequelize_1.DataTypes.STRING,
+                allowNull: true,
+                comment: 'Google Place ID for the hotel',
+            });
+            console.log('placeId column added successfully.');
+        }
+        catch (error) {
+            console.error('Error while adding placeId column:', error.message);
+            throw error;
+        }
     });
 }
 exports.up = up;

package/dist/migrations/018-link-room-amenities-to-hotels.js

@@ -13,25 +13,61 @@ exports.down = exports.up = void 0;
 const sequelize_1 = require("sequelize");
 function up(queryInterface) {
     return __awaiter(this, void 0, void 0, function* () {
-        // Add hotelId column to room_amenities table
-        yield queryInterface.addColumn('room_amenities', 'hotelId', {
-            type: sequelize_1.DataTypes.STRING,
-            allowNull: true,
-            references: {
-                model: 'static_hotels',
-                key: 'id',
-            },
-            onUpdate: 'CASCADE',
-            onDelete: 'CASCADE',
-        });
-        // Add index for better performance
-        yield queryInterface.addIndex('room_amenities', ['hotelId'], {
-            name: 'idx_room_amenities_hotel_id',
-        });
-        // Add composite index for filtering
-        yield queryInterface.addIndex('room_amenities', ['hotelId', 'amenityId'], {
-            name: 'idx_room_amenities_hotel_amenity',
-        });
+        try {
+            // Check if hotelId column already exists
+            const tableDescription = yield queryInterface.describeTable('room_amenities');
+            const existingColumns = Object.keys(tableDescription);
+            if (!existingColumns.includes('hotelId')) {
+                // Add hotelId column to room_amenities table
+                yield queryInterface.addColumn('room_amenities', 'hotelId', {
+                    type: sequelize_1.DataTypes.STRING,
+                    allowNull: true,
+                    references: {
+                        model: 'static_hotels',
+                        key: 'id',
+                    },
+                    onUpdate: 'CASCADE',
+                    onDelete: 'CASCADE',
+                });
+                console.log('hotelId column added successfully.');
+            }
+            else {
+                console.log('hotelId column already exists, skipping column creation.');
+            }
+            // Try to add indexes - they will fail gracefully if they already exist
+            try {
+                yield queryInterface.addIndex('room_amenities', ['hotelId'], {
+                    name: 'idx_room_amenities_hotel_id',
+                });
+                console.log('hotelId index added successfully.');
+            }
+            catch (error) {
+                if (error.message.includes('already exists')) {
+                    console.log('hotelId index already exists, skipping.');
+                }
+                else {
+                    throw error;
+                }
+            }
+            try {
+                yield queryInterface.addIndex('room_amenities', ['hotelId', 'amenityId'], {
+                    name: 'idx_room_amenities_hotel_amenity',
+                });
+                console.log('Composite index added successfully.');
+            }
+            catch (error) {
+                if (error.message.includes('already exists')) {
+                    console.log('Composite index already exists, skipping.');
+                }
+                else {
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error in migration 018:', error.message);
+            throw error;
+        }
     });
 }
 exports.up = up;