@query-doctor/core 0.1.0 → 0.1.2

package/dist/package.json

@@ -1,25 +0,0 @@
-{
-  "name": "@query-doctor/core",
-  "private": false,
-  "version": "0.0.3",
-  "description": "Core logic for Query Doctor",
-  "license": "",
-  "author": "Query Doctor",
-  "type": "module",
-  "types": "./index.d.ts",
-  "main": "./index.js",
-  "exports": {
-    ".": {
-      "types": "./index.d.ts",
-      "import": "./index.js",
-      "require": "./index.cjs"
-    }
-  },
-  "dependencies": {
-    "@pgsql/types": "^17.6.1",
-    "colorette": "^2.0.20",
-    "dedent": "^1.7.0",
-    "pgsql-deparser": "^17.11.1",
-    "zod": "^4.1.12"
-  }
-}

package/dist/sql/analyzer.js

@@ -1,270 +0,0 @@
-import { bgMagentaBright, blue, dim, strikethrough, } from "colorette";
-import { Walker } from "./walker.js";
-export const ignoredIdentifier = "__qd_placeholder";
-/**
- * Analyzes a query and returns a list of column references that
- * should be indexed.
- *
- * This should be instantiated once per analyzed query.
- */
-export class Analyzer {
-    parser;
-    constructor(parser) {
-        this.parser = parser;
-    }
-    async analyze(query, formattedQuery) {
-        const ast = (await this.parser(query));
-        if (!ast.stmts) {
-            throw new Error("Query did not have any statements. This should probably never happen?");
-        }
-        const stmt = ast.stmts[0].stmt;
-        if (!stmt) {
-            throw new Error("Query did not have any statements. This should probably never happen?");
-        }
-        const walker = new Walker(query);
-        const { highlights, indexRepresentations, indexesToCheck, shadowedAliases, tempTables, tableMappings, nudges, } = walker.walk(stmt);
-        const sortedHighlights = highlights.sort((a, b) => b.position.end - a.position.end);
-        let currQuery = query;
-        for (const highlight of sortedHighlights) {
-            // our parts might have
-            const parts = this.resolveTableAliases(highlight.parts, tableMappings);
-            if (parts.length === 0) {
-                console.error(highlight);
-                throw new Error("Highlight must have at least one part");
-            }
-            let color;
-            let skip = false;
-            if (highlight.ignored) {
-                color = (x) => dim(strikethrough(x));
-                skip = true;
-            }
-            else if (parts.length === 2 &&
-                tempTables.has(parts[0].text) &&
-                // sometimes temp tables are aliased as existing tables
-                // we don't want to ignore them if they are
-                !tableMappings.has(parts[0].text)) {
-                color = blue;
-                skip = true;
-            }
-            else {
-                color = bgMagentaBright;
-            }
-            const queryRepr = highlight.representation;
-            const queryBeforeMatch = currQuery.slice(0, highlight.position.start);
-            const queryAfterToken = currQuery.slice(highlight.position.end);
-            currQuery = `${queryBeforeMatch}${color(queryRepr)}${this.colorizeKeywords(queryAfterToken, color)}`;
-            if (indexRepresentations.has(queryRepr)) {
-                skip = true;
-            }
-            if (!skip) {
-                indexesToCheck.push(highlight);
-                indexRepresentations.add(queryRepr);
-            }
-        }
-        const referencedTables = [];
-        for (const value of tableMappings.values()) {
-            // aliased mappings are not concrete tables
-            // eg: select * from table t -> t is not a table
-            if (!value.alias) {
-                referencedTables.push(value.text);
-            }
-        }
-        const { tags, queryWithoutTags } = this.extractSqlcommenter(query);
-        const formattedQueryWithoutTags = formattedQuery
-            ? this.extractSqlcommenter(formattedQuery).queryWithoutTags
-            : undefined;
-        return {
-            indexesToCheck,
-            ansiHighlightedQuery: currQuery,
-            referencedTables,
-            shadowedAliases,
-            tags,
-            queryWithoutTags,
-            formattedQueryWithoutTags,
-            nudges,
-        };
-    }
-    deriveIndexes(tables, discovered) {
-        /**
-         * There are 3 different kinds of parts a col reference can have
-         * {a} = just a column within context. Find out the table
-         * {a, b} = a column reference with a table reference. There's still ambiguity here
-         * with what the schema could be in case there are 2 tables with the same name in different schemas.
-         * {a, b, c} = a column reference with a table reference and a schema reference.
-         * This is the best case scenario.
-         */
-        const allIndexes = [];
-        const seenIndexes = new Set();
-        function addIndex(index) {
-            const key = `"${index.schema}":"${index.table}":"${index.column}"`;
-            if (seenIndexes.has(key)) {
-                return;
-            }
-            seenIndexes.add(key);
-            allIndexes.push(index);
-        }
-        for (const colReference of discovered) {
-            const partsCount = colReference.parts.length;
-            const columnOnlyReference = partsCount === 1;
-            const tableReference = partsCount === 2;
-            const fullReference = partsCount === 3;
-            if (columnOnlyReference) {
-                // select c from x
-                const [column] = colReference.parts;
-                const referencedColumn = this.normalize(column);
-                // TODO: this is not a good guess
-                // we can absolutely infer the schema name
-                // much better from the surrounding context
-                // this will lead to problems where we use
-                // tables like `auth.users` instead of `public.users`
-                // just because `auth` might have alphabetic priority
-                const matchingTables = tables.filter((table) => {
-                    return (table.columns?.some((column) => {
-                        return column.columnName === referencedColumn;
-                    }) ?? false);
-                });
-                for (const table of matchingTables) {
-                    const index = {
-                        schema: table.schemaName,
-                        table: table.tableName,
-                        column: referencedColumn,
-                    };
-                    if (colReference.sort) {
-                        index.sort = colReference.sort;
-                    }
-                    if (colReference.where) {
-                        index.where = colReference.where;
-                    }
-                    addIndex(index);
-                }
-            }
-            else if (tableReference) {
-                // select b.c from x
-                const [table, column] = colReference.parts;
-                const referencedTable = this.normalize(table);
-                const referencedColumn = this.normalize(column);
-                const matchingTable = tables.find((table) => {
-                    const hasMatchingColumn = table.columns?.some((column) => {
-                        return column.columnName === referencedColumn;
-                    }) ?? false;
-                    return table.tableName === referencedTable && hasMatchingColumn;
-                });
-                if (matchingTable) {
-                    const index = {
-                        schema: matchingTable.schemaName,
-                        table: referencedTable,
-                        column: referencedColumn,
-                    };
-                    if (colReference.sort) {
-                        index.sort = colReference.sort;
-                    }
-                    if (colReference.where) {
-                        index.where = colReference.where;
-                    }
-                    addIndex(index);
-                }
-            }
-            else if (fullReference) {
-                // select a.b.c from x
-                const [schema, table, column] = colReference.parts;
-                const referencedSchema = this.normalize(schema);
-                const referencedTable = this.normalize(table);
-                const referencedColumn = this.normalize(column);
-                const index = {
-                    schema: referencedSchema,
-                    table: referencedTable,
-                    column: referencedColumn,
-                };
-                if (colReference.sort) {
-                    index.sort = colReference.sort;
-                }
-                if (colReference.where) {
-                    index.where = colReference.where;
-                }
-                addIndex(index);
-            }
-            else {
-                // select huh.a.b.c from x
-                console.error("Column reference has too many parts. The query is malformed", colReference);
-                continue;
-            }
-        }
-        return allIndexes;
-    }
-    colorizeKeywords(query, color) {
-        return query
-            .replace(
-        // eh? This kinda sucks
-        /(^\s+)(asc|desc)?(\s+(nulls first|nulls last))?/i, (_, pre, dir, spaceNulls, nulls) => {
-            return `${pre}${dir ? color(dir) : ""}${nulls ? spaceNulls.replace(nulls, color(nulls)) : ""}`;
-        })
-            .replace(/(^\s+)(is (null|not null))/i, (_, pre, nulltest) => {
-            return `${pre}${color(nulltest)}`;
-        });
-    }
-    /**
-     * Resolves aliases such as `a.b` to `x.b` if `a` is a known
-     * alias to a table called x.
-     *
-     * Ignores all other combination of parts such as `a.b.c`
-     */
-    resolveTableAliases(parts, tableMappings) {
-        // we don't want to resolve aliases for references such as
-        // `a.b.c` - this is fully qualified with a schema and can't be an alias
-        // `c` - because there's no table reference here (as far as we can tell)
-        if (parts.length !== 2) {
-            return parts;
-        }
-        const tablePart = parts[0];
-        const mapping = tableMappings.get(tablePart.text);
-        if (mapping) {
-            parts[0] = mapping;
-        }
-        return parts;
-    }
-    normalize(columnReference) {
-        return columnReference.quoted
-            ? columnReference.text
-            : // postgres automatically lowercases column names if not quoted
-                columnReference.text.toLowerCase();
-    }
-    extractSqlcommenter(query) {
-        const trimmedQuery = query.trimEnd();
-        const startPosition = trimmedQuery.lastIndexOf("/*");
-        const endPosition = trimmedQuery.lastIndexOf("*/");
-        if (startPosition === -1 || endPosition === -1) {
-            return { tags: [], queryWithoutTags: trimmedQuery };
-        }
-        const queryWithoutTags = trimmedQuery.slice(0, startPosition);
-        const tagString = trimmedQuery.slice(startPosition + 2, endPosition);
-        if (!tagString || typeof tagString !== "string") {
-            return { tags: [], queryWithoutTags: queryWithoutTags };
-        }
-        const tags = [];
-        for (const match of tagString.split(",")) {
-            const [key, value] = match.split("=");
-            if (!key || !value) {
-                console.warn(`Invalid sqlcommenter tag: ${match}. Ignoring`);
-                continue;
-            }
-            try {
-                let sliceStart = 0;
-                if (value.startsWith("'")) {
-                    sliceStart = 1;
-                }
-                let sliceEnd = value.length;
-                if (value.endsWith("'")) {
-                    sliceEnd -= 1;
-                }
-                const decoded = decodeURIComponent(value.slice(sliceStart, sliceEnd));
-                // should we be trimming here?
-                tags.push({ key: key.trim(), value: decoded });
-            }
-            catch (err) {
-                // we want to be very conservative with this parser and ignore errors
-                console.error(err);
-            }
-        }
-        return { tags, queryWithoutTags };
-    }
-}

package/dist/sql/analyzer_test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=analyzer_test.d.ts.map

package/dist/sql/analyzer_test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyzer_test.d.ts","sourceRoot":"","sources":["../../src/sql/analyzer_test.ts"],"names":[],"mappings":""}