easy-postgresql 0.0.1

package/database/table.ts

@@ -0,0 +1,378 @@
+import { sqlTypes } from '../operations/data_types';
+import { getConditionPieces, getInsertPieces, isValidIdentifier } from '../operations/get_pieces';
+import { config } from '../operations/config';
+import { Query } from './query';
+import { log } from '../operations/log';
+
+interface TableOptions {
+    limit?: number | null;
+    selected_keys?: string[];
+    likes?: Record<string, string>;
+}
+
+interface TableSchema {
+    [key: string]: string;
+}
+
+interface TableInfo {
+    name: string;
+    type: string;
+    date: string | null;
+    schema: TableSchema;
+}
+
+interface TableResult {
+    status: number;
+    message: string;
+    data: any[] | null;
+}
+
+interface TableReference {
+    [key: string]: any;
+}
+
+interface TableData {
+    [key: string]: any;
+}
+
+interface TableFunctions {
+    create: (scheme: TableSchema) => Promise<boolean>;
+    remove: () => Promise<boolean>;
+    isThere: () => Promise<boolean>;
+    info: () => Promise<TableInfo | null>;
+    getAll: () => Promise<TableInfo[] | null>;
+    updateColumn: (columnName: string) => {
+        add: (type: string) => Promise<boolean>;
+        remove: () => Promise<boolean>;
+        rename: (newColumnName: string) => Promise<boolean>;
+        update: (type: string) => Promise<boolean>;
+    };
+}
+
+function TableFunctions(name: string): TableFunctions {
+    async function create(scheme: TableSchema): Promise<boolean> {
+        const isThereTable = await isThere();
+        if (isThereTable) return false;
+
+        if (!scheme || Object.keys(scheme).length === 0) return false;
+        const stringScheme = Object.keys(scheme).map(m => m + ' ' + scheme[m]).join(', ');
+
+        const queryString = `CREATE TABLE ${name} (${stringScheme})`;
+        return (await Query(queryString))?.status === 200;
+    }
+
+    async function remove(): Promise<boolean> {
+        const isThereTable = await isThere();
+        if (!isThereTable) return false;
+
+        const queryString = `DROP TABLE ${name}`;
+        return (await Query(queryString))?.status === 200;
+    }
+
+    async function isThere(): Promise<boolean> {
+        const queryString = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND LOWER(table_name) = LOWER($1)`;
+        const queryOutput = await Query(queryString, [name]);
+        return queryOutput?.status === 200 && (queryOutput?.data?.length ?? 0) > 0;
+    }
+
+    async function info(): Promise<TableInfo | null> {
+        const queryString = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public' AND LOWER(table_name) = LOWER($1)`;
+        const queryOutput = await Query(queryString, [name]);
+        if (queryOutput?.status !== 200) {
+            if (config.get.logingMode()) log('Table', 'Info', `Table ${name} not found.`);
+            return null;
+        }
+
+        const data = queryOutput?.data?.[0] || null;
+        if (!data) return null;
+
+        const schema = await getSchema();
+        return {
+            name: data.table_name,
+            type: 'Table',
+            date: null,
+            schema
+        };
+    }
+
+    async function getAll(): Promise<TableInfo[] | null> {
+        const queryString = `SELECT table_name FROM information_schema.tables WHERE table_schema = 'public'`;
+        const queryOutput = await Query(queryString);
+        if (queryOutput?.status !== 200) {
+            if (config.get.logingMode()) log('Table', 'Get All', 'Tables not found.');
+            return null;
+        }
+
+        const data = queryOutput?.data || [];
+        if (!data) return null;
+
+        return Promise.all(data.map(async (m: any) => {
+            const schema = await getSchema(m.table_name);
+            return {
+                name: m.table_name,
+                type: 'Table',
+                date: null,
+                schema
+            };
+        }));
+    }
+
+    async function getSchema(tableName: string = name): Promise<TableSchema> {
+        const queryString = `SELECT COLUMN_NAME, DATA_TYPE FROM INFORMATION_SCHEMA.COLUMNS WHERE LOWER(TABLE_NAME) = LOWER($1)`;
+        const queryOutput = await Query(queryString, [tableName]);
+        if (queryOutput?.status !== 200) return {};
+
+        const data = queryOutput?.data || [];
+        return data.reduce((acc: Record<string, string>, cur: any) => ({ ...acc, [cur.column_name]: cur.data_type }), {});
+    }
+
+    function updateColumn(columnName: string) {
+        async function add(type: string): Promise<boolean> {
+            const queryString = `ALTER TABLE ${name} ADD ${columnName} ${type}`;
+            return (await Query(queryString))?.status === 200;
+        }
+
+        async function remove(): Promise<boolean> {
+            const queryString = `ALTER TABLE ${name} DROP COLUMN ${columnName}`;
+            return (await Query(queryString))?.status === 200;
+        }
+
+        async function rename(newColumnName: string): Promise<boolean> {
+            const queryString = `ALTER TABLE ${name} RENAME COLUMN ${columnName} TO ${newColumnName}`;
+            return (await Query(queryString))?.status === 200;
+        }
+
+        async function update(type: string): Promise<boolean> {
+            const queryString = `ALTER TABLE ${name} ALTER COLUMN ${columnName} TYPE ${type}`;
+            return (await Query(queryString))?.status === 200;
+        }
+
+        return {
+            add,
+            remove,
+            rename,
+            update
+        };
+    }
+
+    return {
+        create,
+        remove,
+        isThere,
+        info,
+        getAll,
+        updateColumn
+    };
+}
+
+export function Table(name: string) {
+    async function find(reference: TableReference = {}, options: TableOptions = { limit: null, selected_keys: [], likes: {} }): Promise<any[]> {
+        let table = await TableFunctions(name).info();
+        if (!table) {
+            if (config.get.logingMode()) log('Table', 'Find', `Table ${name} not found.`);
+            return [];
+        }
+
+        const { condition, inputs } = getConditionPieces(reference, 0);
+        let referenceString = condition ? `WHERE ${condition}` : '';
+
+        if (Object.keys(options.likes || {}).length > 0) {
+            let likeKeys = Object.keys(options.likes || {});
+            let startIdx = inputs.length;
+            let likes = likeKeys.map((m, i) => `${m} LIKE $${startIdx + i + 1}`);
+            referenceString += referenceString ? ` AND ${likes.join(' AND ')}` : `WHERE ${likes.join(' AND ')}`;
+            for (const key of likeKeys) {
+                inputs.push((options.likes?.[key] || '').replaceAll('?', '%').replaceAll('.', '_'));
+            }
+        }
+
+        let columns = '*';
+        if (Array.isArray(options.selected_keys) && options.selected_keys && options.selected_keys?.length > 0) {
+            columns = options.selected_keys.filter(k => isValidIdentifier(k)).join(', ');
+        }
+
+        let limitString = (typeof options.limit === 'number' && options.limit > 0) ? ` LIMIT ${options.limit}` : '';
+        let queryString = `SELECT ${columns} FROM ${name} ${referenceString}${limitString}`;
+
+        let queryOutput = await Query(queryString, inputs.length > 0 ? inputs : undefined);
+        let data = queryOutput?.data || [];
+
+        if (data.length > 0) {
+            data = data.map(m => {
+                let keys = Object.keys(m);
+                let schemaControlled = false;
+                if (options?.selected_keys && options.selected_keys.length > 0 && keys.length <= Object.keys(table?.schema || {}).length) schemaControlled = true;
+                if (!schemaControlled && keys.length === Object.keys(table?.schema || {}).length) schemaControlled = true;
+                if (!schemaControlled) return null;
+
+                let new_data: Record<string, any> = {};
+                keys.forEach(key => {
+                    const lowerKey = (key || '').toLowerCase();
+                    const schemaKey = Object.keys(table!.schema).find(k => k.toLowerCase() === lowerKey) || '';
+                    const converter = sqlTypes[table!.schema[schemaKey]];
+                    new_data[key] = converter ? converter(m[key]) : m[key];
+                });
+                return new_data;
+            }).filter(f => f !== null);
+        }
+
+        return data;
+    }
+
+    async function findOne(reference: TableReference = {}, options: TableOptions = { selected_keys: [], likes: {} }): Promise<any | null> {
+        const findOption = { limit: 1, selected_keys: options.selected_keys, likes: options.likes };
+        return (await find(reference, findOption))[0] || null;
+    }
+
+    async function createOne(data: TableData): Promise<boolean> {
+        const { columns, values, inputs } = getInsertPieces(data);
+        const queryString = `INSERT INTO ${name} (${columns}) VALUES (${values})`;
+        const queryOutput = await Query(queryString, inputs);
+        return queryOutput?.status === 200;
+    }
+
+    async function updateOne(reference: TableReference, data: TableData): Promise<boolean> {
+        const { condition: refCondition, inputs: refInputs } = getConditionPieces(reference, 0);
+        const { condition: dataCondition, inputs: dataInputs } = getConditionPieces(data, refInputs.length);
+
+        if (!refCondition) {
+            if (config.get.logingMode()) log('Table', 'Update', 'No reference provided for update');
+            return false;
+        }
+        if (!dataCondition) {
+            if (config.get.logingMode()) log('Table', 'Update', 'No data provided for update');
+            return false;
+        }
+
+        const existingData = await findOne(reference);
+        if (!existingData) {
+            if (config.get.logingMode()) log('Table', 'Update', 'No data found for update');
+            return false;
+        }
+
+        const allInputs = [...refInputs, ...dataInputs];
+
+        const setValues = dataCondition.replace(/ AND /g, ', ');
+
+        const queryString = `UPDATE ${name} SET ${setValues} WHERE ${refCondition}`;
+        const queryOutput = await Query(queryString, allInputs);
+        return queryOutput?.status === 200;
+    }
+
+    async function deleteOne(reference: TableReference): Promise<boolean> {
+        const deleteOperation = await _deleteOne(reference);
+        if (deleteOperation === false) return false;
+        return deleteOperation.status === 200;
+    }
+
+    async function _deleteOne(reference: TableReference): Promise<TableResult | false> {
+        const { condition, inputs } = getConditionPieces(reference, 0);
+        if (!condition) {
+            if (config.get.logingMode()) log('Table', 'Delete', 'No reference provided for delete');
+            return false;
+        }
+
+        const queryString = `DELETE FROM ${name} WHERE ${condition}`;
+        return await Query(queryString, inputs);
+    }
+
+    async function deleteAll(reference?: TableReference): Promise<boolean> {
+        const datas = await find(reference || {});
+        if (datas.length === 0) {
+            if (config.get.logingMode()) log('Table', 'Delete', 'No data found for delete');
+            return false;
+        }
+
+        const deletes = await Promise.all(datas.map(async data => {
+            const _data: Record<string, any> = {};
+            Object.keys(data)
+                .filter(key => key !== 'created_at' && data[key] !== null)
+                .forEach(key => _data[key] = data[key]);
+            return await _deleteOne(_data);
+        }));
+
+        let output: TableResult;
+        const isCompleted = deletes.filter(f => f !== false && f.status !== 200).length === 0;
+        if (!isCompleted) output = { status: 500, message: "An error occurred while deleting", data: null };
+        else output = { status: 200, message: "Success", data: null };
+
+        return output.status === 200;
+    }
+
+    async function first(reference: TableReference = {}, options: TableOptions = {}): Promise<any | null> {
+        const data = await find(reference, { ...options, limit: 1 });
+        return data[0] || null;
+    }
+
+    async function firstOrDefault(reference: TableReference = {}, options: TableOptions = {}): Promise<any | null> {
+        const data = await find(reference, { ...options, limit: 1 });
+        return data[0] || null;
+    }
+
+    async function single(reference: TableReference = {}, options: TableOptions = {}): Promise<any> {
+        const data = await find(reference, options);
+        if (data.length === 0) throw new Error("Sequence contains no elements");
+        if (data.length > 1) throw new Error("Sequence contains more than one element");
+        return data[0];
+    }
+
+    async function singleOrDefault(reference: TableReference = {}, options: TableOptions = {}): Promise<any | null> {
+        const data = await find(reference, options);
+        if (data.length > 1) throw new Error("Sequence contains more than one element");
+        return data[0] || null;
+    }
+
+    async function last(reference: TableReference = {}, options: TableOptions = {}): Promise<any | null> {
+        const data = await find(reference, options);
+        return data[data.length - 1] || null;
+    }
+
+    async function lastOrDefault(reference: TableReference = {}, options: TableOptions = {}): Promise<any | null> {
+        const data = await find(reference, options);
+        return data[data.length - 1] || null;
+    }
+
+    async function count(reference: TableReference = {}, options: TableOptions = {}): Promise<number> {
+        const data = await find(reference, options);
+        return data.length;
+    }
+
+    async function min(key: string, reference: TableReference = {}, options: TableOptions = {}): Promise<number | null> {
+        const data = await find(reference, options);
+        if (data.length === 0) return null;
+        return Math.min(...data.map(item => item[key]));
+    }
+
+    async function max(key: string, reference: TableReference = {}, options: TableOptions = {}): Promise<number | null> {
+        const data = await find(reference, options);
+        if (data.length === 0) return null;
+        return Math.max(...data.map(item => item[key]));
+    }
+
+    async function average(key: string, reference: TableReference = {}, options: TableOptions = {}): Promise<number | null> {
+        const data = await find(reference, options);
+        if (data.length === 0) return null;
+        const sum = data.reduce((acc, item) => acc + item[key], 0);
+        return sum / data.length;
+    }
+
+    return {
+        find,
+        findOne,
+        createOne,
+        updateOne,
+        deleteOne,
+        deleteAll,
+        first,
+        firstOrDefault,
+        single,
+        singleOrDefault,
+        last,
+        lastOrDefault,
+        count,
+        min,
+        max,
+        average,
+        functions: TableFunctions(name)
+    };
+}

package/database.ts

@@ -0,0 +1,26 @@
+import 'colors';
+import { Table } from './database/table';
+import { Procedure } from './database/procedure';
+import { Query } from './database/query';
+import { sqlTypes } from './database/sql_types';
+import { connectToServer, isConnected } from './operations/connect_to_server';
+import { config } from './operations/config';
+
+/**
+ * This class provides all database operations.
+ * @file database.ts
+ * @description This file contains the database operations.
+ * @module
+ */
+class EasyPostgresql {
+    Table = Table;
+    Procedure = Procedure;
+    Query = Query;
+    Types = sqlTypes;
+    Connect = connectToServer;
+    IsConnected = isConnected;
+    Config = config.set;
+}
+
+const easyPostgresql = new EasyPostgresql();
+export = easyPostgresql;

package/dist/database/procedure.d.ts

@@ -0,0 +1,26 @@
+interface ProcedureInfo {
+    name: string;
+    type: string;
+    date: string | null;
+}
+interface ProcedureResult {
+    status: number;
+    message: string;
+    data: any[] | null;
+}
+interface ProcedureReference {
+    [key: string]: any;
+}
+/**
+ * All functions in the procedure are defined in this class.
+ *
+ * @param name - The name of the procedure to be added to the procedure
+ * @returns Object containing procedure methods
+ */
+export declare function Procedure(name?: string): {
+    Execute: (reference?: ProcedureReference, useRecordsets?: boolean) => Promise<ProcedureResult>;
+    Info: () => Promise<ProcedureInfo | null>;
+    AllInfo: () => Promise<ProcedureInfo[] | null>;
+    SimpleOutput: () => Promise<Record<string, string>>;
+};
+export {};

package/dist/database/procedure.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Procedure = Procedure;
+const procedure_execute_1 = require("../operations/procedure_execute");
+const data_types_1 = require("../operations/data_types");
+const config_1 = require("../operations/config");
+const query_1 = require("./query");
+const log_1 = require("../operations/log");
+/**
+ * All functions in the procedure are defined in this class.
+ *
+ * @param name - The name of the procedure to be added to the procedure
+ * @returns Object containing procedure methods
+ */
+function Procedure(name = '') {
+    /**
+     * Returns information about the procedure in the database.
+     * @returns Promise<ProcedureInfo | null> - Information about the procedure
+     */
+    async function Info() {
+        if (!name)
+            return null;
+        const queryString = `SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema = 'public' AND LOWER(routine_name) = LOWER($1)`;
+        const queryOutput = await (0, query_1.Query)(queryString, [name]);
+        if (queryOutput?.status !== 200) {
+            if (config_1.config.get.logingMode())
+                (0, log_1.log)('Procedure', 'Info', `The ${name} procedure not found.`);
+            return null;
+        }
+        const data = queryOutput?.data?.[0] || null;
+        if (!data)
+            return null;
+        return {
+            name: data.routine_name,
+            type: 'Function',
+            date: null
+        };
+    }
+    /**
+     * Returns information about all procedures in the database.
+     * @returns Promise<ProcedureInfo[] | null> - Information about all procedures
+     */
+    async function AllInfo() {
+        const queryString = `SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema = 'public'`;
+        const queryOutput = await (0, query_1.Query)(queryString);
+        if (queryOutput?.status !== 200) {
+            if (config_1.config.get.logingMode())
+                (0, log_1.log)('Procedure', 'All Info', 'Procedures not found.');
+            return null;
+        }
+        const data = queryOutput?.data || [];
+        if (!data)
+            return null;
+        return data.map(m => ({
+            name: m.routine_name,
+            type: 'Function',
+            date: null
+        }));
+    }
+    /**
+     * Gets the output schema of the procedure in the database.
+     * @returns Promise<Record<string, string>> - The output schema of the procedure
+     */
+    async function SimpleOutput() {
+        if (!name)
+            return {};
+        return {};
+    }
+    /**
+     * Executes the procedure in the database
+     *
+     * @param reference - The reference parameters to be executed in the database
+     * @param useRecordsets - If true, returns result?.recordsets; otherwise returns result?.recordset (default: false)
+     * @returns Promise<ProcedureResult> - The result of the procedure execution
+     */
+    async function Execute(reference = {}, useRecordsets = false) {
+        let procedureOutput = await (0, procedure_execute_1.executeProcedure)(name, reference, useRecordsets);
+        if (procedureOutput?.status !== 200) {
+            if (config_1.config.get.logingMode())
+                (0, log_1.log)('Procedure', 'Execute', `The ${name} procedure could not be executed.`);
+            return { status: 501, message: 'The procedure could not be executed.', data: [] };
+        }
+        let data = procedureOutput?.data || null;
+        if (Array.isArray(data) && data.length > 0 && useRecordsets == false) {
+            const schema = await SimpleOutput();
+            if (schema && Object.keys(schema).length > 0) {
+                data = data.map(m => {
+                    const keys = Object.keys(m);
+                    if (keys.length !== Object.keys(schema).length)
+                        return null;
+                    const new_data = {};
+                    keys.forEach(key => new_data[key] = data_types_1.sqlTypes[schema[key]](m[key]));
+                    return new_data;
+                }).filter(f => f !== null);
+            }
+        }
+        procedureOutput.data = data;
+        return procedureOutput;
+    }
+    return {
+        Execute,
+        Info,
+        AllInfo,
+        SimpleOutput
+    };
+}
+//# sourceMappingURL=procedure.js.map

package/dist/database/procedure.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"procedure.js","sourceRoot":"","sources":["../../database/procedure.ts"],"names":[],"mappings":"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"}

package/dist/database/query.d.ts

@@ -0,0 +1,13 @@
+export interface QueryResult {
+    status: number;
+    message: string;
+    data: any[] | null;
+}
+/**
+ * Executes a raw SQL query with optional parameterized inputs.
+ *
+ * @param query - The SQL query to execute. Use @paramName for named parameters or $1, $2 for positional.
+ * @param inputs - Optional key/value map of named parameters (Record) or ordered values array
+ * @returns Promise<QueryResult>
+ */
+export declare const Query: (query: string, inputs?: Record<string, any> | any[]) => Promise<QueryResult>;

package/dist/database/query.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Query = void 0;
+const connect_to_server_1 = require("../operations/connect_to_server");
+const config_1 = require("../operations/config");
+const log_1 = require("../operations/log");
+function pgTypeOf(value) {
+    if (value === null || value === undefined)
+        return 'text';
+    if (typeof value === 'number')
+        return Number.isInteger(value) ? 'integer' : 'float8';
+    if (typeof value === 'boolean')
+        return 'boolean';
+    if (value instanceof Date)
+        return 'timestamp';
+    if (Buffer.isBuffer(value))
+        return 'bytea';
+    return 'text';
+}
+function convertNamedToPositional(query, inputs) {
+    const paramRegex = /@(\w+)/g;
+    const params = [];
+    let match;
+    while ((match = paramRegex.exec(query)) !== null) {
+        if (!params.includes(match[1])) {
+            params.push(match[1]);
+        }
+    }
+    let text = query;
+    params.forEach((param, i) => {
+        const type = pgTypeOf(inputs[param]);
+        text = text.replace(new RegExp(`@${param}\\b`, 'g'), `$${i + 1}::${type}`);
+    });
+    const values = params.map(p => inputs[p] !== undefined ? inputs[p] : null);
+    return { text, values };
+}
+/**
+ * Executes a raw SQL query with optional parameterized inputs.
+ *
+ * @param query - The SQL query to execute. Use @paramName for named parameters or $1, $2 for positional.
+ * @param inputs - Optional key/value map of named parameters (Record) or ordered values array
+ * @returns Promise<QueryResult>
+ */
+const Query = async (query, inputs) => {
+    try {
+        let text;
+        let values;
+        if (Array.isArray(inputs)) {
+            text = query;
+            values = inputs;
+        }
+        else if (inputs && typeof inputs === 'object') {
+            const converted = convertNamedToPositional(query, inputs);
+            text = converted.text;
+            values = converted.values;
+        }
+        else {
+            text = query;
+            values = [];
+        }
+        const pool = (0, connect_to_server_1.getPool)();
+        const client = await pool.connect();
+        try {
+            const result = await client.query(text, values);
+            return { status: 200, message: 'Success', data: result.rows || null };
+        }
+        finally {
+            client.release();
+        }
+    }
+    catch (err) {
+        if (config_1.config.get.logingMode()) {
+            (0, log_1.log)('Query', null, `${query} : ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { status: 500, message: String(err), data: null };
+    }
+};
+exports.Query = Query;
+//# sourceMappingURL=query.js.map

package/dist/database/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","sourceRoot":"","sources":["../../database/query.ts"],"names":[],"mappings":"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"}