@useairfoil/producer-google-analytics 0.0.1 → 0.0.2

package/src/resources/reports/sources.ts

@@ -0,0 +1,169 @@
+import { ConnectorError, Cursor, Fetch } from "@useairfoil/connector-kit";
+import { DateTime, Duration, Effect, Option, Schema } from "effect";
+
+import type { GoogleAnalyticsClientService } from "../../client/client";
+import type { GoogleAnalyticsConfig } from "../../manifest";
+import type { ReportSpec } from "./spec";
+
+import { readDay } from "./read";
+
+// Daily data is ready about 12 hours after the day ends, so polling more often
+// mostly reads the same numbers.
+const changesInterval = Duration.hours(6);
+
+type ReportConfig = Pick<GoogleAnalyticsConfig, "propertyId" | "startDate" | "lookbackDays">;
+
+const Day = Schema.String.check(Schema.isPattern(/^\d{4}-\d{2}-\d{2}$/));
+
+const addDays = (day: string, days: number) =>
+  DateTime.formatIsoDateUtc(DateTime.add(DateTime.makeUnsafe(day), { days }));
+
+/** The calendar day of `time` in the property's time zone. */
+const dayIn = (zone: DateTime.TimeZone, time: DateTime.DateTime) =>
+  DateTime.formatIsoDate(DateTime.setZone(time, zone));
+
+const minDay = (a: string, b: string) => (a < b ? a : b);
+
+/** Reports cover whole days, so backfill ends the day before the cutoff. */
+const lastBackfillDay = (zone: DateTime.TimeZone, cutoff: DateTime.Utc) =>
+  addDays(dayIn(zone, cutoff), -1);
+
+// The API rejects earlier days.
+const firstDay = "2015-08-14";
+
+const startDay = (config: ReportConfig, end: string) =>
+  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: Schema.SchemaError) =>
+  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 })),
+});
+
+type ChangesCursor = Schema.Schema.Type<typeof ChangesCursorSchema>;
+
+// The first cursor is the backfill cutoff, a plain ISO time.
+const ChangesCursorCodec = Schema.Union([
+  Schema.fromJsonString(ChangesCursorSchema),
+  Schema.DateTimeUtcFromString,
+]);
+
+export const reportCheck = <Row extends object>(
+  client: GoogleAnalyticsClientService,
+  config: ReportConfig,
+  spec: ReportSpec<Row>,
+) =>
+  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 });
+  });
+
+export const reportBackfill = <Row extends object>(
+  client: GoogleAnalyticsClientService,
+  config: ReportConfig,
+  spec: ReportSpec<Row>,
+) =>
+  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 === undefined
+            ? { 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.
+ */
+export const reportChanges = <Row extends object>(
+  client: GoogleAnalyticsClientService,
+  config: ReportConfig,
+  spec: ReportSpec<Row>,
+) =>
+  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: ChangesCursor = 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: ChangesCursor = 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),
+        };
+      }),
+  });

package/src/resources/reports/spec.ts

@@ -0,0 +1,15 @@
+import type { Identified } from "@useairfoil/connector-kit";
+import type { Schema } from "effect";
+
+/** API names by column, in request order. */
+export type Columns<Row> = { readonly [Column in keyof Row & string]?: string };
+
+export type ReportSpec<Row extends object> = {
+  /** Resource name, such as `traffic_sources`. */
+  readonly name: string;
+  /** Every report also asks for `date`. */
+  readonly dimensions: Columns<Row>;
+  /** At most 10. */
+  readonly metrics: Columns<Row>;
+  readonly rowSchema: Schema.Decoder<Row> & Identified<"id">;
+};

package/src/resources/reports/specs.ts

@@ -0,0 +1,173 @@
+import type { ReportSpec } from "./spec";
+
+import {
+  type DailyOverview,
+  DailyOverviewSchema,
+  type Device,
+  DeviceSchema,
+  type EcommerceItem,
+  EcommerceItemSchema,
+  type Event,
+  EventSchema,
+  type LandingPage,
+  LandingPageSchema,
+  type Location,
+  LocationSchema,
+  type Page,
+  PageSchema,
+  type TrafficSource,
+  TrafficSourceSchema,
+  type UserAcquisition,
+  UserAcquisitionSchema,
+} from "../../schemas/reports";
+
+// Every pair here is one Google shows together in its own reports. Check new
+// ones with `checkCompatibility` first.
+
+export const dailyOverview: ReportSpec<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,
+};
+
+export const trafficSources: ReportSpec<TrafficSource> = {
+  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,
+};
+
+export const userAcquisition: ReportSpec<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,
+};
+
+export const pages: ReportSpec<Page> = {
+  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,
+};
+
+export const landingPages: ReportSpec<LandingPage> = {
+  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,
+};
+
+export const events: ReportSpec<Event> = {
+  name: "events",
+  dimensions: { event_name: "eventName" },
+  metrics: {
+    event_count: "eventCount",
+    total_users: "totalUsers",
+    event_value: "eventValue",
+    key_events: "keyEvents",
+  },
+  rowSchema: EventSchema,
+};
+
+export const locations: ReportSpec<Location> = {
+  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,
+};
+
+export const devices: ReportSpec<Device> = {
+  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,
+};
+
+export const ecommerceItems: ReportSpec<EcommerceItem> = {
+  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,
+};

package/src/sandbox.ts

@@ -0,0 +1,37 @@
+import {
+  ConnectorApp,
+  Ingestor,
+  RuntimeConfig,
+  StateStore,
+  Telemetry,
+} from "@useairfoil/connector-kit";
+import { Effect, Layer, Logger } from "effect";
+import { Command } from "effect/cli";
+
+import { GoogleAnalyticsConnector } from "./index";
+
+const ConnectorLayer = GoogleAnalyticsConnector.layerConfig(
+  GoogleAnalyticsConnector.GoogleAnalyticsConfigDef.config,
+);
+
+const TelemetryLayer = Layer.mergeAll(Telemetry.layerOtlp(), Telemetry.layerMetricsConsoleDump());
+
+export const sandboxCommand = Command.make("sandbox", {}, () =>
+  Effect.gen(function* () {
+    const port = yield* RuntimeConfig.httpPort;
+    const entrypoint = yield* GoogleAnalyticsConnector.GoogleAnalyticsConnector;
+
+    return yield* ConnectorApp.start(entrypoint, { port });
+  }).pipe(
+    Effect.annotateLogs({ component: "google-analytics" }),
+    Effect.provide(
+      Layer.mergeAll(
+        StateStore.layerMemory,
+        Ingestor.layerConsole,
+        ConnectorLayer,
+        Logger.layer([Logger.consolePretty()]),
+        TelemetryLayer,
+      ),
+    ),
+  ),
+).pipe(Command.withDescription("Run the connector locally and log ingested data"));

package/src/schemas/api.ts

@@ -0,0 +1,37 @@
+import { Schema } from "effect";
+
+const ValueSchema = Schema.Struct({ value: Schema.String });
+
+/** `POST properties/{id}:runReport`. Every value comes as a string. */
+export 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),
+      }),
+    ),
+  ),
+  // Left out when the report is empty.
+  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)),
+  }),
+});
+
+export type RunReportResponse = Schema.Schema.Type<typeof RunReportResponseSchema>;
+
+export const ErrorBodySchema = Schema.Struct({
+  error: Schema.Struct({
+    code: Schema.optional(Schema.Int),
+    message: Schema.optional(Schema.String),
+    status: Schema.optional(Schema.String),
+  }),
+});

package/src/schemas/reports.ts

@@ -0,0 +1,172 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema } from "effect";
+
+import { amount, common, count, currencyCode, dimension } from "./shared";
+
+// User counts are distinct users, so they don't add up across rows or days.
+
+export 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"));
+
+export type DailyOverview = Schema.Schema.Type<typeof DailyOverviewSchema>;
+
+export 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"));
+
+export type TrafficSource = Schema.Schema.Type<typeof TrafficSourceSchema>;
+
+export 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"));
+
+export type UserAcquisition = Schema.Schema.Type<typeof UserAcquisitionSchema>;
+
+export 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"));
+
+export type Page = Schema.Schema.Type<typeof PageSchema>;
+
+export 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"));
+
+export type LandingPage = Schema.Schema.Type<typeof LandingPageSchema>;
+
+export 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"));
+
+export type Event = Schema.Schema.Type<typeof EventSchema>;
+
+export 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"));
+
+export type Location = Schema.Schema.Type<typeof LocationSchema>;
+
+export 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"));
+
+export type Device = Schema.Schema.Type<typeof DeviceSchema>;
+
+export 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"));
+
+export type EcommerceItem = Schema.Schema.Type<typeof EcommerceItemSchema>;

package/src/schemas/shared.ts

@@ -0,0 +1,42 @@
+import { Iceberg } from "@useairfoil/connector-kit";
+import { Schema, SchemaTransformation } from "effect";
+
+export const field = (fieldId: number, description: string) =>
+  Iceberg.field(fieldId, { description });
+
+/** The API's `YYYYMMDD` as `YYYY-MM-DD`. */
+export const isoDay = (date: string) => `${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. */
+export const count = (fieldId: number, description: string) =>
+  Schema.BigIntFromString.pipe(field(fieldId, description));
+
+/** Float, currency, and seconds metrics, as an Iceberg double. */
+export const amount = (fieldId: number, description: string) =>
+  Schema.FiniteFromString.pipe(field(fieldId, description));
+
+/** Dimension values are never null. GA uses `(not set)` and `(other)` instead. */
+export const dimension = (fieldId: number, description: string) =>
+  Schema.String.pipe(field(fieldId, description));
+
+/** `version` is the fetch time, since report rows have no update time. */
+export 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.")),
+};
+
+export const currencyCode = Schema.String.pipe(
+  field(50, "Currency of the revenue fields, the property's currency."),
+);