@bikdotai/bik-shared-backend 20.3.2-beta.4 → 20.4.0

package/lib/database/database.service.js

@@ -1,382 +0,0 @@
-"use strict";
-/**
- * Database Service
- *
- * Provides generic database connection management for PostgreSQL using Sequelize and node-postgres.
- * Supports connection pooling, read replicas, auto-retry logic, and Secret Manager integration.
- */
-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.readerPool = exports.pool = exports.BikSequelize = exports.resetDefaultConnections = exports.getDefaultReaderPool = exports.getDefaultPool = exports.getDefaultSequelize = exports.DatabaseService = exports.ENABLE_SEQUELIZE_LOGGING = exports.databaseSchema = void 0;
-const sequelize_1 = require("sequelize");
-const pg_1 = require("pg");
-const auth_1 = require("../auth");
-const config_1 = require("../core/config");
-const logger_1 = require("../logger");
-exports.databaseSchema = config_1.isProd ? 'bik' : 'public';
-// Enable sequelize logging based on environment variable
-exports.ENABLE_SEQUELIZE_LOGGING = auth_1.EnvVariableHelper.accessRaw('ENABLE_SEQUELIZE_LOGGING') === 'true';
-/**
- * Service class for managing database connections
- * Provides generic functions to create Sequelize and pg Pool connections
- */
-class DatabaseService {
-    /**
-     * Get PostgreSQL configuration from secrets
-     * @param secretKeyName - Optional custom secret key name (defaults to 'aurora-common')
-     * @returns Promise<PgConfig>
-     */
-    static getPgConfig(secretKeyName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Cache the config to avoid multiple secret manager calls
-            if (!this.pgConfigCache) {
-                this.pgConfigCache = (() => __awaiter(this, void 0, void 0, function* () {
-                    const secretName = secretKeyName ||
-                        auth_1.EnvVariableHelper.access(auth_1.ServiceName.PGSQL, auth_1.PgSQLKeys.SECRET_NAME, 'pg_secret_name') ||
-                        'aurora-common';
-                    const secretManagerService = auth_1.SecretManagerService.getInstance();
-                    const secrets = yield secretManagerService.getSecret(secretName);
-                    return {
-                        username: secrets.user,
-                        password: secrets.password,
-                        host: secrets.host,
-                        read: secrets.read,
-                        database: secrets.database,
-                        dialect: secrets.dialect,
-                        schema: secrets.schema,
-                        port: secrets.port,
-                    };
-                }))();
-            }
-            return this.pgConfigCache;
-        });
-    }
-    /**
-     * Reset the cached config (useful for testing or when secrets change)
-     */
-    static resetConfigCache() {
-        this.pgConfigCache = null;
-    }
-    /**
-     * Create a Sequelize instance with optimal configuration
-     * @param options - Optional configuration for connection pooling and retry logic
-     * @param secretKeyName - Optional custom secret key name
-     * @returns Promise<Sequelize>
-     */
-    static createSequelizeConnection(options = {}, secretKeyName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pgConfig = yield this.getPgConfig(secretKeyName);
-            const { maxConnections = 15, minConnections = 1, acquireTimeout = 60000, idleTimeout = 1000, maxRetries = 20, backoffBase = 500, backoffExponent = 1.2, enableLogging = exports.ENABLE_SEQUELIZE_LOGGING, customSchema, enableQueryMetadata = true, } = options;
-            const sequelize = new sequelize_1.Sequelize(pgConfig.database, pgConfig.username, pgConfig.password, {
-                dialect: 'postgres',
-                replication: {
-                    read: pgConfig.read || [],
-                    write: { host: pgConfig.host },
-                },
-                pool: {
-                    max: maxConnections,
-                    min: minConnections,
-                    acquire: acquireTimeout,
-                    idle: idleTimeout,
-                },
-                retry: {
-                    match: [
-                        sequelize_1.ConnectionError,
-                        sequelize_1.DatabaseError,
-                        sequelize_1.ConnectionRefusedError,
-                        /Deadlock/i,
-                        /SequelizeDatabaseError/,
-                        /SequelizeConnectionError/,
-                        /SequelizeHostNotFoundError/,
-                        /SequelizeHostNotReachableError/,
-                        /SequelizeInvalidConnectionError/,
-                        /SequelizeConnectionTimedOutError/,
-                    ],
-                    max: maxRetries,
-                    backoffBase,
-                    backoffExponent,
-                },
-                port: 5432,
-                logging: enableLogging,
-                schema: customSchema || pgConfig.schema,
-                dialectOptions: {
-                    application_name: 'bik-backend', // Default application name
-                },
-            });
-            // Set application_name at the connection level for ALL queries (including Model operations)
-            // This approach works because it wraps the actual query execution on each connection
-            if (enableQueryMetadata) {
-                // Hook into connection acquisition to wrap the query method
-                const originalGetConnection = sequelize.connectionManager.getConnection.bind(sequelize.connectionManager);
-                sequelize.connectionManager.getConnection = function (options) {
-                    return __awaiter(this, void 0, void 0, function* () {
-                        const connection = yield originalGetConnection(options);
-                        // Wrap the query method if not already wrapped
-                        if (!connection._queryWrapped) {
-                            const originalQuery = connection.query.bind(connection);
-                            connection.query = function (sql, ...args) {
-                                try {
-                                    // Get CURRENT context at query execution time
-                                    const context = logger_1.LogExecutionContextHelper.getContext();
-                                    const apiName = (context === null || context === void 0 ? void 0 : context.apiName) || 'unknown_api';
-                                    if (apiName === 'unknown_api') {
-                                        console.warn('⚠️ [DB] NO API NAME IN CONTEXT!');
-                                    }
-                                    // Inject SET application_name before the actual query
-                                    const appNameQuery = `SET application_name = 'bik:${apiName}'`;
-                                    if (typeof sql === 'string') {
-                                        console.log('🔍 [DB] Executing raw SQL query');
-                                        sql = `${appNameQuery}; ${sql}`;
-                                    }
-                                    else if (sql && typeof sql === 'object' && 'text' in sql) {
-                                        console.log('🔍 [DB] Executing parameterized SQL query');
-                                        sql.text = `${appNameQuery}; ${sql.text}`;
-                                    }
-                                    else {
-                                        console.log('⚠️ [DB] Unable to set application_name - unrecognized query format', sql);
-                                    }
-                                    if (exports.ENABLE_SEQUELIZE_LOGGING) {
-                                        console.log(`🔍 [DB] Query executing with application_name: bik:${apiName}`);
-                                    }
-                                }
-                                catch (error) {
-                                    if (exports.ENABLE_SEQUELIZE_LOGGING) {
-                                        console.error('Error setting application_name:', error);
-                                    }
-                                }
-                                return originalQuery(sql, ...args);
-                            };
-                            connection._queryWrapped = true;
-                        }
-                        else {
-                            console.warn('⚠️ [DB] Query method already wrapped');
-                        }
-                        return connection;
-                    });
-                };
-            }
-            return sequelize;
-        });
-    }
-    /**
-     * Create a PostgreSQL Pool for raw queries (write operations)
-     * @param options - Optional configuration for connection pooling
-     * @param secretKeyName - Optional custom secret key name
-     * @returns Promise<Pool>
-     */
-    static createPool(options = {}, secretKeyName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const pgConfig = yield this.getPgConfig(secretKeyName);
-            const { maxConnections = 15, minConnections = 0, idleTimeout = 1000 } = options;
-            const config = {
-                user: pgConfig.username,
-                database: pgConfig.database,
-                password: pgConfig.password,
-                port: pgConfig.port,
-                host: pgConfig.host,
-                max: maxConnections,
-                min: minConnections,
-                idleTimeoutMillis: idleTimeout,
-                application_name: 'bik-backend', // Default application name for Aurora tracking
-            };
-            const pool = new pg_1.Pool(config);
-            // Wrap the query method to set application_name dynamically
-            const originalQuery = pool.query.bind(pool);
-            pool.query = function (queryTextOrConfig, values, callback) {
-                try {
-                    const context = logger_1.LogExecutionContextHelper.getContext();
-                    const apiName = (context === null || context === void 0 ? void 0 : context.apiName) || 'unknown_api';
-                    // Inject SET application_name before the actual query
-                    // This makes it visible in Aurora Performance Insights and pg_stat_activity
-                    const appNameQuery = `SET application_name = 'bik:${apiName}'`;
-                    if (typeof queryTextOrConfig === 'string') {
-                        // Simple query: query(text, values, callback)
-                        queryTextOrConfig = `${appNameQuery}; ${queryTextOrConfig}`;
-                    }
-                    else if (queryTextOrConfig &&
-                        typeof queryTextOrConfig === 'object' &&
-                        'text' in queryTextOrConfig) {
-                        // Query config object: query({ text, values }, callback)
-                        queryTextOrConfig.text = `${appNameQuery}; ${queryTextOrConfig.text}`;
-                    }
-                }
-                catch (error) {
-                    if (exports.ENABLE_SEQUELIZE_LOGGING) {
-                        console.error('Error setting application_name for Pool query:', error);
-                    }
-                }
-                return originalQuery(queryTextOrConfig, values, callback);
-            };
-            return pool;
-        });
-    }
-    /**
-     * Create a PostgreSQL Pool for read operations (using read replicas)
-     * @param options - Optional configuration for connection pooling
-     * @param secretKeyName - Optional custom secret key name
-     * @returns Promise<Pool>
-     */
-    static createReaderPool(options = {}, secretKeyName) {
-        var _a, _b;
-        return __awaiter(this, void 0, void 0, function* () {
-            const pgConfig = yield this.getPgConfig(secretKeyName);
-            const { maxConnections = 15, minConnections = 0, idleTimeout = 1000 } = options;
-            const config = {
-                user: pgConfig.username,
-                database: pgConfig.database,
-                password: pgConfig.password,
-                port: pgConfig.port,
-                host: ((_b = (_a = pgConfig.read) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.host) || pgConfig.host,
-                max: maxConnections,
-                min: minConnections,
-                idleTimeoutMillis: idleTimeout,
-                application_name: 'bik-backend-reader', // Default application name for Aurora tracking
-            };
-            const pool = new pg_1.Pool(config);
-            // Wrap the query method to set application_name dynamically
-            const originalQuery = pool.query.bind(pool);
-            pool.query = function (queryTextOrConfig, values, callback) {
-                try {
-                    const context = logger_1.LogExecutionContextHelper.getContext();
-                    const apiName = (context === null || context === void 0 ? void 0 : context.apiName) || 'unknown_api';
-                    // Inject SET application_name before the actual query
-                    // This makes it visible in Aurora Performance Insights and pg_stat_activity
-                    const appNameQuery = `SET application_name = 'bik:${apiName}:read'`;
-                    if (typeof queryTextOrConfig === 'string') {
-                        // Simple query: query(text, values, callback)
-                        queryTextOrConfig = `${appNameQuery}; ${queryTextOrConfig}`;
-                    }
-                    else if (queryTextOrConfig &&
-                        typeof queryTextOrConfig === 'object' &&
-                        'text' in queryTextOrConfig) {
-                        // Query config object: query({ text, values }, callback)
-                        queryTextOrConfig.text = `${appNameQuery}; ${queryTextOrConfig.text}`;
-                    }
-                }
-                catch (error) {
-                    if (exports.ENABLE_SEQUELIZE_LOGGING) {
-                        console.error('Error setting application_name for ReaderPool query:', error);
-                    }
-                }
-                return originalQuery(queryTextOrConfig, values, callback);
-            };
-            return pool;
-        });
-    }
-    /**
-     * Create all database connections at once
-     * Useful for initializing all required connections at application startup
-     * @param options - Optional configuration for connection pooling
-     * @param secretKeyName - Optional custom secret key name
-     * @returns Promise with all connection types
-     */
-    static createAllConnections(options = {}, secretKeyName) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const [sequelize, pool, readerPool] = yield Promise.all([
-                this.createSequelizeConnection(options, secretKeyName),
-                this.createPool(options, secretKeyName),
-                this.createReaderPool(options, secretKeyName),
-            ]);
-            return { sequelize, pool, readerPool };
-        });
-    }
-    /**
-     * Test database connection
-     * @param sequelize - Sequelize instance to test
-     * @returns Promise<boolean>
-     */
-    static testConnection(sequelize) {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                yield sequelize.authenticate();
-                console.log('Database connection has been established successfully.');
-                return true;
-            }
-            catch (error) {
-                console.error('Unable to connect to the database:', error);
-                return false;
-            }
-        });
-    }
-    /**
-     * Gracefully close all connections
-     * @param connections - Object containing all connection instances
-     */
-    static closeConnections(connections) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const closePromises = [];
-            if (connections.sequelize) {
-                closePromises.push(connections.sequelize.close());
-            }
-            if (connections.pool) {
-                closePromises.push(connections.pool.end());
-            }
-            if (connections.readerPool) {
-                closePromises.push(connections.readerPool.end());
-            }
-            yield Promise.all(closePromises);
-            console.log('All database connections closed successfully.');
-        });
-    }
-}
-exports.DatabaseService = DatabaseService;
-DatabaseService.pgConfigCache = null;
-// Singleton instances for backward compatibility and easy access
-let defaultSequelizeInstance = null;
-let defaultPoolInstance = null;
-let defaultReaderPoolInstance = null;
-/**
- * Get or create the default Sequelize instance (Singleton)
- * @returns Promise<Sequelize>
- */
-const getDefaultSequelize = () => {
-    if (!defaultSequelizeInstance) {
-        defaultSequelizeInstance = DatabaseService.createSequelizeConnection();
-    }
-    return defaultSequelizeInstance;
-};
-exports.getDefaultSequelize = getDefaultSequelize;
-/**
- * Get or create the default Pool instance (Singleton)
- * @returns Promise<Pool>
- */
-const getDefaultPool = () => {
-    if (!defaultPoolInstance) {
-        defaultPoolInstance = DatabaseService.createPool();
-    }
-    return defaultPoolInstance;
-};
-exports.getDefaultPool = getDefaultPool;
-/**
- * Get or create the default Reader Pool instance (Singleton)
- * @returns Promise<Pool>
- */
-const getDefaultReaderPool = () => {
-    if (!defaultReaderPoolInstance) {
-        defaultReaderPoolInstance = DatabaseService.createReaderPool();
-    }
-    return defaultReaderPoolInstance;
-};
-exports.getDefaultReaderPool = getDefaultReaderPool;
-/**
- * Reset all singleton instances (useful for testing)
- */
-const resetDefaultConnections = () => {
-    defaultSequelizeInstance = null;
-    defaultPoolInstance = null;
-    defaultReaderPoolInstance = null;
-    DatabaseService.resetConfigCache();
-};
-exports.resetDefaultConnections = resetDefaultConnections;
-// Export legacy variable names for backward compatibility
-exports.BikSequelize = (0, exports.getDefaultSequelize)();
-exports.pool = (0, exports.getDefaultPool)();
-exports.readerPool = (0, exports.getDefaultReaderPool)();

package/lib/database/index.d.ts

@@ -1,7 +0,0 @@
-/**
- * Database Service
- *
- * Generic database connection management for PostgreSQL
- */
-export * from './database.service';
-export * from './database.model';

package/lib/database/index.js

@@ -1,23 +0,0 @@
-"use strict";
-/**
- * Database Service
- *
- * Generic database connection management for PostgreSQL
- */
-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("./database.service"), exports);
-__exportStar(require("./database.model"), exports);

package/lib/elastic/queries/chatbot/getAgentCostForBroadcast.d.ts

@@ -1,117 +0,0 @@
-import { Events } from '@bikdotai/bik-models/events';
-import { QueryHelper } from '../query.helper';
-export interface GetAgentCostForBroadcastParams {
-    indexName: string;
-    storeId: string;
-    broadcastId: string;
-    startDate: string;
-    endDate: string;
-}
-export interface AgentCostUsageBucket {
-    usedTier: string | null;
-    usageType: string | null;
-    isFreeAgent: boolean | null;
-    /** For non-audio usage: number of operations */
-    count: number;
-    /** For audio (AUDIO usageType): total seconds */
-    usageUnits: number;
-}
-export interface GetAgentCostForBroadcastResponse {
-    buckets: AgentCostUsageBucket[];
-}
-export declare class GetAgentCostForBroadcastQuery implements QueryHelper<GetAgentCostForBroadcastParams, GetAgentCostForBroadcastResponse> {
-    getQuery(params: GetAgentCostForBroadcastParams): {
-        index: string;
-        size: number;
-        query: {
-            bool: {
-                filter: {
-                    range: {
-                        timestamp: {
-                            gte: string;
-                            lte: string;
-                        };
-                    };
-                }[];
-                must: ({
-                    term: {
-                        'storeId.keyword': {
-                            value: string;
-                        };
-                        "eventName.keyword"?: undefined;
-                        'eventProperties.useCaseId.keyword'?: undefined;
-                    };
-                } | {
-                    term: {
-                        'eventName.keyword': {
-                            value: Events;
-                        };
-                        "storeId.keyword"?: undefined;
-                        'eventProperties.useCaseId.keyword'?: undefined;
-                    };
-                } | {
-                    term: {
-                        'eventProperties.useCaseId.keyword': {
-                            value: string;
-                        };
-                        "storeId.keyword"?: undefined;
-                        "eventName.keyword"?: undefined;
-                    };
-                })[];
-            };
-        };
-        aggs: {
-            usage_by_tier_type_agent: {
-                composite: {
-                    size: number;
-                    sources: ({
-                        usedTier: {
-                            terms: {
-                                field: string;
-                                missing_bucket: boolean;
-                            };
-                        };
-                        usageType?: undefined;
-                        isFreeAgent?: undefined;
-                    } | {
-                        usageType: {
-                            terms: {
-                                field: string;
-                                missing_bucket: boolean;
-                            };
-                        };
-                        usedTier?: undefined;
-                        isFreeAgent?: undefined;
-                    } | {
-                        isFreeAgent: {
-                            terms: {
-                                field: string;
-                                missing_bucket: boolean;
-                            };
-                        };
-                        usedTier?: undefined;
-                        usageType?: undefined;
-                    })[];
-                };
-                aggs: {
-                    audio_usage: {
-                        filter: {
-                            term: {
-                                'eventProperties.usageType.keyword': string;
-                            };
-                        };
-                        aggs: {
-                            total_usage_units: {
-                                sum: {
-                                    field: string;
-                                    missing: number;
-                                };
-                            };
-                        };
-                    };
-                };
-            };
-        };
-    };
-    transform(elasticOutput: any): GetAgentCostForBroadcastResponse;
-}

package/lib/elastic/queries/chatbot/getAgentCostForBroadcast.js

@@ -1,98 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetAgentCostForBroadcastQuery = void 0;
-const events_1 = require("@bikdotai/bik-models/events");
-class GetAgentCostForBroadcastQuery {
-    getQuery(params) {
-        return {
-            index: params.indexName,
-            size: 0,
-            query: {
-                bool: {
-                    filter: [
-                        {
-                            range: {
-                                timestamp: { gte: params.startDate, lte: params.endDate },
-                            },
-                        },
-                    ],
-                    must: [
-                        { term: { 'storeId.keyword': { value: params.storeId } } },
-                        { term: { 'eventName.keyword': { value: events_1.Events.SERVICE_USED } } },
-                        {
-                            term: {
-                                'eventProperties.useCaseId.keyword': { value: params.broadcastId },
-                            },
-                        },
-                    ],
-                },
-            },
-            aggs: {
-                usage_by_tier_type_agent: {
-                    composite: {
-                        size: 10000,
-                        sources: [
-                            {
-                                usedTier: {
-                                    terms: {
-                                        field: 'eventProperties.usedTier.keyword',
-                                        missing_bucket: true,
-                                    },
-                                },
-                            },
-                            {
-                                usageType: {
-                                    terms: {
-                                        field: 'eventProperties.usageType.keyword',
-                                        missing_bucket: true,
-                                    },
-                                },
-                            },
-                            {
-                                isFreeAgent: {
-                                    terms: {
-                                        field: 'eventProperties.isFreeAgent',
-                                        missing_bucket: true,
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                    aggs: {
-                        audio_usage: {
-                            filter: {
-                                term: { 'eventProperties.usageType.keyword': 'AUDIO' },
-                            },
-                            aggs: {
-                                total_usage_units: {
-                                    sum: { field: 'eventProperties.usageUnits', missing: 0 },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        };
-    }
-    transform(elasticOutput) {
-        var _a, _b, _c;
-        const buckets = (_c = (_b = (_a = elasticOutput === null || elasticOutput === void 0 ? void 0 : elasticOutput.aggregations) === null || _a === void 0 ? void 0 : _a.usage_by_tier_type_agent) === null || _b === void 0 ? void 0 : _b.buckets) !== null && _c !== void 0 ? _c : [];
-        return {
-            buckets: buckets
-                .filter((b) => b.key.usedTier !== null &&
-                b.key.usageType !== null &&
-                b.key.isFreeAgent !== null)
-                .map((b) => {
-                var _a, _b, _c, _d;
-                return ({
-                    usedTier: b.key.usedTier,
-                    usageType: b.key.usageType,
-                    isFreeAgent: b.key.isFreeAgent,
-                    count: (_a = b.doc_count) !== null && _a !== void 0 ? _a : 0,
-                    usageUnits: (_d = (_c = (_b = b.audio_usage) === null || _b === void 0 ? void 0 : _b.total_usage_units) === null || _c === void 0 ? void 0 : _c.value) !== null && _d !== void 0 ? _d : 0,
-                });
-            }),
-        };
-    }
-}
-exports.GetAgentCostForBroadcastQuery = GetAgentCostForBroadcastQuery;