@firebase-function-kits/firestore-bigquery-export 0.0.1 → 0.0.2-rc.0

package/src/export-config.ts

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import type {
+  ChangeTrackerConfig,
+  LogLevel,
+} from "@firebaseextensions/firestore-bigquery-change-tracker";
+import type { Expression } from "firebase-functions/params";
+
+type TrackerLogLevel = "debug" | "info" | "warn" | "error" | "silent";
+type ConfigValue<T extends string | number | boolean | string[]> =
+  | T
+  | Expression<T>;
+
+/** How the BigQuery changelog view is materialized. */
+export type ViewType =
+  | "view"
+  | "materialized_incremental"
+  | "materialized_non_incremental";
+
+/**
+ * The export configuration. The main entry point builds it from deploy-time
+ * params; handler consumers can construct it directly.
+ *
+ * `collectionPath`, `datasetId`, `tableId`, `location`, and `projectId` are
+ * required; everything else has a sensible default.
+ */
+export interface ExportConfig {
+  /** Firestore collection (or collection group) path to mirror, e.g. `users`
+   *  or `regions/{regionId}/users`. */
+  collectionPath: ConfigValue<string>;
+  /** BigQuery dataset id to write into. */
+  datasetId: ConfigValue<string>;
+  /** BigQuery changelog table id. */
+  tableId: ConfigValue<string>;
+
+  /** Region for the trigger and task queue. */
+  location: ConfigValue<string>;
+  /** BigQuery dataset location, e.g. `us`, `eu`. Defaults to `us`. */
+  datasetLocation?: ConfigValue<string>;
+  /** Project that owns the BigQuery dataset, if different from the function's
+   *  project. */
+  bqProjectId?: ConfigValue<string>;
+  /** GCP project id. */
+  projectId: ConfigValue<string>;
+  /** Firestore database id. Defaults to `(default)`. */
+  databaseId?: ConfigValue<string>;
+
+  /** Include path-param values as columns. Defaults to `false`. */
+  wildcardIds?: ConfigValue<boolean>;
+  /** Skip writing the previous document state on updates. Defaults to `false`. */
+  excludeOldData?: ConfigValue<boolean>;
+  /** Use the newer snapshot view query syntax. Defaults to `false`. */
+  useNewSnapshotQuerySyntax?: ConfigValue<boolean>;
+  /** Changelog view strategy. Defaults to `view`. */
+  viewType?: ConfigValue<ViewType>;
+
+  /** Partitioning strategy for the changelog table. */
+  partitioning?: ChangeTrackerConfig["partitioning"];
+  /** Clustering columns (max 4). */
+  clustering?: string[] | null;
+  /** Materialized-view max staleness interval, e.g. `0-0 0 4:0:0`. */
+  maxStaleness?: ConfigValue<string>;
+  /** Incremental materialized-view refresh interval in minutes. */
+  refreshIntervalMinutes?: ConfigValue<number>;
+
+  /** Collection id used for the changelog backup table. */
+  backupCollectionId?: ConfigValue<string>;
+  /** Name of a transform function to apply before writing. */
+  transformFunction?: ConfigValue<string>;
+  /** Customer-managed encryption key for the dataset. */
+  kmsKeyName?: ConfigValue<string>;
+
+  /** Log verbosity. Defaults to `info`. */
+  logLevel?: ConfigValue<TrackerLogLevel | LogLevel>;
+}
+
+/** {@link ExportConfig} with all defaults applied. */
+export interface ResolvedExportConfig {
+  collectionPath: string;
+  datasetId: string;
+  tableId: string;
+  location: string;
+  datasetLocation: string;
+  bqProjectId?: string;
+  projectId: string;
+  databaseId: string;
+  wildcardIds: boolean;
+  excludeOldData: boolean;
+  useNewSnapshotQuerySyntax: boolean;
+  viewType: ViewType;
+  partitioning?: ChangeTrackerConfig["partitioning"];
+  clustering: string[] | null;
+  maxStaleness?: string;
+  refreshIntervalMinutes?: number;
+  backupCollectionId?: string;
+  transformFunction?: string;
+  kmsKeyName?: string;
+  logLevel: TrackerLogLevel;
+}
+
+function isExpression<T extends string | number | boolean | string[]>(
+  value: ConfigValue<T>
+): value is Expression<T> {
+  return typeof value === "object" && value !== null && "value" in value;
+}
+
+function resolveConfigValue<T extends string | number | boolean | string[]>(
+  value: ConfigValue<T>
+): T {
+  return isExpression(value) ? value.value() : value;
+}
+
+function resolveOptionalConfigValue<
+  T extends string | number | boolean | string[]
+>(value: ConfigValue<T> | undefined): T | undefined {
+  return value === undefined ? undefined : resolveConfigValue(value);
+}
+
+/**
+ * Applies defaults to an {@link ExportConfig}.
+ *
+ * @param config - The user-supplied configuration.
+ * @returns The configuration with every field populated.
+ */
+export function resolveExportConfig(
+  config: ExportConfig
+): ResolvedExportConfig {
+  const projectId = resolveConfigValue(config.projectId);
+  const viewType = resolveOptionalConfigValue(config.viewType);
+  const logLevel = resolveOptionalConfigValue(config.logLevel);
+
+  return {
+    collectionPath: resolveConfigValue(config.collectionPath),
+    datasetId: resolveConfigValue(config.datasetId),
+    tableId: resolveConfigValue(config.tableId),
+    location: resolveConfigValue(config.location),
+    datasetLocation: resolveOptionalConfigValue(config.datasetLocation) ?? "us",
+    bqProjectId: resolveOptionalConfigValue(config.bqProjectId),
+    projectId,
+    databaseId: resolveOptionalConfigValue(config.databaseId) ?? "(default)",
+    wildcardIds: resolveOptionalConfigValue(config.wildcardIds) ?? false,
+    excludeOldData: resolveOptionalConfigValue(config.excludeOldData) ?? false,
+    useNewSnapshotQuerySyntax:
+      resolveOptionalConfigValue(config.useNewSnapshotQuerySyntax) ?? false,
+    viewType: viewType ?? "view",
+    partitioning: config.partitioning,
+    clustering: config.clustering ?? null,
+    maxStaleness: resolveOptionalConfigValue(config.maxStaleness),
+    refreshIntervalMinutes: resolveOptionalConfigValue(
+      config.refreshIntervalMinutes
+    ),
+    backupCollectionId: resolveOptionalConfigValue(config.backupCollectionId),
+    transformFunction: resolveOptionalConfigValue(config.transformFunction),
+    kmsKeyName: resolveOptionalConfigValue(config.kmsKeyName),
+    logLevel: (logLevel as TrackerLogLevel) ?? "info",
+  };
+}
+
+/**
+ * Maps a resolved export config onto the change-tracker's config shape.
+ *
+ * @param config - The resolved export configuration.
+ * @returns The {@link ChangeTrackerConfig} for the event history tracker.
+ */
+export function toTrackerConfig(
+  config: ResolvedExportConfig
+): ChangeTrackerConfig {
+  return {
+    firestoreInstanceId: config.databaseId,
+    tableId: config.tableId,
+    datasetId: config.datasetId,
+    datasetLocation: config.datasetLocation,
+    backupTableId: config.backupCollectionId,
+    transformFunction: config.transformFunction,
+    partitioning: config.partitioning,
+    databaseId: config.databaseId,
+    clustering: config.clustering,
+    wildcardIds: config.wildcardIds,
+    bqProjectId: config.bqProjectId ?? config.projectId,
+    useNewSnapshotQuerySyntax: config.useNewSnapshotQuerySyntax,
+    skipInit: true,
+    kmsKeyName: config.kmsKeyName,
+    useMaterializedView:
+      config.viewType === "materialized_incremental" ||
+      config.viewType === "materialized_non_incremental",
+    useIncrementalMaterializedView:
+      config.viewType === "materialized_incremental",
+    maxStaleness: config.maxStaleness,
+    refreshIntervalMinutes: config.refreshIntervalMinutes,
+    logLevel: config.logLevel,
+  };
+}

package/src/handlers.ts

@@ -0,0 +1,211 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  ChangeType,
+  type FirestoreBigQueryEventHistoryTracker,
+  type FirestoreDocumentChangeEvent,
+} from "@firebaseextensions/firestore-bigquery-change-tracker";
+import type {
+  Change,
+  DocumentSnapshot,
+  FirestoreEvent,
+} from "firebase-functions/firestore";
+import * as events from "./events";
+import type { ResolvedExportConfig } from "./export-config";
+import * as logs from "./logs";
+import { getChangeType, getDocumentId } from "./util";
+
+/** Serialized Firestore change ready to write to BigQuery. */
+interface SerializedDocumentChange {
+  timestamp: string;
+  eventId: string;
+  fullResourceName: string;
+  changeType: ChangeType;
+  documentId: string;
+  params: FirestoreDocumentChangeEvent["pathParams"] | null;
+  data: FirestoreDocumentChangeEvent["data"];
+  oldData: FirestoreDocumentChangeEvent["oldData"];
+}
+
+/** The Firestore document-write event passed to {@link handleDocumentWrite}. */
+export type DocumentWriteEvent = FirestoreEvent<
+  Change<DocumentSnapshot> | undefined,
+  Record<string, string>
+>;
+
+/**
+ * Everything a handler needs to do its work, injected by the caller so the
+ * handlers stay free of global state.
+ */
+export interface HandlerContext {
+  tracker: FirestoreBigQueryEventHistoryTracker;
+  config: ResolvedExportConfig;
+  /**
+   * Provisions the BigQuery dataset/table/views once per instance. Only called
+   * after an inline write failure as a self-heal; the hot path relies on
+   * out-of-band provisioning (`initBigQuerySync` / `setupBigQuerySync`).
+   */
+  ensureInitialized: () => Promise<void>;
+}
+
+/**
+ * Records a Firestore document change to BigQuery.
+ *
+ * @param change - Serialized change metadata and payload.
+ * @param tracker - The event history tracker to write through.
+ */
+async function recordEventToBigQuery(
+  change: SerializedDocumentChange,
+  tracker: FirestoreBigQueryEventHistoryTracker
+): Promise<void> {
+  const event: FirestoreDocumentChangeEvent = {
+    timestamp: change.timestamp,
+    operation: change.changeType,
+    documentName: change.fullResourceName,
+    documentId: change.documentId,
+    pathParams: change.params,
+    eventId: change.eventId,
+    data: change.data,
+    oldData: change.oldData,
+  };
+
+  await tracker.record([event]);
+}
+
+/**
+ * Gives a failed inline write one self-heal attempt before surfacing it to the
+ * Firestore trigger retry policy.
+ *
+ * @param change - The serialized change to write.
+ * @param ctx - The handler context.
+ */
+async function retryAfterSelfHeal(
+  change: SerializedDocumentChange,
+  ctx: HandlerContext
+): Promise<void> {
+  try {
+    await ctx.ensureInitialized();
+    await recordEventToBigQuery(change, ctx.tracker);
+  } catch (retryErr) {
+    await events.recordErrorEvent(retryErr as Error);
+
+    logs.logFailedEventAction(
+      "Failed to write event to BigQuery from onWrite handler after self-heal",
+      change.fullResourceName,
+      change.eventId,
+      change.changeType,
+      retryErr as Error
+    );
+
+    throw retryErr;
+  }
+}
+
+/**
+ * Handles a Firestore document write: serializes the change and writes it to
+ * BigQuery. Failed writes are surfaced to the trigger retry policy after one
+ * self-heal attempt.
+ *
+ * @param event - The Firestore document-write event.
+ * @param ctx - The handler context.
+ */
+export async function handleDocumentWrite(
+  event: DocumentWriteEvent,
+  ctx: HandlerContext
+): Promise<void> {
+  const { data, ...context } = event;
+  if (!data) return;
+
+  logs.start();
+
+  // No provisioning on the hot path: BigQuery resources are provisioned
+  // out-of-band (afterFirstDeploy / afterRedeploy tasks). If they are missing,
+  // the inline write fails, self-heals once, then falls back to the trigger
+  // retry policy.
+  const { config, tracker } = ctx;
+  const changeType = getChangeType(data);
+  const documentId = getDocumentId(data);
+  const isCreated = changeType === ChangeType.CREATE;
+  const isDeleted = changeType === ChangeType.DELETE;
+
+  const newData = isDeleted ? undefined : data.after.data();
+  const oldData =
+    isCreated || config.excludeOldData ? undefined : data.before.data();
+
+  const relativeName = context.document;
+  const projectId = config.projectId;
+  const fullResourceName = `projects/${projectId}/databases/${config.databaseId}/documents/${relativeName}`;
+  const eventId = context.id;
+  const operation = changeType;
+
+  logs.logEventAction(
+    "Firestore event received by onDocumentWritten trigger",
+    fullResourceName,
+    eventId,
+    operation
+  );
+
+  let serializedData: FirestoreDocumentChangeEvent["data"];
+  let serializedOldData: FirestoreDocumentChangeEvent["oldData"];
+
+  try {
+    serializedData = tracker.serializeData(newData);
+    serializedOldData = tracker.serializeData(oldData);
+  } catch (err) {
+    logs.logFailedEventAction(
+      "Failed to serialize data",
+      fullResourceName,
+      eventId,
+      operation,
+      err as Error
+    );
+    throw err;
+  }
+
+  try {
+    await events.recordStartEvent({
+      documentId,
+      changeType,
+      before: { data: data.before.data() },
+      after: { data: data.after.data() },
+      context,
+    });
+  } catch (err) {
+    logs.error(false, "Failed to record start event", err);
+    throw err;
+  }
+
+  const change: SerializedDocumentChange = {
+    timestamp: context.time,
+    eventId: context.id,
+    fullResourceName,
+    changeType,
+    documentId,
+    params: config.wildcardIds ? { ...context.params, documentId } : null,
+    data: serializedData,
+    oldData: serializedOldData,
+  };
+
+  try {
+    await recordEventToBigQuery(change, tracker);
+  } catch (err) {
+    logs.failedToWriteToBigQueryImmediately(err as Error);
+    await retryAfterSelfHeal(change, ctx);
+  }
+
+  logs.complete();
+}

package/src/index.ts

@@ -0,0 +1,174 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Main entry point. Exports the wired functions with deploy-time param
+ * expressions, then resolves concrete config lazily at runtime. Re-export
+ * `fsexportbigquery` and `initBigQuerySync` from your own functions codebase
+ * entry; configuration comes from a `.env` (or
+ * `.env.<projectId>`), which the Firebase CLI loads at deploy.
+ *
+ * Because this module initializes runtime dependencies lazily, deploy discovery
+ * can analyze it without resolving params too early.
+ * For side-effect-free imports (the handlers and config types), import from
+ * `./lib` instead.
+ */
+
+import { FirestoreBigQueryEventHistoryTracker } from "@firebaseextensions/firestore-bigquery-change-tracker";
+import { getApps, initializeApp } from "firebase-admin/app";
+import { onDocumentWritten } from "firebase-functions/firestore";
+import { expr } from "firebase-functions/params";
+import { onTaskDispatched } from "firebase-functions/tasks";
+import type { Role } from "firebase-functions/v2";
+import { requiresAPI, requiresRole } from "firebase-functions/v2";
+import {
+  afterFirstDeploy,
+  afterRedeploy,
+} from "firebase-functions/v2/lifecycle";
+import { CONFIG_EXPRESSIONS, configFromEnv } from "./config";
+import * as events from "./events";
+import { resolveExportConfig, toTrackerConfig } from "./export-config";
+import { type HandlerContext, handleDocumentWrite } from "./handlers";
+import { createEnsureInitialized } from "./init";
+import * as logs from "./logs";
+
+// Re-export the side-effect-free library surface (handlers and config types).
+export * from "./lib";
+
+const INIT_BIGQUERY_SYNC_FUNCTION = "initBigQuerySync";
+const SETUP_BIGQUERY_SYNC_FUNCTION = "setupBigQuerySync";
+const LIFECYCLE_RETRY_CONFIG = {
+  maxAttempts: 15,
+  minBackoffSeconds: 60,
+} as const;
+const REQUIRED_ROLES: ReadonlyArray<Role> = [
+  "roles/bigquery.dataEditor",
+  "roles/datastore.user",
+  "roles/bigquery.user",
+  // Gen2 Firestore triggers need Eventarc receive and run.invoker on the function SA.
+  "roles/eventarc.eventReceiver",
+  "roles/run.invoker",
+];
+const REQUIRED_APIS = [
+  {
+    api: "bigquery.googleapis.com",
+    reason: "Mirrors data from your Cloud Firestore collection in BigQuery.",
+  },
+] as const;
+
+for (const role of REQUIRED_ROLES) {
+  requiresRole(role);
+}
+
+for (const { api, reason } of REQUIRED_APIS) {
+  requiresAPI(api, reason);
+}
+
+afterFirstDeploy({
+  task: { function: INIT_BIGQUERY_SYNC_FUNCTION, body: { data: {} } },
+});
+afterRedeploy({
+  task: { function: SETUP_BIGQUERY_SYNC_FUNCTION, body: { data: {} } },
+});
+
+let ctx: HandlerContext | undefined;
+
+function getHandlerContext(): HandlerContext {
+  if (ctx) {
+    return ctx;
+  }
+
+  const config = resolveExportConfig(configFromEnv());
+  const tracker = new FirestoreBigQueryEventHistoryTracker(
+    toTrackerConfig(config)
+  );
+
+  logs.logger.setLogLevel(config.logLevel);
+  logs.init(config);
+
+  if (getApps().length === 0) {
+    initializeApp();
+  }
+
+  events.setupEventChannel();
+
+  const ensureInitialized = createEnsureInitialized(tracker);
+
+  ctx = {
+    tracker,
+    config,
+    ensureInitialized,
+  };
+
+  return ctx;
+}
+
+const functionOptions = {
+  region: CONFIG_EXPRESSIONS.location,
+};
+
+/**
+ * Firestore trigger: streams document writes on the watched collection into the
+ * BigQuery changelog table. Failed executions are retried by the Firebase
+ * Functions runtime.
+ */
+export const fsexportbigquery = onDocumentWritten(
+  {
+    ...functionOptions,
+    document: expr`${CONFIG_EXPRESSIONS.collectionPath}/{documentId}`,
+    database: CONFIG_EXPRESSIONS.database,
+    retry: true,
+  },
+  (event) => handleDocumentWrite(event, getHandlerContext())
+);
+
+async function handleBigQuerySyncInitialization(): Promise<void> {
+  try {
+    await getHandlerContext().ensureInitialized();
+  } catch (err) {
+    logs.error(false, "Failed to initialize BigQuery resources", err);
+    throw err;
+  }
+}
+
+/**
+ * First-deploy provisioning task (`afterFirstDeploy`). Runs in the function's
+ * own identity, so it has the runtime service account and bound secrets that
+ * creating the dataset/table/views needs (e.g. CMEK). Cloud Tasks retries a
+ * failed initialization on its own schedule, so a transient BigQuery error does
+ * not leave the resources unprovisioned. It is idempotent (`initialize()`
+ * no-ops when resources already exist) and can also be invoked directly as an
+ * authenticated HTTP POST, without queue retries.
+ */
+export const initBigQuerySync = onTaskDispatched(
+  {
+    ...functionOptions,
+    retryConfig: LIFECYCLE_RETRY_CONFIG,
+  },
+  handleBigQuerySyncInitialization
+);
+
+/**
+ * Update/configure lifecycle task. Uses the same idempotent provisioning path
+ * so BigQuery resources are reconciled after parameter changes.
+ */
+export const setupBigQuerySync = onTaskDispatched(
+  {
+    ...functionOptions,
+    retryConfig: LIFECYCLE_RETRY_CONFIG,
+  },
+  handleBigQuerySyncInitialization
+);

package/src/init.ts

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type { FirestoreBigQueryEventHistoryTracker } from "@firebaseextensions/firestore-bigquery-change-tracker";
+
+/**
+ * Builds the provisioning guard used by the `initBigQuerySync` endpoint and the
+ * retry-path self-heal. The hot write path never calls it.
+ *
+ * The returned function runs `tracker.initialize()` at most once per instance:
+ * concurrent invocations on a cold instance share a single in-flight promise. A
+ * failed initialization resets the guard so a later invocation can retry after
+ * a transient error.
+ *
+ * @param tracker - The event history tracker whose `initialize()` provisions
+ *   the BigQuery dataset, table, and views.
+ * @returns A function that resolves once the resources are provisioned.
+ */
+export function createEnsureInitialized(
+  tracker: FirestoreBigQueryEventHistoryTracker
+): () => Promise<void> {
+  let initialization: Promise<void> | null = null;
+  return () => {
+    if (!initialization) {
+      initialization = tracker.initialize().catch((err) => {
+        initialization = null;
+        throw err;
+      });
+    }
+    return initialization;
+  };
+}

package/src/lib.ts

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2019 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * Side-effect-free library surface:
+ *
+ * - {@link handleDocumentWrite} — the handler, for consumers who want to own
+ *   trigger registration themselves. It takes an injected
+ *   {@link HandlerContext}.
+ * - Config types and helpers ({@link ExportConfig}, {@link resolveExportConfig},
+ *   {@link toTrackerConfig}) for building that context.
+ *
+ * Importing this module has no side effects (it reads no environment), so it is
+ * safe to import anywhere. The main entry point (`./index`) is the one that
+ * reads env params and exports the wired functions.
+ *
+ * The change-tracker engine is an internal dependency and is deliberately not
+ * re-exported; only the types the handler signatures need are surfaced.
+ */
+
+// Engine types referenced by the handler and config signatures. Type-only —
+// the engine itself is internal. `ChangeType` is exported for handler tests and
+// advanced consumers that build Firestore events directly.
+export {
+  type ChangeTrackerConfig,
+  ChangeType,
+  type FirestoreBigQueryEventHistoryTracker,
+} from "@firebaseextensions/firestore-bigquery-change-tracker";
+// Config types and helpers
+export {
+  type ExportConfig,
+  type ResolvedExportConfig,
+  resolveExportConfig,
+  toTrackerConfig,
+  type ViewType,
+} from "./export-config";
+// Handlers
+export {
+  type DocumentWriteEvent,
+  type HandlerContext,
+  handleDocumentWrite,
+} from "./handlers";