easy-postgresql 0.0.1

package/operations/data_types.ts

@@ -0,0 +1,129 @@
+/**
+ * This class is used to create an object of any data type.
+ */
+class Any {
+    value: any;
+
+    constructor(value: any) {
+        this.value = value;
+    }
+}
+
+/**
+ * This function is used to check if the value is null.
+ * 
+ * @param value - The data to be checked
+ * @returns boolean - Returns true if the value is null, false otherwise
+ */
+const isNull = (value: any): boolean => value === null;
+
+/**
+ * This object contains functions to convert values to specific data types.
+ */
+const types = {
+    /**
+     * Converts a value to a string.
+     * @param value - The value to be converted
+     * @returns string | null - The converted string value or null
+     */
+    string: (value: any): string | null => {
+        return isNull(value) ? null : String(value);
+    },
+
+    /**
+     * Converts a value to a number.
+     * @param value - The value to be converted
+     * @returns number | null - The converted number value or null
+     */
+    number: (value: any): number | null => {
+        return isNull(value) ? null : Number(value);
+    },
+
+    /**
+     * Converts a value to a boolean.
+     * @param value - The value to be converted
+     * @returns boolean | null - The converted boolean value or null
+     */
+    boolean: (value: any): boolean | null => {
+        return isNull(value) ? null : Boolean(value);
+    },
+
+    /**
+     * Converts a value to a Date.
+     * @param value - The value to be converted
+     * @returns Date | null - The converted Date value or null
+     */
+    date: (value: any): Date | null => {
+        return isNull(value) ? null : new Date(value);
+    },
+
+    /**
+     * Converts a value to a Buffer.
+     * @param value - The value to be converted
+     * @returns Buffer | null - The converted Buffer value or null
+     */
+    buffer: (value: any): Buffer | null => {
+        return isNull(value) ? null : Buffer.from(String(value));
+    },
+
+    /**
+     * Converts a value to an Array.
+     * @param value - The value to be converted
+     * @returns any[] | null - The converted Array value or null
+     */
+    array: (value: any): any[] | null => {
+        return isNull(value) ? null : Array.isArray(value) ? value : [value];
+    },
+
+    /**
+     * Wraps a value in an Any object.
+     * @param value - The value to be wrapped
+     * @returns Any | null - The wrapped value or null
+     */
+    any: (value: any): Any | null => {
+        return isNull(value) ? null : new Any(value);
+    }
+};
+
+type TypeConverter = (value: any) => any;
+
+/**
+ * This object contains the data types of PostgreSQL and their corresponding JavaScript data type converters.
+ */
+export const sqlTypes: Record<string, TypeConverter> = {
+    "char": types.string,
+    "character": types.string,
+    "varchar": types.string,
+    "character varying": types.string,
+    "text": types.string,
+    "bytea": types.buffer,
+    "bool": types.boolean,
+    "boolean": types.boolean,
+    "int2": types.number,
+    "smallint": types.number,
+    "int4": types.number,
+    "integer": types.number,
+    "int8": types.number,
+    "bigint": types.number,
+    "decimal": types.number,
+    "numeric": types.number,
+    "float4": types.number,
+    "real": types.number,
+    "float8": types.number,
+    "double precision": types.number,
+    "money": types.number,
+    "timestamp": types.date,
+    "timestamptz": types.date,
+    "timestamp without time zone": types.date,
+    "timestamp with time zone": types.date,
+    "date": types.date,
+    "time": types.string,
+    "timetz": types.string,
+    "time without time zone": types.string,
+    "time with time zone": types.string,
+    "uuid": types.string,
+    "xml": types.string,
+    "json": types.any,
+    "jsonb": types.any,
+    "ARRAY": types.array,
+};

package/operations/get_pieces.ts

@@ -0,0 +1,63 @@
+export interface ParameterizedPieces {
+    condition: string;
+    inputs: any[];
+}
+
+export interface InsertPieces {
+    columns: string;
+    values: string;
+    inputs: any[];
+}
+
+/**
+ * Converts an object into a parameterized WHERE/SET condition string.
+ * Generates $1, $2... positional placeholders to prevent SQL injection.
+ *
+ * @param data - The key/value pairs to parameterize
+ * @param startIndex - Starting positional index for parameters (default: 0, meaning first param is $1)
+ * @returns Parameterized condition and ordered input values array
+ */
+export const getConditionPieces = (data: Record<string, any> = {}, startIndex: number = 0): ParameterizedPieces => {
+    const keys = Object.keys(data).filter(key => isValidIdentifier(key));
+    const condition = keys.map((key, i) => `${key} = $${startIndex + i + 1}`).join(' AND ');
+    const inputs: any[] = keys.map(key => sanitizeValue(data[key]));
+    return { condition, inputs };
+};
+
+/**
+ * Converts an object into a parameterized INSERT fragment.
+ *
+ * @param data - The key/value pairs to insert
+ * @returns Column names, positional placeholders ($1, $2...), and ordered input values
+ */
+export const getInsertPieces = (data: Record<string, any> = {}): InsertPieces => {
+    const keys = Object.keys(data).filter(key => isValidIdentifier(key));
+    const columns = keys.join(', ');
+    const values = keys.map((_, i) => `$${i + 1}`).join(', ');
+    const inputs: any[] = keys.map(key => sanitizeValue(data[key]));
+    return { columns, values, inputs };
+};
+
+/**
+ * Validates that a SQL identifier (table/column name) contains only safe characters.
+ */
+export const isValidIdentifier = (name: string): boolean => {
+    return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+};
+
+/**
+ * Sanitizes a value for use as a SQL parameter.
+ * Converts undefined/NaN to null, booleans to true/false, bigint to string.
+ */
+function sanitizeValue(value: any): any {
+    if (value === undefined || value === null || (typeof value === 'number' && isNaN(value))) {
+        return null;
+    }
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (typeof value === 'bigint') {
+        return value.toString();
+    }
+    return value;
+}

package/operations/log.ts

@@ -0,0 +1,27 @@
+import 'colors';
+
+/**
+ * This function is used to display logs in the console.
+ * 
+ * @param title - The title of the log.
+ * @param alt - The alternative title of the log.
+ * @param description - The description of the log.
+ * @param file - The file of the log.
+     */
+function Log(title: string | null, alt: string | null, description: string | null, file: string | null = null): void {
+    title = title ? (title.length > 20 ? title.substring(0, 20) + '...' : title) : null;
+    alt = alt ? (alt.length > 20 ? alt.substring(0, 20) + '...' : alt) : null;
+    description = description ? (description.length > 50 ? description.substring(0, 50) + '...' : description) : null;
+    file = file ? (file.length > 20 ? file.substring(0, 20) + '...' : file) : null;
+
+    let time = (new Date().toLocaleTimeString()).gray;
+    title = title ? ('[' + title.trim() + ']').cyan.bold as any as string : null;
+    alt = alt ? ('(' + alt.trim() + ')').magenta : null;
+    description = description ? description.trim().green : null;
+    file = file ? ('[' + file.trim() + ']').gray : 'easy-postgresql'.gray;
+
+    const data = [time, title, alt, description, file].filter(f => f !== null && f !== undefined);
+    console.log(data.join(' '));
+}
+
+export const log = Log;

package/operations/procedure_execute.ts

@@ -0,0 +1,58 @@
+import { getPool } from './connect_to_server';
+import { config } from './config';
+import { log } from './log';
+
+interface ProcedureResult {
+    status: number;
+    message: string;
+    data: any[] | any | null;
+}
+
+interface ProcedureReference {
+    [key: string]: any;
+}
+
+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';
+}
+
+/**
+ * Executes a stored procedure/function in the database.
+ *
+ * @param procedureName - The name of the stored procedure/function
+ * @param reference - The input parameters for the procedure
+ * @param useRecordsets - If true, wraps rows in array; otherwise returns rows directly
+ * @returns Promise<ProcedureResult>
+ */
+export const executeProcedure = async (
+    procedureName: string,
+    reference: ProcedureReference = {},
+    useRecordsets: boolean = false
+): Promise<ProcedureResult> => {
+    try {
+        const keys = Object.keys(reference);
+        const values = keys.map(k => reference[k]);
+        const params = keys.map((_, i) => `$${i + 1}::${pgTypeOf(values[i])}`).join(', ');
+        const queryText = `SELECT * FROM ${procedureName}(${params})`;
+
+        const pool = getPool();
+        const client = await pool.connect();
+        try {
+            const result = await client.query(queryText, values);
+            const data = useRecordsets ? [result.rows] : result.rows;
+            return { status: 200, message: 'Success', data };
+        } finally {
+            client.release();
+        }
+    } catch (err) {
+        if (config.get.logingMode()) {
+            log('Procedure', procedureName, err instanceof Error ? err.message : String(err));
+        }
+        return { status: 500, message: 'Error', data: null };
+    }
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "easy-postgresql",
+  "version": "0.0.1",
+  "description": "This is a simple and easy to use postgresql library for node.js",
+  "main": "dist/database.js",
+  "types": "dist/database.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/database.d.ts",
+      "default": "./dist/database.js"
+    }
+  },
+  "scripts": {
+    "start": "node dist/simple/server.js",
+    "dev": "nodemon dist/simple/server.js",
+    "build": "tsc",
+    "watch": "tsc -w",
+    "test-ts": "ts-node simple/test.ts",
+    "test-js": "node simple/test.js",
+    "test": "npm run test-ts && npm run test-js",
+    "update": "update-modules"
+  },
+  "author": {
+    "name": "cihatksm",
+    "email": "me@cihatksm.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cihatksm/easy-postgresql.git"
+  },
+  "keywords": [
+    "cihatksm",
+    "cihatksm.com",
+    "sql",
+    "easy",
+    "easypostgresql",
+    "easy-postgresql",
+    "postgresql",
+    "node-postgresql",
+    "database"
+  ],
+  "dependencies": {
+    "colors": "^1.4.0",
+    "pg": "^8.16.0",
+    "update-modules": "^0.3.3"
+  },
+  "devDependencies": {
+    "@types/pg": "^8.16.0",
+    "@types/node": "^26.1.1",
+    "nodemon": "^3.1.14",
+    "ts-node": "^10.9.2",
+    "typescript": "^7.0.2"
+  }
+}