@vibe-flats/booking-engine-common-server 1.0.113 → 1.0.116

package/build/index.d.ts

@@ -3,3 +3,4 @@ export * from './src/config/app';
 export * from './src/utils/vibe-price';
 export * from './src/utils/monthly-diff';
 export * from './src/utils/purge-unit-cache';
+export * from './src/utils/cache';

package/build/index.js

@@ -19,3 +19,4 @@ __exportStar(require("./src/config/app"), exports);
 __exportStar(require("./src/utils/vibe-price"), exports);
 __exportStar(require("./src/utils/monthly-diff"), exports);
 __exportStar(require("./src/utils/purge-unit-cache"), exports);
+__exportStar(require("./src/utils/cache"), exports);

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

@@ -19,6 +19,9 @@ export interface MarketDocument extends mongoose.Document {
             answer: string;
         }[];
     };
+    furnishedFinder: {
+        extractString: string;
+    };
     createdAt: Date;
     updatedAt: Date;
 }

package/build/src/models/markets.js

@@ -52,6 +52,13 @@ const schema = new mongoose_1.default.Schema({
             ]
         }),
         _id: false
+    },
+    furnishedFinder: {
+        type: new mongoose_1.default.Schema({
+            extractString: { type: String }
+        }),
+        required: false,
+        _id: false
     }
 }, {
     timestamps: true

package/build/src/utils/cache.d.ts

@@ -0,0 +1,51 @@
+/**
+ * MongoDB Cache Implementation using Keyv
+ *
+ * This module provides a MongoDB-based caching solution using Keyv with full TypeScript support.
+ * Keyv provides a simple key-value interface with automatic TTL expiration in MongoDB.
+ *
+ * Usage Examples:
+ *
+ * 1. Simple caching with default TTL:
+ *    const data = await withCache('user_123', () => fetchUserData('123'));
+ *
+ * 2. Custom TTL (5 minutes):
+ *    const data = await withCache('expensive_calc', () => performCalculation(), 300);
+ *
+ * 3. In a controller:
+ *    export const myFunction = async (req, res) => {
+ *      const data = await withCache(
+ *        `user_${req.params.id}`,
+ *        () => fetchUserData(req.params.id),
+ *        300 // 5 minutes
+ *      );
+ *      res.json(data);
+ *    };
+ *
+ * Environment Variables Required:
+ * - MONGO_URL: MongoDB connection string base
+ * - MONGO_URL_PARAMS: Additional connection parameters (optional)
+ *
+ *
+ * When using this, need to stop the usage of gReq and pass the req as a param so it passes to withCache fetchFn
+ */
+interface CacheConfig {
+    defaultTTL: number;
+    keyPrefix: string;
+    mongoUri?: string;
+}
+declare class CacheManager {
+    private cache;
+    private config;
+    private isEnabled;
+    private collection;
+    constructor(config: CacheConfig);
+    private initializeCache;
+    get<T>(key: string): Promise<T | null>;
+    set<T>(key: string, value: T, ttl?: number): Promise<boolean>;
+    del(key: string): Promise<boolean>;
+    clear(): Promise<boolean>;
+}
+export declare const mongoCacheManager: CacheManager;
+export declare const withMongoCache: <T>(key: string, fetchFn: () => Promise<T>, ttl?: number) => Promise<T>;
+export default mongoCacheManager;

package/build/src/utils/cache.js

@@ -0,0 +1,172 @@
+"use strict";
+/**
+ * MongoDB Cache Implementation using Keyv
+ *
+ * This module provides a MongoDB-based caching solution using Keyv with full TypeScript support.
+ * Keyv provides a simple key-value interface with automatic TTL expiration in MongoDB.
+ *
+ * Usage Examples:
+ *
+ * 1. Simple caching with default TTL:
+ *    const data = await withCache('user_123', () => fetchUserData('123'));
+ *
+ * 2. Custom TTL (5 minutes):
+ *    const data = await withCache('expensive_calc', () => performCalculation(), 300);
+ *
+ * 3. In a controller:
+ *    export const myFunction = async (req, res) => {
+ *      const data = await withCache(
+ *        `user_${req.params.id}`,
+ *        () => fetchUserData(req.params.id),
+ *        300 // 5 minutes
+ *      );
+ *      res.json(data);
+ *    };
+ *
+ * Environment Variables Required:
+ * - MONGO_URL: MongoDB connection string base
+ * - MONGO_URL_PARAMS: Additional connection parameters (optional)
+ *
+ *
+ * When using this, need to stop the usage of gReq and pass the req as a param so it passes to withCache fetchFn
+ */
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withMongoCache = exports.mongoCacheManager = void 0;
+const keyv_1 = __importDefault(require("keyv"));
+const mongo_1 = __importDefault(require("@keyv/mongo"));
+class CacheManager {
+    constructor(config) {
+        this.cache = null;
+        this.isEnabled = false;
+        this.collection = 'cache';
+        this.config = config;
+        this.initializeCache();
+    }
+    initializeCache() {
+        try {
+            // Use provided MongoDB URI or build from environment variables
+            const mongoUri = this.config.mongoUri || `${process.env.MONGO_URL}${this.collection}${process.env.MONGO_URL_PARAMS || ''}`;
+            if (!mongoUri || !process.env.MONGO_URL) {
+                console.warn('MongoDB URL not provided. Cache will be disabled.');
+                return;
+            }
+            // Create Keyv instance with MongoDB store
+            const store = new mongo_1.default(mongoUri, {
+                collection: this.collection
+            });
+            this.cache = new keyv_1.default({
+                store,
+                ttl: this.config.defaultTTL,
+                namespace: this.config.keyPrefix
+            });
+            // Handle connection events
+            this.cache.on('error', error => {
+                console.warn('Cache error:', error);
+                this.isEnabled = false;
+            });
+            this.isEnabled = true;
+            console.log('MongoDB cache initialized successfully with Keyv');
+        }
+        catch (error) {
+            console.warn('Failed to initialize MongoDB cache:', error);
+            this.isEnabled = false;
+        }
+    }
+    get(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isEnabled || !this.cache) {
+                return null;
+            }
+            try {
+                const value = yield this.cache.get(key);
+                return value || null;
+            }
+            catch (error) {
+                console.warn('Cache get error:', error);
+                return null;
+            }
+        });
+    }
+    set(key, value, ttl) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isEnabled || !this.cache) {
+                return false;
+            }
+            try {
+                const timeToLive = ttl ? ttl * 1000 : this.config.defaultTTL; // Convert seconds to milliseconds
+                yield this.cache.set(key, value, timeToLive);
+                return true;
+            }
+            catch (error) {
+                console.warn('Cache set error:', error);
+                return false;
+            }
+        });
+    }
+    del(key) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isEnabled || !this.cache) {
+                return false;
+            }
+            try {
+                const result = yield this.cache.delete(key);
+                return result;
+            }
+            catch (error) {
+                console.warn('Cache delete error:', error);
+                return false;
+            }
+        });
+    }
+    clear() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.isEnabled || !this.cache) {
+                return false;
+            }
+            try {
+                // Keyv's clear() method respects the namespace/prefix
+                // So this will only clear items with our prefix
+                yield this.cache.clear();
+                console.log(`Cleared all cache entries with prefix: ${this.config.keyPrefix}`);
+                return true;
+            }
+            catch (error) {
+                console.warn('Cache clear error:', error);
+                return false;
+            }
+        });
+    }
+}
+// Create a singleton cache manager instance
+exports.mongoCacheManager = new CacheManager({
+    defaultTTL: 600000, // 10 minutes in milliseconds
+    keyPrefix: process.env.npm_package_name || 'no-process.env.npm_package_name'
+});
+// Helper function for caching with fallback (exactly like your example)
+const withMongoCache = (key_1, fetchFn_1, ...args_1) => __awaiter(void 0, [key_1, fetchFn_1, ...args_1], void 0, function* (key, fetchFn, ttl = 600) {
+    let result = yield exports.mongoCacheManager.get(key);
+    if (result) {
+        console.log(`Cache hit for key: ${key}`);
+        return result;
+    }
+    console.log(`Cache miss for key: ${key}`);
+    result = yield fetchFn();
+    yield exports.mongoCacheManager.set(key, result, ttl);
+    console.log(`Cached data for key: ${key}`);
+    return result;
+});
+exports.withMongoCache = withMongoCache;
+// Alternative export for convenience
+exports.default = exports.mongoCacheManager;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vibe-flats/booking-engine-common-server",
-	"version": "1.0.113",
+	"version": "1.0.116",
 	"description": "",
 	"main": "./build/index.js",
 	"types": "./build/index.d.ts",
@@ -21,8 +21,10 @@
 		"typescript": "^5.1.6"
 	},
 	"dependencies": {
+		"@keyv/mongo": "^3.0.3",
 		"axios": "^1.7.9",
 		"dayjs": "^1.11.13",
+		"keyv": "^5.5.0",
 		"mongoose": "^8.5.2"
 	}
 }