@adtrackify/at-service-common 3.1.27 → 3.1.28

package/dist/cjs/clients/generic/redis-client.js

@@ -1,129 +1,129 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedisClient = void 0;
-const ioredis_1 = __importDefault(require("ioredis"));
-const helpers_1 = require("../../helpers");
-class RedisClient {
-    poolSize;
-    pool;
-    host;
-    port;
-    constructor(host, port = 6379, poolSize = 3) {
-        this.poolSize = poolSize;
-        this.host = host;
-        this.port = port;
-        this.pool = Array.from({ length: poolSize }, () => this.createClient(host, port));
-    }
-    createClient(host, port) {
-        try {
-            const client = new ioredis_1.default({
-                host: host,
-                port: port,
-                maxRetriesPerRequest: 3,
-                commandTimeout: 3000,
-                lazyConnect: true,
-                keepAlive: 1000,
-            });
-            return client;
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error creating Redis client:', { err });
-            return null;
-        }
-    }
-    getClient() {
-        const randomIndex = Math.floor(Math.random() * this.poolSize);
-        let client = this.pool[randomIndex];
-        if (!client) {
-            client = this.createClient(this.host, this.port);
-        }
-        return client;
-    }
-    async connect(client) {
-        try {
-            await client.connect();
-            helpers_1.Logger.debug('Connected to Redis');
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error connecting to Redis:', { err });
-            return;
-        }
-    }
-    async safeSet(key, value, ttlInSeconds) {
-        try {
-            const client = this.getClient();
-            if (ttlInSeconds) {
-                await client.set(key, value, 'EX', ttlInSeconds);
-            }
-            else {
-                await client.set(key, value);
-            }
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error setting value in Redis:', { err, key, value });
-            return;
-        }
-    }
-    async unsafeSet(key, value, ttlInSeconds) {
-        const client = this.getClient();
-        if (ttlInSeconds) {
-            await client.set(key, value, 'EX', ttlInSeconds);
-        }
-        else {
-            await client.set(key, value);
-        }
-    }
-    async unsafeGet(key) {
-        const client = this.getClient();
-        helpers_1.Logger.debug('get', { key, client });
-        return await client.get(key);
-    }
-    async safeGet(key) {
-        try {
-            const client = this.getClient();
-            helpers_1.Logger.debug('get', { key, client });
-            return await client.get(key);
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error getting value from Redis:', { err, key });
-            return null;
-        }
-    }
-    async safeBatchGet(keys) {
-        try {
-            const client = this.getClient();
-            helpers_1.Logger.debug('get', { keys, client });
-            return await client.mget(keys);
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error getting batch from Redis:', { err, keys });
-            return null;
-        }
-    }
-    async del(key) {
-        try {
-            const client = this.getClient();
-            return await client.del(key);
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error deleting key from Redis:', { err });
-            return 0;
-        }
-    }
-    async disconnect() {
-        try {
-            const client = this.getClient();
-            await client.quit();
-            helpers_1.Logger.debug('Disconnected from Redis');
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error disconnecting from Redis:', { err });
-            return;
-        }
-    }
-}
-exports.RedisClient = RedisClient;
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisClient = void 0;
+const ioredis_1 = __importDefault(require("ioredis"));
+const helpers_1 = require("../../helpers");
+class RedisClient {
+    poolSize;
+    pool;
+    host;
+    port;
+    constructor(host, port = 6379, poolSize = 3) {
+        this.poolSize = poolSize;
+        this.host = host;
+        this.port = port;
+        this.pool = Array.from({ length: poolSize }, () => this.createClient(host, port));
+    }
+    createClient(host, port) {
+        try {
+            const client = new ioredis_1.default({
+                host: host,
+                port: port,
+                maxRetriesPerRequest: 3,
+                commandTimeout: 3000,
+                lazyConnect: true,
+                keepAlive: 1000,
+            });
+            return client;
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error creating Redis client:', { err });
+            return null;
+        }
+    }
+    getClient() {
+        const randomIndex = Math.floor(Math.random() * this.poolSize);
+        let client = this.pool[randomIndex];
+        if (!client) {
+            client = this.createClient(this.host, this.port);
+        }
+        return client;
+    }
+    async connect(client) {
+        try {
+            await client.connect();
+            helpers_1.Logger.debug('Connected to Redis');
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error connecting to Redis:', { err });
+            return;
+        }
+    }
+    async safeSet(key, value, ttlInSeconds) {
+        try {
+            const client = this.getClient();
+            if (ttlInSeconds) {
+                await client.set(key, value, 'EX', ttlInSeconds);
+            }
+            else {
+                await client.set(key, value);
+            }
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error setting value in Redis:', { err, key, value });
+            return;
+        }
+    }
+    async unsafeSet(key, value, ttlInSeconds) {
+        const client = this.getClient();
+        if (ttlInSeconds) {
+            await client.set(key, value, 'EX', ttlInSeconds);
+        }
+        else {
+            await client.set(key, value);
+        }
+    }
+    async unsafeGet(key) {
+        const client = this.getClient();
+        helpers_1.Logger.debug('get', { key, client });
+        return await client.get(key);
+    }
+    async safeGet(key) {
+        try {
+            const client = this.getClient();
+            helpers_1.Logger.debug('get', { key, client });
+            return await client.get(key);
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error getting value from Redis:', { err, key });
+            return null;
+        }
+    }
+    async safeBatchGet(keys) {
+        try {
+            const client = this.getClient();
+            helpers_1.Logger.debug('get', { keys, client });
+            return await client.mget(keys);
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error getting batch from Redis:', { err, keys });
+            return null;
+        }
+    }
+    async del(key) {
+        try {
+            const client = this.getClient();
+            return await client.del(key);
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error deleting key from Redis:', { err });
+            return 0;
+        }
+    }
+    async disconnect() {
+        try {
+            const client = this.getClient();
+            await client.quit();
+            helpers_1.Logger.debug('Disconnected from Redis');
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error disconnecting from Redis:', { err });
+            return;
+        }
+    }
+}
+exports.RedisClient = RedisClient;
 //# sourceMappingURL=redis-client.js.map

package/dist/cjs/clients/generic/s3-client.d.ts

@@ -1,16 +1,16 @@
-import { ObjectCannedACL, PutObjectCommandOutput, S3 } from '@aws-sdk/client-s3';
-export declare class S3Client {
-    s3: S3;
-    constructor(region?: string);
-    getObject(path: string, bucket: string): Promise<any>;
-    checkObjectExists(path: string, bucket: string): Promise<boolean>;
-    checkAndUploadJson(path: string, bucket: string, jsonData: any, ACL?: ObjectCannedACL, retryCount?: number, maxRetries?: number): Promise<{
-        status: boolean;
-        response?: PutObjectCommandOutput;
-    }>;
-    uploadJson(path: string, bucket: string, jsonData: any, ACL?: ObjectCannedACL, retryCount?: number, maxRetries?: number, stringify?: boolean): Promise<{
-        status: boolean;
-        response: PutObjectCommandOutput;
-    }>;
-    moveObject(bucket: string, key: string, moveToKey: string): Promise<any>;
-}
+import { ObjectCannedACL, PutObjectCommandOutput, S3 } from '@aws-sdk/client-s3';
+export declare class S3Client {
+    s3: S3;
+    constructor(region?: string);
+    getObject(path: string, bucket: string): Promise<any>;
+    checkObjectExists(path: string, bucket: string): Promise<boolean>;
+    checkAndUploadJson(path: string, bucket: string, jsonData: any, ACL?: ObjectCannedACL, retryCount?: number, maxRetries?: number): Promise<{
+        status: boolean;
+        response?: PutObjectCommandOutput;
+    }>;
+    uploadJson(path: string, bucket: string, jsonData: any, ACL?: ObjectCannedACL, retryCount?: number, maxRetries?: number, stringify?: boolean): Promise<{
+        status: boolean;
+        response: PutObjectCommandOutput;
+    }>;
+    moveObject(bucket: string, key: string, moveToKey: string): Promise<any>;
+}

package/dist/cjs/clients/generic/s3-client.js

@@ -1,111 +1,111 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.S3Client = void 0;
-const client_s3_1 = require("@aws-sdk/client-s3");
-const index_js_1 = require("../../index.js");
-class S3Client {
-    s3;
-    constructor(region = 'us-west-2') {
-        this.s3 = new client_s3_1.S3({ region });
-    }
-    async getObject(path, bucket) {
-        try {
-            const data = await this.s3.getObject({
-                Bucket: bucket,
-                Key: path
-            });
-            return data?.Body;
-        }
-        catch (error) {
-            index_js_1.Logger.error('Failed to getObject', { bucket, path });
-        }
-    }
-    async checkObjectExists(path, bucket) {
-        try {
-            const data = await this.s3.headObject({
-                Bucket: bucket,
-                Key: path,
-            });
-            const exists = data.$metadata.httpStatusCode === 200;
-            return exists;
-        }
-        catch (error) {
-            if (error.$metadata?.httpStatusCode === 404) {
-                return false;
-            }
-            else if (error.$metadata?.httpStatusCode === 403) {
-                return false;
-            }
-            else {
-                index_js_1.Logger.error('checkObjectExists unknown error', { error });
-                return false;
-            }
-        }
-    }
-    async checkAndUploadJson(path, bucket, jsonData, ACL = client_s3_1.ObjectCannedACL.private, retryCount = 0, maxRetries = 5) {
-        try {
-            const checkObject = await this.checkObjectExists(path, bucket);
-            let res = {};
-            if (!checkObject) {
-                res = await this.s3.putObject({
-                    ACL,
-                    Bucket: bucket,
-                    ContentType: 'application/json; charset=utf-8',
-                    Body: JSON.stringify(jsonData),
-                    Key: path
-                });
-            }
-            return { status: true, response: res };
-        }
-        catch (error) {
-            index_js_1.Logger.error('Error in s3 upload json', { error });
-            if (retryCount < maxRetries) {
-                retryCount++;
-                index_js_1.Logger.warn('retrying to uploadJson', { path, bucket, jsonData, ACL, retryCount });
-                await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
-                return await this.uploadJson(path, bucket, jsonData, ACL, retryCount);
-            }
-            return { status: false, response: jsonData };
-        }
-    }
-    async uploadJson(path, bucket, jsonData, ACL = client_s3_1.ObjectCannedACL.private, retryCount = 0, maxRetries = 5, stringify = true) {
-        try {
-            const res = await this.s3.putObject({
-                ACL,
-                Bucket: bucket,
-                ContentType: 'application/json; charset=utf-8',
-                Body: stringify ? JSON.stringify(jsonData) : jsonData,
-                Key: path
-            });
-            return { status: true, response: res };
-        }
-        catch (error) {
-            index_js_1.Logger.error('Error in s3 upload json', { error });
-            if (retryCount < maxRetries) {
-                retryCount++;
-                index_js_1.Logger.warn('retrying to uploadJson', { path, bucket, jsonData, ACL, retryCount });
-                await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
-                return await this.uploadJson(path, bucket, jsonData, ACL, retryCount);
-            }
-            return { status: false, response: jsonData };
-        }
-    }
-    async moveObject(bucket, key, moveToKey) {
-        try {
-            await this.s3.copyObject({
-                Bucket: bucket,
-                CopySource: `${bucket}/${key}`,
-                Key: moveToKey
-            });
-            await this.s3.deleteObject({
-                Bucket: bucket,
-                Key: key
-            });
-        }
-        catch (error) {
-            index_js_1.Logger.error('Failed to move s3 object', { error, bucket, key, moveToKey });
-        }
-    }
-}
-exports.S3Client = S3Client;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S3Client = void 0;
+const client_s3_1 = require("@aws-sdk/client-s3");
+const index_js_1 = require("../../index.js");
+class S3Client {
+    s3;
+    constructor(region = 'us-west-2') {
+        this.s3 = new client_s3_1.S3({ region });
+    }
+    async getObject(path, bucket) {
+        try {
+            const data = await this.s3.getObject({
+                Bucket: bucket,
+                Key: path
+            });
+            return data?.Body;
+        }
+        catch (error) {
+            index_js_1.Logger.error('Failed to getObject', { bucket, path });
+        }
+    }
+    async checkObjectExists(path, bucket) {
+        try {
+            const data = await this.s3.headObject({
+                Bucket: bucket,
+                Key: path,
+            });
+            const exists = data.$metadata.httpStatusCode === 200;
+            return exists;
+        }
+        catch (error) {
+            if (error.$metadata?.httpStatusCode === 404) {
+                return false;
+            }
+            else if (error.$metadata?.httpStatusCode === 403) {
+                return false;
+            }
+            else {
+                index_js_1.Logger.error('checkObjectExists unknown error', { error });
+                return false;
+            }
+        }
+    }
+    async checkAndUploadJson(path, bucket, jsonData, ACL = client_s3_1.ObjectCannedACL.private, retryCount = 0, maxRetries = 5) {
+        try {
+            const checkObject = await this.checkObjectExists(path, bucket);
+            let res = {};
+            if (!checkObject) {
+                res = await this.s3.putObject({
+                    ACL,
+                    Bucket: bucket,
+                    ContentType: 'application/json; charset=utf-8',
+                    Body: JSON.stringify(jsonData),
+                    Key: path
+                });
+            }
+            return { status: true, response: res };
+        }
+        catch (error) {
+            index_js_1.Logger.error('Error in s3 upload json', { error });
+            if (retryCount < maxRetries) {
+                retryCount++;
+                index_js_1.Logger.warn('retrying to uploadJson', { path, bucket, jsonData, ACL, retryCount });
+                await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
+                return await this.uploadJson(path, bucket, jsonData, ACL, retryCount);
+            }
+            return { status: false, response: jsonData };
+        }
+    }
+    async uploadJson(path, bucket, jsonData, ACL = client_s3_1.ObjectCannedACL.private, retryCount = 0, maxRetries = 5, stringify = true) {
+        try {
+            const res = await this.s3.putObject({
+                ACL,
+                Bucket: bucket,
+                ContentType: 'application/json; charset=utf-8',
+                Body: stringify ? JSON.stringify(jsonData) : jsonData,
+                Key: path
+            });
+            return { status: true, response: res };
+        }
+        catch (error) {
+            index_js_1.Logger.error('Error in s3 upload json', { error });
+            if (retryCount < maxRetries) {
+                retryCount++;
+                index_js_1.Logger.warn('retrying to uploadJson', { path, bucket, jsonData, ACL, retryCount });
+                await new Promise(resolve => setTimeout(resolve, 1000 * retryCount));
+                return await this.uploadJson(path, bucket, jsonData, ACL, retryCount);
+            }
+            return { status: false, response: jsonData };
+        }
+    }
+    async moveObject(bucket, key, moveToKey) {
+        try {
+            await this.s3.copyObject({
+                Bucket: bucket,
+                CopySource: `${bucket}/${key}`,
+                Key: moveToKey
+            });
+            await this.s3.deleteObject({
+                Bucket: bucket,
+                Key: key
+            });
+        }
+        catch (error) {
+            index_js_1.Logger.error('Failed to move s3 object', { error, bucket, key, moveToKey });
+        }
+    }
+}
+exports.S3Client = S3Client;
 //# sourceMappingURL=s3-client.js.map

package/dist/cjs/clients/generic/singlestore-db-client.d.ts

@@ -1,14 +1,14 @@
-import * as mysql from 'mysql2/promise';
-export declare class SingleStoreDBClient {
-    _pool: mysql.Pool;
-    constructor(host: string, user: string, password: string, database: string, port: string);
-    private getPool;
-    private getConnection;
-    executeQuery(query: string, values?: any): Promise<{
-        rows: mysql.QueryResult;
-        success: boolean;
-    } | {
-        success: boolean;
-        rows?: undefined;
-    }>;
-}
+import * as mysql from 'mysql2/promise';
+export declare class SingleStoreDBClient {
+    _pool: mysql.Pool;
+    constructor(host: string, user: string, password: string, database: string, port: string);
+    private getPool;
+    private getConnection;
+    executeQuery(query: string, values?: any): Promise<{
+        rows: mysql.QueryResult;
+        success: boolean;
+    } | {
+        success: boolean;
+        rows?: undefined;
+    }>;
+}