easy-postgresql 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 cihatksm, https://cihatksm.com/
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+#### Module Download
+
+```bash
+  npm install easy-postgresql
+```
+
+#### Simple Usage
+```js
+const config = require('./config');
+
+const { Connect, Table, Request } = require('easy-postgresql');
+
+const date = () => new Date();
+console.log(date(), 'System opened!');
+
+Connect(config.sql);
+
+setTimeout(async () => {
+    // const user = await Table('company').findOne({ id: 1 });
+    // console.log(user);
+
+    // const info = await Table('company').functions.info();
+    // console.log(info); 
+
+    // const procedure = await Request.procedure('GetCompany', { companyId: 1 });
+    // console.log(procedure);
+
+    // const query = await Request.query('SELECT * FROM company');
+    // console.log(query);
+
+    // const simple_scheme = require('./simple_scheme');
+    // const createdTable = await Table('company').functions.create(simple_scheme.dataTypes);
+    // console.log(createdTable);
+
+    // const removedTable = await Table('company').functions.remove();
+    // console.log(removedTable);
+}, 1000);
+
+```
+
+[![MIT License](https://img.shields.io/badge/License-MIT-green.svg)](https://choosealicense.com/licenses/mit/)
+
+#### Feedback
+
+**E-mail:** me@cihatksm.com

package/SECURITY.md

@@ -0,0 +1,15 @@
+# Security Policy
+
+## Reporting a Vulnerability
+
+Use this section to tell people how to report a vulnerability.
+Tell them where to go, how often they can expect to get an update on a reported vulnerability, what to expect if the vulnerability is accepted or declined, etc.
+
+To report a vulnerability, please visit our support website at cihatksm.com. 
+We take full responsibility for all rights and ensure continuous support throughout the process. 
+Once you submit a vulnerability, you can expect regular updates on its status. 
+If the vulnerability is accepted, appropriate actions will be taken to address it. 
+If it is declined, we will provide an explanation. Thank you for your cooperation.
+
+All rights reserved.
+cihatksm.com, 2025 © cihatksm

package/database/procedure.ts

@@ -0,0 +1,129 @@
+import { executeProcedure } from '../operations/procedure_execute';
+import { sqlTypes } from '../operations/data_types';
+import { config } from '../operations/config';
+import { Query } from './query';
+import { log } from '../operations/log';
+
+interface ProcedureInfo {
+    name: string;
+    type: string;
+    date: string | null;
+}
+
+interface ProcedureOutput {
+    name: string;
+    type: string;
+}
+
+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 function Procedure(name = '') {
+    /**
+     * Returns information about the procedure in the database.
+     * @returns Promise<ProcedureInfo | null> - Information about the procedure
+     */
+    async function Info(): Promise<ProcedureInfo | null> {
+        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 Query(queryString, [name]);
+        if (queryOutput?.status !== 200) {
+            if (config.get.logingMode()) 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(): Promise<ProcedureInfo[] | null> {
+        const queryString = `SELECT routine_name FROM information_schema.routines WHERE routine_type = 'FUNCTION' AND routine_schema = 'public'`;
+        const queryOutput = await Query(queryString);
+        if (queryOutput?.status !== 200) {
+            if (config.get.logingMode()) 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(): Promise<Record<string, string>> {
+        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: ProcedureReference = {}, useRecordsets: boolean = false): Promise<ProcedureResult> {
+        let procedureOutput = await executeProcedure(name, reference, useRecordsets);
+        if (procedureOutput?.status !== 200) {
+            if (config.get.logingMode()) 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: Record<string, any> = {};
+                    keys.forEach(key => new_data[key] = sqlTypes[schema[key]](m[key]));
+                    return new_data;
+                }).filter(f => f !== null);
+            }
+        }
+
+        procedureOutput.data = data;
+        return procedureOutput;
+    }
+
+    return {
+        Execute,
+        Info,
+        AllInfo,
+        SimpleOutput
+    };
+}

package/database/query.ts

@@ -0,0 +1,78 @@
+import { getPool } from '../operations/connect_to_server';
+import { config } from '../operations/config';
+import { log } from '../operations/log';
+
+export interface QueryResult {
+    status: number;
+    message: string;
+    data: any[] | null;
+}
+
+function pgTypeOf(value: any): string {
+    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: string, inputs: Record<string, any>): { text: string; values: any[] } {
+    const paramRegex = /@(\w+)/g;
+    const params: string[] = [];
+    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>
+ */
+export const Query = async (query: string, inputs?: Record<string, any> | any[]): Promise<QueryResult> => {
+    try {
+        let text: string;
+        let values: any[];
+
+        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 = 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.get.logingMode()) {
+            log('Query', null, `${query} : ${err instanceof Error ? err.message : String(err)}`);
+        }
+        return { status: 500, message: String(err), data: null };
+    }
+};

package/database/sql_types.d.ts

@@ -0,0 +1,52 @@
+/**
+ * This object contains the SQL data types.
+ * @file sql_types.d.ts
+ * @description This file contains the SQL data types.
+ * @module
+ */
+
+interface SqlTypeOptions {
+    notNull: () => string;
+    primaryKey: () => string;
+    unique: () => string;
+    autoIncrement: () => string;
+    default: (value?: any) => string;
+    check: (value?: any) => string;
+    foreignKey: (table?: string, column?: string) => string;
+}
+
+interface SqlTypes {
+    varchar: (length?: number) => string;
+    nvarchar: (length?: number) => string;
+    int: () => string;
+    bigint: () => string;
+    smallint: () => string;
+    tinyint: () => string;
+    bit: () => string;
+    float: () => string;
+    real: () => string;
+    decimal: (precision?: number, scale?: number) => string;
+    numeric: () => string;
+    money: () => string;
+    smallmoney: () => string;
+    date: () => string;
+    time: () => string;
+    datetime: () => string;
+    datetime2: () => string;
+    smalldatetime: () => string;
+    timestamp: () => string;
+    char: () => string;
+    nchar: () => string;
+    text: () => string;
+    ntext: () => string;
+    binary: () => string;
+    varbinary: () => string;
+    image: () => string;
+    uniqueidentifier: () => string;
+    sql_variant: () => string;
+    xml: () => string;
+    options: SqlTypeOptions;
+}
+
+declare const sqlTypes: SqlTypes;
+export { sqlTypes, SqlTypes, SqlTypeOptions };

package/database/sql_types.ts

@@ -0,0 +1,90 @@
+/**
+ * This object contains the SQL data types.
+ * @file sql_types.ts
+ * @description This file contains the SQL data types.
+ * @module
+ */
+
+export interface SqlTypeOptions {
+    notNull: () => string;
+    primaryKey: () => string;
+    unique: () => string;
+    autoIncrement: () => string;
+    default: (value?: any) => string;
+    check: (value?: any) => string;
+    foreignKey: (table?: string, column?: string) => string;
+}
+
+export interface SqlTypes {
+    varchar: (length?: number) => string;
+    nvarchar: (length?: number) => string;
+    int: () => string;
+    bigint: () => string;
+    smallint: () => string;
+    tinyint: () => string;
+    bit: () => string;
+    float: () => string;
+    real: () => string;
+    decimal: (precision?: number, scale?: number) => string;
+    numeric: () => string;
+    money: () => string;
+    smallmoney: () => string;
+    date: () => string;
+    time: () => string;
+    datetime: () => string;
+    datetime2: () => string;
+    smalldatetime: () => string;
+    timestamp: () => string;
+    char: () => string;
+    nchar: () => string;
+    text: () => string;
+    ntext: () => string;
+    binary: () => string;
+    varbinary: () => string;
+    image: () => string;
+    uniqueidentifier: () => string;
+    sql_variant: () => string;
+    xml: () => string;
+    options: SqlTypeOptions;
+}
+
+export const sqlTypes: SqlTypes = {
+    varchar: (length = 255) => typeof length === 'number' ? `VARCHAR(${length})` : 'VARCHAR(255)',
+    nvarchar: (length = 255) => typeof length === 'number' ? `VARCHAR(${length})` : 'VARCHAR(255)',
+    int: () => 'INT',
+    bigint: () => 'BIGINT',
+    smallint: () => 'SMALLINT',
+    tinyint: () => 'SMALLINT',
+    bit: () => 'BOOLEAN',
+    float: () => 'FLOAT',
+    real: () => 'REAL',
+    decimal: (precision = 18, scale = 0) => typeof precision === 'number' && typeof scale === 'number' ? `DECIMAL(${precision}, ${scale})` : 'DECIMAL(18, 0)',
+    numeric: () => 'NUMERIC',
+    money: () => 'NUMERIC(19,4)',
+    smallmoney: () => 'NUMERIC(10,4)',
+    date: () => 'DATE',
+    time: () => 'TIME',
+    datetime: () => 'TIMESTAMP',
+    datetime2: () => 'TIMESTAMP',
+    smalldatetime: () => 'TIMESTAMP',
+    timestamp: () => 'BYTEA',
+    char: () => 'CHAR',
+    nchar: () => 'CHAR',
+    text: () => 'TEXT',
+    ntext: () => 'TEXT',
+    binary: () => 'BYTEA',
+    varbinary: () => 'BYTEA',
+    image: () => 'BYTEA',
+    uniqueidentifier: () => 'UUID',
+    sql_variant: () => 'TEXT',
+    xml: () => 'XML',
+    options: {
+        notNull: () => ' ' + 'NOT NULL',
+        primaryKey: () => ' ' + 'PRIMARY KEY',
+        unique: () => ' ' + 'UNIQUE',
+        autoIncrement: () => ' ' + 'GENERATED ALWAYS AS IDENTITY',
+        default: (value?: any) => value !== undefined ? (' ' + `DEFAULT ${value}`) : '',
+        check: (value?: any) => value !== undefined ? (' ' + `CHECK(${value})`) : '',
+        foreignKey: (table?: string, column?: string) => table !== undefined && column !== undefined ? (' ' + `REFERENCES ${table}(${column})`) : ''
+    }
+};