@gscdump/engine-gsc-api 0.38.2 → 0.40.1

package/dist/index.d.mts

@@ -12,12 +12,13 @@ interface CreateLiveGscSourceOptions {
    * cost is paid only when the source actually runs. Host owns refresh logic.
    */
   getAccessToken: () => Promise<string>;
+  /** Optional host client factory (for custom timeouts, fetch, or telemetry). */
+  createClient?: (accessToken: string) => GoogleSearchConsoleClient | Promise<GoogleSearchConsoleClient>;
   /**
    * GSC `searchType` slice this source is scoped to (`web`, `discover`,
    * `news`, `googleNews`, `image`, `video`). When set, the slice is injected
-   * into every outgoing query's filter so the live API returns rows for that
-   * slice only. Undefined preserves pre-0.17.1 behaviour (web by default,
-   * unless the BuilderState's filter already names a `searchType`).
+   * into every outgoing builder state so the live API returns rows for that
+   * slice only. An explicit search type already present on the state wins.
    */
   searchType?: SearchType$1;
 }

package/dist/index.mjs

@@ -1,7 +1,8 @@
 import { googleSearchConsole } from "gscdump/api";
-import { between, clicks, date, extractMetricFilters, extractSpecialOperatorFilters, gsc, normalizeFilter } from "gscdump/query";
-import { assertDimensionsSupported, getFilterDimensions, matchesDimensionFilter, matchesMetricFilter, matchesTopLevelPage, metricValue } from "@gscdump/engine/resolver";
+import { assertDimensionsSupported, dimensionValue, getFilterDimensions, matchesTopLevelPage, metricValue } from "@gscdump/engine/resolver";
+import { between, clicks, date, extractMetricFilters, extractSpecialOperatorFilters, gsc } from "gscdump/query";
 import { buildLogicalPlan } from "gscdump/query/plan";
+import { normalizeUrl } from "gscdump/normalize";
 const METRIC_NAMES = [
 	"clicks",
 	"impressions",
@@ -14,32 +15,135 @@ function isMetricDimension$1(dim) {
 function isLocalDimensionFilter(filter) {
 	return filter.dimension !== "date" && !isMetricDimension$1(filter.dimension) && filter.operator !== "topLevel" && !filter.operator.startsWith("metric");
 }
-function matchesDimensionFilterTree(row, filter) {
-	if (!filter || !("_filters" in filter)) return true;
-	const checks = [...filter._filters.filter(isLocalDimensionFilter).map((f) => matchesDimensionFilter(row, f)), ...(filter._nestedGroups ?? []).map((group) => matchesDimensionFilterTree(row, group))];
-	if (checks.length === 0) return true;
-	return filter._groupType === "or" ? checks.some(Boolean) : checks.every(Boolean);
+function compileDimensionFilter(filter) {
+	const { dimension, expression } = filter;
+	switch (filter.operator) {
+		case "equals": return dimension === "page" ? (row) => normalizeUrl(dimensionValue(row, dimension)) === expression : (row) => dimensionValue(row, dimension) === expression;
+		case "notEquals": return dimension === "page" ? (row) => normalizeUrl(dimensionValue(row, dimension)) !== expression : (row) => dimensionValue(row, dimension) !== expression;
+		case "contains": return (row) => dimensionValue(row, dimension).includes(expression);
+		case "notContains": return (row) => !dimensionValue(row, dimension).includes(expression);
+		case "includingRegex": {
+			let regex;
+			return (row) => (regex ??= new RegExp(expression)).test(dimensionValue(row, dimension));
+		}
+		case "excludingRegex": {
+			let regex;
+			return (row) => !(regex ??= new RegExp(expression)).test(dimensionValue(row, dimension));
+		}
+		default: return () => true;
+	}
 }
-function applyBuilderStatePostProcessing(rows, state) {
-	const metricFilters = extractMetricFilters(state.filter);
-	const specialFilters = extractSpecialOperatorFilters(state.filter);
-	const ordered = [...rows.filter((row) => {
-		if (!matchesDimensionFilterTree(row, state.filter)) return false;
-		if (!metricFilters.every((filter) => matchesMetricFilter(row, filter))) return false;
-		if (specialFilters.some((filter) => filter.operator === "topLevel") && !matchesTopLevelPage(row)) return false;
+function compileMetricFilter(filter) {
+	const { dimension } = filter;
+	const target = Number(filter.expression);
+	switch (filter.operator) {
+		case "metricGte": return (row) => metricValue(row, dimension) >= target;
+		case "metricGt": return (row) => metricValue(row, dimension) > target;
+		case "metricLte": return (row) => metricValue(row, dimension) <= target;
+		case "metricLt": return (row) => metricValue(row, dimension) < target;
+		case "metricBetween": {
+			const target2 = Number(filter.expression2);
+			return (row) => {
+				const value = metricValue(row, dimension);
+				return value >= target && value <= target2;
+			};
+		}
+		default: return () => true;
+	}
+}
+function compileDimensionFilterTree(filter) {
+	if (!filter || !("_filters" in filter)) return () => true;
+	const localFilters = filter._filters;
+	const matchers = [];
+	for (const localFilter of localFilters) if (isLocalDimensionFilter(localFilter)) matchers.push(compileDimensionFilter(localFilter));
+	for (const group of filter._nestedGroups ?? []) matchers.push(compileDimensionFilterTree(group));
+	if (matchers.length === 0) return () => true;
+	if (filter._groupType === "or") return (row) => {
+		for (const matches of matchers) if (matches(row)) return true;
+		return false;
+	};
+	return (row) => {
+		for (const matches of matchers) if (!matches(row)) return false;
 		return true;
-	})].sort((a, b) => {
-		const column = state.orderBy?.column ?? "clicks";
-		const dir = state.orderBy?.dir ?? "desc";
+	};
+}
+function selectTopK(rows, k, compareRows) {
+	const heap = [];
+	const compare = (a, b) => compareRows(a.row, b.row) || a.index - b.index;
+	const siftUp = (start) => {
+		let child = start;
+		while (child > 0) {
+			const parent = child - 1 >>> 1;
+			if (compare(heap[parent], heap[child]) >= 0) break;
+			const swap = heap[parent];
+			heap[parent] = heap[child];
+			heap[child] = swap;
+			child = parent;
+		}
+	};
+	const siftDown = () => {
+		let parent = 0;
+		while (true) {
+			const left = parent * 2 + 1;
+			if (left >= heap.length) return;
+			const right = left + 1;
+			const worse = right < heap.length && compare(heap[right], heap[left]) > 0 ? right : left;
+			if (compare(heap[parent], heap[worse]) >= 0) return;
+			const swap = heap[parent];
+			heap[parent] = heap[worse];
+			heap[worse] = swap;
+			parent = worse;
+		}
+	};
+	for (let index = 0; index < rows.length; index++) {
+		const candidate = {
+			row: rows[index],
+			index
+		};
+		if (heap.length < k) {
+			heap.push(candidate);
+			siftUp(heap.length - 1);
+		} else if (compare(candidate, heap[0]) < 0) {
+			heap[0] = candidate;
+			siftDown();
+		}
+	}
+	heap.sort(compare);
+	return heap.map((entry) => entry.row);
+}
+function applyBuilderStatePostProcessing(rows, state) {
+	const matchesDimensions = compileDimensionFilterTree(state.filter);
+	const metricMatchers = extractMetricFilters(state.filter).map(compileMetricFilter);
+	const hasTopLevelFilter = extractSpecialOperatorFilters(state.filter).some((filter) => filter.operator === "topLevel");
+	const column = state.orderBy?.column ?? "clicks";
+	const dir = state.orderBy?.dir ?? "desc";
+	const checkFiniteOrderValues = column !== "date" && state.rowLimit !== void 0;
+	let hasNonFiniteOrderValue = false;
+	const filtered = [];
+	for (const row of rows) {
+		if (!matchesDimensions(row)) continue;
+		let matchesMetrics = true;
+		for (const matchesMetric of metricMatchers) if (!matchesMetric(row)) {
+			matchesMetrics = false;
+			break;
+		}
+		if (!matchesMetrics) continue;
+		if (hasTopLevelFilter && !matchesTopLevelPage(row)) continue;
+		filtered.push(row);
+		if (checkFiniteOrderValues && !Number.isFinite(metricValue(row, column))) hasNonFiniteOrderValue = true;
+	}
+	const compareRows = (a, b) => {
 		const left = column === "date" ? String(a.date ?? "") : metricValue(a, column);
 		const right = column === "date" ? String(b.date ?? "") : metricValue(b, column);
 		if (left === right) return 0;
 		if (dir === "asc") return left < right ? -1 : 1;
 		return left > right ? -1 : 1;
-	});
+	};
 	const offset = Math.max(0, Number(state.startRow ?? 0));
-	const limit = Math.max(0, Number((state.rowLimit ?? ordered.length) || 0));
-	return ordered.slice(offset, offset + limit);
+	const limit = Math.max(0, Number((state.rowLimit ?? filtered.length) || 0));
+	if (limit === 0) return [];
+	const requested = offset + limit;
+	return (Number.isInteger(requested) && requested > 0 && requested < filtered.length / 2 && !hasNonFiniteOrderValue ? selectTopK(filtered, requested, compareRows) : filtered.sort(compareRows)).slice(offset, offset + limit);
 }
 async function collectRows(gen) {
 	const out = [];
@@ -171,33 +275,15 @@ function canProxyToGsc(state) {
 	return true;
 }
 function withSearchType(state, searchType) {
-	const normalized = normalizeFilter(state.filter);
-	const existingFilters = normalized?._filters ?? [];
-	if (existingFilters.some((f) => f.dimension === "searchType")) return normalized === state.filter ? state : {
-		...state,
-		filter: normalized
-	};
-	const newEntry = {
-		dimension: "searchType",
-		operator: "eq",
-		expression: searchType
-	};
-	const merged = normalized ? {
-		...normalized,
-		_filters: [...existingFilters, newEntry]
-	} : {
-		_filters: [newEntry],
-		_groupType: "and"
-	};
-	return {
+	return state.searchType ? state : {
 		...state,
-		filter: merged
+		searchType
 	};
 }
 function createLiveGscSource(opts) {
 	let clientPromise = null;
 	function getClient() {
-		if (!clientPromise) clientPromise = opts.getAccessToken().then((accessToken) => googleSearchConsole({ accessToken }));
+		if (!clientPromise) clientPromise = opts.getAccessToken().then((accessToken) => opts.createClient?.(accessToken) ?? googleSearchConsole({ accessToken }));
 		return clientPromise;
 	}
 	return {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@gscdump/engine-gsc-api",
   "type": "module",
-  "version": "0.38.2",
+  "version": "0.40.1",
   "description": "GSC live-API engine adapter — wraps the Search Analytics REST API as an AnalysisQuerySource for typed analyzer dispatch.",
   "author": {
     "name": "Harlan Wilton",
@@ -36,8 +36,8 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@gscdump/engine": "0.38.2",
-    "gscdump": "0.38.2"
+    "@gscdump/engine": "0.40.1",
+    "gscdump": "0.40.1"
   },
   "devDependencies": {
     "vitest": "^4.1.10"