@andymic/pigeon 1.2.0 → 1.3.0

package/bin/pigeon.js

@@ -1,18 +1,22 @@
 #!/usr/bin/env node
 /*
- * Copyright (c) 2024 Andreas Michael
+ * Copyright (c) 2025 Andreas Michael
  * This software is under the Apache 2.0 License
  */
 import { cli, run } from "../src/cli.js";
+import { PigeonError } from "../src/index.js";
 try {
-    const { exitCode, message, error } = await run(cli.flags);
-    if (message) {
-        console.log(message);
+    const result = await run(cli.flags);
+    if (result instanceof PigeonError) {
+        if (result.message !== "")
+            console.log(result.message);
+        console.error(result.error);
+        process.exit(result.exitCode);
     }
-    if (error) {
-        console.error(error);
+    else {
+        console.log("Generation Completed Successfully");
+        process.exit(0);
     }
-    process.exit(exitCode);
 }
 catch (error) {
     console.error(error);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@andymic/pigeon",
-  "version": "1.2.0",
+  "version": "1.3.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.14.1",
+    "pg": "^8.15.6",
     "prompt-sync": "^4.2.0"
   },
-  "gitHead": "b163d7dac6444fad09fa7bf9bc2b812ed3f486ad"
+  "gitHead": "40d793e0267631471bde05ffddc53ba908e07512"
 }

package/src/cli.js

@@ -1,11 +1,11 @@
 /*
- * Copyright (c) 2024 Andreas Michael
+ * Copyright (c) 2025 Andreas Michael
  * This software is under the Apache 2.0 License
  */
 import meow from "meow";
 import { createConfig } from "./config.js";
+import { Database, deleteDir, guided, PigeonError, queryDB, runGeneration } from "./index.js";
 import * as path from "node:path";
-import { deleteDir, guided, runPigeon } from "./index.js";
 import fs from "node:fs";
 export const cli = meow(`
     Usage
@@ -69,14 +69,19 @@ export async function run(flags) {
         deleteDir(flags.output);
     if (flags.guided) {
         const params = guided();
-        return await runPigeon(flags.output, params.host, params.port, params.db, params.user, params.pass);
+        const database = new Database(params.host, String(params.port), params.db, params.user, params.pass);
+        const result = await queryDB(database);
+        if (result instanceof PigeonError)
+            return result;
     }
     if (!fs.existsSync(path.join(process.cwd(), ".pigeon.json")))
-        return {
-            exitCode: 1,
-            message: null,
-            error: new Error("The configuration file does not exist. Generate one using the \"pigeon --init\" command"),
-        };
+        return new PigeonError(1, "", new Error("The configuration file does not exist. Generate one using the \"pigeon --init\" command"));
     const params = JSON.parse(fs.readFileSync(flags.config).toString());
-    return await runPigeon(flags.output, params.host, params.port, params.database, params.username, params.password);
+    const database = new Database(params.host, params.port, params.database, params.username, params.password);
+    const queryResult = await queryDB(database);
+    if (queryResult instanceof PigeonError)
+        return queryResult;
+    const generationResult = runGeneration(flags.output, database, queryResult.tables, queryResult.enums);
+    if (generationResult instanceof PigeonError)
+        return generationResult;
 }

package/src/config.js

@@ -1,21 +1,13 @@
 /*
- * Copyright (c) 2024 Andreas Michael
+ * Copyright (c) 2025 Andreas Michael
  * This software is under the Apache 2.0 License
  */
+import { PigeonError } from "./index.js";
 import fs from "node:fs";
 import * as path from "node:path";
 export function createConfig(dir) {
-    if (fs.existsSync(path.join(dir, ".pigeon.json"))) {
-        return {
-            exitCode: 1,
-            message: null,
-            error: new Error("A Pigeon configuration file already exists."),
-        };
-    }
+    if (fs.existsSync(path.join(dir, ".pigeon.json")))
+        return new PigeonError(1, "", new Error("A Pigeon configuration file already exists."));
     fs.writeFileSync(path.join(dir, ".pigeon.json"), "{\n\t\"host\": \"localhost\",\n\t\"port\": 5432,\n\t\"database\": \"postgres\",\n\t\"username\": \"postgres\",\n\t\"password\": \"xxx\"\n}");
-    return {
-        exitCode: 0,
-        message: "Configuration file successfully created!",
-        error: null,
-    };
+    return new PigeonError(0, "Configuration file successfully created!", null);
 }

package/src/index.js

@@ -1,33 +1,110 @@
 /*
- * Copyright (c) 2024 Andreas Michael
+ * Copyright (c) 2025 Andreas Michael
  * This software is under the Apache 2.0 License
  */
-import { arrayMaker, getCombinations, nameBeautifier, queryMaker, runQuery, singularize, sleep, tabsInserter } from "./utils.js";
-import { types } from "./maps.js";
+import { arrayMaker, consoleMessage, getCombinations, getType, 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";
-import prompt from "prompt-sync";
+export class PigeonError {
+    exitCode;
+    message;
+    error;
+    constructor(exitCode, message, error) {
+        this.exitCode = exitCode;
+        this.message = message;
+        this.error = error;
+    }
+}
+export class Database {
+    host;
+    port;
+    db;
+    user;
+    pass;
+    constructor(host, port, db, user, pass) {
+        this.host = host;
+        this.port = port;
+        this.db = db;
+        this.user = user;
+        this.pass = pass;
+    }
+}
+class Table {
+    table_schema;
+    table_name;
+    columns = [];
+    primaryKey;
+    foreignKeys;
+    unique;
+    constructor(table_schema, table_name, columns, primaryKey, foreignKeys, unique) {
+        this.table_schema = table_schema;
+        this.table_name = table_name;
+        this.columns = columns;
+        this.primaryKey = primaryKey;
+        this.foreignKeys = foreignKeys;
+        this.unique = unique;
+    }
+}
+class Enum {
+    name;
+    labels;
+    constructor(name, labels) {
+        this.name = name;
+        this.labels = labels;
+    }
+}
+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;
+    }
+}
+class PrimaryKeyQueryRow {
+    column_name;
+    constructor(column_name) {
+        this.column_name = column_name;
+    }
+}
+class ForeignKeyQueryRow {
+    local_table;
+    local_column;
+    foreign_schema;
+    foreign_table;
+    foreign_column;
+    constructor(local_table, local_column, foreign_schema, foreign_table, foreign_column) {
+        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;
+    }
+}
+class UniqueQueryRow {
+    columns;
+    constructor(columns) {
+        this.columns = columns;
+    }
+}
 function createDir(dirPath) {
     if (fs.existsSync(dirPath))
-        return {
-            exitCode: 1,
-            message: null,
-            error: new Error("Generation directory already exists. Add the --force flag if you want to overwrite it.")
-        };
+        return new PigeonError(1, "", new Error("Generation directory already exists. Add the --force flag if you want to overwrite it."));
     else
-        fs.mkdir(dirPath, (err) => {
-            if (err)
-                return {
-                    exitCode: 1,
-                    message: null,
-                    error: err
-                };
-        });
-    return {
-        exitCode: 0,
-        message: null,
-        error: null
-    };
+        fs.mkdirSync(dirPath);
 }
 export function deleteDir(dirPath) {
     if (fs.existsSync(dirPath)) {
@@ -75,94 +152,65 @@ export function guided() {
     const pass = input("Database Password: ");
     return { host, port, db, user, pass };
 }
-export async function runPigeon(dir, host, port, db, user, pass) {
-    const dirResult = createDir(dir);
-    if (dirResult.exitCode !== 0)
-        return dirResult;
+export async function queryDB(db) {
     const tableQuery = await runQuery(`SELECT table_schema, table_name
          FROM information_schema.tables
          WHERE table_type = 'BASE TABLE'
            AND table_schema NOT IN
-               ('pg_catalog', 'information_schema');`, [], host, port, db, user, pass);
+               ('pg_catalog', 'information_schema');`, [], db);
     if (typeof tableQuery === "undefined")
-        return {
-            exitCode: 1,
-            message: null,
-            error: new Error("An SQL error has occurred.")
-        };
-    let schemas = [];
-    for (const table of tableQuery.rows) {
-        if (schemas.includes(table.table_schema))
-            continue;
-        schemas.push(table.table_schema);
-    }
-    for (const schema of schemas)
-        createDir(path.join(dir, schema));
+        return new PigeonError(1, "", new Error("An SQL error has occurred."));
     const customTypeQuery = await runQuery(`SELECT t.oid, t.typname
          FROM pg_type t
          WHERE (t.typrelid = 0 OR t.typrelid IN (SELECT oid FROM pg_class WHERE relkind = 'c'))
            AND t.typelem = 0
            AND t.typnamespace NOT IN
-               (SELECT oid FROM pg_namespace WHERE nspname IN ('pg_catalog', 'information_schema'));`, [], host, port, db, user, pass);
+               (SELECT oid FROM pg_namespace WHERE nspname IN ('pg_catalog', 'information_schema'));`, [], db);
     if (typeof customTypeQuery === "undefined")
-        return {
-            exitCode: 1,
-            message: null,
-            error: new Error("An SQL error has occurred.")
-        };
-    const customTypes = [];
+        return new PigeonError(1, "", new Error("An SQL error has occurred."));
+    const enums = [];
     for (const type of customTypeQuery.rows) {
         const enumQuery = await runQuery(`SELECT enumlabel
              FROM pg_enum
              WHERE enumtypid = $1::oid
-             ORDER BY enumsortorder;`, [type.oid], host, port, db, user, pass);
+             ORDER BY enumsortorder;`, [type.oid], db);
         if (typeof enumQuery === "undefined")
-            return {
-                exitCode: 1,
-                message: null,
-                error: new Error("An SQL error has occurred.")
-            };
+            return new PigeonError(1, "", new Error("An SQL error has occurred."));
         let labels = [];
         for (const enumLabel of enumQuery.rows)
             labels.push(enumLabel.enumlabel);
-        customTypes.push({
-            name: type.typname,
-            labels: labels
-        });
+        enums.push(new Enum(type.typname, labels));
     }
+    const tables = [];
     for (const table of tableQuery.rows) {
-        const columnQuery = await runQuery(`SELECT *
+        const columnQuery = await runQuery(`SELECT column_name,
+                    ordinal_position,
+                    column_default,
+                    is_nullable,
+                    data_type,
+                    udt_name,
+                    is_identity,
+                    identity_generation
              FROM information_schema.columns
              WHERE table_name = $1::varchar
-               AND table_schema = $2::varchar;`, [table.table_name, table.table_schema], host, port, db, user, pass);
+               AND table_schema = $2::varchar;`, [table.table_name, table.table_schema], db);
         if (typeof columnQuery === "undefined")
-            return {
-                exitCode: 1,
-                message: null,
-                error: new Error("An SQL error has occurred.")
-            };
+            return new PigeonError(1, "", new Error("An SQL error has occurred."));
         const pKeyQuery = await runQuery(`SELECT ku.column_name
              FROM information_schema.table_constraints AS tc
                       INNER JOIN information_schema.key_column_usage AS ku
                                  ON tc.constraint_type = 'PRIMARY KEY'
                                      AND tc.constraint_name = ku.constraint_name
              WHERE tc.table_schema = $1::varchar
-               AND tc.table_name = $2::varchar;`, [table.table_schema, table.table_name], host, port, db, user, pass);
+               AND tc.table_name = $2::varchar;`, [table.table_schema, table.table_name], db);
         if (typeof pKeyQuery === "undefined")
-            return {
-                exitCode: 1,
-                message: null,
-                error: new Error("An SQL error has occurred.")
-            };
-        let pKeys = [];
-        for (let pKey of pKeyQuery.rows)
-            pKeys.push(pKey.column_name);
+            return new PigeonError(1, "", new Error("An SQL error has occurred."));
         const fKeyQuery = await runQuery(`SELECT kcu1.table_schema AS local_schema,
                     kcu1.table_name   AS local_table,
                     kcu1.column_name  AS local_column,
-                    kcu2.table_schema AS referenced_schema,
-                    kcu2.table_name   AS referenced_table,
-                    kcu2.column_name  AS referenced_column
+                    kcu2.table_schema AS foreign_schema,
+                    kcu2.table_name   AS foreign_table,
+                    kcu2.column_name  AS foreign_column
              FROM information_schema.referential_constraints AS rc
                       INNER JOIN information_schema.key_column_usage AS kcu1
                                  ON kcu1.constraint_catalog = rc.constraint_catalog
@@ -175,13 +223,9 @@ export async function runPigeon(dir, host, port, db, user, pass) {
                                      AND kcu2.constraint_name = rc.unique_constraint_name
                                      AND kcu2.ordinal_position = kcu1.ordinal_position
              WHERE kcu1.table_schema = $1::varchar
-               AND kcu1.table_name = $2::varchar;`, [table.table_schema, table.table_name], host, port, db, user, pass);
+               AND kcu1.table_name = $2::varchar;`, [table.table_schema, table.table_name], db);
         if (typeof fKeyQuery === "undefined")
-            return {
-                exitCode: 1,
-                message: null,
-                error: new Error("An SQL error has occurred.")
-            };
+            return new PigeonError(1, "", new Error("An SQL error has occurred."));
         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)
@@ -190,61 +234,88 @@ export async function runPigeon(dir, host, port, db, user, pass) {
                AND c.connamespace = $1::regnamespace
                AND c.conrelid = $2::regclass
              GROUP BY c.conrelid;
-            `, [table.table_schema, table.table_name], host, port, db, user, pass);
+            `, [table.table_schema, table.table_name], db);
         if (typeof uniqueQuery === "undefined")
-            return {
-                exitCode: 1,
-                message: null,
-                error: new Error("An SQL error has occurred.")
-            };
+            return new PigeonError(1, "", new Error("An SQL error has occurred."));
         let uniques = [];
         if (uniqueQuery.rowCount > 0)
             uniques = uniqueQuery.rows[0].columns.slice(1, -1).split(",");
-        let ts = clientMaker(0, host, port, db, user, pass);
+        tables.push(new Table(table.table_schema, table.table_name, columnQuery.rows, pKeyQuery.rows[0], fKeyQuery.rows, { columns: uniques }));
+    }
+    return {
+        tables: tables,
+        enums: enums
+    };
+}
+export function runGeneration(dir, db, tables, enums) {
+    if (!tables)
+        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))
+            continue;
+        schemas.push(table.table_schema);
+    }
+    for (const schema of schemas) {
+        const dirResult = createDir(path.join(dir, schema));
+        if (dirResult instanceof PigeonError)
+            return dirResult;
+    }
+    for (const table of tables) {
+        let ts = clientMaker(0, db);
         ts += "\n\n";
-        for (const customType of customTypes) {
-            for (const column of columnQuery.rows) {
-                if (customType.name === column.udt_name) {
-                    const enumName = nameBeautifier(customType.name).replaceAll(" ", "");
-                    ts += "/**\n An Enum representing the " + nameBeautifier(customType.name).toLowerCase() + ".\n * @readonly\n * @enum {string}\n */\n";
-                    ts += "class " + enumName + " {\n";
-                    let longestLabel = 0;
-                    for (const label of customType.labels)
-                        if (label.length > longestLabel)
-                            longestLabel = label.length;
-                    for (const label of customType.labels)
-                        ts += "\tstatic " + label.toUpperCase().replaceAll(/[^a-zA-Z0-9$]/g, "_") + ": string" + " ".repeat(longestLabel - label.length + 1) + "= \"" + label + "\";\n";
-                    ts += "}\n\n";
+        if (enums) {
+            for (const cEnum of enums) {
+                for (const column of table.columns) {
+                    if (cEnum.name === column.udt_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";
+                        let longestLabel = 0;
+                        for (const label of cEnum.labels)
+                            if (label.length > longestLabel)
+                                longestLabel = label.length;
+                        for (const label of cEnum.labels)
+                            ts += "\tstatic " + label.toUpperCase().replaceAll(/[^a-zA-Z0-9$]/g, "_") + ": string" + " ".repeat(longestLabel - label.length + 1) + "= \"" + label + "\";\n";
+                        ts += "}\n\n";
+                    }
                 }
             }
         }
-        ts += createClass(table.table_name, columnQuery.rows, pKeys, fKeyQuery.rows);
+        ts += createClass(table.table_name, table.columns, table.primaryKey?.column_name, table.foreignKeys);
         ts += "\n\n";
-        ts += createGetAll(table.table_schema, table.table_name, columnQuery.rows);
+        ts += createGetAll(table.table_schema, table.table_name, table.columns);
         ts += "\n\n";
-        let keys = [...pKeys];
-        for (const fKey of fKeyQuery.rows)
-            keys.push(fKey.local_column.replaceAll(" ", ""));
-        keys = keys.concat(uniques);
+        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 keyCombination of getCombinations(keys)) {
-            ts += createGet(table.table_schema, table.table_name, columnQuery.rows, keyCombination);
+            ts += createGet(table.table_schema, table.table_name, table.columns, keyCombination);
             ts += "\n\n";
         }
         let nonDefaults = [];
         let softDefaults = [];
         let hardDefaults = [];
-        for (const column of columnQuery.rows) {
+        for (const column of table.columns) {
             if (column.column_default === null && column.is_identity === "NO")
                 nonDefaults.push(column);
-            if ((column.column_default !== null && !column.column_default.includes("nextval")) || (column.is_identity === "YES" && column.identity_generation === "BY DEFAULT"))
+            else if ((column.column_default !== null && !column.column_default.includes("nextval")) || (column.is_identity === "YES" && column.identity_generation === "BY DEFAULT"))
                 softDefaults.push(column);
-            if ((column.column_default !== null && column.column_default.includes("nextval")) || (column.is_identity === "YES" && column.identity_generation === "ALWAYS"))
+            else if ((column.column_default !== null && column.column_default.includes("nextval")) || (column.is_identity === "YES" && column.identity_generation === "ALWAYS"))
                 hardDefaults.push(column);
         }
-        ts += createAdd(table.table_schema, table.table_name, nonDefaults, [], hardDefaults.concat(softDefaults), fKeyQuery.rows) + "\n\n";
+        ts += createAdd(table.table_schema, table.table_name, nonDefaults, [], hardDefaults.concat(softDefaults), table.foreignKeys) + "\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))), fKeyQuery.rows) + "\n\n";
+            ts += createAdd(table.table_schema, table.table_name, nonDefaults, softCombination, hardDefaults.concat(softDefaults.filter(n => !getCombinations(softDefaults).includes([n]))), table.foreignKeys) + "\n\n";
         ts = ts.slice(0, -2);
         const regex = /import ({?.*?}?) from "(.*?)";\n/g;
         let importObjects = [];
@@ -291,34 +362,29 @@ export async function runPigeon(dir, host, port, db, user, pass) {
         ts = importString + ts;
         fs.writeFileSync(path.join(dir, table.table_schema, table.table_name + ".ts"), ts);
     }
-    return {
-        exitCode: 0,
-        message: "Generation Completed Successfully",
-        error: null
-    };
 }
-function createClass(tableName, columns, primaryKeys, foreignKeys) {
+function createClass(tableName, columns, primaryKey, foreignKeys) {
     let text = "";
     text += "export class " + singularize(nameBeautifier(tableName)).replaceAll(" ", "") + " {\n";
     for (const column of columns) {
-        let dataType = types.get(column.data_type);
-        if (dataType === undefined)
-            dataType = nameBeautifier(column.udt_name).replaceAll(" ", "");
-        if (column.is_nullable == "YES")
+        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
+        if (column.is_nullable === "YES")
             dataType += " | undefined";
         let isPrimaryKey = false;
-        for (const pKey of primaryKeys)
-            if (pKey === column.column_name)
-                isPrimaryKey = true;
-        let foreignKeyIndex = -1;
-        for (let i = 0; i < foreignKeys.length; i++)
-            if (foreignKeys[i].local_column === column.column_name)
-                foreignKeyIndex = i;
+        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 (foreignKeyIndex !== -1)
-            text += "\t * A foreign key representing the " + nameBeautifier(column.column_name) + " for the " + nameBeautifier(tableName) + " table and referencing the " + nameBeautifier(foreignKeys[foreignKeyIndex].referenced_column) + " in the " + nameBeautifier(foreignKeys[foreignKeyIndex].referenced_table) + " table in the " + nameBeautifier(foreignKeys[foreignKeyIndex].referenced_schema) + " schema.\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";
         else
             text += "\t * The " + nameBeautifier(column.column_name) + " for the " + nameBeautifier(tableName) + " table.\n";
         text += "\t * @type {" + dataType + "}\n";
@@ -332,7 +398,7 @@ function createClass(tableName, columns, primaryKeys, foreignKeys) {
                     else
                         text += " = new Date(" + column.column_default.replace(' ', 'T') + ")";
                 }
-                else if (dataType === "number")
+                else if (dataType === "number" || dataType === "boolean")
                     text += " = " + column.column_default;
                 else
                     text += " = \"" + column.column_default + "\"";
@@ -345,24 +411,23 @@ function createClass(tableName, columns, primaryKeys, foreignKeys) {
     text += "\t * Creates a new object for the " + nameBeautifier(tableName) + " table.\n";
     text += "\t * \n";
     for (const column of columns) {
-        let dataType = types.get(column.data_type);
-        if (dataType === undefined)
-            dataType = nameBeautifier(column.udt_name).replaceAll(" ", "");
+        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
         text += "\t * ";
         text += "@param {" + dataType;
-        if (column.is_nullable == "YES")
+        if (column.is_nullable === "YES")
             text += " | undefined";
         text += "} " + column.column_name;
-        text += " - The " + nameBeautifier(column.column_name) + " of the " + nameBeautifier(tableName) + " table. \n";
+        if (!column.column_name.toLowerCase().startsWith('is_'))
+            text += " - The " + nameBeautifier(column.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 += "\t */\n";
     text += "\tconstructor(";
     for (const column of columns) {
-        let dataType = types.get(column.data_type);
-        if (dataType === undefined)
-            dataType = nameBeautifier(column.udt_name).replaceAll(" ", "");
+        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
         text += column.column_name + ": " + dataType;
-        if (column.is_nullable == "YES")
+        if (column.is_nullable === "YES")
             text += " | undefined";
         text += ", ";
     }
@@ -374,14 +439,14 @@ function createClass(tableName, columns, primaryKeys, foreignKeys) {
     text += "}";
     return text;
 }
-export function clientMaker(baseTabs, host, port, db, user, pass) {
+export function clientMaker(baseTabs, db) {
     let text = "";
     text += tabsInserter(baseTabs) + "const client = new Client({\n";
-    text += tabsInserter(baseTabs + 1) + "host: \"" + host + "\",\n";
-    text += tabsInserter(baseTabs + 1) + "port: " + port + ",\n";
-    text += tabsInserter(baseTabs + 1) + "database: \"" + db + "\",\n";
-    text += tabsInserter(baseTabs + 1) + "user: \"" + user + "\",\n";
-    text += tabsInserter(baseTabs + 1) + "password: \"" + pass + "\"\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;
 }
@@ -413,10 +478,12 @@ function createGet(tableSchema, tableName, columns, keys) {
     text = text.slice(0, -5) + ".\n";
     text += " *\n";
     for (const key of keys) {
-        const column = columns.find(column => column.column_name == key);
-        let dataType = types.get(column.data_type);
-        if (dataType === undefined)
-            dataType = nameBeautifier(column.udt_name).replaceAll(" ", "");
+        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;
@@ -429,8 +496,14 @@ function createGet(tableSchema, tableName, columns, keys) {
         text += nameBeautifier(key).replaceAll(" ", "") + "And";
     text = text.slice(0, -3);
     text += "(";
-    for (const key of keys)
-        text += key + ": " + (types.get(columns.find(column => column.column_name == key).data_type) || nameBeautifier(columns.find(column => column.column_name == key).udt_name).replaceAll(" ", "")) + ", ";
+    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) + ", ";
+    }
     text = text.slice(0, -2);
     text += "): Promise<" + className + "[]> {\n";
     text += "\tif (";
@@ -441,7 +514,12 @@ function createGet(tableSchema, tableName, columns, keys) {
     let query = "SELECT * FROM " + tableSchema + "." + tableName + " WHERE ";
     let parameters = "";
     for (let i = 0; i < keys.length; i++) {
-        query += keys[i] + " = " + "$" + (i + 1) + "::" + (columns.find(column => column.column_name == keys[i]).data_type || columns.find(column => column.column_name == keys[i]).udt_name) + " AND ";
+        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 = query.slice(0, -5) + ";";
@@ -456,13 +534,15 @@ function createGet(tableSchema, tableName, columns, keys) {
 function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaults, foreignKeys) {
     let text = "";
     const className = singularize(nameBeautifier(tableName)).replaceAll(" ", "");
-    for (const foreignKey of foreignKeys) {
-        if ((tableSchema == foreignKey.referenced_schema) && (tableName == foreignKey.referenced_table))
-            continue;
-        text += "import {get" + nameBeautifier(foreignKey.referenced_table).replaceAll(" ", "") + "By" + nameBeautifier(foreignKey.referenced_column).replaceAll(" ", "") + "} from \".";
-        if (tableSchema !== foreignKey.referenced_schema)
-            text += "./" + foreignKey.referenced_schema;
-        text += "/" + foreignKey.referenced_table + ".js\";\n";
+    if (foreignKeys) {
+        for (const foreignKey of foreignKeys) {
+            if ((tableSchema === foreignKey.foreign_schema) && (tableName === foreignKey.foreign_table))
+                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 += "/**\n";
     text += " * Adds the provided " + className + " object to the database.\n";
@@ -470,9 +550,7 @@ function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaul
     let columns = nonDefaults.concat(softDefaults);
     columns.sort((a, b) => a.ordinal_position - b.ordinal_position);
     for (const column of columns) {
-        let dataType = types.get(column.data_type);
-        if (dataType === undefined)
-            dataType = nameBeautifier(column.udt_name).replaceAll(" ", "");
+        let dataType = getType(column.data_type, column.udt_name).replaceAll(" ", "");
         text += " * ";
         text += "@param {" + dataType;
         if (column.is_nullable === "YES")
@@ -481,7 +559,7 @@ function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaul
         text += " - The " + nameBeautifier(column.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.length > 0) {
+    if (foreignKeys && foreignKeys.length > 0) {
         text += " * @throws string An exception in the case of the ";
         for (const foreignKey of foreignKeys)
             text += nameBeautifier(foreignKey.local_column) + " or the ";
@@ -498,9 +576,7 @@ function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaul
     }
     text += "(";
     for (const column of columns) {
-        let dataType = types.get(column.data_type);
-        if (dataType === undefined)
-            dataType = nameBeautifier(column.udt_name).replaceAll(" ", "");
+        let dataType = getType(column.data_type, column.udt_name);
         text += column.column_name + ": " + dataType;
         if (column.is_nullable === "YES")
             text += " | undefined";
@@ -508,18 +584,25 @@ function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaul
     }
     text = text.slice(0, -2);
     text += "): Promise<" + className + "> {\n";
-    for (const foreignKey of foreignKeys) {
-        if (columns.find(column => column.column_name == foreignKey.local_column).is_nullable === "YES") {
-            text += "\tif (" + foreignKey.local_column + ") {\n";
-            text += "\t\tconst verify" + nameBeautifier(foreignKey.local_column).replaceAll(" ", "") + " = await get" + nameBeautifier(foreignKey.referenced_table).replaceAll(" ", "") + "By" + nameBeautifier(foreignKey.referenced_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.referenced_table).replaceAll(" ", "") + "By" + nameBeautifier(foreignKey.referenced_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 (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";
+            }
         }
     }
     let query = "INSERT INTO " + tableSchema + "." + tableName + " (";
@@ -529,9 +612,11 @@ function createAdd(tableSchema, tableName, nonDefaults, softDefaults, hardDefaul
     query += ") VALUES (";
     let parameters = "";
     for (let i = 0; i < columns.length; i++) {
-        let dataType = columns[i].data_type;
-        if (dataType === "USER-DEFINED")
-            dataType = columns[i].udt_name;
+        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 + ", ";
     }

package/src/utils.js

@@ -1,16 +1,17 @@
 /*
- * Copyright (c) 2024 Andreas Michael
+ * Copyright (c) 2025 Andreas Michael
  * This software is under the Apache 2.0 License
  */
 import pg from "pg";
+import { types } from "./maps.js";
 const { Client } = pg;
-export async function runQuery(command, parameters, host, port, db, username, password) {
+export async function runQuery(command, parameters, db) {
     const client = new Client({
-        host: host,
-        port: port,
-        database: db,
-        user: username,
-        password: password,
+        host: db.host,
+        port: Number(db.port),
+        database: db.db,
+        user: db.user,
+        password: db.pass,
     });
     try {
         await client.connect();
@@ -149,3 +150,16 @@ export function getCombinations(valuesArray) {
     combinations.sort((a, b) => a.length - b.length);
     return combinations;
 }
+export function getType(dataType, udtName) {
+    let isArray = false;
+    if (dataType === "ARRAY") {
+        dataType = udtName.slice(1);
+        isArray = true;
+    }
+    let foundDataType = types.get(dataType);
+    if (foundDataType === undefined)
+        foundDataType = nameBeautifier(udtName).replaceAll(" ", "");
+    if (isArray)
+        foundDataType += "[]";
+    return foundDataType;
+}