@ahmedhegazee/nestjs-telescope/dist/telescope/storage/drivers/database-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;
};
var __metadata = (this && this.__metadata) || function (k, v) {
    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
};
var __param = (this && this.__param) || function (paramIndex, decorator) {
    return function (target, key) { decorator(target, key, paramIndex); }
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.DatabaseStorageDriver = void 0;
const common_1 = require("@nestjs/common");
const typeorm_1 = require("@nestjs/typeorm");
const typeorm_2 = require("typeorm");
const telescope_entry_entity_1 = require("../entities/telescope-entry.entity");
let DatabaseStorageDriver = class DatabaseStorageDriver {
    constructor(entryRepository) {
        this.entryRepository = entryRepository;
    }
    async store(entry) {
        const entity = this.entryRepository.create({
            id: entry.id,
            type: entry.type,
            familyHash: entry.familyHash,
            content: entry.content,
            tags: entry.tags,
            timestamp: entry.timestamp,
            sequence: entry.sequence,
            batchId: entry.batchId,
            createdAt: new Date(),
            environment: process.env.NODE_ENV || 'development',
            metadata: entry.batchId ? JSON.stringify({ batchId: entry.batchId }) : undefined
        });
        await this.entryRepository.save(entity);
    }
    async storeBatch(entries) {
        const entities = entries.map(entry => this.entryRepository.create({
            id: entry.id,
            type: entry.type,
            familyHash: entry.familyHash,
            content: entry.content,
            tags: entry.tags,
            timestamp: entry.timestamp,
            sequence: entry.sequence,
            batchId: entry.batchId,
            createdAt: new Date(),
            environment: process.env.NODE_ENV || 'development',
            metadata: entry.batchId ? JSON.stringify({ batchId: entry.batchId }) : undefined
        }));
        await this.entryRepository.save(entities, { chunk: 100 });
    }
    async find(filter) {
        const queryBuilder = this.entryRepository.createQueryBuilder('entry');
        if (filter?.type) {
            queryBuilder.andWhere('entry.type = :type', { type: filter.type });
        }
        if (filter?.tags && filter.tags.length > 0) {
            queryBuilder.andWhere('entry.tags && :tags', { tags: filter.tags });
        }
        if (filter?.dateFrom && filter?.dateTo) {
            queryBuilder.andWhere('entry.timestamp BETWEEN :dateFrom AND :dateTo', {
                dateFrom: filter.dateFrom,
                dateTo: filter.dateTo
            });
        }
        else if (filter?.dateFrom) {
            queryBuilder.andWhere('entry.timestamp >= :dateFrom', { dateFrom: filter.dateFrom });
        }
        else if (filter?.dateTo) {
            queryBuilder.andWhere('entry.timestamp <= :dateTo', { dateTo: filter.dateTo });
        }
        queryBuilder.orderBy('entry.timestamp', 'DESC');
        const offset = filter?.offset || 0;
        const limit = filter?.limit || 100;
        queryBuilder.skip(offset).take(limit);
        const [entities, total] = await queryBuilder.getManyAndCount();
        return {
            entries: entities.map(entity => this.entityToEntry(entity)),
            total,
            hasMore: offset + limit < total
        };
    }
    async findById(id) {
        const entity = await this.entryRepository.findOne({ where: { id } });
        return entity ? this.entityToEntry(entity) : null;
    }
    async delete(id) {
        const result = await this.entryRepository.delete({ id });
        return (result.affected || 0) > 0;
    }
    async clear() {
        await this.entryRepository.clear();
    }
    async prune(olderThan) {
        const result = await this.entryRepository.delete({
            timestamp: (0, typeorm_2.Between)(new Date(0), olderThan)
        });
        return result.affected || 0;
    }
    async getStats() {
        const [totalEntries, entriesByType, oldestEntry, newestEntry] = await Promise.all([
            this.entryRepository.count(),
            this.getEntriesByType(),
            this.entryRepository.findOne({
                order: { timestamp: 'ASC' },
                select: ['timestamp']
            }),
            this.entryRepository.findOne({
                order: { timestamp: 'DESC' },
                select: ['timestamp']
            })
        ]);
        return {
            totalEntries,
            entriesByType,
            oldestEntry: oldestEntry?.timestamp,
            newestEntry: newestEntry?.timestamp
        };
    }
    async getEntriesByType() {
        const result = await this.entryRepository
            .createQueryBuilder('entry')
            .select('entry.type', 'type')
            .addSelect('COUNT(*)', 'count')
            .groupBy('entry.type')
            .getRawMany();
        return result.reduce((acc, row) => {
            acc[row.type] = parseInt(row.count);
            return acc;
        }, {});
    }
    entityToEntry(entity) {
        return {
            id: entity.id,
            type: entity.type,
            familyHash: entity.familyHash,
            content: entity.content,
            tags: entity.tags,
            timestamp: entity.timestamp,
            sequence: entity.sequence,
            batchId: entity.batchId
        };
    }
    async healthCheck() {
        try {
            await this.entryRepository.query('SELECT 1');
            return true;
        }
        catch (error) {
            return false;
        }
    }
};
exports.DatabaseStorageDriver = DatabaseStorageDriver;
exports.DatabaseStorageDriver = DatabaseStorageDriver = __decorate([
    (0, common_1.Injectable)(),
    __param(0, (0, typeorm_1.InjectRepository)(telescope_entry_entity_1.TelescopeEntryEntity)),
    __metadata("design:paramtypes", [typeorm_2.Repository])
], DatabaseStorageDriver);
//# sourceMappingURL=database-storage.driver.js.map