true-pg 0.6.0 → 0.8.0

package/lib/extractor/adapter.d.ts

@@ -1,16 +1,24 @@
 import Pg from "pg";
 import { PGlite as Pglite } from "@electric-sql/pglite";
+import type { Canonical, QueueMember } from "./canonicalise/index.ts";
 export declare class DbAdapter {
     private client;
     private external?;
+    resolveQueue: QueueMember[];
+    queryCount: number;
     constructor(client: Pg.Client | Pg.Pool | Pglite, external?: boolean | undefined);
+    resetQueue(): void;
+    resetQueryCount(): void;
+    reset(): void;
+    enqueue(type: string): Canonical;
+    resolve(): Promise<Canonical[]>;
     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 the connection and clear the cache
      */
     close(): Promise<void>;
 }

package/lib/extractor/adapter.js

@@ -1,13 +1,40 @@
 import Pg from "pg";
 import { PGlite as Pglite } from "@electric-sql/pglite";
+import { canonicaliseQueue } from "./canonicalise/index.js";
 export class DbAdapter {
     client;
     external;
+    resolveQueue = [];
+    queryCount = 0;
     constructor(client, external) {
         this.client = client;
         this.external = external;
     }
+    resetQueue() {
+        this.resolveQueue = [];
+    }
+    resetQueryCount() {
+        this.queryCount = 0;
+    }
+    reset() {
+        this.resetQueue();
+        this.resetQueryCount();
+    }
+    enqueue(type) {
+        const member = { type, out: {} };
+        this.resolveQueue.push(member);
+        return member.out;
+    }
+    async resolve() {
+        const results = await canonicaliseQueue(this, this.resolveQueue);
+        for (let i = 0; i < this.resolveQueue.length; i++) {
+            this.resolveQueue[i].out = results[i];
+        }
+        this.resetQueue();
+        return results;
+    }
     async connect() {
+        this.reset();
         if (this.external)
             return;
         if (this.client instanceof Pg.Pool) {
@@ -24,6 +51,7 @@ export class DbAdapter {
      * Execute a read query and return just the rows
      */
     async query(text, params) {
+        this.queryCount++;
         let stack;
         try {
             stack = new Error().stack;
@@ -47,9 +75,10 @@ export class DbAdapter {
         }
     }
     /**
-     * Close the connection if needed
+     * Close the connection and clear the cache
      */
     async close() {
+        this.reset();
         if (this.external)
             return;
         if (this.client instanceof Pg.Pool) {

package/lib/extractor/canonicalise/composite.d.ts

@@ -0,0 +1,7 @@
+import { Canonical, type ExclusiveComposite } from "./types.ts";
+import type { DbAdapter } from "../adapter.ts";
+export type { ExclusiveComposite };
+export declare function getCompositeDetails(db: DbAdapter, enqueue: (types: string) => Canonical, entries: {
+    typrelid: number;
+    canonical_name: string;
+}[]): Promise<ExclusiveComposite[]>;

package/lib/extractor/canonicalise/composite.js

@@ -0,0 +1,53 @@
+import { Canonical } from "./types.js";
+import { minifyQuery, removeNulls } from "../../util.js";
+const query = minifyQuery(`
+SELECT
+	input.seq,
+	input.relid,
+	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(a.attrelid, 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 unnest($1::oid[]) WITH ORDINALITY AS input(relid, seq)
+JOIN pg_attribute a ON a.attrelid = input.relid
+LEFT JOIN pg_attrdef d ON d.adrelid = a.attrelid AND d.adnum = a.attnum
+WHERE a.attnum > 0 AND NOT a.attisdropped
+GROUP BY input.relid, input.seq
+ORDER BY input.seq;
+`);
+// TODO: combine all recursive canonicalise calls into a single call then unnest the results
+export async function getCompositeDetails(db, enqueue, entries) {
+    if (entries.length === 0)
+        return [];
+    const results = await db.query(query, [entries.map(r => r.typrelid)]);
+    return results.map((result, index) => {
+        const attributes = result.attributes.map((attr, index) => {
+            const canonical = enqueue(attr.type_name);
+            return removeNulls({
+                name: attr.name,
+                index: attr.index,
+                type: canonical,
+                comment: attr.comment,
+                defaultValue: attr.defaultValue,
+                isNullable: attr.isNullable,
+                isIdentity: attr.isIdentity,
+                generated: attr.generated,
+            });
+        });
+        return { kind: Canonical.Kind.Composite, canonical_name: entries[index].canonical_name, attributes };
+    });
+}

package/lib/extractor/canonicalise/domain.d.ts

@@ -0,0 +1,12 @@
+import { Canonical, type ExclusiveDomain } from "./types.ts";
+import type { DbAdapter } from "../adapter.ts";
+export type { ExclusiveDomain };
+/**
+ * Fetches the canonical name of the ultimate base type for a given domain OID
+ * in a single query. If the OID is not a domain, it returns the name of the
+ * type corresponding to the original OID.
+ */
+export declare function getDomainDetails(db: DbAdapter, enqueue: (types: string) => Canonical, entries: {
+    oid: number;
+    canonical_name: string;
+}[]): Promise<ExclusiveDomain[]>;

package/lib/extractor/canonicalise/domain.js

@@ -0,0 +1,77 @@
+import { Canonical } from "./types.js";
+import { minifyQuery } from "../../util.js";
+const query = minifyQuery(`
+	WITH RECURSIVE
+	-- 1. Unnest input OIDs and sequences
+	input_data AS (
+		SELECT oid, seq
+		FROM unnest($1::oid[]) WITH ORDINALITY AS u(oid, seq)
+	),
+	-- 2. Recursively find the base type for each input OID
+	domain_chain(input_seq, current_oid, base_oid, level) AS (
+		-- Base case: Start with the input OIDs from unnested data
+		SELECT
+			i.seq,
+			i.oid,
+			t.typbasetype,
+			1
+		FROM input_data i
+		JOIN pg_type t ON t.oid = i.oid
+		WHERE t.typtype = 'd' -- Ensure it's actually a domain
+
+		UNION ALL
+
+		-- Recursive step: Follow the domain chain for each sequence
+		SELECT
+			dc.input_seq,
+			dc.base_oid, -- The current OID becomes the base OID from the previous step
+			t.typbasetype,
+			dc.level + 1
+		FROM domain_chain dc
+		JOIN pg_type t ON dc.base_oid = t.oid
+		WHERE t.typtype = 'd' -- Continue only if the next type is also a domain
+	),
+	-- 3. Determine the final base OID for each sequence
+	final_base AS (
+		SELECT DISTINCT ON (i.seq)
+			i.seq,
+			-- Use the ultimate base_oid from the chain if it exists for this seq,
+			-- otherwise fallback to the original input OID for this seq
+			COALESCE(
+				(SELECT dc.base_oid FROM domain_chain dc WHERE dc.input_seq = i.seq ORDER BY dc.level DESC LIMIT 1),
+				i.oid
+			) AS oid
+		FROM input_data i
+	)
+	-- 4. Fetch the formatted name for the final OID for each sequence
+	SELECT
+		fb.seq,
+		format('%I.%I', n.nspname, t.typname) AS name
+	FROM final_base fb
+	JOIN pg_type t ON t.oid = fb.oid
+	JOIN pg_namespace n ON t.typnamespace = n.oid
+	ORDER BY fb.seq;
+`);
+/**
+ * Fetches the canonical name of the ultimate base type for a given domain OID
+ * in a single query. If the OID is not a domain, it returns the name of the
+ * type corresponding to the original OID.
+ */
+export async function getDomainDetails(db, enqueue, entries) {
+    if (entries.length === 0)
+        return [];
+    const results = await db.query(query, [entries.map(i => i.oid)]);
+    // Basic check for result length mismatch
+    if (results.length !== entries.length) {
+        throw new Error("Mismatch between input domain count and domain detail results count.");
+    }
+    return results.map((result, index) => {
+        const { canonical_name, oid } = entries[index];
+        const name = result.name;
+        if (!name) {
+            throw new Error(`Could not resolve base type for domain ${canonical_name} (OID: ${oid}).`);
+        }
+        const canonicalBaseType = enqueue(name);
+        return { kind: Canonical.Kind.Domain, canonical_name, domain_base_type: canonicalBaseType };
+    });
+}

package/lib/extractor/canonicalise/enum.d.ts

@@ -0,0 +1,8 @@
+import { type ExclusiveEnum } from "./types.ts";
+import type { DbAdapter } from "../adapter.ts";
+export type { ExclusiveEnum };
+/** Fetches enum values for given enum type OIDs */
+export declare function getEnumDetails(db: DbAdapter, entries: {
+    oid: number;
+    canonical_name: string;
+}[]): Promise<ExclusiveEnum[]>;

package/lib/extractor/canonicalise/enum.js

@@ -0,0 +1,22 @@
+import { Canonical } from "./types.js";
+import { minifyQuery } from "../../util.js";
+const query = minifyQuery(`
+SELECT
+	input.seq,
+	json_agg(e.enumlabel ORDER BY e.enumsortorder) AS values
+FROM unnest($1::oid[]) WITH ORDINALITY AS input(oid, seq)
+JOIN pg_enum e ON e.enumtypid = input.oid
+GROUP BY input.seq, e.enumtypid
+ORDER BY input.seq;
+`);
+/** Fetches enum values for given enum type OIDs */
+export async function getEnumDetails(db, entries) {
+    if (entries.length === 0)
+        return [];
+    const results = await db.query(query, [entries.map(o => o.oid)]);
+    return results.map((r, i) => ({
+        kind: Canonical.Kind.Enum,
+        canonical_name: entries[i].canonical_name,
+        enum_values: r.values,
+    }));
+}

package/lib/extractor/canonicalise/index.d.ts

@@ -0,0 +1,11 @@
+import { Canonical, type ExclusiveCanonProps } from "./types.ts";
+import { DbAdapter } from "../adapter.ts";
+import { type ResolvedBasicInfo } from "./resolve.ts";
+export { Canonical, type ExclusiveCanonProps };
+export interface QueueMember {
+    type: string;
+    out: Canonical;
+}
+export declare const canonicaliseQueue: (db: DbAdapter, queue: QueueMember[], resolveCache?: Map<string, ResolvedBasicInfo>, canonCache?: Map<string, ExclusiveCanonProps>) => Promise<Canonical[]>;
+export declare const oidsToQualifiedNames: (db: DbAdapter, oids: number[]) => Promise<string[]>;
+export declare const canonicaliseFromOids: (db: DbAdapter, oids: number[]) => Promise<Canonical[]>;

package/lib/extractor/canonicalise/index.js

@@ -0,0 +1,148 @@
+import { Canonical } from "./types.js";
+import { DbAdapter } from "../adapter.js";
+import { resolveBasicInfo } from "./resolve.js";
+import { parseRawType } from "./parse.js";
+import { getEnumDetails } from "./enum.js";
+import { getCompositeDetails } from "./composite.js";
+import { getDomainDetails } from "./domain.js";
+import { getRangeDetails } from "./range.js";
+export { Canonical };
+// The Final Strategy
+//
+// Insert placeholder objects wherever a Canonical is needed
+// After extracting all tables, views, functions, etc. resolve all Canonicals
+// Then map over the input types and wait for all cached promises to resolve
+// Finally patch all Canonicals with resolved values
+export const canonicaliseQueue = async (db, queue, resolveCache = new Map(), canonCache = new Map()) => {
+    if (queue.length === 0)
+        return [];
+    const parsed = queue.map(q => parseRawType(q.type));
+    const plain = [...new Set(parsed.filter(p => !resolveCache.has(p.plain)).map(p => p.plain))];
+    const resolved = await resolveBasicInfo(db, plain);
+    plain.forEach((p, i) => {
+        const r = resolved[i];
+        if (!r)
+            throw new Error(`(Unreachable) Could not find resolved basic info for ${p}`);
+        resolveCache.set(p, r);
+    });
+    const unknown = resolved.filter(r => r.kind === Canonical.Kind.Unknown);
+    if (unknown.length > 0) {
+        const types = unknown.map(u => u.canonical_name).join(", ");
+        throw new Error(`Received kind 'unknown', could not resolve ${unknown.length} types: ${types}`);
+    }
+    const internalQueue = [];
+    const q = (types) => {
+        const member = { type: types, out: {} };
+        internalQueue.push(member);
+        return member.out;
+    };
+    const batches = {
+        enums: [],
+        composites: [],
+        domains: [],
+        ranges: [],
+    };
+    let seen = new Set();
+    const Kind = Canonical.Kind;
+    // split in one loop instead of 4 filters
+    for (const r of resolved) {
+        if (canonCache.has(r.canonical_name))
+            continue;
+        // deduplicate
+        if (seen.has(r.canonical_name))
+            continue;
+        seen.add(r.canonical_name);
+        if (r.kind === Kind.Enum)
+            batches.enums.push(r);
+        if (r.kind === Kind.Composite)
+            batches.composites.push(r);
+        if (r.kind === Kind.Domain)
+            batches.domains.push(r);
+        if (r.kind === Kind.Range)
+            batches.ranges.push(r);
+        // special cases because these are not further extracted
+        if (r.kind === Kind.Base || r.kind === Kind.Pseudo)
+            canonCache.set(r.canonical_name, { kind: r.kind, canonical_name: r.canonical_name });
+    }
+    // @ts-expect-error allow GC
+    seen = null;
+    {
+        // extract all in parallel
+        const [enums, composites, domains, ranges] = await Promise.all([
+            getEnumDetails(db, batches.enums),
+            getCompositeDetails(db, q, batches.composites),
+            getDomainDetails(db, q, batches.domains),
+            getRangeDetails(db, q, batches.ranges),
+        ]);
+        for (const e of enums)
+            canonCache.set(e.canonical_name, e);
+        for (const c of composites)
+            canonCache.set(c.canonical_name, c);
+        for (const d of domains)
+            canonCache.set(d.canonical_name, d);
+        for (const r of ranges)
+            canonCache.set(r.canonical_name, r);
+    }
+    await Promise.all(parsed.map(async (p, index) => {
+        const info = resolveCache.get(p.plain);
+        if (!info)
+            throw new Error(`(Unreachable) Could not find resolved basic info for ${p.plain}`);
+        const m = queue[index];
+        try {
+            const dimensions = p.dimensions + info.internal_dimensions;
+            const common = {
+                kind: info.kind,
+                oid: info.oid,
+                typrelid: info.typrelid,
+                typbasetype: info.typbasetype,
+                rngsubtype: info.rngsubtype,
+                canonical_name: info.canonical_name,
+                schema: info.schema,
+                name: info.name,
+                original_type: p.original,
+                modifiers: p.modifiers,
+                dimensions,
+            };
+            const kind = info.kind;
+            if (kind === Canonical.Kind.Unknown)
+                throw new Error(`Could not find canonical type for "${info.schema}.${info.canonical_name}"`);
+            const exclusive = canonCache.get(info.canonical_name);
+            if (!exclusive)
+                throw new Error(`(Unreachable) Could not find canonical type for ${info.canonical_name}`);
+            const result = { ...common, ...exclusive };
+            Object.assign(m.out, result);
+        }
+        catch (error) {
+            throw error;
+        }
+    }));
+    if (internalQueue.length > 0) {
+        await canonicaliseQueue(db, internalQueue, resolveCache, canonCache);
+    }
+    return queue.map(m => m.out);
+};
+export const oidsToQualifiedNames = async (db, oids) => {
+    if (oids.length === 0)
+        return [];
+    const query = `
+		SELECT
+			input.ord,
+			format('%I.%I', n.nspname, t.typname) AS qualified_name
+		-- Use unnest WITH ORDINALITY because SQL doesn't guarantee order of SELECT results
+		FROM unnest($1::oid[]) WITH ORDINALITY AS input(oid, ord)
+		JOIN pg_type t ON t.oid = input.oid
+		JOIN pg_namespace n ON t.typnamespace = n.oid
+		ORDER BY input.ord;
+	`;
+    const results = await db.query(query, [oids]);
+    return results.map(r => r.qualified_name);
+};
+export const canonicaliseFromOids = async (db, oids) => {
+    if (oids.length === 0)
+        return [];
+    const types = await oidsToQualifiedNames(db, oids);
+    const unknown = types.filter(name => name == undefined);
+    if (unknown.length > 0)
+        throw new Error(`Failed to resolve OIDs to type names: ${unknown.join(", ")}`);
+    return canonicaliseQueue(db, types.map(t => ({ type: t, out: {} })));
+};

package/lib/extractor/canonicalise/parse.d.ts

@@ -0,0 +1,43 @@
+export interface ParsedType {
+    /** Name after removing modifiers and brackets, e.g. "varchar" in "varchar(50)" */
+    plain: string;
+    /** Modifiers, e.g. "50" in "varchar(50)" */
+    modifiers: string | null;
+    /** Number of dimensions from explicit brackets, e.g. 1 in "int[]" */
+    dimensions: number;
+    /** Original type name, e.g. "varchar(50)" */
+    original: string;
+}
+/**
+ * Parses a PostgreSQL type name string to extract its base name,
+ * modifiers, and dimensions from explicit '[]' brackets.
+ *
+ * Examples:
+ *
+ * - `parseTypeName("varchar(50)")`
+ *
+ *		`⤷ { plain: "varchar", modifiers: "50", dimensions: 0, original: "varchar(50)" }`
+ *
+ * - `parseTypeName("int[]")`
+ *
+ *		`⤷ { plain: "int", modifiers: null, dimensions: 1, original: "int[]" }`
+ *
+ * - `parseTypeName("public.my_table[][]")`
+ *
+ *		`⤷ { plain: "public.my_table", modifiers: null, dimensions: 2, original: "public.my_table[][]" }`
+ *
+ * - `parseTypeName("numeric(10, 2)[]")`
+ *
+ *		`⤷ { plain: "numeric", modifiers: "10, 2", dimensions: 1, original: "numeric(10, 2)[]" }`
+ *
+ * - `parseTypeName("geometry(Point, 4326)")`
+ *
+ *		`⤷ { plain: "geometry", modifiers: "Point, 4326", dimensions: 0, original: "geometry(Point, 4326)" }`
+ *
+ * - `parseTypeName("_text")`
+ *
+ *		`⤷ { plain: "_text", modifiers: null, dimensions: 0, original: "_text" }`
+ *
+ *		Internal arrays aren't handled here
+ */
+export declare function parseRawType(type: string): ParsedType;

package/lib/extractor/canonicalise/parse.js

@@ -0,0 +1,50 @@
+/**
+ * Parses a PostgreSQL type name string to extract its base name,
+ * modifiers, and dimensions from explicit '[]' brackets.
+ *
+ * Examples:
+ *
+ * - `parseTypeName("varchar(50)")`
+ *
+ *		`⤷ { plain: "varchar", modifiers: "50", dimensions: 0, original: "varchar(50)" }`
+ *
+ * - `parseTypeName("int[]")`
+ *
+ *		`⤷ { plain: "int", modifiers: null, dimensions: 1, original: "int[]" }`
+ *
+ * - `parseTypeName("public.my_table[][]")`
+ *
+ *		`⤷ { plain: "public.my_table", modifiers: null, dimensions: 2, original: "public.my_table[][]" }`
+ *
+ * - `parseTypeName("numeric(10, 2)[]")`
+ *
+ *		`⤷ { plain: "numeric", modifiers: "10, 2", dimensions: 1, original: "numeric(10, 2)[]" }`
+ *
+ * - `parseTypeName("geometry(Point, 4326)")`
+ *
+ *		`⤷ { plain: "geometry", modifiers: "Point, 4326", dimensions: 0, original: "geometry(Point, 4326)" }`
+ *
+ * - `parseTypeName("_text")`
+ *
+ *		`⤷ { plain: "_text", modifiers: null, dimensions: 0, original: "_text" }`
+ *
+ *		Internal arrays aren't handled here
+ */
+export function parseRawType(type) {
+    let base = type;
+    let modifiers = null;
+    let dimensions = 0;
+    // 1. Extract modifiers (content within the last parentheses)
+    const modifierMatch = base.match(/\(([^)]*)\)$/);
+    if (modifierMatch) {
+        modifiers = modifierMatch[1];
+        base = base.substring(0, modifierMatch.index).trim();
+    }
+    // 2. Count and remove explicit array brackets '[]'
+    // Repeatedly remove '[]' from the end and count dimensions
+    while (base.endsWith("[]")) {
+        dimensions++;
+        base = base.slice(0, -2);
+    }
+    return { original: type, plain: base, modifiers, dimensions };
+}

package/lib/extractor/canonicalise/range.d.ts

@@ -0,0 +1,11 @@
+import type { DbAdapter } from "../adapter.ts";
+import type { ExclusiveRange } from "./types.ts";
+import { Canonical } from "./types.ts";
+export type { ExclusiveRange };
+/**
+ * Fetches the canonical name of the subtype for given range OIDs, ordered by sequence.
+ */
+export declare function getRangeDetails(db: DbAdapter, enqueue: (types: string) => Canonical, entries: {
+    oid: number;
+    canonical_name: string;
+}[]): Promise<ExclusiveRange[]>;

package/lib/extractor/canonicalise/range.js

@@ -0,0 +1,36 @@
+import { minifyQuery } from "../../util.js";
+import { Canonical } from "./types.js";
+const query = minifyQuery(`
+	-- Fetch the formatted name for each input OID, ordered by sequence
+	SELECT
+		u.seq,
+		format('%I.%I', n.nspname, t.typname) AS name
+	FROM unnest($1::oid[]) WITH ORDINALITY AS u(oid, seq)
+	JOIN pg_type t ON t.oid = u.oid
+	JOIN pg_namespace n ON t.typnamespace = n.oid
+	ORDER BY u.seq;
+`);
+/**
+ * Fetches the canonical name of the subtype for given range OIDs, ordered by sequence.
+ */
+export async function getRangeDetails(db, enqueue, entries) {
+    if (entries.length === 0)
+        return [];
+    const oids = entries.map(i => i.oid);
+    const results = await db.query(query, [oids]);
+    if (results.length !== entries.length) {
+        throw new Error("Mismatch between input range count and range detail results count.");
+    }
+    return results.map((result, index) => {
+        const { canonical_name } = entries[index];
+        const subtypeName = result.name;
+        if (!subtypeName) {
+            throw new Error(`Range ${canonical_name} (Subtype OID: ${oids[index]}) lacks a resolved subtype name.`);
+        }
+        const canonicalSubtype = enqueue(subtypeName);
+        if (!canonicalSubtype) {
+            throw new Error(`Failed to canonicalise subtype "${subtypeName}" for Range ${canonical_name} (Subtype OID: ${oids[index]}).`);
+        }
+        return { kind: Canonical.Kind.Range, canonical_name, range_subtype: canonicalSubtype };
+    });
+}

package/lib/extractor/canonicalise/resolve.d.ts

@@ -0,0 +1,19 @@
+import type { DbAdapter } from "../adapter.ts";
+import type { Canonical } from "./types.ts";
+export interface ResolvedBasicInfo {
+    original_name: string;
+    oid: number;
+    internal_dimensions: number;
+    schema: string;
+    name: string;
+    canonical_name: string;
+    kind: Canonical.Kind;
+    typrelid: number;
+    typbasetype: number;
+    rngsubtype: number;
+}
+/**
+ * Takes base type names (without modifiers/brackets), resolves them to their ultimate base type OID
+ * and internal array dimensions, and fetches basic kind information
+ */
+export declare function resolveBasicInfo(db: DbAdapter, types: string[]): Promise<ResolvedBasicInfo[]>;

package/lib/extractor/canonicalise/resolve.js

@@ -0,0 +1,59 @@
+import { minifyQuery } from "../../util.js";
+const query = minifyQuery(`
+WITH RECURSIVE
+input(base_type_name, seq) AS (
+	SELECT * FROM unnest($1::text[]) WITH ORDINALITY
+),
+type_resolution(seq, current_oid, level) AS (
+	-- Base case: Look up the initial base type name
+	SELECT i.seq, t.oid, 1, i.base_type_name
+	FROM input i JOIN pg_type t ON t.oid = i.base_type_name::regtype
+	UNION ALL
+	-- Recursive step: Follow typelem for standard arrays (_)
+	SELECT r.seq, t.typelem, r.level + 1, r.base_type_name
+	FROM type_resolution r JOIN pg_type t ON r.current_oid = t.oid
+	-- // TODO: do a more robust check for array types than 'left(t.typname, 1) = '_'
+	WHERE t.typelem != 0 AND left(t.typname, 1) = '_'
+),
+final_resolution AS (
+	-- Get the OID and max level (depth) for each sequence number
+	SELECT DISTINCT ON (seq) seq, current_oid AS base_type_oid, level, base_type_name
+	FROM type_resolution ORDER BY seq, level DESC
+)
+-- Combine resolution with basic type info fetching
+SELECT
+	fr.seq,
+	fr.base_type_name as original_name,
+	fr.base_type_oid AS oid,
+	(fr.level - 1) AS internal_dimensions,
+	n.nspname AS schema,
+	t.typname AS name,
+	n.nspname || '.' || t.typname AS canonical_name,
+	CASE t.typtype
+		WHEN 'b' THEN 'base'::text
+		WHEN 'c' THEN 'composite'::text
+		WHEN 'd' THEN 'domain'::text
+		WHEN 'e' THEN 'enum'::text
+		WHEN 'p' THEN 'pseudo'::text
+		WHEN 'r' THEN 'range'::text
+		ELSE 'unknown'::text
+	END AS kind,
+	t.typrelid, -- needed for composite details
+	t.typbasetype, -- needed for domain details
+	COALESCE(r.rngsubtype, 0) AS rngsubtype -- needed for range details
+FROM final_resolution fr
+JOIN pg_type t ON t.oid = fr.base_type_oid
+JOIN pg_namespace n ON t.typnamespace = n.oid
+LEFT JOIN pg_range r ON t.oid = r.rngtypid AND t.typtype = 'r'
+ORDER BY fr.seq;
+`);
+/**
+ * Takes base type names (without modifiers/brackets), resolves them to their ultimate base type OID
+ * and internal array dimensions, and fetches basic kind information
+ */
+export async function resolveBasicInfo(db, types) {
+    if (types.length === 0)
+        return [];
+    const results = await db.query(query, [types]);
+    return results;
+}