@protobase/server 0.26.6 → 0.26.8

package/dist/rest/parse-filter.js

@@ -0,0 +1,131 @@
+import { parseError } from "./rest-error.js";
+import { parseFieldPath } from "./field-path.js";
+import { splitList, unquote } from "./split-list.js";
+//#region src/rest/parse-filter.ts
+const operators = [
+	"eq",
+	"neq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"like",
+	"ilike",
+	"match",
+	"imatch",
+	"in",
+	"is",
+	"isdistinct",
+	"fts",
+	"plfts",
+	"phfts",
+	"wfts",
+	"cs",
+	"cd",
+	"ov",
+	"sl",
+	"sr",
+	"nxr",
+	"nxl",
+	"adj"
+];
+/** The operators that compare with `any` or `all` of a list, `eq(any).{1,2}`. */
+const quantifiable = /* @__PURE__ */ new Set([
+	"eq",
+	"gt",
+	"gte",
+	"lt",
+	"lte",
+	"like",
+	"ilike",
+	"match",
+	"imatch"
+]);
+/** The full text search operators, which take a language, `fts(english).cat`. */
+const textSearch = /* @__PURE__ */ new Set([
+	"fts",
+	"plfts",
+	"phfts",
+	"wfts"
+]);
+const isValues = [
+	"null",
+	"not_null",
+	"true",
+	"false",
+	"unknown"
+];
+const isOperator = (name) => operators.includes(name);
+const inList = (text) => {
+	if (!text.startsWith("(") || !text.endsWith(")")) throw parseError(`"failed to parse filter (in.${text})"`, "in takes a list in parentheses, such as in.(1,2)");
+	const inner = text.slice(1, -1);
+	return inner.trim() === "" ? [] : splitList(inner).map(unquote);
+};
+/**
+* Parses what a filter says of `field`: `[not.]operator[(modifier)].value`. In a logic tree a value in double quotes
+* loses them, so it may hold commas and parentheses.
+*/
+const parseCondition = (field, text, inTree = false) => {
+	const negated = text.startsWith("not.");
+	const rest = negated ? text.slice(4) : text;
+	const match = /^(\w+)(?:\((\w+)\))?\.([\s\S]*)$/.exec(rest);
+	const [, name = "", modifier, value = ""] = match ?? [];
+	if (!match || !isOperator(name)) throw parseError(`"failed to parse filter (${text})"`, `"${name || text}" is not an operator`);
+	const condition = {
+		kind: "condition",
+		field,
+		negated,
+		operator: name
+	};
+	if (name === "in") return {
+		...condition,
+		value: inList(value)
+	};
+	if (name === "is") {
+		if (!isValues.includes(value)) throw parseError(`"failed to parse filter (${text})"`, `is takes one of ${isValues.join(", ")}`);
+		return {
+			...condition,
+			value
+		};
+	}
+	const plain = inTree ? unquote(value) : value;
+	if (modifier === void 0) return {
+		...condition,
+		value: plain
+	};
+	if (textSearch.has(name)) return {
+		...condition,
+		language: modifier,
+		value: plain
+	};
+	if ((modifier === "any" || modifier === "all") && quantifiable.has(name)) return {
+		...condition,
+		quantifier: modifier,
+		value: plain
+	};
+	throw parseError(`"failed to parse filter (${text})"`, `${name} takes no "${modifier}"`);
+};
+const treeItem = (text) => {
+	const nested = /^(not\.)?(and|or)(\([\s\S]*\))$/.exec(text);
+	if (nested) return parseLogic(nested[2], Boolean(nested[1]), nested[3]);
+	const dot = text.indexOf(".");
+	if (dot <= 0) throw parseError(`"failed to parse logic tree (${text})"`, "Each condition is field.operator.value");
+	return parseCondition(parseFieldPath(text.slice(0, dot)), text.slice(dot + 1), true);
+};
+/** Parses the value of `or=`, `and=`, `not.or=` or `not.and=`: `(item,item,...)`, items nesting `and(...)` and `or(...)`. */
+const parseLogic = (kind, negated, text) => {
+	if (!text.startsWith("(") || !text.endsWith(")")) throw parseError(`"failed to parse logic tree (${text})"`, "A logic tree is a list in parentheses");
+	return {
+		kind,
+		negated,
+		args: splitList(text.slice(1, -1)).map((item) => treeItem(item.trim()))
+	};
+};
+/** The filter of one query parameter: `column=op.value`, or a logic tree under `or`, `and`, `not.or` or `not.and`. */
+const parseFilter = (key, value) => {
+	const logic = /^(not\.)?(and|or)$/.exec(key);
+	if (logic) return parseLogic(logic[2], Boolean(logic[1]), value);
+	return parseCondition(parseFieldPath(key), value);
+};
+//#endregion
+export { isValues, operators, parseCondition, parseFilter, parseLogic, textSearch };

package/dist/rest/parse-order.js

@@ -0,0 +1,18 @@
+import { parseError } from "./rest-error.js";
+import { parseFieldPath } from "./field-path.js";
+import { splitList } from "./split-list.js";
+//#region src/rest/parse-order.ts
+const directions = /* @__PURE__ */ new Set(["asc", "desc"]);
+const nulls = /* @__PURE__ */ new Set(["nullsfirst", "nullslast"]);
+const parseTerm = (text) => {
+	const [fieldText = "", ...modifiers] = text.trim().split(".");
+	const term = { field: parseFieldPath(fieldText) };
+	for (const modifier of modifiers) if (directions.has(modifier) && !term.direction && !term.nulls) term.direction = modifier;
+	else if (nulls.has(modifier) && !term.nulls) term.nulls = modifier === "nullsfirst" ? "first" : "last";
+	else throw parseError(`"failed to parse order (${text})"`, `"${modifier}" is neither asc, desc, nullsfirst nor nullslast`);
+	return term;
+};
+/** Parses `order`: terms separated by commas, such as `priority.desc.nullslast,id`. */
+const parseOrder = (text) => splitList(text).map(parseTerm);
+//#endregion
+export { parseOrder };

package/dist/rest/parse-prefer.js

@@ -0,0 +1,26 @@
+//#region src/rest/parse-prefer.ts
+const known = {
+	return: [
+		"minimal",
+		"representation",
+		"headers-only"
+	],
+	count: [
+		"exact",
+		"planned",
+		"estimated"
+	],
+	resolution: ["merge-duplicates", "ignore-duplicates"],
+	missing: ["default", "null"]
+};
+/** Reads `Prefer: return=representation, count=exact`, in one header or several; the first of each kind counts. */
+const parsePrefer = (header) => {
+	const preferences = {};
+	for (const part of header?.split(",") ?? []) {
+		const [name = "", value = ""] = part.trim().split("=").map((text) => text.trim());
+		if (name in known && !(name in preferences) && known[name].includes(value)) preferences[name] = value;
+	}
+	return preferences;
+};
+//#endregion
+export { parsePrefer };

package/dist/rest/parse-query.js

@@ -0,0 +1,64 @@
+import { splitList, unquote } from "./split-list.js";
+import { parseFilter } from "./parse-filter.js";
+import { parseOrder } from "./parse-order.js";
+import { parseSelect } from "./parse-select.js";
+import { wholeNumber } from "./whole-number.js";
+import { parseEmbedParams, splitEmbedKey } from "./embed-params.js";
+//#region src/rest/parse-query.ts
+const reserved = /* @__PURE__ */ new Set([
+	"select",
+	"order",
+	"limit",
+	"offset",
+	"on_conflict",
+	"columns"
+]);
+const names = (text) => splitList(text).map((name) => unquote(name.trim()));
+/** `Range: 2-4` or `Range: 5-`, in items; anything else asks for every row, as PostgREST takes it. */
+const rangeHeader = (header) => {
+	const match = header === null ? null : /^\s*(\d+)-(\d*)\s*$/.exec(header);
+	if (!match) return { offset: 0 };
+	const offset = Number(match[1]);
+	return match[2] === "" ? { offset } : {
+		offset,
+		limit: Math.max(0, Number(match[2]) - offset + 1)
+	};
+};
+const intersect = (a, b) => {
+	const offset = Math.max(a.offset, b.offset);
+	const ends = [a, b].flatMap((range) => range.limit === void 0 ? [] : [range.offset + range.limit]);
+	return ends.length === 0 ? { offset } : {
+		offset,
+		limit: Math.max(0, Math.min(...ends) - offset)
+	};
+};
+/**
+* Parses a request's query parameters. The ones in `args` are a function's arguments, not filters. `select`, `order`,
+* `limit`, `offset`, `on_conflict` and `columns` count once, the first time; a parameter under an embed's path, such
+* as `comments.likes`, is the embed's (see `parseEmbedParams`); every other parameter is a filter.
+*/
+const parseQuery = (params, rangeText = null, args = /* @__PURE__ */ new Set()) => {
+	const first = (name) => params.find(([key]) => key === name)?.[1];
+	const limit = first("limit");
+	const offset = first("offset");
+	const order = first("order");
+	const onConflict = first("on_conflict");
+	const columns = first("columns");
+	const select = parseSelect(first("select"));
+	const own = params.filter(([key]) => !reserved.has(key) && !args.has(key));
+	const fromParams = {
+		offset: offset === void 0 ? 0 : wholeNumber("offset", offset),
+		...limit !== void 0 && { limit: wholeNumber("limit", limit) }
+	};
+	return {
+		select,
+		filters: own.filter(([key]) => splitEmbedKey(key).path === void 0).map(([key, value]) => parseFilter(key, value)),
+		embedded: parseEmbedParams(own, select),
+		order: order === void 0 ? [] : parseOrder(order),
+		range: intersect(fromParams, rangeHeader(rangeText)),
+		...onConflict !== void 0 && { onConflict: names(onConflict) },
+		...columns !== void 0 && { columns: names(columns) }
+	};
+};
+//#endregion
+export { parseQuery };

package/dist/rest/parse-select.js

@@ -0,0 +1,42 @@
+import { parseError, restError } from "./rest-error.js";
+import { parseFieldPath } from "./field-path.js";
+import { splitList } from "./split-list.js";
+//#region src/rest/parse-select.ts
+const typeName = /^[A-Za-z_][A-Za-z0-9_]*(\[\])?$/;
+const embedPattern = /^(?:([^:(!]+):(?!:))?([^!(]+)((?:![^!(]+)*)\(([\s\S]*)\)$/;
+const parseEmbed = (item) => {
+	const [, alias, nameText = "", modifiers = "", inner = ""] = embedPattern.exec(item) ?? [];
+	const name = nameText.trim();
+	if (!name || name.startsWith("...") || name.includes(".") || name === "count") throw restError(400, "PGRST100", `"${item}" spreads a resource or calls an aggregate, which /rest/v1 does not support yet`);
+	const flags = modifiers.split("!").slice(1).map((flag) => flag.trim());
+	const hint = flags.find((flag) => flag !== "inner" && flag !== "left");
+	return {
+		kind: "embed",
+		name,
+		...alias?.trim() && { alias: alias.trim() },
+		...hint !== void 0 && { hint },
+		inner: flags.includes("inner"),
+		select: inner.trim() === "" ? [] : splitList(inner).map(parseItem)
+	};
+};
+const parseItem = (text) => {
+	const item = text.trim();
+	if (item === "*") return { kind: "all" };
+	if (item.includes("(")) return parseEmbed(item);
+	const aliased = /^([^:]+):(?!:)([\s\S]*)$/.exec(item);
+	const alias = aliased?.[1]?.trim();
+	const [fieldText = "", cast, ...more] = (aliased ? aliased[2] : item).split("::");
+	if (more.length > 0 || cast !== void 0 && !typeName.test(cast.trim())) throw parseError(`"failed to parse select parameter (${item})"`, `"${cast}" is not a type name`);
+	return {
+		kind: "field",
+		field: parseFieldPath(fieldText),
+		...alias && { alias },
+		...cast !== void 0 && { cast: cast.trim() }
+	};
+};
+/** Parses `select`: items separated by commas, `*` for every column. Missing or empty, it is `*`. */
+const parseSelect = (text) => text === void 0 || text.trim() === "" ? [{ kind: "all" }] : splitList(text).map(parseItem);
+/** The name an embed goes by in a row and in the parameters that filter it: its alias, else its name. */
+const embedKey = (item) => item.alias ?? item.name;
+//#endregion
+export { embedKey, parseSelect };

package/dist/rest/read-rows.js

@@ -0,0 +1,41 @@
+import { whereSql } from "./filter-sql.js";
+import { orderSql, rangeSql, selectSql } from "./shape-sql.js";
+import { joinsSql } from "./embed-sql.js";
+import { sql } from "kysely";
+//#region src/rest/read-rows.ts
+/** The most rows a read returns, as Supabase's `db-max-rows` default. */
+const maxRows = 1e3;
+const plannedRows = async (trx, source, filtered) => {
+	const { rows } = await sql`explain (format json) select 1 from ${source.from}${filtered}`.execute(trx);
+	return rows[0]["QUERY PLAN"][0].Plan["Plan Rows"];
+};
+/**
+* Reads the rows of `source` the query asks for: filtered, shaped by `shape` (its `select`, embeds resolved), sorted, in its range and never more than
+* `maxRows`, as one JSON array built by Postgres, so values reach the client exactly as Postgres writes them. `count`
+* counts the matching rows: `exact` by counting, `planned` by the planner's estimate, `estimated` by counting up to
+* `maxRows` and estimating beyond. The rows an inner embed drops are not counted.
+*/
+const readRows = async (trx, source, shape, query, count) => {
+	const where = whereSql(source.alias, query.filters);
+	const filtered = sql`${joinsSql(source.alias, shape.filter((item) => item.kind === "embed" && item.inner))}${where}`;
+	const range = {
+		offset: query.range.offset,
+		limit: Math.min(query.range.limit ?? 1e3, maxRows)
+	};
+	const columns = source.scalar ? sql`${sql.id(source.alias)} as pgrst_scalar` : selectSql(source.alias, shape);
+	const rows = sql`select ${columns} from ${source.from}${joinsSql(source.alias, shape)}${where}${orderSql(source.alias, query.order)}${rangeSql(range)}`;
+	const counted = count === "exact" || count === "estimated" ? sql`(select count(*) from ${source.from}${filtered})` : sql`null::bigint`;
+	const aggregate = source.scalar ? sql`json_agg(pgrst_rows.pgrst_scalar)` : sql`json_agg(pgrst_rows)`;
+	const { rows: [result] } = await sql`
+    select coalesce(${aggregate}, '[]')::text as body, count(*) as page, ${counted} as total from (${rows}) as pgrst_rows
+  `.execute(trx);
+	const exact = result.total === null ? void 0 : Number(result.total);
+	const total = count === "planned" || count === "estimated" && exact > 1e3 ? await plannedRows(trx, source, filtered) : exact;
+	return {
+		body: result.body,
+		page: Number(result.page),
+		...total !== void 0 && { total }
+	};
+};
+//#endregion
+export { maxRows, readRows };

package/dist/rest/respond.js

@@ -0,0 +1,35 @@
+import { restError } from "./rest-error.js";
+import { contentRange, rangeStatus } from "./content-range.js";
+//#region src/rest/respond.ts
+const jsonType = "application/json; charset=utf-8";
+const objectType = "application/vnd.pgrst.object+json; charset=utf-8";
+/** Whether the client asked for one object rather than an array, as `.single()` and `.maybeSingle()` do. */
+const wantsObject = (request) => (request.headers.get("accept") ?? "").includes("application/vnd.pgrst.object+json");
+/** PGRST116 unless there is exactly one row, which an object response needs. */
+const checkSingle = (rows) => {
+	if (rows !== 1) throw restError(406, "PGRST116", "Cannot coerce the result to a single JSON object", `The result contains ${rows} rows`);
+};
+/** The one element of a JSON array of one element, as Postgres's `json_agg` writes it: `[` and `]` around it. */
+const onlyElement = (array) => array.slice(1, -1);
+/** The response of a page of rows read from `offset`: an array, or one object when asked for. */
+const pageResponse = (page, offset, object, headers = {}) => {
+	const status = rangeStatus(offset, page.page, page.total);
+	if (object) checkSingle(page.page);
+	return new Response(object ? onlyElement(page.body) : page.body, {
+		status,
+		headers: {
+			"content-range": contentRange(offset, page.page, page.total),
+			"content-type": object ? objectType : jsonType,
+			...headers
+		}
+	});
+};
+const errorResponse = (error) => new Response(JSON.stringify(error.body), {
+	status: error.status,
+	headers: {
+		"content-type": jsonType,
+		...error.headers
+	}
+});
+//#endregion
+export { checkSingle, errorResponse, jsonType, objectType, onlyElement, pageResponse, wantsObject };

package/dist/rest/rest-context.js

@@ -0,0 +1,31 @@
+import { readTransaction, writeTransaction } from "../transactions.js";
+import { wakeDispatch } from "../changes/actor.js";
+import { callerSettings } from "./caller-settings.js";
+import { restError } from "./rest-error.js";
+//#region src/rest/rest-context.ts
+/**
+* Runs `work` in one transaction as the request's caller (see `callerSettings`), under the statement timeout;
+* read-only for a read, so a function that writes fails as on PostgREST.
+*/
+const asCaller = async (deps, c, readOnly, work) => {
+	const settings = callerSettings(c.get("caller"), deps.actorSetting);
+	if (readOnly) return readTransaction(deps.db, deps.statementTimeoutMs, work, settings);
+	const result = await writeTransaction(deps.db, deps.statementTimeoutMs, work, settings);
+	wakeDispatch(deps);
+	return result;
+};
+/** The request's query parameters in order, decoded as `URLSearchParams` decodes them. */
+const queryParams = (c) => [...new URL(c.req.url).searchParams];
+/** The JSON body; `empty` when there is none, as a function called without arguments may send. Invalid JSON is PGRST102. */
+const readBody = async (c, empty) => {
+	const text = await c.req.text();
+	if (text.trim() === "" && empty !== void 0) return empty;
+	try {
+		return JSON.parse(text);
+	} catch (error) {
+		if (error instanceof SyntaxError) throw restError(400, "PGRST102", "Empty or invalid json");
+		throw error;
+	}
+};
+//#endregion
+export { asCaller, queryParams, readBody };

package/dist/rest/rest-error.js

@@ -0,0 +1,80 @@
+import { isDatabaseError } from "../error-handler.js";
+//#region src/rest/rest-error.ts
+/** A `/rest/v1` error: its status, the body, and headers such as `Content-Range`. Thrown anywhere below the route. */
+var RestError = class RestError extends Error {
+	status;
+	body;
+	headers;
+	constructor(status, body, headers = {}) {
+		super(body.message);
+		this.status = status;
+		this.body = body;
+		this.headers = headers;
+	}
+	withHeaders(headers) {
+		return new RestError(this.status, this.body, {
+			...this.headers,
+			...headers
+		});
+	}
+};
+const restError = (status, code, message, details = null, hint = null) => new RestError(status, {
+	code,
+	details,
+	hint,
+	message
+});
+/** PGRST100: a query parameter that does not parse. */
+const parseError = (message, details = null) => restError(400, "PGRST100", message, details);
+const prefixStatus = [
+	["08", 503],
+	["09", 500],
+	["0L", 403],
+	["0P", 403],
+	["25", 500],
+	["28", 403],
+	["2D", 500],
+	["38", 500],
+	["39", 500],
+	["3B", 500],
+	["40", 500],
+	["53", 503],
+	["54", 500],
+	["55", 500],
+	["57", 500],
+	["58", 500],
+	["F0", 500],
+	["HV", 500],
+	["P0", 500],
+	["XX", 500]
+];
+const codeStatus = {
+	"23503": 409,
+	"23505": 409,
+	"25006": 405,
+	"53400": 500,
+	"57P01": 503,
+	P0001: 400,
+	"42883": 404,
+	"42P01": 404,
+	"42P17": 500
+};
+const databaseStatus = (code, message, anonymous) => {
+	if (code === "42501") return anonymous ? 401 : 403;
+	if (code.startsWith("PT")) return Number(code.slice(2)) || 500;
+	if (code === "21000") return message.endsWith("requires a WHERE clause") ? 400 : 500;
+	return codeStatus[code] ?? prefixStatus.find(([prefix]) => code.startsWith(prefix))?.[1] ?? 400;
+};
+/**
+* The `/rest/v1` error an error stands for: its own, or a database error with PostgREST's status and the error's
+* message, detail and hint, which PostgREST passes on as they are. Other errors give `undefined`. Refusing a write by
+* RLS is 401 for an anonymous caller and 403 for others, as on Supabase.
+*/
+const restErrorOf = (error, anonymous) => {
+	if (error instanceof RestError) return error;
+	if (!isDatabaseError(error)) return void 0;
+	const { code, message, detail, hint } = error;
+	return restError(databaseStatus(code, message, anonymous), code, message, detail ?? null, hint ?? null);
+};
+//#endregion
+export { RestError, parseError, restError, restErrorOf };

package/dist/rest/rest-routes.js

@@ -0,0 +1,34 @@
+import { HttpProblem } from "../problem.js";
+import { foreignKeyCache } from "./foreign-keys.js";
+import { restError, restErrorOf } from "./rest-error.js";
+import { errorResponse } from "./respond.js";
+import { rpcRoute } from "./rpc-route.js";
+import { tableRoutes } from "./table-routes.js";
+import { Hono } from "hono";
+//#region src/rest/rest-routes.ts
+/**
+* The PostgREST-compatible API supabase-js's `from()` and `rpc()` call, mounted at `/rest/v1`. Each request runs in one
+* transaction as `anon`, `authenticated` or the app's own role, so the tables' RLS policies decide what it may read and
+* write. Errors come back as PostgREST's `{ code, details, hint, message }`; an unexpected one as a 500 that names
+* nothing of it.
+*/
+const restRoutes = ({ deps, caller, report }) => {
+	const app = new Hono();
+	app.onError((error, c) => {
+		const known = restErrorOf(error, c.get("caller")?.role === "anon");
+		if (known) return errorResponse(known);
+		if (error instanceof HttpProblem) return errorResponse(restError(error.status, error.status === 401 ? "PGRST301" : "PGRST000", error.detail).withHeaders(error.headers));
+		report?.(error, c.req.raw);
+		return errorResponse(restError(500, "PGRST000", "The server failed to handle the request"));
+	});
+	app.use("*", async (c, next) => {
+		c.set("caller", await caller(c.req.raw));
+		await next();
+	});
+	app.route("/", rpcRoute(deps));
+	app.route("/", tableRoutes(deps, foreignKeyCache(deps.db)));
+	app.notFound(() => errorResponse(restError(404, "PGRST125", "Invalid path specified in request URL")));
+	return app;
+};
+//#endregion
+export { restRoutes };

package/dist/rest/rest-scan.js

@@ -0,0 +1,106 @@
+import { restError } from "./rest-error.js";
+//#region src/rest/rest-scan.ts
+const needs = {
+	eq: "equality",
+	neq: "btree",
+	gt: "btree",
+	gte: "btree",
+	lt: "btree",
+	lte: "btree",
+	in: "btree",
+	is: "btree",
+	isdistinct: "btree",
+	like: "trigram",
+	ilike: "trigram",
+	match: "trigram",
+	imatch: "trigram",
+	fts: "gin",
+	plfts: "gin",
+	phfts: "gin",
+	wfts: "gin",
+	cs: "containment",
+	cd: "containment",
+	ov: "containment",
+	sl: "gist",
+	sr: "gist",
+	nxr: "gist",
+	nxl: "gist",
+	adj: "gist"
+};
+const trigramClasses = ["gin_trgm_ops", "gist_trgm_ops"];
+const quoted = (name) => `"${name.replaceAll("\"", "\"\"")}"`;
+const pathKey = (path) => path.column + path.json.map((step) => `${step.arrow}${typeof step.key === "number" ? step.key : `'${step.key}'`}`).join("");
+const normalized = (definition) => definition.replaceAll("::text", "").replace(/[\s()"]/g, "");
+const keyMatches = (key, path) => path.json.length === 0 ? key.column === path.column : key.column === null && normalized(key.definition) === pathKey(path);
+const keyName = (key) => key.column ?? normalized(key.definition);
+const serves = (index, read, pinned) => {
+	if (index.partial) return false;
+	const position = index.keys.findIndex((key) => keyMatches(key, read.field));
+	if (position < 0) return false;
+	switch (read.need) {
+		case "equality":
+			if (trigramClasses.includes(index.keys[position].opclass)) return true;
+			return index.method === "btree" && index.keys.slice(0, position).every((key) => pinned.has(keyName(key)));
+		case "btree": return index.method === "btree" && index.keys.slice(0, position).every((key) => pinned.has(keyName(key)));
+		case "trigram": return trigramClasses.includes(index.keys[position].opclass);
+		case "gin":
+		case "containment": return index.method === "gin" || index.method === "gist";
+		case "gist": return index.method === "gist";
+	}
+};
+const pinnedFields = (filter) => {
+	if (filter.negated) return [];
+	if (filter.kind === "and") return filter.args.flatMap(pinnedFields);
+	if (filter.kind === "condition" && [
+		"eq",
+		"in",
+		"is"
+	].includes(filter.operator) && !filter.quantifier) return [pathKey(filter.field)];
+	return [];
+};
+const filterReads = (filter) => filter.kind === "condition" ? [{
+	field: filter.field,
+	need: needs[filter.operator],
+	use: "filter"
+}] : filter.args.flatMap(filterReads);
+const suggestion = (table, read) => {
+	const column = read.field.json.length === 0 ? quoted(read.field.column) : `(${pathKey(read.field).replace(read.field.column, quoted(read.field.column))})`;
+	if (read.need === "trigram") return `create index on ${table} using gin (${column} gin_trgm_ops)`;
+	if (read.need === "gin" || read.need === "containment") return `create index on ${table} using gin (${column})`;
+	if (read.need === "gist") return `create index on ${table} using gist (${column})`;
+	return `create index on ${table} (${column})`;
+};
+/**
+* The reads of a request no index of the table serves: each column an embed joins on, which equals one value per
+* related row; each filtered field, by the kind of index its operator needs; and the first sort field. A view or a
+* foreign table has no indexes of its own and is not judged.
+*/
+const uncoveredReads = (table, filters, order, joined = []) => {
+	if (table.kind !== "table") return [];
+	const pinned = /* @__PURE__ */ new Set([...joined, ...filters.flatMap(pinnedFields)]);
+	return [
+		...joined.map((column) => ({
+			field: {
+				column,
+				json: []
+			},
+			need: "equality",
+			use: "join"
+		})),
+		...filters.flatMap(filterReads),
+		...order[0] ? [{
+			field: order[0].field,
+			need: "btree",
+			use: "sort"
+		}] : []
+	].filter((read) => !table.indexes.some((index) => serves(index, read, pinned)));
+};
+/** The 400 error of a read no index serves, with the statement that adds one as its hint. */
+const scanRefusal = (table, read) => {
+	const tableName = table.schema ? `${quoted(table.schema)}.${quoted(table.name)}` : quoted(table.name);
+	const what = read.use === "sort" ? "Sorting by" : read.use === "join" ? "Embedding through" : "Filtering on";
+	const index = read.need === "btree" || read.need === "equality" ? "an index" : read.need === "trigram" ? "a pg_trgm index" : read.need === "gist" ? "a GiST index" : "a GIN index";
+	return restError(400, "expensive-query", `${what} "${pathKey(read.field)}" needs ${index} that serves it`, null, suggestion(tableName, read));
+};
+//#endregion
+export { scanRefusal, uncoveredReads };