@indiekitai/pg-complete 0.1.0

package/dist/index.js

@@ -0,0 +1,1219 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BUILTIN_FUNCTIONS: () => BUILTIN_FUNCTIONS,
+  KEYWORDS: () => KEYWORDS,
+  KEYWORD_TREE: () => KEYWORD_TREE,
+  PgCompleter: () => PgCompleter,
+  extractTables: () => extractTables,
+  suggestType: () => suggestType
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/completer.ts
+var import_pg = require("pg");
+
+// src/keywords.ts
+var KEYWORDS = [
+  // DML
+  "SELECT",
+  "FROM",
+  "WHERE",
+  "AND",
+  "OR",
+  "NOT",
+  "IN",
+  "EXISTS",
+  "BETWEEN",
+  "LIKE",
+  "ILIKE",
+  "IS",
+  "NULL",
+  "TRUE",
+  "FALSE",
+  "AS",
+  "ON",
+  "USING",
+  "JOIN",
+  "INNER",
+  "LEFT",
+  "RIGHT",
+  "FULL",
+  "OUTER",
+  "CROSS",
+  "NATURAL",
+  "ORDER",
+  "BY",
+  "ASC",
+  "DESC",
+  "NULLS",
+  "FIRST",
+  "LAST",
+  "GROUP",
+  "HAVING",
+  "LIMIT",
+  "OFFSET",
+  "UNION",
+  "ALL",
+  "INTERSECT",
+  "EXCEPT",
+  "DISTINCT",
+  "INSERT",
+  "INTO",
+  "VALUES",
+  "DEFAULT",
+  "RETURNING",
+  "UPDATE",
+  "SET",
+  "DELETE",
+  "WITH",
+  "RECURSIVE",
+  "CASE",
+  "WHEN",
+  "THEN",
+  "ELSE",
+  "END",
+  "CAST",
+  "COALESCE",
+  "NULLIF",
+  "GREATEST",
+  "LEAST",
+  // DDL
+  "CREATE",
+  "ALTER",
+  "DROP",
+  "TRUNCATE",
+  "TABLE",
+  "VIEW",
+  "INDEX",
+  "SEQUENCE",
+  "SCHEMA",
+  "DATABASE",
+  "FUNCTION",
+  "PROCEDURE",
+  "TRIGGER",
+  "TYPE",
+  "EXTENSION",
+  "MATERIALIZED",
+  "TEMPORARY",
+  "TEMP",
+  "UNLOGGED",
+  "IF",
+  "CASCADE",
+  "RESTRICT",
+  "ADD",
+  "COLUMN",
+  "RENAME",
+  "TO",
+  "PRIMARY",
+  "KEY",
+  "FOREIGN",
+  "REFERENCES",
+  "UNIQUE",
+  "CHECK",
+  "CONSTRAINT",
+  "NOT NULL",
+  // Data types
+  "INTEGER",
+  "INT",
+  "BIGINT",
+  "SMALLINT",
+  "SERIAL",
+  "BIGSERIAL",
+  "REAL",
+  "DOUBLE",
+  "PRECISION",
+  "NUMERIC",
+  "DECIMAL",
+  "TEXT",
+  "VARCHAR",
+  "CHAR",
+  "CHARACTER",
+  "VARYING",
+  "BOOLEAN",
+  "BOOL",
+  "DATE",
+  "TIME",
+  "TIMESTAMP",
+  "TIMESTAMPTZ",
+  "INTERVAL",
+  "JSON",
+  "JSONB",
+  "UUID",
+  "BYTEA",
+  "ARRAY",
+  // Transaction
+  "BEGIN",
+  "COMMIT",
+  "ROLLBACK",
+  "SAVEPOINT",
+  // Other
+  "GRANT",
+  "REVOKE",
+  "EXPLAIN",
+  "ANALYZE",
+  "VERBOSE",
+  "COPY",
+  "VACUUM",
+  "REINDEX",
+  "CLUSTER",
+  "LATERAL",
+  "WINDOW",
+  "OVER",
+  "PARTITION",
+  "ROWS",
+  "RANGE",
+  "FETCH",
+  "NEXT",
+  "PRIOR",
+  "ABSOLUTE",
+  "RELATIVE",
+  "FOR",
+  "SHARE",
+  "NOWAIT",
+  "SKIP",
+  "LOCKED",
+  "ANY",
+  "SOME"
+];
+var KEYWORD_TREE = {
+  "SELECT": ["DISTINCT", "ALL", "*"],
+  "FROM": [],
+  "WHERE": [],
+  "ORDER": ["BY"],
+  "GROUP": ["BY"],
+  "INSERT": ["INTO"],
+  "UPDATE": ["SET"],
+  "DELETE": ["FROM"],
+  "CREATE": [
+    "TABLE",
+    "VIEW",
+    "INDEX",
+    "SCHEMA",
+    "DATABASE",
+    "FUNCTION",
+    "PROCEDURE",
+    "TRIGGER",
+    "TYPE",
+    "EXTENSION",
+    "MATERIALIZED",
+    "TEMPORARY",
+    "TEMP",
+    "UNLOGGED",
+    "UNIQUE",
+    "OR"
+  ],
+  "ALTER": [
+    "TABLE",
+    "VIEW",
+    "INDEX",
+    "SCHEMA",
+    "DATABASE",
+    "FUNCTION",
+    "PROCEDURE",
+    "TRIGGER",
+    "TYPE",
+    "EXTENSION",
+    "SEQUENCE"
+  ],
+  "DROP": [
+    "TABLE",
+    "VIEW",
+    "INDEX",
+    "SCHEMA",
+    "DATABASE",
+    "FUNCTION",
+    "PROCEDURE",
+    "TRIGGER",
+    "TYPE",
+    "EXTENSION",
+    "SEQUENCE",
+    "IF"
+  ],
+  "JOIN": [],
+  "INNER": ["JOIN"],
+  "LEFT": ["JOIN", "OUTER"],
+  "RIGHT": ["JOIN", "OUTER"],
+  "FULL": ["JOIN", "OUTER"],
+  "CROSS": ["JOIN"],
+  "NATURAL": ["JOIN", "LEFT", "RIGHT", "FULL", "INNER"],
+  "OUTER": ["JOIN"],
+  "IF": ["EXISTS", "NOT"],
+  "NOT": ["NULL", "EXISTS", "IN", "BETWEEN", "LIKE", "ILIKE"],
+  "IS": ["NULL", "NOT", "TRUE", "FALSE", "DISTINCT"],
+  "OR": ["REPLACE"],
+  "UNION": ["ALL"],
+  "LIMIT": [],
+  "OFFSET": [],
+  "SET": [],
+  "VALUES": [],
+  "ON": [],
+  "RETURNING": [],
+  "INTO": [],
+  "GRANT": ["ALL", "SELECT", "INSERT", "UPDATE", "DELETE", "USAGE"],
+  "REVOKE": ["ALL", "SELECT", "INSERT", "UPDATE", "DELETE", "USAGE"],
+  "WITH": ["RECURSIVE"]
+};
+var BUILTIN_FUNCTIONS = [
+  // Aggregate
+  "avg",
+  "count",
+  "max",
+  "min",
+  "sum",
+  "array_agg",
+  "string_agg",
+  "bool_and",
+  "bool_or",
+  "json_agg",
+  "jsonb_agg",
+  "json_object_agg",
+  "jsonb_object_agg",
+  // String
+  "length",
+  "lower",
+  "upper",
+  "trim",
+  "ltrim",
+  "rtrim",
+  "substring",
+  "replace",
+  "concat",
+  "concat_ws",
+  "left",
+  "right",
+  "repeat",
+  "reverse",
+  "split_part",
+  "starts_with",
+  "format",
+  "regexp_replace",
+  "regexp_matches",
+  // Numeric
+  "abs",
+  "ceil",
+  "floor",
+  "round",
+  "trunc",
+  "mod",
+  "power",
+  "sqrt",
+  "random",
+  "generate_series",
+  // Date/Time
+  "now",
+  "current_date",
+  "current_time",
+  "current_timestamp",
+  "date_trunc",
+  "date_part",
+  "extract",
+  "age",
+  "to_char",
+  "to_date",
+  "to_timestamp",
+  "to_number",
+  "make_date",
+  "make_time",
+  "make_timestamp",
+  // JSON
+  "json_build_object",
+  "jsonb_build_object",
+  "json_build_array",
+  "jsonb_build_array",
+  "json_extract_path",
+  "jsonb_extract_path",
+  "json_extract_path_text",
+  "jsonb_extract_path_text",
+  "json_array_length",
+  "jsonb_array_length",
+  "json_each",
+  "jsonb_each",
+  "json_each_text",
+  "jsonb_each_text",
+  "json_typeof",
+  "jsonb_typeof",
+  "row_to_json",
+  "to_json",
+  "to_jsonb",
+  // Array
+  "array_length",
+  "array_dims",
+  "array_lower",
+  "array_upper",
+  "array_append",
+  "array_prepend",
+  "array_cat",
+  "array_remove",
+  "array_position",
+  "array_positions",
+  "unnest",
+  // Type casting
+  "cast",
+  // Window
+  "row_number",
+  "rank",
+  "dense_rank",
+  "percent_rank",
+  "cume_dist",
+  "ntile",
+  "lag",
+  "lead",
+  "first_value",
+  "last_value",
+  "nth_value",
+  // System
+  "current_database",
+  "current_schema",
+  "current_user",
+  "session_user",
+  "pg_typeof",
+  "version",
+  // Conditional
+  "coalesce",
+  "nullif",
+  "greatest",
+  "least"
+];
+
+// src/parser.ts
+function suggestType(fullText, textBeforeCursor) {
+  const trimmed = textBeforeCursor.trimEnd();
+  const wordMatch = textBeforeCursor.match(/([A-Za-z0-9_."$]+)$/);
+  const wordBeforeCursor = wordMatch ? wordMatch[1] : "";
+  const textForAnalysis = wordBeforeCursor ? textBeforeCursor.slice(0, -wordBeforeCursor.length) : textBeforeCursor;
+  const dotMatch = wordBeforeCursor.match(/^([A-Za-z_][A-Za-z0-9_]*)\.(.*)$/);
+  const tableRefs = extractTables(fullText);
+  const lastKeyword = findLastKeyword(textForAnalysis);
+  const lastKw = lastKeyword?.toUpperCase() || "";
+  if (dotMatch) {
+    const parent = dotMatch[1];
+    const matchingTables = tableRefs.filter(
+      (t) => t.alias === parent || t.name === parent || t.schema && `${t.schema}.${t.name}` === parent
+    );
+    const suggestions = [];
+    if (matchingTables.length > 0) {
+      suggestions.push({ type: "column", tableRefs: matchingTables, qualifiable: false, parent });
+    }
+    suggestions.push(
+      { type: "table", schema: parent },
+      { type: "view", schema: parent },
+      { type: "function", schema: parent }
+    );
+    return suggestions;
+  }
+  if (!lastKw || lastKw === "") {
+    return [{ type: "keyword" }];
+  }
+  if (lastKw === "SELECT" || lastKw === "WHERE" || lastKw === "HAVING" || lastKw === "ORDER BY" || lastKw === "DISTINCT") {
+    return [
+      { type: "column", tableRefs, qualifiable: tableRefs.length > 1 },
+      { type: "function", schema: null },
+      { type: "keyword", lastToken: lastKw }
+    ];
+  }
+  if (lastKw === "FROM" || lastKw === "COPY" || lastKw === "UPDATE" || lastKw === "INTO" || lastKw === "INSERT INTO" || lastKw === "TRUNCATE") {
+    const isFrom = lastKw === "FROM";
+    const suggestions = [{ type: "schema" }];
+    if (isFrom) {
+      suggestions.push({ type: "from_clause", schema: null, tableRefs });
+    } else {
+      suggestions.push({ type: "table", schema: null });
+      suggestions.push({ type: "view", schema: null });
+    }
+    return suggestions;
+  }
+  if (lastKw === "JOIN" || lastKw.endsWith(" JOIN")) {
+    const suggestions = [
+      { type: "schema" },
+      { type: "from_clause", schema: null, tableRefs }
+    ];
+    if (tableRefs.length > 0) {
+      suggestions.push({ type: "join", tableRefs, schema: null });
+    }
+    return suggestions;
+  }
+  if (lastKw === "ON") {
+    const aliases = tableRefs.map((t) => t.alias || t.name);
+    const suggestions = [
+      { type: "alias", aliases }
+    ];
+    if (tableRefs.length >= 2) {
+      suggestions.push({ type: "join_condition", tableRefs });
+    }
+    return suggestions;
+  }
+  if (lastKw === "SET") {
+    return [{ type: "column", tableRefs, qualifiable: false }];
+  }
+  if (lastKw === "TABLE" || lastKw === "VIEW") {
+    return [{ type: "schema" }, { type: lastKw === "TABLE" ? "table" : "view", schema: null }];
+  }
+  if (lastKw === "FUNCTION") {
+    return [{ type: "schema" }, { type: "function", schema: null }];
+  }
+  if (lastKw === "SCHEMA") {
+    return [{ type: "schema" }];
+  }
+  if (lastKw === "DATABASE") {
+    return [{ type: "database" }];
+  }
+  if (lastKw === "TYPE" || lastKw === "::") {
+    return [
+      { type: "datatype", schema: null },
+      { type: "table", schema: null },
+      { type: "schema" }
+    ];
+  }
+  if (["CREATE", "ALTER", "DROP"].includes(lastKw)) {
+    return [{ type: "keyword", lastToken: lastKw }];
+  }
+  if (lastKw === "AND" || lastKw === "OR" || lastKw === "," || lastKw === "=") {
+    const prevKw = findPrevSignificantKeyword(textForAnalysis);
+    if (prevKw) {
+      return suggestType(fullText, textForAnalysis);
+    }
+  }
+  if (lastKw === "AS") {
+    return [];
+  }
+  if (lastKw === "COLUMN") {
+    return [{ type: "column", tableRefs, qualifiable: false }];
+  }
+  return [{ type: "keyword", lastToken: lastKw }];
+}
+function extractTables(sql) {
+  const tables = [];
+  const normalized = sql.replace(/\s+/g, " ").trim();
+  const tableContextRegex = /\b(?:FROM|JOIN|UPDATE|INTO|TABLE)\s+/gi;
+  let match;
+  while ((match = tableContextRegex.exec(normalized)) !== null) {
+    const afterKeyword = normalized.slice(match.index + match[0].length);
+    const refs = parseTableList(afterKeyword);
+    tables.push(...refs);
+  }
+  return dedup(tables);
+}
+function parseTableList(text) {
+  const tables = [];
+  const parts = splitOnCommas(text);
+  for (const part of parts) {
+    const ref = parseOneTableRef(part.trim());
+    if (ref) tables.push(ref);
+  }
+  return tables;
+}
+function splitOnCommas(text) {
+  const parts = [];
+  let depth = 0;
+  let current = "";
+  for (const ch of text) {
+    if (ch === "(") depth++;
+    else if (ch === ")") depth--;
+    if (ch === "," && depth === 0) {
+      parts.push(current);
+      current = "";
+    } else if (depth < 0) {
+      parts.push(current);
+      break;
+    } else if (/[;]/.test(ch) && depth === 0) {
+      parts.push(current);
+      break;
+    } else {
+      current += ch;
+    }
+  }
+  if (current.trim()) parts.push(current);
+  return parts;
+}
+function parseOneTableRef(text) {
+  const stopKeywords = /\b(?:WHERE|SET|ORDER|GROUP|HAVING|LIMIT|OFFSET|UNION|INTERSECT|EXCEPT|ON|USING|RETURNING|VALUES|LEFT|RIGHT|INNER|OUTER|FULL|CROSS|NATURAL|JOIN)\b/i;
+  const stopMatch = text.match(stopKeywords);
+  if (stopMatch) {
+    text = text.slice(0, stopMatch.index).trim();
+  }
+  if (!text) return null;
+  const m = text.match(
+    /^(?:"([^"]+)"|([A-Za-z_][A-Za-z0-9_$]*))(?:\.(?:"([^"]+)"|([A-Za-z_][A-Za-z0-9_$]*)))?(?:\s+(?:AS\s+)?(?:"([^"]+)"|([A-Za-z_][A-Za-z0-9_$]*)))?/i
+  );
+  if (!m) return null;
+  const part1 = m[1] || m[2];
+  const part2 = m[3] || m[4];
+  const alias = m[5] || m[6];
+  const aliasUpper = alias?.toUpperCase();
+  const keywordAlias = aliasUpper && /^(WHERE|SET|ORDER|GROUP|HAVING|LIMIT|OFFSET|ON|USING|JOIN|LEFT|RIGHT|INNER|OUTER|FULL|CROSS|NATURAL|AS|AND|OR|NOT|RETURNING|VALUES|INTO|FROM|SELECT|INSERT|UPDATE|DELETE|CREATE|ALTER|DROP)$/.test(aliasUpper);
+  if (part2) {
+    return {
+      schema: part1.toLowerCase(),
+      name: part2.toLowerCase(),
+      alias: keywordAlias ? null : alias?.toLowerCase() || null,
+      isFunction: false
+    };
+  }
+  return {
+    schema: null,
+    name: part1.toLowerCase(),
+    alias: keywordAlias ? null : alias?.toLowerCase() || null,
+    isFunction: false
+  };
+}
+function dedup(tables) {
+  const seen = /* @__PURE__ */ new Set();
+  return tables.filter((t) => {
+    const key = `${t.schema || ""}.${t.name}.${t.alias || ""}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function findLastKeyword(text) {
+  const trimmed = text.trimEnd();
+  const compoundMatch = trimmed.match(/\b(ORDER\s+BY|GROUP\s+BY|INSERT\s+INTO|NOT\s+IN|LEFT\s+(?:OUTER\s+)?JOIN|RIGHT\s+(?:OUTER\s+)?JOIN|FULL\s+(?:OUTER\s+)?JOIN|INNER\s+JOIN|CROSS\s+JOIN|NATURAL\s+JOIN|DISTINCT\s+ON)\s*$/i);
+  if (compoundMatch) {
+    return compoundMatch[1].replace(/\s+/g, " ").toUpperCase();
+  }
+  const simpleMatch = trimmed.match(/\b([A-Za-z]+)\s*$/);
+  if (simpleMatch) {
+    const kw = simpleMatch[1].toUpperCase();
+    const knownKeywords = /* @__PURE__ */ new Set([
+      "SELECT",
+      "FROM",
+      "WHERE",
+      "JOIN",
+      "ON",
+      "AND",
+      "OR",
+      "SET",
+      "INTO",
+      "UPDATE",
+      "INSERT",
+      "DELETE",
+      "CREATE",
+      "ALTER",
+      "DROP",
+      "TABLE",
+      "VIEW",
+      "FUNCTION",
+      "SCHEMA",
+      "DATABASE",
+      "AS",
+      "HAVING",
+      "ORDER",
+      "GROUP",
+      "DISTINCT",
+      "LIMIT",
+      "OFFSET",
+      "RETURNING",
+      "TRUNCATE",
+      "COPY",
+      "TYPE",
+      "COLUMN",
+      "VALUES"
+    ]);
+    if (knownKeywords.has(kw)) return kw;
+  }
+  if (trimmed.endsWith(",")) return ",";
+  if (trimmed.endsWith("=")) return "=";
+  if (trimmed.endsWith("::")) return "::";
+  return null;
+}
+function findPrevSignificantKeyword(text) {
+  const withoutLast = text.replace(/\S+\s*$/, "").trim();
+  return findLastKeyword(withoutLast);
+}
+function tableRef(t) {
+  return t.alias || t.name;
+}
+
+// src/metadata.ts
+async function fetchMetadata(pool) {
+  const meta = {
+    tables: {},
+    views: {},
+    functions: {},
+    datatypes: {}
+  };
+  const [schemas, tables, views, tableCols, viewCols, functions, fks, datatypes] = await Promise.all([
+    fetchSchemas(pool),
+    fetchTables(pool),
+    fetchViews(pool),
+    fetchColumns(pool, ["r", "p", "f"]),
+    fetchColumns(pool, ["v", "m"]),
+    fetchFunctions(pool),
+    fetchForeignKeys(pool),
+    fetchDatatypes(pool)
+  ]);
+  for (const schema of schemas) {
+    meta.tables[schema] = meta.tables[schema] || {};
+    meta.views[schema] = meta.views[schema] || {};
+    meta.functions[schema] = meta.functions[schema] || {};
+    meta.datatypes[schema] = meta.datatypes[schema] || {};
+  }
+  for (const { schema, name } of tables) {
+    if (!meta.tables[schema]) meta.tables[schema] = {};
+    meta.tables[schema][name] = [];
+  }
+  for (const { schema, name } of views) {
+    if (!meta.views[schema]) meta.views[schema] = {};
+    meta.views[schema][name] = [];
+  }
+  for (const col of tableCols) {
+    const tbl = meta.tables[col.schema]?.[col.table];
+    if (tbl) {
+      tbl.push({
+        name: col.name,
+        datatype: col.datatype,
+        hasDefault: col.hasDefault,
+        default_: col.default_,
+        foreignKeys: []
+      });
+    }
+  }
+  for (const col of viewCols) {
+    const v = meta.views[col.schema]?.[col.view];
+    if (v) {
+      v.push({
+        name: col.name,
+        datatype: col.datatype,
+        hasDefault: col.hasDefault,
+        default_: col.default_,
+        foreignKeys: []
+      });
+    }
+  }
+  for (const f of functions) {
+    if (!meta.functions[f.schemaName]) meta.functions[f.schemaName] = {};
+    if (!meta.functions[f.schemaName][f.funcName]) {
+      meta.functions[f.schemaName][f.funcName] = [];
+    }
+    meta.functions[f.schemaName][f.funcName].push(f);
+  }
+  for (const fk of fks) {
+    const childCols = meta.tables[fk.childSchema]?.[fk.childTable];
+    if (childCols) {
+      const col = childCols.find((c) => c.name === fk.childColumn);
+      if (col) col.foreignKeys.push(fk);
+    }
+    const parentCols = meta.tables[fk.parentSchema]?.[fk.parentTable];
+    if (parentCols) {
+      const col = parentCols.find((c) => c.name === fk.parentColumn);
+      if (col) col.foreignKeys.push(fk);
+    }
+  }
+  for (const dt of datatypes) {
+    if (!meta.datatypes[dt.schema]) meta.datatypes[dt.schema] = {};
+    meta.datatypes[dt.schema][dt.name] = null;
+  }
+  return meta;
+}
+async function fetchSchemas(pool) {
+  const { rows } = await pool.query(
+    `SELECT nspname FROM pg_catalog.pg_namespace ORDER BY 1`
+  );
+  return rows.map((r) => r.nspname);
+}
+async function fetchTables(pool) {
+  const { rows } = await pool.query(
+    `SELECT n.nspname AS schema, c.relname AS name
+     FROM pg_catalog.pg_class c
+     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+     WHERE c.relkind = ANY($1)
+     ORDER BY 1, 2`,
+    [["r", "p", "f"]]
+  );
+  return rows.map((r) => ({ schema: r.schema, name: r.name }));
+}
+async function fetchViews(pool) {
+  const { rows } = await pool.query(
+    `SELECT n.nspname AS schema, c.relname AS name
+     FROM pg_catalog.pg_class c
+     LEFT JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
+     WHERE c.relkind = ANY($1)
+     ORDER BY 1, 2`,
+    [["v", "m"]]
+  );
+  return rows.map((r) => ({ schema: r.schema, name: r.name }));
+}
+async function fetchColumns(pool, kinds) {
+  const { rows } = await pool.query(
+    `SELECT nsp.nspname AS schema,
+            cls.relname AS table,
+            att.attname AS name,
+            att.atttypid::regtype::text AS datatype,
+            att.atthasdef AS "hasDefault",
+            pg_catalog.pg_get_expr(def.adbin, def.adrelid, true) AS "default_"
+     FROM pg_catalog.pg_attribute att
+     INNER JOIN pg_catalog.pg_class cls ON att.attrelid = cls.oid
+     INNER JOIN pg_catalog.pg_namespace nsp ON cls.relnamespace = nsp.oid
+     LEFT OUTER JOIN pg_attrdef def ON def.adrelid = att.attrelid AND def.adnum = att.attnum
+     WHERE cls.relkind = ANY($1)
+       AND NOT att.attisdropped
+       AND att.attnum > 0
+     ORDER BY 1, 2, att.attnum`,
+    [kinds]
+  );
+  return rows.map((r) => ({
+    schema: r.schema,
+    table: r.table,
+    view: r.table,
+    name: r.name,
+    datatype: r.datatype,
+    hasDefault: r.hasDefault,
+    default_: r.default_
+  }));
+}
+async function fetchFunctions(pool) {
+  const { rows } = await pool.query(
+    `SELECT n.nspname AS "schemaName",
+            p.proname AS "funcName",
+            p.proargnames AS "argNames",
+            COALESCE(proallargtypes::regtype[], proargtypes::regtype[])::text[] AS "argTypes",
+            p.proargmodes AS "argModes",
+            prorettype::regtype::text AS "returnType",
+            p.prokind = 'a' AS "isAggregate",
+            p.prokind = 'w' AS "isWindow",
+            p.proretset AS "isSetReturning",
+            d.deptype = 'e' AS "isExtension"
+     FROM pg_catalog.pg_proc p
+     INNER JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
+     LEFT JOIN pg_depend d ON d.objid = p.oid AND d.deptype = 'e'
+     WHERE p.prorettype::regtype != 'trigger'::regtype
+     ORDER BY 1, 2`
+  );
+  return rows.map((r) => ({
+    ...r,
+    isPublic: r.schemaName === "public",
+    isExtension: !!r.isExtension
+  }));
+}
+async function fetchForeignKeys(pool) {
+  const { rows } = await pool.query(
+    `SELECT s_p.nspname AS "parentSchema",
+            t_p.relname AS "parentTable",
+            unnest((
+              SELECT array_agg(attname ORDER BY i)
+              FROM (SELECT unnest(confkey) AS attnum, generate_subscripts(confkey, 1) AS i) x
+              JOIN pg_catalog.pg_attribute c USING(attnum)
+              WHERE c.attrelid = fk.confrelid
+            )) AS "parentColumn",
+            s_c.nspname AS "childSchema",
+            t_c.relname AS "childTable",
+            unnest((
+              SELECT array_agg(attname ORDER BY i)
+              FROM (SELECT unnest(conkey) AS attnum, generate_subscripts(conkey, 1) AS i) x
+              JOIN pg_catalog.pg_attribute c USING(attnum)
+              WHERE c.attrelid = fk.conrelid
+            )) AS "childColumn"
+     FROM pg_catalog.pg_constraint fk
+     JOIN pg_catalog.pg_class t_p ON t_p.oid = fk.confrelid
+     JOIN pg_catalog.pg_namespace s_p ON s_p.oid = t_p.relnamespace
+     JOIN pg_catalog.pg_class t_c ON t_c.oid = fk.conrelid
+     JOIN pg_catalog.pg_namespace s_c ON s_c.oid = t_c.relnamespace
+     WHERE fk.contype = 'f'`
+  );
+  return rows;
+}
+async function fetchDatatypes(pool) {
+  const { rows } = await pool.query(
+    `SELECT n.nspname AS schema, t.typname AS name
+     FROM pg_catalog.pg_type t
+     INNER JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
+     WHERE (t.typrelid = 0 OR (SELECT c.relkind = 'c' FROM pg_catalog.pg_class c WHERE c.oid = t.typrelid))
+       AND NOT EXISTS (SELECT 1 FROM pg_catalog.pg_type el WHERE el.oid = t.typelem AND el.typarray = t.oid)
+       AND n.nspname <> 'pg_catalog'
+       AND n.nspname <> 'information_schema'
+     ORDER BY 1, 2`
+  );
+  return rows;
+}
+async function fetchSearchPath(pool) {
+  const { rows } = await pool.query(
+    `SELECT * FROM unnest(current_schemas(true))`
+  );
+  return rows.map((r) => r.unnest);
+}
+
+// src/completer.ts
+var PgCompleter = class {
+  pool = null;
+  metadata;
+  searchPath;
+  qualifyColumns;
+  connectionString;
+  constructor(connectionStringOrOpts) {
+    const opts = typeof connectionStringOrOpts === "string" ? { connectionString: connectionStringOrOpts } : connectionStringOrOpts || {};
+    this.connectionString = opts.connectionString;
+    this.metadata = opts.metadata || { tables: {}, views: {}, functions: {}, datatypes: {} };
+    this.searchPath = opts.searchPath || ["pg_catalog", "public"];
+    this.qualifyColumns = opts.qualifyColumns || "if_more_than_one_table";
+  }
+  /** Connect to the database and load schema metadata */
+  async refresh() {
+    if (!this.connectionString) {
+      throw new Error("No connection string provided");
+    }
+    this.pool = new import_pg.Pool({ connectionString: this.connectionString, max: 2 });
+    try {
+      const [meta, sp] = await Promise.all([
+        fetchMetadata(this.pool),
+        fetchSearchPath(this.pool)
+      ]);
+      this.metadata = meta;
+      this.searchPath = sp;
+    } finally {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  /** Close any open connections */
+  async close() {
+    if (this.pool) {
+      await this.pool.end();
+      this.pool = null;
+    }
+  }
+  /** Set metadata directly (for testing or pre-loaded scenarios) */
+  setMetadata(meta, searchPath) {
+    this.metadata = meta;
+    if (searchPath) this.searchPath = searchPath;
+  }
+  /**
+   * Get completions for the given SQL text.
+   * @param text - The full SQL text typed so far
+   * @param cursorPos - Cursor position (defaults to end of text)
+   * @returns Array of completion suggestions
+   */
+  complete(text, cursorPos) {
+    const pos = cursorPos ?? text.length;
+    const textBeforeCursor = text.slice(0, pos);
+    const fullText = text;
+    const suggestions = suggestType(fullText, textBeforeCursor);
+    const completions = [];
+    for (const suggestion of suggestions) {
+      switch (suggestion.type) {
+        case "keyword":
+          completions.push(...this.getKeywordCompletions(suggestion.lastToken));
+          break;
+        case "table":
+          completions.push(...this.getTableCompletions(suggestion.schema));
+          break;
+        case "view":
+          completions.push(...this.getViewCompletions(suggestion.schema));
+          break;
+        case "column":
+          completions.push(...this.getColumnCompletions(
+            suggestion.tableRefs,
+            suggestion.qualifiable,
+            suggestion.parent
+          ));
+          break;
+        case "function":
+          completions.push(...this.getFunctionCompletions(suggestion.schema));
+          break;
+        case "schema":
+          completions.push(...this.getSchemaCompletions());
+          break;
+        case "from_clause":
+          completions.push(...this.getTableCompletions(suggestion.schema));
+          completions.push(...this.getViewCompletions(suggestion.schema));
+          completions.push(...this.getFunctionCompletions(suggestion.schema));
+          break;
+        case "join":
+          completions.push(...this.getJoinCompletions(suggestion.tableRefs, suggestion.schema));
+          break;
+        case "join_condition":
+          completions.push(...this.getJoinConditionCompletions(suggestion.tableRefs, suggestion.parent));
+          break;
+        case "alias":
+          completions.push(...suggestion.aliases.map((a) => ({
+            text: a,
+            type: "alias"
+          })));
+          break;
+        case "database":
+          break;
+        case "datatype":
+          completions.push(...this.getDatatypeCompletions(suggestion.schema));
+          break;
+      }
+    }
+    const wordMatch = textBeforeCursor.match(/([A-Za-z0-9_."$]+)$/);
+    const word = wordMatch ? wordMatch[1] : "";
+    const dotIdx = word.lastIndexOf(".");
+    const filterWord = dotIdx >= 0 ? word.slice(dotIdx + 1) : word;
+    if (!filterWord) return this.dedup(completions);
+    const lower = filterWord.toLowerCase().replace(/^"/, "");
+    const filtered = completions.filter((c) => {
+      const ct = c.text.toLowerCase();
+      return ct.startsWith(lower) || fuzzyMatch(lower, ct);
+    });
+    filtered.sort((a, b) => {
+      const aExact = a.text.toLowerCase().startsWith(lower) ? 0 : 1;
+      const bExact = b.text.toLowerCase().startsWith(lower) ? 0 : 1;
+      if (aExact !== bExact) return aExact - bExact;
+      return a.text.localeCompare(b.text);
+    });
+    return this.dedup(filtered);
+  }
+  dedup(completions) {
+    const seen = /* @__PURE__ */ new Set();
+    return completions.filter((c) => {
+      const key = `${c.type}:${c.text}`;
+      if (seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+  getKeywordCompletions(lastToken) {
+    let kws;
+    if (lastToken && KEYWORD_TREE[lastToken]) {
+      kws = KEYWORD_TREE[lastToken];
+      if (kws.length === 0) kws = KEYWORDS;
+    } else {
+      kws = KEYWORDS;
+    }
+    return kws.map((k) => ({ text: k, type: "keyword" }));
+  }
+  getSchemaCompletions() {
+    const schemas = /* @__PURE__ */ new Set();
+    for (const kind of ["tables", "views", "functions", "datatypes"]) {
+      for (const s of Object.keys(this.metadata[kind])) {
+        if (!s.startsWith("pg_")) schemas.add(s);
+      }
+    }
+    return [...schemas].map((s) => ({ text: s, type: "schema" }));
+  }
+  getTableCompletions(schema) {
+    const results = [];
+    const schemas = schema ? [schema] : this.getVisibleSchemas();
+    for (const s of schemas) {
+      const tables = this.metadata.tables[s];
+      if (!tables) continue;
+      for (const name of Object.keys(tables)) {
+        if (!schema && name.startsWith("pg_")) continue;
+        const prefix = !schema && !this.searchPath.includes(s) ? `${s}.` : "";
+        results.push({ text: prefix + name, type: "table" });
+      }
+    }
+    return results;
+  }
+  getViewCompletions(schema) {
+    const results = [];
+    const schemas = schema ? [schema] : this.getVisibleSchemas();
+    for (const s of schemas) {
+      const views = this.metadata.views[s];
+      if (!views) continue;
+      for (const name of Object.keys(views)) {
+        if (!schema && name.startsWith("pg_")) continue;
+        const prefix = !schema && !this.searchPath.includes(s) ? `${s}.` : "";
+        results.push({ text: prefix + name, type: "view" });
+      }
+    }
+    return results;
+  }
+  getColumnCompletions(tableRefs, qualifiable, parent) {
+    const results = [];
+    const doQualify = qualifiable && {
+      always: true,
+      never: false,
+      if_more_than_one_table: tableRefs.length > 1
+    }[this.qualifyColumns];
+    for (const tref of tableRefs) {
+      const cols = this.findColumns(tref);
+      const ref = tableRef(tref);
+      for (const col of cols) {
+        const text = doQualify ? `${ref}.${col.name}` : col.name;
+        results.push({
+          text,
+          type: "column",
+          meta: col.datatype
+        });
+      }
+    }
+    return results;
+  }
+  getFunctionCompletions(schema) {
+    const results = [];
+    const schemas = schema ? [schema] : this.getVisibleSchemas();
+    for (const s of schemas) {
+      const funcs = this.metadata.functions[s];
+      if (!funcs) continue;
+      for (const name of Object.keys(funcs)) {
+        const prefix = schema || !this.searchPath.includes(s) ? `${s}.` : "";
+        results.push({ text: prefix + name, type: "function" });
+      }
+    }
+    if (!schema) {
+      for (const f of BUILTIN_FUNCTIONS) {
+        results.push({ text: f, type: "function" });
+      }
+    }
+    return results;
+  }
+  getJoinCompletions(tableRefs, schema) {
+    const results = [];
+    for (const tref of tableRefs) {
+      const cols = this.findColumns(tref);
+      for (const col of cols) {
+        for (const fk of col.foreignKeys) {
+          const isChild = col.name === fk.childColumn && this.matchesTable(tref, fk.childSchema, fk.childTable);
+          const otherSchema = isChild ? fk.parentSchema : fk.childSchema;
+          const otherTable = isChild ? fk.parentTable : fk.childTable;
+          const otherCol = isChild ? fk.parentColumn : fk.childColumn;
+          const thisCol = isChild ? fk.childColumn : fk.parentColumn;
+          if (schema && otherSchema !== schema) continue;
+          const ref = tableRef(tref);
+          const joinText = `${otherTable} ON ${otherTable}.${otherCol} = ${ref}.${thisCol}`;
+          results.push({ text: joinText, type: "join", meta: "fk join" });
+        }
+      }
+    }
+    return results;
+  }
+  getJoinConditionCompletions(tableRefs, parent) {
+    const results = [];
+    if (tableRefs.length < 2) return results;
+    const lastRef = tableRefs[tableRefs.length - 1];
+    const lastCols = this.findColumns(lastRef);
+    const lastRefName = tableRef(lastRef);
+    for (const col of lastCols) {
+      for (const fk of col.foreignKeys) {
+        for (const otherRef of tableRefs.slice(0, -1)) {
+          const otherRefName = tableRef(otherRef);
+          const isChild = col.name === fk.childColumn && this.matchesTable(lastRef, fk.childSchema, fk.childTable);
+          if (isChild) {
+            if (this.matchesTable(otherRef, fk.parentSchema, fk.parentTable)) {
+              results.push({
+                text: `${lastRefName}.${fk.childColumn} = ${otherRefName}.${fk.parentColumn}`,
+                type: "join",
+                meta: "fk join"
+              });
+            }
+          } else {
+            if (this.matchesTable(otherRef, fk.childSchema, fk.childTable)) {
+              results.push({
+                text: `${lastRefName}.${fk.parentColumn} = ${otherRefName}.${fk.childColumn}`,
+                type: "join",
+                meta: "fk join"
+              });
+            }
+          }
+        }
+      }
+    }
+    for (const col of lastCols) {
+      for (const otherRef of tableRefs.slice(0, -1)) {
+        const otherCols = this.findColumns(otherRef);
+        const match = otherCols.find((c) => c.name === col.name);
+        if (match) {
+          const otherRefName = tableRef(otherRef);
+          const text = `${lastRefName}.${col.name} = ${otherRefName}.${col.name}`;
+          if (!results.some((r) => r.text === text)) {
+            results.push({ text, type: "join", meta: "name join" });
+          }
+        }
+      }
+    }
+    return results;
+  }
+  getDatatypeCompletions(schema) {
+    const results = [];
+    const schemas = schema ? [schema] : this.getVisibleSchemas();
+    for (const s of schemas) {
+      const types = this.metadata.datatypes[s];
+      if (!types) continue;
+      for (const name of Object.keys(types)) {
+        results.push({ text: name, type: "datatype" });
+      }
+    }
+    if (!schema) {
+      for (const t of [
+        "integer",
+        "bigint",
+        "smallint",
+        "serial",
+        "bigserial",
+        "real",
+        "double precision",
+        "numeric",
+        "decimal",
+        "text",
+        "varchar",
+        "char",
+        "boolean",
+        "bool",
+        "date",
+        "time",
+        "timestamp",
+        "timestamptz",
+        "interval",
+        "json",
+        "jsonb",
+        "uuid",
+        "bytea",
+        "xml"
+      ]) {
+        results.push({ text: t, type: "datatype" });
+      }
+    }
+    return results;
+  }
+  /** Find columns for a table reference, searching through schemas */
+  findColumns(tref) {
+    const schemas = tref.schema ? [tref.schema] : this.searchPath;
+    for (const s of schemas) {
+      const cols = this.metadata.tables[s]?.[tref.name] || this.metadata.views[s]?.[tref.name];
+      if (cols) return cols;
+    }
+    return [];
+  }
+  matchesTable(tref, schema, table) {
+    if (tref.schema) return tref.schema === schema && tref.name === table;
+    return tref.name === table && this.searchPath.includes(schema);
+  }
+  getVisibleSchemas() {
+    const all = new Set(this.searchPath);
+    for (const kind of ["tables", "views", "functions", "datatypes"]) {
+      for (const s of Object.keys(this.metadata[kind])) {
+        all.add(s);
+      }
+    }
+    return [...all];
+  }
+};
+function fuzzyMatch(pattern, text) {
+  let pi = 0;
+  for (let ti = 0; ti < text.length && pi < pattern.length; ti++) {
+    if (text[ti] === pattern[pi]) pi++;
+  }
+  return pi === pattern.length;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BUILTIN_FUNCTIONS,
+  KEYWORDS,
+  KEYWORD_TREE,
+  PgCompleter,
+  extractTables,
+  suggestType
+});
+//# sourceMappingURL=index.js.map