introspeql 0.0.4 → 1.0.0

package/package.json

@@ -1,37 +1,52 @@
 {
   "name": "introspeql",
-  "version": "0.0.4",
-  "description": "Easy Postgres to TypeScript type generation.",
-  "exports": {
-    ".": "./dist/index.js"
-  },
-  "types": "./dist/index.d.ts",
-  "scripts": {
-    "format": "npx prettier . --write",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc"
-  },
+  "version": "1.0.0",
+  "description": "IntrospeQL reads information about the schemas, tables, columns, functions, and enums in your PostgreSQL database and produces a TypeScript file detailing type information for each database object.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "files": [
     "dist",
     "README.md"
   ],
+  "scripts": {
+    "build": "tsc",
+    "format": "npx prettier . --write",
+    "lint": "npx eslint --fix",
+    "test": "vitest --no-watch"
+  },
   "keywords": [
     "PostgreSQL",
     "Postgres",
     "TypeScript"
   ],
   "author": "Joseph Dvorak",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dvorakjt/introspeql"
+  },
   "license": "MIT",
-  "type": "module",
+  "type": "commonjs",
   "devDependencies": {
-    "@types/node": "^24.5.2",
+    "@eslint/js": "^9.39.2",
+    "@eslint/json": "^0.14.0",
+    "@eslint/markdown": "^7.5.1",
+    "@faker-js/faker": "^10.1.0",
+    "@types/node": "^24.7.0",
     "@types/pg": "^8.15.5",
-    "prettier": "^3.6.2",
-    "tsx": "^4.20.6",
-    "typescript": "^5.9.2"
+    "dotenv": "^17.2.3",
+    "eslint": "^9.39.2",
+    "globals": "^16.5.0",
+    "nanoid": "^5.1.6",
+    "pgmock": "^1.0.3",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.51.0",
+    "vitest": "^3.2.4"
   },
   "dependencies": {
+    "@prettier/sync": "^0.6.1",
     "pg": "^8.16.3",
-    "zod": "^4.1.11"
+    "prettier-plugin-jsdoc": "^1.8.0",
+    "zod": "^4.1.12"
   }
 }

package/dist/append-schema.d.ts

@@ -1,8 +0,0 @@
-import type { Schema } from './prepare-data-for-writing';
-/**
- * Appends a namespace representing the given schema to the provided output file.
- *
- * @param outputPath
- * @param schema
- */
-export declare function appendSchema(outputPath: string, schema: Schema): void;

package/dist/append-schema.js

@@ -1,96 +0,0 @@
-import fs from 'node:fs';
-/**
- * Appends a namespace representing the given schema to the provided output file.
- *
- * @param outputPath
- * @param schema
- */
-export function appendSchema(outputPath, schema) {
-    let schemaTypeDefinitions = `export namespace ${schema.formattedName} {\n`;
-    schemaTypeDefinitions += `  export const SchemaName = '${schema.rawName}';\n`;
-    if (schema.enums.length > 0) {
-        schemaTypeDefinitions = appendEnums(schemaTypeDefinitions, schema);
-    }
-    if (schema.tables.length > 0) {
-        schemaTypeDefinitions = appendTables(schemaTypeDefinitions, schema);
-    }
-    if (schema.procedures.length > 0) {
-        schemaTypeDefinitions = appendProcedures(schemaTypeDefinitions, schema);
-    }
-    schemaTypeDefinitions += `};`;
-    fs.appendFileSync(outputPath, schemaTypeDefinitions, 'utf-8');
-}
-function appendEnums(typeDefs, schema) {
-    typeDefs += '\n' + ' '.repeat(2) + 'export namespace Enums {';
-    for (const e of schema.enums) {
-        typeDefs += '\n' + ' '.repeat(4) + `export enum ${e.name} {\n`;
-        typeDefs += e.values.map(v => ' '.repeat(6) + `${v} = '${v}',\n`).join('');
-        typeDefs += ' '.repeat(4) + '};\n';
-    }
-    typeDefs += ' '.repeat(2) + `};\n`;
-    return typeDefs;
-}
-function appendTables(typeDefs, schema) {
-    typeDefs += '\n' + ' '.repeat(2) + 'export namespace Tables {';
-    for (const t of schema.tables) {
-        typeDefs +=
-            '\n' + ' '.repeat(4) + `export namespace ${t.formattedName} {\n`;
-        typeDefs += ' '.repeat(6) + `export const TableName = '${t.rawName}';\n`;
-        if (Object.entries(t.columnNames).length > 0) {
-            typeDefs += '\n' + ' '.repeat(6) + 'export enum ColumnNames {\n';
-            for (const [formattedName, rawName] of Object.entries(t.columnNames)) {
-                typeDefs += ' '.repeat(8) + `${formattedName} = '${rawName}',\n`;
-            }
-            typeDefs += ' '.repeat(6) + '};\n';
-        }
-        if (Object.entries(t.rowType).length > 0) {
-            typeDefs += '\n' + ' '.repeat(6) + 'export interface RowType {\n';
-            for (const [rawName, type] of Object.entries(t.rowType)) {
-                const columnName = Object.entries(t.columnNames).find(entry => {
-                    return entry[1] === rawName;
-                })[0];
-                typeDefs += ' '.repeat(8) + `[ColumnNames.${columnName}]: ${type};\n`;
-            }
-            typeDefs += ' '.repeat(6) + '};\n';
-        }
-        typeDefs += ' '.repeat(4) + '};\n';
-    }
-    typeDefs += ' '.repeat(2) + '};\n';
-    return typeDefs;
-}
-function appendProcedures(typeDefs, schema) {
-    typeDefs += '\n' + ' '.repeat(2) + 'export namespace Procedures {';
-    for (const proc of schema.procedures) {
-        typeDefs +=
-            '\n' + ' '.repeat(4) + `export namespace ${proc.formattedName} {\n`;
-        typeDefs +=
-            ' '.repeat(6) + `export const ProcedureName = '${proc.rawName}';\n`;
-        typeDefs +=
-            '\n' +
-                ' '.repeat(6) +
-                `export const ArgNames = [\n` +
-                proc.argNames
-                    .map(n => {
-                    return ' '.repeat(8) + `'${n}',\n`;
-                })
-                    .join('') +
-                ' '.repeat(6) +
-                '] as const;\n';
-        typeDefs +=
-            '\n' +
-                ' '.repeat(6) +
-                `export type ArgTypes = [\n` +
-                proc.argTypes
-                    .map(t => {
-                    return ' '.repeat(8) + t + ',\n';
-                })
-                    .join('') +
-                ' '.repeat(6) +
-                '];\n';
-        typeDefs +=
-            '\n' + ' '.repeat(6) + `export type ReturnType = ${proc.returnType};\n`;
-        typeDefs += ' '.repeat(4) + '};\n';
-    }
-    typeDefs += ' '.repeat(2) + '};\n';
-    return typeDefs;
-}

package/dist/generate-types.d.ts

@@ -1,8 +0,0 @@
-import { type IntrospeQLConfig } from './introspeql-config';
-/**
- * Reads table, function, and enum metadata from a database and writes
- * corresponding TypeScript type definitions to the provided output path.
- *
- * @param config
- */
-export declare function generateTypes(config: IntrospeQLConfig): Promise<void>;

package/dist/generate-types.js

@@ -1,110 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { Client } from 'pg';
-import { introspectTables } from './introspect-tables';
-import { introspectColumns } from './introspect-columns';
-import { introspectProcedures } from './introspect-procedures';
-import { introspectEnum, } from './introspect-enum';
-import { writeHeader } from './write-header';
-import { prepareDataForWriting } from './prepare-data-for-writing';
-import { appendSchema } from './append-schema';
-import { introspeqlConfig } from './introspeql-config';
-/**
- * Reads table, function, and enum metadata from a database and writes
- * corresponding TypeScript type definitions to the provided output path.
- *
- * @param config
- */
-export async function generateTypes(config) {
-    const parsedConfig = introspeqlConfig.parse(config);
-    const client = 'dbConnectionString' in parsedConfig ?
-        new Client({
-            connectionString: parsedConfig.dbConnectionString,
-        })
-        : new Client({
-            ...parsedConfig.dbConnectionParams,
-        });
-    try {
-        await client.connect();
-    }
-    catch (e) {
-        throw new Error('Failed to connect to the database.', { cause: e });
-    }
-    // Read table data
-    let tableDataObjects;
-    try {
-        tableDataObjects = await introspectTables(client, parsedConfig);
-    }
-    catch (e) {
-        throw new Error('Failed to introspect tables.', { cause: e });
-    }
-    // Read column data and update enums object when enum types are found
-    const columnDataObjectsByTableId = {};
-    const partialEnumDataObjects = [];
-    for (const tableDataObj of tableDataObjects) {
-        try {
-            const columnDataObjects = await introspectColumns(client, tableDataObj.id);
-            columnDataObjectsByTableId[tableDataObj.id] = columnDataObjects;
-            for (const columnDataObj of columnDataObjects) {
-                if (columnDataObj.is_enum &&
-                    !partialEnumDataObjects.find(d => d.id === columnDataObj.column_type_id)) {
-                    partialEnumDataObjects.push({
-                        id: columnDataObj.column_type_id,
-                        schema: columnDataObj.column_type_schema,
-                        name: columnDataObj.column_type,
-                    });
-                }
-            }
-        }
-        catch (e) {
-            throw new Error('Failed to introspect columns.', { cause: e });
-        }
-    }
-    // Read procedure data and update enums object when enum types are found
-    let procedureDataObjects;
-    try {
-        procedureDataObjects = await introspectProcedures(client, parsedConfig);
-    }
-    catch (e) {
-        throw new Error('Failed to introspect procedures.', { cause: e });
-    }
-    for (const procedureDataObject of procedureDataObjects) {
-        for (const argType of procedureDataObject.arg_types) {
-            if (argType.is_enum &&
-                !partialEnumDataObjects.find(d => d.id === argType.id)) {
-                partialEnumDataObjects.push({
-                    id: argType.id,
-                    schema: argType.schema,
-                    name: argType.name,
-                });
-            }
-        }
-        if (procedureDataObject.return_type.is_enum &&
-            !partialEnumDataObjects.find(d => d.id === procedureDataObject.return_type.id)) {
-            partialEnumDataObjects.push({
-                id: procedureDataObject.return_type.id,
-                schema: procedureDataObject.return_type.schema,
-                name: procedureDataObject.return_type.name,
-            });
-        }
-    }
-    // Read enum metadata for all enums that were featured in tables or procedures
-    const enumDataObjects = [];
-    for (const partialEnumDataObj of partialEnumDataObjects) {
-        try {
-            const enumData = await introspectEnum(client, partialEnumDataObj);
-            enumDataObjects.push(enumData);
-        }
-        catch (e) {
-            throw new Error('Failed to introspect enum.', { cause: e });
-        }
-    }
-    await client.end();
-    const outDir = path.dirname(config.outFile);
-    if (!fs.existsSync(outDir)) {
-        fs.mkdirSync(outDir, { recursive: true });
-    }
-    writeHeader(parsedConfig.outFile, parsedConfig);
-    const schemas = prepareDataForWriting(enumDataObjects, tableDataObjects, columnDataObjectsByTableId, procedureDataObjects, parsedConfig);
-    schemas.forEach(schema => appendSchema(parsedConfig.outFile, schema));
-}

package/dist/introspect-columns.d.ts

@@ -1,21 +0,0 @@
-import { z } from 'zod';
-import type { Client } from 'pg';
-declare const columnDataSchema: z.ZodObject<{
-    column_name: z.ZodString;
-    column_type_schema: z.ZodString;
-    column_type_id: z.ZodNumber;
-    column_type: z.ZodString;
-    is_enum: z.ZodBoolean;
-    num_dimensions: z.ZodNumber;
-    nullable: z.ZodBoolean;
-}, z.core.$strip>;
-export type ColumnData = z.infer<typeof columnDataSchema>;
-/**
- * Reads metadata for each column of a given table.
- *
- * @param client
- * @param tableId
- * @returns A {@link Promise}<{@link ColumnData}[]>
- */
-export declare function introspectColumns(client: Client, tableId: number): Promise<ColumnData[]>;
-export {};

package/dist/introspect-columns.js

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-const columnDataSchema = z.object({
-    column_name: z.string(),
-    column_type_schema: z.string(),
-    column_type_id: z.number(),
-    column_type: z.string(),
-    is_enum: z.boolean(),
-    num_dimensions: z.number(),
-    nullable: z.boolean(),
-});
-/**
- * Reads metadata for each column of a given table.
- *
- * @param client
- * @param tableId
- * @returns A {@link Promise}<{@link ColumnData}[]>
- */
-export async function introspectColumns(client, tableId) {
-    const result = await client.query(`
-SELECT
-  a.attname AS column_name, 
-  (
-	  SELECT nspname 
-	  FROM pg_catalog.pg_namespace
-	  WHERE oid = t.typnamespace
-  ) AS column_type_schema,
-  CASE WHEN a.attndims > 0 THEN (
-    SELECT base_type.oid
-	  FROM pg_catalog.pg_type AS array_type, pg_catalog.pg_type as base_type
-	  WHERE array_type.oid = a.atttypid AND base_type.typarray = array_type.oid
-  ) ELSE a.atttypid END AS column_type_id,
-  CASE WHEN a.attndims > 0 THEN (
-    SELECT base_type.typname
-	  FROM pg_catalog.pg_type AS array_type, pg_catalog.pg_type as base_type
-	  WHERE array_type.oid = a.atttypid AND base_type.typarray = array_type.oid
-  ) ELSE t.typname END AS column_type,
-  CASE WHEN a.attndims > 0 THEN (
-    SELECT t2.typtype = 'e' AS is_enum
-	  FROM pg_catalog.pg_type AS t1, pg_catalog.pg_type as t2
-	  INNER JOIN pg_catalog.pg_namespace AS n ON t2.typnamespace = n.oid
-	  WHERE t1.oid = a.atttypid AND t2.typarray = t1.oid
-  ) ELSE t.typtype = 'e' END AS is_enum,
-  a.attndims AS num_dimensions,
-  NOT a.attnotnull As nullable 
-FROM pg_catalog.pg_class AS c
-INNER JOIN pg_catalog.pg_namespace AS n ON c.relnamespace = n.oid
-INNER JOIN pg_catalog.pg_attribute AS a ON c.oid = a.attrelid
-INNER JOIN pg_catalog.pg_type AS t ON a.atttypid = t.oid
-WHERE c.oid = $1
-AND a.attnum >= 1;`, [tableId]);
-    const columnData = columnDataSchema.array().parse(result.rows);
-    return columnData;
-}

package/dist/introspect-enum.d.ts

@@ -1,20 +0,0 @@
-import type { Client } from 'pg';
-export type PartialEnumData = {
-    /** The OID of the enum. */
-    id: number;
-    /** The name of the schema in which the enum was defined. */
-    schema: string;
-    /** The name of the enum. */
-    name: string;
-};
-export type EnumData = PartialEnumData & {
-    values: string[];
-};
-/**
- * Reads metadata for the provided enum.
- *
- * @param client
- * @param data
- * @returns A {@link Promise}<{@link EnumData}[]>
- */
-export declare function introspectEnum(client: Client, data: PartialEnumData): Promise<EnumData>;

package/dist/introspect-enum.js

@@ -1,24 +0,0 @@
-import { z } from 'zod';
-/**
- * Reads metadata for the provided enum.
- *
- * @param client
- * @param data
- * @returns A {@link Promise}<{@link EnumData}[]>
- */
-export async function introspectEnum(client, data) {
-    const query = `
-SELECT ARRAY(SELECT enumlabel FROM pg_enum WHERE enumtypid = $1)::text[] AS enum_values;
-`;
-    const parameters = [data.id];
-    const result = await client.query(query, parameters);
-    const { enum_values: enumValues } = z
-        .object({
-        enum_values: z.string().array(),
-    })
-        .parse(result.rows[0]);
-    return {
-        ...data,
-        values: enumValues,
-    };
-}

package/dist/introspect-procedures.d.ts

@@ -1,53 +0,0 @@
-import { z } from 'zod';
-import type { Client } from 'pg';
-import type { ParsedIntrospeQLConfig } from './introspeql-config';
-declare const procedureDataSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    schema: z.ZodString;
-    name: z.ZodString;
-    arg_names: z.ZodPipe<z.ZodNullable<z.ZodArray<z.ZodString>>, z.ZodTransform<string[], string[] | null>>;
-    arg_types: z.ZodArray<z.ZodObject<{
-        id: z.ZodCoercedNumber<unknown>;
-        schema: z.ZodString;
-        name: z.ZodString;
-        is_array: z.ZodBoolean;
-        is_enum: z.ZodBoolean;
-    }, z.core.$strip>>;
-    return_type: z.ZodObject<{
-        id: z.ZodCoercedNumber<unknown>;
-        schema: z.ZodString;
-        name: z.ZodString;
-        is_array: z.ZodBoolean;
-        is_enum: z.ZodBoolean;
-    }, z.core.$strip>;
-}, z.core.$strip>;
-export type ProcedureData = z.infer<typeof procedureDataSchema>;
-/**
- * Reads information about procedures in the provided schema(s), including their
- * ids, names, schema names, argument names, argument types, and return type.
- *
- * @param client
- * @param config
- * @returns A {@link Promise}<{@link ProcedureData}[]>
- */
-export declare function introspectProcedures(client: Client, config: ParsedIntrospeQLConfig): Promise<{
-    id: number;
-    schema: string;
-    name: string;
-    arg_names: string[];
-    arg_types: {
-        id: number;
-        schema: string;
-        name: string;
-        is_array: boolean;
-        is_enum: boolean;
-    }[];
-    return_type: {
-        id: number;
-        schema: string;
-        name: string;
-        is_array: boolean;
-        is_enum: boolean;
-    };
-}[]>;
-export {};

package/dist/introspect-procedures.js

@@ -1,129 +0,0 @@
-import { z } from 'zod';
-const typeSchema = z.object({
-    /** The OID of the type. */
-    id: z.coerce.number(),
-    /** The name of the schema in which the type was defined. */
-    schema: z.string(),
-    /**
-     * The name of the type, or the name of the type of each element if the type
-     * is an array.
-     */
-    name: z.string(),
-    /** Whether or not the type is an array. */
-    is_array: z.boolean(),
-    /**
-     * Whether or not the type (or the type of each element if the type is an
-     * array) is an enum.
-     */
-    is_enum: z.boolean(),
-});
-const procedureDataSchema = z.object({
-    /** The OID of the procedure. */
-    id: z.number(),
-    /** The name of the schema in which the procedure was defined. */
-    schema: z.string(),
-    /** The name of the procedure. */
-    name: z.string(),
-    /**
-     * An array containing the names of the procedure's arguments. Note that this
-     * array can be empty even for procedures with arguments if those arguments
-     * are unnamed.
-     */
-    arg_names: z
-        .string()
-        .array()
-        .nullable()
-        .transform(v => (v ? v : [])),
-    /**
-     * An array containing type information for each of the procedure's
-     * arguments.
-     */
-    arg_types: typeSchema.array(),
-    /**
-     * Type information for the procedure's return type.
-     */
-    return_type: typeSchema,
-});
-/**
- * Reads information about procedures in the provided schema(s), including their
- * ids, names, schema names, argument names, argument types, and return type.
- *
- * @param client
- * @param config
- * @returns A {@link Promise}<{@link ProcedureData}[]>
- */
-export async function introspectProcedures(client, config) {
-    const schemaPlaceholders = config.schemas
-        .map((_, i) => `$${i + 1}`)
-        .join(', ');
-    let query = `
-SELECT 
-  p.oid AS id, 
-  n.nspname AS schema,
-  p.proname AS name, 
-  p.proargnames AS arg_names, 
-  ARRAY(
-    SELECT jsonb_build_object(
-	  'id',
-	  t.oid,
-	  'schema',
-	  n.nspname,
-	  'name',
-	  t.typname,
-	  'is_array',
-	  EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = pt.*),
-	  'is_enum',
-	  t.typtype = 'e'
-	) FROM UNNEST(p.proargtypes) AS pt
-	INNER JOIN pg_catalog.pg_type as t
-	ON 
-	  CASE 
-	    WHEN EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = pt.*) 
-		THEN pt.* = t.typarray
-		ELSE pt.* = t.oid
-	  END
-	INNER JOIN pg_catalog.pg_namespace AS n
-	ON t.typnamespace = n.oid
-  ) AS arg_types,
-  (
-    SELECT jsonb_build_object(
-	  'id',
-	  t.oid,
-	  'schema',
-	  n.nspname,
-	  'name',
-	  t.typname,
-	  'is_array',
-	  EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = p.prorettype),
-	  'is_enum',
-	  t.typtype = 'e'
-	) FROM pg_catalog.pg_type AS t
-	INNER JOIN pg_catalog.pg_namespace as n
-	ON t.typnamespace = n.oid
-	WHERE
-	  CASE 
-	    WHEN EXISTS(SELECT 1 FROM pg_catalog.pg_type AS t WHERE t.typarray = p.prorettype) 
-		THEN t.typarray = p.prorettype
-		ELSE t.oid = p.prorettype
-	  END
-  ) AS return_type
-FROM pg_catalog.pg_proc AS p
-INNER JOIN pg_catalog.pg_namespace AS n ON p.pronamespace = n.oid
-WHERE n.nspname IN (${schemaPlaceholders})
-`;
-    const parameters = [...config.schemas];
-    if (config.ignoreProcedures.length > 0) {
-        let offset = schemaPlaceholders.length;
-        const filters = [];
-        for (const procedureToIgnore of config.ignoreProcedures) {
-            filters.push(`(n.nspname = $${offset++} AND p.proname = $${offset++})`);
-            parameters.push(procedureToIgnore.schema);
-            parameters.push(procedureToIgnore.name);
-        }
-        query += `AND NOT (${filters.join(' OR\n')})`;
-    }
-    query += ';';
-    const result = await client.query(query, parameters);
-    const procedureData = procedureDataSchema.array().parse(result.rows);
-    return procedureData;
-}

package/dist/introspect-tables.d.ts

@@ -1,19 +0,0 @@
-import { z } from 'zod';
-import type { Client } from 'pg';
-import type { ParsedIntrospeQLConfig } from './introspeql-config';
-declare const tableDataSchema: z.ZodObject<{
-    id: z.ZodNumber;
-    schema: z.ZodString;
-    name: z.ZodString;
-}, z.core.$strip>;
-export type TableData = z.infer<typeof tableDataSchema>;
-/**
- * Returns information about tables in the provided schema(s), including their
- * ids, names, and schema names.
- *
- * @param client
- * @param config
- * @returns A {@link Promise}<{@link TableData}[]>
- */
-export declare function introspectTables(client: Client, config: ParsedIntrospeQLConfig): Promise<TableData[]>;
-export {};

package/dist/introspect-tables.js

@@ -1,43 +0,0 @@
-import { z } from 'zod';
-const tableDataSchema = z.object({
-    /** The OID of the table. */
-    id: z.number(),
-    /** The name of the schema containing the table. */
-    schema: z.string(),
-    /** The name of the table. */
-    name: z.string(),
-});
-/**
- * Returns information about tables in the provided schema(s), including their
- * ids, names, and schema names.
- *
- * @param client
- * @param config
- * @returns A {@link Promise}<{@link TableData}[]>
- */
-export async function introspectTables(client, config) {
-    const schemaPlaceholders = config.schemas
-        .map((_, i) => `$${i + 1}`)
-        .join(', ');
-    let query = `
-SELECT c.oid AS id, n.nspname AS schema, c.relname AS name 
-FROM pg_catalog.pg_class AS c
-INNER JOIN pg_catalog.pg_namespace AS n ON c.relnamespace = n.oid
-WHERE c.relkind = 'r' AND n.nspname IN (${schemaPlaceholders})
-`;
-    const parameters = [...config.schemas];
-    if (config.ignoreTables.length > 0) {
-        let offset = schemaPlaceholders.length;
-        const filters = [];
-        for (const tableToIgnore of config.ignoreTables) {
-            filters.push(`(n.nspname = $${offset++} AND c.relname = $${offset++})`);
-            parameters.push(tableToIgnore.schema);
-            parameters.push(tableToIgnore.name);
-        }
-        query += `AND NOT (${filters.join(' OR\n')})`;
-    }
-    query += ';';
-    const result = await client.query(query, parameters);
-    const tableData = tableDataSchema.array().parse(result.rows);
-    return tableData;
-}