@gscdump/cli 3.8.0 → 4.0.0

package/dist/commands/query.mjs

@@ -1,21 +1,25 @@
 import { queryCommandMeta } from "../command-meta.mjs";
+import { useCliRuntime } from "../runtime.mjs";
 import { loadConfig } from "../config.mjs";
 import { terminalOutputOptions } from "../render/terminal.mjs";
 import { ALL_SEARCH_TYPES, logger, parseSearchType, toCSV } from "../utils.mjs";
-import { allTables, inferTable, tableDimensions } from "../local-store.mjs";
-import { createCommandContext } from "../context.mjs";
-import { gscErrorHandler } from "../error-handler.mjs";
+import { allTables } from "../local-store.mjs";
+import { createCommandContext, formatSiteResolution } from "../context.mjs";
+import { decideRoute, describeStop, liveNote, readRouteState, readSiteStates, resolveReadSite, stopAtRoute } from "../route.mjs";
+import { DEFAULT_WINDOW, checkWindowFlags, newestDoneDate, parseWindowFlags } from "../window.mjs";
 import { renderTable } from "../render/layout.mjs";
 import { asRecord, columnsFor } from "../render/analysis.mjs";
+import { FILTER_DIMS, filterDimensions, parseFilterArgs, toLiveFilter, toLocalFilter } from "../filters.mjs";
 import { renderQuery } from "../render/query.mjs";
+import { openSqlViews, referencedTables } from "../sql-views.mjs";
 import process from "node:process";
 import { defineCommand } from "citty";
 import fs from "node:fs/promises";
-import { and, between, contains, country, date, device, eq, gsc, hour, notRegex, page, query, regex, searchAppearance } from "gscdump/query";
-import { decodeSiteId } from "gscdump/tenant";
+import { and, between, country, date, device, gsc, hour, page, query, searchAppearance } from "gscdump/query";
+import { getLatestGscDate } from "gscdump/dates";
 import { cancel, isCancel, multiselect, text } from "@clack/prompts";
-import { daysAgoUtc } from "gscdump/dates";
 import { collectSpans } from "@gscdump/engine/profile";
+import { inferDataset, isDatasetResolvable } from "gscdump/query/plan";
 const DIMENSIONS = [
 	"page",
 	"query",
@@ -34,20 +38,6 @@ const DIM_COLUMNS = {
 	device,
 	searchAppearance
 };
-const FILTER_DIMS = [
-	"query",
-	"page",
-	"country",
-	"device",
-	"searchAppearance"
-];
-const FILTER_COL = {
-	query,
-	page,
-	country,
-	device,
-	searchAppearance
-};
 const DATA_STATES = [
 	"all",
 	"final",
@@ -59,27 +49,6 @@ const AGGREGATION_TYPES = [
 	"byProperty"
 ];
 const POSITIVE_INTEGER_RE = /^\d+$/;
-const ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
-function buildFilterFromArg(col, raw) {
-	if (raw.startsWith("!~")) return makeLeaf(col, "notContains", raw.slice(2));
-	if (raw.startsWith("!re:")) return notRegex(col, raw.slice(4));
-	if (raw.startsWith("!")) return makeLeaf(col, "notEquals", raw.slice(1));
-	if (raw.startsWith("~")) return contains(col, raw.slice(1));
-	if (raw.startsWith("re:")) return regex(col, raw.slice(3));
-	if (raw.startsWith("contains:")) return contains(col, raw.slice(9));
-	if (raw.startsWith("eq:")) return eq(col, raw.slice(3));
-	return eq(col, raw);
-}
-function makeLeaf(col, operator, value) {
-	return {
-		_constraints: {},
-		_filters: [{
-			dimension: col.dimension,
-			operator,
-			expression: value
-		}]
-	};
-}
 async function runLiveQuery(client, siteUrl, opts) {
 	const allRows = [];
 	const totalLimit = Math.max(0, opts.rowLimit);
@@ -137,7 +106,7 @@ const queryCommand = defineCommand({
 		"site": {
 			type: "string",
 			alias: "s",
-			description: "Site URL (e.g., sc-domain:example.com)"
+			description: "Site, for example example.com"
 		},
 		"dimensions": {
 			type: "string",
@@ -169,11 +138,12 @@ const queryCommand = defineCommand({
 		},
 		"sql": {
 			type: "string",
-			description: "Raw DuckDB SQL using {{FILES}} as the file list placeholder (bypasses builder)"
+			description: "DuckDB SQL over one view per Store table, with site and search_type columns. Example: SELECT search_type, SUM(clicks) AS clicks, gsc_position(sum_position, impressions) AS position FROM pages GROUP BY search_type. Run --schema to list views"
 		},
-		"table": {
-			type: "string",
-			description: "Analytics table for --sql (default: pages)"
+		"schema": {
+			type: "boolean",
+			default: false,
+			description: "List the --sql views, their columns, and the date range of each view, then exit"
 		},
 		"live": {
 			type: "boolean",
@@ -214,7 +184,7 @@ const queryCommand = defineCommand({
 		},
 		"type": {
 			type: "string",
-			description: `Search type (live mode only). One of: ${ALL_SEARCH_TYPES.join(",")}`
+			description: `Search type. One of: ${ALL_SEARCH_TYPES.join(",")} (default: web; --sql and --schema default to every search type)`
 		},
 		"data-state": {
 			type: "string",
@@ -242,20 +212,28 @@ const queryCommand = defineCommand({
 			logger.error("Invalid --format. Use table, json, or csv.");
 			process.exit(1);
 		}
-		if (args.sql) {
-			await runRawSqlMode({
-				sql: String(args.sql),
+		if (args.sql || args.schema) {
+			await runSqlMode({
+				mode: args.schema ? { kind: "schema" } : {
+					kind: "sql",
+					sql: String(args.sql)
+				},
 				site: args.site ? String(args.site) : void 0,
-				table: args.table ? String(args.table) : "pages",
 				output: args.output ? String(args.output) : void 0,
 				format,
 				quiet: Boolean(args.quiet),
+				forceLive: Boolean(args.live),
 				searchType: parseSearchType(args.type, "--type")
 			});
 			return;
 		}
 		const dimNames = await resolveDimensions(args);
-		const { startDate, endDate } = await resolveRange(args);
+		const windowFlags = await promptRange(args);
+		const invalidWindow = checkWindowFlags(windowFlags);
+		if (invalidWindow) {
+			logger.error(invalidWindow.message);
+			process.exit(1);
+		}
 		await promptFilters(args);
 		const limitArg = String(args.limit ?? ctxConfig.defaultLimit ?? 1e3);
 		const rowLimit = Number(limitArg);
@@ -263,10 +241,12 @@ const queryCommand = defineCommand({
 			logger.error("Invalid --limit. Use a positive safe integer, such as --limit 1000.");
 			process.exit(1);
 		}
-		const dimensionFilter = buildDimensionFilter(args);
+		const filters = parseFilterArgs(args);
 		const searchType = parseSearchType(args.type ?? ctxConfig.defaultSearchType, "--type");
+		const localSearchType = searchType ?? "web";
 		const dataState = args["data-state"] ? String(args["data-state"]) : ctxConfig.defaultDataState;
 		const aggregationType = args["aggregation-type"] ? String(args["aggregation-type"]) : void 0;
+		const filterDims = filterDimensions(filters);
 		if (dataState && !DATA_STATES.includes(dataState)) {
 			logger.error(`Invalid --data-state: ${dataState}. Allowed: ${DATA_STATES.join(", ")}`);
 			process.exit(1);
@@ -275,15 +255,54 @@ const queryCommand = defineCommand({
 			logger.error(`Invalid --aggregation-type: ${aggregationType}. Allowed: ${AGGREGATION_TYPES.join(", ")}`);
 			process.exit(1);
 		}
-		const ctx = await createCommandContext({
+		const forceLive = Boolean(args.live);
+		const resolvable = isDatasetResolvable(dimNames, filterDims);
+		if (!resolvable && !forceLive) throw new Error(`No Store table holds ${[.../* @__PURE__ */ new Set([...dimNames, ...filterDims])].join(" with ")}. Remove a dimension or filter, or pass --live.`);
+		const storeCtx = await createCommandContext({ needsStore: true });
+		const store = storeCtx.store;
+		let liveCtx;
+		const connect = () => liveCtx ??= createCommandContext({
 			needsAuth: true,
-			needsStore: !args.live,
 			interactive: Boolean(args.interactive)
 		});
-		const hint = args.site ? String(args.site) : ctx.config.defaultSite;
-		const exactHint = !args.live && hint && /^(?:sc-domain:\S+|https?:\/\/\S+)$/.test(hint) ? hint : void 0;
-		const siteUrl = exactHint ? await resolveLocalSite(ctx.store, exactHint) ?? await ctx.resolveSite(hint) : await ctx.resolveSite(hint);
-		if (args.live) {
+		const { site, siteHint, auth } = await resolveReadSite(storeCtx, args.site ? String(args.site) : void 0, {
+			forceLive,
+			connect
+		});
+		const table = resolvable ? inferDataset(dimNames, filterDims) : void 0;
+		const states = site ? await readSiteStates(store, site) : [];
+		const { start: startDate, end: endDate } = windowOrExit(windowFlags, forceLive || !table ? getLatestGscDate() : newestDoneDate(states, [table]) ?? getLatestGscDate());
+		const req = {
+			site,
+			siteHint,
+			label: "query",
+			localCapable: resolvable,
+			liveCapable: true,
+			forceLive,
+			argv: useCliRuntime().rawArgs
+		};
+		const routeState = await readRouteState({
+			store,
+			site,
+			needs: table ? [{
+				kind: "window",
+				period: "current",
+				table,
+				searchType: localSearchType,
+				window: {
+					start: startDate,
+					end: endDate
+				}
+			}] : [],
+			states,
+			auth
+		});
+		const route = decideRoute(req, routeState);
+		const json = format === "json";
+		if (route.kind === "live") {
+			const live = await connect();
+			const siteUrl = site ?? await live.resolveSite(void 0);
+			const dimensionFilter = toLiveFilter(filters, siteUrl);
 			if (args.explain) {
 				const body = {
 					startDate,
@@ -297,12 +316,14 @@ const queryCommand = defineCommand({
 				if (dimensionFilter) body.dimensionFilterGroups = filterToGroups(dimensionFilter);
 				console.log(JSON.stringify({
 					siteUrl,
+					source: "live",
 					body
 				}, null, 2));
 				return;
 			}
+			if (route.reason === "no-store-data") logger.warn(liveNote(siteUrl));
 			if (!args.quiet) logger.debug(`Querying ${siteUrl} via live GSC API...`);
-			const result = await runLiveQuery(ctx.client, siteUrl, {
+			const result = await runLiveQuery(live.client, siteUrl, {
 				startDate,
 				endDate,
 				dimensions: dimNames,
@@ -311,7 +332,7 @@ const queryCommand = defineCommand({
 				dataState,
 				aggregationType,
 				dimensionFilter
-			}).catch(gscErrorHandler);
+			});
 			await writeOutput({
 				output: {
 					siteUrl,
@@ -321,7 +342,8 @@ const queryCommand = defineCommand({
 						end: endDate
 					},
 					total: result.rows.length,
-					data: result.rows
+					data: result.rows,
+					meta: { source: "live" }
 				},
 				format,
 				path: args.output ? String(args.output) : void 0,
@@ -329,26 +351,28 @@ const queryCommand = defineCommand({
 			});
 			return;
 		}
-		if (dataState || aggregationType) logger.warn("--data-state / --aggregation-type are ignored without --live");
-		if (!args.quiet) logger.debug(`Querying ${siteUrl} from local Parquet store...`);
-		const state = buildLocalState(dimNames, startDate, endDate, rowLimit, dimensionFilter);
-		const store = ctx.store;
-		const table = inferTable(dimNames);
+		const state = buildLocalState(dimNames, startDate, endDate, rowLimit, toLocalFilter(filters));
 		if (args.explain) {
+			const stop = route.kind === "local" ? void 0 : describeStop(route, req, routeState.auth);
 			console.log(JSON.stringify({
-				siteUrl,
+				siteUrl: site ?? null,
+				source: "local",
 				table,
-				state
+				state,
+				...stop ? { stop } : {}
 			}, null, 2));
 			return;
 		}
-		await assertRangeCovered(store, siteUrl, table, startDate, endDate, format === "json", searchType);
+		if (route.kind === "syncing" || route.kind === "prompt") stopAtRoute(route, req, routeState.auth, { json });
+		if (dataState || aggregationType) logger.warn("--data-state / --aggregation-type are ignored without --live");
+		const siteUrl = site;
+		if (!args.quiet) logger.debug(`Querying ${siteUrl} from local Parquet store...`);
 		const probe = Boolean(args.profile) ? collectSpans() : void 0;
 		const result = await store.engine.query({
 			userId: store.userId,
 			siteId: store.siteIdFor(siteUrl),
 			table,
-			...searchType !== void 0 ? { searchType } : {},
+			searchType: localSearchType,
 			...probe ? { profiler: probe.profiler } : {}
 		}, state).catch((e) => {
 			logger.error(`Query failed: ${e.message}`);
@@ -364,7 +388,8 @@ const queryCommand = defineCommand({
 					end: endDate
 				},
 				total: result.rows.length,
-				data: result.rows
+				data: result.rows,
+				meta: { source: "local" }
 			},
 			format,
 			path: args.output ? String(args.output) : void 0,
@@ -398,51 +423,46 @@ async function resolveDimensions(args) {
 	}
 	return ["page", "query"];
 }
-async function resolveRange(args) {
-	let startDate = args.start != null ? String(args.start) : void 0;
-	let endDate = args.end != null ? String(args.end) : void 0;
+async function promptRange(args) {
+	let start = args.start != null ? String(args.start) : void 0;
+	let end = args.end != null ? String(args.end) : void 0;
 	if (args.interactive) {
-		if (startDate === void 0) {
+		if (start === void 0) {
 			const startInput = await text({
-				message: "Start date (YYYY-MM-DD)",
-				placeholder: daysAgoUtc(28)
+				message: "Start date (YYYY-MM-DD, blank for the last 28 synced days)",
+				placeholder: ""
 			});
 			if (isCancel(startInput)) {
 				cancel("Cancelled");
 				process.exit(0);
 			}
-			startDate = String(startInput) || daysAgoUtc(28);
+			start = String(startInput) || void 0;
 		}
-		if (endDate === void 0) {
+		if (end === void 0) {
 			const endInput = await text({
-				message: "End date (YYYY-MM-DD)",
-				placeholder: daysAgoUtc(3)
+				message: "End date (YYYY-MM-DD, blank for the newest synced day)",
+				placeholder: ""
 			});
 			if (isCancel(endInput)) {
 				cancel("Cancelled");
 				process.exit(0);
 			}
-			endDate = String(endInput) || daysAgoUtc(3);
+			end = String(endInput) || void 0;
 		}
 	}
-	startDate ??= daysAgoUtc(31);
-	endDate ??= daysAgoUtc(3);
-	for (const [flag, value] of [["--start", startDate], ["--end", endDate]]) {
-		const date = /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
-		if (!ISO_DATE_RE.test(value) || !Number.isFinite(date.getTime()) || date.toISOString().slice(0, 10) !== value) {
-			logger.error(`Invalid ${flag}. Use a calendar date in YYYY-MM-DD format.`);
-			process.exit(1);
-		}
-	}
-	if (startDate > endDate) {
-		logger.error("Invalid date range. --start must be on or before --end.");
-		process.exit(1);
-	}
 	return {
-		startDate,
-		endDate
+		start,
+		end
 	};
 }
+function windowOrExit(flags, anchor) {
+	const window = parseWindowFlags(flags, DEFAULT_WINDOW, anchor);
+	if (!window.ok) {
+		logger.error(window.error.message);
+		process.exit(1);
+	}
+	return window.value;
+}
 async function promptFilters(args) {
 	if (!args.interactive) return;
 	for (const dim of FILTER_DIMS) {
@@ -480,126 +500,118 @@ async function promptFilters(args) {
 		if (ds && String(ds).length > 0) args["data-state"] = String(ds);
 	}
 }
-async function resolveLocalSite(store, hint) {
-	const siteIds = new Set((await store.engine.getWatermarks({ userId: store.userId })).map((w) => w.siteId).filter((siteId) => siteId !== void 0));
-	const exact = store.siteIdFor(hint);
-	if (siteIds.has(exact)) return hint;
-	const lowered = exact.toLowerCase();
-	const matches = [...siteIds].filter((siteId) => siteId.toLowerCase() === lowered);
-	return matches.length === 1 ? decodeSiteId(matches[0]) : void 0;
-}
 function buildLocalState(dimNames, startDate, endDate, rowLimit, dimensionFilter) {
 	const dims = dimNames.map((d) => DIM_COLUMNS[d]).filter((c) => Boolean(c));
 	const dateFilter = between(date, startDate, endDate);
 	const filter = dimensionFilter ? and(dateFilter, dimensionFilter) : dateFilter;
 	return gsc.select(...dims).where(filter).limit(rowLimit).getState();
 }
-function buildDimensionFilter(args) {
-	const leaves = [];
-	for (const dim of FILTER_DIMS) {
-		const raw = args[dim];
-		if (raw == null || raw === "") continue;
-		leaves.push(buildFilterFromArg(FILTER_COL[dim], String(raw)));
-	}
-	if (leaves.length === 0) return void 0;
-	if (leaves.length === 1) return leaves[0];
-	return and(...leaves);
-}
-async function assertRangeCovered(store, siteUrl, table, startDate, endDate, json, searchType) {
-	const watermarks = await store.engine.getWatermarks({
-		userId: store.userId,
-		siteId: store.siteIdFor(siteUrl),
-		table,
-		...searchType !== void 0 ? { searchType } : {}
-	});
-	const wm = watermarks[0];
-	const states = await store.engine.getSyncStates({
-		userId: store.userId,
-		siteId: store.siteIdFor(siteUrl),
-		table,
-		searchType: searchType ?? "web",
-		state: "done"
+async function runSqlMode(opts) {
+	const ctx = await createCommandContext({ needsStore: true });
+	const store = ctx.store;
+	const found = opts.site ? await ctx.matchSite(opts.site, { scope: "store" }) : void 0;
+	if (found && found.kind !== "resolved") throw new Error(formatSiteResolution(found, "store"));
+	const site = found?.kind === "resolved" ? found.siteUrl : void 0;
+	const siteIds = site ? [store.siteIdFor(site)] : void 0;
+	const views = await openSqlViews(store, {
+		...siteIds ? { siteIds } : {},
+		...opts.searchType !== void 0 ? { searchType: opts.searchType } : {}
 	});
-	const completed = new Set(states.map((state) => state.date));
-	const missingDates = [];
-	for (let date = Date.parse(startDate); date <= Date.parse(endDate); date += 864e5) {
-		const day = new Date(date).toISOString().slice(0, 10);
-		if (!completed.has(day)) missingDates.push(day);
+	if (opts.mode.kind === "sql") {
+		const tables = referencedTables(opts.mode.sql, allTables());
+		if (tables.length > 0) {
+			const req = {
+				site,
+				siteHint: opts.site,
+				label: "query --sql",
+				localCapable: true,
+				liveCapable: false,
+				forceLive: opts.forceLive
+			};
+			const routeState = await readRouteState({
+				store,
+				site,
+				needs: [],
+				states: []
+			});
+			const stored = tables.some((table) => !views.emptyTables.includes(table));
+			const route = decideRoute(req, {
+				...routeState,
+				coverage: [{
+					kind: "any",
+					tables,
+					stored
+				}]
+			});
+			if (route.kind === "syncing" || route.kind === "prompt") {
+				views.close();
+				stopAtRoute(route, req, routeState.auth, { json: opts.format === "json" });
+			}
+		}
 	}
-	if (missingDates.length === 0) return;
-	const nextArgs = [
-		"sync",
-		"--site",
-		siteUrl,
-		"--start",
-		startDate,
-		"--end",
-		endDate,
-		"--tables",
-		table,
-		"--types",
-		searchType ?? "web",
-		"--json"
-	];
-	const nextCommand = `gscdump ${nextArgs.map((value) => /^[\w:./=-]+$/.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`).join(" ")}`;
-	const message = !wm ? `No data synced for ${siteUrl} / ${table}.` : `Store coverage is incomplete for ${missingDates.length} requested dates.`;
-	if (json) {
-		const available = await store.engine.getWatermarks({
-			userId: store.userId,
-			siteId: store.siteIdFor(siteUrl)
-		});
-		console.log(JSON.stringify({ error: {
-			code: "STORE_RANGE_NOT_COVERED",
-			message,
-			siteUrl,
-			table,
-			range: {
-				start: startDate,
-				end: endDate
-			},
-			missingDates,
-			watermarks: watermarks.filter((w) => w.table === table),
-			availableTables: available.map((w) => ({
-				...w,
-				dimensions: tableDimensions(w.table)
-			})),
-			nextArgs,
-			nextCommand
-		} }, null, 2));
+	try {
+		const result = opts.mode.kind === "schema" ? await describeViews(views) : await runSql(views, opts.mode.sql);
+		const rows = result.rows;
+		const payload = opts.format === "table" && opts.mode.kind === "schema" ? renderSchema(rows) : opts.format === "table" ? renderTable(rows, columnsFor(rows), terminalOutputOptions(Boolean(opts.output && opts.output !== "-"))).join("\n") : opts.format === "csv" ? toCSV(rows.map((row) => Object.fromEntries(Object.entries(row).map(([key, value]) => [key, value !== null && typeof value === "object" ? JSON.stringify(value) : value]))), result.columns) : JSON.stringify({
+			total: rows.length,
+			data: rows,
+			...result.warnings.length > 0 ? { warnings: result.warnings } : {}
+		}, null, 2);
+		if (opts.output && opts.output !== "-") {
+			await fs.writeFile(opts.output, payload);
+			if (!opts.quiet) logger.info(`Written to ${opts.output}`);
+		} else console.log(payload);
+	} finally {
+		views.close();
 	}
-	logger.error(`${message} Run ${nextCommand}, or pass --live.`);
-	process.exit(1);
 }
-async function runRawSqlMode(opts) {
-	if (!isKnownTable(opts.table)) {
-		logger.error(`Unknown table "${opts.table}". Known: ${allTables().join(", ")}`);
-		process.exit(1);
+async function runSql(views, sql) {
+	const warnings = referencedTables(sql, views.emptyTables).map((table) => `No synced data for table ${table}. Run gscdump sync --tables ${table} to fill it.`);
+	for (const warning of warnings) logger.warn(warning);
+	return {
+		...await views.run(sql).catch((e) => {
+			logger.error(`SQL failed: ${e.message}`);
+			process.exit(1);
+		}),
+		warnings
+	};
+}
+function renderSchema(rows) {
+	return rows.map((row) => {
+		const summary = row.rows === 0 ? "no synced data" : `${Number(row.rows).toLocaleString()} rows, ${row.start} to ${row.end}, ${row.search_types}, ${row.sites}`;
+		return `${row.view}  ${summary}\n  ${row.columns}`;
+	}).join("\n");
+}
+async function describeViews(views) {
+	const rows = [];
+	for (const view of views.views) {
+		const range = view.sources.length === 0 ? {
+			start: null,
+			end: null
+		} : (await views.run(`SELECT min(date) AS start, max(date) AS end FROM ${view.table}`)).rows[0];
+		rows.push({
+			view: view.table,
+			columns: view.columns.map((column) => `${column.name} ${column.type}`).join(", "),
+			sites: [...new Set(view.sources.map((source) => source.site))].join(", "),
+			search_types: [...new Set(view.sources.map((source) => source.searchType))].join(", "),
+			rows: view.sources.reduce((sum, source) => sum + source.rows, 0),
+			start: range.start ?? null,
+			end: range.end ?? null
+		});
 	}
-	const ctx = await createCommandContext({
-		needsAuth: true,
-		needsStore: true
-	});
-	const siteUrl = await ctx.resolveSite(opts.site);
-	const store = ctx.store;
-	if (!opts.quiet) logger.debug(`Running raw SQL over table "${opts.table}" for ${siteUrl}`);
-	const { rows, sql } = await store.runRawSql({
-		sql: opts.sql,
-		siteUrl,
-		table: opts.table,
-		...opts.searchType !== void 0 ? { searchType: opts.searchType } : {}
-	}).catch((e) => {
-		logger.error(`SQL failed: ${e.message}`);
-		process.exit(1);
-	});
-	const payload = opts.format === "table" ? renderTable(rows, columnsFor(rows), terminalOutputOptions(Boolean(opts.output && opts.output !== "-"))).join("\n") : opts.format === "csv" ? toCSV(rows, Object.keys(rows[0] ?? {})) : JSON.stringify({
-		sql,
-		total: rows.length,
-		data: rows
-	}, (_key, value) => typeof value === "bigint" ? value.toString() : value, 2);
-	if (opts.output && opts.output !== "-") {
-		await fs.writeFile(opts.output, payload);
-		if (!opts.quiet) logger.info(`Written to ${opts.output}`);
-	} else console.log(payload);
+	return {
+		columns: [
+			"view",
+			"columns",
+			"sites",
+			"search_types",
+			"rows",
+			"start",
+			"end"
+		],
+		rows,
+		warnings: []
+	};
 }
 function logProfile(spans) {
 	if (spans.length === 0) {
@@ -632,7 +644,4 @@ async function writeOutput(opts) {
 		if (!opts.quiet) logger.info(`Written to ${opts.path}`);
 	} else console.log(content);
 }
-function isKnownTable(name) {
-	return allTables().includes(name);
-}
 export { queryCommand };