@tablecraft-app/plugin-postgres 1.10.3 → 1.10.4

package/index.js

@@ -11215,7 +11215,13 @@ var SHOWN_ARROW = "→";
 var OPTIONAL_MARK = "?";
 var VARIADIC_MARK = "...";
 var COMPARATOR = /^(>=|<=|>|<|=)?(\d+(?:\.\d+)*)$/;
-function parameter$1(written) {
+var BARE_MARK = "=";
+var LEAD_WORD = /^[A-Z][A-Z_]*$/;
+var LEAD_CHOICE = "|";
+var PARAMETER_SEPARATOR = ",";
+var COMMA_SHOWN = ", ";
+var MEMBER_SEPARATOR$2 = ".";
+function parameter$1(written, lead) {
 	let name = written.trim();
 	const variadic = name.endsWith(VARIADIC_MARK);
 	if (variadic) name = name.slice(0, -3).trim();
@@ -11224,28 +11230,78 @@ function parameter$1(written) {
 	return {
 		name,
 		...optional ? { optional } : {},
-		...variadic ? { variadic } : {}
+		...variadic ? { variadic } : {},
+		...lead === null ? {} : { lead }
 	};
 }
-/** Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats. */
+function isLeadWord(word) {
+	return word.split(LEAD_CHOICE).every((choice) => LEAD_WORD.test(choice));
+}
+/** Whether `lead` is `word` or offers it among its `|` alternatives. */
+function leadMatches(lead, word) {
+	return lead.split(LEAD_CHOICE).includes(word);
+}
+/**
+* One comma-separated part: an upper-case word between names leads the next, as one before the
+* first parameter does; one standing alone is a keyword choice. After a comma the keyword is the
+* argument's own (`date, INTERVAL expr unit`), since the comma already separates it.
+*/
+function leadParameters(part, index) {
+	const words = part.trim().split(/\s+/);
+	const parameters = [];
+	let lead = null;
+	let name = [];
+	const flush = () => {
+		if (name.length > 0) parameters.push(parameter$1(name.join(" "), lead));
+		name = [];
+		lead = null;
+	};
+	words.forEach((word, at) => {
+		const next = words[at + 1];
+		if (!(at === 0 && index > 0) && isLeadWord(word) && next !== void 0 && !isLeadWord(next)) {
+			flush();
+			lead = word;
+		} else name.push(word);
+	});
+	flush();
+	return parameters;
+}
+function isBareSignature(written) {
+	return written.trim().startsWith(BARE_MARK);
+}
+/**
+* Reads `"str, len? -> string"`: `?` marks an optional parameter, `...` one that repeats, an
+* upper-case word between names the keyword before the next (`"unit FROM date -> integer"`).
+* `"= date"` is a bare function's and `"str ->"` a procedure's, which returns nothing.
+*/
 function parseSignature(written) {
+	if (isBareSignature(written)) return {
+		parameters: [],
+		returns: written.trim().slice(1).trim()
+	};
 	const arrow = written.lastIndexOf(RETURNS_ARROW);
 	if (arrow < 0) throw new Error(`Signature "${written}" has no "${RETURNS_ARROW} type"; add what it returns.`);
 	const list = written.slice(0, arrow).trim();
 	return {
-		parameters: list === "" ? [] : list.split(",").map(parameter$1),
+		parameters: list === "" ? [] : list.split(PARAMETER_SEPARATOR).flatMap(leadParameters),
 		returns: written.slice(arrow + 2).trim()
 	};
 }
 /** Specs for one category, from compact entries a plugin's data file lists. */
 function functionSpecs(category, entries) {
-	return entries.map(([name, signatures, summary, available]) => ({
-		name,
-		signatures: (typeof signatures === "string" ? [signatures] : signatures).map(parseSignature),
-		summary,
-		category,
-		...available === void 0 ? {} : { available }
-	}));
+	return entries.map(([name, signatures, summary, available]) => {
+		const written = typeof signatures === "string" ? [signatures] : signatures;
+		const bare = written.filter(isBareSignature).length;
+		if (bare > 0 && bare < written.length) throw new Error(`${name} mixes "${BARE_MARK} type" with called signatures; write the bare form as "-> type".`);
+		return {
+			name,
+			signatures: written.map(parseSignature),
+			summary,
+			category,
+			...available === void 0 ? {} : { available },
+			...bare > 0 ? { bare: true } : {}
+		};
+	});
 }
 function compareVersions(left, right) {
 	for (let at = 0; at < Math.max(left.length, right.length); at += 1) {
@@ -11274,20 +11330,48 @@ function isAvailable(spec, server) {
 	if (range === false) return false;
 	return range.split(/\s+/).filter((comparator) => comparator !== "").every((comparator) => satisfies(server.version, comparator));
 }
-function shownParameter(parameter) {
+function shownParameter(parameter, index) {
 	const name = parameter.variadic === true ? `${parameter.name}${VARIADIC_MARK}` : parameter.name;
-	return parameter.optional === true ? `[${name}]` : name;
+	const led = parameter.lead === void 0 ? name : `${parameter.lead} ${name}`;
+	return (index === 0 ? "" : parameter.lead === void 0 ? COMMA_SHOWN : " ") + (parameter.optional === true ? `[${led}]` : led);
 }
-/** `(date, format) → string`, the popup's detail for one signature. */
+function returnsLabel(returns) {
+	return returns === "" ? "" : `${SHOWN_ARROW} ${returns}`;
+}
+/** `(date, format) → string`, the popup's detail for one signature; a lead replaces the comma, a procedure has no `→`. */
 function signatureLabel(signature) {
-	return `(${signature.parameters.map(shownParameter).join(", ")}) ${SHOWN_ARROW} ${signature.returns}`;
+	const list = `(${signature.parameters.map(shownParameter).join("")})`;
+	const returns = returnsLabel(signature.returns);
+	return returns === "" ? list : `${list} ${returns}`;
+}
+function shownSignature(spec, signature) {
+	return spec.bare === true ? returnsLabel(signature.returns) : signatureLabel(signature);
 }
 /** Every signature on its own line, then the summary. */
 function functionInfo(spec) {
 	const label = spec.name.toLowerCase();
-	return `${spec.signatures.map((signature) => `${label}${signatureLabel(signature)}`).join("\n")}\n\n${spec.summary}`;
+	const gap = spec.bare === true ? " " : "";
+	return `${spec.signatures.map((signature) => `${label}${gap}${shownSignature(spec, signature)}`).join("\n")}\n\n${spec.summary}`;
 }
-/** A spec as an item: `name()` with the caret between the parentheses when it takes arguments. */
+/**
+* A spec as an item: `name()` with the caret between the parentheses when it takes arguments, or
+* the name alone for a bare one. `label` is what the popup offers, the member alone after `pkg.`.
+*/
+function specItem(spec, label, boost) {
+	const first = spec.signatures[0];
+	const takesArguments = spec.signatures.some((signature) => signature.parameters.length > 0);
+	const bare = spec.bare === true;
+	return {
+		label,
+		kind: "function",
+		detail: first === void 0 ? null : shownSignature(spec, first),
+		apply: bare ? label : `${label}()`,
+		boost,
+		info: functionInfo(spec),
+		caret: takesArguments && !bare ? label.length + 1 : null
+	};
+}
+/** A spec as an item: `name()` with the caret between the parentheses when it takes arguments, the name alone when bare. */
 function functionItem(spec, boost) {
 	if (typeof spec === "string") return {
 		label: spec,
@@ -11298,18 +11382,17 @@ function functionItem(spec, boost) {
 		info: null,
 		caret: null
 	};
-	const label = spec.name.toLowerCase();
-	const first = spec.signatures[0];
-	const takesArguments = spec.signatures.some((signature) => signature.parameters.length > 0);
-	return {
-		label,
-		kind: "function",
-		detail: first === void 0 ? null : signatureLabel(first),
-		apply: `${label}()`,
-		boost,
-		info: functionInfo(spec),
-		caret: takesArguments ? label.length + 1 : null
-	};
+	return specItem(spec, spec.name.toLowerCase(), boost);
+}
+/** The package a spec named `PKG.MEMBER` belongs to, upper case; null for a plain function. */
+function functionPackage(spec) {
+	const name = functionName(spec);
+	const dot = name.lastIndexOf(MEMBER_SEPARATOR$2);
+	return dot < 0 ? null : name.slice(0, dot).toUpperCase();
+}
+/** A package member as offered after `pkg.`: the member's name alone, the info naming it in full. */
+function memberItem(spec, boost) {
+	return specItem(spec, spec.name.slice(spec.name.lastIndexOf(MEMBER_SEPARATOR$2) + 1).toLowerCase(), boost);
 }
 /** The name a function entry is offered under, either form. */
 function functionName(spec) {
@@ -11637,7 +11720,7 @@ function wordOf(text, token) {
 var OPEN$6 = "(";
 var CLOSE$5 = ")";
 var DOT$3 = ".";
-var COMMA$7 = ",";
+var COMMA$9 = ",";
 var QUERY_STARTS$2 = /* @__PURE__ */ new Set(["SELECT", "WITH"]);
 var RELATION_INTRODUCERS$1 = /* @__PURE__ */ new Set([
 	"FROM",
@@ -11894,7 +11977,7 @@ var QueryReader = class {
 					flush();
 					selecting = false;
 					selected = true;
-				} else if (statement.isSymbol(index, COMMA$7)) {
+				} else if (statement.isSymbol(index, COMMA$9)) {
 					flush();
 					continue;
 				} else {
@@ -11926,7 +12009,7 @@ var QueryReader = class {
 				into = false;
 				continue;
 			}
-			if (fromList && statement.isSymbol(index, COMMA$7)) expectRelation = true;
+			if (fromList && statement.isSymbol(index, COMMA$9)) expectRelation = true;
 		}
 		if (selecting) flush();
 	}
@@ -11954,7 +12037,7 @@ var QueryReader = class {
 				query: statement.query(body)
 			});
 			this.#at += 1;
-			if (!statement.isSymbol(this.#index(), COMMA$7)) return;
+			if (!statement.isSymbol(this.#index(), COMMA$9)) return;
 			this.#at += 1;
 		}
 	}
@@ -12116,7 +12199,7 @@ function clauseOf(statement, queryOpen, group, anchor, query) {
 	}
 	const lastWord = statement.word(last ?? void 0);
 	if (lastWord !== null && (RELATION_INTRODUCERS$1.has(lastWord) || RELATION_MODIFIERS.has(lastWord))) return lastWord === "JOIN" || lastWord === "STRAIGHT_JOIN" ? "join" : "relation";
-	if (fromList && last !== null && statement.isSymbol(last, COMMA$7)) return "relation";
+	if (fromList && last !== null && statement.isSymbol(last, COMMA$9)) return "relation";
 	if (clause !== null && EXPRESSION_CLAUSES.has(clause)) return "columns";
 	return "keywords";
 }
@@ -12163,6 +12246,10 @@ function scopeAt(text, offset, dialect, mode = "complete") {
 	};
 }
 // ../plugin-api/src/sql/signature.ts
+var COMMA$8 = ",";
+var MEMBER_SEPARATOR$1 = ".";
+/** Calls a procedure by name, so it may come before a package member as it never may before a function. */
+var CALL_WORD = "CALL";
 /** Words a relation or routine name follows, so `TABLE upper (` defines rather than calls. */
 var NAME_INTRODUCERS = /* @__PURE__ */ new Set([
 	"CALL",
@@ -12189,7 +12276,8 @@ function upperWord(text, token) {
 }
 /**
 * Finds the innermost call around `offset` whose name `known` accepts, counting its top-level
-* commas; strings, comments and quoted names are tokens of their own, so their commas never count.
+* commas and listing its separators; strings, comments and quoted names are tokens of their own,
+* so their commas never count. `pkg.member (` asks `known` for `PKG.MEMBER`.
 * Grouping parentheses are looked through; a subquery, a non-function name before `(` or a caret
 * in a string or comment ends the search with null. `reserved` holds the dialect's keywords: a
 * function spelled like one (`VALUES`, `LEFT`) is a call only where an operand fits, not after a
@@ -12198,16 +12286,35 @@ function upperWord(text, token) {
 function callAt(text, offset, dialect, reserved, known) {
 	const { tokens, literal } = statementTokens(text, offset, dialect);
 	if (literal) return null;
+	/** `pkg.member` ending at `at`, when the package's spec knows the member. */
+	function member(at) {
+		const name = tokens[at];
+		const owner = tokens[at - 2];
+		const word = upperWord(text, name);
+		const ownerWord = upperWord(text, owner);
+		if (name === void 0 || owner === void 0 || word === null || ownerWord === null) return null;
+		if (!known(`${ownerWord}${MEMBER_SEPARATOR$1}${word}`)) return null;
+		const previous = upperWord(text, tokens[at - 3]);
+		if (previous !== null && previous !== CALL_WORD && NAME_INTRODUCERS.has(previous)) return null;
+		return {
+			written: `${text.slice(owner.from, owner.to)}${MEMBER_SEPARATOR$1}${text.slice(name.from, name.to)}`,
+			from: owner.from
+		};
+	}
 	function callable(at) {
 		const name = tokens[at];
+		const before = tokens[at - 1];
+		if (symbol(text, before, MEMBER_SEPARATOR$1)) return member(at);
 		const word = upperWord(text, name);
 		if (name === void 0 || word === null || !known(word)) return null;
-		const before = tokens[at - 1];
-		if (symbol(text, before, ".")) return null;
+		const found = {
+			written: text.slice(name.from, name.to),
+			from: name.from
+		};
 		const previous = upperWord(text, before);
 		if (previous !== null && NAME_INTRODUCERS.has(previous)) return null;
-		if (!reserved.has(word)) return name;
-		return before === void 0 || before.kind === "symbol" && !symbol(text, before, ")") || previous !== null && reserved.has(previous) ? name : null;
+		if (!reserved.has(word)) return found;
+		return before === void 0 || before.kind === "symbol" && !symbol(text, before, ")") || previous !== null && reserved.has(previous) ? found : null;
 	}
 	const frames = [];
 	let index = 0;
@@ -12220,12 +12327,19 @@ function callAt(text, offset, dialect, reserved, known) {
 				name,
 				named: name === null && !grouping(text, tokens[index - 1]),
 				open: index,
-				commas: 0
+				commas: 0,
+				separators: []
 			});
 		} else if (symbol(text, token, ")")) frames.pop();
-		else if (symbol(text, token, ",")) {
+		else if (symbol(text, token, COMMA$8)) {
 			const top = frames.at(-1);
-			if (top !== void 0) top.commas += 1;
+			if (top !== void 0) {
+				top.commas += 1;
+				top.separators.push(COMMA$8);
+			}
+		} else {
+			const word = upperWord(text, token);
+			if (word !== null) frames.at(-1)?.separators.push(word);
 		}
 	}
 	for (let depth = frames.length - 1; depth >= 0; depth -= 1) {
@@ -12236,8 +12350,9 @@ function callAt(text, offset, dialect, reserved, known) {
 			continue;
 		}
 		return {
-			name: text.slice(frame.name.from, frame.name.to),
+			name: frame.name.written,
 			argument: frame.commas,
+			separators: frame.separators,
 			from: frame.name.from,
 			to: closeOf(text, tokens, index, frames.length - depth) ?? offset
 		};
@@ -12304,7 +12419,7 @@ var FROM = "FROM";
 var AS$4 = "AS";
 var STAR$1 = "*";
 var DOT$2 = ".";
-var COMMA$6 = ",";
+var COMMA$7 = ",";
 var OPEN$5 = "(";
 var CLOSE$4 = ")";
 var OVER = "OVER";
@@ -12502,7 +12617,7 @@ function tailRefusal(reader, from, depth) {
 	const tokens = reader.tokens;
 	const first = reader.word(tokens[from]);
 	if (from < tokens.length && (first === null || !TAIL_CLAUSES.has(first))) {
-		if (reader.symbol(tokens[from]) === COMMA$6 || first !== null && JOINS.has(first)) return SELECT_READ_ONLY_REASONS.joins;
+		if (reader.symbol(tokens[from]) === COMMA$7 || first !== null && JOINS.has(first)) return SELECT_READ_ONLY_REASONS.joins;
 		if (first !== null && GROUPING.has(first)) return SELECT_READ_ONLY_REASONS.aggregates;
 		if (first !== null && SET_OPERATIONS.has(first)) return SELECT_READ_ONLY_REASONS.combines;
 		return SELECT_READ_ONLY_REASONS.notSelect;
@@ -12540,7 +12655,7 @@ function parseSimpleSelect(sql, dialect) {
 	if (refusal !== null) return { readOnly: refusal };
 	const items = [];
 	let itemFrom = at;
-	for (let index = at; index <= fromAt; index += 1) if (index === fromAt || depth[index] === 0 && reader.symbol(tokens[index]) === COMMA$6) {
+	for (let index = at; index <= fromAt; index += 1) if (index === fromAt || depth[index] === 0 && reader.symbol(tokens[index]) === COMMA$7) {
 		if (index === itemFrom) return { readOnly: SELECT_READ_ONLY_REASONS.notSelect };
 		items.push(selectItem(reader, itemFrom, index));
 		itemFrom = index + 1;
@@ -13315,6 +13430,47 @@ var QUOTES = /* @__PURE__ */ new Set([
 /** Below every other namespace: `USE mysql` is legitimate but rarely meant. */
 var SYSTEM_NAMESPACE_BOOST = -20;
 var CURRENT_DETAIL = "current";
+var COMMA$6 = ",";
+var MEMBER_SEPARATOR = ".";
+/**
+* Walks `separators` through `signature`: a comma moves to the next parameter without a lead, a
+* word to the next one it leads. A word nothing leads is an argument's own (`YEAR`, `DECIMAL`).
+* Past the last parameter a comma keeps counting, as the hint's variadic rule expects; a variadic
+* parameter keyword-led ones follow (`CHAR(code... USING charset)`) takes every comma.
+*/
+function argumentAt(signature, separators) {
+	const { parameters } = signature;
+	let at = 0;
+	let entered = false;
+	let led = 0;
+	for (const separator of separators) {
+		if (separator === COMMA$6) {
+			const next = parameters.findIndex((parameter, index) => index > at && parameter.lead === void 0);
+			if (next >= 0) at = next;
+			else if (!(parameters[at]?.variadic === true && at < parameters.length - 1)) at += 1;
+			entered = true;
+			continue;
+		}
+		const next = parameters.findIndex((parameter, index) => (index > at || index === at && !entered) && parameter.lead !== void 0 && leadMatches(parameter.lead, separator));
+		if (next < 0) continue;
+		at = next;
+		entered = true;
+		led += 1;
+	}
+	return {
+		argument: at,
+		led
+	};
+}
+/** The argument the caret is in, by the overload whose leads the call follows most; the first on a tie. */
+function argumentOf(spec, call) {
+	let best = null;
+	for (const signature of spec.signatures) {
+		const found = argumentAt(signature, call.separators ?? []);
+		if (best === null || found.led > best.led) best = found;
+	}
+	return best?.argument ?? call.argument;
+}
 function relationKind(relation) {
 	return relation.kind === "table" ? "table" : "view";
 }
@@ -13331,6 +13487,11 @@ function sqlCompleter(options) {
 	function specNamed(name, server) {
 		return specs.get(name.toUpperCase())?.find((spec) => isAvailable(spec, server));
 	}
+	/** The members of the package `qualifier` names, as offered after its dot. */
+	function memberItems(qualifier, server) {
+		const name = qualifier.map((part) => part.name.toUpperCase()).join(MEMBER_SEPARATOR);
+		return availableFunctions(server, true).filter((spec) => typeof spec !== "string" && functionPackage(spec) === name).map((spec) => memberItem(spec, BOOST.function));
+	}
 	function quoted(name) {
 		return options.plainIdentifier.test(name) && !reserved.has(name.toUpperCase()) ? name : options.quoteIdentifier(name);
 	}
@@ -13355,10 +13516,12 @@ function sqlCompleter(options) {
 	function keywordItems(except = /* @__PURE__ */ new Set()) {
 		return options.keywords.filter((keyword) => !except.has(keyword.toUpperCase())).map((keyword) => item("keyword", keyword, keyword, null));
 	}
-	function availableFunctions(server) {
+	/** Plain functions, or with `members` the package members only: a bare name never offers `pkg.member`. */
+	function availableFunctions(server, members = false) {
 		const offered = /* @__PURE__ */ new Set();
 		return options.functions.filter((spec) => {
 			const name = functionName(spec).toUpperCase();
+			if (functionPackage(spec) !== null !== members) return false;
 			if (offered.has(name) || typeof spec !== "string" && !isAvailable(spec, server)) return false;
 			offered.add(name);
 			return true;
@@ -13369,17 +13532,18 @@ function sqlCompleter(options) {
 		const last = qualifier.at(-1);
 		if (last === void 0) return [];
 		const relational = clause === "relation" || clause === "join";
+		const members = relational ? [] : memberItems(qualifier, lookup.server);
 		if (qualifier.length === 1 && !relational) {
 			const source = sourceNamed(query, last);
-			if (source !== void 0) return columnItems(await lookup.columnsOf(source, query));
+			if (source !== void 0) return [...columnItems(await lookup.columnsOf(source, query)), ...members];
 			const cte = cteNamed(query, last);
-			if (cte !== void 0) return columnItems(await lookup.cteColumns(cte, 1));
+			if (cte !== void 0) return [...columnItems(await lookup.cteColumns(cte, 1)), ...members];
 		}
 		const namespace = await lookup.namespace(qualifier);
-		if (namespace !== void 0) return relationItems(await lookup.relations(namespace.path), null);
+		if (namespace !== void 0) return [...members, ...relationItems(await lookup.relations(namespace.path), null)];
 		if (relational) return [];
 		const found = await lookup.relation(qualifier.slice(0, -1), last);
-		return found === null ? [] : columnItems(found.relation.columns);
+		return found === null ? members : [...columnItems(found.relation.columns), ...members];
 	}
 	async function relationContextItems(scope, lookup) {
 		const current = lookup.current;
@@ -13688,14 +13852,18 @@ function sqlCompleter(options) {
 	function signatureAt(request, catalog) {
 		const { text, offset, shift } = wrap(request);
 		const server = serverOf(catalog);
-		const call = callAt(text, offset, options.dialect, reserved, (name) => specNamed(name, server) !== void 0);
+		const callable = (name) => {
+			const spec = specNamed(name, server);
+			return spec !== void 0 && spec.bare !== true;
+		};
+		const call = callAt(text, offset, options.dialect, reserved, callable);
 		const spec = call === null ? void 0 : specNamed(call.name, server);
 		if (call === null || spec === void 0) return Promise.resolve(null);
 		return Promise.resolve({
 			name: spec.name.toLowerCase(),
 			summary: spec.summary,
 			signatures: spec.signatures,
-			argument: call.argument,
+			argument: argumentOf(spec, call),
 			from: call.from - shift,
 			to: call.to - shift
 		});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tablecraft-app/plugin-postgres",
-  "version": "1.10.3",
+  "version": "1.10.4",
   "description": "The PostgreSQL datasource plugin for TableCraft, downloaded by the app when a data source needs it.",
   "license": "MIT",
   "type": "module",
@@ -24,6 +24,6 @@
   },
   "tableCraft": {
     "id": "postgres",
-    "apiVersion": "1.3.0"
+    "apiVersion": "1.4.0"
   }
 }

package/table-craft-plugin.json

@@ -1,8 +1,8 @@
 {
   "id": "postgres",
   "name": "PostgreSQL",
-  "version": "1.10.3",
-  "apiVersion": "1.3.0",
+  "version": "1.10.4",
+  "apiVersion": "1.4.0",
   "entry": "index.js",
   "capabilities": [
     "sql",