sspart-common-lib 0.0.2

package/dist/common/common.d.ts

@@ -0,0 +1,8 @@
+export declare const sleep: (ms: number) => Promise<void>;
+export declare const isValidUsername: (username: string) => boolean;
+export declare const validateStringIsValidEmail: (email: string) => boolean;
+export declare const validateStringIsValidNumber: (num: string) => boolean;
+export declare const genRandomString: (len: number) => string;
+export declare const genRandomNumber: (len: number) => string;
+export declare const format: (str: string, ...args: (string | number)[]) => string;
+export declare const createUUID: () => string;

package/dist/common/common.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createUUID = exports.format = exports.genRandomNumber = exports.genRandomString = exports.validateStringIsValidNumber = exports.validateStringIsValidEmail = exports.isValidUsername = exports.sleep = void 0;
+const crypto_1 = require("crypto");
+const emailRegex = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;
+const usernameRegex = /^(?=.*[a-zA-Z])[a-zA-Z0-9]+$/;
+const formatRegex = /{(\d+)}/g;
+const charset = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+const charsetLen = charset.length;
+const numset = "0123456789";
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+exports.sleep = sleep;
+const isValidUsername = (username) => usernameRegex.test(username);
+exports.isValidUsername = isValidUsername;
+const validateStringIsValidEmail = (email) => emailRegex.test(email);
+exports.validateStringIsValidEmail = validateStringIsValidEmail;
+const validateStringIsValidNumber = (num) => {
+    if (num.length !== 10)
+        return false;
+    for (let i = 0; i < 10; i++) {
+        const code = num.charCodeAt(i);
+        if (code < 48 || code > 57)
+            return false;
+    }
+    return true;
+};
+exports.validateStringIsValidNumber = validateStringIsValidNumber;
+const genRandomString = (len) => {
+    const bytes = (0, crypto_1.randomBytes)(len);
+    let result = "";
+    for (let i = 0; i < len; i++) {
+        result += charset[bytes[i] % charsetLen];
+    }
+    return result;
+};
+exports.genRandomString = genRandomString;
+const genRandomNumber = (len) => {
+    const arr = new Uint8Array(len);
+    crypto_1.webcrypto.getRandomValues(arr);
+    let res = "";
+    for (let i = 0; i < len; i++) {
+        res += numset[arr[i] % 10];
+    }
+    return res;
+};
+exports.genRandomNumber = genRandomNumber;
+const format = (str, ...args) => str.replace(formatRegex, (_, idx) => { var _a; return ((_a = args[idx]) !== null && _a !== void 0 ? _a : `{${idx}}`) + ""; });
+exports.format = format;
+const createUUID = () => (0, crypto_1.randomUUID)();
+exports.createUUID = createUUID;

package/dist/common/cookies.d.ts

@@ -0,0 +1 @@
+export declare const getCookies: (cookieText: string) => Record<string, string>;

package/dist/common/cookies.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCookies = void 0;
+const getCookies = (cookieText) => {
+    if (typeof cookieText !== "string" || !cookieText)
+        return {};
+    const cookies = {};
+    const parts = cookieText.split(";");
+    for (let i = 0, len = parts.length; i < len; i++) {
+        const eqIdx = parts[i].indexOf("=");
+        if (eqIdx === -1)
+            continue;
+        const name = parts[i].slice(0, eqIdx).trim();
+        if (!name)
+            continue;
+        const value = parts[i].slice(eqIdx + 1).trim();
+        try {
+            cookies[name] = decodeURIComponent(value);
+        }
+        catch (_a) {
+            cookies[name] = value;
+        }
+    }
+    return cookies;
+};
+exports.getCookies = getCookies;

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,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createKnexClient = void 0;
+const knex_1 = 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/password.service.d.ts

@@ -0,0 +1,2 @@
+export declare const generateHashedPassword: (myPlaintextPassword: string) => Promise<string>;
+export declare const validateHashedPassword: (plainTextPassword: string, hashedPasword: string) => Promise<boolean>;

package/dist/common/password.service.js

@@ -0,0 +1,23 @@
+"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.validateHashedPassword = exports.generateHashedPassword = void 0;
+const bcrypt_1 = require("bcrypt");
+const saltRounds = 10;
+const generateHashedPassword = (myPlaintextPassword) => __awaiter(void 0, void 0, void 0, function* () {
+    const salt = yield (0, bcrypt_1.genSalt)(saltRounds);
+    return yield (0, bcrypt_1.hash)(myPlaintextPassword, salt);
+});
+exports.generateHashedPassword = generateHashedPassword;
+const validateHashedPassword = (plainTextPassword, hashedPasword) => __awaiter(void 0, void 0, void 0, function* () {
+    return yield (0, bcrypt_1.compare)(plainTextPassword, hashedPasword);
+});
+exports.validateHashedPassword = validateHashedPassword;

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

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

package/dist/common/postgres-service.js

@@ -0,0 +1,57 @@
+"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.getPool = exports.connectWithRetry = void 0;
+// src/common/postgres-service.ts
+const pg_1 = require("pg");
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.config)();
+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, // connection pool size
+    idleTimeoutMillis: 30000,
+};
+let retryCount = 0;
+let pool;
+const connectWithRetry = () => __awaiter(void 0, void 0, void 0, function* () {
+    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) {
+        retryCount++;
+        console.error(`❌ PostgreSQL connection failed (attempt ${retryCount}). Retrying in 5s...`, error.message);
+        setTimeout(exports.connectWithRetry, 5000);
+    }
+});
+exports.connectWithRetry = connectWithRetry;
+process.on('SIGINT', () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log('Closing PostgreSQL pool...');
+    if (pool)
+        yield pool.end();
+    console.log('PostgreSQL pool closed');
+    process.exit(0);
+}));
+const getPool = () => {
+    if (!pool)
+        throw new Error('PostgreSQL not connected yet');
+    return pool;
+};
+exports.getPool = getPool;
+// Initialize connection
+(0, exports.connectWithRetry)();

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

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

package/dist/common/postgres.service.js

@@ -0,0 +1,55 @@
+"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.getPool = exports.connectWithRetry = void 0;
+const pg_1 = require("pg");
+const dotenv_1 = require("dotenv");
+(0, dotenv_1.config)();
+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 retryCount = 0;
+let pool;
+const connectWithRetry = () => __awaiter(void 0, void 0, void 0, function* () {
+    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) {
+        retryCount++;
+        console.error(`❌ PostgreSQL connection failed (attempt ${retryCount}). Retrying in 5s...`, error.message);
+        setTimeout(exports.connectWithRetry, 5000);
+    }
+});
+exports.connectWithRetry = connectWithRetry;
+process.on('SIGINT', () => __awaiter(void 0, void 0, void 0, function* () {
+    console.log('Closing PostgreSQL pool...');
+    if (pool)
+        yield pool.end();
+    console.log('PostgreSQL pool closed');
+    process.exit(0);
+}));
+const getPool = () => {
+    if (!pool)
+        throw new Error('PostgreSQL not connected yet');
+    return pool;
+};
+exports.getPool = getPool;
+(0, exports.connectWithRetry)();

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

@@ -0,0 +1,6 @@
+export declare const logFailure: (res: any, filename: string, method: string, err: any) => Promise<any>;
+export declare const logFailureWithoutReturn: (filename: string, method: string, err: any) => Promise<void>;
+export declare const sendFailureResponse: (res: any, code: string) => Promise<any>;
+export declare const sendSuccessCode: (res: any, code: string) => Promise<any>;
+export declare const sendSuccessResponse: (res: any, output: string) => Promise<any>;
+export declare const sendSuccessCodeResponse: (res: any, code: string, output: string) => Promise<any>;

package/dist/common/response.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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendSuccessCodeResponse = exports.sendSuccessResponse = exports.sendSuccessCode = exports.sendFailureResponse = exports.logFailureWithoutReturn = exports.logFailure = void 0;
+const statuscode_1 = require("./statuscode");
+const logFailure = (res, filename, method, err) => __awaiter(void 0, void 0, void 0, function* () {
+    (0, exports.logFailureWithoutReturn)(filename, method, err);
+    return (0, exports.sendFailureResponse)(res, statuscode_1.STATUS_CODES.BAD_REQUEST);
+});
+exports.logFailure = logFailure;
+const logFailureWithoutReturn = (filename, method, err) => __awaiter(void 0, void 0, void 0, function* () {
+    console.log(`Error at ${filename}.js>${method}, Error Stack: ${err.stack}, Error Message: ${err.message}`);
+});
+exports.logFailureWithoutReturn = logFailureWithoutReturn;
+const sendFailureResponse = (res, code) => __awaiter(void 0, void 0, void 0, function* () {
+    return res.status(200).send({ status: statuscode_1.STATUSES.FAILURE, code });
+});
+exports.sendFailureResponse = sendFailureResponse;
+const sendSuccessCode = (res, code) => __awaiter(void 0, void 0, void 0, function* () {
+    return res.status(200).send({ status: statuscode_1.STATUSES.SUCCESS, code });
+});
+exports.sendSuccessCode = sendSuccessCode;
+const sendSuccessResponse = (res, output) => __awaiter(void 0, void 0, void 0, function* () {
+    return (0, exports.sendSuccessCodeResponse)(res, statuscode_1.STATUS_CODES.OK, output);
+});
+exports.sendSuccessResponse = sendSuccessResponse;
+const sendSuccessCodeResponse = (res, code, output) => __awaiter(void 0, void 0, void 0, function* () {
+    return res.status(200).send({
+        status: statuscode_1.STATUSES.SUCCESS,
+        code: code,
+        output: output
+    });
+});
+exports.sendSuccessCodeResponse = sendSuccessCodeResponse;

package/dist/common/statuscode.d.ts

@@ -0,0 +1,8 @@
+export declare const STATUS_CODES: {
+    OK: string;
+    BAD_REQUEST: string;
+};
+export declare const STATUSES: {
+    SUCCESS: string;
+    FAILURE: string;
+};

package/dist/common/statuscode.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.STATUSES = exports.STATUS_CODES = void 0;
+exports.STATUS_CODES = {
+    OK: "ok",
+    BAD_REQUEST: "Something went wrong, please try again later"
+};
+exports.STATUSES = {
+    SUCCESS: 'Success',
+    FAILURE: 'Failure',
+};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { logFailure, logFailureWithoutReturn, sendFailureResponse, sendSuccessCode, sendSuccessResponse, sendSuccessCodeResponse } from "./common/response.service";
+export { sleep, isValidUsername, validateStringIsValidEmail, validateStringIsValidNumber, genRandomString, genRandomNumber, format, createUUID } from './common/common';
+export { getCookies } from './common/cookies';
+export { generateHashedPassword, validateHashedPassword } from './common/password.service';

package/dist/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateHashedPassword = exports.generateHashedPassword = exports.getCookies = exports.createUUID = exports.format = exports.genRandomNumber = exports.genRandomString = exports.validateStringIsValidNumber = exports.validateStringIsValidEmail = exports.isValidUsername = exports.sleep = exports.sendSuccessCodeResponse = exports.sendSuccessResponse = exports.sendSuccessCode = exports.sendFailureResponse = exports.logFailureWithoutReturn = exports.logFailure = void 0;
+var response_service_1 = require("./common/response.service");
+Object.defineProperty(exports, "logFailure", { enumerable: true, get: function () { return response_service_1.logFailure; } });
+Object.defineProperty(exports, "logFailureWithoutReturn", { enumerable: true, get: function () { return response_service_1.logFailureWithoutReturn; } });
+Object.defineProperty(exports, "sendFailureResponse", { enumerable: true, get: function () { return response_service_1.sendFailureResponse; } });
+Object.defineProperty(exports, "sendSuccessCode", { enumerable: true, get: function () { return response_service_1.sendSuccessCode; } });
+Object.defineProperty(exports, "sendSuccessResponse", { enumerable: true, get: function () { return response_service_1.sendSuccessResponse; } });
+Object.defineProperty(exports, "sendSuccessCodeResponse", { enumerable: true, get: function () { return response_service_1.sendSuccessCodeResponse; } });
+var common_1 = require("./common/common");
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return common_1.sleep; } });
+Object.defineProperty(exports, "isValidUsername", { enumerable: true, get: function () { return common_1.isValidUsername; } });
+Object.defineProperty(exports, "validateStringIsValidEmail", { enumerable: true, get: function () { return common_1.validateStringIsValidEmail; } });
+Object.defineProperty(exports, "validateStringIsValidNumber", { enumerable: true, get: function () { return common_1.validateStringIsValidNumber; } });
+Object.defineProperty(exports, "genRandomString", { enumerable: true, get: function () { return common_1.genRandomString; } });
+Object.defineProperty(exports, "genRandomNumber", { enumerable: true, get: function () { return common_1.genRandomNumber; } });
+Object.defineProperty(exports, "format", { enumerable: true, get: function () { return common_1.format; } });
+Object.defineProperty(exports, "createUUID", { enumerable: true, get: function () { return common_1.createUUID; } });
+var cookies_1 = require("./common/cookies");
+Object.defineProperty(exports, "getCookies", { enumerable: true, get: function () { return cookies_1.getCookies; } });
+var password_service_1 = require("./common/password.service");
+Object.defineProperty(exports, "generateHashedPassword", { enumerable: true, get: function () { return password_service_1.generateHashedPassword; } });
+Object.defineProperty(exports, "validateHashedPassword", { enumerable: true, get: function () { return password_service_1.validateHashedPassword; } });

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

@@ -0,0 +1,12 @@
+import { QueryResult, QueryResultRow } from 'pg';
+export declare abstract class BaseModel<T extends object> {
+    protected tableName: string;
+    constructor(tableName: string);
+    protected query<R extends QueryResultRow = any>(sql: string, params?: any[]): Promise<QueryResult<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>;
+}

package/dist/models/base.model.js

@@ -0,0 +1,157 @@
+"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.BaseModel = void 0;
+const postgres_service_1 = require("../common/postgres.service");
+class BaseModel {
+    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();
+            }
+        });
+    }
+    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;
+        });
+    }
+}
+exports.BaseModel = BaseModel;

package/dist/models/users.model.d.ts

@@ -0,0 +1,14 @@
+import { BaseModel } from './base.model';
+export interface IUser {
+    id?: number;
+    username: string;
+    name: string;
+    status: string;
+    subject: string;
+    text: string;
+    created_at?: Date;
+    last_modified?: Date;
+}
+export declare class UserModel extends BaseModel<IUser> {
+    constructor();
+}

package/dist/models/users.model.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserModel = void 0;
+// src/models/user.model.ts
+const base_model_1 = require("./base.model");
+class UserModel extends base_model_1.BaseModel {
+    constructor() {
+        super('users');
+    }
+}
+exports.UserModel = UserModel;

package/package.json

@@ -0,0 +1,24 @@
+{
+    "name": "sspart-common-lib",
+    "version": "0.0.2",
+    "description": "",
+    "main": "dist/index.js",
+    "type": "commonjs",
+    "files": [
+        "dist",
+        "README.md"
+    ],
+    "scripts": {
+        "build": "tsc"
+    },
+    "author": "",
+    "license": "ISC",
+    "dependencies": {
+        "@types/bcrypt": "^5.0.2",
+        "bcrypt": "^5.1.1",
+        "dotenv": "^17.2.3"
+    },
+    "devDependencies": {
+        "typescript": "^5.7.2"
+    }
+}