true-pg 0.2.3 → 0.3.1

package/README.md

@@ -1,6 +1,6 @@
 # true-pg
 
-A truthful and complete<sup>†</sup> TypeScript code generator for PostgreSQL database schemas.
+A truthful and complete[1] TypeScript code generator for PostgreSQL database schemas.
 
 ## Installation
 
@@ -22,12 +22,12 @@ true-pg [options]
 
 Options:
 
-- `-h, --help` - Show help information
-- `-c, --config [path]` - Path to config file (JSON)
-- `-u, --uri [uri]` - Database URI (Postgres only!)
-- `-o, --out [path]` - Path to output directory (defaults to "models")
-- `-a, --adapter [adapter]` - Adapter to use (e.g. `kysely`, `zod`). Can be specified multiple times.
-- `-A, --all-adapters` - Enable all built-in adapters
+-   `-h, --help` - Show help information
+-   `-c, --config [path]` - Path to config file (JSON)
+-   `-u, --uri [uri]` - Database URI (Postgres only!)
+-   `-o, --out [path]` - Path to output directory (defaults to "models")
+-   `-a, --adapter [adapter]` - Adapter to use (e.g. `kysely`, `zod`). Can be specified multiple times.
+-   `-A, --all-adapters` - Enable all built-in adapters
 
 You can configure true-pg either through command-line arguments or a config file.
 
@@ -120,8 +120,12 @@ The `SchemaGenerator` interface provides methods to customize code generation:
 | `formatSchemaType(type)`        | Formats schema type names (user_sessions -> UserSessions)         |
 | `formatType(type)`              | Formats type names (pg_catalog.int4 -> number)                    |
 | `table(types, table)`           | Generates code for tables                                         |
+| `view(types, view)`             | Generates code for views                                          |
+| `materialisedView(types, view)` | Generates code for materialised views                             |
 | `enum(types, en)`               | Generates code for enums                                          |
 | `composite(types, composite)`   | Generates code for composite types                                |
+| `domain(types, domain)`         | Generates code for domains                                        |
+| `range(types, range)`           | Generates code for ranges                                         |
 | `function(types, func)`         | Generates code for functions                                      |
 | `schemaKindIndex(schema, kind)` | Generates index for a schema kind (models/public/tables/index.ts) |
 | `schemaIndex(schema)`           | Generates index for a schema (models/public/index.ts)             |
@@ -131,4 +135,4 @@ The `SchemaGenerator` interface provides methods to customize code generation:
 
 [MIT](LICENSE)
 
-<sup>†</sup> We only support tables, enums, composite types, and functions at the moment, but we're working on adding support for views, materialised views, domains, and more.
+[1]: We support codegen for tables, views, materialized views, enums, composite types, domains, ranges, and functions.

package/lib/bin.js

@@ -32,7 +32,7 @@ if (help) {
     log("  -o, --out      [path]       Path to output directory");
     log("  -a, --adapter  [adapter]    Output adapter to use (default: 'kysely')");
     log("  -A, --all-adapters          Output all adapters");
-    log("  -c, --config   [path]       Path to config file (JSON)");
+    log("  -c, --config   [path]       Path to config file");
     log("                              Defaults to '.truepgrc.json' or '.config/.truepgrc.json'");
     log("Example:");
     log("  true-pg -u postgres://user:pass@localhost:5432/my-database -o models -a kysely -a zod");
@@ -42,19 +42,15 @@ if (help) {
     else
         process.exit(1);
 }
-if (opts["all-adapters"]) {
+if (opts["all-adapters"])
     opts.adapter = Object.keys(adapters);
-    console.log("Enabling all built-in adapters:", opts.adapter);
-}
 if (!(opts.adapter || config.adapters))
     console.warn('No adapters specified, using default: ["kysely"]');
-opts.out ??= "models";
 // allow single adapter or comma-separated list of adapters
 if (typeof opts.adapter === "string")
     opts.adapter = opts.adapter.split(",");
-opts.adapter ??= ["kysely"];
 // CLI args take precedence over config file
 config.uri = opts.uri ?? config.uri;
 config.out = opts.out ?? config.out;
-config.adapters = opts.adapter ?? config.adapters;
+config.adapters = opts.adapter ?? config.adapters ?? ["kysely"];
 await generate(config);

package/lib/extractor/adapter.d.ts

@@ -0,0 +1,15 @@
+import { Client as Pg } from "pg";
+import { PGlite as Pglite } from "@electric-sql/pglite";
+export declare class DbAdapter {
+    private client;
+    constructor(client: Pg | Pglite);
+    connect(): Promise<void>;
+    /**
+     * Execute a read query and return just the rows
+     */
+    query<R, I extends any[] = []>(text: string, params?: I): Promise<R[]>;
+    /**
+     * Close the connection if needed
+     */
+    close(): Promise<void>;
+}

package/lib/extractor/adapter.js

@@ -0,0 +1,53 @@
+import { Client as Pg } from "pg";
+import { PGlite as Pglite } from "@electric-sql/pglite";
+export class DbAdapter {
+    client;
+    constructor(client) {
+        this.client = client;
+    }
+    async connect() {
+        if (this.client instanceof Pg) {
+            return this.client.connect();
+        }
+        else if (this.client instanceof Pglite) {
+            // Pglite doesn't have an explicit connect method
+        }
+    }
+    /**
+     * Execute a read query and return just the rows
+     */
+    async query(text, params) {
+        let stack;
+        try {
+            stack = new Error().stack;
+            stack = stack?.split("\n").slice(3).join("\n");
+            // @ts-expect-error The two clients can process our query types similarly
+            const result = await this.client.query(text, params);
+            return result.rows;
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                console.error("Query Error ===");
+                console.error("Query:", text);
+                console.error("Parameters:", params);
+                console.error("\nStack trace:");
+                console.error(stack);
+                console.error("\nError details:", error.message);
+                process.exit(1);
+            }
+            else
+                throw error;
+        }
+    }
+    /**
+     * Close the connection if needed
+     */
+    async close() {
+        if (this.client instanceof Pg) {
+            await this.client.end();
+        }
+        else if (this.client instanceof Pglite) {
+            await this.client.close();
+        }
+    }
+}

package/lib/extractor/canonicalise.d.ts

@@ -0,0 +1,64 @@
+import { DbAdapter } from "./adapter.ts";
+export declare namespace Canonical {
+    export enum Kind {
+        Base = "base",
+        Composite = "composite",
+        Domain = "domain",
+        Enum = "enum",
+        Range = "range",
+        Pseudo = "pseudo",
+        Unknown = "unknown"
+    }
+    interface Abstract {
+        original_type: string;
+        canonical_name: string;
+        schema: string;
+        name: string;
+        kind: Kind;
+        dimensions: number;
+        modifiers?: string | null;
+    }
+    export interface Base extends Abstract {
+        kind: Kind.Base;
+    }
+    export interface Enum extends Abstract {
+        kind: Kind.Enum;
+        enum_values: string[];
+    }
+    export interface CompositeAttribute {
+        name: string;
+        index: number;
+        type: Canonical;
+        comment: string | null;
+        defaultValue: any;
+        isNullable: boolean;
+        /**
+         * Whether the attribute is an identity attribute.
+         */
+        isIdentity: boolean;
+        /**
+         * Behavior of the generated attribute. "ALWAYS" if always generated,
+         * "NEVER" if never generated, "BY DEFAULT" if generated when a value
+         * is not provided.
+         */
+        generated: "ALWAYS" | "NEVER" | "BY DEFAULT";
+    }
+    export interface Composite extends Abstract {
+        kind: Kind.Composite;
+        attributes: CompositeAttribute[];
+    }
+    export interface Domain extends Abstract {
+        kind: Kind.Domain;
+        domain_base_type: Canonical;
+    }
+    export interface Range extends Abstract {
+        kind: Kind.Range;
+        range_subtype: Canonical;
+    }
+    export interface Pseudo extends Abstract {
+        kind: Kind.Pseudo;
+    }
+    export {};
+}
+export type Canonical = Canonical.Base | Canonical.Enum | Canonical.Composite | Canonical.Domain | Canonical.Range | Canonical.Pseudo;
+export declare const canonicalise: (db: DbAdapter, types: string[]) => Promise<Canonical[]>;

package/lib/extractor/canonicalise.js

@@ -0,0 +1,245 @@
+import { DbAdapter } from "./adapter.js";
+const removeNulls = (o) => {
+    for (const key in o)
+        if (o[key] == null)
+            delete o[key];
+    return o;
+};
+export var Canonical;
+(function (Canonical) {
+    let Kind;
+    (function (Kind) {
+        Kind["Base"] = "base";
+        Kind["Composite"] = "composite";
+        Kind["Domain"] = "domain";
+        Kind["Enum"] = "enum";
+        Kind["Range"] = "range";
+        Kind["Pseudo"] = "pseudo";
+        Kind["Unknown"] = "unknown";
+    })(Kind = Canonical.Kind || (Canonical.Kind = {}));
+})(Canonical || (Canonical = {}));
+export const canonicalise = async (db, types) => {
+    if (types.length === 0)
+        return [];
+    const placeholders = types.map((_, i) => `($${i * 2 + 1}, $${i * 2 + 2})`).join(", ");
+    const query = `
+	WITH RECURSIVE 
+	-- Parameters with sequence numbers to preserve order
+	input(type_name, seq) AS (
+		VALUES ${placeholders}
+	),
+	-- Parse array dimensions and base type
+	type_parts AS (
+		SELECT
+			type_name,
+			seq,
+			CASE 
+				WHEN type_name ~ '\\(.*\\)' THEN regexp_replace(type_name, '\\(.*\\)', '')
+				ELSE type_name
+			END AS clean_type,
+			CASE 
+				WHEN type_name ~ '\\(.*\\)' THEN substring(type_name from '\\((.*\\?)\\)')
+				ELSE NULL
+			END AS modifiers
+		FROM input
+	),
+	array_dimensions AS (
+		SELECT
+			type_name,
+			seq,
+			modifiers,
+			CASE 
+				WHEN clean_type ~ '.*\\[\\].*' THEN 
+					(length(clean_type) - length(regexp_replace(clean_type, '\\[\\]', '', 'g'))) / 2
+				ELSE 0
+			END AS dimensions,
+			regexp_replace(clean_type, '\\[\\]', '', 'g') AS base_type_name
+		FROM type_parts
+	),
+	-- Get base type information
+	base_type_info AS (
+		SELECT
+			a.type_name,
+			a.seq,
+			a.modifiers,
+			a.dimensions,
+			t.oid AS type_oid,
+			t.typname AS internal_name,
+			n.nspname AS schema_name,
+			t.typtype AS type_kind_code,
+			t.typbasetype,
+			CASE t.typtype
+				WHEN 'b' THEN 'base'
+				WHEN 'c' THEN 'composite'
+				WHEN 'd' THEN 'domain'
+				WHEN 'e' THEN 'enum'
+				WHEN 'p' THEN 'pseudo'
+				WHEN 'r' THEN 'range'
+				ELSE 'unknown'
+			END AS type_kind
+		FROM array_dimensions a
+		JOIN pg_type t ON t.oid = a.base_type_name::regtype
+		JOIN pg_namespace n ON t.typnamespace = n.oid
+	),
+	-- Handle enum values for enum types
+	enum_values AS (
+		SELECT
+			b.type_name,
+			jsonb_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+		FROM base_type_info b
+		JOIN pg_enum e ON b.type_oid = e.enumtypid
+		WHERE b.type_kind_code = 'e'
+		GROUP BY b.type_name
+	),
+	-- Enhanced composite attributes with additional metadata
+	composite_attributes AS (
+		SELECT
+			b.type_name,
+			jsonb_agg(
+				jsonb_build_object(
+					'name', a.attname,
+					'index', a.attnum,
+					'type_oid', a.atttypid,
+					'type_name', format_type(a.atttypid, null),
+					'comment', col_description(c.oid, a.attnum::int),
+					'defaultValue', pg_get_expr(d.adbin, d.adrelid),
+					'isNullable', NOT a.attnotnull,
+					'isIdentity', a.attidentity IS NOT NULL AND a.attidentity != '',
+					'generated', CASE 
+						WHEN a.attidentity = 'a' THEN 'ALWAYS'
+						WHEN a.attidentity = 'd' THEN 'BY DEFAULT'
+						WHEN a.attgenerated = 's' THEN 'ALWAYS'
+						ELSE 'NEVER'
+					END
+				)
+				ORDER BY a.attnum
+			) AS attributes
+		FROM base_type_info b
+		JOIN pg_type t ON t.oid = b.type_oid
+		JOIN pg_class c ON c.oid = t.typrelid
+		JOIN pg_attribute a ON a.attrelid = c.oid
+		LEFT JOIN pg_attrdef d ON d.adrelid = c.oid AND d.adnum = a.attnum
+		WHERE b.type_kind_code = 'c' AND a.attnum > 0 AND NOT a.attisdropped
+		GROUP BY b.type_name
+	),
+	-- Recursive CTE to resolve domain base types
+	domain_types AS (
+		-- Base case: start with initial domain type
+		SELECT
+			b.type_name AS original_type,
+			b.type_oid AS domain_oid,
+			b.typbasetype AS base_type_oid,
+			1 AS level
+		FROM base_type_info b
+		WHERE b.type_kind_code = 'd'
+		
+		UNION ALL
+		
+		-- Recursive case: follow chain of domains
+		SELECT
+			d.original_type,
+			t.oid AS domain_oid,
+			t.typbasetype AS base_type_oid,
+			d.level + 1 AS level
+		FROM domain_types d
+		JOIN pg_type t ON d.base_type_oid = t.oid
+		WHERE t.typtype = 'd'-- Only continue if the base is also a domain
+	),
+	-- Get ultimate base type for domains
+	domain_base_types AS (
+		SELECT DISTINCT ON (original_type)
+			d.original_type,
+			format('%s.%s', n.nspname, t.typname) AS base_canonical_name
+		FROM (
+			-- Get the max level for each original type
+			SELECT original_type, MAX(level) AS max_level
+			FROM domain_types
+			GROUP BY original_type
+		) m
+		JOIN domain_types d ON d.original_type = m.original_type AND d.level = m.max_level
+		JOIN pg_type t ON d.base_type_oid = t.oid
+		JOIN pg_namespace n ON t.typnamespace = n.oid
+	),
+	-- Range type subtype information
+	range_subtypes AS (
+		SELECT
+			b.type_name,
+			format('%s.%s', n.nspname, t.typname) AS subtype_canonical_name
+		FROM base_type_info b
+		JOIN pg_range r ON b.type_oid = r.rngtypid
+		JOIN pg_type t ON t.oid = r.rngsubtype  -- Join to get subtype details
+		JOIN pg_namespace n ON n.oid = t.typnamespace -- Join to get subtype schema
+		WHERE b.type_kind_code = 'r'
+	)
+	-- Final result as JSON
+	SELECT jsonb_build_object(
+		'canonical_name', b.schema_name || '.' || b.internal_name,
+		'schema', b.schema_name,
+		'name', b.internal_name,
+		'kind', b.type_kind,
+		'dimensions', b.dimensions,
+		'original_type', b.type_name,
+		'modifiers', b.modifiers,
+		'enum_values', e.values,
+		'attributes', c.attributes,
+		'domain_base_type', CASE
+			WHEN b.type_kind_code = 'd' THEN d.base_canonical_name
+			ELSE NULL
+		END,
+		'range_subtype', CASE
+			WHEN b.type_kind_code = 'r' THEN r.subtype_canonical_name
+			ELSE NULL
+		END
+	) AS type_info,
+	b.seq
+	FROM base_type_info b
+	LEFT JOIN enum_values e ON b.type_name = e.type_name
+	LEFT JOIN composite_attributes c ON b.type_name = c.type_name
+	LEFT JOIN domain_base_types d ON b.type_name = d.original_type
+	LEFT JOIN range_subtypes r ON b.type_name = r.type_name
+	ORDER BY b.seq::integer;
+	`;
+    const resolved = await db.query(query, types.flatMap((type, index) => [type, index]));
+    return Promise.all(resolved
+        .map(each => each.type_info)
+        .map(async (each) => {
+        if (each.kind === Canonical.Kind.Composite) {
+            const types = each.attributes.map(each => each.type_name);
+            const canonical = await canonicalise(db, types);
+            const attributes = await Promise.all(each.attributes.map(async (each, index) => {
+                return {
+                    name: each.name,
+                    index: each.index,
+                    type: canonical[index],
+                    comment: each.comment,
+                    defaultValue: each.defaultValue,
+                    isNullable: each.isNullable,
+                    isIdentity: each.isIdentity,
+                    generated: each.generated,
+                };
+            }));
+            return removeNulls({
+                ...each,
+                kind: Canonical.Kind.Composite,
+                attributes,
+            });
+        }
+        if (each.kind === Canonical.Kind.Domain) {
+            const canonical = await canonicalise(db, [each.domain_base_type]);
+            return removeNulls({
+                ...each,
+                kind: Canonical.Kind.Domain,
+                domain_base_type: canonical[0],
+            });
+        }
+        if (each.kind === Canonical.Kind.Range) {
+            const canonical = await canonicalise(db, [each.range_subtype]);
+            return removeNulls({
+                ...each,
+                kind: Canonical.Kind.Range,
+                range_subtype: canonical[0],
+            });
+        }
+        return removeNulls(each);
+    }));
+};

package/lib/extractor/fetchExtensionItemIds.d.ts

@@ -0,0 +1,12 @@
+import { DbAdapter } from "./adapter.ts";
+/**
+ * In order to ignore the items (types, views, etc.) that belong to extensions,
+ * we use these queries to figure out what the OID's of those are. We can then
+ * ignore them in fetchClasses.
+ * @returns the oids of the Postgres extension classes and types
+ */
+export default function fetchExtensionItemIds(db: DbAdapter): Promise<{
+    extClassOids: number[];
+    extTypeOids: number[];
+    extProcOids: number[];
+}>;

package/lib/extractor/fetchExtensionItemIds.js

@@ -0,0 +1,43 @@
+import { DbAdapter } from "./adapter.js";
+/**
+ * In order to ignore the items (types, views, etc.) that belong to extensions,
+ * we use these queries to figure out what the OID's of those are. We can then
+ * ignore them in fetchClasses.
+ * @returns the oids of the Postgres extension classes and types
+ */
+export default async function fetchExtensionItemIds(db) {
+    // Query for class OIDs
+    const classQuery = `
+		SELECT c.oid
+		FROM pg_extension AS e
+		JOIN pg_depend AS d ON d.refobjid = e.oid
+		JOIN pg_class AS c ON c.oid = d.objid
+		JOIN pg_namespace AS ns ON ns.oid = e.extnamespace
+		WHERE d.deptype = 'e'
+	`;
+    const classResult = await db.query(classQuery);
+    const extClassOids = classResult.map(({ oid }) => oid);
+    // Query for type OIDs
+    const typeQuery = `
+		SELECT t.oid
+		FROM pg_extension AS e
+		JOIN pg_depend AS d ON d.refobjid = e.oid
+		JOIN pg_type AS t ON t.oid = d.objid
+		JOIN pg_namespace AS ns ON ns.oid = e.extnamespace
+		WHERE d.deptype = 'e'
+	`;
+    const typeResult = await db.query(typeQuery);
+    const extTypeOids = typeResult.map(({ oid }) => oid);
+    // Query for procedure OIDs
+    const procQuery = `
+		SELECT p.oid
+		FROM pg_extension AS e
+		JOIN pg_depend AS d ON d.refobjid = e.oid
+		JOIN pg_proc AS p ON p.oid = d.objid
+		JOIN pg_namespace AS ns ON ns.oid = e.extnamespace
+		WHERE d.deptype = 'e'
+	`;
+    const procResult = await db.query(procQuery);
+    const extProcOids = procResult.map(({ oid }) => oid);
+    return { extClassOids, extTypeOids, extProcOids };
+}

package/lib/extractor/fetchTypes.d.ts

@@ -0,0 +1,4 @@
+import { DbAdapter } from "./adapter.ts";
+import type { PgType } from "./pgtype.ts";
+declare const fetchTypes: (db: DbAdapter, schemaNames: string[]) => Promise<PgType[]>;
+export default fetchTypes;

package/lib/extractor/fetchTypes.js

@@ -0,0 +1,65 @@
+import { DbAdapter } from "./adapter.js";
+import fetchExtensionItemIds from "./fetchExtensionItemIds.js";
+import { classKindMap, typeKindMap } from "./pgtype.js";
+const fetchTypes = async (db, schemaNames) => {
+    // We want to ignore everything belonging to etensions. (Maybe this should be optional?)
+    const { extClassOids, extTypeOids } = await fetchExtensionItemIds(db);
+    const typeQuery = await db.query(`
+		SELECT
+			typname as "name",
+			nspname as "schemaName",
+			case typtype
+				when 'c' then case relkind
+					${Object.entries(classKindMap)
+        .map(([key, classKind]) => `when '${key}' then '${classKind}'`)
+        .join("\n")}
+					else null
+				end
+				${Object.entries(typeKindMap)
+        .map(([key, typeKind]) => `when '${key}' then '${typeKind}'`)
+        .join("\n")}
+				else null
+			end as "kind",
+			COALESCE(
+				obj_description(COALESCE(pg_class.oid, pg_type.oid)),
+				obj_description(pg_type.oid)
+			) as "comment"
+		FROM pg_catalog.pg_type
+		JOIN pg_catalog.pg_namespace ON pg_namespace.oid = pg_type.typnamespace
+		FULL OUTER JOIN pg_catalog.pg_class ON pg_type.typrelid = pg_class.oid
+		WHERE (
+			pg_class.oid IS NULL
+			OR (
+				pg_class.relispartition = false
+				AND pg_class.relkind NOT IN ('S')
+				${extClassOids.length > 0 ? `AND pg_class.oid NOT IN (${extClassOids.join(", ")})` : ""}
+			)
+		)
+		${extTypeOids.length > 0 ? `AND pg_type.oid NOT IN (${extTypeOids.join(", ")})` : ""}
+		AND pg_type.typtype IN ('c', ${Object.keys(typeKindMap)
+        .map(key => `'${key}'`)
+        .join(", ")})
+		AND pg_namespace.nspname IN (${schemaNames.map(name => `'${name}'`).join(", ")})
+	`);
+    const procQuery = await db.query(`
+		SELECT
+			proname as "name",
+			nspname as "schemaName",
+			case prokind
+				when 'f' then 'function'
+				when 'p' then 'procedure'
+				when 'a' then 'aggregate'
+				when 'w' then 'window'
+			end as "kind",
+			obj_description(pg_proc.oid) as "comment"
+		FROM pg_catalog.pg_proc
+		JOIN pg_catalog.pg_namespace ON pg_namespace.oid = pg_proc.pronamespace
+		JOIN pg_catalog.pg_language ON pg_language.oid = pg_proc.prolang
+		WHERE ${extClassOids.length > 0 ? `pg_proc.oid NOT IN (${extClassOids.join(", ")}) AND` : ""}
+		pg_namespace.nspname IN (${schemaNames.map(name => `'${name}'`).join(", ")})
+		AND prokind IN ('f', 'p') -- TODO: Add support for aggregate and window functions
+		AND pg_language.lanname != 'internal'
+	`);
+    return [...typeQuery, ...procQuery];
+};
+export default fetchTypes;

package/lib/extractor/index.d.ts

@@ -0,0 +1,95 @@
+import { Client as Pg, type ConnectionConfig } from "pg";
+import { PGlite as Pglite } from "@electric-sql/pglite";
+import { type TableDetails } from "./kinds/table.ts";
+import { type ViewDetails } from "./kinds/view.ts";
+import { type MaterializedViewDetails } from "./kinds/materialized-view.ts";
+import { type EnumDetails } from "./kinds/enum.ts";
+import { type CompositeTypeDetails } from "./kinds/composite.ts";
+import { type FunctionDetails } from "./kinds/function.ts";
+import { type DomainDetails } from "./kinds/domain.ts";
+import { type RangeDetails } from "./kinds/range.ts";
+import type { PgType } from "./pgtype.ts";
+import { Canonical } from "./canonicalise.ts";
+export { Canonical };
+export type { TableDetails, ViewDetails, MaterializedViewDetails, EnumDetails, CompositeTypeDetails, FunctionDetails, DomainDetails, RangeDetails, };
+export type { TableColumn } from "./kinds/table.ts";
+export type { ViewColumn } from "./kinds/view.ts";
+export type { MaterializedViewColumn } from "./kinds/materialized-view.ts";
+export type { FunctionParameter, FunctionReturnType } from "./kinds/function.ts";
+export { FunctionReturnTypeKind } from "./kinds/function.ts";
+/**
+ * extractSchemas generates a record of all the schemas extracted, indexed by schema name.
+ * The schemas are instances of this type.
+ */
+export type Schema = {
+    name: string;
+    tables: TableDetails[];
+    views: ViewDetails[];
+    materializedViews: MaterializedViewDetails[];
+    enums: EnumDetails[];
+    composites: CompositeTypeDetails[];
+    functions: FunctionDetails[];
+    domains: DomainDetails[];
+    ranges: RangeDetails[];
+};
+export type SchemaType = TableDetails | ViewDetails | MaterializedViewDetails | EnumDetails | CompositeTypeDetails | FunctionDetails | DomainDetails | RangeDetails;
+/**
+ * This is the options object that can be passed to `extractSchemas`.
+ * @see extractSchemas
+ */
+export interface ExtractSchemaOptions {
+    /**
+     * Will contain an array of schema names to extract.
+     * If undefined, all non-system schemas will be extracted.
+     */
+    schemas?: string[];
+    /**
+     * Filter function that you can use if you want to exclude
+     * certain items from the schemas.
+     */
+    typeFilter?: (pgType: PgType) => boolean;
+    /**
+     * extractShemas will always attempt to parse view definitions to
+     * discover the "source" of each column, i.e. the table or view that it
+     * is derived from.
+     * If this option is set to `true`, it will attempt to follow this
+     * source and copy values like indices, isNullable, etc.
+     * so that the view data is closer to what the database reflects.
+     */
+    resolveViews?: boolean;
+    /**
+     * Called with the number of types to extract.
+     */
+    onProgressStart?: (total: number) => void;
+    /**
+     * Called once for each type that is extracted.
+     */
+    onProgress?: () => void;
+    /**
+     * Called when all types have been extracted.
+     */
+    onProgressEnd?: () => void;
+}
+export declare class Extractor {
+    private db;
+    /**
+     * @param connectionConfig - Connection string or configuration object for Postgres connection
+     */
+    constructor(opts: {
+        pg?: Pg | Pglite;
+        uri?: string;
+        config?: ConnectionConfig;
+    });
+    canonicalise(types: string[]): Promise<Canonical[]>;
+    getBuiltinTypes(): Promise<{
+        name: string;
+        format: string;
+        kind: string;
+    }[]>;
+    /**
+     * Perform the extraction
+     * @param options - Optional options
+     * @returns A record of all the schemas extracted, indexed by schema name.
+     */
+    extractSchemas(options?: ExtractSchemaOptions): Promise<Record<string, Schema>>;
+}