gscdump 0.1.2 → 0.2.0

package/dist/query/index.d.mts

@@ -1,45 +1,11 @@
-import "ofetch";
-import { indexing_v3 } from "@googleapis/indexing/v3";
+import _dayjs, { Dayjs } from "dayjs";
 import { searchconsole_v1 } from "@googleapis/searchconsole/v1";
 
 //#region src/core/types.d.ts
-type ApiSite = searchconsole_v1.Schema$WmxSite;
-type ApiSitemap = searchconsole_v1.Schema$WmxSitemap;
-type SearchAnalyticsQuery = searchconsole_v1.Schema$SearchAnalyticsQueryRequest;
-type SearchAnalyticsResponse = searchconsole_v1.Schema$SearchAnalyticsQueryResponse;
-type InspectUrlIndexResponse = searchconsole_v1.Schema$InspectUrlIndexResponse;
-type UrlNotificationMetadata = indexing_v3.Schema$UrlNotificationMetadata;
-type PublishUrlNotificationResponse = indexing_v3.Schema$PublishUrlNotificationResponse;
-//#endregion
-//#region src/core/client.d.ts
 
-interface GoogleSearchConsoleClient {
-  sites: {
-    list: () => Promise<{
-      siteEntry?: ApiSite[];
-    }>;
-  };
-  sitemaps: {
-    list: (siteUrl: string) => Promise<{
-      sitemap?: ApiSitemap[];
-    }>;
-    get: (siteUrl: string, feedpath: string) => Promise<ApiSitemap>;
-    submit: (siteUrl: string, feedpath: string) => Promise<void>;
-    delete: (siteUrl: string, feedpath: string) => Promise<void>;
-  };
-  searchAnalytics: {
-    query: (siteUrl: string, body: SearchAnalyticsQuery) => Promise<SearchAnalyticsResponse>;
-  };
-  urlInspection: {
-    inspect: (siteUrl: string, inspectionUrl: string) => Promise<InspectUrlIndexResponse>;
-  };
-  indexing: {
-    publish: (url: string, type: 'URL_UPDATED' | 'URL_DELETED') => Promise<PublishUrlNotificationResponse>;
-    getMetadata: (url: string) => Promise<UrlNotificationMetadata>;
-  };
-}
+type SearchAnalyticsQuery = searchconsole_v1.Schema$SearchAnalyticsQueryRequest;
 //#endregion
-//#region src/utils/countries.d.ts
+//#region src/query/utils/countries.d.ts
 declare const _default: {
   name: string;
   'alpha-2': string;
@@ -48,14 +14,21 @@ declare const _default: {
 }[];
 //#endregion
 //#region src/query/constants.d.ts
-declare const Device: {
+declare const Devices: {
   readonly MOBILE: "MOBILE";
   readonly DESKTOP: "DESKTOP";
   readonly TABLET: "TABLET";
 };
-type Device = typeof Device[keyof typeof Device];
-declare const Country: { [K in (typeof _default)[number]["alpha-3"]]: Lowercase<K> };
-type Country = typeof Country[keyof typeof Country];
+type Device = typeof Devices[keyof typeof Devices];
+declare const SearchTypes: {
+  readonly WEB: "web";
+  readonly IMAGE: "image";
+  readonly VIDEO: "video";
+  readonly NEWS: "news";
+};
+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];
 //#endregion
 //#region src/query/types.d.ts
 interface DimensionValueMap {
@@ -67,15 +40,24 @@ interface DimensionValueMap {
   date: string;
 }
 type Dimension = keyof DimensionValueMap;
+interface QueryParamValueMap {
+  searchType: SearchType;
+}
+type QueryParamName = keyof QueryParamValueMap;
 declare const ColumnBrand: unique symbol;
 interface Column<D extends Dimension> {
   readonly [ColumnBrand]: D;
   readonly dimension: D;
 }
+declare const QueryParamBrand: unique symbol;
+interface QueryParam<P extends QueryParamName> {
+  readonly [QueryParamBrand]: P;
+  readonly param: P;
+}
 type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'includingRegex' | 'excludingRegex';
 type DateOperator = 'gte' | 'gt' | 'lte' | 'lt' | 'between';
 interface InternalFilter {
-  dimension: Dimension;
+  dimension: Dimension | QueryParamName;
   operator: FilterOperator | DateOperator;
   expression: string;
   expression2?: string;
@@ -85,6 +67,7 @@ interface Filter<C = object> {
   readonly [FilterBrand]: true;
   readonly _constraints: C;
   readonly _filters: InternalFilter[];
+  readonly _nestedGroups?: Filter<any>[];
   readonly _groupType?: 'and' | 'or';
 }
 type MergeConstraints<F extends Filter<any>[]> = UnionToIntersection<F[number]['_constraints']>;
@@ -100,8 +83,7 @@ type GSCRow<D extends Dimension[], C> = { [K in D[number]]: K extends keyof C ?
 };
 interface BuilderState {
   dimensions: Dimension[];
-  filters: Filter<any>[];
-  siteUrl?: string;
+  filter?: Filter<any>;
   rowLimit?: number;
   startRow?: number;
 }
@@ -110,12 +92,9 @@ interface BuilderState {
 interface GSCQueryBuilder<D extends Dimension[] = [], C = object> {
   select: <T extends Dimension[]>(...dims: T) => GSCQueryBuilder<T, C>;
   where: <F extends Filter<any>>(filter: F) => GSCQueryBuilder<D, C & F['_constraints']>;
-  siteUrl: (url: string) => GSCQueryBuilder<D, C>;
   limit: (n: number) => GSCQueryBuilder<D, C>;
   offset: (n: number) => GSCQueryBuilder<D, C>;
-  execute: (client: GoogleSearchConsoleClient) => Promise<GSCResult<D, C>>;
   toBody: () => SearchAnalyticsQuery;
-  /** Expose internal state for analysis functions to merge with */
   getState: () => BuilderState;
 }
 declare const gsc: GSCQueryBuilder<[], object>;
@@ -127,9 +106,11 @@ declare const device: Column<"device">;
 declare const country: Column<"country">;
 declare const searchAppearance: Column<"searchAppearance">;
 declare const date: Column<"date">;
+declare const searchType: QueryParam<"searchType">;
 //#endregion
 //#region src/query/operators.d.ts
 declare function eq<D extends Dimension, V extends DimensionValueMap[D]>(column: Column<D>, value: V): Filter<Record<D, V>>;
+declare function eq<P extends QueryParamName, V extends QueryParamValueMap[P]>(param: QueryParam<P>, value: V): Filter<Record<P, V>>;
 declare function ne<D extends Dimension>(column: Column<D>, value: DimensionValueMap[D]): Filter<object>;
 declare function inArray<D extends Dimension, V extends DimensionValueMap[D]>(column: Column<D>, values: readonly V[]): Filter<Record<D, V>>;
 declare function contains<D extends Dimension>(column: Column<D>, pattern: string): Filter<object>;
@@ -146,12 +127,18 @@ declare function lt<D extends Dimension>(column: Column<D>, value: DimensionValu
 declare function between<D extends Dimension>(column: Column<D>, start: DimensionValueMap[D], end: DimensionValueMap[D]): Filter<object>;
 //#endregion
 //#region src/query/resolver.d.ts
-/**
- * Extract date range from filters. Used by analysis functions to get the period.
- */
-declare function extractDateRange(filters: Filter<any>[]): {
+declare function extractDateRange(filter?: Filter<any>): {
   startDate?: string;
   endDate?: string;
 };
 //#endregion
-export { type BuilderState, type Column, Country, type Country as CountryType, Device, type Device as DeviceType, type Dimension, type DimensionValueMap, type Filter, type GSCQueryBuilder, type GSCResult, type GSCRow, and, between, contains, country, date, device, eq, extractDateRange, gsc, gt, gte, inArray, like, lt, lte, ne, not, notRegex, or, page, query, regex, searchAppearance };
+//#region src/query/utils/dayjs.d.ts
+declare function dayjs(date?: _dayjs.ConfigType): Dayjs;
+declare function currentPstDate(): string;
+declare function dayjsPst(): Dayjs;
+//#endregion
+//#region src/query/index.d.ts
+declare function today(): string;
+declare function daysAgo(n: number): string;
+//#endregion
+export { type BuilderState, type Column, Countries, type Country, type Device, Devices, type Dimension, type DimensionValueMap, type Filter, type GSCQueryBuilder, type GSCResult, type GSCRow, type QueryParam, type QueryParamName, type QueryParamValueMap, type SearchType, SearchTypes, and, between, contains, country, currentPstDate, date, dayjs, dayjsPst, daysAgo, device, eq, extractDateRange, gsc, gt, gte, inArray, like, lt, lte, ne, not, notRegex, or, page, query, regex, searchAppearance, searchType, today };

package/dist/query/index.mjs

@@ -1,3 +1,21 @@
+import _dayjs from "dayjs";
+import timezone from "dayjs/plugin/timezone.js";
+import utc from "dayjs/plugin/utc.js";
+
+//#region src/query/utils/dayjs.ts
+_dayjs.extend(utc);
+_dayjs.extend(timezone);
+function dayjs(date$1) {
+	return _dayjs(date$1);
+}
+function currentPstDate() {
+	return dayjs().tz("America/Los_Angeles").hour(12).minute(0).second(0).format("YYYY-MM-DD");
+}
+function dayjsPst() {
+	return dayjs().tz("America/Los_Angeles").hour(12).minute(0).second(0);
+}
+
+//#endregion
 //#region src/query/resolver.ts
 const DATE_OPERATORS = [
 	"gte",
@@ -6,110 +24,110 @@ const DATE_OPERATORS = [
 	"lt",
 	"between"
 ];
+const QUERY_PARAMS = ["searchType"];
 function isDateOperator(op) {
 	return DATE_OPERATORS.includes(op);
 }
+function isQueryParam(dim) {
+	return QUERY_PARAMS.includes(dim);
+}
 function addDays(dateStr, days) {
 	const d = new Date(dateStr);
 	d.setDate(d.getDate() + days);
 	return d.toISOString().split("T")[0];
 }
-/**
-* Extract date range from filters. Used by analysis functions to get the period.
-*/
-function extractDateRange(filters) {
-	const { startDate, endDate } = extractDateFilters(filters);
-	return {
-		startDate,
-		endDate
-	};
-}
-function extractDateFilters(filters) {
+function extractSpecialFilters(filter) {
+	if (!filter) return {};
 	let startDate;
 	let endDate;
-	const nonDateFilters = [];
-	for (const filter of filters) {
-		const dateFilters = [];
-		const otherFilters = [];
-		for (const f of filter._filters) if (f.dimension === "date" && isDateOperator(f.operator)) dateFilters.push(f);
-		else otherFilters.push(f);
-		for (const df of dateFilters) switch (df.operator) {
-			case "gte":
-				startDate = df.expression;
-				break;
-			case "gt":
-				startDate = addDays(df.expression, 1);
-				break;
-			case "lte":
-				endDate = df.expression;
-				break;
-			case "lt":
-				endDate = addDays(df.expression, -1);
-				break;
-			case "between":
-				startDate = df.expression;
-				endDate = df.expression2;
-				break;
-		}
-		if (otherFilters.length > 0) nonDateFilters.push({
-			...filter,
-			_filters: otherFilters
-		});
+	let searchType$1;
+	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$1 = f.expression;
+	} else otherFilters.push(f);
+	if (filter._nestedGroups) for (const nested of filter._nestedGroups) {
+		const extracted = extractSpecialFilters(nested);
+		if (extracted.startDate) startDate = extracted.startDate;
+		if (extracted.endDate) endDate = extracted.endDate;
+		if (extracted.searchType) searchType$1 = 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,
-		nonDateFilters
+		searchType: searchType$1,
+		dimensionFilter
+	};
+}
+function extractDateRange(filter) {
+	const { startDate, endDate } = extractSpecialFilters(filter);
+	return {
+		startDate,
+		endDate
 	};
 }
 function resolveToBody(state) {
-	const { startDate, endDate, nonDateFilters } = extractDateFilters(state.filters);
-	if (!startDate || !endDate) throw new Error("Date range required: use .where(between(date, start, end)) or .where(gte(date, start)).where(lte(date, end))");
+	const { startDate, endDate, searchType: searchType$1, dimensionFilter } = extractSpecialFilters(state.filter);
+	if (!startDate || !endDate) throw new Error("Date range required: use .where(between(date, start, end)) or .where(and(gte(date, start), lte(date, end)))");
 	const body = {
 		dimensions: state.dimensions,
 		startDate,
 		endDate
 	};
+	if (searchType$1) body.searchType = searchType$1;
 	if (state.rowLimit) body.rowLimit = state.rowLimit;
 	if (state.startRow) body.startRow = state.startRow;
-	const filterGroups = resolveFilters(nonDateFilters);
+	const filterGroups = resolveFilter(dimensionFilter);
 	if (filterGroups.length > 0) body.dimensionFilterGroups = filterGroups;
 	return body;
 }
-function resolveFilters(filters) {
+function resolveFilter(filter) {
+	if (!filter) return [];
 	const groups = [];
-	for (const filter of filters) if ((filter._groupType ?? "and") === "or" && filter._filters.length > 1) groups.push({
-		groupType: "or",
-		filters: filter._filters.map((f) => ({
-			dimension: f.dimension,
-			operator: f.operator,
-			expression: f.expression
-		}))
-	});
-	else if (filter._filters.length > 0) groups.push({ filters: filter._filters.map((f) => ({
+	if ((filter._groupType ?? "and") === "or") {
+		if (filter._filters.length > 0) groups.push({
+			groupType: "or",
+			filters: filter._filters.map((f) => ({
+				dimension: f.dimension,
+				operator: f.operator,
+				expression: f.expression
+			}))
+		});
+	} else if (filter._filters.length > 0) groups.push({ filters: filter._filters.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;
 }
 
 //#endregion
 //#region src/query/builder.ts
-function transformResponse(response, dimensions) {
-	return { rows: (response.rows ?? []).map((row) => {
-		const result = {
-			clicks: row.clicks,
-			impressions: row.impressions,
-			ctr: row.ctr,
-			position: row.position
-		};
-		dimensions.forEach((dim, i) => {
-			result[dim] = row.keys?.[i];
-		});
-		return result;
-	}) };
-}
 function createBuilder(state) {
 	return {
 		select(...dims) {
@@ -121,13 +139,7 @@ function createBuilder(state) {
 		where(filter) {
 			return createBuilder({
 				...state,
-				filters: [...state.filters, filter]
-			});
-		},
-		siteUrl(url) {
-			return createBuilder({
-				...state,
-				siteUrl: url
+				filter
 			});
 		},
 		limit(n) {
@@ -142,10 +154,6 @@ function createBuilder(state) {
 				startRow: n
 			});
 		},
-		async execute(client) {
-			const body = resolveToBody(state);
-			return transformResponse(await client.searchAnalytics.query(state.siteUrl, body), state.dimensions);
-		},
 		toBody() {
 			return resolveToBody(state);
 		},
@@ -154,25 +162,26 @@ function createBuilder(state) {
 		}
 	};
 }
-const gsc = createBuilder({
-	dimensions: [],
-	filters: []
-});
+const gsc = createBuilder({ dimensions: [] });
 
 //#endregion
 //#region src/query/columns.ts
 function createColumn(dimension) {
 	return { dimension };
 }
+function createQueryParam(param) {
+	return { param };
+}
 const page = createColumn("page");
 const query = createColumn("query");
 const device = createColumn("device");
 const country = createColumn("country");
 const searchAppearance = createColumn("searchAppearance");
 const date = createColumn("date");
+const searchType = createQueryParam("searchType");
 
 //#endregion
-//#region src/utils/countries.ts
+//#region src/query/utils/countries.ts
 var countries_default = [
 	{
 		"name": "Afghanistan",
@@ -1672,20 +1681,26 @@ var countries_default = [
 
 //#endregion
 //#region src/query/constants.ts
-const Device = {
+const Devices = {
 	MOBILE: "MOBILE",
 	DESKTOP: "DESKTOP",
 	TABLET: "TABLET"
 };
-const Country = Object.fromEntries(countries_default.map((c) => [c["alpha-3"], c["alpha-3"].toLowerCase()]));
+const SearchTypes = {
+	WEB: "web",
+	IMAGE: "image",
+	VIDEO: "video",
+	NEWS: "news"
+};
+const Countries = Object.fromEntries(countries_default.map((c) => [c["alpha-3"], c["alpha-3"].toLowerCase()]));
 
 //#endregion
 //#region src/query/operators.ts
-function eq(column, value) {
+function eq(columnOrParam, value) {
 	return {
 		_constraints: {},
 		_filters: [{
-			dimension: column.dimension,
+			dimension: "dimension" in columnOrParam ? columnOrParam.dimension : columnOrParam.param,
 			operator: "equals",
 			expression: String(value)
 		}]
@@ -1753,9 +1768,17 @@ function notRegex(column, pattern) {
 	};
 }
 function and(...filters) {
+	const flatFilters = [];
+	const nestedGroups = [];
+	for (const f of filters) if (f._groupType === "or") nestedGroups.push(f);
+	else {
+		flatFilters.push(...f._filters);
+		if (f._nestedGroups) nestedGroups.push(...f._nestedGroups);
+	}
 	return {
 		_constraints: {},
-		_filters: filters.flatMap((f) => f._filters),
+		_filters: flatFilters,
+		_nestedGroups: nestedGroups.length > 0 ? nestedGroups : void 0,
 		_groupType: "and"
 	};
 }
@@ -1845,4 +1868,13 @@ function between(column, start, end) {
 }
 
 //#endregion
-export { Country, Device, and, between, contains, country, date, device, eq, extractDateRange, gsc, gt, gte, inArray, like, lt, lte, ne, not, notRegex, or, page, query, regex, searchAppearance };
+//#region src/query/index.ts
+function today() {
+	return currentPstDate();
+}
+function daysAgo(n) {
+	return dayjsPst().subtract(n, "day").format("YYYY-MM-DD");
+}
+
+//#endregion
+export { Countries, Devices, SearchTypes, and, between, contains, country, currentPstDate, date, dayjs, dayjsPst, daysAgo, device, eq, extractDateRange, gsc, gt, gte, inArray, like, lt, lte, ne, not, notRegex, or, page, query, regex, searchAppearance, searchType, today };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gscdump",
   "type": "module",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Google Search Console API wrapper with typed query builder, streaming pagination, and SEO analysis functions",
   "author": {
     "name": "Harlan Wilton",
@@ -39,6 +39,10 @@
     "./query": {
       "types": "./dist/query/index.d.mts",
       "import": "./dist/query/index.mjs"
+    },
+    "./analysis": {
+      "types": "./dist/analysis/index.d.mts",
+      "import": "./dist/analysis/index.mjs"
     }
   },
   "main": "./dist/index.mjs",