@ahmedhegazee/nestjs-telescope/dist/telescope/storage/drivers/memory-storage.driver.js

Advanced observability and monitoring solution for NestJS applications with ML-powered analytics, enterprise features, and production-ready scaling

"use strict";
var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
    return c > 3 && r && Object.defineProperty(target, key, r), r;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.MemoryStorageDriver = void 0;
const common_1 = require("@nestjs/common");
let MemoryStorageDriver = class MemoryStorageDriver {
    constructor() {
        this.entries = [];
        this.maxEntries = 10000;
    }
    async store(entry) {
        this.entries.push(entry);
        this.enforceMaxEntries();
    }
    async storeBatch(entries) {
        this.entries.push(...entries);
        this.enforceMaxEntries();
    }
    async find(filter) {
        let filteredEntries = [...this.entries];
        if (filter?.type) {
            filteredEntries = filteredEntries.filter(entry => entry.type === filter.type);
        }
        if (filter?.tags && filter.tags.length > 0) {
            filteredEntries = filteredEntries.filter(entry => filter.tags.some(tag => entry.tags.includes(tag)));
        }
        if (filter?.dateFrom) {
            filteredEntries = filteredEntries.filter(entry => entry.timestamp >= filter.dateFrom);
        }
        if (filter?.dateTo) {
            filteredEntries = filteredEntries.filter(entry => entry.timestamp <= filter.dateTo);
        }
        filteredEntries.sort((a, b) => b.timestamp.getTime() - a.timestamp.getTime());
        const offset = filter?.offset || 0;
        const limit = filter?.limit || 100;
        const total = filteredEntries.length;
        const paginatedEntries = filteredEntries.slice(offset, offset + limit);
        return {
            entries: paginatedEntries,
            total,
            hasMore: offset + limit < total
        };
    }
    async findById(id) {
        return this.entries.find(entry => entry.id === id) || null;
    }
    async delete(id) {
        const index = this.entries.findIndex(entry => entry.id === id);
        if (index >= 0) {
            this.entries.splice(index, 1);
            return true;
        }
        return false;
    }
    async clear() {
        this.entries = [];
    }
    async prune(olderThan) {
        const originalLength = this.entries.length;
        this.entries = this.entries.filter(entry => entry.timestamp > olderThan);
        return originalLength - this.entries.length;
    }
    async getStats() {
        const entriesByType = {};
        let oldestEntry;
        let newestEntry;
        for (const entry of this.entries) {
            entriesByType[entry.type] = (entriesByType[entry.type] || 0) + 1;
            if (!oldestEntry || entry.timestamp < oldestEntry) {
                oldestEntry = entry.timestamp;
            }
            if (!newestEntry || entry.timestamp > newestEntry) {
                newestEntry = entry.timestamp;
            }
        }
        return {
            totalEntries: this.entries.length,
            entriesByType,
            oldestEntry,
            newestEntry,
            sizeInBytes: JSON.stringify(this.entries).length
        };
    }
    enforceMaxEntries() {
        if (this.entries.length > this.maxEntries) {
            this.entries.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
            this.entries = this.entries.slice(-this.maxEntries);
        }
    }
};
exports.MemoryStorageDriver = MemoryStorageDriver;
exports.MemoryStorageDriver = MemoryStorageDriver = __decorate([
    (0, common_1.Injectable)()
], MemoryStorageDriver);
//# sourceMappingURL=memory-storage.driver.js.map