@andymic/pigeon 1.4.2 → 1.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andymic/pigeon",
-  "version": "1.4.2",
+  "version": "1.6.0",
   "author": "Andreas Michael <ateasm03@gmail.com>",
   "description": "Pigeon is a TypeScript-based tool for generating TypeScript classes and methods from PostgreSQL database schemas.",
   "keywords": [
@@ -32,8 +32,8 @@
   },
   "dependencies": {
     "meow": "^13.2.0",
-    "pg": "^8.15.6",
+    "pg": "^8.16.0",
     "prompt-sync": "^4.2.0"
   },
-  "gitHead": "04b72fd9eb0dde3a4005146b38d899b9655f0d83"
+  "gitHead": "6562b7ff32a6a9dd9f0ef108026c198db32b0aa9"
 }

package/src/index.js

@@ -1,4 +1,4 @@
-import { arrayMaker, consoleMessage, getCombinations, getType, nameBeautifier, queryMaker, runQuery, singularize, sleep, tabsInserter } from "./utils.js";
+import { arrayMaker, getCombinations, getJSType, getPGType, nameBeautifier, queryMaker, runQuery, singularize, sleep, tabsInserter } from "./utils.js";
 import prompt from "prompt-sync";
 import fs from "node:fs";
 import * as path from "node:path";
@@ -27,20 +27,46 @@ export class Database {
         this.pass = pass;
     }
 }
+export class Column {
+    name;
+    position;
+    defaultValue;
+    isNullable;
+    jsType;
+    pgType;
+    isIdentity;
+    identityGeneration;
+    isPrimary;
+    isUnique;
+    isForeign;
+    foreignSchema;
+    foreignTable;
+    foreignColumn;
+    constructor(name, position, defaultValue, isNullable, jsType, pgType, isIdentity, identityGeneration, isPrimary, isUnique, isForeign, foreignSchema, foreignTable, foreignColumn) {
+        this.name = name;
+        this.position = position;
+        this.defaultValue = defaultValue;
+        this.isNullable = isNullable;
+        this.jsType = jsType;
+        this.pgType = pgType;
+        this.isIdentity = isIdentity;
+        this.identityGeneration = identityGeneration;
+        this.isPrimary = isPrimary;
+        this.isUnique = isUnique;
+        this.isForeign = isForeign;
+        this.foreignSchema = foreignSchema;
+        this.foreignTable = foreignTable;
+        this.foreignColumn = foreignColumn;
+    }
+}
 export class Table {
-    table_schema;
-    table_name;
+    name;
+    schema;
     columns = [];
-    primaryKey;
-    foreignKeys;
-    unique;
-    constructor(table_schema, table_name, columns, primaryKey, foreignKeys, unique) {
-        this.table_schema = table_schema;
-        this.table_name = table_name;
+    constructor(name, schema, columns) {
+        this.name = name;
+        this.schema = schema;
         this.columns = columns;
-        this.primaryKey = primaryKey;
-        this.foreignKeys = foreignKeys;
-        this.unique = unique;
     }
 }
 export class Enum {
@@ -51,54 +77,6 @@ export class Enum {
         this.labels = labels;
     }
 }
-export class ColumnQueryRow {
-    column_name;
-    ordinal_position;
-    column_default;
-    is_nullable;
-    data_type;
-    udt_name;
-    is_identity;
-    identity_generation;
-    constructor(column_name, ordinal_position, column_default, is_nullable, data_type, udt_name, is_identity, identity_generation) {
-        this.column_name = column_name;
-        this.ordinal_position = ordinal_position;
-        this.column_default = column_default;
-        this.is_nullable = is_nullable;
-        this.data_type = data_type;
-        this.udt_name = udt_name;
-        this.is_identity = is_identity;
-        this.identity_generation = identity_generation;
-    }
-}
-export class PrimaryKeyQueryRow {
-    column_name;
-    constructor(column_name) {
-        this.column_name = column_name;
-    }
-}
-export class ForeignKeyQueryRow {
-    local_schema;
-    local_table;
-    local_column;
-    foreign_schema;
-    foreign_table;
-    foreign_column;
-    constructor(local_schema, local_table, local_column, foreign_schema, foreign_table, foreign_column) {
-        this.local_schema = local_schema;
-        this.local_table = local_table;
-        this.local_column = local_column;
-        this.foreign_schema = foreign_schema;
-        this.foreign_table = foreign_table;
-        this.foreign_column = foreign_column;
-    }
-}
-export class UniqueQueryRow {
-    columns;
-    constructor(columns) {
-        this.columns = columns;
-    }
-}
 function createDir(dirPath) {
     if (fs.existsSync(dirPath))
         return new PigeonError(1, "", new Error("Generation directory already exists. Add the --force flag if you want to overwrite it."));
@@ -210,6 +188,10 @@ export async function queryDB(db) {
                AND tc.table_name = $2::varchar;`, [table.table_schema, table.table_name], db);
         if (typeof pKeyQuery === "undefined")
             return new PigeonError(1, "", new Error("An SQL error has occurred."));
+        for (const pKey of pKeyQuery.rows)
+            for (const column of columnQuery.rows)
+                if (pKey.column_name === column.column_name)
+                    column.isPrimary = true;
         const fKeyQuery = await runQuery(`SELECT kcu1.table_schema AS local_schema,
                     kcu1.table_name   AS local_table,
                     kcu1.column_name  AS local_column,
@@ -231,6 +213,16 @@ export async function queryDB(db) {
                AND kcu1.table_name = $2::varchar;`, [table.table_schema, table.table_name], db);
         if (typeof fKeyQuery === "undefined")
             return new PigeonError(1, "", new Error("An SQL error has occurred."));
+        for (const fKey of fKeyQuery.rows) {
+            for (const column of columnQuery.rows) {
+                if (fKey.local_schema === table.table_schema && fKey.local_table === table.table_name && fKey.local_column === column.column_name) {
+                    column.isForeign = true;
+                    column.foreignSchema = fKey.foreign_schema;
+                    column.foreignTable = fKey.foreign_table;
+                    column.foreignColumn = fKey.foreign_column;
+                }
+            }
+        }
         const uniqueQuery = await runQuery(`SELECT array_agg(a.attname) AS columns
              FROM pg_constraint AS c
                       CROSS JOIN LATERAL unnest(c.conkey) AS k(c)
@@ -245,7 +237,15 @@ export async function queryDB(db) {
         let uniques = [];
         if (uniqueQuery.rowCount > 0)
             uniques = uniqueQuery.rows[0].columns.slice(1, -1).split(",");
-        tables.push(new Table(table.table_schema, table.table_name, columnQuery.rows, pKeyQuery.rows[0], fKeyQuery.rows, { columns: uniques }));
+        for (const unique of uniques)
+            for (const column of columnQuery.rows)
+                if (unique === column.column_name)
+                    column.isUnique = true;
+        const columns = [];
+        for (const column of columnQuery.rows) {
+            columns.push(new Column(column.column_name, column.ordinal_position, column.column_default, column.is_nullable === "YES", getJSType(column.data_type, column.udt_name, column.is_nullable === "YES"), getPGType(column.data_type, column.udt_name), column.is_identity === "YES", column.identity_generation, column.isPrimary || false, column.isUnique || false, column.isForeign || false, column.foreignSchema, column.foreignTable, column.foreignColumn));
+        }
+        tables.push(new Table(table.table_name, table.table_schema, columns));
     }
     return {
         tables: tables,
@@ -253,16 +253,16 @@ export async function queryDB(db) {
     };
 }
 export function runGeneration(dir, db, tables, enums) {
-    if (!tables)
+    if (tables.length === 0)
         return new PigeonError(1, "", new Error("No tables were found."));
     const dirResult = createDir(dir);
     if (dirResult instanceof PigeonError)
         return dirResult;
     let schemas = [];
     for (const table of tables) {
-        if (schemas.includes(table.table_schema))
+        if (schemas.includes(table.schema))
             continue;
-        schemas.push(table.table_schema);
+        schemas.push(table.schema);
     }
     for (const schema of schemas) {
         const dirResult = createDir(path.join(dir, schema));
@@ -275,7 +275,7 @@ export function runGeneration(dir, db, tables, enums) {
         if (enums) {
             for (const cEnum of enums) {
                 for (const column of table.columns) {
-                    if (cEnum.name === column.udt_name) {
+                    if (column.pgType.includes(cEnum.name)) {
                         const enumName = nameBeautifier(cEnum.name).replaceAll(" ", "");
                         ts += "/**\n An Enum representing the " + nameBeautifier(cEnum.name).toLowerCase() + ".\n * @readonly\n * @enum {string}\n */\n";
                         ts += "class " + enumName + " {\n";
@@ -290,37 +290,40 @@ export function runGeneration(dir, db, tables, enums) {
                 }
             }
         }
-        ts += createClass(table.table_name, table.columns, table.primaryKey?.column_name, table.foreignKeys);
+        ts += createClass(table.name, table.columns);
         ts += "\n\n";
-        ts += createGetAll(table.table_schema, table.table_name, table.columns);
+        ts += createGetAll(table.schema, table.name, table.columns);
         ts += "\n\n";
         let keys = [];
-        if (table.primaryKey)
-            keys.push(table.primaryKey.column_name);
-        if (table.foreignKeys)
-            for (const fKey of table.foreignKeys)
-                keys.push(fKey.local_column.replaceAll(" ", ""));
-        if (table.unique)
-            keys = keys.concat(table.unique.columns);
-        keys = [...new Set(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.table_schema, table.table_name, table.columns, keyCombination);
+            ts += createGet(table.schema, table.name, table.columns, keyCombination);
             ts += "\n\n";
         }
         let nonDefaults = [];
         let softDefaults = [];
         let hardDefaults = [];
         for (const column of table.columns) {
-            if (column.column_default === null && column.is_identity === "NO")
+            if (column.defaultValue === null && !column.isIdentity)
                 nonDefaults.push(column);
-            else if ((column.column_default !== null && !column.column_default.includes("nextval")) || (column.is_identity === "YES" && column.identity_generation === "BY DEFAULT"))
+            else if ((column.defaultValue !== null && !column.defaultValue.includes("nextval")) || (column.isIdentity && column.identityGeneration === "BY DEFAULT"))
                 softDefaults.push(column);
-            else if ((column.column_default !== null && column.column_default.includes("nextval")) || (column.is_identity === "YES" && column.identity_generation === "ALWAYS"))
+            else if ((column.defaultValue !== null && column.defaultValue.includes("nextval")) || (column.isIdentity && column.identityGeneration === "ALWAYS"))
                 hardDefaults.push(column);
         }
-        ts += createAdd(table.table_schema, table.table_name, nonDefaults, [], hardDefaults.concat(softDefaults), table.foreignKeys) + "\n\n";
+        ts += createAdd(table.schema, table.name, nonDefaults, [], hardDefaults.concat(softDefaults)) + "\n\n";
         for (const softCombination of getCombinations(softDefaults))
-            ts += createAdd(table.table_schema, table.table_name, nonDefaults, softCombination, hardDefaults.concat(softDefaults.filter(n => !getCombinations(softDefaults).includes([n]))), table.foreignKeys) + "\n\n";
+            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";
+        }
         ts = ts.slice(0, -2);
         const regex = /import ({?.*?}?) from "(.*?)";\n/g;
         let importObjects = [];
@@ -365,47 +368,36 @@ export function runGeneration(dir, db, tables, enums) {
         importString += "import pg from \"pg\";\n\n";
         importString += "const {Client} = pg;\n\n";
         ts = importString + ts;
-        fs.writeFileSync(path.join(dir, table.table_schema, table.table_name + ".ts"), ts);
+        fs.writeFileSync(path.join(dir, table.schema, table.name + ".ts"), ts);
     }
 }
-function createClass(tableName, columns, primaryKey, foreignKeys) {
+function createClass(tableName, columns) {
     let text = "";
     text += "export class " + singularize(nameBeautifier(tableName)).replaceAll(" ", "") + " {\n";
     for (const column of columns) {
-        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
-        if (column.is_nullable === "YES")
-            dataType += " | undefined";
-        let isPrimaryKey = false;
-        if (column.column_name === primaryKey)
-            isPrimaryKey = true;
-        let foreignKeyIndex;
-        if (foreignKeys)
-            for (let i = 0; i < foreignKeys.length; i++)
-                if (foreignKeys[i].local_column === column.column_name)
-                    foreignKeyIndex = i;
         text += "\t/**\n";
-        if (isPrimaryKey)
-            text += "\t * A primary key representing the " + nameBeautifier(column.column_name) + " for the " + nameBeautifier(tableName) + " table.\n";
-        else if (foreignKeys && foreignKeyIndex)
-            text += "\t * A foreign key representing the " + nameBeautifier(column.column_name) + " for the " + nameBeautifier(tableName) + " table and referencing the " + nameBeautifier(foreignKeys[foreignKeyIndex].foreign_column) + " in the " + nameBeautifier(foreignKeys[foreignKeyIndex].foreign_table) + " table in the " + nameBeautifier(foreignKeys[foreignKeyIndex].foreign_schema) + " schema.\n";
-        else if (column.column_name.toLowerCase().startsWith("is_"))
-            text += "\t * Indicates whether this record in the table " + nameBeautifier(tableName) + " is currently " + nameBeautifier(column.column_name.slice(3)).toLowerCase() + ".\n";
+        if (column.isPrimary)
+            text += "\t * A primary key representing the " + nameBeautifier(column.name) + " for the " + nameBeautifier(tableName) + " table.\n";
+        else if (column.isForeign && column.foreignColumn && column.foreignTable && column.foreignSchema)
+            text += "\t * A foreign key representing the " + nameBeautifier(column.name) + " for the " + nameBeautifier(tableName) + " table and referencing the " + nameBeautifier(column.foreignColumn) + " in the " + nameBeautifier(column.foreignTable) + " table in the " + nameBeautifier(column.foreignSchema) + " schema.\n";
+        else if (column.name.toLowerCase().startsWith("is_"))
+            text += "\t * Indicates whether this record in the table " + nameBeautifier(tableName) + " is currently " + nameBeautifier(column.name.slice(3)).toLowerCase() + ".\n";
         else
-            text += "\t * The " + nameBeautifier(column.column_name) + " for the " + nameBeautifier(tableName) + " table.\n";
-        text += "\t * @type {" + dataType + "}\n";
+            text += "\t * The " + nameBeautifier(column.name) + " for the " + nameBeautifier(tableName) + " table.\n";
+        text += "\t * @type {" + column.jsType + "}\n";
         text += "\t */\n";
-        text += "\t" + column.column_name + ": " + dataType;
-        if (column.column_default !== null) {
-            let columnDefault = column.column_default.split("::")[0];
-            let type = column.column_default.split("::")[1];
+        text += "\t" + column.name + ": " + column.jsType;
+        if (column.defaultValue !== null) {
+            let columnDefault = column.defaultValue.split("::")[0];
+            let type = column.defaultValue.split("::")[1];
             if (!columnDefault.includes("nextval")) {
-                if (dataType === "Date") {
+                if (column.jsType === "Date") {
                     if (columnDefault.toLowerCase() === "now()")
                         text += " = new Date()";
                     else
                         text += " = new Date(" + columnDefault.replace(" ", "T") + ")";
                 }
-                else if (dataType === "number" || dataType === "boolean")
+                else if (column.jsType.includes("number") || column.jsType.includes("boolean"))
                     text += " = " + columnDefault;
                 else if (type) {
                     if (jsTypes.get(type) === "string")
@@ -419,7 +411,7 @@ function createClass(tableName, columns, primaryKey, foreignKeys) {
                     }
                 }
                 else
-                    text += " = \"" + column.column_default + "\"";
+                    text += " = \"" + column.defaultValue + "\"";
             }
         }
         text += ";\n";
@@ -429,30 +421,20 @@ function createClass(tableName, columns, primaryKey, foreignKeys) {
     text += "\t * Creates a new object for the " + nameBeautifier(tableName) + " table.\n";
     text += "\t * \n";
     for (const column of columns) {
-        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
-        text += "\t * ";
-        text += "@param {" + dataType;
-        if (column.is_nullable === "YES")
-            text += " | undefined";
-        text += "} " + column.column_name;
-        if (!column.column_name.toLowerCase().startsWith("is_"))
-            text += " - The " + nameBeautifier(column.column_name) + " of the " + nameBeautifier(tableName) + " table. \n";
+        text += "\t * @param {" + column.jsType + "} " + column.name;
+        if (!column.name.toLowerCase().startsWith("is_"))
+            text += " - The " + nameBeautifier(column.name) + " of the " + nameBeautifier(tableName) + " table. \n";
         else
-            text += " - Indicates whether this record in the table " + nameBeautifier(tableName) + " is currently " + nameBeautifier(column.column_name.slice(3)).toLowerCase() + ".\n";
+            text += " - Indicates whether this record in the table " + nameBeautifier(tableName) + " is currently " + nameBeautifier(column.name.slice(3)).toLowerCase() + ".\n";
     }
     text += "\t */\n";
     text += "\tconstructor(";
-    for (const column of columns) {
-        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
-        text += column.column_name + ": " + dataType;
-        if (column.is_nullable === "YES")
-            text += " | undefined";
-        text += ", ";
-    }
+    for (const column of columns)
+        text += column.name + ": " + column.jsType + ", ";
     text = text.slice(0, -2);
     text += ") {\n";
     for (const column of columns)
-        text += "\t\tthis." + column.column_name + " = " + column.column_name + ";\n";
+        text += "\t\tthis." + column.name + " = " + column.name + ";\n";
     text += "\t}\n";
     text += "}";
     return text;
@@ -492,53 +474,32 @@ function createGet(tableSchema, tableName, columns, keys) {
     text += "/**\n";
     text += " * Gets " + className + " objects from the database by ";
     for (const key of keys)
-        text += key + " and ";
+        text += key.name + " and ";
     text = text.slice(0, -5) + ".\n";
     text += " *\n";
-    for (const key of keys) {
-        const column = columns.find(column => column.column_name === key);
-        if (!column) {
-            consoleMessage("WRN", `Key ${key} was not found in the columns of table ${tableName}.`);
-            continue;
-        }
-        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
-        text += " * ";
-        text += "@param {" + dataType;
-        text += "} " + column.column_name;
-        text += " - The " + nameBeautifier(column.column_name) + " of the " + nameBeautifier(tableName) + " table.\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 += " */\n";
     text += "export async function get" + nameBeautifier(tableName).replaceAll(" ", "") + "By";
     for (const key of keys)
-        text += nameBeautifier(key).replaceAll(" ", "") + "And";
+        text += nameBeautifier(key.name).replaceAll(" ", "") + "And";
     text = text.slice(0, -3);
     text += "(";
-    for (const key of keys) {
-        const column = columns.find(column => column.column_name === key);
-        if (!column) {
-            consoleMessage("WRN", `Key ${key} was not found in the columns of table ${tableName}.`);
-            continue;
-        }
-        text += key + ": " + getType(column.data_type, column.udt_name) + ", ";
-    }
+    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 + " === undefined || ";
+        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++) {
-        const column = columns.find(column => column.column_name === keys[i]);
-        if (!column) {
-            consoleMessage("WRN", `Key ${keys[i]} was not found in the columns of table ${tableName}.`);
-            continue;
-        }
-        query += keys[i] + " = " + "$" + (i + 1) + "::" + (column.data_type || column.udt_name) + " AND ";
-        parameters += keys[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);
@@ -549,38 +510,34 @@ function createGet(tableSchema, tableName, columns, keys) {
     text += "}";
     return text;
 }
-function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaults, foreignKeys) {
+function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaults) {
     let text = "";
     const className = singularize(nameBeautifier(tableName)).replaceAll(" ", "");
-    if (foreignKeys) {
-        for (const foreignKey of foreignKeys) {
-            if ((tableSchema === foreignKey.foreign_schema) && (tableName === foreignKey.foreign_table))
+    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(foreignKey.foreign_table).replaceAll(" ", "") + "By" + nameBeautifier(foreignKey.foreign_column).replaceAll(" ", "") + "} from \".";
-            if (tableSchema !== foreignKey.foreign_schema)
-                text += "./" + foreignKey.foreign_schema;
-            text += "/" + foreignKey.foreign_table + ".js\";\n";
+            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";
         }
     }
     text += "/**\n";
     text += " * Adds the provided " + className + " object to the database.\n";
     text += " *\n";
     let columns = nonDefaults.concat(softDefaults);
-    columns.sort((a, b) => a.ordinal_position - b.ordinal_position);
-    for (const column of columns) {
-        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
-        text += " * ";
-        text += "@param {" + dataType;
-        if (column.is_nullable === "YES")
-            text += " | undefined";
-        text += "} " + column.column_name;
-        text += " - The " + nameBeautifier(column.column_name) + " to be inserted into the " + nameBeautifier(tableName) + " table.\n";
-    }
+    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";
-    if (foreignKeys && foreignKeys.length > 0) {
+    if (hasForeign) {
         text += " * @throws string An exception in the case of the ";
-        for (const foreignKey of foreignKeys)
-            text += nameBeautifier(foreignKey.local_column) + " or 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";
     }
@@ -589,54 +546,42 @@ function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaul
     if (softDefaults.length > 0) {
         text += "With";
         for (const softDefault of softDefaults)
-            text += nameBeautifier(softDefault.column_name).replaceAll(" ", "") + "And";
+            text += nameBeautifier(softDefault.name).replaceAll(" ", "") + "And";
         text = text.slice(0, -3);
     }
     text += "(";
-    for (const column of columns) {
-        let dataType = getType(column.data_type, column.udt_name);
-        text += column.column_name + ": " + dataType;
-        if (column.is_nullable === "YES")
-            text += " | undefined";
-        text += ", ";
-    }
+    for (const column of columns)
+        text += column.name + ": " + column.jsType + ", ";
     text = text.slice(0, -2);
     text += "): Promise<" + className + "> {\n";
-    if (foreignKeys) {
-        for (const foreignKey of foreignKeys) {
-            const column = columns.find(column => column.column_name === foreignKey.local_column);
-            if (!column) {
-                consoleMessage("WRN", `Key ${foreignKey} was not found in the columns of table ${tableName}.`);
-                continue;
-            }
-            if (column.is_nullable === "YES") {
-                text += "\tif (" + foreignKey.local_column + ") {\n";
-                text += "\t\tconst verify" + nameBeautifier(foreignKey.local_column).replaceAll(" ", "") + " = await get" + nameBeautifier(foreignKey.foreign_table).replaceAll(" ", "") + "By" + nameBeautifier(foreignKey.foreign_column).replaceAll(" ", "") + "(" + foreignKey.local_column + ");\n";
-                text += "\t\tif (verify" + nameBeautifier(foreignKey.local_column).replaceAll(" ", "") + ".length === 0)\n";
-                text += "\t\t\tthrow \"The " + nameBeautifier(foreignKey.local_column) + " provided does not exist.\";\n";
-                text += "\t}\n\n";
-            }
-            else {
-                text += "\tconst verify" + nameBeautifier(foreignKey.local_column).replaceAll(" ", "") + " = await get" + nameBeautifier(foreignKey.foreign_table).replaceAll(" ", "") + "By" + nameBeautifier(foreignKey.foreign_column).replaceAll(" ", "") + "(" + foreignKey.local_column + ");\n";
-                text += "\tif (verify" + nameBeautifier(foreignKey.local_column).replaceAll(" ", "") + ".length === 0)\n";
-                text += "\t\tthrow \"The " + nameBeautifier(foreignKey.local_column) + " provided does not exist.\";\n\n";
+    if (hasForeign) {
+        for (const column of columns) {
+            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 += "\t\tif (verify" + name + ".length === 0)\n";
+                    text += "\t\t\tthrow \"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 += "\tif (verify" + name + ".length === 0)\n";
+                    text += "\t\tthrow \"The " + nameBeautifier(column.name) + " provided does not exist.\";\n\n";
+                }
             }
         }
     }
     let query = "INSERT INTO " + tableSchema + "." + tableName + " (";
     for (const column of columns)
-        query += column.column_name + ", ";
+        query += column.name + ", ";
     query = query.slice(0, -2);
     query += ") VALUES (";
     let parameters = "";
     for (let i = 0; i < columns.length; i++) {
-        let dataType = columns[i].udt_name;
-        if (dataType[0] === "_")
-            dataType = dataType.slice(1) + "[]";
-        else if (columns[i].data_type !== "USER-DEFINED")
-            dataType = columns[i].data_type;
-        query += "$" + (i + 1) + "::" + dataType + ", ";
-        parameters += columns[i].column_name + ", ";
+        query += "$" + (i + 1) + "::" + columns[i].pgType + ", ";
+        parameters += columns[i].name + ", ";
     }
     query = query.slice(0, -2);
     parameters = parameters.slice(0, -2);
@@ -646,9 +591,122 @@ function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaul
     text += "\treturn new " + className + "(\n";
     columns = columns.concat(hardDefaults);
     columns = [...new Set(columns)];
-    columns.sort((a, b) => a.ordinal_position - b.ordinal_position);
+    columns.sort((a, b) => a.position - b.position);
+    for (const column of columns)
+        text += "\t\tinsertQuery.rows[0]." + column.name + ",\n";
+    text = text.slice(0, -2);
+    text += "\n";
+    text += "\t);\n";
+    text += "}";
+    return text;
+}
+function createUpdate(tableSchema, tableName, columns, keys) {
+    const optionals = columns.filter(column => !keys.includes(column));
+    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";
+        }
+    }
+    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 += " *\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 += " */\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";
+    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";
+                }
+                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 += "\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 += "\n";
+    text += "\t);\n";
+    text += "}";
+    return text;
+}
+function createDelete(tableSchema, tableName, column, columns) {
+    let text = "";
+    const className = singularize(nameBeautifier(tableName)).replaceAll(" ", "");
+    text += "/**\n";
+    text += " * Deletes the " + className + " objects from the database by the value of its " + nameBeautifier(column.name) + ".\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 += " */\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\tinsertQuery.rows[0]." + column.column_name + ",\n";
+        text += "\t\tdeleteQuery.rows[0]." + column.name + ",\n";
     text = text.slice(0, -2);
     text += "\n";
     text += "\t);\n";

package/src/maps.js

@@ -1,64 +1,64 @@
 export const jsTypes = new Map([
-    ["bigint", "number"],
-    ["int8", "number"],
-    ["bigserial", "number"],
-    ["serial8", "number"],
-    ["bit", "Array"],
-    ["bit varying", "Array"],
-    ["varbit", "Array"],
-    ["boolean", "boolean"],
-    ["bool", "boolean"],
-    ["box", ""],
-    ["bytea", "Array"],
-    ["character", "string"],
-    ["char", "string"],
-    ["character varying", "string"],
-    ["varchar", "string"],
-    ["cidr", "string"],
-    ["circle", ""],
-    ["date", "Date"],
-    ["double precision", "number"],
-    ["float8", "number"],
-    ["inet", "string"],
+    ["smallint", "number"],
+    ["int2", "number"],
     ["integer", "number"],
     ["int", "number"],
-    ["int4", "number"],
-    ["interval", ""],
-    ["json", "string"],
-    ["jsonb", "Array"],
-    ["line", ""],
-    ["lseg", ""],
-    ["macaddr", "string"],
-    ["macaddr8", "string"],
-    ["money", "number"],
-    ["numeric", "number"],
-    ["decimal", "number"],
-    ["path", ""],
-    ["pg_lsn", "number"],
-    ["pg_snapshot", ""],
-    ["point", ""],
-    ["polygon", ""],
+    ["bigint", "string"],
+    ["int8", "string"],
     ["real", "number"],
     ["float4", "number"],
-    ["smallint", "number"],
-    ["int2", "number"],
+    ["double precision", "number"],
+    ["float8", "string"],
+    ["numeric", "string"],
+    ["decimal", "string"],
+    ["money", "string"],
     ["smallserial", "number"],
     ["serial2", "number"],
     ["serial", "number"],
-    ["string4", "number"],
+    ["serial4", "number"],
+    ["bigserial", "string"],
+    ["serial8", "string"],
+    ["character", "string"],
+    ["char", "string"],
+    ["character varying", "string"],
+    ["varchar", "string"],
     ["text", "string"],
-    ["time", ""],
-    ["time without time zone", ""],
-    ["time with time zone", ""],
-    ["timetz", ""],
-    ["timestamp", "Date"],
+    ["name", "string"],
+    ["bytea", "Buffer"],
+    ["bit", "string"],
+    ["bit varying", "string"],
+    ["varbit", "string"],
+    ["boolean", "boolean"],
+    ["bool", "boolean"],
+    ["date", "Date"],
+    ["time without time zone", "string"],
+    ["time", "string"],
+    ["time with time zone", "string"],
+    ["timetz", "string"],
     ["timestamp without time zone", "Date"],
+    ["timestamp", "Date"],
     ["timestamp with time zone", "Date"],
     ["timestamptz", "Date"],
-    ["tsquery", ""],
-    ["tsvector", ""],
-    ["txid_snapshot", ""],
+    ["interval", "object"],
+    ["box", "object"],
+    ["circle", "object"],
+    ["line", "object"],
+    ["lseg", "object"],
+    ["path", "object"],
+    ["point", "object"],
+    ["polygon", "object"],
+    ["cidr", "string"],
+    ["inet", "string"],
+    ["macaddr", "string"],
+    ["macaddr8", "string"],
+    ["json", "object"],
+    ["jsonb", "object"],
     ["uuid", "string"],
+    ["tsquery", "string"],
+    ["tsvector", "string"],
+    ["pg_lsn", "string"],
+    ["pg_snapshot", "string"],
+    ["txid_snapshot", "string"],
     ["xml", "string"],
 ]);
 export const udtTypes = new Map([
@@ -83,6 +83,7 @@ export const udtTypes = new Map([
     ["character varying", "varchar"],
     ["varchar", "varchar"],
     ["text", "text"],
+    ["name", "name"],
     ["bytea", "bytea"],
     ["bit", "bit"],
     ["bit varying", "varbit"],

package/src/pgAdmin.js

@@ -1,5 +1,5 @@
-import { ColumnQueryRow, ForeignKeyQueryRow, PigeonError, PrimaryKeyQueryRow, Table, UniqueQueryRow } from "./index.js";
-import { udtTypes } from "./maps.js";
+import { Column, PigeonError, Table, } from "./index.js";
+import { getJSType, getPGType, getTypesByDataType } from "./utils.js";
 function objectToArray(json) {
     let arrayJSON = "";
     let enteredObject = false;
@@ -52,66 +52,57 @@ export function tableProcessing(tables) {
         const columns = [];
         let ordinalPossition = 1;
         for (const column of data.columns) {
-            let dataType = column.cltype;
-            let udtType;
-            udtType = udtTypes.get(dataType);
-            if (!udtType) {
-                if (dataType.endsWith("[]")) {
-                    udtType = "_" + udtTypes.get(dataType.slice(0, -2));
-                    dataType = "ARRAY";
-                }
-                else {
-                    udtType = dataType;
-                    dataType = "USER-DEFINED";
-                }
-            }
-            if (dataType === "smallserial" || dataType === "serial" || dataType === "bigserial") {
-                dataType = dataType.replace("serial", "int");
-                if (dataType === "int")
-                    dataType = "integer";
-                column.defval = "nextval('" + data.name + "_" + column.name + "_seq'::regclass)";
-            }
-            let isNullable;
+            const types = getTypesByDataType(column.cltype);
+            let isNullable = true;
             if (column.attnotnull)
-                isNullable = "NO";
-            else
-                isNullable = "YES";
+                isNullable = false;
+            const jsType = getJSType(types.dataType, types.udtName, isNullable);
+            const pgType = getPGType(types.dataType);
+            if (column.cltype.includes("serial"))
+                column.defval = "nextval('" + data.name + "_" + column.name + "_seq'::regclass)";
             let columnDefault;
             if (column.defval !== "" && column.defval !== undefined)
                 columnDefault = column.defval;
             else
                 columnDefault = null;
-            let identity;
+            let identity = false;
             if (column.colconstype === "i")
-                identity = "YES";
-            else
-                identity = "NO";
+                identity = true;
             let identityGeneration = null;
-            if (identity === "YES") {
+            if (identity) {
                 if (column.attidentity === "a")
                     identityGeneration = "ALWAYS";
                 if (column.attidentity === "b")
                     identityGeneration = "BY DEFAULT";
             }
-            columns.push(new ColumnQueryRow(column.name, ordinalPossition, columnDefault, isNullable, dataType, udtType, identity, identityGeneration));
-            ordinalPossition++;
-        }
-        let primaryKey = undefined;
-        if (data.primary_key[0]?.columns[0]?.column)
-            primaryKey = new PrimaryKeyQueryRow(data.primary_key[0].columns[0].column);
-        const foreignKeys = [];
-        for (const foreignKey of data.foreign_key) {
-            for (const column of foreignKey.columns) {
-                const match = column.references_table_name.match(/(?:\((.*?)\))? ?(.*)/);
-                foreignKeys.push(new ForeignKeyQueryRow(data.schema, data.name, column.local_column, match[1] || data.schema, match[2], column.referenced));
+            let isPrimary = false;
+            if (column.name === data.primary_key[0].columns[0].column)
+                isPrimary = true;
+            let isForeign = false;
+            let foreignSchema = undefined;
+            let foreignTable = undefined;
+            let foreignColumn = undefined;
+            for (const foreignKey of data.foreign_key) {
+                for (const foreignKeyColumn of foreignKey.columns) {
+                    if (foreignKeyColumn.local_column === column.name) {
+                        isForeign = true;
+                        const match = foreignKeyColumn.references_table_name.match(/(?:\((.*?)\))? ?(.*)/);
+                        foreignSchema = match[1] || data.schema;
+                        foreignTable = match[2];
+                        foreignColumn = foreignKeyColumn.referenced;
+                    }
+                }
             }
+            let isUnique = false;
+            if (data.unique_constraint)
+                for (const uniqueConstraint of data.unique_constraint)
+                    for (const uniqueColumn of uniqueConstraint.columns)
+                        if (uniqueColumn.column === column.name)
+                            isUnique = true;
+            columns.push(new Column(column.name, ordinalPossition, columnDefault, isNullable, jsType, pgType, identity, identityGeneration, isPrimary, isUnique, isForeign, foreignSchema, foreignTable, foreignColumn));
+            ordinalPossition++;
         }
-        const uniqueConstraints = [];
-        if (data.unique_constraint)
-            for (const uniqueConstraint of data.unique_constraint)
-                for (const column of uniqueConstraint.columns)
-                    uniqueConstraints.push(column.column);
-        pigeonTables.push(new Table(data.schema, data.name, columns, primaryKey, foreignKeys, new UniqueQueryRow(uniqueConstraints)));
+        pigeonTables.push(new Table(data.name, data.schema, columns));
     }
     return pigeonTables;
 }

package/src/utils.js

@@ -1,5 +1,5 @@
 import pg from "pg";
-import { jsTypes } from "./maps.js";
+import { jsTypes, udtTypes } from "./maps.js";
 const { Client } = pg;
 export async function runQuery(command, parameters, db) {
     const client = new Client({
@@ -85,7 +85,7 @@ export function queryMaker(baseTabs, variableName, command, parameters) {
     return query;
 }
 function queryBeautifier(baseTabs, command) {
-    const regex = /(?=((?:SELECT|INSERT|FROM|WHERE|AND|VALUES|RETURNING).*?)(?:FROM|WHERE|AND|VALUES|RETURNING|;))/g;
+    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) {
@@ -114,7 +114,7 @@ export function arrayMaker(baseTabs, variableName, className, columns) {
     array += tabsInserter(baseTabs) + "for (const row of " + variableName + "Query.rows)\n";
     array += tabsInserter(baseTabs + 1) + variableName + ".push(new " + className + "(\n";
     for (const column of columns)
-        array += tabsInserter(baseTabs + 2) + "row." + column.column_name + ",\n";
+        array += tabsInserter(baseTabs + 2) + "row." + column.name + ",\n";
     array = array.slice(0, -2) + "\n";
     array += tabsInserter(baseTabs + 1) + "));";
     return array;
@@ -146,7 +146,10 @@ export function getCombinations(valuesArray) {
     combinations.sort((a, b) => a.length - b.length);
     return combinations;
 }
-export function getType(dataType, udtName) {
+export function getJSType(dataType, udtName, isNullable) {
+    dataType = dataType.replace("serial", "int");
+    if (dataType === "int")
+        dataType = "integer";
     let isArray = false;
     if (dataType === "ARRAY") {
         dataType = udtName.slice(1);
@@ -157,5 +160,40 @@ export function getType(dataType, udtName) {
         foundDataType = nameBeautifier(udtName).replaceAll(" ", "");
     if (isArray)
         foundDataType += "[]";
+    if (isNullable)
+        foundDataType += " | null";
     return foundDataType;
 }
+export function getTypesByDataType(dataType) {
+    let udtName;
+    udtName = udtTypes.get(dataType);
+    if (!udtName) {
+        if (dataType.endsWith("[]")) {
+            udtName = "_" + udtTypes.get(dataType.slice(0, -2));
+            dataType = "ARRAY";
+        }
+        else {
+            udtName = dataType;
+            dataType = "USER-DEFINED";
+        }
+    }
+    return {
+        dataType: dataType,
+        udtName: udtName
+    };
+}
+export function getPGType(dataType, udtName) {
+    if (!udtName) {
+        const types = getTypesByDataType(dataType);
+        udtName = types.udtName;
+    }
+    dataType = dataType.replace("serial", "int");
+    if (dataType === "int")
+        dataType = "integer";
+    let pgType = udtName;
+    if (dataType.endsWith("[]") || dataType === "ARRAY")
+        pgType = (udtTypes.get(pgType.slice(1)) || pgType.slice(1)) + "[]";
+    else if (dataType !== "USER-DEFINED")
+        pgType = dataType;
+    return pgType;
+}