@andymic/pigeon 1.6.0 → 2.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andymic/pigeon",
-  "version": "1.6.0",
+  "version": "2.0.1",
   "author": "Andreas Michael <ateasm03@gmail.com>",
   "description": "Pigeon is a TypeScript-based tool for generating TypeScript classes and methods from PostgreSQL database schemas.",
   "keywords": [
@@ -35,5 +35,5 @@
     "pg": "^8.16.0",
     "prompt-sync": "^4.2.0"
   },
-  "gitHead": "6562b7ff32a6a9dd9f0ef108026c198db32b0aa9"
+  "gitHead": "565fcc64621e0c076f77933662e6f82969ef62e6"
 }

package/src/index.js

@@ -1,4 +1,4 @@
-import { arrayMaker, getCombinations, getJSType, getPGType, nameBeautifier, queryMaker, runQuery, singularize, sleep, tabsInserter } from "./utils.js";
+import { arrayMaker, getJSType, getPGType, nameBeautifier, runQuery, singularize, sleep, } from "./utils.js";
 import prompt from "prompt-sync";
 import fs from "node:fs";
 import * as path from "node:path";
@@ -268,10 +268,27 @@ export function runGeneration(dir, db, tables, enums) {
         const dirResult = createDir(path.join(dir, schema));
         if (dirResult instanceof PigeonError)
             return dirResult;
+        fs.writeFileSync(path.join(dir, schema, "index.ts"), createIndex(db));
     }
     for (const table of tables) {
-        let ts = clientMaker(0, db);
-        ts += "\n\n";
+        let ts = "";
+        const imports = [];
+        for (const column of table.columns) {
+            if (column.isForeign && column.foreignColumn && column.foreignTable && column.foreignSchema) {
+                if ((table.schema === column.foreignSchema) && (table.name === column.foreignTable))
+                    continue;
+                if (imports.includes(column.foreignSchema + "/" + column.foreignTable))
+                    continue;
+                ts += "import {get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "} from \".";
+                if (table.schema !== column.foreignSchema)
+                    ts += "./" + column.foreignSchema;
+                ts += "/" + column.foreignTable + ".js\";\n";
+                imports.push(column.foreignSchema + "/" + column.foreignTable);
+            }
+        }
+        if (imports.length !== 0)
+            ts += "\n";
+        ts += "import query from \"./index.js\";\n\n";
         if (enums) {
             for (const cEnum of enums) {
                 for (const column of table.columns) {
@@ -292,85 +309,75 @@ export function runGeneration(dir, db, tables, enums) {
         }
         ts += createClass(table.name, table.columns);
         ts += "\n\n";
-        ts += createGetAll(table.schema, table.name, table.columns);
+        ts += createGetTypecast(table.columns);
+        ts += "\n\n";
+        ts += createGet(table.schema, table.name, table.columns);
         ts += "\n\n";
         let keys = [];
         for (const column of table.columns)
             if (column.isPrimary || column.isForeign || column.isUnique)
                 keys.push(column);
-        for (const keyCombination of getCombinations(keys)) {
-            ts += createGet(table.schema, table.name, table.columns, keyCombination);
-            ts += "\n\n";
-        }
-        let nonDefaults = [];
-        let softDefaults = [];
-        let hardDefaults = [];
+        let required = [];
+        let optional = [];
+        let autoGenerated = [];
         for (const column of table.columns) {
             if (column.defaultValue === null && !column.isIdentity)
-                nonDefaults.push(column);
+                required.push(column);
             else if ((column.defaultValue !== null && !column.defaultValue.includes("nextval")) || (column.isIdentity && column.identityGeneration === "BY DEFAULT"))
-                softDefaults.push(column);
+                optional.push(column);
             else if ((column.defaultValue !== null && column.defaultValue.includes("nextval")) || (column.isIdentity && column.identityGeneration === "ALWAYS"))
-                hardDefaults.push(column);
-        }
-        ts += createAdd(table.schema, table.name, nonDefaults, [], hardDefaults.concat(softDefaults)) + "\n\n";
-        for (const softCombination of getCombinations(softDefaults))
-            ts += createAdd(table.schema, table.name, nonDefaults, softCombination, hardDefaults.concat(softDefaults.filter(n => !getCombinations(softDefaults).includes([n])))) + "\n\n";
-        for (const keyCombination of getCombinations(keys)) {
-            ts += createUpdate(table.schema, table.name, table.columns, keyCombination);
-            ts += "\n\n";
-        }
-        for (const column of table.columns) {
-            ts += createDelete(table.schema, table.name, column, table.columns);
-            ts += "\n\n";
+                autoGenerated.push(column);
         }
-        ts = ts.slice(0, -2);
-        const regex = /import ({?.*?}?) from "(.*?)";\n/g;
-        let importObjects = [];
-        const matches = ts.matchAll(regex);
-        let charOffset = 0;
-        for (const match of matches) {
-            ts = ts.slice(0, match.index - charOffset) + ts.slice(match.index - charOffset + match[0].length);
-            charOffset += match[0].length;
-            let fileExists = false;
-            const isBrackets = match[1][0] === "{";
-            for (const object of importObjects) {
-                if (object.file === match[2] && isBrackets === object.brackets) {
-                    fileExists = true;
-                    object.functions.push(match[1]);
-                }
-            }
-            if (!fileExists) {
-                importObjects.push({
-                    file: match[2],
-                    functions: [match[1]],
-                    brackets: isBrackets
-                });
-            }
-        }
-        let importString = "";
-        for (const object of importObjects) {
-            object.functions = [...new Set(object.functions)];
-            importString += "import ";
-            if (object.brackets)
-                importString += "{";
-            for (const fun of object.functions) {
-                if (object.brackets)
-                    importString += fun.slice(1, -1) + ", ";
-                else
-                    importString += fun + ", ";
-            }
-            importString = importString.slice(0, -2);
-            if (object.brackets)
-                importString += "}";
-            importString += " from \"" + object.file + "\";\n";
-        }
-        importString += "import pg from \"pg\";\n\n";
-        importString += "const {Client} = pg;\n\n";
-        ts = importString + ts;
+        ts += createAdd(table.schema, table.name, required, optional, autoGenerated, imports.length !== 0);
+        ts += "\n\n";
+        ts += createUpdate(table.schema, table.name, table.columns, autoGenerated, imports.length !== 0);
+        ts += "\n\n";
+        ts += createDelete(table.schema, table.name, table.columns);
         fs.writeFileSync(path.join(dir, table.schema, table.name + ".ts"), ts);
     }
 }
+function createIndex(db) {
+    let text = "";
+    text += "import pg from \"pg\";\n";
+    text += "const { Client, Pool } = pg;\n";
+    text += "\n";
+    text += "const pool = new Pool({\n";
+    text += "\thost: \"" + db.host + "\",\n";
+    text += "\tport: " + db.port + ",\n";
+    text += "\tdatabase: \"" + db.db + "\",\n";
+    text += "\tuser: \"" + db.user + "\",\n";
+    text += "\tpassword: \"" + db.pass + "\",\n";
+    text += "\tmax: 20,\n";
+    text += "\tidleTimeoutMillis: 30000,\n";
+    text += "\tconnectionTimeoutMillis: 2000\n";
+    text += "});\n";
+    text += "\n";
+    text += "const client = new Client({\n";
+    text += "\thost: \"" + db.host + "\",\n";
+    text += "\tport: " + db.port + ",\n";
+    text += "\tdatabase: \"" + db.db + "\",\n";
+    text += "\tuser: \"" + db.user + "\",\n";
+    text += "\tpassword: \"" + db.pass + "\"\n";
+    text += "});\n";
+    text += "\n";
+    text += "/*\n";
+    text += "export default (sql: string, params: any[]) => pool.query(sql, params);\n";
+    text += "*/\n";
+    text += "\n";
+    text += "/*\n";
+    text += "export default async (sql: string, params: any[]) => {\n";
+    text += "\ttry {\n";
+    text += "\t\tawait client.connect();\n";
+    text += "\t\treturn await client.query(sql, params);\n";
+    text += "\t} catch (error: any) {\n";
+    text += "\t\tthrow error;\n";
+    text += "\t} finally {\n";
+    text += "\t\tawait client.end();\n";
+    text += "\t}\n";
+    text += "}\n";
+    text += "*/";
+    return text;
+}
 function createClass(tableName, columns) {
     let text = "";
     text += "export class " + singularize(nameBeautifier(tableName)).replaceAll(" ", "") + " {\n";
@@ -439,157 +446,153 @@ function createClass(tableName, columns) {
     text += "}";
     return text;
 }
-export function clientMaker(baseTabs, db) {
-    let text = "";
-    text += tabsInserter(baseTabs) + "const client = new Client({\n";
-    text += tabsInserter(baseTabs + 1) + "host: \"" + db.host + "\",\n";
-    text += tabsInserter(baseTabs + 1) + "port: " + db.port + ",\n";
-    text += tabsInserter(baseTabs + 1) + "database: \"" + db.db + "\",\n";
-    text += tabsInserter(baseTabs + 1) + "user: \"" + db.user + "\",\n";
-    text += tabsInserter(baseTabs + 1) + "password: \"" + db.pass + "\"\n";
-    text += tabsInserter(baseTabs) + "});";
-    return text;
-}
-function createGetAll(tableSchema, tableName, columns) {
+function createGetTypecast(columns) {
     let text = "";
-    const className = singularize(nameBeautifier(tableName)).replaceAll(" ", "");
-    const varName = nameBeautifier(tableName).replaceAll(" ", "")[0].toLowerCase() + nameBeautifier(tableName).replaceAll(" ", "").substring(1);
-    text += "/**\n";
-    text += " * Gets all " + className + " objects from the database.\n";
-    text += " *\n";
-    text += " * @returns {Promise<" + className + "[]>} - A Promise object returning an array of " + nameBeautifier(tableName) + ".\n";
-    text += " */\n";
-    text += "export async function getAll" + nameBeautifier(tableName).replaceAll(" ", "") + "(): Promise<" + className + "[]> {\n";
-    text += queryMaker(1, varName, "SELECT * FROM " + tableSchema + "." + tableName + ";", "");
-    text += "\n\n";
-    text += arrayMaker(1, varName, className, columns) + "\n";
-    text += "\treturn " + varName + ";\n";
+    text += "function getTypecast(columnName: string): string {\n";
+    text += "\tswitch (columnName) {\n";
+    const typeColumns = columns.toSorted((a, b) => a.pgType.localeCompare(b.pgType));
+    for (let i = 0; i < typeColumns.length; i++) {
+        text += "\t\tcase \"" + typeColumns[i].name + "\":\n";
+        if (i !== typeColumns.length - 1 && typeColumns[i].pgType === typeColumns[i + 1].pgType)
+            continue;
+        text += "\t\t\treturn \"::" + typeColumns[i].pgType + "\";\n";
+    }
+    text += "\t}\n";
+    text += "\treturn \"\";\n";
     text += "}";
     return text;
 }
-function createGet(tableSchema, tableName, columns, keys) {
+function createGet(tableSchema, tableName, columns) {
     let text = "";
     const className = singularize(nameBeautifier(tableName)).replaceAll(" ", "");
     const varName = nameBeautifier(tableName).replaceAll(" ", "")[0].toLowerCase() + nameBeautifier(tableName).replaceAll(" ", "").substring(1);
+    const functionName = "get" + nameBeautifier(tableName).replaceAll(" ", "");
     text += "/**\n";
-    text += " * Gets " + className + " objects from the database by ";
-    for (const key of keys)
-        text += key.name + " and ";
-    text = text.slice(0, -5) + ".\n";
+    text += " * Finds and retrieves " + singularize(nameBeautifier(tableName)) + " objects from the database based on specified criteria.\n";
     text += " *\n";
-    for (const key of keys)
-        text += " * @param {" + key.jsType + "} " + key.name + " - The " + nameBeautifier(key.name) + " of the " + nameBeautifier(tableName) + " table.\n";
-    text += " * @returns {Promise<" + className + "[]>} - A Promise object returning an array of " + nameBeautifier(tableName) + ".\n";
+    text += " * @async\n";
+    text += " * @function " + functionName + "\n";
+    text += " * @param {Partial<" + className + ">} criteria - An object containing properties of the " + className + " to filter by.\n";
+    text += " * Only " + nameBeautifier(tableName).toLowerCase() + " matching all provided criteria will be returned.\n";
+    text += " * An empty object or undefined criteria will fetch all " + className + " objects.\n";
+    text += " * @returns {Promise<" + className + "[]>} - A Promise object returning an array of " + nameBeautifier(tableName) + " matching the criteria.\n";
     text += " */\n";
-    text += "export async function get" + nameBeautifier(tableName).replaceAll(" ", "") + "By";
-    for (const key of keys)
-        text += nameBeautifier(key.name).replaceAll(" ", "") + "And";
-    text = text.slice(0, -3);
-    text += "(";
-    for (const key of keys)
-        text += key.name + ": " + key.jsType + ", ";
-    text = text.slice(0, -2);
-    text += "): Promise<" + className + "[]> {\n";
-    text += "\tif (";
-    for (const key of keys)
-        text += key.name + " === undefined || ";
-    text = text.slice(0, -4);
-    text += ")\n" + "\t\tthrow \"Missing Parameters\";\n\n";
-    let query = "SELECT * FROM " + tableSchema + "." + tableName + " WHERE ";
-    let parameters = "";
-    for (let i = 0; i < keys.length; i++) {
-        query += keys[i].name + " = " + "$" + (i + 1) + "::" + keys[i].pgType + " AND ";
-        parameters += keys[i].name + ", ";
-    }
-    query = query.slice(0, -5) + ";";
-    parameters = parameters.slice(0, -2);
-    text += queryMaker(1, varName, query, parameters);
-    text += "\n\n";
+    text += "export async function get" + nameBeautifier(tableName).replaceAll(" ", "") + "(criteria: Partial<" + className + ">): Promise<" + className + "[]> {\n";
+    text += "\tconst whereClauses: string[] = [];\n";
+    text += "\tconst values: any[] = [];\n";
+    text += "\tlet paramIndex = 1;\n";
+    text += "\n";
+    text += "\tfor (const key in criteria) {\n";
+    text += "\t\tif (Object.prototype.hasOwnProperty.call(criteria, key) && criteria[key as keyof typeof criteria] !== undefined) {\n";
+    text += "\t\t\twhereClauses.push(\"\\\"\" + key + \"\\\" = $\" + paramIndex + getTypecast(key));\n";
+    text += "\t\t\tvalues.push(criteria[key as keyof typeof criteria]);\n";
+    text += "\t\t\tparamIndex++;\n";
+    text += "\t\t}\n";
+    text += "\t}\n";
+    text += "\n";
+    text += "\tlet sql = \"SELECT * FROM " + tableSchema + "." + tableName + "\";\n";
+    text += "\tif (whereClauses.length > 0)\n";
+    text += "\t\tsql += \" WHERE \" + whereClauses.join(\" AND \");\n";
+    text += "\tsql += \";\";\n";
+    text += "\n";
+    text += "\tconst " + varName + "Query = await query(sql, values);\n";
     text += arrayMaker(1, varName, className, columns) + "\n";
     text += "\treturn " + varName + ";\n";
     text += "}";
     return text;
 }
-function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaults) {
+function createAdd(tableSchema, tableName, required, optional, autoGenerated, hasForeign) {
     let text = "";
     const className = singularize(nameBeautifier(tableName)).replaceAll(" ", "");
-    let hasForeign = false;
-    for (const column of nonDefaults.concat(softDefaults).concat(hardDefaults).sort((a, b) => a.position - b.position)) {
-        if (column.isForeign && column.foreignColumn && column.foreignTable && column.foreignSchema) {
-            hasForeign = true;
-            if ((tableSchema === column.foreignSchema) && (tableName === column.foreignTable))
-                continue;
-            text += "import {get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "By" + nameBeautifier(column.foreignColumn).replaceAll(" ", "") + "} from \".";
-            if (tableSchema !== column.foreignSchema)
-                text += "./" + column.foreignSchema;
-            text += "/" + column.foreignTable + ".js\";\n";
-        }
-    }
+    const paramName = className.slice(0, 1).toLowerCase() + className.slice(1);
+    const functionName = "add" + singularize(nameBeautifier(tableName).replaceAll(" ", ""));
+    const dataType = "Omit<" + className + ", '" + autoGenerated.concat(optional).map((column) => {
+        return column.name;
+    }).join("\' | \'") + "'>" + (optional.length > 0 ? " & Partial<Pick<" + className + ", '" + optional.map((column) => {
+        return column.name;
+    }).join("\' | \'") + "'>>" : "");
+    const editableColumns = required.concat(optional);
     text += "/**\n";
-    text += " * Adds the provided " + className + " object to the database.\n";
+    text += " * Adds a new " + singularize(nameBeautifier(tableName)) + " object to the database.\n";
+    if (autoGenerated.length !== 0)
+        text += " * The field" + (autoGenerated.length > 1 ? "s" : "") + " `" + autoGenerated.map((column) => {
+            return column.name;
+        }).join("\`, \`") + "` " + (autoGenerated.length > 1 ? "are" : "is") + " auto-generated.\n";
+    if (optional.length !== 0)
+        text += " * The field" + (optional.length > 1 ? "s" : "") + " `" + optional.map((column) => {
+            return column.name;
+        }).join("`, `") + "` " + (optional.length > 1 ? "are" : "is") + " optional and will use database defaults if not provided.\n";
     text += " *\n";
-    let columns = nonDefaults.concat(softDefaults);
-    columns.sort((a, b) => a.position - b.position);
-    for (const column of columns)
-        text += " * @param {" + column.jsType + "} " + column.name + " - The " + nameBeautifier(column.name) + " to be inserted into the " + nameBeautifier(tableName) + " table.\n";
-    text += " * @returns {Promise<" + className + ">} - A Promise object returning the inserted " + nameBeautifier(tableName) + ".\n";
+    text += " * @async\n";
+    text += " * @function " + functionName + "\n";
+    text += " * @param {" + dataType + "} " + paramName + " - An object containing the data for the new " + className + ".\n";
+    if (required.length !== 0)
+        text += " * - The " + (required.length > 1 ? "properties" : "property") + " from `" + className + "\` like \`" + required.map((column) => {
+            return column.name;
+        }).join("`, `") + "` " + (required.length > 1 ? "are" : "is") + " required.\n";
+    const nullable = editableColumns.filter((column) => column.isNullable);
+    if (nullable.length !== 0)
+        text += " * - The nullable " + (nullable.length > 1 ? "fields" : "field") + " like \`" + nullable.map((column) => {
+            return column.name;
+        }).join("`, `") + "` can be provided as `null` or " + (nullable.length > 1 ? "their" : "its") + " respective type.\n";
+    if (optional.length !== 0)
+        text += " * - The field" + (optional.length > 1 ? "s" : "") + " `" + optional.map((column) => {
+            return column.name;
+        }).join("`, `") + "` " + (optional.length > 1 ? "are" : "is") + " optional.\n";
+    text += " * @returns {Promise<" + className + ">} A Promise returning the newly created " + className + " object.\n";
     if (hasForeign) {
-        text += " * @throws string An exception in the case of the ";
-        for (const column of columns)
+        text += " * @throws {Error} An exception in the case of the ";
+        for (const column of editableColumns)
             if (column.isForeign)
                 text += nameBeautifier(column.name) + " or the ";
         text = text.slice(0, -8);
-        text += " not existing in their table.\n";
+        text += " not existing in their table, or if other pre-insertion validation fails.\n";
     }
     text += " */\n";
-    text += "export async function add" + className;
-    if (softDefaults.length > 0) {
-        text += "With";
-        for (const softDefault of softDefaults)
-            text += nameBeautifier(softDefault.name).replaceAll(" ", "") + "And";
-        text = text.slice(0, -3);
-    }
-    text += "(";
-    for (const column of columns)
-        text += column.name + ": " + column.jsType + ", ";
-    text = text.slice(0, -2);
-    text += "): Promise<" + className + "> {\n";
+    text += "export async function " + functionName + "(" + paramName + ": " + dataType.replaceAll("'", "\"") + "): Promise<" + className + "> {\n";
     if (hasForeign) {
-        for (const column of columns) {
+        for (const column of editableColumns) {
             if (column.isForeign && column.foreignColumn && column.foreignTable && column.foreignSchema) {
                 const name = nameBeautifier(column.name).replaceAll(" ", "");
                 if (column.isNullable) {
-                    text += "\tif (" + column.name + ") {\n";
-                    text += "\t\tconst verify" + name + " = await get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "By" + nameBeautifier(column.foreignColumn).replaceAll(" ", "") + "(" + column.name + ");\n";
+                    text += "\tif (" + paramName + "." + column.name + " !== undefined && " + paramName + "." + column.name + " !== null) {\n";
+                    text += "\t\tconst verify" + name + " = await get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "({" + column.foreignColumn + ": " + paramName + "." + column.name + "});\n";
                     text += "\t\tif (verify" + name + ".length === 0)\n";
-                    text += "\t\t\tthrow \"The " + nameBeautifier(column.name) + " provided does not exist.\";\n";
+                    text += "\t\t\tthrow new Error(\"The " + nameBeautifier(column.name) + " provided does not exist.\");\n";
                     text += "\t}\n\n";
                 }
                 else {
-                    text += "\tconst verify" + name + " = await get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "By" + nameBeautifier(column.foreignColumn).replaceAll(" ", "") + "(" + column.name + ");\n";
+                    text += "\tconst verify" + name + " = await get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "({" + column.foreignColumn + ": " + paramName + "." + column.name + "});\n";
                     text += "\tif (verify" + name + ".length === 0)\n";
-                    text += "\t\tthrow \"The " + nameBeautifier(column.name) + " provided does not exist.\";\n\n";
+                    text += "\t\t\tthrow new Error(\"The " + nameBeautifier(column.name) + " provided does not exist.\");\n\n";
                 }
             }
         }
     }
-    let query = "INSERT INTO " + tableSchema + "." + tableName + " (";
-    for (const column of columns)
-        query += column.name + ", ";
-    query = query.slice(0, -2);
-    query += ") VALUES (";
-    let parameters = "";
-    for (let i = 0; i < columns.length; i++) {
-        query += "$" + (i + 1) + "::" + columns[i].pgType + ", ";
-        parameters += columns[i].name + ", ";
-    }
-    query = query.slice(0, -2);
-    parameters = parameters.slice(0, -2);
-    query += ") RETURNING *;";
-    text += queryMaker(1, "insert", query, parameters);
-    text += "\n\n";
+    text += "\tconst intoClauses: string[] = [];\n";
+    text += "\tconst valuesClauses:  string[] = [];\n";
+    text += "\tconst values: any[] = [];\n";
+    text += "\tlet paramIndex = 1;\n";
+    text += "\n";
+    text += "\tfor (const key in " + paramName + ") {\n";
+    text += "\t\tif (Object.prototype.hasOwnProperty.call(" + paramName + ", key)) {\n";
+    text += "\t\t\tconst value = " + paramName + "[key as keyof typeof " + paramName + "];\n";
+    text += "\t\t\tif (value !== undefined) {\n";
+    text += "\t\t\t\tintoClauses.push(\"\\\"\"+ key + \"\\\"\");\n";
+    text += "\t\t\t\tvalues.push(value);\n";
+    text += "\t\t\t\tvaluesClauses.push(\"$\" + paramIndex + getTypecast(key));\n";
+    text += "\t\t\t\tparamIndex++;\n";
+    text += "\t\t\t}\n";
+    text += "\t\t}\n";
+    text += "\t}\n";
+    text += "\n";
+    text += "\tif (intoClauses.length === 0)\n";
+    text += "\t\tthrow new Error(\"No data provided for " + paramName + " creation.\");\n";
+    text += "\n";
+    text += "\tconst sql = \"INSERT INTO " + tableSchema + "." + tableName + " (\" + intoClauses.join(\", \") + \") VALUES (\" + valuesClauses.join(\", \") + \") RETURNING *;\";\n";
+    text += "\tconst insertQuery = await query(sql, values);\n";
     text += "\treturn new " + className + "(\n";
-    columns = columns.concat(hardDefaults);
+    let columns = editableColumns.concat(autoGenerated);
     columns = [...new Set(columns)];
     columns.sort((a, b) => a.position - b.position);
     for (const column of columns)
@@ -600,116 +603,117 @@ function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaul
     text += "}";
     return text;
 }
-function createUpdate(tableSchema, tableName, columns, keys) {
-    const optionals = columns.filter(column => !keys.includes(column));
+function createUpdate(tableSchema, tableName, columns, autoGenerated, hasForeign) {
     let text = "";
     const className = singularize(nameBeautifier(tableName)).replaceAll(" ", "");
-    let hasForeign = false;
-    for (const column of columns) {
-        if (column.isForeign && column.foreignColumn && column.foreignTable && column.foreignSchema) {
-            hasForeign = true;
-            if ((tableSchema === column.foreignSchema) && (tableName === column.foreignTable))
-                continue;
-            text += "import {get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "By" + nameBeautifier(column.foreignColumn).replaceAll(" ", "") + "} from \".";
-            if (tableSchema !== column.foreignSchema)
-                text += "./" + column.foreignSchema;
-            text += "/" + column.foreignTable + ".js\";\n";
-        }
-    }
+    const functionName = "update" + nameBeautifier(tableName).replaceAll(" ", "");
+    const criteriaType = "Partial<" + className + ">";
+    const updatesType = "Partial<" + (autoGenerated.length !== 0 ? "Omit<" + className + ", '" + autoGenerated.map((column) => {
+        return column.name;
+    }).join("' | '") + "'>" : className) + ">";
     text += "/**\n";
-    text += " * Updates the " + className + " objects from the database by ";
-    for (const key of keys)
-        text += key.name + " and ";
-    text = text.slice(0, -5) + ".\n";
+    text += " * Updates existing " + className + " objects in the database based on the specified criteria.\n";
     text += " *\n";
-    for (const key of keys)
-        text += " * @param {" + key.jsType.replace(" | null", "") + "} " + key.name + " - The " + nameBeautifier(key.name) + " of the " + nameBeautifier(tableName) + " table to be updated.\n";
-    for (const optional of optionals)
-        text += " * @param {" + optional.jsType + " | undefined} " + optional.name + " - The value of the" + nameBeautifier(optional.name) + " of the " + nameBeautifier(tableName) + " table to be updated.\n";
-    text += " * @returns {Promise<" + className + ">} - A Promise object returning the updated " + nameBeautifier(tableName) + ".\n";
-    if (hasForeign) {
-        text += " * @throws string An exception in the case of the ";
-        for (const column of columns)
-            if (column.isForeign)
-                text += nameBeautifier(column.name) + " or the ";
-        text = text.slice(0, -8);
-        text += " not existing in their table.\n";
-    }
+    text += " * @async\n";
+    text += " * @function " + functionName + "\n";
+    text += " * @param {" + criteriaType + "} criteria - An object defining the conditions for which " + nameBeautifier(tableName) + " to update.\n";
+    text += " * An empty object would typically mean updating ALL " + nameBeautifier(tableName) + ", which should be handled with caution or disallowed.\n";
+    text += " * @param {" + updatesType + "} updates - An object containing the new values for the fields to be updated.\n";
+    text += " * Only fields present in this object will be updated.\n";
+    text += " * @returns {Promise<" + className + "[]>} A promise that resolves to an array of the updated " + className + " objects.\n";
+    text += " * Returns an empty array if no records matched the criteria or if no rows were updated.\n";
+    text += " * @throws {Error} If updates object is empty" + (hasForeign ? ", or if foreign key checks fail for provided update values" : "") + ".\n";
     text += " */\n";
-    text += "export async function update" + className + "By";
-    for (const key of keys)
-        text += nameBeautifier(key.name).replaceAll(" ", "") + "And";
-    text = text.slice(0, -3);
-    text += "(";
-    for (const key of keys)
-        text += key.name + ": " + key.jsType.replace(" | null", "") + ", ";
-    for (const optional of optionals)
-        text += optional.name + "?: " + optional.jsType + " | undefined, ";
-    text = text.slice(0, -2);
-    text += "): Promise<" + className + "> {\n";
+    text += "export async function update" + nameBeautifier(tableName).replaceAll(" ", "") + "(criteria: " + criteriaType.replaceAll("'", "\"") + ", updates: " + updatesType.replaceAll("'", "\"") + "): Promise<" + className + "[]> {\n";
+    text += "\tif (Object.keys(updates).length === 0)\n";
+    text += "\t\tthrow new Error(\"No update data provided.\");\n";
+    text += "\n";
     if (hasForeign) {
         for (const column of columns) {
             if (column.isForeign && column.foreignColumn && column.foreignTable && column.foreignSchema) {
                 const name = nameBeautifier(column.name).replaceAll(" ", "");
-                if (!keys.includes(column)) {
-                    text += "\tif (" + column.name + ") {\n";
-                    text += "\t\tconst verify" + name + " = await get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "By" + nameBeautifier(column.foreignColumn).replaceAll(" ", "") + "(" + column.name + ");\n";
-                    text += "\t\tif (verify" + name + ".length === 0)\n";
-                    text += "\t\t\tthrow \"The " + nameBeautifier(column.name) + " provided does not exist.\";\n";
-                    text += "\t}\n\n";
+                if (column.isNullable) {
+                    text += "\tif (updates." + column.name + " !== undefined && updates." + column.name + " !== null) {\n";
                 }
                 else {
-                    text += "\tconst verify" + name + " = await get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "By" + nameBeautifier(column.foreignColumn).replaceAll(" ", "") + "(" + column.name + ");\n";
-                    text += "\tif (verify" + name + ".length === 0)\n";
-                    text += "\t\tthrow \"The " + nameBeautifier(column.name) + " provided does not exist.\";\n\n";
+                    text += "\tif (updates." + column.name + " !== undefined) {\n";
                 }
+                text += "\t\tconst verify" + name + " = await get" + nameBeautifier(column.foreignTable).replaceAll(" ", "") + "({" + column.foreignColumn + ": updates." + column.name + "});\n";
+                text += "\t\tif (verify" + name + ".length === 0)\n";
+                text += "\t\t\tthrow new Error(\"The " + nameBeautifier(column.name) + " provided does not exist.\");\n";
+                text += "\t}\n\n";
             }
         }
     }
-    text += "\tlet set = \"\";\n";
-    for (let optional of optionals) {
-        text += "\tif (" + optional.name + " !== undefined)\n";
-        text += "\t\tset += \"" + optional.name + " = '\" + " + optional.name + " + \"', \";\n";
-    }
-    text += "\tset = set.slice(0, -2);\n";
-    let parameters = "";
-    let query = "UPDATE " + tableSchema + "." + tableName + ` SET \$\{set\} WHERE `;
-    for (let i = 0; i < keys.length; i++) {
-        query += keys[i].name + " = " + "$" + (i + 1) + "::" + keys[i].pgType + " AND ";
-        parameters += keys[i].name + ", ";
-    }
-    parameters = parameters.slice(0, -2);
-    query = query.slice(0, -5) + " RETURNING *;";
-    text += queryMaker(1, "update", query, parameters);
-    text += "\n\n";
-    text += "\treturn new " + className + "(\n";
-    for (const column of columns)
-        text += "\t\tupdateQuery.rows[0]." + column.name + ",\n";
-    text = text.slice(0, -2);
+    text += "\tconst setClauses: string[] = [];\n";
+    text += "\tconst whereClauses: string[] = [];\n";
+    text += "\tconst values: any[] = [];\n";
+    text += "\tlet paramIndex = 1;\n";
     text += "\n";
-    text += "\t);\n";
+    text += "\tfor (const key in updates) {\n";
+    text += "\t\tif (Object.prototype.hasOwnProperty.call(updates, key)) {\n";
+    text += "\t\t\tconst value = updates[key as keyof typeof updates];\n";
+    text += "\t\t\tif (value !== undefined) {\n";
+    text += "\t\t\t\tvalues.push(value);\n";
+    text += "\t\t\t\tsetClauses.push(\"\\\"\"+ key + \"\\\" = $\" + paramIndex + (value !== null ? getTypecast(key) : \"\"));\n";
+    text += "\t\t\t\tparamIndex++;\n";
+    text += "\t\t\t}\n";
+    text += "\t\t}\n";
+    text += "\t}\n";
+    text += "\n";
+    text += "\tfor (const key in criteria) {\n";
+    text += "\t\tif (Object.prototype.hasOwnProperty.call(criteria, key)) {\n";
+    text += "\t\t\tconst value = criteria[key as keyof typeof criteria];\n";
+    text += "\t\t\tif (value !== undefined) {\n";
+    text += "\t\t\t\tvalues.push(value);\n";
+    text += "\t\t\t\twhereClauses.push(\"\\\"\"+ key + \"\\\" = $\" + paramIndex + (value !== null ? getTypecast(key) : \"\"));\n";
+    text += "\t\t\t\tparamIndex++;\n";
+    text += "\t\t\t}\n";
+    text += "\t\t}\n";
+    text += "\t}\n";
+    text += "\n";
+    text += "\tlet sql = \"UPDATE " + tableSchema + "." + tableName + " SET \" + setClauses.join(\", \") + (whereClauses.length !== 0 ? \" WHERE \" + whereClauses.join(\" AND \") : \"\") + \" RETURNING *;\";\n";
+    text += "\n";
+    text += "\tconst updateQuery = await query(sql, values);\n";
+    text += arrayMaker(1, "update", className, columns) + "\n";
+    text += "\treturn update;\n";
     text += "}";
     return text;
 }
-function createDelete(tableSchema, tableName, column, columns) {
+function createDelete(tableSchema, tableName, columns) {
     let text = "";
     const className = singularize(nameBeautifier(tableName)).replaceAll(" ", "");
+    const functionName = "delete" + nameBeautifier(tableName).replaceAll(" ", "");
     text += "/**\n";
-    text += " * Deletes the " + className + " objects from the database by the value of its " + nameBeautifier(column.name) + ".\n";
+    text += " * Deletes the " + className + " records from the database based on specified criteria.\n";
     text += " *\n";
-    text += " * @param {" + column.jsType.replace(" | null", "") + "} " + column.name + " - The value of the" + nameBeautifier(column.name) + " of the " + nameBeautifier(tableName) + " table to be updated.\n";
-    text += " * @returns {Promise<" + className + ">} - A Promise object returning the deleted " + nameBeautifier(tableName) + ".\n";
+    text += " * @async\n";
+    text += " * @function " + functionName + "\n";
+    text += " * @param {Partial<" + className + ">} criteria - An object containing properties of the " + className + " to filter by for deletion.\n";
+    text += " * An empty object would typically mean deleting ALL " + nameBeautifier(tableName) + ", which should be handled with caution or disallowed.\n";
+    text += " * Only accounts matching all provided criteria will be deleted.\n";
+    text += " * @returns {Promise<" + className + "[]>} - A Promise object returning the deleted " + nameBeautifier(tableName) + ".\n";
     text += " */\n";
-    text += "export async function delete" + className + "By" + nameBeautifier(column.name).replaceAll(" ", "") + "(" + column.name + ": " + column.jsType.replace(" | null", "") + "): Promise<" + className + "> {\n";
-    const query = "DELETE FROM " + tableSchema + "." + tableName + " WHERE " + column.name + " = $1::" + column.pgType + "RETURNING *;";
-    text += queryMaker(1, "delete", query, column.name);
-    text += "\n\n";
-    text += "\treturn new " + className + "(\n";
-    for (const column of columns)
-        text += "\t\tdeleteQuery.rows[0]." + column.name + ",\n";
-    text = text.slice(0, -2);
+    text += "export async function " + functionName + "(criteria : Partial<" + className + ">): Promise<" + className + "[]> {\n";
+    text += "\tconst whereClauses: string[] = [];\n";
+    text += "\tconst values: any[] = [];\n";
+    text += "\tlet paramIndex = 1;\n";
+    text += "\tfor (const key in criteria) {\n";
+    text += "\t\tif (Object.prototype.hasOwnProperty.call(criteria, key)) {\n";
+    text += "\t\t\tconst value = criteria[key as keyof typeof criteria];\n";
+    text += "\t\t\tif (value !== undefined) {\n";
+    text += "\t\t\t\tvalues.push(value);\n";
+    text += "\t\t\t\twhereClauses.push(\"\\\"\"+ key + \"\\\" = $\" + paramIndex + (value !== null ? getTypecast(key) : \"\"));\n";
+    text += "\t\t\t\tparamIndex++;\n";
+    text += "\t\t\t}\n";
+    text += "\t\t}\n";
+    text += "\t}\n";
     text += "\n";
-    text += "\t);\n";
+    text += "\tlet sql = \"DELETE FROM " + tableSchema + "." + tableName + "\" + (whereClauses.length !== 0 ? \" WHERE \" + whereClauses.join(\" AND \") : \"\") + \" RETURNING *;\";\n";
+    text += "\n";
+    text += "\tconst removeQuery = await query(sql, values);\n";
+    text += arrayMaker(1, "remove", className, columns) + "\n";
+    text += "\treturn remove;\n";
     text += "}";
     return text;
 }

package/src/pgAdmin.js

@@ -57,7 +57,7 @@ export function tableProcessing(tables) {
             if (column.attnotnull)
                 isNullable = false;
             const jsType = getJSType(types.dataType, types.udtName, isNullable);
-            const pgType = getPGType(types.dataType);
+            const pgType = getPGType(types.dataType, types.udtName);
             if (column.cltype.includes("serial"))
                 column.defval = "nextval('" + data.name + "_" + column.name + "_seq'::regclass)";
             let columnDefault;

package/src/utils.js

@@ -69,45 +69,6 @@ export function tabsInserter(tabNumber) {
         tabs += "\t";
     return tabs;
 }
-export function queryMaker(baseTabs, variableName, command, parameters) {
-    let query = "";
-    query += tabsInserter(baseTabs) + "let " + variableName + "Query;\n";
-    query += tabsInserter(baseTabs) + "try {\n";
-    query += tabsInserter(baseTabs + 1) + "await client.connect();\n";
-    query += tabsInserter(baseTabs + 1) + variableName + "Query = await client.query(`\n";
-    query += queryBeautifier(baseTabs + 2, command);
-    query += tabsInserter(baseTabs + 1) + "`, [" + parameters + "]);\n";
-    query += tabsInserter(baseTabs) + "} catch (error: any) {\n";
-    query += tabsInserter(baseTabs + 1) + "throw error;\n";
-    query += tabsInserter(baseTabs) + "} finally {\n";
-    query += tabsInserter(baseTabs + 1) + "await client.end();\n";
-    query += tabsInserter(baseTabs) + "}";
-    return query;
-}
-function queryBeautifier(baseTabs, command) {
-    const regex = /(?=((?:SELECT|INSERT|UPDATE|DELETE|FROM|WHERE|AND|VALUES|RETURNING).*?)(?:FROM|WHERE|AND|VALUES|RETURNING|;))/g;
-    let match;
-    let lines = [];
-    while ((match = regex.exec(command)) !== null) {
-        lines.push(match[1]);
-        regex.lastIndex = regex.lastIndex + 1;
-    }
-    for (let i = 0; i < lines.length; i++)
-        if (lines[i][lines[i].length - 1] === " ")
-            lines[i] = lines[i].slice(0, -1);
-    lines[lines.length - 1] = lines[lines.length - 1] + ";";
-    let maxLength = 0;
-    for (const line of lines)
-        if (line.split(" ")[0].length > maxLength)
-            maxLength = line.split(" ")[0].length;
-    for (let i = 0; i < lines.length; i++)
-        if (lines[i].split(" ")[0].length < maxLength)
-            lines[i] = " ".repeat(maxLength - lines[i].split(" ")[0].length) + lines[i];
-    let formated = "";
-    for (const line of lines)
-        formated += tabsInserter(baseTabs) + line + "\n";
-    return formated;
-}
 export function arrayMaker(baseTabs, variableName, className, columns) {
     let array = "";
     array += tabsInserter(baseTabs) + "let " + variableName + ": " + className + "[] = [];\n";
@@ -131,21 +92,6 @@ export function singularize(word) {
     };
     return word.replace(new RegExp(`(${Object.keys(endings).join('|')})$`), r => endings[r]);
 }
-export function getCombinations(valuesArray) {
-    let combinations = [];
-    let temp = [];
-    let possibleCombinations = Math.pow(2, valuesArray.length);
-    for (let i = 0; i < possibleCombinations; i++) {
-        temp = [];
-        for (let j = 0; j < valuesArray.length; j++)
-            if ((i & Math.pow(2, j)))
-                temp.push(valuesArray[j]);
-        if (temp.length > 0)
-            combinations.push(temp);
-    }
-    combinations.sort((a, b) => a.length - b.length);
-    return combinations;
-}
 export function getJSType(dataType, udtName, isNullable) {
     dataType = dataType.replace("serial", "int");
     if (dataType === "int")