sspart-be-lib 2.0.0

package/README.md

@@ -0,0 +1,14 @@
+# sspart-be-lib
+
+A small, focused backend utility library providing database connection helpers
+and lightweight base models for ClickHouse (using `@clickhouse/client`), PostgreSQL (using `pg`) and MongoDB (using`mongoose`), plus a helper to create a Knex client. This library is intended
+for internal use at SSPART Enterprises (sspart) and provides convenient
+abstractions for common data access patterns.
+
+**Package**
+- **Name:** sspart-be-lib
+- **Version:** 2.0.0
+- **Description:** Backend library for database helpers and base models.
+
+**License**
+- ISC

package/dist/common/clickhouse.service.d.ts

@@ -0,0 +1,3 @@
+import { ClickHouseClient } from '@clickhouse/client';
+export declare const connectClickHouse: () => ClickHouseClient;
+export declare const closeClickHouse: () => Promise<void>;

package/dist/common/clickhouse.service.js

@@ -0,0 +1,41 @@
+"use strict";
+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.closeClickHouse = exports.connectClickHouse = void 0;
+const client_1 = require("@clickhouse/client");
+let client = null;
+const CLICKHOUSE_URL = process.env.CLICKHOUSE_URL || 'http://localhost:8123';
+const CLICKHOUSE_USER = process.env.CLICKHOUSE_USER || 'default';
+const CLICKHOUSE_PASSWORD = process.env.CLICKHOUSE_PASSWORD || '';
+const CLICKHOUSE_DATABASE = process.env.CLICKHOUSE_DATABASE || 'default';
+const connectClickHouse = () => {
+    if (client)
+        return client;
+    try {
+        client = (0, client_1.createClient)({ host: CLICKHOUSE_URL, username: CLICKHOUSE_USER,
+            password: CLICKHOUSE_PASSWORD, database: CLICKHOUSE_DATABASE });
+        console.log(`✅ ClickHouse connected successfully: ${CLICKHOUSE_URL}`);
+        return client;
+    }
+    catch (error) {
+        console.error(`❌ ClickHouse connection failed: ${error.message}`);
+        throw error;
+    }
+};
+exports.connectClickHouse = connectClickHouse;
+const closeClickHouse = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (client) {
+        yield client.close();
+        console.log('🔌 ClickHouse connection closed');
+        client = null;
+    }
+});
+exports.closeClickHouse = closeClickHouse;

package/dist/common/knex.service.d.ts

@@ -0,0 +1,2 @@
+import knex from 'knex';
+export declare const createKnexClient: (config: any) => knex.Knex<any, unknown[]>;

package/dist/common/knex.service.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKnexClient = void 0;
+const knex_1 = __importDefault(require("knex"));
+const createKnexClient = (config) => {
+    return (0, knex_1.default)({
+        client: 'pg',
+        connection: config,
+        pool: { min: 1, max: 10 }
+    });
+};
+exports.createKnexClient = createKnexClient;

package/dist/common/mongo.service.d.ts

@@ -0,0 +1,3 @@
+import mongoose from 'mongoose';
+export declare const connectMongo: () => Promise<typeof mongoose>;
+export declare const closeMongo: () => Promise<void>;

package/dist/common/mongo.service.js

@@ -0,0 +1,42 @@
+"use strict";
+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());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.closeMongo = exports.connectMongo = void 0;
+const mongoose_1 = __importDefault(require("mongoose"));
+let isConnected = false;
+const uri = process.env.MONGO_URI || 'mongodb://localhost:27017/test';
+const connectMongo = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (isConnected)
+        return mongoose_1.default;
+    try {
+        mongoose_1.default.set('strictQuery', false);
+        yield mongoose_1.default.connect(uri);
+        isConnected = true;
+        console.log(`✅ MongoDB connected successfully: ${uri}`);
+    }
+    catch (error) {
+        console.error(`❌ MongoDB connection failed: ${error.message}`);
+        throw error;
+    }
+    return mongoose_1.default;
+});
+exports.connectMongo = connectMongo;
+const closeMongo = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (isConnected) {
+        yield mongoose_1.default.disconnect();
+        console.log('🔌 MongoDB connection closed');
+        isConnected = false;
+    }
+});
+exports.closeMongo = closeMongo;

package/dist/common/postgres.service.d.ts

@@ -0,0 +1,4 @@
+import { Pool } from 'pg';
+export declare const connectPostgres: () => Promise<Pool>;
+export declare const getPool: () => Pool;
+export declare const closePostgres: () => Promise<void>;

package/dist/common/postgres.service.js

@@ -0,0 +1,54 @@
+"use strict";
+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.closePostgres = exports.getPool = exports.connectPostgres = void 0;
+const pg_1 = require("pg");
+const dbConfig = {
+    host: process.env.PG_HOST || 'localhost',
+    user: process.env.PG_USER || 'postgres',
+    password: process.env.PG_PASSWORD || '',
+    database: process.env.PG_DATABASE || 'test',
+    port: Number(process.env.PG_PORT) || 5432,
+    max: 10,
+    idleTimeoutMillis: 30000,
+};
+let pool = null;
+const connectPostgres = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (pool)
+        return pool;
+    try {
+        pool = new pg_1.Pool(dbConfig);
+        const client = yield pool.connect();
+        yield client.query('SELECT 1');
+        client.release();
+        console.log(`✅ PostgreSQL connected successfully: ${dbConfig.database}`);
+    }
+    catch (error) {
+        console.error(`❌ PostgreSQL connection failed: ${error.message}`);
+        throw error;
+    }
+    return pool;
+});
+exports.connectPostgres = connectPostgres;
+const getPool = () => {
+    if (!pool)
+        throw new Error('PostgreSQL not connected yet. Call connectWithRetry() first.');
+    return pool;
+};
+exports.getPool = getPool;
+const closePostgres = () => __awaiter(void 0, void 0, void 0, function* () {
+    if (pool) {
+        yield pool.end();
+        console.log('🔌 PostgreSQL pool closed');
+        pool = null;
+    }
+});
+exports.closePostgres = closePostgres;

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+export { PostgresSQLBaseModel } from './models/postgresql.base.model';
+export { connectPostgres, closePostgres } from './common/postgres.service';
+export { MongoBaseModel } from './models/mongo.base.model';
+export { connectMongo, closeMongo } from './common/mongo.service';
+export { ClickHouseBaseModel } from './models/clickhouse.base.model';
+export { connectClickHouse, closeClickHouse } from './common/clickhouse.service';
+export { createKnexClient } from './common/knex.service';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKnexClient = exports.closeClickHouse = exports.connectClickHouse = exports.ClickHouseBaseModel = exports.closeMongo = exports.connectMongo = exports.MongoBaseModel = exports.closePostgres = exports.connectPostgres = exports.PostgresSQLBaseModel = void 0;
+var postgresql_base_model_1 = require("./models/postgresql.base.model");
+Object.defineProperty(exports, "PostgresSQLBaseModel", { enumerable: true, get: function () { return postgresql_base_model_1.PostgresSQLBaseModel; } });
+var postgres_service_1 = require("./common/postgres.service");
+Object.defineProperty(exports, "connectPostgres", { enumerable: true, get: function () { return postgres_service_1.connectPostgres; } });
+Object.defineProperty(exports, "closePostgres", { enumerable: true, get: function () { return postgres_service_1.closePostgres; } });
+var mongo_base_model_1 = require("./models/mongo.base.model");
+Object.defineProperty(exports, "MongoBaseModel", { enumerable: true, get: function () { return mongo_base_model_1.MongoBaseModel; } });
+var mongo_service_1 = require("./common/mongo.service");
+Object.defineProperty(exports, "connectMongo", { enumerable: true, get: function () { return mongo_service_1.connectMongo; } });
+Object.defineProperty(exports, "closeMongo", { enumerable: true, get: function () { return mongo_service_1.closeMongo; } });
+var clickhouse_base_model_1 = require("./models/clickhouse.base.model");
+Object.defineProperty(exports, "ClickHouseBaseModel", { enumerable: true, get: function () { return clickhouse_base_model_1.ClickHouseBaseModel; } });
+var clickhouse_service_1 = require("./common/clickhouse.service");
+Object.defineProperty(exports, "connectClickHouse", { enumerable: true, get: function () { return clickhouse_service_1.connectClickHouse; } });
+Object.defineProperty(exports, "closeClickHouse", { enumerable: true, get: function () { return clickhouse_service_1.closeClickHouse; } });
+var knex_service_1 = require("./common/knex.service");
+Object.defineProperty(exports, "createKnexClient", { enumerable: true, get: function () { return knex_service_1.createKnexClient; } });

package/dist/models/clickhouse.base.model.d.ts

@@ -0,0 +1,16 @@
+import { ClickHouseClient } from '@clickhouse/client';
+export declare abstract class ClickHouseBaseModel<T> {
+    protected client: ClickHouseClient;
+    protected tableName: string;
+    protected hasSoftDelete: boolean;
+    constructor(client: ClickHouseClient, tableName: string, hasSoftDelete?: boolean);
+    protected handleError(method: string, error: Error, ...args: any[]): void;
+    protected abstract createTableSQL(): string;
+    protected schemaMigrations(): string[];
+    createOrUpdateTable(): Promise<boolean>;
+    protected tableExists(): Promise<boolean>;
+    insertMany(data: T[]): Promise<boolean>;
+    findByTimeRange(columns: string, where: string, from: string, to: string, timeColumn?: string): Promise<T[] | []>;
+    softDelete(where: string): Promise<boolean>;
+    protected applySoftDelete(where: string): string;
+}

package/dist/models/clickhouse.base.model.js

@@ -0,0 +1,132 @@
+"use strict";
+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.ClickHouseBaseModel = void 0;
+class ClickHouseBaseModel {
+    constructor(client, tableName, hasSoftDelete = false) {
+        this.client = client;
+        this.tableName = tableName;
+        this.hasSoftDelete = hasSoftDelete;
+    }
+    handleError(method, error, ...args) {
+        console.error(`ClickHouse :: ${this.tableName} :: ${method} :: Error :: ${error.message}`, ...args);
+    }
+    schemaMigrations() {
+        return [];
+    }
+    createOrUpdateTable() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const exists = yield this.tableExists();
+                if (!exists) {
+                    yield this.client.exec({ query: this.createTableSQL() });
+                    console.log(`✅ Created table: ${this.tableName}`);
+                }
+                else {
+                    for (const sql of this.schemaMigrations()) {
+                        yield this.client.exec({ query: sql });
+                    }
+                    if (this.schemaMigrations().length) {
+                        console.log(`🔁 Updated schema: ${this.tableName}`);
+                    }
+                }
+                return true;
+            }
+            catch (error) {
+                console.error(`❌ ClickHouse :: ${this.tableName} :: createOrUpdateTable`, error.message);
+                return false;
+            }
+        });
+    }
+    tableExists() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const result = yield this.client.query({
+                query: `
+                SELECT count() AS cnt
+                FROM system.tables
+                WHERE database = currentDatabase()
+                AND name = '${this.tableName}'
+            `,
+                format: 'JSONEachRow',
+            });
+            const rows = yield result.json();
+            return ((_a = rows[0]) === null || _a === void 0 ? void 0 : _a.cnt) > 0;
+        });
+    }
+    insertMany(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!data.length)
+                return true;
+            try {
+                yield this.client.insert({
+                    table: this.tableName,
+                    values: data,
+                    format: 'JSONEachRow',
+                });
+                return true;
+            }
+            catch (error) {
+                this.handleError('insertMany', error, data);
+                return false;
+            }
+        });
+    }
+    findByTimeRange(columns_1, where_1, from_1, to_1) {
+        return __awaiter(this, arguments, void 0, function* (columns, where, from, to, timeColumn = 'ts') {
+            try {
+                const query = `
+                SELECT ${columns}
+                FROM ${this.tableName}
+                WHERE ${this.applySoftDelete(where)}
+                  AND ${timeColumn} BETWEEN toDateTime('${from}')
+                                     AND toDateTime('${to}')
+                ORDER BY ${timeColumn}
+            `;
+                const result = yield this.client.query({
+                    query, format: 'JSONEachRow'
+                });
+                return yield result.json();
+            }
+            catch (error) {
+                this.handleError('findByTimeRange', error, where, from, to);
+                return [];
+            }
+        });
+    }
+    softDelete(where) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.hasSoftDelete) {
+                throw new Error(`Soft delete not enabled for table ${this.tableName}`);
+            }
+            try {
+                yield this.client.exec({
+                    query: `
+                    ALTER TABLE ${this.tableName}
+                    UPDATE is_deleted = 1
+                    WHERE ${where}
+                `,
+                });
+                return true;
+            }
+            catch (error) {
+                this.handleError('softDelete', error, where);
+                return false;
+            }
+        });
+    }
+    applySoftDelete(where) {
+        return this.hasSoftDelete
+            ? `(${where}) AND is_deleted = 0`
+            : where;
+    }
+}
+exports.ClickHouseBaseModel = ClickHouseBaseModel;

package/dist/models/mongo.base.model.d.ts

@@ -0,0 +1,24 @@
+import { Model, Document, AnyBulkWriteOperation, IndexDefinition } from 'mongoose';
+export declare abstract class MongoBaseModel<T extends Document> {
+    protected model: Model<T>;
+    protected modelName: string;
+    constructor(model: Model<T>, modelName: string);
+    protected handleError(method: string, error: Error, ...args: any[]): void;
+    insertOne(data: Partial<T>): Promise<T | false>;
+    insertMany(data: Partial<T>[]): Promise<any[]>;
+    find(query: object): Promise<T[]>;
+    findLean(query: object): Promise<any[]>;
+    findOne(query: object): Promise<T | null>;
+    findOneLean(query: object): Promise<any | null>;
+    findOneAndUpdate(query: object, data: object): Promise<T | null>;
+    updateOne(query: object, data: object): Promise<any>;
+    updateMany(query: object, data: object): Promise<any>;
+    deleteOne(query: object): Promise<any>;
+    deleteMany(query: object): Promise<any>;
+    count(query: object): Promise<number>;
+    bulkWrite(operations: AnyBulkWriteOperation<any>[]): Promise<any>;
+    createIndex(name: string, index: IndexDefinition): Promise<boolean>;
+    getIndexes(): Promise<any>;
+    dropIndex(name: string): Promise<any>;
+    dropIndexes(): Promise<boolean>;
+}

package/dist/models/mongo.base.model.js

@@ -0,0 +1,212 @@
+"use strict";
+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.MongoBaseModel = void 0;
+class MongoBaseModel {
+    constructor(model, modelName) {
+        this.model = model;
+        this.modelName = modelName;
+    }
+    handleError(method, error, ...args) {
+        console.error(`${this.modelName} :: ${method} :: Error :: ${error.message}`, ...args);
+    }
+    insertOne(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.create(data);
+            }
+            catch (error) {
+                this.handleError('insertOne', error, data);
+                return false;
+            }
+        });
+    }
+    insertMany(data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.insertMany(data);
+            }
+            catch (error) {
+                this.handleError('insertMany', error, data);
+                return [];
+            }
+        });
+    }
+    find(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.find(query);
+            }
+            catch (error) {
+                this.handleError('find', error, query);
+                return [];
+            }
+        });
+    }
+    findLean(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.find(query).lean().exec();
+            }
+            catch (error) {
+                this.handleError('findLean', error, query);
+                return [];
+            }
+        });
+    }
+    findOne(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.findOne(query);
+            }
+            catch (error) {
+                this.handleError('findOne', error, query);
+                return null;
+            }
+        });
+    }
+    findOneLean(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.findOne(query).lean().exec();
+            }
+            catch (error) {
+                this.handleError('findOneLean', error, query);
+                return null;
+            }
+        });
+    }
+    findOneAndUpdate(query, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.findOneAndUpdate(query, data, { new: true });
+            }
+            catch (error) {
+                this.handleError('findOneAndUpdate', error, query, data);
+                return null;
+            }
+        });
+    }
+    updateOne(query, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.updateOne(query, data);
+            }
+            catch (error) {
+                this.handleError('updateOne', error, query, data);
+                return false;
+            }
+        });
+    }
+    updateMany(query, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.updateMany(query, data);
+            }
+            catch (error) {
+                this.handleError('updateMany', error, query, data);
+                return false;
+            }
+        });
+    }
+    deleteOne(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.deleteOne(query);
+            }
+            catch (error) {
+                this.handleError('deleteOne', error, query);
+                return false;
+            }
+        });
+    }
+    deleteMany(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.deleteMany(query);
+            }
+            catch (error) {
+                this.handleError('deleteMany', error, query);
+                return false;
+            }
+        });
+    }
+    count(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.countDocuments(query);
+            }
+            catch (error) {
+                this.handleError('count', error, query);
+                return 0;
+            }
+        });
+    }
+    bulkWrite(operations) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.bulkWrite(operations);
+            }
+            catch (error) {
+                this.handleError('bulkWrite', error, operations);
+                return false;
+            }
+        });
+    }
+    createIndex(name, index) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.model.schema.index(index, { name });
+                yield this.model.createIndexes();
+                return true;
+            }
+            catch (error) {
+                this.handleError('createIndex', error, index);
+                return false;
+            }
+        });
+    }
+    getIndexes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return this.model.collection.getIndexes();
+            }
+            catch (error) {
+                this.handleError('getIndexes', error);
+                return false;
+            }
+        });
+    }
+    dropIndex(name) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.model.collection.dropIndex(name);
+            }
+            catch (error) {
+                this.handleError('dropIndex', error, name);
+                return false;
+            }
+        });
+    }
+    dropIndexes() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                yield this.model.collection.dropIndexes();
+                return true;
+            }
+            catch (error) {
+                this.handleError('dropIndexes', error);
+                return false;
+            }
+        });
+    }
+}
+exports.MongoBaseModel = MongoBaseModel;

package/dist/models/postgresql.base.model.d.ts

@@ -0,0 +1,14 @@
+import { QueryResult, QueryResultRow } from 'pg';
+export declare abstract class PostgresSQLBaseModel<T extends object> {
+    protected tableName: string;
+    constructor(tableName: string);
+    protected query<R extends QueryResultRow = any>(sql: string, params?: any[]): Promise<QueryResult<R>>;
+    sendQuery<R extends QueryResultRow = any>(sql: string, params?: any[]): Promise<R[]>;
+    insertOne(data: Partial<T>, projection?: string): Promise<T | null>;
+    insertMany(data: Partial<T>[], projection?: string): Promise<T[]>;
+    find(query?: Partial<T>, columns?: string): Promise<T[]>;
+    count(query?: Partial<T>): Promise<number>;
+    update(query: Partial<T>, data: Partial<T>, projection?: string): Promise<T[]>;
+    delete(query: Partial<T>): Promise<number>;
+    deleteByQuery(query: string): Promise<number>;
+}

package/dist/models/postgresql.base.model.js

@@ -0,0 +1,171 @@
+"use strict";
+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.PostgresSQLBaseModel = void 0;
+const postgres_service_1 = require("../common/postgres.service");
+class PostgresSQLBaseModel {
+    constructor(tableName) {
+        this.tableName = tableName;
+    }
+    query(sql_1) {
+        return __awaiter(this, arguments, void 0, function* (sql, params = []) {
+            const pool = (0, postgres_service_1.getPool)();
+            const client = yield pool.connect();
+            try {
+                return yield client.query(sql, params);
+            }
+            catch (error) {
+                console.error(`${this.tableName} :: Query Failed ::`, error.message, sql, params);
+                return { rows: [], rowCount: 0, command: 'ERROR',
+                    oid: 0, fields: [] };
+            }
+            finally {
+                client.release();
+            }
+        });
+    }
+    sendQuery(sql_1) {
+        return __awaiter(this, arguments, void 0, function* (sql, params = []) {
+            const result = yield this.query(sql, params);
+            return result.rows;
+        });
+    }
+    insertOne(data_1) {
+        return __awaiter(this, arguments, void 0, function* (data, projection = '*') {
+            const keys = [];
+            const values = [];
+            for (const [key, value] of Object.entries(data)) {
+                keys.push(key);
+                values.push(value);
+            }
+            const placeholders = keys.map((_, i) => `$${i + 1}`).join(', ');
+            const sql = `INSERT INTO ${this.tableName} (${keys.join(', ')})
+                    VALUES (${placeholders}) RETURNING ${projection}`;
+            const result = yield this.query(sql, values);
+            return result.rows[0] || null;
+        });
+    }
+    insertMany(data_1) {
+        return __awaiter(this, arguments, void 0, function* (data, projection = '*') {
+            if (!data.length)
+                return [];
+            const keys = Object.keys(data[0]);
+            const len = data.length;
+            const keyLen = keys.length;
+            const values = new Array(len * keyLen);
+            const columns = keys.map(k => `"${k}"`).join(', ');
+            const placeholderParts = new Array(len);
+            let paramIndex = 1;
+            let valueIndex = 0;
+            for (let i = 0; i < len; i++) {
+                const row = data[i];
+                const rowParts = new Array(keyLen);
+                for (let j = 0; j < keyLen; j++) {
+                    const val = row[keys[j]];
+                    values[valueIndex++] = val;
+                    rowParts[j] = `$${paramIndex++}`;
+                }
+                placeholderParts[i] = `(${rowParts.join(',')})`;
+            }
+            const sql = `INSERT INTO ${this.tableName} (${columns}) VALUES ${placeholderParts.join(', ')} RETURNING ${projection};`;
+            const res = yield this.query(sql, values);
+            return res.rows;
+        });
+    }
+    find() {
+        return __awaiter(this, arguments, void 0, function* (query = {}, columns = '*') {
+            const values = [];
+            const whereParts = [];
+            const entries = Object.entries(query);
+            for (let i = 0; i < entries.length; i++) {
+                const [key, val] = entries[i];
+                whereParts.push(`"${key}" = $${i + 1}`);
+                values.push(val);
+            }
+            const sql = `SELECT ${columns} FROM ${this.tableName}` +
+                (whereParts.length ? ' WHERE ' + whereParts.join(' AND ') : '');
+            const result = yield this.query(sql, values);
+            return result.rows;
+        });
+    }
+    count() {
+        return __awaiter(this, arguments, void 0, function* (query = {}) {
+            var _a;
+            const values = [];
+            const whereParts = [];
+            const entries = Object.entries(query);
+            for (let i = 0; i < entries.length; i++) {
+                const [key, val] = entries[i];
+                whereParts.push(`"${key}" = $${i + 1}`);
+                values.push(val);
+            }
+            const sql = `SELECT COUNT(*) AS count FROM ${this.tableName}` +
+                (whereParts.length ? ' WHERE ' + whereParts.join(' AND ') : '');
+            const result = yield this.query(sql, values);
+            return parseInt(((_a = result.rows[0]) === null || _a === void 0 ? void 0 : _a.count) || '0', 10);
+        });
+    }
+    update(query_1, data_1) {
+        return __awaiter(this, arguments, void 0, function* (query, data, projection = '*') {
+            const dataKeys = Object.keys(data);
+            const queryKeys = Object.keys(query);
+            const setLen = dataKeys.length;
+            const whereLen = queryKeys.length;
+            if (setLen === 0)
+                return [];
+            const values = new Array(setLen + whereLen);
+            const setParts = new Array(setLen);
+            const whereParts = whereLen > 0 ? new Array(whereLen) : [];
+            for (let i = 0; i < setLen; i++) {
+                const key = dataKeys[i];
+                setParts[i] = `"${key}" = $${i + 1}`;
+                values[i] = data[key];
+            }
+            const setClause = setParts.join(',');
+            if (whereLen > 0) {
+                for (let i = 0; i < whereLen; i++) {
+                    const key = queryKeys[i];
+                    whereParts[i] = `"${key}" = $${setLen + i + 1}`;
+                    values[setLen + i] = query[key];
+                }
+            }
+            const whereClause = whereLen > 0 ? ' WHERE ' + whereParts.join(' AND ') : '';
+            const sql = `UPDATE ${this.tableName} SET ${setClause}${whereClause} RETURNING ${projection};`;
+            const result = yield this.query(sql, values);
+            return result.rows;
+        });
+    }
+    delete(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const values = [];
+            const whereParts = [];
+            const entries = Object.entries(query);
+            for (let i = 0; i < entries.length; i++) {
+                const [key, val] = entries[i];
+                whereParts.push(`"${key}" = $${i + 1}`);
+                values.push(val);
+            }
+            const sql = `DELETE FROM ${this.tableName}` +
+                (whereParts.length ? ' WHERE ' + whereParts.join(' AND ') : '');
+            const result = yield this.query(sql, values);
+            return result.rowCount || 0;
+        });
+    }
+    deleteByQuery(query) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const values = [];
+            const sql = `DELETE FROM ${this.tableName} WHERE ${query}`;
+            const result = yield this.query(sql, values);
+            return result.rowCount || 0;
+        });
+    }
+}
+exports.PostgresSQLBaseModel = PostgresSQLBaseModel;

package/package.json

@@ -0,0 +1,38 @@
+{
+    "name": "sspart-be-lib",
+    "version": "2.0.0",
+    "description": "This is a backend library designed for sspart enterprises private limited.",
+    "type": "commonjs",
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsc"
+    },
+    "main": "dist/index.js",
+    "dependencies": {
+        "@clickhouse/client": "^1.17.0",
+        "@types/pg": "^8.15.6",
+        "knex": "^3.1.0",
+        "mongoose": "^8.19.2",
+        "pg": "^8.16.3"
+    },
+    "devDependencies": {
+        "typescript": "^5.7.2"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://sspartorg@bitbucket.org/sspartorg/sspart-be-lib.git"
+    },
+    "keywords": [
+        "Backend",
+        "library"
+    ],
+    "author": "Ram",
+    "license": "ISC",
+    "bugs": {
+        "url": "https://bitbucket.org/sspartorg/sspart-be-lib/issues"
+    },
+    "homepage": "https://bitbucket.org/sspartorg/sspart-be-lib#readme"
+}