@andymic/pigeon 1.2.0 → 1.4.0

package/bin/pigeon.js

@@ -1,18 +1,18 @@
 #!/usr/bin/env node
-/*
- * Copyright (c) 2024 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.4.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": "ec33791a735792a340bfa41c1f66e9a08534ffa6"
 }

package/src/cli.js

@@ -1,12 +1,9 @@
-/*
- * Copyright (c) 2024 Andreas Michael
- * This software is under the Apache 2.0 License
- */
 import meow from "meow";
 import { createConfig } from "./config.js";
+import { Database, deleteDir, enumsQuery, 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";
+import { getRelationshipsAndTables, tableProcessing } from "./pgAdmin.js";
 export const cli = meow(`
     Usage
       $ pigeon [options]
@@ -17,12 +14,15 @@ export const cli = meow(`
       --force   overwrites already existing files
       --output  [path:String] output directory for the generated files.
       --config  [path:String] path to .pigeon.json config file.
+      --pgAdmin [path:String] path to the pgAdmin ERD file.
+      --offline (only with pgAdmin) does not contact the database
  
     Examples
       $ pigeon --init
       $ pigeon --output C:/Users/User/Documents/Project
       $ pigeon --output ./generatedFiles --force
       $ pigeon --config ./customPigeonConfig.json
+      $ pigeon --pgAdmin C:/Users/User/Documents/Project/ERD.json --offline
       
     Exit Status
       Pigeon returns the following codes:
@@ -57,6 +57,13 @@ export const cli = meow(`
             type: "string",
             default: process.cwd(),
         },
+        pgAdmin: {
+            type: "string",
+        },
+        offline: {
+            type: "boolean",
+            default: false,
+        }
     },
     autoHelp: true,
     autoVersion: true,
@@ -67,16 +74,51 @@ export async function run(flags) {
         return createConfig(flags.cwd);
     if (flags.force)
         deleteDir(flags.output);
+    if (flags.pgAdmin) {
+        let enums;
+        let database;
+        if (!flags.offline) {
+            if (!fs.existsSync(path.join(process.cwd(), ".pigeon.json")))
+                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());
+            database = new Database(params.host, params.port, params.database, params.username, params.password);
+            enums = await enumsQuery(database);
+        }
+        else {
+            enums = [];
+            database = new Database("localhost", "5432", "database", "username", "password");
+        }
+        if (enums instanceof PigeonError)
+            return enums;
+        if (!fs.existsSync(flags.pgAdmin))
+            return new PigeonError(1, "", new Error("The pgAdmin ERD file specified does not exist."));
+        const file = fs.readFileSync(flags.pgAdmin).toString();
+        let tables;
+        try {
+            tables = getRelationshipsAndTables(file).tables;
+        }
+        catch (e) {
+            return e;
+        }
+        const generationResult = runGeneration(flags.output, database, tableProcessing(tables), enums);
+        if (generationResult instanceof PigeonError)
+            return generationResult;
+    }
     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,9 @@
-/*
- * Copyright (c) 2024 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,108 @@
-/*
- * Copyright (c) 2024 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;
+    }
+}
+export 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;
+    }
+}
+export class Enum {
+    name;
+    labels;
+    constructor(name, labels) {
+        this.name = name;
+        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 {
-            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 +150,71 @@ 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;
-    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);
-    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));
+export async function enumsQuery(db) {
     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));
     }
+    return enums;
+}
+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');`, [], db);
+    if (typeof tableQuery === "undefined")
+        return new PigeonError(1, "", new Error("An SQL error has occurred."));
+    const enums = await enumsQuery(db);
+    if (enums instanceof PigeonError)
+        return enums;
+    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 +227,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 +238,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 +366,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";
@@ -330,9 +400,9 @@ function createClass(tableName, columns, primaryKeys, foreignKeys) {
                     if (column.column_default)
                         text += " = new Date()";
                     else
-                        text += " = new Date(" + column.column_default.replace(' ', 'T') + ")";
+                        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 +415,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 +443,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 +482,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 +500,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 +518,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 +538,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 +554,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 +563,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 +580,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 +588,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 +616,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/maps.js

@@ -1,8 +1,4 @@
-/*
- * Copyright (c) 2024 Andreas Michael
- * This software is under the Apache 2.0 License
- */
-export const types = new Map([
+export const jsTypes = new Map([
     ["bigint", "number"],
     ["int8", "number"],
     ["bigserial", "number"],
@@ -65,3 +61,62 @@ export const types = new Map([
     ["uuid", "string"],
     ["xml", "string"],
 ]);
+export const udtTypes = new Map([
+    ["smallint", "int2"],
+    ["int2", "int2"],
+    ["integer", "int4"],
+    ["int", "int4"],
+    ["bigint", "int8"],
+    ["int8", "int8"],
+    ["real", "float4"],
+    ["float4", "float4"],
+    ["double precision", "float8"],
+    ["float8", "float8"],
+    ["numeric", "numeric"],
+    ["decimal", "numeric"],
+    ["money", "money"],
+    ["smallserial", "int2"],
+    ["serial", "int4"],
+    ["bigserial", "int8"],
+    ["character", "bpchar"],
+    ["char", "bpchar"],
+    ["character varying", "varchar"],
+    ["varchar", "varchar"],
+    ["text", "text"],
+    ["bytea", "bytea"],
+    ["bit", "bit"],
+    ["bit varying", "varbit"],
+    ["varbit", "varbit"],
+    ["boolean", "bool"],
+    ["bool", "bool"],
+    ["date", "date"],
+    ["time without time zone", "time"],
+    ["time", "time"],
+    ["time with time zone", "timetz"],
+    ["timetz", "timetz"],
+    ["timestamp without time zone", "timestamp"],
+    ["timestamp", "timestamp"],
+    ["timestamp with time zone", "timestamptz"],
+    ["timestamptz", "timestamptz"],
+    ["interval", "interval"],
+    ["box", "box"],
+    ["circle", "circle"],
+    ["line", "line"],
+    ["lseg", "lseg"],
+    ["path", "path"],
+    ["point", "point"],
+    ["polygon", "polygon"],
+    ["cidr", "cidr"],
+    ["inet", "inet"],
+    ["macaddr", "macaddr"],
+    ["macaddr8", "macaddr8"],
+    ["json", "json"],
+    ["jsonb", "jsonb"],
+    ["uuid", "uuid"],
+    ["tsquery", "tsquery"],
+    ["tsvector", "tsvector"],
+    ["pg_lsn", "pg_lsn"],
+    ["pg_snapshot", "pg_snapshot"],
+    ["txid_snapshot", "txid_snapshot"],
+    ["xml", "xml"],
+]);

package/src/pgAdmin.js

@@ -0,0 +1,117 @@
+import { ColumnQueryRow, ForeignKeyQueryRow, PigeonError, PrimaryKeyQueryRow, Table, UniqueQueryRow } from "./index.js";
+import { udtTypes } from "./maps.js";
+function objectToArray(json) {
+    let arrayJSON = "";
+    let enteredObject = false;
+    let brackets = 0;
+    for (let i = 0; i < json.length; i++) {
+        if (json[i] === "{") {
+            if (!enteredObject) {
+                enteredObject = true;
+                arrayJSON += "[";
+                brackets++;
+                continue;
+            }
+            brackets++;
+            arrayJSON += json[i];
+            continue;
+        }
+        else if (json[i] === "}") {
+            brackets--;
+            if (brackets === 0)
+                return JSON.parse(arrayJSON.slice(0, -1) + "]");
+            arrayJSON += json[i];
+            if (brackets === 1)
+                arrayJSON += ",";
+            continue;
+        }
+        if (enteredObject && brackets !== 1)
+            arrayJSON += json[i];
+    }
+}
+export function getRelationshipsAndTables(json) {
+    if (!json.startsWith("{\"version\":"))
+        throw new PigeonError(1, "", new Error("The file specified is not an pgAdmin ERD file."));
+    let relationships = [];
+    let tables = [];
+    const relationshipsIndex = json.match(/"type":"diagram-links"/)?.index;
+    if (relationshipsIndex)
+        relationships = objectToArray(json.slice(relationshipsIndex));
+    const tablesIndex = json.match(/"type":"diagram-nodes"/)?.index;
+    if (tablesIndex)
+        tables = objectToArray(json.slice(tablesIndex));
+    return {
+        relationships: relationships,
+        tables: tables,
+    };
+}
+export function tableProcessing(tables) {
+    const pigeonTables = [];
+    for (const table of tables) {
+        const data = table.otherInfo.data;
+        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;
+            if (column.attnotnull)
+                isNullable = "NO";
+            else
+                isNullable = "YES";
+            let columnDefault;
+            if (column.defval !== "" && column.defval !== undefined)
+                columnDefault = column.defval;
+            else
+                columnDefault = null;
+            let identity;
+            if (column.colconstype === "i")
+                identity = "YES";
+            else
+                identity = "NO";
+            let identityGeneration = null;
+            if (identity === "YES") {
+                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));
+            }
+        }
+        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)));
+    }
+    return pigeonTables;
+}

package/src/utils.js

@@ -1,16 +1,13 @@
-/*
- * Copyright (c) 2024 Andreas Michael
- * This software is under the Apache 2.0 License
- */
 import pg from "pg";
+import { jsTypes } 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 +146,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 = jsTypes.get(dataType);
+    if (foundDataType === undefined)
+        foundDataType = nameBeautifier(udtName).replaceAll(" ", "");
+    if (isArray)
+        foundDataType += "[]";
+    return foundDataType;
+}