@querypanel/node-sdk 1.0.8 → 1.0.10

package/dist/cjs/adapters/introspection.spec.js

@@ -0,0 +1,201 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const clickhouse_js_1 = require("./clickhouse.js");
+const postgres_js_1 = require("./postgres.js");
+function createClickHouseResponse(rows) {
+    return {
+        json: async () => rows,
+    };
+}
+(0, vitest_1.describe)("Database adapter introspection", () => {
+    (0, vitest_1.it)("introspects ClickHouse tables", async () => {
+        const clientFn = vitest_1.vi.fn(async ({ query }) => {
+            if (query.includes("FROM system.tables")) {
+                return createClickHouseResponse([
+                    {
+                        name: "events",
+                        engine: "MergeTree",
+                        comment: "Main events table",
+                        total_rows: "1000",
+                        total_bytes: "2048",
+                        is_view: "0",
+                        primary_key: "(id)",
+                        sorting_key: null,
+                    },
+                ]);
+            }
+            if (query.includes("FROM system.columns")) {
+                return createClickHouseResponse([
+                    {
+                        table: "events",
+                        name: "id",
+                        type: "UInt64",
+                        position: 1,
+                        default_kind: null,
+                        default_expression: null,
+                        comment: "Primary identifier",
+                        codec_expression: null,
+                        ttl_expression: null,
+                        is_in_primary_key: "1",
+                        data_compressed_bytes: "128",
+                        data_uncompressed_bytes: "256",
+                    },
+                    {
+                        table: "events",
+                        name: "name",
+                        type: "Nullable(String)",
+                        position: 2,
+                        default_kind: null,
+                        default_expression: null,
+                        comment: null,
+                        codec_expression: null,
+                        ttl_expression: null,
+                        is_in_primary_key: "0",
+                        data_compressed_bytes: null,
+                        data_uncompressed_bytes: null,
+                    },
+                ]);
+            }
+            return createClickHouseResponse([]);
+        });
+        const adapter = new clickhouse_js_1.ClickHouseAdapter(clientFn, {
+            database: "analytics",
+        });
+        const result = await adapter.introspect();
+        (0, vitest_1.expect)(result.db.name).toBe("analytics");
+        (0, vitest_1.expect)(result.tables).toHaveLength(1);
+        const table = result.tables[0];
+        if (!table)
+            throw new Error("missing table");
+        (0, vitest_1.expect)(table.columns.map((c) => c.name)).toEqual(["id", "name"]);
+        const idColumn = table.columns.find((c) => c.name === "id");
+        (0, vitest_1.expect)(idColumn?.isPrimaryKey).toBe(true);
+        (0, vitest_1.expect)(table.indexes[0]?.name).toBe("primary_key");
+    });
+    (0, vitest_1.it)("introspects Postgres tables", async () => {
+        const responses = new Map();
+        responses.set("tables", () => ({
+            rows: [
+                {
+                    table_name: "users",
+                    schema_name: "public",
+                    table_type: "BASE TABLE",
+                    comment: "application users",
+                    total_rows: 200,
+                    total_bytes: 4096,
+                },
+            ],
+            fields: [],
+        }));
+        responses.set("columns", () => ({
+            rows: [
+                {
+                    table_name: "users",
+                    table_schema: "public",
+                    column_name: "id",
+                    data_type: "integer",
+                    udt_name: "int4",
+                    is_nullable: "NO",
+                    column_default: "nextval('users_id_seq'::regclass)",
+                    character_maximum_length: null,
+                    numeric_precision: 32,
+                    numeric_scale: 0,
+                    ordinal_position: 1,
+                    description: "primary key",
+                },
+                {
+                    table_name: "users",
+                    table_schema: "public",
+                    column_name: "role_id",
+                    data_type: "integer",
+                    udt_name: "int4",
+                    is_nullable: "YES",
+                    column_default: null,
+                    character_maximum_length: null,
+                    numeric_precision: 32,
+                    numeric_scale: 0,
+                    ordinal_position: 2,
+                    description: null,
+                },
+            ],
+            fields: [],
+        }));
+        responses.set("constraints", () => ({
+            rows: [
+                {
+                    table_schema: "public",
+                    table_name: "users",
+                    constraint_name: "users_pkey",
+                    constraint_type: "PRIMARY KEY",
+                    column_name: "id",
+                    foreign_table_schema: null,
+                    foreign_table_name: null,
+                    foreign_column_name: null,
+                },
+                {
+                    table_schema: "public",
+                    table_name: "users",
+                    constraint_name: "users_role_id_fkey",
+                    constraint_type: "FOREIGN KEY",
+                    column_name: "role_id",
+                    foreign_table_schema: "public",
+                    foreign_table_name: "roles",
+                    foreign_column_name: "id",
+                },
+            ],
+            fields: [],
+        }));
+        responses.set("indexes", () => ({
+            rows: [
+                {
+                    schema_name: "public",
+                    table_name: "users",
+                    index_name: "users_pkey",
+                    indisunique: true,
+                    column_names: ["id"],
+                    definition: "CREATE UNIQUE INDEX users_pkey ON public.users USING btree (id)",
+                },
+            ],
+            fields: [],
+        }));
+        let indexQuerySql = null;
+        let lastSql = null;
+        const clientFn = vitest_1.vi.fn(async (sql) => {
+            lastSql = sql;
+            if (/pg_index\s+idx/.test(sql)) {
+                indexQuerySql = sql;
+                return responses.get("indexes")?.() ?? { rows: [], fields: [] };
+            }
+            if (sql.includes("FROM pg_class c")) {
+                return responses.get("tables")?.() ?? { rows: [], fields: [] };
+            }
+            if (sql.includes("information_schema.columns")) {
+                return responses.get("columns")?.() ?? { rows: [], fields: [] };
+            }
+            if (sql.includes("table_constraints")) {
+                return responses.get("constraints")?.() ?? { rows: [], fields: [] };
+            }
+            return { rows: [], fields: [] };
+        });
+        const adapter = new postgres_js_1.PostgresAdapter(clientFn, {
+            database: "app",
+            defaultSchema: "public",
+        });
+        const result = await adapter.introspect();
+        if (!indexQuerySql) {
+            throw new Error(`index query not executed. last sql: ${lastSql}`);
+        }
+        (0, vitest_1.expect)(result.db.name).toBe("app");
+        const table = result.tables[0];
+        if (!table)
+            throw new Error("expected table");
+        (0, vitest_1.expect)(table.constraints).toHaveLength(2);
+        const fk = table.constraints.find((c) => c.type === "FOREIGN KEY");
+        (0, vitest_1.expect)(fk?.referencedTable).toBe("public.roles");
+        const roleColumn = table.columns.find((c) => c.name === "role_id");
+        (0, vitest_1.expect)(roleColumn?.isForeignKey).toBe(true);
+        (0, vitest_1.expect)(table.indexes[0]?.columns).toEqual(["id"]);
+    });
+});
+//# sourceMappingURL=introspection.spec.js.map

package/dist/cjs/adapters/introspection.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"introspection.spec.js","sourceRoot":"","sources":["../../../src/adapters/introspection.spec.ts"],"names":[],"mappings":"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"}

package/dist/cjs/adapters/postgres.d.ts

@@ -0,0 +1,35 @@
+import type { IntrospectOptions, SchemaIntrospection } from "../schema/types.js";
+import type { DatabaseAdapter, DatabaseExecutionResult } from "./types.js";
+export interface PostgresQueryResult {
+    rows: Array<Record<string, unknown>>;
+    fields: Array<{
+        name: string;
+    }>;
+}
+export type PostgresClientFn = (sql: string, params?: unknown[]) => Promise<PostgresQueryResult>;
+export interface PostgresAdapterOptions {
+    /** Logical database name used in introspection metadata. */
+    database?: string;
+    /** Schema to assume when a table is provided without qualification. */
+    defaultSchema?: string;
+    /** Optional database kind label. Defaults to "postgres". */
+    kind?: SchemaIntrospection["db"]["kind"];
+}
+export declare class PostgresAdapter implements DatabaseAdapter {
+    private readonly clientFn;
+    private readonly databaseName;
+    private readonly defaultSchema;
+    private readonly kind;
+    constructor(clientFn: PostgresClientFn, options?: PostgresAdapterOptions);
+    execute(sql: string, params?: Record<string, string | number | boolean | string[] | number[]>): Promise<DatabaseExecutionResult>;
+    /**
+     * Convert named params to positional array for PostgreSQL
+     * PostgreSQL expects $1, $2, $3 in SQL and an array of values [val1, val2, val3]
+     * The LLM should generate params like: { '1': 'value1', '2': 'value2' }
+     */
+    private convertNamedToPositionalParams;
+    validate(sql: string): Promise<void>;
+    getDialect(): "postgres";
+    introspect(options?: IntrospectOptions): Promise<SchemaIntrospection>;
+}
+//# sourceMappingURL=postgres.d.ts.map

package/dist/cjs/adapters/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../src/adapters/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAIV,iBAAiB,EACjB,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,eAAe,EACf,uBAAuB,EACxB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACrC,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACjC;AAED,MAAM,MAAM,gBAAgB,GAAG,CAC7B,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,OAAO,EAAE,KACf,OAAO,CAAC,mBAAmB,CAAC,CAAC;AAElC,MAAM,WAAW,sBAAsB;IACrC,4DAA4D;IAC5D,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,uEAAuE;IACvE,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,IAAI,CAAC,EAAE,mBAAmB,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC;CAC1C;AAmDD,qBAAa,eAAgB,YAAW,eAAe;IAMnD,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAL3B,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAS;IACtC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAS;IACvC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoC;gBAGtC,QAAQ,EAAE,gBAAgB,EAC3C,OAAO,GAAE,sBAA2B;IAOhC,OAAO,CACX,GAAG,EAAE,MAAM,EACX,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,EAAE,GAAG,MAAM,EAAE,CAAC,GACvE,OAAO,CAAC,uBAAuB,CAAC;IAYnC;;;;OAIG;IACH,OAAO,CAAC,8BAA8B;IAkBhC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI1C,UAAU,IACD,UAAU;IAGb,UAAU,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,OAAO,CAAC,mBAAmB,CAAC;CA0K5E"}

package/dist/cjs/adapters/postgres.js

@@ -0,0 +1,407 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresAdapter = void 0;
+class PostgresAdapter {
+    constructor(clientFn, options = {}) {
+        this.clientFn = clientFn;
+        this.databaseName = options.database ?? "postgres";
+        this.defaultSchema = options.defaultSchema ?? "public";
+        this.kind = options.kind ?? "postgres";
+    }
+    async execute(sql, params) {
+        // Convert named params to positional array for PostgreSQL
+        let paramArray;
+        if (params) {
+            paramArray = this.convertNamedToPositionalParams(params);
+        }
+        const result = await this.clientFn(sql, paramArray);
+        const fields = result.fields.map((f) => f.name);
+        return { fields, rows: result.rows };
+    }
+    /**
+     * Convert named params to positional array for PostgreSQL
+     * PostgreSQL expects $1, $2, $3 in SQL and an array of values [val1, val2, val3]
+     * The LLM should generate params like: { '1': 'value1', '2': 'value2' }
+     */
+    convertNamedToPositionalParams(params) {
+        // Extract numeric keys and sort them
+        const keys = Object.keys(params)
+            .filter((k) => /^\d+$/.test(k))
+            .map((k) => Number.parseInt(k, 10))
+            .sort((a, b) => a - b);
+        // Build positional array
+        const positionalParams = [];
+        for (const key of keys) {
+            positionalParams.push(params[String(key)]);
+        }
+        return positionalParams;
+    }
+    async validate(sql) {
+        await this.clientFn(`EXPLAIN ${sql}`);
+    }
+    getDialect() {
+        return "postgres";
+    }
+    async introspect(options) {
+        const normalizedTables = normalizeTableFilter(options?.tables, this.defaultSchema);
+        const tablesResult = await this.clientFn(buildTablesQuery(normalizedTables));
+        const tableRows = tablesResult.rows;
+        const columnsResult = await this.clientFn(buildColumnsQuery(normalizedTables));
+        const columnRows = columnsResult.rows;
+        const constraintsResult = await this.clientFn(buildConstraintsQuery(normalizedTables));
+        const constraintRows = constraintsResult.rows;
+        const indexesResult = await this.clientFn(buildIndexesQuery(normalizedTables));
+        const indexRows = indexesResult.rows;
+        const tablesByKey = new Map();
+        const columnsByKey = new Map();
+        for (const row of tableRows) {
+            const key = tableKey(row.schema_name, row.table_name);
+            const statistics = buildTableStatistics(toNumber(row.total_rows), toNumber(row.total_bytes));
+            const table = {
+                name: row.table_name,
+                schema: row.schema_name,
+                type: asTableType(row.table_type),
+                columns: [],
+                indexes: [],
+                constraints: [],
+            };
+            const comment = sanitize(row.comment);
+            if (comment !== undefined) {
+                table.comment = comment;
+            }
+            if (statistics) {
+                table.statistics = statistics;
+            }
+            tablesByKey.set(key, table);
+            columnsByKey.set(key, new Map());
+        }
+        for (const row of columnRows) {
+            const key = tableKey(row.table_schema, row.table_name);
+            const table = tablesByKey.get(key);
+            if (!table)
+                continue;
+            const column = {
+                name: row.column_name,
+                type: row.data_type,
+                nullable: row.is_nullable.toUpperCase() === "YES",
+                isPrimaryKey: false,
+                isForeignKey: false,
+            };
+            const rawType = row.udt_name ?? undefined;
+            if (rawType !== undefined)
+                column.rawType = rawType;
+            const defaultExpression = sanitize(row.column_default);
+            if (defaultExpression !== undefined)
+                column.defaultExpression = defaultExpression;
+            const comment = sanitize(row.description);
+            if (comment !== undefined)
+                column.comment = comment;
+            const maxLength = row.character_maximum_length ?? undefined;
+            if (maxLength !== undefined)
+                column.maxLength = maxLength;
+            const precision = row.numeric_precision ?? undefined;
+            if (precision !== undefined)
+                column.precision = precision;
+            const scale = row.numeric_scale ?? undefined;
+            if (scale !== undefined)
+                column.scale = scale;
+            table.columns.push(column);
+            columnsByKey.get(key)?.set(row.column_name, column);
+        }
+        const constraintGroups = groupConstraints(constraintRows);
+        for (const group of constraintGroups) {
+            const key = tableKey(group.table_schema, group.table_name);
+            const table = tablesByKey.get(key);
+            if (!table)
+                continue;
+            const constraint = {
+                name: group.constraint_name,
+                type: group.constraint_type,
+                columns: [...group.columns],
+            };
+            if (group.type === "FOREIGN KEY") {
+                if (group.foreign_table_name) {
+                    const referencedTable = group.foreign_table_schema
+                        ? `${group.foreign_table_schema}.${group.foreign_table_name}`
+                        : group.foreign_table_name;
+                    constraint.referencedTable = referencedTable;
+                }
+                if (group.foreign_columns.length) {
+                    constraint.referencedColumns = [...group.foreign_columns];
+                }
+            }
+            table.constraints.push(constraint);
+            for (let index = 0; index < group.columns.length; index += 1) {
+                const columnName = group.columns[index];
+                if (!columnName)
+                    continue;
+                const column = columnsByKey.get(key)?.get(columnName);
+                if (!column)
+                    continue;
+                if (group.type === "PRIMARY KEY") {
+                    column.isPrimaryKey = true;
+                }
+                if (group.type === "FOREIGN KEY") {
+                    column.isForeignKey = true;
+                    if (group.foreign_table_name) {
+                        column.foreignKeyTable = group.foreign_table_schema
+                            ? `${group.foreign_table_schema}.${group.foreign_table_name}`
+                            : group.foreign_table_name;
+                    }
+                    const referencedColumn = group.foreign_columns[index];
+                    if (referencedColumn) {
+                        column.foreignKeyColumn = referencedColumn;
+                    }
+                }
+            }
+        }
+        for (const row of indexRows) {
+            const key = tableKey(row.schema_name, row.table_name);
+            const table = tablesByKey.get(key);
+            if (!table)
+                continue;
+            const columns = coerceStringArray(row.column_names)
+                .map((c) => c.trim())
+                .filter(Boolean);
+            const index = {
+                name: row.index_name,
+                columns,
+                unique: Boolean(row.indisunique),
+                type: columns.length === 1 ? "INDEX" : "COMPOSITE INDEX",
+            };
+            const definition = sanitize(row.definition);
+            if (definition !== undefined)
+                index.definition = definition;
+            table.indexes.push(index);
+        }
+        const tables = Array.from(tablesByKey.values()).sort((a, b) => {
+            if (a.schema === b.schema) {
+                return a.name.localeCompare(b.name);
+            }
+            return a.schema.localeCompare(b.schema);
+        });
+        return {
+            db: {
+                kind: this.kind,
+                name: this.databaseName,
+            },
+            tables,
+            introspectedAt: new Date().toISOString(),
+        };
+    }
+}
+exports.PostgresAdapter = PostgresAdapter;
+function groupConstraints(rows) {
+    const groups = new Map();
+    for (const row of rows) {
+        const key = `${row.table_schema}.${row.table_name}.${row.constraint_name}`;
+        let group = groups.get(key);
+        if (!group) {
+            group = {
+                table_schema: row.table_schema,
+                table_name: row.table_name,
+                constraint_name: row.constraint_name,
+                constraint_type: row.constraint_type,
+                columns: [],
+                foreign_columns: [],
+                type: row.constraint_type,
+            };
+            groups.set(key, group);
+        }
+        if (row.column_name) {
+            group.columns.push(row.column_name);
+        }
+        if (row.constraint_type === "FOREIGN KEY") {
+            group.foreign_table_schema = row.foreign_table_schema;
+            group.foreign_table_name = row.foreign_table_name;
+            if (row.foreign_column_name) {
+                group.foreign_columns.push(row.foreign_column_name);
+            }
+        }
+    }
+    return Array.from(groups.values());
+}
+function normalizeTableFilter(tables, defaultSchema) {
+    if (!tables?.length)
+        return [];
+    const normalized = [];
+    const seen = new Set();
+    for (const raw of tables) {
+        if (!raw)
+            continue;
+        const trimmed = raw.trim();
+        if (!trimmed)
+            continue;
+        const parts = trimmed.split(".");
+        const table = parts.pop() ?? "";
+        const schema = parts.pop() ?? defaultSchema;
+        if (!isSafeIdentifier(schema) || !isSafeIdentifier(table)) {
+            continue;
+        }
+        const key = tableKey(schema, table);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        normalized.push({ schema, table });
+    }
+    return normalized;
+}
+function buildTablesQuery(tables) {
+    const filter = buildFilterClause(tables, "n.nspname", "c.relname");
+    return `SELECT
+    c.relname AS table_name,
+    n.nspname AS schema_name,
+    CASE c.relkind
+      WHEN 'r' THEN 'table'
+      WHEN 'v' THEN 'view'
+      WHEN 'm' THEN 'materialized_view'
+      ELSE c.relkind::text
+    END AS table_type,
+    obj_description(c.oid) AS comment,
+    c.reltuples AS total_rows,
+    pg_total_relation_size(c.oid) AS total_bytes
+  FROM pg_class c
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+    AND c.relkind IN ('r', 'v', 'm')
+    ${filter}
+  ORDER BY n.nspname, c.relname;`;
+}
+function buildColumnsQuery(tables) {
+    const filter = buildFilterClause(tables, "cols.table_schema", "cols.table_name");
+    return `SELECT
+    cols.table_name,
+    cols.table_schema,
+    cols.column_name,
+    cols.data_type,
+    cols.udt_name,
+    cols.is_nullable,
+    cols.column_default,
+    cols.character_maximum_length,
+    cols.numeric_precision,
+    cols.numeric_scale,
+    cols.ordinal_position,
+    pgd.description
+  FROM information_schema.columns cols
+  LEFT JOIN pg_catalog.pg_class c
+    ON c.relname = cols.table_name
+   AND c.relkind IN ('r', 'v', 'm')
+  LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+  LEFT JOIN pg_catalog.pg_attribute attr
+    ON attr.attrelid = c.oid
+   AND attr.attname = cols.column_name
+  LEFT JOIN pg_catalog.pg_description pgd
+    ON pgd.objoid = attr.attrelid AND pgd.objsubid = attr.attnum
+  WHERE cols.table_schema NOT IN ('pg_catalog', 'information_schema')
+    ${filter}
+  ORDER BY cols.table_schema, cols.table_name, cols.ordinal_position;`;
+}
+function buildConstraintsQuery(tables) {
+    const filter = buildFilterClause(tables, "tc.table_schema", "tc.table_name");
+    return `SELECT
+    tc.table_schema,
+    tc.table_name,
+    tc.constraint_name,
+    tc.constraint_type,
+    kcu.column_name,
+    ccu.table_schema AS foreign_table_schema,
+    ccu.table_name AS foreign_table_name,
+    ccu.column_name AS foreign_column_name
+  FROM information_schema.table_constraints tc
+  LEFT JOIN information_schema.key_column_usage kcu
+    ON tc.constraint_name = kcu.constraint_name
+   AND tc.table_schema = kcu.table_schema
+  LEFT JOIN information_schema.constraint_column_usage ccu
+    ON ccu.constraint_name = tc.constraint_name
+   AND ccu.table_schema = tc.table_schema
+  WHERE tc.constraint_type IN ('PRIMARY KEY', 'UNIQUE', 'FOREIGN KEY')
+    AND tc.table_schema NOT IN ('pg_catalog', 'information_schema')
+    ${filter}
+  ORDER BY tc.table_schema, tc.table_name, tc.constraint_name, kcu.ordinal_position;`;
+}
+function buildIndexesQuery(tables) {
+    const filter = buildFilterClause(tables, "n.nspname", "c.relname");
+    return `SELECT
+    n.nspname AS schema_name,
+    c.relname AS table_name,
+    ci.relname AS index_name,
+    idx.indisunique,
+    array_remove(
+      array_agg(pg_get_indexdef(idx.indexrelid, g.k, true) ORDER BY g.k),
+      NULL
+    ) AS column_names,
+    pg_get_indexdef(idx.indexrelid) AS definition
+  FROM pg_class c
+  JOIN pg_namespace n ON n.oid = c.relnamespace
+  JOIN pg_index idx ON idx.indrelid = c.oid
+  JOIN pg_class ci ON ci.oid = idx.indexrelid
+  JOIN LATERAL generate_subscripts(idx.indkey, 1) AS g(k) ON true
+  WHERE n.nspname NOT IN ('pg_catalog', 'information_schema')
+    ${filter}
+  GROUP BY n.nspname, c.relname, ci.relname, idx.indisunique, idx.indexrelid;`;
+}
+function buildFilterClause(tables, schemaExpr, tableExpr) {
+    if (!tables.length)
+        return "";
+    const clauses = tables.map(({ schema, table }) => {
+        return `(${schemaExpr} = '${schema}' AND ${tableExpr} = '${table}')`;
+    });
+    return `AND (${clauses.join(" OR ")})`;
+}
+function tableKey(schema, table) {
+    return `${schema}.${table}`;
+}
+function isSafeIdentifier(value) {
+    return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+function asTableType(value) {
+    const normalized = value.toLowerCase();
+    if (normalized.includes("view")) {
+        return normalized.includes("materialized") ? "materialized_view" : "view";
+    }
+    return "table";
+}
+function buildTableStatistics(totalRows, totalBytes) {
+    if (totalRows === undefined && totalBytes === undefined)
+        return undefined;
+    const stats = {};
+    if (totalRows !== undefined)
+        stats.totalRows = totalRows;
+    if (totalBytes !== undefined)
+        stats.totalBytes = totalBytes;
+    return stats;
+}
+function sanitize(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    const trimmed = String(value).trim();
+    return trimmed.length ? trimmed : undefined;
+}
+function toNumber(value) {
+    if (value === null || value === undefined)
+        return undefined;
+    if (typeof value === "number")
+        return value;
+    const parsed = Number.parseFloat(String(value));
+    return Number.isNaN(parsed) ? undefined : parsed;
+}
+function coerceStringArray(value) {
+    if (!value)
+        return [];
+    if (Array.isArray(value)) {
+        return value.map((entry) => String(entry));
+    }
+    const text = String(value).trim();
+    if (!text)
+        return [];
+    const withoutBraces = text.startsWith("{") && text.endsWith("}")
+        ? text.slice(1, -1)
+        : text;
+    if (!withoutBraces)
+        return [];
+    return withoutBraces
+        .split(",")
+        .map((part) => part.trim().replace(/^"(.+)"$/, "$1"))
+        .filter(Boolean);
+}
+//# sourceMappingURL=postgres.js.map