@query-doctor/core 0.0.3

package/dist/sql/schema_dump.d.ts

@@ -0,0 +1,132 @@
+import { z } from "zod";
+export declare const ExportedPgMetadataSchema: z.ZodObject<{
+    indexes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        oid: z.ZodNumber;
+        schema_name: z.ZodString;
+        table_name: z.ZodString;
+        index_name: z.ZodString;
+        index_type: z.ZodString;
+        is_unique: z.ZodBoolean;
+        is_primary: z.ZodBoolean;
+        is_clustered: z.ZodBoolean;
+        where_predicate: z.ZodNullable<z.ZodString>;
+        tablespace: z.ZodNullable<z.ZodString>;
+        key_columns: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            order: z.ZodNullable<z.ZodEnum<{
+                ASC: "ASC";
+                DESC: "DESC";
+            }>>;
+            nulls: z.ZodNullable<z.ZodEnum<{
+                FIRST: "FIRST";
+                LAST: "LAST";
+            }>>;
+            opclass: z.ZodNullable<z.ZodString>;
+            collation: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+        included_columns: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    tables: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        oid: z.ZodNumber;
+        schema_name: z.ZodString;
+        table_name: z.ZodString;
+        tablespace: z.ZodNullable<z.ZodString>;
+        partition_key_def: z.ZodNullable<z.ZodString>;
+        columns: z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            order: z.ZodNumber;
+            type: z.ZodString;
+            is_nullable: z.ZodBoolean;
+            default_value: z.ZodNullable<z.ZodString>;
+            dropped: z.ZodBoolean;
+            collation: z.ZodNullable<z.ZodString>;
+            storage: z.ZodNullable<z.ZodEnum<{
+                plain: "plain";
+                main: "main";
+                external: "external";
+                extended: "extended";
+            }>>;
+            is_identity: z.ZodNullable<z.ZodEnum<{
+                always: "always";
+                "by default": "by default";
+            }>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+    constraints: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        oid: z.ZodNumber;
+        schema_name: z.ZodString;
+        table_name: z.ZodString;
+        constraint_name: z.ZodString;
+        constraint_type: z.ZodEnum<{
+            CHECK: "CHECK";
+            "FOREIGN KEY": "FOREIGN KEY";
+            "PRIMARY KEY": "PRIMARY KEY";
+            UNIQUE: "UNIQUE";
+            EXCLUSION: "EXCLUSION";
+        }>;
+        definition: z.ZodString;
+        is_deferrable: z.ZodNullable<z.ZodBoolean>;
+        is_initially_deferred: z.ZodNullable<z.ZodBoolean>;
+        is_validated: z.ZodNullable<z.ZodBoolean>;
+        backing_index_oid: z.ZodNullable<z.ZodNumber>;
+    }, z.core.$strip>>>;
+    functions: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        schema_name: z.ZodString;
+        object_name: z.ZodString;
+        object_type: z.ZodEnum<{
+            FUNCTION: "FUNCTION";
+            PROCEDURE: "PROCEDURE";
+            AGGREGATE: "AGGREGATE";
+            "WINDOW FUNCTION": "WINDOW FUNCTION";
+        }>;
+        identity_arguments: z.ZodNullable<z.ZodString>;
+        definition: z.ZodString;
+    }, z.core.$strip>>>;
+    extensions: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        extension_name: z.ZodString;
+        version: z.ZodString;
+        schema_name: z.ZodString;
+    }, z.core.$strip>>>;
+    views: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        schema_name: z.ZodString;
+        view_name: z.ZodString;
+        object_type: z.ZodEnum<{
+            view: "view";
+            materialized_view: "materialized_view";
+        }>;
+        definition: z.ZodString;
+        tablespace: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    types: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        schema_name: z.ZodString;
+        type_name: z.ZodString;
+        type_category: z.ZodEnum<{
+            enum: "enum";
+            domain: "domain";
+            composite: "composite";
+        }>;
+        enum_labels: z.ZodNullable<z.ZodArray<z.ZodString>>;
+        domain_base_type: z.ZodNullable<z.ZodString>;
+        domain_is_not_null: z.ZodNullable<z.ZodBoolean>;
+        domain_default: z.ZodNullable<z.ZodString>;
+        domain_constraints: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            definition: z.ZodString;
+        }, z.core.$strip>>>;
+        composite_attributes: z.ZodNullable<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodString;
+            collation: z.ZodNullable<z.ZodString>;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>>;
+    triggers: z.ZodNullable<z.ZodArray<z.ZodObject<{
+        schema_name: z.ZodString;
+        table_name: z.ZodString;
+        trigger_name: z.ZodString;
+        definition: z.ZodString;
+        enabled_mode: z.ZodString;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+//# sourceMappingURL=schema_dump.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema_dump.d.ts","sourceRoot":"","sources":["../../src/sql/schema_dump.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA+HxB,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBASnC,CAAC"}

package/dist/sql/trace.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=trace.d.ts.map

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

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

package/dist/sql/walker.d.ts

@@ -0,0 +1,44 @@
+import type { Node } from "@pgsql/types";
+import type { DiscoveredColumnReference } from "./analyzer.ts";
+import type { Nudge } from "./nudges.ts";
+/** Information about tables that appear in the query */
+export type TableMappings = Map<string, ColumnReferencePart>;
+/**
+ * Walks the AST of a sql query and extracts query metadata.
+ * This pattern is used to segregate the mutable state that's more common for the
+ * AST walking process from the rest of the analyzer.
+ */
+export declare class Walker {
+    private readonly query;
+    private tableMappings;
+    private tempTables;
+    private highlights;
+    private indexRepresentations;
+    private indexesToCheck;
+    private highlightPositions;
+    private seenReferences;
+    private shadowedAliases;
+    private nudges;
+    constructor(query: string);
+    walk(root: Node): {
+        highlights: DiscoveredColumnReference[];
+        indexRepresentations: Set<string>;
+        indexesToCheck: DiscoveredColumnReference[];
+        shadowedAliases: ColumnReferencePart[];
+        tempTables: Set<string>;
+        tableMappings: TableMappings;
+        nudges: Nudge[];
+    };
+    private add;
+    static traverse(node: unknown, stack: (KeysOfUnion<Node> | string)[], callback: (node: Node, stack: (KeysOfUnion<Node> | string)[]) => void): void;
+}
+export type ColumnReferencePart = {
+    /** the text of the column reference (excluding any potential quotes) */
+    text: string;
+    start?: number;
+    quoted: boolean;
+    alias?: string;
+};
+type KeysOfUnion<T> = T extends T ? keyof T : never;
+export {};
+//# sourceMappingURL=walker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"walker.d.ts","sourceRoot":"","sources":["../../src/sql/walker.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAgB,MAAM,cAAc,CAAC;AAEvD,OAAO,KAAK,EAAE,yBAAyB,EAAe,MAAM,eAAe,CAAC;AAE5E,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAEzC,wDAAwD;AACxD,MAAM,MAAM,aAAa,GAAG,GAAG,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;AAG7D;;;;GAIG;AACH,qBAAa,MAAM;IAaL,OAAO,CAAC,QAAQ,CAAC,KAAK;IAZlC,OAAO,CAAC,aAAa,CAA4B;IACjD,OAAO,CAAC,UAAU,CAAqB;IACvC,OAAO,CAAC,UAAU,CAAmC;IACrD,OAAO,CAAC,oBAAoB,CAAqB;IACjD,OAAO,CAAC,cAAc,CAAmC;IACzD,OAAO,CAAC,kBAAkB,CAAqB;IAG/C,OAAO,CAAC,cAAc,CAA6B;IACnD,OAAO,CAAC,eAAe,CAA6B;IACpD,OAAO,CAAC,MAAM,CAAe;gBAEA,KAAK,EAAE,MAAM;IAE1C,IAAI,CAAC,IAAI,EAAE,IAAI;;;;;;;;;IAoLf,OAAO,CAAC,GAAG;IA6EX,MAAM,CAAC,QAAQ,CACb,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,EAAE,EACrC,QAAQ,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,MAAM,CAAC,EAAE,KAAK,IAAI;CAwBxE;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,wEAAwE;IACxE,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,KAAK,WAAW,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,GAAG,KAAK,CAAC"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@query-doctor/core",
+  "private": false,
+  "version": "0.0.3",
+  "description": "Core logic for Query Doctor",
+  "license": "",
+  "author": "Query Doctor",
+  "type": "module",
+  "types": "dist/index.d.ts",
+  "main": "dist/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "dev": "tsup src/index.ts --target es2020 --format esm,cjs --watch --external react --onSuccess 'tsc --emitDeclarationOnly --declaration'",
+    "build": "tsup src/index.ts --target es2020 --format esm,cjs --external react",
+    "test": "node --import tsx --test src/**/*_test.ts"
+  },
+  "dependencies": {
+    "@pgsql/types": "^17.6.1",
+    "colorette": "^2.0.20",
+    "dedent": "^1.7.0",
+    "pgsql-deparser": "^17.11.1",
+    "zod": "^4.1.12"
+  },
+  "devDependencies": {
+    "@pgsql/parser": "^17.5.0",
+    "@query-doctor/eslint-config-custom": "*",
+    "@query-doctor/typescript-config": "*",
+    "tsup": "^8.5.0",
+    "typescript": "^5.9.0"
+  }
+}

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "strictPropertyInitialization": false,
+    "target": "es2022",
+    "lib": ["es2022"],
+    "outDir": "dist",
+    "baseUrl": "."
+  },
+  "extends": "@query-doctor/typescript-config/react-library.json",
+  "include": ["src"],
+  "exclude": ["dist", "build", "node_modules"]
+}