introspeql 0.0.4 → 1.1.0

package/dist/shared/convert-pg-identifier-to-ts-identifier.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Converts a PostgreSQL identifier to a valid TypeScript identifier.
+ *
+ * @remarks
+ * In PostgreSQL, if an identifier is enclosed in double quotes, it can include
+ * a wider selection of characters than are valid in TypeScript.
+ * Additionally, while it is idiomatic to use snake_case in PostgreSQL, it is
+ * more commonplace to use PascalCase for TypeScript types. Therefore, the
+ * following rules are followed when converting identifiers:
+ *
+ * - If the PostgreSQL identifier begins with underscore(s), these are
+ *   preserved.
+ * - Otherwise, only alphanumeric and $ characters are copied.
+ * - All non-letter characters are treated as separators, except for
+ *   apostrophes, which are simply discarded.
+ * - Each word (i.e. the letters between separators) is capitalized.
+ * - If the result begins with a number, it is prefaced with an underscore.
+ */
+export declare function convertPGIdentifierToTSIdentifier(identifier: string): string;

package/dist/shared/convert-pg-identifier-to-ts-identifier.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertPGIdentifierToTSIdentifier = convertPGIdentifierToTSIdentifier;
+var capitalize_1 = require("./capitalize");
+/**
+ * Converts a PostgreSQL identifier to a valid TypeScript identifier.
+ *
+ * @remarks
+ * In PostgreSQL, if an identifier is enclosed in double quotes, it can include
+ * a wider selection of characters than are valid in TypeScript.
+ * Additionally, while it is idiomatic to use snake_case in PostgreSQL, it is
+ * more commonplace to use PascalCase for TypeScript types. Therefore, the
+ * following rules are followed when converting identifiers:
+ *
+ * - If the PostgreSQL identifier begins with underscore(s), these are
+ *   preserved.
+ * - Otherwise, only alphanumeric and $ characters are copied.
+ * - All non-letter characters are treated as separators, except for
+ *   apostrophes, which are simply discarded.
+ * - Each word (i.e. the letters between separators) is capitalized.
+ * - If the result begins with a number, it is prefaced with an underscore.
+ */
+function convertPGIdentifierToTSIdentifier(identifier) {
+    // preserve leading underscores
+    var prefix = '';
+    while (identifier.startsWith('_')) {
+        prefix += '_';
+        identifier = identifier.slice(1);
+    }
+    var words = [];
+    var word = '';
+    for (var _i = 0, identifier_1 = identifier; _i < identifier_1.length; _i++) {
+        var char = identifier_1[_i];
+        if (char === "'")
+            continue;
+        if (/[^A-Za-z]/.test(char)) {
+            if (word.length)
+                words.push(word);
+            if (/[0-9$]/.test(char)) {
+                words.push(char);
+            }
+            word = '';
+        }
+        else {
+            word += char;
+        }
+    }
+    if (word.length) {
+        words.push(word);
+    }
+    var result = prefix + words.map(function (word) { return (0, capitalize_1.capitalize)(word); }).join('');
+    if (/^\d/.test(result))
+        result = '_' + result;
+    return result;
+}

package/dist/shared/directives.d.ts

@@ -0,0 +1,12 @@
+export declare enum Directives {
+    Include = "@introspeql-include",
+    Exclude = "@introspeql-exclude",
+    EnableNullableArgs = "@introspeql-enable-nullable-args",
+    DisableNullableArgs = "@introspeql-disable-nullable-args",
+    EnableNullableReturnTypes = "@introspeql-enable-nullable-return-types",
+    DisableNullableReturnTypes = "@introspeql-disable-nullable-return-types",
+    EnableTSDocComments = "@introspeql-enable-tsdoc-comments",
+    DisableTSDocComments = "@introspeql-disable-tsdoc-comments",
+    BeginTSDocComment = "@introspeql-begin-tsdoc-comment",
+    EndTSDocComment = "@introspeql-end-tsdoc-comment"
+}

package/dist/shared/directives.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Directives = void 0;
+var Directives;
+(function (Directives) {
+    Directives["Include"] = "@introspeql-include";
+    Directives["Exclude"] = "@introspeql-exclude";
+    Directives["EnableNullableArgs"] = "@introspeql-enable-nullable-args";
+    Directives["DisableNullableArgs"] = "@introspeql-disable-nullable-args";
+    Directives["EnableNullableReturnTypes"] = "@introspeql-enable-nullable-return-types";
+    Directives["DisableNullableReturnTypes"] = "@introspeql-disable-nullable-return-types";
+    Directives["EnableTSDocComments"] = "@introspeql-enable-tsdoc-comments";
+    Directives["DisableTSDocComments"] = "@introspeql-disable-tsdoc-comments";
+    Directives["BeginTSDocComment"] = "@introspeql-begin-tsdoc-comment";
+    Directives["EndTSDocComment"] = "@introspeql-end-tsdoc-comment";
+})(Directives || (exports.Directives = Directives = {}));

package/dist/shared/get-tokens.d.ts

@@ -0,0 +1 @@
+export declare function getTokens(comment: string | null): string[];

package/dist/shared/get-tokens.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTokens = getTokens;
+function getTokens(comment) {
+    var tokens = comment ? comment.split(/\s/).map(function (t) { return t.toLowerCase(); }) : [];
+    return tokens;
+}

package/dist/shared/indent.d.ts

@@ -0,0 +1 @@
+export declare function indent(str: string, spaces: number): string;

package/dist/shared/indent.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.indent = indent;
+function indent(str, spaces) {
+    return str
+        .split('\n')
+        .map(function (line) { return ' '.repeat(spaces) + line; })
+        .join('\n');
+}

package/dist/shared/index.d.ts

@@ -0,0 +1,6 @@
+export * from './capitalize';
+export * from './directives';
+export * from './get-tokens';
+export * from './indent';
+export * from './parsing-error';
+export * from './convert-pg-identifier-to-ts-identifier';

package/dist/shared/index.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./capitalize"), exports);
+__exportStar(require("./directives"), exports);
+__exportStar(require("./get-tokens"), exports);
+__exportStar(require("./indent"), exports);
+__exportStar(require("./parsing-error"), exports);
+__exportStar(require("./convert-pg-identifier-to-ts-identifier"), exports);

package/dist/shared/parsing-error.d.ts

@@ -0,0 +1,3 @@
+export declare class ParsingError extends Error {
+    constructor(message: string);
+}

package/dist/shared/parsing-error.js

@@ -0,0 +1,26 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParsingError = void 0;
+var ParsingError = /** @class */ (function (_super) {
+    __extends(ParsingError, _super);
+    function ParsingError(message) {
+        return _super.call(this, message) || this;
+    }
+    return ParsingError;
+}(Error));
+exports.ParsingError = ParsingError;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export * from './lookup-type';

package/dist/types/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./lookup-type"), exports);

package/dist/types/lookup-type.d.ts

@@ -0,0 +1,15 @@
+import type { ParsedConfig } from '../config';
+interface TypeInformation {
+    schema: string;
+    name: string;
+    isEnum: boolean;
+}
+/**
+ * Looks up the correct TypeScript type for a given PostgreSQL type. First
+ * checks the config.types object for the type, then checks whether or not the
+ * type is an Enum, and if it is, creates a string that will refer to the
+ * enum definition generated by IntrospeQL. If the type is not defined in
+ * config.types and is not an enum, 'string' is returned.
+ */
+export declare function lookupType({ schema, name, isEnum }: TypeInformation, parentSchema: string, config: ParsedConfig): string;
+export {};

package/dist/types/lookup-type.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.lookupType = lookupType;
+var shared_1 = require("../shared");
+/**
+ * Looks up the correct TypeScript type for a given PostgreSQL type. First
+ * checks the config.types object for the type, then checks whether or not the
+ * type is an Enum, and if it is, creates a string that will refer to the
+ * enum definition generated by IntrospeQL. If the type is not defined in
+ * config.types and is not an enum, 'string' is returned.
+ */
+function lookupType(_a, parentSchema, config) {
+    var schema = _a.schema, name = _a.name, isEnum = _a.isEnum;
+    var key = "".concat(schema, ".").concat(name);
+    if (key in config.types) {
+        return config.types[key];
+    }
+    if (isEnum) {
+        var type = "Enums.".concat((0, shared_1.convertPGIdentifierToTSIdentifier)(name));
+        if (schema !== parentSchema)
+            type = "".concat((0, shared_1.convertPGIdentifierToTSIdentifier)(schema), ".").concat(type);
+        return type;
+    }
+    return 'string';
+}

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.1.0",
+  "description": "IntrospeQL reads information about the schemas, tables, views, materialized views, functions and enums in your PostgreSQL database and produces a TypeScript file detailing type information for each object in the database.",
+  "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>;