gscdump 1.4.0 → 1.4.2

package/dist/query/resolver.mjs

@@ -0,0 +1,243 @@
+import { err, ok, unwrapResult } from "../core/result.mjs";
+import { addDays } from "../core/gsc-dates.mjs";
+import { SearchTypes } from "./constants.mjs";
+import { queryErrorToException, queryErrors } from "./errors.mjs";
+import { isDateOperator, isMetricOperator, isQueryParam, isSpecialOperator } from "./operator-meta.mjs";
+const KNOWN_SEARCH_TYPES = new Set(Object.values(SearchTypes));
+function isWireGroupType(type) {
+	return type === "and" || type === "or";
+}
+function convertWireLeaf(alt) {
+	if (!alt.column || !alt.type || isWireGroupType(alt.type)) return null;
+	const f = {
+		dimension: alt.column,
+		operator: alt.type,
+		expression: alt.type === "between" ? alt.from ?? "" : alt.value ?? ""
+	};
+	if (alt.type === "between" && alt.to) f.expression2 = alt.to;
+	return f;
+}
+function convertWireGroup(alt) {
+	if (!isWireGroupType(alt.type)) {
+		const leaf = convertWireLeaf(alt);
+		return leaf ? { _filters: [leaf] } : null;
+	}
+	const leaves = [];
+	const nested = [];
+	for (const child of alt.filters ?? []) if (isWireGroupType(child.type)) {
+		const sub = convertWireGroup(child);
+		if (sub) nested.push(sub);
+	} else {
+		const leaf = convertWireLeaf(child);
+		if (leaf) leaves.push(leaf);
+	}
+	if (leaves.length === 0 && nested.length === 0) return null;
+	return {
+		_filters: leaves,
+		_nestedGroups: nested.length > 0 ? nested : void 0,
+		_groupType: alt.type
+	};
+}
+function isWireFilter(input) {
+	if (!input || typeof input !== "object") return false;
+	const o = input;
+	if ("_filters" in o) return false;
+	return "type" in o && typeof o.type === "string" || "filters" in o && Array.isArray(o.filters);
+}
+function normalizeFilter(input) {
+	if (!input) return void 0;
+	if (isWireFilter(input)) return convertWireGroup(input) ?? void 0;
+	if (typeof input === "object" && Array.isArray(input._filters)) return input;
+}
+function normalizeOrderBy(orderBy) {
+	const spec = Array.isArray(orderBy) ? orderBy[0] : orderBy;
+	if (!spec || typeof spec !== "object") return void 0;
+	const o = spec;
+	if (typeof o.column !== "string" || o.column.length === 0) return void 0;
+	const dir = typeof o.dir === "string" ? o.dir.toLowerCase() === "asc" ? "asc" : "desc" : o.desc === false ? "asc" : "desc";
+	return {
+		column: o.column,
+		dir
+	};
+}
+function hasMalformedFilterLeaf(filter) {
+	if (!filter || typeof filter !== "object") return false;
+	if (Array.isArray(filter._filters)) {
+		for (const leaf of filter._filters) if (!leaf || typeof leaf !== "object" || typeof leaf.operator !== "string" || typeof leaf.dimension !== "string") return true;
+	}
+	if (Array.isArray(filter._nestedGroups)) {
+		for (const group of filter._nestedGroups) if (hasMalformedFilterLeaf(group)) return true;
+	}
+	return false;
+}
+function normalizeBuilderStateResult(state) {
+	if (!state || typeof state !== "object") return err(queryErrors.invalidBuilderState(state));
+	const s = state;
+	const filter = normalizeFilter(s.filter);
+	if (hasMalformedFilterLeaf(filter)) return err(queryErrors.malformedFilterLeaf());
+	const normalized = {
+		dimensions: Array.isArray(s.dimensions) ? s.dimensions : [],
+		metrics: s.metrics,
+		filter,
+		orderBy: normalizeOrderBy(s.orderBy),
+		rowLimit: s.rowLimit,
+		startRow: s.startRow,
+		dataState: s.dataState,
+		aggregationType: s.aggregationType
+	};
+	if (typeof s.searchType === "string" && KNOWN_SEARCH_TYPES.has(s.searchType)) normalized.searchType = s.searchType;
+	return ok(normalized);
+}
+function normalizeBuilderState(state) {
+	return unwrapResult(normalizeBuilderStateResult(state), queryErrorToException);
+}
+function extractSpecialFilters(filter) {
+	if (!filter || !Array.isArray(filter._filters)) return {};
+	let startDate;
+	let endDate;
+	let searchType;
+	const otherFilters = [];
+	const cleanedNestedGroups = [];
+	for (const f of filter._filters) if (f.dimension === "date" && isDateOperator(f.operator)) switch (f.operator) {
+		case "gte":
+			startDate = f.expression;
+			break;
+		case "gt":
+			startDate = addDays(f.expression, 1);
+			break;
+		case "lte":
+			endDate = f.expression;
+			break;
+		case "lt":
+			endDate = addDays(f.expression, -1);
+			break;
+		case "between":
+			startDate = f.expression;
+			endDate = f.expression2;
+			break;
+	}
+	else if (isQueryParam(f.dimension)) {
+		if (f.dimension === "searchType") searchType = f.expression;
+	} else if (isMetricOperator(f.operator) || isSpecialOperator(f.operator)) otherFilters.push(f);
+	else otherFilters.push(f);
+	if (filter._nestedGroups) for (const nested of filter._nestedGroups) {
+		const extracted = extractSpecialFilters(nested);
+		if (!startDate && extracted.startDate) startDate = extracted.startDate;
+		if (!endDate && extracted.endDate) endDate = extracted.endDate;
+		if (!searchType && extracted.searchType) searchType = extracted.searchType;
+		if (extracted.dimensionFilter) cleanedNestedGroups.push(extracted.dimensionFilter);
+	}
+	const dimensionFilter = otherFilters.length > 0 || cleanedNestedGroups.length > 0 ? {
+		...filter,
+		_filters: otherFilters,
+		_nestedGroups: cleanedNestedGroups.length > 0 ? cleanedNestedGroups : void 0
+	} : void 0;
+	return {
+		startDate,
+		endDate,
+		searchType,
+		dimensionFilter
+	};
+}
+function extractDateRange(input) {
+	const { startDate, endDate } = extractSpecialFilters(normalizeFilter(input));
+	return {
+		startDate,
+		endDate
+	};
+}
+function extractMetricFilters(input) {
+	const filter = normalizeFilter(input);
+	if (!filter) return [];
+	const metricFilters = filter._filters.filter((f) => isMetricOperator(f.operator));
+	const nested = filter._nestedGroups?.flatMap((g) => extractMetricFilters(g)) ?? [];
+	return [...metricFilters, ...nested];
+}
+function extractSpecialOperatorFilters(input) {
+	const filter = normalizeFilter(input);
+	if (!filter) return [];
+	const special = filter._filters.filter((f) => isSpecialOperator(f.operator));
+	const nested = filter._nestedGroups?.flatMap((g) => extractSpecialOperatorFilters(g)) ?? [];
+	return [...special, ...nested];
+}
+function extractSearchType(state) {
+	if (!state) return void 0;
+	if (state.searchType && KNOWN_SEARCH_TYPES.has(state.searchType)) return state.searchType;
+	const filter = state.filter;
+	const raw = extractSpecialFilters(normalizeFilter(filter)).searchType;
+	if (typeof raw !== "string" || raw.length === 0) return void 0;
+	return KNOWN_SEARCH_TYPES.has(raw) ? raw : void 0;
+}
+function resolveToBodyResult(state) {
+	const { startDate, endDate, searchType, dimensionFilter } = extractSpecialFilters(state.filter);
+	if (!startDate || !endDate) return err(queryErrors.missingDateRange());
+	const body = {
+		dimensions: state.dimensions,
+		startDate,
+		endDate
+	};
+	const resolvedType = state.searchType ?? searchType;
+	if (resolvedType) body.type = resolvedType;
+	if (state.rowLimit !== void 0) {
+		if (!Number.isInteger(state.rowLimit) || state.rowLimit < 1) return err(queryErrors.invalidRowLimit(state.rowLimit));
+		body.rowLimit = state.rowLimit;
+	}
+	if (state.startRow !== void 0) {
+		if (!Number.isInteger(state.startRow) || state.startRow < 0) return err(queryErrors.invalidStartRow(state.startRow));
+		if (state.startRow > 0) body.startRow = state.startRow;
+	}
+	const hasHour = state.dimensions?.includes("hour");
+	if (hasHour && state.dataState !== "hourly_all") return err(queryErrors.hourDimensionRequiresHourlyState());
+	if (state.dataState === "hourly_all" && !hasHour) return err(queryErrors.hourlyStateRequiresHourDimension());
+	if (state.dataState) body.dataState = state.dataState;
+	const filterGroups = resolveFilter(dimensionFilter);
+	if (filterGroups.length > 0) body.dimensionFilterGroups = filterGroups;
+	if (state.aggregationType) {
+		const groupsByPage = (body.dimensions ?? []).includes("page");
+		const apiLeafFilters = filterGroups.flatMap((g) => g.filters ?? []);
+		const filtersByPage = apiLeafFilters.some((f) => f.dimension === "page");
+		if (state.aggregationType === "byProperty") {
+			if (body.type === "discover" || body.type === "googleNews") return err(queryErrors.byPropertyUnsupportedSearchType());
+			if (groupsByPage || filtersByPage) return err(queryErrors.byPropertyNotAllowedWithPage());
+		}
+		if (state.aggregationType === "byNewsShowcasePanel") {
+			if (body.type !== "discover" && body.type !== "googleNews") return err(queryErrors.byNewsShowcaseRequiresSearchType());
+			if (groupsByPage || filtersByPage) return err(queryErrors.byNewsShowcaseNotAllowedWithPage());
+			const saFilters = apiLeafFilters.filter((f) => f.dimension === "searchAppearance");
+			const hasNewsShowcase = saFilters.some((f) => f.operator === "equals" && f.expression === "NEWS_SHOWCASE");
+			const hasOther = saFilters.some((f) => !(f.operator === "equals" && f.expression === "NEWS_SHOWCASE"));
+			if (!hasNewsShowcase || hasOther) return err(queryErrors.byNewsShowcaseRequiresShowcaseFilter());
+		}
+		body.aggregationType = state.aggregationType;
+	}
+	return ok(body);
+}
+function resolveToBody(state) {
+	return unwrapResult(resolveToBodyResult(state), queryErrorToException);
+}
+function isApiFilter(f) {
+	return !isMetricOperator(f.operator) && !isSpecialOperator(f.operator);
+}
+function resolveFilter(filter) {
+	if (!filter) return [];
+	const groups = [];
+	const groupType = filter._groupType ?? "and";
+	const apiFilters = filter._filters.filter(isApiFilter);
+	if (groupType === "or") {
+		if (apiFilters.length > 0) groups.push({
+			groupType: "or",
+			filters: apiFilters.map((f) => ({
+				dimension: f.dimension,
+				operator: f.operator,
+				expression: f.expression
+			}))
+		});
+	} else if (apiFilters.length > 0) groups.push({ filters: apiFilters.map((f) => ({
+		dimension: f.dimension,
+		operator: f.operator,
+		expression: f.expression
+	})) });
+	if (filter._nestedGroups) for (const nested of filter._nestedGroups) groups.push(...resolveFilter(nested));
+	return groups;
+}
+export { extractDateRange, extractMetricFilters, extractSearchType, extractSpecialOperatorFilters, normalizeBuilderState, normalizeBuilderStateResult, normalizeFilter, resolveToBody, resolveToBodyResult };

package/dist/{_chunks → query}/types.d.mts

@@ -1,27 +1,5 @@
-import { GscAggregationType, GscDataState } from "./contracts.mjs";
-declare const _default: {
-  name: string;
-  'alpha-2': string;
-  'alpha-3': string;
-  'country-code': string;
-}[];
-declare const Devices: {
-  readonly MOBILE: 'MOBILE';
-  readonly DESKTOP: 'DESKTOP';
-  readonly TABLET: 'TABLET';
-};
-type Device = typeof Devices[keyof typeof Devices];
-declare const SearchTypes: {
-  readonly WEB: 'web';
-  readonly IMAGE: 'image';
-  readonly VIDEO: 'video';
-  readonly NEWS: 'news';
-  readonly DISCOVER: 'discover';
-  readonly GOOGLE_NEWS: 'googleNews';
-};
-type SearchType = typeof SearchTypes[keyof typeof SearchTypes];
-declare const Countries: { [K in typeof _default[number]['alpha-3']]: Lowercase<K>; };
-type Country = typeof Countries[keyof typeof Countries];
+import { GscAggregationType, GscDataState } from "../contracts.mjs";
+import { Country, Device, SearchType } from "./constants.mjs";
 interface DimensionValueMap {
   query: string;
   queryCanonical: string;
@@ -109,4 +87,4 @@ interface JsonFilter {
   _groupType?: 'and' | 'or';
 }
 type FilterInput = Filter<any> | JsonFilter;
-export { BuilderState, Column, Countries, Country, Device, Devices, Dimension, DimensionValueMap, Filter, FilterInput, FilterOperator, GSCResult, GSCRow, InternalFilter, JsonFilter, JsonInternalFilter, MergeConstraints, Metric, MetricColumn, MetricOperator, QueryParam, QueryParamName, QueryParamValueMap, SearchType, SearchTypes };
+export { BuilderState, Column, DateOperator, Dimension, DimensionValueMap, Filter, FilterInput, FilterOperator, GSCResult, GSCRow, InternalFilter, JsonFilter, JsonInternalFilter, MergeConstraints, Metric, MetricColumn, MetricOperator, QueryParam, QueryParamName, QueryParamValueMap, SpecialOperator, UnionToIntersection };

package/dist/query/utils/countries.d.mts

@@ -0,0 +1,7 @@
+declare const _default: {
+  name: string;
+  'alpha-2': string;
+  'alpha-3': string;
+  'country-code': string;
+}[];
+export { _default as default };