@bikdotai/bik-shared-backend 20.3.1 → 20.3.2-beta.1

package/lib/core/local_runner.js

@@ -1,4 +1,6 @@
 "use strict";
+// Boilerplate code to easily run bik-shared-backend locally
+// To run this in local please do npx tsc && npx ts-node src/core/local_runner.ts
 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) {
@@ -13,9 +15,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const setup_1 = __importDefault(require("../logger/setup"));
-const merchant_events_1 = require("../merchant-events");
-const podName_1 = require("./podName");
 const setup_2 = require("./setup");
+const alertsV2_service_1 = require("../alertsV2/alertsV2.service");
+const constants_1 = require("@bikdotai/bik-models/core/constants");
 setup_2.BikBackendSetup.setUpV2({
     slackConfiguration: {
         slackChannelId: 'C04LEGSM0Q2',
@@ -24,20 +26,35 @@ setup_2.BikBackendSetup.setUpV2({
 }).then(() => {
     setup_1.default.setUp([console, console]);
     console.log('BikBackendSetup done');
+    // Uncomment to run the simulation when you start this file.
+    for (let i = 0; i < 1; i++) {
+        simulateSendAlert().then().catch(console.error);
+    }
 });
 /**
  * Function to simulate concurrent Redis requests
  */
-function test() {
+// async function test() {}
+// test().then().catch();
+/**
+ * Minimal local simulation for Alerts V2 `sendAlert`.
+ *
+ * Notes:
+ * - This hits repo lookups + channel senders.
+ * - If `alertConfigId` doesn't exist (or is inactive), you'd see `RESOURCE_NOT_FOUND` or a success no-op.
+ * - Keep `types` undefined to use whatever channels are configured on the alert config.
+ */
+function simulateSendAlert() {
     return __awaiter(this, void 0, void 0, function* () {
-        const es = yield merchant_events_1.ElasticSearchService.getInstance(undefined, '9kzbACQO05VTLsIGHRz2Ws9OlLt2');
-        es.executeQuery(podName_1.PodName.Campaign, 'broadcastSentCountByBroadcastId', {
-            broadcastIds: ['389961', '389804'],
-            storeId: '9kzbACQO05VTLsIGHRz2Ws9OlLt2',
-            indexName: 'events-prod-alias',
-        }).then((res) => {
-            console.log('ES Response:', JSON.stringify(res, null, 2));
+        const alertsV2Service = new alertsV2_service_1.AlertsV2Service();
+        // TODO: Replace these with real IDs from your env.
+        const res = yield alertsV2Service.sendAlert({
+            alertConfigId: 'PE294r6xtYgMzCVMgiEK',
+            storeId: 'p60HYv5wjgQaOrPdqT5NjbpkroD2',
+            sentBy: constants_1.POD_NAME.CAMPAIGN,
+            agentId: ['amankun77@gmail.com'],
+            variables: ['Hi', 'Sir', 'Aman', 'You have been conned', "https://google.co.in", "go to google.com"],
         });
+        console.log('sendAlert response:', JSON.stringify(res, null, 2));
     });
 }
-test().then().catch();

package/lib/core/setup.d.ts

@@ -12,6 +12,9 @@ export interface BikBackendOptions {
 export declare class BikBackendSetup {
     static options: BikBackendOptions;
     static useSharedFirebase?: boolean;
+    private static didLogPackageVersions;
+    private static readPackageVersion;
+    private static logPackageVersionsOnce;
     static fetchServiceName(): string | undefined;
     static fetchPodName(): PodName | undefined;
     static setUp(options: BikBackendOptions): void;

package/lib/core/setup.js

@@ -23,7 +23,27 @@ const auth_1 = require("../auth");
 const deprecated_1 = require("./decorators/deprecated");
 const refresh_pod_service_1 = require("../refresh/refresh-pod.service");
 const setup_1 = __importDefault(require("../logger/setup"));
+const local_1 = require("./local");
 class BikBackendSetup {
+    static readPackageVersion(requireIdOrPath) {
+        try {
+            const pkg = require(requireIdOrPath);
+            const version = pkg === null || pkg === void 0 ? void 0 : pkg.version;
+            return typeof version === 'string' ? version : undefined;
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+    static logPackageVersionsOnce() {
+        var _a, _b, _c, _d;
+        if (BikBackendSetup.didLogPackageVersions)
+            return;
+        BikBackendSetup.didLogPackageVersions = true;
+        const backendVersion = (_a = BikBackendSetup.readPackageVersion('../../package.json')) !== null && _a !== void 0 ? _a : 'unknown';
+        const bikModelsVersion = (_d = (_c = (_b = BikBackendSetup.readPackageVersion('@bikdotai/bik-models/package.json')) !== null && _b !== void 0 ? _b : BikBackendSetup.readPackageVersion('bik-models/package.json')) !== null && _c !== void 0 ? _c : BikBackendSetup.readPackageVersion(`${__dirname}/../../../bik-models/package.json`)) !== null && _d !== void 0 ? _d : 'unknown';
+        console.log(`[BikBackendSetup] versions: @bikdotai/bik-shared-backend=${backendVersion}, @bikdotai/bik-models=${bikModelsVersion}`);
+    }
     static fetchServiceName() {
         return auth_1.EnvVariableHelper.accessRaw('service_name');
     }
@@ -48,6 +68,7 @@ class BikBackendSetup {
             if (!options.serviceName) {
                 options.serviceName = this.fetchServiceName();
             }
+            BikBackendSetup.logPackageVersionsOnce();
             if (options.useSharedFirebase) {
                 BikBackendSetup.useSharedFirebase = options.useSharedFirebase;
                 (0, auth_1.initializeFirebaseConfig)(options.serviceAccountId);
@@ -64,16 +85,17 @@ class BikBackendSetup {
             // Hot-reload listener is now keyed by pod (was service). All services in
             // a pod share one `bik:refresh:{podName}` channel and one log-config secret.
             // Non-fatal if Redis is unavailable.
-            if (options.podName) {
+            if (options.podName && !(0, local_1.isLocal)()) {
                 refresh_pod_service_1.RefreshPodService.initialize(options.podName);
             }
             else {
-                console.warn('[BikBackendSetup] No podName provided; hot-reload listener not started.');
+                console.warn('[BikBackendSetup] No podName provided or running in local environment; hot-reload listener not started.');
             }
         });
     }
 }
 BikBackendSetup.useSharedFirebase = false;
+BikBackendSetup.didLogPackageVersions = false;
 __decorate([
     (0, deprecated_1.deprecated)('This method will be removed soon. Use setUpV2() instead.')
 ], BikBackendSetup, "setUp", null);

package/lib/database/database.model.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Types and Interfaces for Database Service
+ */
+import { Sequelize } from 'sequelize';
+import { Pool } from 'pg';
+/**
+ * PostgreSQL configuration interface
+ */
+export interface PgConfig {
+    username: string;
+    password: string;
+    host: string;
+    read?: Array<{
+        host: string;
+    }>;
+    database: string;
+    dialect: string;
+    schema: string;
+    port: number;
+}
+/**
+ * Options for creating a Sequelize connection
+ */
+export interface SequelizeConnectionOptions {
+    /** Maximum number of connections in the pool (default: 15) */
+    maxConnections?: number;
+    /** Minimum number of connections in the pool (default: 1) */
+    minConnections?: number;
+    /** Maximum time in milliseconds to acquire a connection (default: 60000) */
+    acquireTimeout?: number;
+    /** Maximum time in milliseconds for a connection to be idle before being released (default: 1000) */
+    idleTimeout?: number;
+    /** Maximum number of retry attempts for failed connections (default: 20) */
+    maxRetries?: number;
+    /** Initial backoff duration in milliseconds for retries (default: 500) */
+    backoffBase?: number;
+    /** Exponent to increase backoff duration on each retry (default: 1.2) */
+    backoffExponent?: number;
+    /** Enable SQL query logging (default: false) */
+    enableLogging?: boolean;
+    /** Override database schema from secret */
+    customSchema?: string;
+    /**
+     * Enable API metadata in SQL queries for tracking (default: true)
+     *
+     * When enabled, automatically sets PostgreSQL application_name to 'bik:{apiName}'
+     * for every query, making it visible in:
+     * - Aurora Performance Insights (group by application_name dimension)
+     * - pg_stat_activity (real-time query monitoring)
+     * - CloudWatch Logs (historical analysis)
+     *
+     * API name is extracted from LogExecutionContextHelper.getContext()?.apiName
+     * Format: 'bik:{apiName}' for write pools, 'bik:{apiName}:read' for reader pools
+     */
+    enableQueryMetadata?: boolean;
+}
+/**
+ * Options for creating a PostgreSQL Pool connection
+ */
+export interface PoolConnectionOptions {
+    /** Maximum number of connections in the pool (default: 15) */
+    maxConnections?: number;
+    /** Minimum number of connections in the pool (default: 0) */
+    minConnections?: number;
+    /** Connection idle timeout in milliseconds (default: 1000) */
+    idleTimeout?: number;
+}
+/**
+ * Result of creating all database connections
+ */
+export interface DatabaseConnections {
+    /** Sequelize ORM instance for complex queries and models */
+    sequelize: Sequelize;
+    /** PostgreSQL Pool for write operations */
+    pool: Pool;
+    /** PostgreSQL Pool for read operations (uses read replicas) */
+    readerPool: Pool;
+}
+/**
+ * Connections object for cleanup
+ */
+export interface ConnectionsToClose {
+    sequelize?: Sequelize;
+    pool?: Pool;
+    readerPool?: Pool;
+}
+/**
+ * Options passed to Sequelize beforeQuery hook
+ */
+export interface BeforeQueryOptions {
+    sql?: string;
+    bind?: any;
+    type?: string;
+    [key: string]: any;
+}

package/lib/database/database.model.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Types and Interfaces for Database Service
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/database/database.service.d.ts

@@ -0,0 +1,90 @@
+/**
+ * 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.
+ */
+import { Sequelize } from 'sequelize';
+import { Pool } from 'pg';
+import { SequelizeConnectionOptions, PoolConnectionOptions, DatabaseConnections, ConnectionsToClose } from './database.model';
+export declare const databaseSchema: string;
+export declare const ENABLE_SEQUELIZE_LOGGING: boolean;
+/**
+ * Service class for managing database connections
+ * Provides generic functions to create Sequelize and pg Pool connections
+ */
+export declare class DatabaseService {
+    private static pgConfigCache;
+    /**
+     * Get PostgreSQL configuration from secrets
+     * @param secretKeyName - Optional custom secret key name (defaults to 'aurora-common')
+     * @returns Promise<PgConfig>
+     */
+    private static getPgConfig;
+    /**
+     * Reset the cached config (useful for testing or when secrets change)
+     */
+    static resetConfigCache(): void;
+    /**
+     * 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?: SequelizeConnectionOptions, secretKeyName?: string): Promise<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?: PoolConnectionOptions, secretKeyName?: string): Promise<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?: PoolConnectionOptions, secretKeyName?: string): Promise<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?: SequelizeConnectionOptions & PoolConnectionOptions, secretKeyName?: string): Promise<DatabaseConnections>;
+    /**
+     * Test database connection
+     * @param sequelize - Sequelize instance to test
+     * @returns Promise<boolean>
+     */
+    static testConnection(sequelize: Sequelize): Promise<boolean>;
+    /**
+     * Gracefully close all connections
+     * @param connections - Object containing all connection instances
+     */
+    static closeConnections(connections: ConnectionsToClose): Promise<void>;
+}
+/**
+ * Get or create the default Sequelize instance (Singleton)
+ * @returns Promise<Sequelize>
+ */
+export declare const getDefaultSequelize: () => Promise<Sequelize>;
+/**
+ * Get or create the default Pool instance (Singleton)
+ * @returns Promise<Pool>
+ */
+export declare const getDefaultPool: () => Promise<Pool>;
+/**
+ * Get or create the default Reader Pool instance (Singleton)
+ * @returns Promise<Pool>
+ */
+export declare const getDefaultReaderPool: () => Promise<Pool>;
+/**
+ * Reset all singleton instances (useful for testing)
+ */
+export declare const resetDefaultConnections: () => void;
+export declare const BikSequelize: Promise<Sequelize>;
+export declare const pool: Promise<Pool>;
+export declare const readerPool: Promise<Pool>;