@useairfoil/producer-google-analytics 0.0.1 → 0.0.2

package/dist/src-Cu0LuOTi.mjs

@@ -0,0 +1,711 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { GoogleAnalyticsConfigDef, manifest } from "./manifest.mjs";
+import { Auth, Connector, ConnectorError, Cursor, Fetch, Iceberg, Metrics, Resource, Telemetry } from "@useairfoil/connector-kit";
+import { Clock, Config, Context, Data, DateTime, Duration, Effect, Exit, Layer, Option, Redacted, Schedule, Schema, SchemaTransformation, Semaphore } from "effect";
+import { HttpClient, HttpClientRequest, HttpClientResponse } from "effect/http";
+import { createPrivateKey, sign } from "node:crypto";
+//#region src/client/auth.ts
+var auth_exports = /* @__PURE__ */ __exportAll({
+	GoogleAnalyticsAuth: () => GoogleAnalyticsAuth,
+	layer: () => layer$2,
+	make: () => make$2,
+	makeAssertion: () => makeAssertion,
+	scope: () => scope,
+	tokenUrl: () => tokenUrl
+});
+var GoogleAnalyticsAuth = class extends Context.Service()("@useairfoil/producer-google-analytics/GoogleAnalyticsAuth") {};
+const tokenUrl = "https://oauth2.googleapis.com/token";
+const scope = "https://www.googleapis.com/auth/analytics.readonly";
+const TokenResponseSchema = Schema.Struct({
+	access_token: Schema.String,
+	expires_in: Schema.Number
+});
+const TokenErrorSchema = Schema.Struct({
+	error: Schema.optional(Schema.String),
+	error_description: Schema.optional(Schema.String)
+});
+const base64Url = (value) => Buffer.from(value).toString("base64url");
+/** Signs the service account JWT with RS256. Google allows at most 1 hour. */
+const makeAssertion = (options) => Effect.try({
+	try: () => {
+		const now = Math.floor(options.nowMillis / 1e3);
+		const signingInput = `${base64Url(JSON.stringify({
+			alg: "RS256",
+			typ: "JWT"
+		}))}.${base64Url(JSON.stringify({
+			iss: options.clientEmail,
+			scope,
+			aud: tokenUrl,
+			iat: now,
+			exp: now + 3600
+		}))}`;
+		const key = createPrivateKey(options.privateKey.replace(/\\n/g, "\n"));
+		return `${signingInput}.${base64Url(sign("sha256", Buffer.from(signingInput), key))}`;
+	},
+	catch: (cause) => new ConnectorError({
+		message: "Invalid Google service account private key",
+		cause
+	})
+});
+const tokenError = (response) => HttpClientResponse.schemaBodyJson(TokenErrorSchema)(response).pipe(Effect.map((body) => body.error), Effect.orElseSucceed(() => void 0), Effect.flatMap((error) => Effect.fail(new ConnectorError({ message: error === "invalid_grant" || error === "invalid_client" ? "Google rejected the service account key" : `Google returned ${response.status} for the OAuth token` }))));
+const make$2 = Effect.fnUntraced(function* (config) {
+	const client = (yield* HttpClient.HttpClient).pipe(HttpClient.retryTransient({
+		schedule: Schedule.exponential("250 millis").pipe(Schedule.jittered),
+		times: 3
+	}));
+	return yield* Auth.makeTokenCache({ acquire: Effect.gen(function* () {
+		const assertion = yield* makeAssertion({
+			clientEmail: config.clientEmail,
+			privateKey: Redacted.value(config.privateKey),
+			nowMillis: yield* Clock.currentTimeMillis
+		});
+		const response = yield* client.execute(HttpClientRequest.post(tokenUrl).pipe(HttpClientRequest.acceptJson, HttpClientRequest.bodyUrlParams({
+			grant_type: "urn:ietf:params:oauth:grant-type:jwt-bearer",
+			assertion
+		}))).pipe(Effect.mapError((cause) => new ConnectorError({
+			message: "Google OAuth token request failed",
+			cause
+		})));
+		const body = yield* HttpClientResponse.matchStatus(response, {
+			"2xx": (ok) => HttpClientResponse.schemaBodyJson(TokenResponseSchema)(ok).pipe(Effect.mapError((cause) => new ConnectorError({
+				message: "Invalid Google OAuth token response",
+				cause
+			}))),
+			orElse: tokenError
+		});
+		return {
+			value: Redacted.make(body.access_token),
+			expiresIn: Duration.seconds(body.expires_in)
+		};
+	}).pipe(Effect.tapError((error) => Telemetry.annotateError("api_auth", error)), Effect.withSpan(Telemetry.SpanName.apiFetch, {
+		kind: "client",
+		attributes: { [Telemetry.Attr.apiPath]: "/token" }
+	})) });
+});
+const layer$2 = (config) => Layer.effect(GoogleAnalyticsAuth)(make$2(config));
+//#endregion
+//#region src/schemas/api.ts
+const ValueSchema = Schema.Struct({ value: Schema.String });
+/** `POST properties/{id}:runReport`. Every value comes as a string. */
+const RunReportResponseSchema = Schema.Struct({
+	dimensionHeaders: Schema.Array(Schema.Struct({ name: Schema.String })),
+	metricHeaders: Schema.Array(Schema.Struct({ name: Schema.String })),
+	rows: Schema.optional(Schema.Array(Schema.Struct({
+		dimensionValues: Schema.Array(ValueSchema),
+		metricValues: Schema.Array(ValueSchema)
+	}))),
+	rowCount: Schema.optional(Schema.Int),
+	metadata: Schema.Struct({
+		timeZone: Schema.String,
+		currencyCode: Schema.optional(Schema.String),
+		dataLossFromOtherRow: Schema.optional(Schema.Boolean),
+		subjectToThresholding: Schema.optional(Schema.Boolean),
+		samplingMetadatas: Schema.optional(Schema.Array(Schema.Unknown)),
+		dataTruncationReasons: Schema.optional(Schema.Array(Schema.Unknown))
+	})
+});
+const ErrorBodySchema = Schema.Struct({ error: Schema.Struct({
+	code: Schema.optional(Schema.Int),
+	message: Schema.optional(Schema.String),
+	status: Schema.optional(Schema.String)
+}) });
+//#endregion
+//#region src/client/client.ts
+var client_exports = /* @__PURE__ */ __exportAll({
+	DATA_API_VERSION: () => DATA_API_VERSION,
+	GoogleAnalyticsClient: () => GoogleAnalyticsClient,
+	layer: () => layer$1,
+	layerConfig: () => layerConfig$1,
+	make: () => make$1
+});
+const DATA_API_VERSION = "v1beta";
+const baseUrl = `https://analyticsdata.googleapis.com/${DATA_API_VERSION}`;
+const maxRetries = 5;
+const retryBaseDelay = Duration.seconds(1);
+const requestTimeout = Duration.minutes(2);
+const limitRetry = Schedule.min([Schedule.exponential("1 minute"), Schedule.spaced("10 minutes")]);
+const maxConcurrent = 5;
+var GoogleAnalyticsClient = class extends Context.Service()("@useairfoil/producer-google-analytics/GoogleAnalyticsClient") {};
+var QuotaExhausted = class extends Data.TaggedError("QuotaExhausted") {};
+const statusError = (response, name) => HttpClientResponse.schemaBodyJson(ErrorBodySchema)(response).pipe(Effect.map((body) => body.error), Effect.orElseSucceed(() => void 0), Effect.flatMap((error) => response.status === 429 ? Effect.fail(new QuotaExhausted({ message: `Google Analytics quota used up for ${name}${error?.message ? `: ${error.message}` : ""}` })) : Effect.fail(new ConnectorError({ message: `Google Analytics API returned ${response.status}${error?.status ? ` ${error.status}` : ""} for ${name}${error?.message ? `: ${error.message}` : ""}` }))), Effect.tapError((error) => Telemetry.annotateError("api_status", error)));
+const make$1 = Effect.fnUntraced(function* (config) {
+	const auth = yield* GoogleAnalyticsAuth;
+	const semaphore = yield* Semaphore.make(maxConcurrent);
+	const client = (yield* HttpClient.HttpClient).pipe(HttpClient.mapRequest(HttpClientRequest.acceptJson), HttpClient.mapRequestEffect((request) => auth.get.pipe(Effect.map((token) => HttpClientRequest.bearerToken(request, Redacted.value(token))))), HttpClient.retryTransient({ schedule: Metrics.retrySchedule({
+		connector: manifest.name,
+		baseDelay: retryBaseDelay,
+		times: maxRetries
+	}) }));
+	const url = `${baseUrl}/properties/${config.propertyId}:runReport`;
+	const runReport = (name, request) => Effect.gen(function* () {
+		const response = yield* client.execute(HttpClientRequest.post(url).pipe(HttpClientRequest.bodyJsonUnsafe({
+			dateRanges: [{
+				startDate: request.startDate,
+				endDate: request.endDate
+			}],
+			dimensions: request.dimensions.map((dimension) => ({ name: dimension })),
+			metrics: request.metrics.map((metric) => ({ name: metric })),
+			orderBys: request.dimensions.map((dimension) => ({ dimension: { dimensionName: dimension } })),
+			limit: request.limit,
+			offset: request.offset
+		}))).pipe(Effect.tapError((error) => Telemetry.annotateError("api_http", error)), Effect.mapError((error) => new ConnectorError({
+			message: `Google Analytics API request failed for ${name}`,
+			cause: error
+		})));
+		return yield* HttpClientResponse.matchStatus(response, {
+			"2xx": (ok) => HttpClientResponse.schemaBodyJson(RunReportResponseSchema)(ok).pipe(Effect.tapError((error) => Telemetry.annotateError("api_decode", error)), Effect.mapError((error) => new ConnectorError({
+				message: `Google Analytics API response for ${name} does not match the schema`,
+				cause: error
+			}))),
+			orElse: (failed) => statusError(failed, name)
+		});
+	}).pipe(Effect.timeoutOrElse({
+		duration: requestTimeout,
+		orElse: () => Effect.fail(new ConnectorError({ message: `Google Analytics API request timed out for ${name}` }))
+	}), semaphore.withPermits(1), Effect.tapErrorTag("QuotaExhausted", (error) => Effect.logWarning(`${error.message}. Waiting to try again.`)), Effect.retry({
+		schedule: limitRetry,
+		while: (error) => error._tag === "QuotaExhausted"
+	}), Effect.catchTag("QuotaExhausted", (error) => Effect.fail(new ConnectorError({ message: error.message }))), Effect.withSpan(Telemetry.SpanName.apiFetch, {
+		kind: "client",
+		attributes: { [Telemetry.Attr.apiPath]: `runReport:${name}` }
+	}));
+	const timeZone = yield* Effect.cachedWithTTL(runReport("time_zone", {
+		dimensions: ["date"],
+		metrics: ["sessions"],
+		startDate: "yesterday",
+		endDate: "yesterday",
+		limit: 1,
+		offset: 0
+	}).pipe(Effect.flatMap((response) => DateTime.zoneMakeNamedEffect(response.metadata.timeZone).pipe(Effect.mapError((cause) => new ConnectorError({
+		message: `Unknown Google Analytics time zone ${response.metadata.timeZone}`,
+		cause
+	}))))), (exit) => Exit.isSuccess(exit) ? Duration.hours(1) : Duration.zero);
+	return GoogleAnalyticsClient.of({
+		runReport,
+		timeZone
+	});
+});
+const layer$1 = (config) => Layer.effect(GoogleAnalyticsClient)(make$1(config)).pipe(Layer.provide(layer$2(config)));
+const layerConfig$1 = (config) => Layer.unwrap(Config.unwrap(config).pipe(Effect.map(layer$1)));
+//#endregion
+//#region src/schemas/shared.ts
+const field = (fieldId, description) => Iceberg.field(fieldId, { description });
+/** The API's `YYYYMMDD` as `YYYY-MM-DD`. */
+const isoDay = (date) => `${date.slice(0, 4)}-${date.slice(4, 6)}-${date.slice(6)}`;
+const ReportDate = Schema.String.check(Schema.isPattern(/^\d{8}$/)).pipe(Schema.decodeTo(Schema.String, SchemaTransformation.transform({
+	decode: isoDay,
+	encode: (date) => date.replaceAll("-", "")
+})));
+/** `TYPE_INTEGER` metrics, as an Iceberg long. */
+const count = (fieldId, description) => Schema.BigIntFromString.pipe(field(fieldId, description));
+/** Float, currency, and seconds metrics, as an Iceberg double. */
+const amount = (fieldId, description) => Schema.FiniteFromString.pipe(field(fieldId, description));
+/** Dimension values are never null. GA uses `(not set)` and `(other)` instead. */
+const dimension = (fieldId, description) => Schema.String.pipe(field(fieldId, description));
+/** `version` is the fetch time, since report rows have no update time. */
+const common = {
+	id: Schema.String.pipe(field(1, "JSON array of the property ID, date, and dimension values.")),
+	version: Schema.Date.pipe(field(2, "Time the row was read from Google Analytics.")),
+	property_id: Schema.String.pipe(field(3, "GA4 property ID.")),
+	date: ReportDate.pipe(field(4, "Day in the property's time zone, as YYYY-MM-DD."))
+};
+const currencyCode = Schema.String.pipe(field(50, "Currency of the revenue fields, the property's currency."));
+//#endregion
+//#region src/resources/reports/read.ts
+const pageSize = 1e5;
+/** `[column, apiName]` pairs, in request order. */
+const pairs = (columns) => Object.entries(columns).flatMap(([column, name]) => name === void 0 ? [] : [[column, name]]);
+const valuesByName = (headers, values) => new Map(headers.map((header, index) => [header.name, values[index]?.value]));
+/** Logs the response flags that mean some data is hidden or estimated. */
+const warnDataLoss = (name, day, metadata) => {
+	const flags = {
+		otherRow: metadata.dataLossFromOtherRow === true,
+		thresholded: metadata.subjectToThresholding === true,
+		sampled: (metadata.samplingMetadatas?.length ?? 0) > 0,
+		truncated: (metadata.dataTruncationReasons?.length ?? 0) > 0
+	};
+	return Object.values(flags).some(Boolean) ? Effect.logWarning("Google Analytics report is incomplete").pipe(Effect.annotateLogs({
+		report: name,
+		day,
+		...flags
+	})) : Effect.void;
+};
+const readDay = (client, propertyId, spec, options) => Effect.gen(function* () {
+	const dimensions = pairs(spec.dimensions);
+	const metrics = pairs(spec.metrics);
+	const columns = [...dimensions, ...metrics];
+	const response = yield* client.runReport(spec.name, {
+		dimensions: ["date", ...dimensions.map(([, name]) => name)],
+		metrics: metrics.map(([, name]) => name),
+		startDate: options.day,
+		endDate: options.day,
+		limit: options.limit ?? pageSize,
+		offset: options.offset
+	});
+	yield* warnDataLoss(spec.name, options.day, response.metadata);
+	const version = yield* DateTime.nowAsDate;
+	const decodeRow = Schema.decodeUnknownEffect(spec.rowSchema);
+	const toRow = (row) => {
+		const values = new Map([...valuesByName(response.dimensionHeaders, row.dimensionValues), ...valuesByName(response.metricHeaders, row.metricValues)]);
+		const date = values.get("date") ?? "";
+		return decodeRow({
+			id: JSON.stringify([
+				propertyId,
+				isoDay(date),
+				...dimensions.map(([, name]) => values.get(name))
+			]),
+			version,
+			property_id: propertyId,
+			date,
+			currency_code: response.metadata.currencyCode,
+			...Object.fromEntries(columns.map(([column, name]) => [column, values.get(name)]))
+		}).pipe(Effect.mapError((cause) => new ConnectorError({
+			message: `Unexpected Google Analytics row in ${spec.name} for ${options.day}`,
+			cause
+		})));
+	};
+	const rows = yield* Effect.forEach(response.rows ?? [], toRow);
+	const read = options.offset + rows.length;
+	return {
+		rows,
+		next: rows.length > 0 && read < (response.rowCount ?? 0) ? Option.some(read) : Option.none()
+	};
+});
+//#endregion
+//#region src/resources/reports/sources.ts
+const changesInterval = Duration.hours(6);
+const Day = Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}$/));
+const addDays = (day, days) => DateTime.formatIsoDateUtc(DateTime.add(DateTime.makeUnsafe(day), { days }));
+/** The calendar day of `time` in the property's time zone. */
+const dayIn = (zone, time) => DateTime.formatIsoDate(DateTime.setZone(time, zone));
+const minDay = (a, b) => a < b ? a : b;
+/** Reports cover whole days, so backfill ends the day before the cutoff. */
+const lastBackfillDay = (zone, cutoff) => addDays(dayIn(zone, cutoff), -1);
+const firstDay = "2015-08-14";
+const startDay = (config, end) => Option.match(config.startDate, {
+	onNone: () => Effect.succeed(DateTime.formatIsoDateUtc(DateTime.add(DateTime.makeUnsafe(end), { years: -2 }))),
+	onSome: (startDate) => Schema.decodeUnknownEffect(Day)(startDate).pipe(Effect.mapError((cause) => new ConnectorError({
+		message: "GA_START_DATE must be YYYY-MM-DD",
+		cause
+	})))
+}).pipe(Effect.map((day) => day < firstDay ? firstDay : day));
+const cursorError = (cause) => new ConnectorError({
+	message: "Invalid Google Analytics cursor",
+	cause
+});
+const PageCursorSchema = Schema.fromJsonString(Schema.Struct({
+	day: Day,
+	offset: Schema.Int
+}));
+/**
+* `through` is the last day fully read. `pending` is set while a run is split:
+* the day and offset to go on from, and the last day of that run.
+*/
+const ChangesCursorSchema = Schema.Struct({
+	through: Day,
+	pending: Schema.optional(Schema.Struct({
+		day: Day,
+		end: Day,
+		offset: Schema.Int
+	}))
+});
+const ChangesCursorCodec = Schema.Union([Schema.fromJsonString(ChangesCursorSchema), Schema.DateTimeUtcFromString]);
+const reportCheck = (client, config, spec) => Effect.gen(function* () {
+	const zone = yield* client.timeZone;
+	const yesterday = addDays(dayIn(zone, yield* DateTime.now), -1);
+	yield* startDay(config, yesterday);
+	yield* readDay(client, config.propertyId, spec, {
+		day: yesterday,
+		offset: 0,
+		limit: 1
+	});
+});
+const reportBackfill = (client, config, spec) => Fetch.page({
+	pageCursor: Cursor.string(),
+	cutoff: Cursor.isoDateTime(),
+	fetch: ({ pageCursor, cutoff }) => Effect.gen(function* () {
+		const zone = yield* client.timeZone;
+		const cutoffTime = yield* Schema.decodeUnknownEffect(Schema.DateTimeUtcFromString)(String(cutoff)).pipe(Effect.mapError(cursorError));
+		const end = lastBackfillDay(zone, cutoffTime);
+		const at = pageCursor === void 0 ? {
+			day: yield* startDay(config, end),
+			offset: 0
+		} : yield* Schema.decodeUnknownEffect(PageCursorSchema)(String(pageCursor)).pipe(Effect.mapError(cursorError));
+		if (at.day > end) return {
+			rows: [],
+			hasMore: false
+		};
+		const page = yield* readDay(client, config.propertyId, spec, at);
+		const next = Option.match(page.next, {
+			onSome: (offset) => ({
+				day: at.day,
+				offset
+			}),
+			onNone: () => ({
+				day: addDays(at.day, 1),
+				offset: 0
+			})
+		});
+		if (next.day > end) return {
+			rows: page.rows,
+			hasMore: false
+		};
+		return {
+			rows: page.rows,
+			hasMore: true,
+			nextPageCursor: yield* Schema.encodeEffect(PageCursorSchema)(next).pipe(Effect.mapError(cursorError))
+		};
+	})
+});
+/**
+* Reads the last `lookbackDays` again on every run, since Google keeps
+* updating recent days. After downtime it also reads the days it missed.
+*/
+const reportChanges = (client, config, spec) => Fetch.changes({
+	cursor: Cursor.string(),
+	interval: changesInterval,
+	fetch: ({ cursor }) => Effect.gen(function* () {
+		const zone = yield* client.timeZone;
+		const decoded = yield* Schema.decodeUnknownEffect(ChangesCursorCodec)(String(cursor)).pipe(Effect.mapError(cursorError));
+		const state = DateTime.isDateTime(decoded) ? { through: lastBackfillDay(zone, decoded) } : decoded;
+		const yesterday = addDays(dayIn(zone, yield* DateTime.now), -1);
+		const window = state.pending ?? {
+			day: minDay(addDays(state.through, 1), addDays(yesterday, 1 - config.lookbackDays)),
+			end: yesterday,
+			offset: 0
+		};
+		const page = yield* readDay(client, config.propertyId, spec, window);
+		const pending = Option.match(page.next, {
+			onSome: (offset) => Option.some({
+				...window,
+				offset
+			}),
+			onNone: () => window.day < window.end ? Option.some({
+				...window,
+				day: addDays(window.day, 1),
+				offset: 0
+			}) : Option.none()
+		});
+		const next = Option.match(pending, {
+			onSome: (pending) => ({
+				through: state.through,
+				pending
+			}),
+			onNone: () => ({ through: window.end })
+		});
+		return {
+			rows: page.rows,
+			cursor: yield* Schema.encodeEffect(Schema.fromJsonString(ChangesCursorSchema))(next).pipe(Effect.mapError(cursorError)),
+			hasMore: Option.isSome(pending)
+		};
+	})
+});
+//#endregion
+//#region src/resources/reports/resource.ts
+const reportEntity = (client, config, spec) => ({
+	name: spec.name,
+	rowSchema: spec.rowSchema,
+	version: "version",
+	check: reportCheck(client, config, spec),
+	backfill: reportBackfill(client, config, spec),
+	changes: reportChanges(client, config, spec)
+});
+//#endregion
+//#region src/schemas/reports.ts
+const DailyOverviewSchema = Schema.Struct({
+	...common,
+	active_users: count(30, "Users who engaged on the day."),
+	new_users: count(31, "Users who came for the first time."),
+	total_users: count(32, "Users who logged any event."),
+	sessions: count(33, "Sessions that started."),
+	engaged_sessions: count(34, "Sessions that lasted 10 seconds or more, or had a key event or 2 page views."),
+	screen_page_views: count(35, "Page and screen views."),
+	event_count: count(36, "Events."),
+	key_events: amount(37, "Key events. Can be fractional after attribution."),
+	total_revenue: amount(38, "Revenue from purchases, subscriptions, and ads."),
+	user_engagement_duration: amount(39, "Seconds the site or app was in the foreground."),
+	currency_code: currencyCode
+}).annotate({ description: "Google Analytics totals per day." }).pipe(Iceberg.identifier("id"));
+const TrafficSourceSchema = Schema.Struct({
+	...common,
+	session_source: dimension(10, "Source of the session, such as google."),
+	session_medium: dimension(11, "Medium of the session, such as organic."),
+	session_campaign_name: dimension(12, "Campaign of the session."),
+	session_default_channel_group: dimension(13, "Default channel group of the session."),
+	sessions: count(30, "Sessions that started."),
+	engaged_sessions: count(31, "Engaged sessions."),
+	active_users: count(32, "Users who engaged."),
+	new_users: count(33, "Users who came for the first time."),
+	screen_page_views: count(34, "Page and screen views."),
+	event_count: count(35, "Events."),
+	key_events: amount(36, "Key events."),
+	total_revenue: amount(37, "Revenue from purchases, subscriptions, and ads."),
+	user_engagement_duration: amount(38, "Seconds the site or app was in the foreground."),
+	currency_code: currencyCode
+}).annotate({ description: "Google Analytics sessions per day and traffic source." }).pipe(Iceberg.identifier("id"));
+const UserAcquisitionSchema = Schema.Struct({
+	...common,
+	first_user_source: dimension(10, "Source that first brought the user."),
+	first_user_medium: dimension(11, "Medium that first brought the user."),
+	first_user_campaign_name: dimension(12, "Campaign that first brought the user."),
+	first_user_default_channel_group: dimension(13, "Default channel group that first brought the user."),
+	new_users: count(30, "Users who came for the first time."),
+	active_users: count(31, "Users who engaged."),
+	sessions: count(32, "Sessions that started."),
+	engaged_sessions: count(33, "Engaged sessions."),
+	key_events: amount(34, "Key events."),
+	total_revenue: amount(35, "Revenue from purchases, subscriptions, and ads."),
+	currency_code: currencyCode
+}).annotate({ description: "Google Analytics users per day and first traffic source." }).pipe(Iceberg.identifier("id"));
+const PageSchema = Schema.Struct({
+	...common,
+	host_name: dimension(10, "Host name, such as www.example.com."),
+	page_path: dimension(11, "Page path, without the query string."),
+	page_title: dimension(12, "Page title."),
+	screen_page_views: count(30, "Page and screen views."),
+	active_users: count(31, "Users who engaged."),
+	event_count: count(32, "Events."),
+	key_events: amount(33, "Key events."),
+	user_engagement_duration: amount(34, "Seconds the page was in the foreground.")
+}).annotate({ description: "Google Analytics page views per day and page." }).pipe(Iceberg.identifier("id"));
+const LandingPageSchema = Schema.Struct({
+	...common,
+	landing_page: dimension(10, "First page path of the session, without the query string."),
+	sessions: count(30, "Sessions that started."),
+	engaged_sessions: count(31, "Engaged sessions."),
+	active_users: count(32, "Users who engaged."),
+	new_users: count(33, "Users who came for the first time."),
+	key_events: amount(34, "Key events."),
+	total_revenue: amount(35, "Revenue from purchases, subscriptions, and ads."),
+	currency_code: currencyCode
+}).annotate({ description: "Google Analytics sessions per day and landing page." }).pipe(Iceberg.identifier("id"));
+const EventSchema = Schema.Struct({
+	...common,
+	event_name: dimension(10, "Event name, such as page_view."),
+	event_count: count(30, "Events."),
+	total_users: count(31, "Users who logged the event."),
+	event_value: amount(32, "Sum of the event's value parameter."),
+	key_events: amount(33, "Key events.")
+}).annotate({ description: "Google Analytics events per day and event name." }).pipe(Iceberg.identifier("id"));
+const LocationSchema = Schema.Struct({
+	...common,
+	country: dimension(10, "Country of the user."),
+	region: dimension(11, "Region of the user."),
+	city: dimension(12, "City of the user."),
+	active_users: count(30, "Users who engaged."),
+	new_users: count(31, "Users who came for the first time."),
+	sessions: count(32, "Sessions that started."),
+	engaged_sessions: count(33, "Engaged sessions."),
+	key_events: amount(34, "Key events."),
+	total_revenue: amount(35, "Revenue from purchases, subscriptions, and ads."),
+	currency_code: currencyCode
+}).annotate({ description: "Google Analytics users per day and location." }).pipe(Iceberg.identifier("id"));
+const DeviceSchema = Schema.Struct({
+	...common,
+	device_category: dimension(10, "Device category: desktop, mobile, or tablet."),
+	platform: dimension(11, "Platform: web, iOS, or Android."),
+	operating_system: dimension(12, "Operating system."),
+	browser: dimension(13, "Browser."),
+	active_users: count(30, "Users who engaged."),
+	new_users: count(31, "Users who came for the first time."),
+	sessions: count(32, "Sessions that started."),
+	engaged_sessions: count(33, "Engaged sessions."),
+	screen_page_views: count(34, "Page and screen views."),
+	key_events: amount(35, "Key events.")
+}).annotate({ description: "Google Analytics users per day and device." }).pipe(Iceberg.identifier("id"));
+const EcommerceItemSchema = Schema.Struct({
+	...common,
+	item_id: dimension(10, "Item ID."),
+	item_name: dimension(11, "Item name."),
+	item_brand: dimension(12, "Item brand."),
+	item_category: dimension(13, "First item category."),
+	items_viewed: count(30, "Units viewed."),
+	items_added_to_cart: count(31, "Units added to carts."),
+	items_purchased: count(32, "Units purchased."),
+	item_revenue: amount(33, "Revenue from the item, without tax and shipping."),
+	currency_code: currencyCode
+}).annotate({ description: "Google Analytics ecommerce items per day. Empty without ecommerce events." }).pipe(Iceberg.identifier("id"));
+//#endregion
+//#region src/resources/reports/specs.ts
+const dailyOverview = {
+	name: "daily_overview",
+	dimensions: {},
+	metrics: {
+		active_users: "activeUsers",
+		new_users: "newUsers",
+		total_users: "totalUsers",
+		sessions: "sessions",
+		engaged_sessions: "engagedSessions",
+		screen_page_views: "screenPageViews",
+		event_count: "eventCount",
+		key_events: "keyEvents",
+		total_revenue: "totalRevenue",
+		user_engagement_duration: "userEngagementDuration"
+	},
+	rowSchema: DailyOverviewSchema
+};
+const trafficSources = {
+	name: "traffic_sources",
+	dimensions: {
+		session_source: "sessionSource",
+		session_medium: "sessionMedium",
+		session_campaign_name: "sessionCampaignName",
+		session_default_channel_group: "sessionDefaultChannelGroup"
+	},
+	metrics: {
+		sessions: "sessions",
+		engaged_sessions: "engagedSessions",
+		active_users: "activeUsers",
+		new_users: "newUsers",
+		screen_page_views: "screenPageViews",
+		event_count: "eventCount",
+		key_events: "keyEvents",
+		total_revenue: "totalRevenue",
+		user_engagement_duration: "userEngagementDuration"
+	},
+	rowSchema: TrafficSourceSchema
+};
+const userAcquisition = {
+	name: "user_acquisition",
+	dimensions: {
+		first_user_source: "firstUserSource",
+		first_user_medium: "firstUserMedium",
+		first_user_campaign_name: "firstUserCampaignName",
+		first_user_default_channel_group: "firstUserDefaultChannelGroup"
+	},
+	metrics: {
+		new_users: "newUsers",
+		active_users: "activeUsers",
+		sessions: "sessions",
+		engaged_sessions: "engagedSessions",
+		key_events: "keyEvents",
+		total_revenue: "totalRevenue"
+	},
+	rowSchema: UserAcquisitionSchema
+};
+const pages = {
+	name: "pages",
+	dimensions: {
+		host_name: "hostName",
+		page_path: "pagePath",
+		page_title: "pageTitle"
+	},
+	metrics: {
+		screen_page_views: "screenPageViews",
+		active_users: "activeUsers",
+		event_count: "eventCount",
+		key_events: "keyEvents",
+		user_engagement_duration: "userEngagementDuration"
+	},
+	rowSchema: PageSchema
+};
+const landingPages = {
+	name: "landing_pages",
+	dimensions: { landing_page: "landingPage" },
+	metrics: {
+		sessions: "sessions",
+		engaged_sessions: "engagedSessions",
+		active_users: "activeUsers",
+		new_users: "newUsers",
+		key_events: "keyEvents",
+		total_revenue: "totalRevenue"
+	},
+	rowSchema: LandingPageSchema
+};
+const events = {
+	name: "events",
+	dimensions: { event_name: "eventName" },
+	metrics: {
+		event_count: "eventCount",
+		total_users: "totalUsers",
+		event_value: "eventValue",
+		key_events: "keyEvents"
+	},
+	rowSchema: EventSchema
+};
+const locations = {
+	name: "locations",
+	dimensions: {
+		country: "country",
+		region: "region",
+		city: "city"
+	},
+	metrics: {
+		active_users: "activeUsers",
+		new_users: "newUsers",
+		sessions: "sessions",
+		engaged_sessions: "engagedSessions",
+		key_events: "keyEvents",
+		total_revenue: "totalRevenue"
+	},
+	rowSchema: LocationSchema
+};
+const devices = {
+	name: "devices",
+	dimensions: {
+		device_category: "deviceCategory",
+		platform: "platform",
+		operating_system: "operatingSystem",
+		browser: "browser"
+	},
+	metrics: {
+		active_users: "activeUsers",
+		new_users: "newUsers",
+		sessions: "sessions",
+		engaged_sessions: "engagedSessions",
+		screen_page_views: "screenPageViews",
+		key_events: "keyEvents"
+	},
+	rowSchema: DeviceSchema
+};
+const ecommerceItems = {
+	name: "ecommerce_items",
+	dimensions: {
+		item_id: "itemId",
+		item_name: "itemName",
+		item_brand: "itemBrand",
+		item_category: "itemCategory"
+	},
+	metrics: {
+		items_viewed: "itemsViewed",
+		items_added_to_cart: "itemsAddedToCart",
+		items_purchased: "itemsPurchased",
+		item_revenue: "itemRevenue"
+	},
+	rowSchema: EcommerceItemSchema
+};
+//#endregion
+//#region src/connector.ts
+var connector_exports = /* @__PURE__ */ __exportAll({
+	GoogleAnalyticsConfigDef: () => GoogleAnalyticsConfigDef,
+	GoogleAnalyticsConnector: () => GoogleAnalyticsConnector,
+	layer: () => layer,
+	layerConfig: () => layerConfig,
+	make: () => make,
+	manifest: () => manifest
+});
+const make = Effect.fnUntraced(function* (config) {
+	const client = yield* GoogleAnalyticsClient;
+	return Connector.define({
+		name: "producer-google-analytics",
+		title: "Google Analytics",
+		resources: [
+			Resource.entity(reportEntity(client, config, dailyOverview)),
+			Resource.entity(reportEntity(client, config, trafficSources)),
+			Resource.entity(reportEntity(client, config, userAcquisition)),
+			Resource.entity(reportEntity(client, config, pages)),
+			Resource.entity(reportEntity(client, config, landingPages)),
+			Resource.entity(reportEntity(client, config, events)),
+			Resource.entity(reportEntity(client, config, locations)),
+			Resource.entity(reportEntity(client, config, devices)),
+			Resource.entity(reportEntity(client, config, ecommerceItems))
+		]
+	});
+});
+var GoogleAnalyticsConnector = class extends Context.Service()("@useairfoil/producer-google-analytics/GoogleAnalyticsConnector") {};
+const layer = (config) => Layer.effect(GoogleAnalyticsConnector)(make(config).pipe(Effect.annotateLogs({ component: "google-analytics" }))).pipe(Layer.provide(layer$1(config)));
+const layerConfig = (config) => Layer.unwrap(Config.unwrap(config).pipe(Effect.map(layer)));
+//#endregion
+export { DeviceSchema as a, LandingPageSchema as c, TrafficSourceSchema as d, UserAcquisitionSchema as f, DailyOverviewSchema as i, LocationSchema as l, auth_exports as m, connector_exports as n, EcommerceItemSchema as o, client_exports as p, layerConfig as r, EventSchema as s, GoogleAnalyticsConnector as t, PageSchema as u };
+
+//# sourceMappingURL=src-Cu0LuOTi.mjs.map