true-pg 0.2.2 → 0.3.0

package/lib/extractor/index.js

@@ -0,0 +1,140 @@
+import { Client as Pg } from "pg";
+import { PGlite as Pglite } from "@electric-sql/pglite";
+import { DbAdapter } from "./adapter.js";
+import extractTable, {} from "./kinds/table.js";
+import extractView, {} from "./kinds/view.js";
+import extractMaterializedView, {} from "./kinds/materialized-view.js";
+import extractEnum, {} from "./kinds/enum.js";
+import extractComposite, {} from "./kinds/composite.js";
+import extractFunction, {} from "./kinds/function.js";
+import extractDomain, {} from "./kinds/domain.js";
+import extractRange, {} from "./kinds/range.js";
+import fetchTypes from "./fetchTypes.js";
+import { canonicalise, Canonical } from "./canonicalise.js";
+export { Canonical };
+export { FunctionReturnTypeKind } from "./kinds/function.js";
+const emptySchema = {
+    tables: [],
+    views: [],
+    materializedViews: [],
+    enums: [],
+    composites: [],
+    functions: [],
+    domains: [],
+    ranges: [],
+};
+const populatorMap = {
+    table: extractTable,
+    view: extractView,
+    materializedView: extractMaterializedView,
+    enum: extractEnum,
+    composite: extractComposite,
+    function: extractFunction,
+    domain: extractDomain,
+    range: extractRange,
+};
+export class Extractor {
+    db;
+    /**
+     * @param connectionConfig - Connection string or configuration object for Postgres connection
+     */
+    constructor(opts) {
+        let pg;
+        if (opts.pg)
+            pg = opts.pg;
+        else if (opts.uri)
+            pg = new Pg({ connectionString: opts.uri });
+        else if (opts.config)
+            pg = new Pg(opts.config);
+        else {
+            console.error("One of these options are required in your config file: pg, uri, config. See documentation for more information.");
+            process.exit(1);
+        }
+        this.db = new DbAdapter(pg);
+    }
+    async canonicalise(types) {
+        return canonicalise(this.db, types);
+    }
+    async getBuiltinTypes() {
+        await this.db.connect();
+        const db = this.db;
+        const query = `
+			SELECT
+				t.typname AS name,
+				t.typlen AS internal_size,
+				pg_catalog.format_type(t.oid, NULL) AS format,
+				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 kind
+			FROM pg_catalog.pg_type t
+			WHERE t.typnamespace = 'pg_catalog'::regnamespace
+			ORDER BY name;
+		`;
+        const result = await db.query(query);
+        await db.close();
+        return result;
+    }
+    /**
+     * Perform the extraction
+     * @param options - Optional options
+     * @returns A record of all the schemas extracted, indexed by schema name.
+     */
+    async extractSchemas(options) {
+        await this.db.connect();
+        const db = this.db;
+        const q = await db.query(`
+			SELECT nspname FROM pg_catalog.pg_namespace
+			WHERE nspname != 'information_schema'
+			AND nspname NOT LIKE 'pg_%'
+		`);
+        const allSchemaNames = q.map(r => r.nspname);
+        const schemaNames = options?.schemas ?? allSchemaNames;
+        if (options?.schemas) {
+            const missingSchemas = schemaNames.filter(schemaName => !allSchemaNames.includes(schemaName));
+            if (missingSchemas.length > 0) {
+                throw new Error(`No schemas found for ${missingSchemas.join(", ")}`);
+            }
+        }
+        const pgTypes = await fetchTypes(db, schemaNames);
+        const filtered = options?.typeFilter ? pgTypes.filter(element => options.typeFilter(element)) : pgTypes;
+        const typesToExtract = filtered.filter(x => x.kind);
+        const skipped = filtered.filter(x => !x.kind).map(x => x.name);
+        if (skipped.length) {
+            console.warn("Skipping types of unsupported kinds:", skipped.join(", "));
+            console.warn("This is a bug!");
+        }
+        options?.onProgressStart?.(typesToExtract.length);
+        const populated = (await Promise.all(typesToExtract.map(async (pgType) => {
+            const result = await populatorMap[pgType.kind](db, pgType);
+            options?.onProgress?.();
+            return result;
+        }))).flat();
+        const schemas = {};
+        for (const p of populated) {
+            if (!(p.schemaName in schemas)) {
+                schemas[p.schemaName] = {
+                    name: p.schemaName,
+                    ...emptySchema,
+                };
+            }
+            schemas[p.schemaName][`${p.kind}s`] = [
+                ...schemas[p.schemaName][`${p.kind}s`],
+                p,
+            ];
+        }
+        const result = 
+        //  options?.resolveViews
+        // 	? resolveViewColumns(schemas)
+        // :
+        schemas;
+        options?.onProgressEnd?.();
+        await db.close();
+        return result;
+    }
+}

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

@@ -0,0 +1,15 @@
+import type { DbAdapter } from "../adapter.ts";
+import type { PgType } from "../pgtype.ts";
+import { Canonical } from "../canonicalise.ts";
+/**
+ * Composite type in a schema with details.
+ */
+export interface CompositeTypeDetails extends PgType<"composite"> {
+    /**
+     * Canonical representation of the composite type
+     * with full attribute details.
+     */
+    canonical: Canonical.Composite;
+}
+declare const extractComposite: (db: DbAdapter, composite: PgType<"composite">) => Promise<CompositeTypeDetails>;
+export default extractComposite;

package/lib/extractor/kinds/composite.js

@@ -0,0 +1,13 @@
+import { Canonical, canonicalise } from "../canonicalise.js";
+const extractComposite = async (db, composite) => {
+    // Form the fully qualified type name
+    const fullTypeName = `"${composite.schemaName}"."${composite.name}"`;
+    // Get canonical type information with all the metadata
+    const [canonical] = await canonicalise(db, [fullTypeName]);
+    // Return the composite type with its canonical representation
+    return {
+        ...composite,
+        canonical: canonical,
+    };
+};
+export default extractComposite;

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

@@ -0,0 +1,15 @@
+import type { DbAdapter } from "../adapter.ts";
+import type { PgType } from "../pgtype.ts";
+import { Canonical } from "../canonicalise.ts";
+/**
+ * Domain type in a schema with details.
+ */
+export interface DomainDetails extends PgType<"domain"> {
+    /**
+     * Canonical representation of the domain type
+     * with full attribute details.
+     */
+    canonical: Canonical.Domain;
+}
+declare const extractDomain: (db: DbAdapter, domain: PgType<"domain">) => Promise<DomainDetails>;
+export default extractDomain;

package/lib/extractor/kinds/domain.js

@@ -0,0 +1,13 @@
+import { Canonical, canonicalise } from "../canonicalise.js";
+const extractDomain = async (db, domain) => {
+    // Form the fully qualified type name
+    const fullTypeName = `"${domain.schemaName}"."${domain.name}"`;
+    // Get canonical type information with all the metadata
+    const [canonical] = await canonicalise(db, [fullTypeName]);
+    // Return the composite type with its canonical representation
+    return {
+        ...domain,
+        canonical: canonical,
+    };
+};
+export default extractDomain;

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

@@ -0,0 +1,9 @@
+import { DbAdapter } from "../adapter.ts";
+import type { PgType } from "../pgtype.ts";
+/** Enum type in a schema. */
+export interface EnumDetails extends PgType<"enum"> {
+    /** Array of enum values in order. */
+    values: string[];
+}
+declare const extractEnum: (db: DbAdapter, pgEnum: PgType<"enum">) => Promise<EnumDetails>;
+export default extractEnum;

package/lib/extractor/kinds/enum.js

@@ -0,0 +1,20 @@
+import { DbAdapter } from "../adapter.js";
+const extractEnum = async (db, pgEnum) => {
+    const results = await db.query(`
+		SELECT
+			json_agg(pg_enum.enumlabel ORDER BY pg_enum.enumsortorder) as "values"
+		FROM
+			pg_type
+			JOIN pg_namespace ON pg_type.typnamespace = pg_namespace.oid
+			JOIN pg_enum ON pg_type.oid = pg_enum.enumtypid
+		WHERE
+			pg_type.typtype = 'e'
+			AND pg_namespace.nspname = $2
+			AND typname = $1
+		`, [pgEnum.name, pgEnum.schemaName]);
+    return {
+        ...pgEnum,
+        ...results[0],
+    };
+};
+export default extractEnum;

package/lib/extractor/kinds/function.d.ts

@@ -0,0 +1,73 @@
+import type { DbAdapter } from "../adapter.ts";
+import type { PgType } from "../pgtype.ts";
+import { Canonical } from "../canonicalise.ts";
+declare const parameterModeMap: {
+    readonly i: "IN";
+    readonly o: "OUT";
+    readonly b: "INOUT";
+    readonly v: "VARIADIC";
+    readonly t: "TABLE";
+};
+type ParameterMode = (typeof parameterModeMap)[keyof typeof parameterModeMap];
+export type FunctionParameter = {
+    name: string;
+    type: Canonical;
+    mode: ParameterMode;
+    hasDefault: boolean;
+    ordinalPosition: number;
+};
+declare const volatilityMap: {
+    readonly i: "IMMUTABLE";
+    readonly s: "STABLE";
+    readonly v: "VOLATILE";
+};
+type FunctionVolatility = (typeof volatilityMap)[keyof typeof volatilityMap];
+declare const parallelSafetyMap: {
+    readonly s: "SAFE";
+    readonly r: "RESTRICTED";
+    readonly u: "UNSAFE";
+};
+type FunctionParallelSafety = (typeof parallelSafetyMap)[keyof typeof parallelSafetyMap];
+export declare enum FunctionReturnTypeKind {
+    Regular = "regular",
+    InlineTable = "inline_table",
+    ExistingTable = "table"
+}
+export declare namespace FunctionReturnType {
+    type Regular = {
+        kind: FunctionReturnTypeKind.Regular;
+        type: Canonical;
+        isSet: boolean;
+    };
+    type InlineTable = {
+        kind: FunctionReturnTypeKind.InlineTable;
+        columns: {
+            name: string;
+            type: Canonical;
+        }[];
+        isSet: boolean;
+    };
+    type ExistingTable = {
+        kind: FunctionReturnTypeKind.ExistingTable;
+        schema: string;
+        name: string;
+        isSet: boolean;
+    };
+}
+export type FunctionReturnType = FunctionReturnType.Regular | FunctionReturnType.InlineTable | FunctionReturnType.ExistingTable;
+export interface FunctionDetails extends PgType<"function"> {
+    parameters: FunctionParameter[];
+    returnType: FunctionReturnType;
+    language: string;
+    definition: string;
+    isStrict: boolean;
+    isSecurityDefiner: boolean;
+    isLeakProof: boolean;
+    volatility: FunctionVolatility;
+    parallelSafety: FunctionParallelSafety;
+    estimatedCost: number;
+    estimatedRows: number | null;
+    comment: string | null;
+}
+declare function extractFunction(db: DbAdapter, pgType: PgType<"function">): Promise<FunctionDetails[]>;
+export default extractFunction;

package/lib/extractor/kinds/function.js

@@ -0,0 +1,179 @@
+import { canonicalise, Canonical } from "../canonicalise.js";
+import { parsePostgresTableDefinition } from "./util/parseInlineTable.js";
+const parameterModeMap = {
+    i: "IN",
+    o: "OUT",
+    b: "INOUT",
+    v: "VARIADIC",
+    t: "TABLE",
+};
+const removeNulls = (o) => {
+    for (const key in o)
+        if (o[key] === null)
+            delete o[key];
+    return o;
+};
+const INPUT_MODES = ["i", "b", "v"];
+const volatilityMap = {
+    i: "IMMUTABLE",
+    s: "STABLE",
+    v: "VOLATILE",
+};
+const parallelSafetyMap = {
+    s: "SAFE",
+    r: "RESTRICTED",
+    u: "UNSAFE",
+};
+export var FunctionReturnTypeKind;
+(function (FunctionReturnTypeKind) {
+    FunctionReturnTypeKind["Regular"] = "regular";
+    FunctionReturnTypeKind["InlineTable"] = "inline_table";
+    FunctionReturnTypeKind["ExistingTable"] = "table";
+})(FunctionReturnTypeKind || (FunctionReturnTypeKind = {}));
+async function extractFunction(db, pgType) {
+    const query = `
+		SELECT
+			p.proname as name,
+			format_type(p.prorettype, null) as return_type_string,
+			l.lanname AS language,
+			p.prosrc AS definition,
+			p.proisstrict AS is_strict,
+			p.prosecdef AS is_security_definer,
+			p.proleakproof AS is_leak_proof,
+			p.proretset AS returns_set,
+			p.provolatile AS volatility,
+			p.proparallel AS parallel_safety,
+			p.procost AS estimated_cost,
+			CASE WHEN p.proretset THEN p.prorows ELSE NULL END AS estimated_rows,
+			d.description AS comment,
+			p.prorettype,
+			p.proargnames as arg_names,
+			array_to_json(p.proargmodes) AS arg_modes,
+			array_to_json(COALESCE(p.proallargtypes::regtype[], p.proargtypes::regtype[])) AS arg_types,
+			pronargs,
+			p.pronargdefaults as default_arg_count,
+			p.proargdefaults as arg_defaults,
+			pg_get_function_arguments(p.oid) AS arg_list,
+			pg_get_function_identity_arguments(p.oid) AS identity_args,
+			pg_get_function_result(p.oid) as declared_return_type,
+			ret_typ.typtype as return_type_kind_code,
+			ret_typ_ns.nspname as return_type_schema,
+			ret_typ.typname as return_type_name,
+			ret_typ.typrelid as return_type_relation_oid,
+			ret_rel.relkind as return_type_relation_kind
+		FROM pg_proc p
+		LEFT JOIN pg_namespace n ON n.oid = p.pronamespace
+		LEFT JOIN pg_description d ON d.objoid = p.oid
+		LEFT JOIN pg_language l ON l.oid = p.prolang
+		LEFT JOIN pg_type ret_typ ON ret_typ.oid = p.prorettype
+		LEFT JOIN pg_namespace ret_typ_ns ON ret_typ.typnamespace = ret_typ_ns.oid
+		LEFT JOIN pg_class ret_rel ON ret_rel.oid = ret_typ.typrelid
+		WHERE n.nspname = $1 AND p.proname = $2
+	`;
+    const rows = await db.query(query, [pgType.schemaName, pgType.name]);
+    const functions = Promise.all(rows.map(async (row) => {
+        if (row.arg_names && !row.arg_modes)
+            row.arg_modes = row.arg_names.map(() => "i");
+        const argModes = row.arg_modes?.map(mode => parameterModeMap[mode]) ?? [];
+        const canonical_arg_types = row.arg_types ? await canonicalise(db, row.arg_types) : [];
+        let returnType;
+        const tableMatch = row.declared_return_type.match(/^TABLE\((.*)\)$/i);
+        if (tableMatch) {
+            const columnDefs = parsePostgresTableDefinition(row.declared_return_type);
+            const columnTypes = columnDefs.map(col => col.type);
+            const canonicalColumnTypes = await canonicalise(db, columnTypes);
+            returnType = {
+                kind: FunctionReturnTypeKind.InlineTable,
+                columns: columnDefs.map((col, i) => ({
+                    name: col.name,
+                    type: canonicalColumnTypes[i],
+                })),
+                isSet: row.returns_set,
+            };
+        }
+        else {
+            // "c" = composite type
+            if (row.return_type_kind_code === "c") {
+                if (
+                // "r" = table
+                row.return_type_relation_kind === "r" ||
+                    // "v" = view
+                    row.return_type_relation_kind === "v" ||
+                    // "m" = materialized view
+                    row.return_type_relation_kind === "m") {
+                    returnType = {
+                        kind: FunctionReturnTypeKind.ExistingTable,
+                        schema: row.return_type_schema,
+                        name: row.return_type_name,
+                        isSet: row.returns_set,
+                    };
+                }
+                else if (
+                // "c" = composite type
+                row.return_type_relation_kind === "c") {
+                    const canonicalReturnType = (await canonicalise(db, [row.return_type_string]))[0];
+                    returnType = {
+                        kind: FunctionReturnTypeKind.Regular,
+                        type: canonicalReturnType,
+                        isSet: row.returns_set,
+                    };
+                }
+                else {
+                    console.warn(`Composite return type '${row.return_type_string}' has unexpected relkind '${row.return_type_relation_kind}' for function ${pgType.schemaName}.${row.name}`);
+                    const canonicalReturnType = (await canonicalise(db, [row.return_type_string]))[0];
+                    returnType = {
+                        kind: FunctionReturnTypeKind.Regular,
+                        type: canonicalReturnType,
+                        isSet: row.returns_set,
+                    };
+                }
+            }
+            else {
+                const canonicalReturnType = (await canonicalise(db, [row.return_type_string]))[0];
+                returnType = {
+                    kind: FunctionReturnTypeKind.Regular,
+                    type: canonicalReturnType,
+                    isSet: row.returns_set,
+                };
+            }
+        }
+        // Filter to include IN, INOUT, and VARIADIC parameters as input parameters
+        const inputParams = row.arg_modes
+            ?.map((mode, index) => ({ mode, index }))
+            .filter(item => INPUT_MODES.includes(item.mode))
+            .map(item => item.index) ?? [];
+        const parameters = row.arg_types?.map((_, i) => {
+            const name = row.arg_names?.[i] ?? `$${i + 1}`;
+            const isInputParam = INPUT_MODES.includes(row.arg_modes?.[i] ?? "i");
+            const inputParamIndex = inputParams.indexOf(i);
+            const hasDefault = isInputParam && inputParamIndex >= inputParams.length - (row.default_arg_count ?? 0);
+            return {
+                name,
+                type: canonical_arg_types[i],
+                mode: argModes[i] ?? "IN",
+                hasDefault,
+                ordinalPosition: i + 1,
+            };
+        }) ?? [];
+        const func = {
+            name: row.name,
+            schemaName: pgType.schemaName,
+            kind: "function",
+            comment: row.comment,
+            definition: row.definition,
+            estimatedCost: row.estimated_cost,
+            estimatedRows: row.estimated_rows,
+            language: row.language,
+            isStrict: row.is_strict,
+            isSecurityDefiner: row.is_security_definer,
+            isLeakProof: row.is_leak_proof,
+            parameters,
+            volatility: volatilityMap[row.volatility],
+            parallelSafety: parallelSafetyMap[row.parallel_safety],
+            returnType: removeNulls(returnType),
+        };
+        return func;
+    }));
+    return functions;
+}
+export default extractFunction;

package/lib/extractor/kinds/materialized-view.d.ts

@@ -0,0 +1,17 @@
+import type { DbAdapter } from "../adapter.ts";
+import type { PgType } from "../pgtype.ts";
+import { Canonical } from "../canonicalise.ts";
+export interface MaterializedViewColumn {
+    name: string;
+    type: Canonical;
+    isNullable: boolean;
+    ordinalPosition: number;
+    comment: string | null;
+}
+export interface MaterializedViewDetails extends PgType<"materializedView"> {
+    columns: MaterializedViewColumn[];
+    definition: string;
+    isPopulated: boolean;
+}
+declare const extractMaterializedView: (db: DbAdapter, mview: PgType<"materializedView">) => Promise<MaterializedViewDetails>;
+export default extractMaterializedView;

package/lib/extractor/kinds/materialized-view.js

@@ -0,0 +1,64 @@
+import { Canonical, canonicalise } from "../canonicalise.js";
+const extractMaterializedView = async (db, mview) => {
+    // 1. Query for columns (using pg_attribute for potentially more accurate nullability)
+    const columnQuery = await db.query(`
+		SELECT
+			attr.attname AS "name",
+			format_type(attr.atttypid, attr.atttypmod)
+			|| CASE
+				WHEN attr.attndims > 1 THEN repeat('[]', attr.attndims - 1)
+				ELSE ''
+			END AS "definedType",
+			NOT attr.attnotnull AS "isNullable", -- Use pg_attribute.attnotnull
+			attr.attnum AS "ordinalPosition", -- Use pg_attribute.attnum
+			col_description(c.oid, attr.attnum) AS "comment"
+		FROM
+			pg_catalog.pg_class c
+			JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid
+			JOIN pg_catalog.pg_attribute attr ON c.oid = attr.attrelid
+		WHERE
+			c.relname = $1      -- Materialized view name
+			AND n.nspname = $2    -- Schema name
+			AND c.relkind = 'm'   -- Materialized view
+			AND attr.attnum > 0   -- Exclude system columns
+			AND NOT attr.attisdropped
+		ORDER BY attr.attnum;
+		`, [mview.name, mview.schemaName]);
+    // 2. Get canonical types
+    const definedTypes = columnQuery.map(row => row.definedType);
+    const canonicalTypes = await canonicalise(db, definedTypes);
+    const columns = columnQuery.map((row, index) => ({
+        name: row.name,
+        type: canonicalTypes[index],
+        isNullable: row.isNullable,
+        ordinalPosition: row.ordinalPosition,
+        comment: row.comment,
+    }));
+    // 3. Query for materialized view definition, comment, and properties
+    const mviewInfoQuery = await db.query(`
+		SELECT
+			m.definition,
+			d.description AS "comment",
+			m.ispopulated AS "isPopulated"
+		FROM
+			pg_catalog.pg_matviews m
+			JOIN pg_catalog.pg_class c ON m.matviewname = c.relname AND c.relkind = 'm'
+			JOIN pg_catalog.pg_namespace n ON c.relnamespace = n.oid AND m.schemaname = n.nspname
+			LEFT JOIN pg_catalog.pg_description d ON c.oid = d.objoid AND d.objsubid = 0
+		WHERE
+			m.matviewname = $1
+			AND m.schemaname = $2;
+		`, [mview.name, mview.schemaName]);
+    const mviewInfo = mviewInfoQuery[0];
+    if (!mviewInfo) {
+        throw new Error(`Could not find materialized view "${mview.schemaName}"."${mview.name}".`);
+    }
+    return {
+        ...mview,
+        columns,
+        comment: mviewInfo.comment ?? mview.comment,
+        definition: mviewInfo.definition,
+        isPopulated: mviewInfo.isPopulated,
+    };
+};
+export default extractMaterializedView;

package/lib/extractor/kinds/parts/commentMapQueryPart.d.ts

@@ -0,0 +1,2 @@
+declare const commentMapQueryPart = "\n\tSELECT\n\t\ta.attname as \"column_name\",\n\t\tcol_description(c.oid, a.attnum::int) as \"comment\"\n\tFROM\n\t\tpg_class c\n\t\tJOIN pg_attribute a on a.attrelid=c.oid\n\t\tJOIN pg_namespace n ON c.relnamespace = n.oid\n\tWHERE\n\t\tn.nspname = $2\n\t\tAND c.relname = $1\n";
+export default commentMapQueryPart;

package/lib/extractor/kinds/parts/commentMapQueryPart.js

@@ -0,0 +1,14 @@
+// Extract comments from attributes. Used for tables, views, materialized views and composite types.
+const commentMapQueryPart = `
+	SELECT
+		a.attname as "column_name",
+		col_description(c.oid, a.attnum::int) as "comment"
+	FROM
+		pg_class c
+		JOIN pg_attribute a on a.attrelid=c.oid
+		JOIN pg_namespace n ON c.relnamespace = n.oid
+	WHERE
+		n.nspname = $2
+		AND c.relname = $1
+`;
+export default commentMapQueryPart;

package/lib/extractor/kinds/parts/indexMapQueryPart.d.ts

@@ -0,0 +1,2 @@
+declare const indexMapQueryPart = "\n\tSELECT\n\t\ta.attname AS column_name,\n\t\tbool_or(ix.indisprimary) AS is_primary,\n\t\tjson_agg(json_build_object(\n\t\t\t\t'name', i.relname,\n\t\t\t\t'isPrimary', ix.indisprimary)\n\t\t\t) AS indices\n\tFROM\n\t\tpg_class t,\n\t\tpg_class i,\n\t\tpg_index ix,\n\t\tpg_attribute a,\n\t\tpg_namespace n\n\tWHERE\n\t\tt.oid = ix.indrelid\n\t\tAND i.oid = ix.indexrelid\n\t\tAND a.attrelid = t.oid\n\t\tAND n.oid = t.relnamespace\n\t\tAND a.attnum = ANY (ix.indkey)\n\t\tAND t.relkind = 'r'\n\t\tAND t.relname = $1\n\t\tAND n.nspname = $2\n\tGROUP BY\n\t\ta.attname\n";
+export default indexMapQueryPart;

package/lib/extractor/kinds/parts/indexMapQueryPart.js

@@ -0,0 +1,27 @@
+const indexMapQueryPart = `
+	SELECT
+		a.attname AS column_name,
+		bool_or(ix.indisprimary) AS is_primary,
+		json_agg(json_build_object(
+				'name', i.relname,
+				'isPrimary', ix.indisprimary)
+			) AS indices
+	FROM
+		pg_class t,
+		pg_class i,
+		pg_index ix,
+		pg_attribute a,
+		pg_namespace n
+	WHERE
+		t.oid = ix.indrelid
+		AND i.oid = ix.indexrelid
+		AND a.attrelid = t.oid
+		AND n.oid = t.relnamespace
+		AND a.attnum = ANY (ix.indkey)
+		AND t.relkind = 'r'
+		AND t.relname = $1
+		AND n.nspname = $2
+	GROUP BY
+		a.attname
+`;
+export default indexMapQueryPart;

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

@@ -0,0 +1,15 @@
+import type { DbAdapter } from "../adapter.ts";
+import type { PgType } from "../pgtype.ts";
+import { Canonical } from "../canonicalise.ts";
+/**
+ * Range type in a schema with details.
+ */
+export interface RangeDetails extends PgType<"range"> {
+    /**
+     * Canonical representation of the range type
+     * with full attribute details.
+     */
+    canonical: Canonical.Range;
+}
+declare const extractRange: (db: DbAdapter, range: PgType<"range">) => Promise<RangeDetails>;
+export default extractRange;

package/lib/extractor/kinds/range.js

@@ -0,0 +1,13 @@
+import { Canonical, canonicalise } from "../canonicalise.js";
+const extractRange = async (db, range) => {
+    // Form the fully qualified type name
+    const fullTypeName = `"${range.schemaName}"."${range.name}"`;
+    // Get canonical type information with all the metadata
+    const [canonical] = await canonicalise(db, [fullTypeName]);
+    // Return the composite type with its canonical representation
+    return {
+        ...range,
+        canonical: canonical,
+    };
+};
+export default extractRange;