@query-doctor/core 0.1.0 → 0.1.2

package/dist/sql/analyzer_test.js

@@ -1,584 +0,0 @@
-import assert from "node:assert";
-import fs from "node:fs";
-import test from "node:test";
-import dedent from "dedent";
-import { Analyzer } from "./analyzer.js";
-import { parse } from "@pgsql/parser";
-test("analyzer test", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-  select
-    "public"."team_user"."team_user_id",
-    "public"."team_user"."team_id"
-  from
-    "public"."team_user"
-  where
-    (
-      1 = 1
-      and "public"."team_user"."team_id" in ($1)
-    )
-  offset
-    $2`;
-    const { indexesToCheck } = await analyzer.analyze(query);
-    assert.deepStrictEqual(indexesToCheck, [
-        {
-            frequency: 1,
-            representation: '"public"."team_user"."team_id"',
-            parts: [
-                { quoted: true, start: 135, text: "public" },
-                { quoted: true, start: 144, text: "team_user" },
-                { quoted: true, start: 156, text: "team_id" },
-            ],
-            ignored: false,
-            position: { start: 135, end: 165 },
-        },
-    ]);
-});
-test("analyzer test with ordering", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-  select
-    "public"."team"."team_id"
-  from
-    "public"."team"
-  order by
-    team.team_id desc nulls first
-  `;
-    const { indexesToCheck } = await analyzer.analyze(query);
-    assert.deepStrictEqual(indexesToCheck, [
-        {
-            frequency: 1,
-            representation: "team.team_id",
-            parts: [
-                { quoted: false, start: 42, text: "team" },
-                { quoted: false, start: 74, text: "team_id" },
-            ],
-            ignored: false,
-            position: { start: 69, end: 81 },
-            sort: {
-                dir: "SORTBY_DESC",
-                nulls: "SORTBY_NULLS_FIRST",
-            },
-        },
-    ]);
-});
-test("analyzer isnull", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-    select * from team
-    where team.deleted_at is null
-  `;
-    const { indexesToCheck } = await analyzer.analyze(query);
-    assert.deepStrictEqual(indexesToCheck, [
-        {
-            frequency: 1,
-            representation: "team.deleted_at",
-            parts: [
-                { text: "team", start: 14, quoted: false },
-                { text: "deleted_at", start: 30, quoted: false },
-            ],
-            ignored: false,
-            position: { start: 25, end: 40 },
-            where: { nulltest: "IS_NULL" },
-        },
-    ]);
-});
-test("analyzer test", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-  select
-    COUNT(*) as "_count._all"
-  from
-    (
-      select
-        "public"."team"."team_id"
-      from
-        "public"."team"
-      where
-        (
-          "public"."team"."deleted_at" is null
-          and exists (
-            select
-              "t0"."team_id"
-            from
-              "public"."team_user" as "t0"
-            where
-              (
-                "t0"."user_id" = $1
-                and ("public"."team"."team_id") = ("t0"."team_id")
-                and "t0"."team_id" is not null
-              )
-          )
-        )
-      offset
-        $2
-    ) as "sub"`;
-    const { indexesToCheck } = await analyzer.analyze(query);
-    assert.deepStrictEqual(indexesToCheck, [
-        {
-            frequency: 1,
-            representation: '"t0"."team_id"',
-            parts: [
-                { text: "team_user", start: 273, quoted: true, alias: "t0" },
-                { text: "team_id", start: 454, quoted: true },
-            ],
-            ignored: false,
-            position: { start: 449, end: 463 },
-            where: {
-                nulltest: "IS_NOT_NULL",
-            },
-        },
-        {
-            frequency: 1,
-            representation: '"public"."team"."team_id"',
-            parts: [
-                { text: "public", start: 385, quoted: true },
-                { text: "team", start: 394, quoted: true },
-                { text: "team_id", start: 401, quoted: true },
-            ],
-            ignored: false,
-            position: { start: 385, end: 410 },
-        },
-        {
-            frequency: 1,
-            representation: '"t0"."user_id"',
-            parts: [
-                { text: "team_user", start: 273, quoted: true, alias: "t0" },
-                { text: "user_id", start: 351, quoted: true },
-            ],
-            ignored: false,
-            position: { start: 346, end: 360 },
-        },
-        {
-            frequency: 1,
-            representation: '"public"."team"."deleted_at"',
-            parts: [
-                { text: "public", start: 144, quoted: true },
-                { text: "team", start: 153, quoted: true },
-                { text: "deleted_at", start: 160, quoted: true },
-            ],
-            ignored: false,
-            position: { start: 144, end: 172 },
-            where: {
-                nulltest: "IS_NULL",
-            },
-        },
-    ]);
-    const indexes = analyzer.deriveIndexes(testMetadata, indexesToCheck);
-    assert.deepStrictEqual(indexes, [
-        {
-            schema: "public",
-            table: "team_user",
-            column: "team_id",
-            where: {
-                nulltest: "IS_NOT_NULL",
-            },
-        },
-        { schema: "public", table: "team", column: "team_id" },
-        { schema: "public", table: "team_user", column: "user_id" },
-        {
-            schema: "public",
-            table: "team",
-            column: "deleted_at",
-            where: {
-                nulltest: "IS_NULL",
-            },
-        },
-    ]);
-});
-const testMetadata = JSON.parse(fs.readFileSync("test/umami_test.json", "utf-8"));
-test("analyzer with aliases", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-  select
-    "public"."team_user"."team_user_id",
-    "public"."team_user"."team_id",
-    "public"."team_user"."user_id",
-    "public"."team_user"."role",
-    "public"."team_user"."created_at",
-    "public"."team_user"."updated_at"
-  from
-    "public"."team_user"
-    left join "public"."user" as "j0" on ("j0"."user_id") = ("public"."team_user"."user_id")
-  where
-    (
-      "public"."team_user"."team_id" = $1
-      and (
-        "j0"."deleted_at" is null
-        and ("j0"."user_id" is not null)
-      )
-    )
-  order by
-    "public"."team_user"."team_user_id" asc
-  limit
-    $2
-  offset
-    $3
-  `;
-    const { indexesToCheck, ansiHighlightedQuery } = await analyzer.analyze(query);
-    const indexes = analyzer.deriveIndexes(testMetadata, indexesToCheck);
-    console.log(indexes);
-    console.log(ansiHighlightedQuery);
-    assert.deepStrictEqual(indexes, [
-        {
-            schema: "public",
-            table: "team_user",
-            column: "team_user_id",
-            sort: {
-                dir: "SORTBY_ASC",
-                nulls: "SORTBY_NULLS_DEFAULT",
-            },
-        },
-        {
-            schema: "public",
-            table: "user",
-            column: "user_id",
-            where: {
-                nulltest: "IS_NOT_NULL",
-            },
-        },
-        {
-            schema: "public",
-            table: "user",
-            column: "deleted_at",
-            where: {
-                nulltest: "IS_NULL",
-            },
-        },
-        { schema: "public", table: "team_user", column: "team_id" },
-        { schema: "public", table: "team_user", column: "user_id" },
-    ]);
-});
-test("analyzer does not pickup aggregate aliases", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-    select
-      "public"."team"."team_id",
-      "public"."team"."name",
-      "public"."team"."access_code",
-      "public"."team"."logo_url",
-      "public"."team"."created_at",
-      "public"."team"."updated_at",
-      "public"."team"."deleted_at",
-      COALESCE(
-        "aggr_selection_0_Website"."_aggr_count_website",
-        0
-      ) as "_aggr_count_website",
-      COALESCE(
-        "aggr_selection_1_TeamUser"."_aggr_count_teamUser",
-        0
-      ) as "_aggr_count_teamUser"
-    from
-      "public"."team"
-      left join (
-        select
-          "public"."website"."team_id",
-          COUNT(*) as "_aggr_count_website"
-        from
-          "public"."website"
-        where
-          "public"."website"."deleted_at" is null
-        group by
-          "public"."website"."team_id"
-      ) as "aggr_selection_0_Website" on (
-        "public"."team"."team_id" = "aggr_selection_0_Website"."team_id"
-      )
-      left join (
-        select
-          "public"."team_user"."team_id",
-          COUNT(*) as "_aggr_count_teamUser"
-        from
-          "public"."team_user"
-          left join "public"."user" as "j0" on ("j0"."user_id") = ("public"."team_user"."user_id")
-        where
-          (
-            "j0"."deleted_at" is null
-            and ("j0"."user_id" is not null)
-          )
-        group by
-          "public"."team_user"."team_id"
-      ) as "aggr_selection_1_TeamUser" on (
-        "public"."team"."team_id" = "aggr_selection_1_TeamUser"."team_id"
-      )
-    where
-      (
-        "public"."team"."deleted_at" is null
-        and exists (
-          select
-            "t1"."team_id"
-          from
-            "public"."team_user" as "t1"
-          where
-            (
-              "t1"."user_id" = $1
-              and ("public"."team"."team_id") = ("t1"."team_id")
-              and "t1"."team_id" is not null
-            )
-        )
-      )
-    order by
-      "public"."team"."team_id" asc
-    limit
-      $2
-    offset
-      $3`;
-    const { indexesToCheck } = await analyzer.analyze(query);
-    assert(!indexesToCheck.some((i) => /aggr_selection_0_Website/.test(i.representation)));
-    assert(!indexesToCheck.some((i) => /aggr_selection_1_TeamUser/.test(i.representation)));
-});
-test("sqlcommenter test", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-    SELECT * FROM FOO /*action='%2Fparam*d',controller='index',framework='spring',
-    traceparent='00-5bd66ef5095369c7b0d1f8f4bd33716a-c532cb4098ac3dd2-01',
-    tracestate='congo%3Dt61rcWkgMzE%2Crojo%3D00f067aa0ba902b7'*/
-  `;
-    const { tags } = await analyzer.analyze(query);
-    assert.deepStrictEqual(tags, [
-        { key: "action", value: "/param*d" },
-        { key: "controller", value: "index" },
-        { key: "framework", value: "spring" },
-        {
-            key: "traceparent",
-            value: "00-5bd66ef5095369c7b0d1f8f4bd33716a-c532cb4098ac3dd2-01",
-        },
-        { key: "tracestate", value: "congo=t61rcWkgMzE,rojo=00f067aa0ba902b7" },
-    ]);
-});
-test("analyzer doesn't pick up temp table references", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-    select * from "public"."team_user" "t0"
-  `;
-    const { referencedTables } = await analyzer.analyze(query);
-    assert.deepStrictEqual(referencedTables, ["team_user"]);
-    // also check the `as` syntax
-    const query2 = dedent `
-    select * from "public"."team_user" as "t0"
-  `;
-    const { referencedTables: referencedTables2 } = await analyzer.analyze(query2);
-    assert.deepStrictEqual(referencedTables2, ["team_user"]);
-});
-test("analyzer should use queries aliased as existing tables", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `select * from
-    (
-      select * from "guests"
-      order by
-        "guests"."last_upload" desc,
-        "guests"."id" desc
-      limit
-        100
-    ) "guests"
-    cross join lateral (
-      select * from "assets"
-      where
-        (
-          "assets"."event_id" = (
-            select
-              "id"
-            from
-              "events"
-            where
-              "events"."event_key" = '01JKCVP4M2CH34SVTQGHSW4Y5G'
-          )
-          and "assets"."uploader_id" = "guests"."id"
-        )
-      order by
-        "assets"."inserted_at" desc
-      limit
-        100
-    ) "userAssets";`;
-    const { referencedTables } = await analyzer.analyze(query);
-    assert.deepStrictEqual(referencedTables, ["guests", "assets", "events"]);
-});
-test("nudge for found star", async function () {
-    const analyzer = new Analyzer(parse);
-    const query = dedent `
-    select * from "guest"
-  `;
-    const { nudges } = await analyzer.analyze(query);
-    // This query triggers multiple nudges: SELECT *, missing WHERE, missing LIMIT
-    assert(nudges.some(n => n.kind === "AVOID_SELECT_STAR"));
-    assert(nudges.some(n => n.kind === "MISSING_WHERE_CLAUSE"));
-    assert(nudges.some(n => n.kind === "MISSING_LIMIT_CLAUSE"));
-});
-test("nudge for functions on columns in WHERE clause", async function () {
-    const analyzer = new Analyzer(parse);
-    // Test LOWER function on column
-    const query1 = dedent `
-    select name from users where LOWER(name) = 'bob' limit 10
-  `;
-    const { nudges: nudges1 } = await analyzer.analyze(query1);
-    assert.deepStrictEqual(nudges1, [{ kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE" }]);
-    // Test DATE function on column
-    const query2 = dedent `
-    select id from events where DATE(created_at) = '2025-09-18' limit 5
-  `;
-    const { nudges: nudges2 } = await analyzer.analyze(query2);
-    assert.deepStrictEqual(nudges2, [{ kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE" }]);
-    // Test UPPER function on column
-    const query3 = dedent `
-    select email from users where UPPER(email) LIKE 'TEST%' limit 20
-  `;
-    const { nudges: nudges3 } = await analyzer.analyze(query3);
-    assert.deepStrictEqual(nudges3, [{ kind: "AVOID_FUNCTIONS_ON_COLUMNS_IN_WHERE" }]);
-    // Test function in SELECT (should NOT trigger nudge)
-    const query4 = dedent `
-    select LOWER(name) from users where id = 1 limit 1
-  `;
-    const { nudges: nudges4 } = await analyzer.analyze(query4);
-    assert.deepStrictEqual(nudges4, []);
-    // Test function with literal (should NOT trigger nudge)
-    const query5 = dedent `
-    select name from users where age > LENGTH('test') limit 100
-  `;
-    const { nudges: nudges5 } = await analyzer.analyze(query5);
-    assert.deepStrictEqual(nudges5, []);
-});
-test("nudge for unbounded queries", async function () {
-    const analyzer = new Analyzer(parse);
-    // Test missing WHERE clause
-    const query1 = dedent `
-    select name from users
-  `;
-    const { nudges: nudges1 } = await analyzer.analyze(query1);
-    assert(nudges1.some(n => n.kind === "MISSING_WHERE_CLAUSE"));
-    assert(nudges1.some(n => n.kind === "MISSING_LIMIT_CLAUSE"));
-    // Test missing LIMIT clause (has WHERE but no LIMIT)
-    const query2 = dedent `
-    select name from users where active = true
-  `;
-    const { nudges: nudges2 } = await analyzer.analyze(query2);
-    assert(!nudges2.some(n => n.kind === "MISSING_WHERE_CLAUSE"));
-    assert(nudges2.some(n => n.kind === "MISSING_LIMIT_CLAUSE"));
-    // Test bounded query (has both WHERE and LIMIT - should NOT trigger)
-    const query3 = dedent `
-    select name from users where active = true limit 10
-  `;
-    const { nudges: nudges3 } = await analyzer.analyze(query3);
-    assert(!nudges3.some(n => n.kind === "MISSING_WHERE_CLAUSE"));
-    assert(!nudges3.some(n => n.kind === "MISSING_LIMIT_CLAUSE"));
-    // Test subquery (should NOT trigger nudges)
-    const query4 = dedent `
-    select count(*) from (select name from users) as sub
-  `;
-    const { nudges: nudges4 } = await analyzer.analyze(query4);
-    // The outer query has no WHERE/LIMIT but queries a subquery, not a table
-    assert(!nudges4.some(n => n.kind === "MISSING_WHERE_CLAUSE"));
-    assert(!nudges4.some(n => n.kind === "MISSING_LIMIT_CLAUSE"));
-    // Test JOIN query missing WHERE/LIMIT
-    const query5 = dedent `
-    select u.name, p.title
-    from users u
-    join posts p on u.id = p.user_id
-  `;
-    const { nudges: nudges5 } = await analyzer.analyze(query5);
-    assert(nudges5.some(n => n.kind === "MISSING_WHERE_CLAUSE"));
-    assert(nudges5.some(n => n.kind === "MISSING_LIMIT_CLAUSE"));
-});
-test("nudge for NULL comparison issues", async function () {
-    const analyzer = new Analyzer(parse);
-    // Test = NULL (should trigger nudge)
-    const query1 = dedent `
-    select name from users where email = NULL limit 10
-  `;
-    const { nudges: nudges1 } = await analyzer.analyze(query1);
-    assert(nudges1.some(n => n.kind === "USE_IS_NULL_NOT_EQUALS"));
-    // Test != NULL (should trigger nudge)
-    const query2 = dedent `
-    select name from users where email <> NULL limit 10
-  `;
-    const { nudges: nudges2 } = await analyzer.analyze(query2);
-    assert(nudges2.some(n => n.kind === "USE_IS_NULL_NOT_EQUALS"));
-    // Test IS NULL (should NOT trigger nudge)
-    const query3 = dedent `
-    select name from users where email IS NULL limit 10
-  `;
-    const { nudges: nudges3 } = await analyzer.analyze(query3);
-    assert(!nudges3.some(n => n.kind === "USE_IS_NULL_NOT_EQUALS"));
-    // Test normal equality (should NOT trigger nudge)
-    const query4 = dedent `
-    select name from users where active = true limit 10
-  `;
-    const { nudges: nudges4 } = await analyzer.analyze(query4);
-    assert(!nudges4.some(n => n.kind === "USE_IS_NULL_NOT_EQUALS"));
-});
-test("nudge for DISTINCT usage", async function () {
-    const analyzer = new Analyzer(parse);
-    // Test DISTINCT (should trigger nudge)
-    const query1 = dedent `
-    select distinct name from users where active = true limit 10
-  `;
-    const { nudges: nudges1 } = await analyzer.analyze(query1);
-    assert(nudges1.some(n => n.kind === "AVOID_DISTINCT_WITHOUT_REASON"));
-    // Test regular SELECT (should NOT trigger nudge)
-    const query2 = dedent `
-    select name from users where active = true limit 10
-  `;
-    const { nudges: nudges2 } = await analyzer.analyze(query2);
-    assert(!nudges2.some(n => n.kind === "AVOID_DISTINCT_WITHOUT_REASON"));
-});
-test("nudge for cartesian joins", async function () {
-    const analyzer = new Analyzer(parse);
-    // Test JOIN without ON clause (should trigger nudge)
-    const query1 = dedent `
-    select u.name, p.title from users u cross join posts p where u.active = true limit 10
-  `;
-    const { nudges: nudges1 } = await analyzer.analyze(query1);
-    assert(nudges1.some(n => n.kind === "MISSING_JOIN_CONDITION"));
-    // Test old-style comma join (should trigger nudge)
-    const query2 = dedent `
-    select u.name, p.title from users u, posts p where u.active = true limit 10
-  `;
-    const { nudges: nudges2 } = await analyzer.analyze(query2);
-    assert(nudges2.some(n => n.kind === "MISSING_JOIN_CONDITION"));
-    // Test proper JOIN with ON clause (should NOT trigger nudge)
-    const query3 = dedent `
-    select u.name, p.title from users u join posts p on u.id = p.user_id where u.active = true limit 10
-  `;
-    const { nudges: nudges3 } = await analyzer.analyze(query3);
-    assert(!nudges3.some(n => n.kind === "MISSING_JOIN_CONDITION"));
-});
-test("nudge for LIKE leading wildcards", async function () {
-    const analyzer = new Analyzer(parse);
-    // Test LIKE with leading wildcard (should trigger nudge)
-    const query1 = dedent `
-    select name from users where email LIKE '%@example.com' limit 10
-  `;
-    const { nudges: nudges1 } = await analyzer.analyze(query1);
-    assert(nudges1.some(n => n.kind === "AVOID_LEADING_WILDCARD_LIKE"));
-    // Test ILIKE with leading wildcard (should trigger nudge)
-    const query2 = dedent `
-    select name from users where email ILIKE '%EXAMPLE' limit 10
-  `;
-    const { nudges: nudges2 } = await analyzer.analyze(query2);
-    assert(nudges2.some(n => n.kind === "AVOID_LEADING_WILDCARD_LIKE"));
-    // Test LIKE without leading wildcard (should NOT trigger nudge)
-    const query3 = dedent `
-    select name from users where email LIKE 'user%@example.com' limit 10
-  `;
-    const { nudges: nudges3 } = await analyzer.analyze(query3);
-    assert(!nudges3.some(n => n.kind === "AVOID_LEADING_WILDCARD_LIKE"));
-});
-test("nudge for multiple OR conditions", async function () {
-    const analyzer = new Analyzer(parse);
-    // Test 3+ OR conditions (should trigger nudge)
-    const query1 = dedent `
-    select name from users where status = 'active' OR status = 'pending' OR status = 'trial' limit 10
-  `;
-    const { nudges: nudges1 } = await analyzer.analyze(query1);
-    assert(nudges1.some(n => n.kind === "CONSIDER_IN_INSTEAD_OF_MANY_ORS"));
-    // Test 2 OR conditions (should NOT trigger nudge)
-    const query2 = dedent `
-    select name from users where status = 'active' OR status = 'pending' limit 10
-  `;
-    const { nudges: nudges2 } = await analyzer.analyze(query2);
-    assert(!nudges2.some(n => n.kind === "CONSIDER_IN_INSTEAD_OF_MANY_ORS"));
-    // Test IN clause (should NOT trigger nudge)
-    const query3 = dedent `
-    select name from users where status IN ('active', 'pending', 'trial') limit 10
-  `;
-    const { nudges: nudges3 } = await analyzer.analyze(query3);
-    assert(!nudges3.some(n => n.kind === "CONSIDER_IN_INSTEAD_OF_MANY_ORS"));
-});

package/dist/sql/builder.js

@@ -1,77 +0,0 @@
-export class PostgresQueryBuilder {
-    query;
-    commands = {};
-    isIntrospection = false;
-    explainFlags = [];
-    _preamble = 0;
-    constructor(query) {
-        this.query = query;
-    }
-    get preamble() {
-        return this._preamble;
-    }
-    static createIndex(definition, name) {
-        if (name) {
-            return new PostgresQueryBuilder(`create index "${name}" on ${definition};`);
-        }
-        return new PostgresQueryBuilder(`create index on ${definition};`);
-    }
-    enable(command, value = true) {
-        const commandString = `enable_${command}`;
-        if (value) {
-            this.commands[commandString] = "on";
-        }
-        else {
-            this.commands[commandString] = "off";
-        }
-        return this;
-    }
-    withQuery(query) {
-        this.query = query;
-        return this;
-    }
-    introspect() {
-        this.isIntrospection = true;
-        return this;
-    }
-    explain(flags) {
-        this.explainFlags = flags;
-        return this;
-    }
-    build() {
-        let commands = this.generateSetCommands();
-        commands += this.generateExplain().query;
-        if (this.isIntrospection) {
-            commands += " -- @qd_introspection";
-        }
-        return commands;
-    }
-    /** Return the "set a=b" parts of the command in the query separate from the explain select ... part */
-    buildParts() {
-        const commands = this.generateSetCommands();
-        const explain = this.generateExplain();
-        this._preamble = explain.preamble;
-        if (this.isIntrospection) {
-            explain.query += " -- @qd_introspection";
-        }
-        return { commands, query: explain.query };
-    }
-    generateSetCommands() {
-        let commands = "";
-        for (const key in this.commands) {
-            const value = this.commands[key];
-            commands += `set local ${key}=${value};\n`;
-        }
-        return commands;
-    }
-    generateExplain() {
-        let query = "";
-        if (this.explainFlags.length > 0) {
-            query += `explain (${this.explainFlags.join(", ")}) `;
-        }
-        const semicolon = this.query.endsWith(";") ? "" : ";";
-        const preamble = query.length;
-        query += `${this.query}${semicolon}`;
-        return { query, preamble };
-    }
-}

package/dist/sql/database.js

@@ -1,20 +0,0 @@
-import { z } from "zod";
-export const PostgresVersion = z.string().brand("PostgresVersion");
-/**
- * Drops a disabled index. Rollsback if it fails for any reason
- * @returns Did dropping the index succeed?
- */
-export async function dropIndex(tx, index) {
-    try {
-        await tx.exec(`
-      savepoint idx_drop;
-      drop index if exists ${index} cascade;
-    `);
-        return true;
-    }
-    catch (error) {
-        // no problem if droping the index fails. It should throw an error
-        await tx.exec(`rollback to idx_drop`);
-        return false;
-    }
-}

package/dist/sql/indexes.js

@@ -1,12 +0,0 @@
-export function isIndexSupported(index) {
-    return index.index_type === "btree";
-}
-/**
- * Doesn't necessarily decide whether the index can be dropped but can be
- * used to not even try dropping indexes that _definitely_ cannot be dropped
- */
-export function isIndexProbablyDroppable(index) {
-    /* TODO: until we have a better solution, this is the best we have */
-    /* The is_unique check is problematic only if the column is declared as unique */
-    return !index.is_primary && !index.is_unique;
-}