@rawdash/connector-google-ads 0.16.0

package/dist/index.js

@@ -0,0 +1,703 @@
+// ../../connector-shared/dist/index.js
+var HTTP_CLIENT_VERSION = "0.0.0";
+var DEFAULT_USER_AGENT = `rawdash-connector/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;
+function connectorUserAgent(connectorId) {
+  return `rawdash-connector-${connectorId}/${HTTP_CLIENT_VERSION} (+https://rawdash.dev)`;
+}
+
+// src/google-ads.ts
+import {
+  BaseConnector,
+  defineConfigFields,
+  defineConnectorDoc,
+  defineResources,
+  makeChunkedCursorGuard,
+  paginateChunked,
+  schemasFromResources,
+  selectActivePhases
+} from "@rawdash/core";
+import { z } from "zod";
+var configFields = defineConfigFields(
+  z.object({
+    customerId: z.string().trim().regex(
+      /^\d{10}$/,
+      "customerId must be the 10-digit Google Ads ID, digits only (no dashes)"
+    ).meta({
+      label: "Customer ID",
+      description: "Google Ads customer ID for the account to sync, digits only (the dashed form 123-456-7890 with the dashes removed).",
+      placeholder: "1234567890"
+    }),
+    loginCustomerId: z.string().trim().regex(
+      /^\d{10}$/,
+      "loginCustomerId must be a 10-digit Google Ads ID, digits only"
+    ).optional().meta({
+      label: "Login Customer ID (MCC)",
+      description: "Manager (MCC) account ID, digits only. Set this when the OAuth credential authenticates against an MCC that owns the customer account.",
+      placeholder: "1234567890"
+    }),
+    clientId: z.string().min(1).meta({
+      label: "OAuth Client ID",
+      description: "OAuth 2.0 client ID from a Google Cloud project that has the Google Ads API enabled.",
+      placeholder: "\u2026apps.googleusercontent.com"
+    }),
+    clientSecret: z.object({ $secret: z.string() }).meta({
+      label: "OAuth Client Secret",
+      description: "OAuth 2.0 client secret paired with the client ID above.",
+      secret: true
+    }),
+    refreshToken: z.object({ $secret: z.string() }).meta({
+      label: "OAuth Refresh Token",
+      description: "Google OAuth 2.0 refresh token issued for the https://www.googleapis.com/auth/adwords scope.",
+      secret: true
+    }),
+    developerToken: z.object({ $secret: z.string() }).meta({
+      label: "Developer Token",
+      description: "Google Ads API developer token from the manager account that owns API access (Tools \u2192 API Center).",
+      secret: true
+    }),
+    lookbackDays: z.number().int().positive().optional().meta({
+      label: "Lookback days (full sync)",
+      description: "How many calendar days of metric history to fetch on a full sync. Defaults to 90.",
+      placeholder: "90"
+    }),
+    resources: z.array(
+      z.enum([
+        "campaigns",
+        "campaign_metrics",
+        "ad_group_metrics",
+        "keyword_metrics"
+      ])
+    ).nonempty().optional().meta({
+      label: "Resources",
+      description: "Which Google Ads resources to sync. Omit to sync everything; pin a subset to avoid pulling keyword-level metrics on a quota-limited token."
+    })
+  })
+);
+var doc = defineConnectorDoc({
+  displayName: "Google Ads",
+  category: "marketing",
+  brandColor: "#4285F4",
+  tagline: "Sync Google Ads campaigns plus daily campaign, ad-group, and keyword performance (impressions, clicks, cost, conversions) via GAQL.",
+  vendor: {
+    name: "Google Ads",
+    apiDocs: "https://developers.google.com/google-ads/api/docs/start",
+    website: "https://ads.google.com"
+  },
+  auth: {
+    summary: "OAuth 2.0 refresh token against an account with read access to the Google Ads customer, plus a developer token from the manager account that owns API access.",
+    setup: [
+      "Apply for Google Ads API access from your manager account (Tools \u2192 API Center). Copy the developer token - it lives on the manager, not the child account.",
+      "In Google Cloud Console, enable the Google Ads API on a project, create an OAuth 2.0 client ID, and complete the OAuth consent flow for the adwords scope to obtain a refresh token. The official walkthrough is at https://developers.google.com/google-ads/api/docs/oauth/overview.",
+      "Find the Google Ads customer ID at the top of the Ads UI (e.g. 123-456-7890) and store it without dashes (e.g. 1234567890).",
+      "If the OAuth credential authenticates against an MCC that owns the customer, set `loginCustomerId` to the MCC id (digits only). For a direct-access account, omit it.",
+      'Store the client secret, refresh token, and developer token as secrets, then reference them as `clientSecret: secret("GADS_CLIENT_SECRET")`, `refreshToken: secret("GADS_REFRESH_TOKEN")`, and `developerToken: secret("GADS_DEVELOPER_TOKEN")`.'
+    ]
+  },
+  rateLimit: "Google Ads API basic-access tokens get a 15,000 operations / day quota per developer token; the connector treats 429 (RESOURCE_EXHAUSTED) as a transient error and the host backs off.",
+  limitations: [
+    "Cost values are stored in account currency units (cost_micros \xF7 1,000,000); the original micro-precision integer is also exposed in attributes.",
+    "Keyword metrics use the historical (per-day) quality score from `metrics.historical_quality_score`; criteria with no impressions on a day will report a null quality score.",
+    "Incremental syncs trail the last 3 days because Google Ads can attribute conversions to a click up to 3 days after the event.",
+    "Audience-, asset-, and recommendation-level reporting are out of scope; this connector covers campaign / ad-group / keyword performance only."
+  ]
+});
+var googleAdsCredentials = {
+  clientId: {
+    description: "Google OAuth 2.0 client ID (public, not a secret)",
+    auth: "required"
+  },
+  clientSecret: {
+    description: "Google OAuth 2.0 client secret",
+    auth: "required"
+  },
+  refreshToken: {
+    description: "Google OAuth 2.0 refresh token with the adwords scope",
+    auth: "required"
+  },
+  developerToken: {
+    description: "Google Ads API developer token",
+    auth: "required"
+  }
+};
+var PHASE_ORDER = [
+  "campaigns",
+  "campaign_metrics",
+  "ad_group_metrics",
+  "keyword_metrics"
+];
+var isGoogleAdsSyncCursor = makeChunkedCursorGuard(PHASE_ORDER);
+var API_VERSION = "v18";
+var PAGE_SIZE = 1e4;
+var MS_PER_DAY = 24 * 60 * 60 * 1e3;
+var DEFAULT_LOOKBACK_DAYS = 90;
+var INCREMENTAL_LOOKBACK_DAYS = 3;
+var MICROS_PER_UNIT = 1e6;
+var TOKEN_URL = "https://oauth2.googleapis.com/token";
+var ENTITY_TYPE_CAMPAIGN = "google_ads_campaign";
+var METRIC_NAME = {
+  campaigns: ENTITY_TYPE_CAMPAIGN,
+  campaign_metrics: "google_ads_campaign_metrics",
+  ad_group_metrics: "google_ads_ad_group_metrics",
+  keyword_metrics: "google_ads_keyword_metrics"
+};
+var int64String = z.union([z.string().min(1), z.number()]);
+var segmentsSchema = z.object({
+  date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/)
+});
+var dateString = z.string().regex(/^\d{4}-\d{2}-\d{2}$/);
+var campaignFieldsSchema = z.object({
+  id: int64String,
+  name: z.string().nullish(),
+  status: z.string().nullish(),
+  biddingStrategyType: z.string().nullish(),
+  startDate: dateString.nullish(),
+  endDate: dateString.nullish(),
+  resourceName: z.string().nullish()
+});
+var metricsSchema = z.object({
+  impressions: int64String.nullish(),
+  clicks: int64String.nullish(),
+  costMicros: int64String.nullish(),
+  conversions: z.number().nullish(),
+  conversionsValue: z.number().nullish(),
+  historicalQualityScore: int64String.nullish()
+});
+var campaignRowSchema = z.object({
+  campaign: campaignFieldsSchema
+});
+var campaignMetricRowSchema = z.object({
+  segments: segmentsSchema,
+  campaign: z.object({
+    id: int64String,
+    name: z.string().nullish(),
+    resourceName: z.string().nullish()
+  }),
+  metrics: metricsSchema
+});
+var adGroupMetricRowSchema = z.object({
+  segments: segmentsSchema,
+  campaign: z.object({ id: int64String }).nullish(),
+  adGroup: z.object({
+    id: int64String,
+    name: z.string().nullish(),
+    resourceName: z.string().nullish()
+  }),
+  metrics: metricsSchema
+});
+var keywordMetricRowSchema = z.object({
+  segments: segmentsSchema,
+  adGroup: z.object({ id: int64String }).nullish(),
+  adGroupCriterion: z.object({
+    criterionId: int64String,
+    keyword: z.object({
+      text: z.string().nullish(),
+      matchType: z.string().nullish()
+    }).nullish(),
+    resourceName: z.string().nullish()
+  }),
+  metrics: metricsSchema
+});
+var campaignsResponseSchema = z.array(campaignRowSchema);
+var campaignMetricsResponseSchema = z.array(campaignMetricRowSchema);
+var adGroupMetricsResponseSchema = z.array(adGroupMetricRowSchema);
+var keywordMetricsResponseSchema = z.array(keywordMetricRowSchema);
+var googleAdsResources = defineResources({
+  [ENTITY_TYPE_CAMPAIGN]: {
+    shape: "entity",
+    description: "Google Ads campaigns with id, name, status, bidding strategy type, and start / end dates.",
+    endpoint: "POST /v18/customers/{customerId}/googleAds:search",
+    fields: [
+      { name: "id", description: "Numeric Google Ads campaign id." },
+      { name: "name", description: "Campaign display name." },
+      {
+        name: "status",
+        description: "Campaign status (ENABLED, PAUSED, REMOVED, UNKNOWN, UNSPECIFIED)."
+      },
+      {
+        name: "biddingStrategyType",
+        description: "Bidding strategy in use (e.g. MAXIMIZE_CONVERSIONS, MANUAL_CPC)."
+      },
+      { name: "startDate", description: "Campaign start date (YYYY-MM-DD)." },
+      {
+        name: "endDate",
+        description: "Campaign end date (YYYY-MM-DD), if set."
+      }
+    ],
+    responses: {
+      oauth_token: z.object({
+        access_token: z.string().min(1),
+        expires_in: z.number().int().positive().optional()
+      }),
+      campaigns: campaignsResponseSchema
+    }
+  },
+  google_ads_campaign_metrics: {
+    shape: "metric",
+    description: "Daily campaign performance - impressions, clicks, cost, conversions, and conversion value per (date, campaignId).",
+    endpoint: "POST /v18/customers/{customerId}/googleAds:search",
+    unit: "cost",
+    granularity: "day",
+    dimensions: [
+      { name: "date", description: "Calendar day of the metric sample." },
+      { name: "campaignId", description: "Numeric Google Ads campaign id." },
+      {
+        name: "campaignName",
+        description: "Campaign display name at sync time."
+      },
+      { name: "impressions", description: "Ad impressions served on the day." },
+      { name: "clicks", description: "Clicks recorded on the day." },
+      {
+        name: "cost",
+        description: "Cost in account currency units (cost_micros \xF7 1,000,000)."
+      },
+      {
+        name: "costMicros",
+        description: "Raw cost in micros, as returned by the API."
+      },
+      {
+        name: "conversions",
+        description: "Counted conversions attributed to the day."
+      },
+      {
+        name: "conversionsValue",
+        description: "Total value of conversions for the day."
+      }
+    ],
+    notes: "Sample value is `cost` (account currency units). All other fields are mirrored in attributes for filtering and ratio metrics (CPA = cost / conversions, ROAS = conversionsValue / cost).",
+    responses: { campaign_metrics: campaignMetricsResponseSchema }
+  },
+  google_ads_ad_group_metrics: {
+    shape: "metric",
+    description: "Daily ad-group performance - impressions, clicks, cost, and conversions per (date, adGroupId).",
+    endpoint: "POST /v18/customers/{customerId}/googleAds:search",
+    unit: "cost",
+    granularity: "day",
+    dimensions: [
+      { name: "date", description: "Calendar day of the metric sample." },
+      { name: "adGroupId", description: "Numeric Google Ads ad-group id." },
+      {
+        name: "adGroupName",
+        description: "Ad-group display name at sync time."
+      },
+      { name: "campaignId", description: "Parent campaign id." },
+      { name: "impressions", description: "Ad impressions served on the day." },
+      { name: "clicks", description: "Clicks recorded on the day." },
+      { name: "cost", description: "Cost in account currency units." },
+      {
+        name: "costMicros",
+        description: "Raw cost in micros, as returned by the API."
+      },
+      {
+        name: "conversions",
+        description: "Counted conversions attributed to the day."
+      }
+    ],
+    responses: { ad_group_metrics: adGroupMetricsResponseSchema }
+  },
+  google_ads_keyword_metrics: {
+    shape: "metric",
+    description: "Daily keyword performance - impressions, clicks, cost, and historical quality score per (date, criterionId).",
+    endpoint: "POST /v18/customers/{customerId}/googleAds:search",
+    unit: "cost",
+    granularity: "day",
+    dimensions: [
+      { name: "date", description: "Calendar day of the metric sample." },
+      {
+        name: "criterionId",
+        description: "Numeric keyword (ad-group criterion) id."
+      },
+      { name: "keywordText", description: "Keyword text." },
+      {
+        name: "matchType",
+        description: "Match type (EXACT, PHRASE, BROAD, \u2026)."
+      },
+      { name: "adGroupId", description: "Parent ad-group id." },
+      { name: "impressions", description: "Ad impressions served on the day." },
+      { name: "clicks", description: "Clicks recorded on the day." },
+      { name: "cost", description: "Cost in account currency units." },
+      {
+        name: "costMicros",
+        description: "Raw cost in micros, as returned by the API."
+      },
+      {
+        name: "qualityScore",
+        description: "Historical quality score for the day (1-10), null when no impressions."
+      }
+    ],
+    notes: "Driven by `keyword_view`; the cost / impression columns roll up to the criterion-day pair.",
+    responses: { keyword_metrics: keywordMetricsResponseSchema }
+  }
+});
+function toDateString(date) {
+  const y = date.getUTCFullYear();
+  const m = String(date.getUTCMonth() + 1).padStart(2, "0");
+  const d = String(date.getUTCDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+var DATE_RE = /^(\d{4})-(\d{2})-(\d{2})$/;
+function dateStringToMs(yyyyMmDd) {
+  const m = DATE_RE.exec(yyyyMmDd);
+  if (!m) {
+    return 0;
+  }
+  const ms = Date.UTC(Number(m[1]), Number(m[2]) - 1, Number(m[3]));
+  return Number.isFinite(ms) ? ms : 0;
+}
+function getDateRange(options, lookbackDays, now = Date.now()) {
+  const endDate = toDateString(new Date(now));
+  if (options.mode === "latest") {
+    const startMs2 = now - (INCREMENTAL_LOOKBACK_DAYS - 1) * MS_PER_DAY;
+    return { startDate: toDateString(new Date(startMs2)), endDate };
+  }
+  if (options.since) {
+    const sinceMs = new Date(options.since).getTime();
+    if (Number.isFinite(sinceMs)) {
+      const days = Math.max(1, Math.ceil((now - sinceMs) / MS_PER_DAY));
+      const cappedDays = Math.min(days, lookbackDays);
+      const startMs2 = now - (cappedDays - 1) * MS_PER_DAY;
+      return { startDate: toDateString(new Date(startMs2)), endDate };
+    }
+  }
+  const startMs = now - (lookbackDays - 1) * MS_PER_DAY;
+  return { startDate: toDateString(new Date(startMs)), endDate };
+}
+function coerceInt(value) {
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? value : 0;
+  }
+  if (typeof value === "string" && value !== "") {
+    const n = Number(value);
+    return Number.isFinite(n) ? n : 0;
+  }
+  return 0;
+}
+function coerceIntOrNull(value) {
+  if (value === null || value === void 0) {
+    return null;
+  }
+  const n = coerceInt(value);
+  return n;
+}
+function microsToUnits(micros) {
+  return coerceInt(micros) / MICROS_PER_UNIT;
+}
+function campaignsQuery() {
+  return [
+    "SELECT",
+    "  campaign.id,",
+    "  campaign.name,",
+    "  campaign.status,",
+    "  campaign.bidding_strategy_type,",
+    "  campaign.start_date,",
+    "  campaign.end_date",
+    "FROM campaign"
+  ].join(" ");
+}
+function campaignMetricsQuery(range) {
+  return [
+    "SELECT",
+    "  segments.date,",
+    "  campaign.id,",
+    "  campaign.name,",
+    "  metrics.impressions,",
+    "  metrics.clicks,",
+    "  metrics.cost_micros,",
+    "  metrics.conversions,",
+    "  metrics.conversions_value",
+    "FROM campaign",
+    `WHERE segments.date BETWEEN '${range.startDate}' AND '${range.endDate}'`
+  ].join(" ");
+}
+function adGroupMetricsQuery(range) {
+  return [
+    "SELECT",
+    "  segments.date,",
+    "  campaign.id,",
+    "  ad_group.id,",
+    "  ad_group.name,",
+    "  metrics.impressions,",
+    "  metrics.clicks,",
+    "  metrics.cost_micros,",
+    "  metrics.conversions",
+    "FROM ad_group",
+    `WHERE segments.date BETWEEN '${range.startDate}' AND '${range.endDate}'`
+  ].join(" ");
+}
+function keywordMetricsQuery(range) {
+  return [
+    "SELECT",
+    "  segments.date,",
+    "  ad_group.id,",
+    "  ad_group_criterion.criterion_id,",
+    "  ad_group_criterion.keyword.text,",
+    "  ad_group_criterion.keyword.match_type,",
+    "  metrics.impressions,",
+    "  metrics.clicks,",
+    "  metrics.cost_micros,",
+    "  metrics.historical_quality_score",
+    "FROM keyword_view",
+    `WHERE segments.date BETWEEN '${range.startDate}' AND '${range.endDate}'`
+  ].join(" ");
+}
+function queryForPhase(phase, range) {
+  switch (phase) {
+    case "campaigns":
+      return campaignsQuery();
+    case "campaign_metrics":
+      return campaignMetricsQuery(range);
+    case "ad_group_metrics":
+      return adGroupMetricsQuery(range);
+    case "keyword_metrics":
+      return keywordMetricsQuery(range);
+  }
+}
+function campaignToEntity(row) {
+  const c = row.campaign;
+  const startMs = c.startDate ? dateStringToMs(c.startDate) : 0;
+  return {
+    type: ENTITY_TYPE_CAMPAIGN,
+    id: String(c.id),
+    attributes: {
+      name: c.name ?? null,
+      status: c.status ?? null,
+      biddingStrategyType: c.biddingStrategyType ?? null,
+      startDate: c.startDate ?? null,
+      endDate: c.endDate ?? null,
+      resourceName: c.resourceName ?? null
+    },
+    updated_at: startMs
+  };
+}
+function campaignMetricRowToSample(row) {
+  const m = row.metrics;
+  const cost = microsToUnits(m.costMicros);
+  return {
+    name: METRIC_NAME.campaign_metrics,
+    ts: dateStringToMs(row.segments.date),
+    value: cost,
+    attributes: {
+      date: row.segments.date,
+      campaignId: String(row.campaign.id),
+      campaignName: row.campaign.name ?? null,
+      impressions: coerceInt(m.impressions),
+      clicks: coerceInt(m.clicks),
+      cost,
+      costMicros: coerceInt(m.costMicros),
+      conversions: typeof m.conversions === "number" ? m.conversions : 0,
+      conversionsValue: typeof m.conversionsValue === "number" ? m.conversionsValue : 0
+    }
+  };
+}
+function adGroupMetricRowToSample(row) {
+  const m = row.metrics;
+  const cost = microsToUnits(m.costMicros);
+  return {
+    name: METRIC_NAME.ad_group_metrics,
+    ts: dateStringToMs(row.segments.date),
+    value: cost,
+    attributes: {
+      date: row.segments.date,
+      adGroupId: String(row.adGroup.id),
+      adGroupName: row.adGroup.name ?? null,
+      campaignId: row.campaign?.id != null ? String(row.campaign.id) : null,
+      impressions: coerceInt(m.impressions),
+      clicks: coerceInt(m.clicks),
+      cost,
+      costMicros: coerceInt(m.costMicros),
+      conversions: typeof m.conversions === "number" ? m.conversions : 0
+    }
+  };
+}
+function keywordMetricRowToSample(row) {
+  const m = row.metrics;
+  const cost = microsToUnits(m.costMicros);
+  return {
+    name: METRIC_NAME.keyword_metrics,
+    ts: dateStringToMs(row.segments.date),
+    value: cost,
+    attributes: {
+      date: row.segments.date,
+      criterionId: String(row.adGroupCriterion.criterionId),
+      keywordText: row.adGroupCriterion.keyword?.text ?? null,
+      matchType: row.adGroupCriterion.keyword?.matchType ?? null,
+      adGroupId: row.adGroup?.id != null ? String(row.adGroup.id) : null,
+      impressions: coerceInt(m.impressions),
+      clicks: coerceInt(m.clicks),
+      cost,
+      costMicros: coerceInt(m.costMicros),
+      qualityScore: coerceIntOrNull(m.historicalQualityScore)
+    }
+  };
+}
+var GoogleAdsConnector = class _GoogleAdsConnector extends BaseConnector {
+  static id = "google-ads";
+  static resources = googleAdsResources;
+  static schemas = schemasFromResources(googleAdsResources);
+  static create(input, ctx) {
+    const parsed = configFields.parse(input);
+    return new _GoogleAdsConnector(
+      {
+        customerId: parsed.customerId,
+        loginCustomerId: parsed.loginCustomerId,
+        lookbackDays: parsed.lookbackDays,
+        resources: parsed.resources
+      },
+      {
+        clientId: parsed.clientId,
+        clientSecret: parsed.clientSecret,
+        refreshToken: parsed.refreshToken,
+        developerToken: parsed.developerToken
+      },
+      ctx
+    );
+  }
+  id = "google-ads";
+  credentials = googleAdsCredentials;
+  cachedToken = null;
+  async fetchAccessToken(signal) {
+    const body = new URLSearchParams({
+      grant_type: "refresh_token",
+      client_id: this.creds.clientId,
+      client_secret: this.creds.clientSecret,
+      refresh_token: this.creds.refreshToken
+    }).toString();
+    const res = await this.post(TOKEN_URL, {
+      resource: "oauth_token",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body,
+      signal
+    });
+    const expiresIn = res.body.expires_in ?? 3600;
+    return {
+      token: res.body.access_token,
+      // Refresh 60s before expiry so a long-running phase doesn't 401 on the
+      // boundary.
+      expiresAt: Date.now() + (expiresIn - 60) * 1e3
+    };
+  }
+  async getAccessToken(signal) {
+    if (this.cachedToken && Date.now() < this.cachedToken.expiresAt) {
+      return this.cachedToken.token;
+    }
+    this.cachedToken = await this.fetchAccessToken(signal);
+    return this.cachedToken.token;
+  }
+  buildHeaders(accessToken) {
+    const headers = {
+      Authorization: `Bearer ${accessToken}`,
+      "Content-Type": "application/json",
+      "developer-token": this.creds.developerToken,
+      "User-Agent": connectorUserAgent("google-ads")
+    };
+    if (this.settings.loginCustomerId) {
+      headers["login-customer-id"] = this.settings.loginCustomerId;
+    }
+    return headers;
+  }
+  async searchPage(phase, range, pageToken, signal) {
+    const token = await this.getAccessToken(signal);
+    const url = `https://googleads.googleapis.com/${API_VERSION}/customers/${this.settings.customerId}/googleAds:search`;
+    const body = {
+      query: queryForPhase(phase, range),
+      pageSize: PAGE_SIZE
+    };
+    if (pageToken) {
+      body.pageToken = pageToken;
+    }
+    const res = await this.post(url, {
+      resource: phase,
+      headers: this.buildHeaders(token),
+      body: JSON.stringify(body),
+      signal
+    });
+    return {
+      items: res.body.results ?? [],
+      next: res.body.nextPageToken ?? null
+    };
+  }
+  async writePhase(phase, items, storage) {
+    switch (phase) {
+      case "campaigns": {
+        for (const row of items) {
+          await storage.entity(campaignToEntity(row));
+        }
+        return;
+      }
+      case "campaign_metrics": {
+        const samples = items.map(
+          campaignMetricRowToSample
+        );
+        await storage.metrics(samples, {
+          names: [METRIC_NAME.campaign_metrics]
+        });
+        return;
+      }
+      case "ad_group_metrics": {
+        const samples = items.map(
+          adGroupMetricRowToSample
+        );
+        await storage.metrics(samples, {
+          names: [METRIC_NAME.ad_group_metrics]
+        });
+        return;
+      }
+      case "keyword_metrics": {
+        const samples = items.map(
+          keywordMetricRowToSample
+        );
+        await storage.metrics(samples, {
+          names: [METRIC_NAME.keyword_metrics]
+        });
+        return;
+      }
+    }
+  }
+  async clearScopeOnFirstPage(phase, storage, isFull) {
+    if (phase === "campaigns") {
+      if (isFull) {
+        await storage.entities([], { types: [ENTITY_TYPE_CAMPAIGN] });
+      }
+      return;
+    }
+    await storage.metrics([], { names: [METRIC_NAME[phase]] });
+  }
+  async sync(options, storage, signal) {
+    const lookbackDays = this.settings.lookbackDays ?? DEFAULT_LOOKBACK_DAYS;
+    const range = getDateRange(options, lookbackDays);
+    const isFull = options.mode === "full";
+    const phases = selectActivePhases(
+      (r) => r,
+      PHASE_ORDER,
+      this.settings.resources
+    );
+    const cursor = isGoogleAdsSyncCursor(options.cursor) ? options.cursor : void 0;
+    return paginateChunked({
+      phases,
+      cursor,
+      signal,
+      logger: this.logger,
+      fetchPage: (phase, page, sig) => this.searchPage(phase, range, page, sig),
+      writeBatch: async (phase, items, page) => {
+        if (page === null) {
+          await this.clearScopeOnFirstPage(phase, storage, isFull);
+        }
+        await this.writePhase(phase, items, storage);
+      }
+    });
+  }
+};
+
+// src/index.ts
+var index_default = GoogleAdsConnector;
+export {
+  GoogleAdsConnector,
+  adGroupMetricRowToSample,
+  campaignMetricRowToSample,
+  campaignToEntity,
+  configFields,
+  index_default as default,
+  doc,
+  getDateRange,
+  keywordMetricRowToSample
+};
+//# sourceMappingURL=index.js.map