introspeql 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Joseph Dvorak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# IntrospeQL
+
+IntrospeQL is a simple package for introspecting PostgreSQL tables and functions
+and generating TypeScript types from them. The aim of the package is to
+make the capturing of PostgreSQL types and the generation of TypeScript types
+easy, comprehensive, and accurate.
+
+## Not Production Ready
+
+This project is currently in alpha. Do not use it in production at this time.
+Full documentation will be available in subsequent releases.
+
+## License
+
+MIT License
+
+Copyright (c) 2025 Joseph Dvorak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/append-schema.d.ts

@@ -0,0 +1,2 @@
+import type { Schema } from "./prepare-data-for-writing";
+export declare function appendSchema(outputPath: string, schema: Schema): void;

package/dist/append-schema.js

@@ -0,0 +1,92 @@
+import fs from "node:fs";
+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/index.d.ts

@@ -0,0 +1,2 @@
+export { introspectDatabase as introspeql } from "./introspect-database";
+export type { IntrospeQLConfig } from "./introspeql-config";

package/dist/index.js

@@ -0,0 +1 @@
+export { introspectDatabase as introspeql } from "./introspect-database";

package/dist/introspect-columns.d.ts

@@ -0,0 +1,22 @@
+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>;
+export declare function introspectColumns(client: Client, tableId: number): Promise<{
+    column_name: string;
+    column_type_schema: string;
+    column_type_id: number;
+    column_type: string;
+    is_enum: boolean;
+    num_dimensions: number;
+    nullable: boolean;
+}[]>;
+export {};

package/dist/introspect-columns.js

@@ -0,0 +1,46 @@
+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(),
+});
+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-database.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedIntrospeQLConfig } from "./introspeql-config";
+export declare function introspectDatabase(config: ParsedIntrospeQLConfig): Promise<void>;

package/dist/introspect-database.js

@@ -0,0 +1,100 @@
+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";
+export async function introspectDatabase(config) {
+    const client = "dbConnectionString" in config
+        ? new Client({
+            connectionString: config.dbConnectionString,
+        })
+        : new Client({
+            ...config.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, config);
+    }
+    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, config);
+    }
+    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,
+            });
+        }
+    }
+    // introspect enums
+    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 outputPath = "outFile" in config
+        ? config.outFile
+        : path.join(config.outDir, "introspeql-types.ts");
+    writeHeader(outputPath, config);
+    const schemas = prepareDataForWriting(enumDataObjects, tableDataObjects, columnDataObjectsByTableId, procedureDataObjects, config);
+    schemas.forEach((schema) => appendSchema(outputPath, schema));
+}

package/dist/introspect-enum.d.ts

@@ -0,0 +1,10 @@
+import type { Client } from "pg";
+export type PartialEnumData = {
+    id: number;
+    schema: string;
+    name: string;
+};
+export type EnumData = PartialEnumData & {
+    values: string[];
+};
+export declare function introspectEnum(client: Client, data: PartialEnumData): Promise<EnumData>;

package/dist/introspect-enum.js

@@ -0,0 +1,17 @@
+import { z } from "zod";
+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

@@ -0,0 +1,45 @@
+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[]>>;
+    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>;
+export declare function introspectProcedures(client: Client, config: ParsedIntrospeQLConfig): Promise<{
+    id: number;
+    schema: string;
+    name: 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;
+    };
+    arg_names?: string[];
+}[]>;
+export {};

package/dist/introspect-procedures.js

@@ -0,0 +1,95 @@
+import { z } from "zod";
+const typeSchema = z.object({
+    id: z.coerce.number(),
+    schema: z.string(),
+    name: z.string(),
+    is_array: z.boolean(),
+    is_enum: z.boolean(),
+});
+const procedureDataSchema = z.object({
+    id: z.number(),
+    schema: z.string(),
+    name: z.string(),
+    arg_names: z
+        .string()
+        .array()
+        .nullable()
+        .transform((v) => (v ? v : [])),
+    arg_types: typeSchema.array(),
+    return_type: typeSchema,
+});
+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

@@ -0,0 +1,15 @@
+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>;
+export declare function introspectTables(client: Client, config: ParsedIntrospeQLConfig): Promise<{
+    id: number;
+    schema: string;
+    name: string;
+}[]>;
+export {};

package/dist/introspect-tables.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+const tableDataSchema = z.object({
+    id: z.number(),
+    schema: z.string(),
+    name: z.string(),
+});
+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;
+}

package/dist/introspeql-config.d.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+declare const introspeqlConfig: z.ZodIntersection<z.ZodIntersection<z.ZodUnion<readonly [z.ZodObject<{
+    dbConnectionString: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    dbConnectionParams: z.ZodObject<{
+        user: z.ZodOptional<z.ZodString>;
+        password: z.ZodOptional<z.ZodString>;
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        database: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>]>, z.ZodUnion<readonly [z.ZodObject<{
+    outDir: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    outFile: z.ZodString;
+}, z.core.$strip>]>>, z.ZodObject<{
+    schemas: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString>>>;
+    header: z.ZodOptional<z.ZodString>;
+    types: z.ZodPipe<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>, z.ZodTransform<{
+        "pg_catalog.bool": string;
+        "pg_catalog.int2": string;
+        "pg_catalog.int4": string;
+        "pg_catalog.float4": string;
+        "pg_catalog.float8": string;
+        "pg_catalog.json": string;
+        "pg_catalog.jsonb": string;
+        "pg_catalog.date": string;
+        "pg_catalog.timestamp": string;
+        "pg_catalog.timestamptz": string;
+        "pg_catalog.void": string;
+    }, Record<string, string>>>;
+    ignoreTables: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>>;
+    ignoreProcedures: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        name: z.ZodString;
+    }, z.core.$strip>>>>;
+}, z.core.$strip>>;
+type IntrospeQLConfig = z.input<typeof introspeqlConfig>;
+type ParsedIntrospeQLConfig = z.infer<typeof introspeqlConfig>;
+export { introspeqlConfig, type IntrospeQLConfig, type ParsedIntrospeQLConfig };

package/dist/introspeql-config.js

@@ -0,0 +1,65 @@
+import { z } from "zod";
+const databaseConnectionConfig = z.union([
+    z.object({
+        dbConnectionString: z.string(),
+    }),
+    z.object({
+        dbConnectionParams: z.object({
+            user: z.string().optional(),
+            password: z.string().optional(),
+            host: z.string().optional(),
+            port: z.number().optional(),
+            database: z.string().optional(),
+        }),
+    }),
+]);
+const outputConfig = z.union([
+    z.object({
+        outDir: z.string(),
+    }),
+    z.object({
+        outFile: z.string(),
+    }),
+]);
+const entityData = z.object({
+    schema: z.string(),
+    name: z.string(),
+});
+const otherConfig = z.object({
+    schemas: z
+        .string()
+        .array()
+        .nonempty({
+        message: "Please provide at least one schema.",
+    })
+        .optional()
+        .default(() => ["public"]),
+    header: z.string().optional(),
+    types: z
+        .record(z.string(), z.string())
+        .optional()
+        .transform((t) => ({
+        "pg_catalog.bool": "boolean",
+        "pg_catalog.int2": "number",
+        "pg_catalog.int4": "number",
+        "pg_catalog.float4": "number",
+        "pg_catalog.float8": "number",
+        "pg_catalog.json": "object",
+        "pg_catalog.jsonb": "object",
+        "pg_catalog.date": "Date",
+        "pg_catalog.timestamp": "Date",
+        "pg_catalog.timestamptz": "Date",
+        "pg_catalog.void": "void",
+        ...t,
+    })),
+    ignoreTables: entityData
+        .array()
+        .optional()
+        .default(() => []),
+    ignoreProcedures: entityData
+        .array()
+        .optional()
+        .default(() => []),
+});
+const introspeqlConfig = z.intersection(z.intersection(databaseConnectionConfig, outputConfig), otherConfig);
+export { introspeqlConfig };

package/dist/prepare-data-for-writing.d.ts

@@ -0,0 +1,27 @@
+import type { EnumData } from "./introspect-enum";
+import type { TableData } from "./introspect-tables";
+import type { ColumnData } from "./introspect-columns";
+import type { ProcedureData } from "./introspect-procedures";
+import type { ParsedIntrospeQLConfig } from "./introspeql-config";
+export interface Schema {
+    formattedName: string;
+    rawName: string;
+    enums: Array<{
+        name: string;
+        values: string[];
+    }>;
+    tables: Array<{
+        formattedName: string;
+        rawName: string;
+        columnNames: Record<string, string>;
+        rowType: Record<string, string>;
+    }>;
+    procedures: Array<{
+        formattedName: string;
+        rawName: string;
+        argNames: string[];
+        argTypes: string[];
+        returnType: string;
+    }>;
+}
+export declare function prepareDataForWriting(enumDataObjects: EnumData[], tableDataObjects: TableData[], columnDataObjectsByTableId: Record<number, ColumnData[]>, procedureDataObjects: ProcedureData[], config: ParsedIntrospeQLConfig): Schema[];

package/dist/prepare-data-for-writing.js

@@ -0,0 +1,134 @@
+import { snakeCaseToPascalCase } from "./snake-case-to-pascal-case";
+export function prepareDataForWriting(enumDataObjects, tableDataObjects, columnDataObjectsByTableId, procedureDataObjects, config) {
+    const schemas = [];
+    prepareEnums(enumDataObjects, schemas, config);
+    prepareTables(tableDataObjects, columnDataObjectsByTableId, schemas, config);
+    prepareProcedures(procedureDataObjects, schemas, config);
+    return schemas;
+}
+function prepareEnums(enumDataObjects, schemas, config) {
+    for (const enumDataObj of enumDataObjects) {
+        // If the enum is overridden by configuration options, skip it.
+        const typeMappingKey = `${enumDataObj.schema}.${enumDataObj.name}`;
+        if (typeMappingKey in config.types)
+            continue;
+        const schema = findOrInsertSchema(schemas, enumDataObj.schema);
+        const formattedEnumName = snakeCaseToPascalCase(enumDataObj.name);
+        schema.enums.push({
+            name: formattedEnumName,
+            values: enumDataObj.values,
+        });
+    }
+}
+function prepareTables(tableDataObjects, columnDataObjectsByTableId, schemas, config) {
+    for (const tableDataObj of tableDataObjects) {
+        const schema = findOrInsertSchema(schemas, tableDataObj.schema);
+        const tableData = {
+            formattedName: snakeCaseToPascalCase(tableDataObj.name),
+            rawName: tableDataObj.name,
+            columnNames: columnDataObjectsByTableId[tableDataObj.id].reduce((acc, current) => {
+                const formattedColumnName = snakeCaseToPascalCase(current.column_name);
+                acc[formattedColumnName] = current.column_name;
+                return acc;
+            }, {}),
+            rowType: columnDataObjectsByTableId[tableDataObj.id].reduce((acc, current) => {
+                let type;
+                const typeMappingKey = `${current.column_type_schema}.${current.column_type}`;
+                if (typeMappingKey in config.types) {
+                    type = config.types[typeMappingKey];
+                }
+                else if (current.is_enum) {
+                    const formattedEnumName = snakeCaseToPascalCase(current.column_type);
+                    type = `Enums.${formattedEnumName}`;
+                    if (current.column_type_schema !== schema.rawName) {
+                        const formattedEnumSchemaName = snakeCaseToPascalCase(current.column_type_schema);
+                        type = `${formattedEnumSchemaName}.${type}`;
+                    }
+                }
+                else {
+                    type = "string";
+                }
+                type += "[]".repeat(current.num_dimensions);
+                if (current.nullable) {
+                    type += " | null";
+                }
+                acc[current.column_name] = type;
+                return acc;
+            }, {}),
+        };
+        schema.tables.push(tableData);
+    }
+}
+function prepareProcedures(procedureDataObjects, schemas, config) {
+    for (const procDataObj of procedureDataObjects) {
+        const schema = findOrInsertSchema(schemas, procDataObj.schema);
+        const extantProcedureDeclarations = schema.procedures.filter((p) => p.rawName === procDataObj.name).length;
+        const procData = {
+            formattedName: snakeCaseToPascalCase(procDataObj.name) +
+                (extantProcedureDeclarations > 0
+                    ? "_" + extantProcedureDeclarations
+                    : ""),
+            rawName: procDataObj.name,
+            argNames: procDataObj.arg_names,
+            argTypes: procDataObj.arg_types.map((a) => {
+                let type;
+                const typeMappingKey = `${a.schema}.${a.name}`;
+                if (typeMappingKey in config.types) {
+                    type = config.types[typeMappingKey];
+                }
+                else if (a.is_enum) {
+                    const formattedEnumName = snakeCaseToPascalCase(a.name);
+                    type = `Enums.${formattedEnumName}`;
+                    if (a.schema !== schema.rawName) {
+                        const formattedEnumSchemaName = snakeCaseToPascalCase(a.schema);
+                        type = `${formattedEnumSchemaName}.${type}`;
+                    }
+                }
+                else {
+                    type = "string";
+                }
+                if (a.is_array) {
+                    type += "[]";
+                }
+                return type;
+            }),
+            returnType: (() => {
+                let type;
+                const typeMappingKey = `${procDataObj.return_type.schema}.${procDataObj.return_type.name}`;
+                if (typeMappingKey in config.types) {
+                    type = config.types[typeMappingKey];
+                }
+                else if (procDataObj.return_type.is_enum) {
+                    const formattedEnumName = snakeCaseToPascalCase(procDataObj.return_type.name);
+                    type = `Enums.${formattedEnumName}`;
+                    if (procDataObj.return_type.schema !== schema.rawName) {
+                        const formattedEnumSchemaName = snakeCaseToPascalCase(procDataObj.return_type.schema);
+                        type = `${formattedEnumSchemaName}.${type}`;
+                    }
+                }
+                else {
+                    type = "string";
+                }
+                if (procDataObj.return_type.is_array) {
+                    type += "[]";
+                }
+                return type;
+            })(),
+        };
+        schema.procedures.push(procData);
+    }
+}
+function findOrInsertSchema(schemas, rawName) {
+    let schema = schemas.find((s) => s.rawName === rawName);
+    if (schema)
+        return schema;
+    schema = {
+        formattedName: snakeCaseToPascalCase(rawName),
+        rawName,
+        enums: [],
+        tables: [],
+        procedures: [],
+    };
+    schemas.push(schema);
+    return schema;
+}

package/dist/snake-case-to-pascal-case.d.ts

@@ -0,0 +1 @@
+export declare function snakeCaseToPascalCase(str: string): string;

package/dist/snake-case-to-pascal-case.js

@@ -0,0 +1,10 @@
+export function snakeCaseToPascalCase(str) {
+    let formatted = str
+        .split("_")
+        .map((s) => s.slice(0, 1).toUpperCase() + s.slice(1))
+        .join("");
+    if (str.startsWith("_")) {
+        formatted = "_" + formatted;
+    }
+    return formatted;
+}

package/dist/write-header.d.ts

@@ -0,0 +1,2 @@
+import type { ParsedIntrospeQLConfig } from "./introspeql-config";
+export declare function writeHeader(outputPath: string, config: ParsedIntrospeQLConfig): void;

package/dist/write-header.js

@@ -0,0 +1,10 @@
+import fs from "node:fs";
+export function writeHeader(outputPath, config) {
+    const comment = `/* This file was generated by IntrospeQL. Do not edit manually. */\n\n`;
+    const header = config.header
+        ? comment +
+            config.header +
+            "\n".repeat(config.header.endsWith("\n") ? 1 : 2)
+        : comment;
+    fs.writeFileSync(outputPath, header, "utf-8");
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "introspeql",
+  "version": "0.0.0",
+  "description": "Easy Postgres to TypeScript type generation.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "tsc"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "PostgreSQL",
+    "Postgres",
+    "TypeScript"
+  ],
+  "author": "Joseph Dvorak",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.2"
+  },
+  "dependencies": {
+    "@types/pg": "^8.15.5",
+    "pg": "^8.16.3",
+    "zod": "^4.1.11"
+  }
+}