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

package/lib/util.js

@@ -0,0 +1,66 @@
+"use strict";
+/*
+ * 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.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWildcardIds = void 0;
+exports.getChangeType = getChangeType;
+exports.getDocumentId = getDocumentId;
+const firestore_bigquery_change_tracker_1 = require("@firebaseextensions/firestore-bigquery-change-tracker");
+/**
+ * Get the change type (CREATE, UPDATE, DELETE) from the Firestore change.
+ * @param change Firestore document change object.
+ * @returns {ChangeType} The type of change.
+ */
+function getChangeType(change) {
+    if (!change.after.exists) {
+        return firestore_bigquery_change_tracker_1.ChangeType.DELETE;
+    }
+    if (!change.before.exists) {
+        return firestore_bigquery_change_tracker_1.ChangeType.CREATE;
+    }
+    return firestore_bigquery_change_tracker_1.ChangeType.UPDATE;
+}
+/**
+ * Get the document ID from the Firestore change.
+ * @param change Firestore document change object.
+ * @returns {string} The document ID.
+ */
+function getDocumentId(change) {
+    if (change.after.exists) {
+        return change.after.id;
+    }
+    return change.before.id;
+}
+/**
+ *
+ * @param template - eg, regions/{regionId}/countries
+ * @param text - eg, regions/asia/countries
+ *
+ * @return - eg, { regionId: "asia" }
+ */
+const resolveWildcardIds = (template, text) => {
+    const textSegments = text.split("/");
+    return template
+        .split("/")
+        .reduce((previousValue, currentValue, currentIndex) => {
+        if (currentValue.startsWith("{") && currentValue.endsWith("}")) {
+            previousValue[currentValue.slice(1, -1)] = textSegments[currentIndex];
+        }
+        return previousValue;
+    }, {});
+};
+exports.resolveWildcardIds = resolveWildcardIds;
+//# sourceMappingURL=util.js.map

package/lib/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sourceRoot":"","sources":["../src/util.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;;;AAEH,6GAAmF;AAGnF;;;;GAIG;AACH,uBAA8B,MAAgC;IAC5D,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QACzB,OAAO,8CAAU,CAAC,MAAM,CAAC;IAC3B,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QAC1B,OAAO,8CAAU,CAAC,MAAM,CAAC;IAC3B,CAAC;IACD,OAAO,8CAAU,CAAC,MAAM,CAAC;AAC3B,CAAC;AAED;;;;GAIG;AACH,uBAA8B,MAAgC;IAC5D,IAAI,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,CAAC;QACxB,OAAO,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IACzB,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,EAAE,CAAC;AAC1B,CAAC;AAED;;;;;;GAMG;AACI,MAAM,kBAAkB,GAAG,CAAC,QAAgB,EAAE,IAAY,EAAE,EAAE;IACnE,MAAM,YAAY,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IACrC,OAAO,QAAQ;SACZ,KAAK,CAAC,GAAG,CAAC;SACV,MAAM,CAAC,CAAC,aAAa,EAAE,YAAY,EAAE,YAAY,EAAE,EAAE;QACpD,IAAI,YAAY,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,YAAY,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/D,aAAa,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,GAAG,YAAY,CAAC,YAAY,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,aAAa,CAAC;IACvB,CAAC,EAAE,EAAE,CAAC,CAAC;AACX,CAAC,CAAC;AAVW,QAAA,kBAAkB,GAAlB,kBAAkB,CAU7B"}

package/package.json

@@ -1,11 +1,41 @@
 {
   "name": "@firebase-function-kits/firestore-bigquery-export",
-  "version": "0.0.1",
+  "version": "0.0.2-rc.0",
+  "repository": "firebase/extensions",
   "description": "Stream a Cloud Firestore collection to BigQuery as a deployable Firebase Function",
   "license": "Apache-2.0",
-  "main": "index.js",
-  "repository": "firebase/extensions",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./lib": {
+      "types": "./lib/lib.d.ts",
+      "default": "./lib/lib.js"
+    }
+  },
   "engines": {
     "node": ">=22"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "clean": "tsc -b --clean",
+    "test": "vitest run",
+    "deploy": "pnpm build && firebase deploy --only functions",
+    "serve": "firebase emulators:start --only functions"
+  },
+  "dependencies": {
+    "@firebaseextensions/firestore-bigquery-change-tracker": "^2.0.4",
+    "@google-cloud/bigquery": "^7.6.0",
+    "firebase-admin": "^14.1.0",
+    "firebase-functions": "7.3.2",
+    "generate-schema": "^2.6.0",
+    "lodash": "^4.17.14"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.17.0",
+    "vitest": "^3.2.4"
   }
 }

package/src/config.ts

@@ -0,0 +1,420 @@
+/*
+ * 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,
+  PartitioningFieldType,
+  TimePartitioningGranularity,
+} from "@firebaseextensions/firestore-bigquery-change-tracker";
+import { LogLevel } from "@firebaseextensions/firestore-bigquery-change-tracker";
+import type { Expression } from "firebase-functions/params";
+import {
+  defineBoolean,
+  defineString,
+  projectID,
+  select,
+} from "firebase-functions/params";
+import type { ExportConfig, ViewType } from "./export-config";
+
+type TrackerLogLevel = "debug" | "info" | "warn" | "error" | "silent";
+type ConfigExpression<T extends string | number | boolean> = Expression<T>;
+const DECIMAL_RADIX = 10;
+const DATASET_LOCATION_OPTIONS = [
+  "us-central1",
+  "us-west4",
+  "europe-central2",
+  "us-west2",
+  "northamerica-northeast1",
+  "us-east4",
+  "us-west1",
+  "us-west3",
+  "southamerica-east1",
+  "us-east1",
+  "europe-west1",
+  "europe-north1",
+  "europe-west3",
+  "europe-west2",
+  "europe-west4",
+  "europe-west6",
+  "asia-east1",
+  "asia-east2",
+  "asia-southeast2",
+  "asia-south1",
+  "asia-southeast1",
+  "asia-northeast2",
+  "asia-northeast3",
+  "australia-southeast1",
+  "asia-northeast1",
+  "us",
+  "eu",
+  "africa-south1",
+  "me-west1",
+  "me-central1",
+  "me-central2",
+  "europe-west12",
+  "europe-north2",
+  "europe-west9",
+  "europe-west8",
+  "europe-southwest1",
+  "europe-west10",
+  "australia-southeast2",
+  "asia-south2",
+  "northamerica-northeast2",
+  "southamerica-west1",
+  "northamerica-south1",
+  "us-south1",
+  "us-east5",
+] as const;
+const DATABASE_REGION_OPTIONS = [
+  "eur3",
+  "nam5",
+  "nam7",
+  "us-central1",
+  "us-west1",
+  "us-west2",
+  "us-west3",
+  "us-west4",
+  "us-east1",
+  "us-east4",
+  "us-east5",
+  "us-south1",
+  "northamerica-northeast1",
+  "northamerica-northeast2",
+  "northamerica-south1",
+  "southamerica-east1",
+  "southamerica-west1",
+  "europe-west1",
+  "europe-west2",
+  "europe-west3",
+  "europe-west4",
+  "europe-west6",
+  "europe-west8",
+  "europe-west9",
+  "europe-west10",
+  "europe-west12",
+  "europe-southwest1",
+  "europe-north1",
+  "europe-north2",
+  "europe-central2",
+  "me-central1",
+  "me-central2",
+  "me-west1",
+  "asia-south1",
+  "asia-south2",
+  "asia-southeast1",
+  "asia-southeast2",
+  "asia-east1",
+  "asia-east2",
+  "asia-northeast1",
+  "asia-northeast2",
+  "asia-northeast3",
+  "australia-southeast1",
+  "australia-southeast2",
+  "africa-south1",
+] as const;
+const TABLE_PARTITIONING_OPTIONS = [
+  "HOUR",
+  "DAY",
+  "MONTH",
+  "YEAR",
+  "NONE",
+] as const;
+const TIME_PARTITIONING_FIELD_TYPE_OPTIONS = [
+  "TIMESTAMP",
+  "DATETIME",
+  "DATE",
+  "omit",
+] as const;
+const VIEW_TYPE_OPTIONS = [
+  "view",
+  "materialized_incremental",
+  "materialized_non_incremental",
+] as const;
+const LOG_LEVEL_OPTIONS = ["debug", "info", "warn", "error", "silent"] as const;
+export interface ConfigExpressions {
+  collectionPath: ConfigExpression<string>;
+  datasetId: ConfigExpression<string>;
+  tableId: ConfigExpression<string>;
+  location: ConfigExpression<string>;
+  database: ConfigExpression<string>;
+}
+
+/**
+ * Deploy-time parameters. Set these via a `.env` / `.env.<project>` file or the
+ * interactive prompts shown by `firebase deploy`.
+ *
+ * @see https://firebase.google.com/docs/functions/config-env
+ */
+const params = {
+  bigqueryProjectId: defineString("BIGQUERY_PROJECT_ID", {
+    default: projectID,
+  }),
+  database: defineString("DATABASE", { default: "(default)" }),
+  databaseRegion: defineString("DATABASE_REGION", {
+    input: select([...DATABASE_REGION_OPTIONS]),
+  }),
+  collectionPath: defineString("COLLECTION_PATH", { default: "posts" }),
+  datasetId: defineString("DATASET_ID", { default: "firestore_export" }),
+  tableId: defineString("TABLE_ID", { default: "posts" }),
+  datasetLocation: defineString("DATASET_LOCATION", {
+    default: "us",
+    input: select([...DATASET_LOCATION_OPTIONS]),
+  }),
+  backupCollection: defineString("BACKUP_COLLECTION", { default: "" }),
+  transformFunction: defineString("TRANSFORM_FUNCTION", { default: "" }),
+  tablePartitioning: defineString("TABLE_PARTITIONING", {
+    default: "NONE",
+    input: select([...TABLE_PARTITIONING_OPTIONS]),
+  }),
+  timePartitioningField: defineString("TIME_PARTITIONING_FIELD", {
+    default: "",
+  }),
+  timePartitioningFieldType: defineString("TIME_PARTITIONING_FIELD_TYPE", {
+    default: "omit",
+    input: select([...TIME_PARTITIONING_FIELD_TYPE_OPTIONS]),
+  }),
+  timePartitioningFirestoreField: defineString(
+    "TIME_PARTITIONING_FIRESTORE_FIELD",
+    { default: "" }
+  ),
+  clustering: defineString("CLUSTERING", { default: "" }),
+  wildcardIds: defineBoolean("WILDCARD_IDS", {
+    default: false,
+  }),
+  useNewSnapshotQuerySyntax: defineBoolean("USE_NEW_SNAPSHOT_QUERY_SYNTAX", {
+    default: false,
+  }),
+  excludeOldData: defineBoolean("EXCLUDE_OLD_DATA", {
+    default: false,
+  }),
+  viewType: defineString("VIEW_TYPE", {
+    default: "view",
+    input: select([...VIEW_TYPE_OPTIONS]),
+  }),
+  maxStaleness: defineString("MAX_STALENESS", { default: "" }),
+  refreshIntervalMinutes: defineString("REFRESH_INTERVAL_MINUTES", {
+    default: "",
+  }),
+  kmsKeyName: defineString("KMS_KEY_NAME", { default: "" }),
+  logLevel: defineString("LOG_LEVEL", {
+    default: "info",
+    input: select([...LOG_LEVEL_OPTIONS]),
+  }),
+};
+
+export const CONFIG_EXPRESSIONS: ConfigExpressions = {
+  collectionPath: params.collectionPath,
+  datasetId: params.datasetId,
+  tableId: params.tableId,
+  location: params.databaseRegion,
+  database: params.database,
+};
+
+function timePartitioning(
+  type: string | undefined
+): TimePartitioningGranularity | null {
+  if (
+    type === "HOUR" ||
+    type === "DAY" ||
+    type === "MONTH" ||
+    type === "YEAR"
+  ) {
+    return type;
+  }
+
+  return null;
+}
+
+export function clustering(clusters: string | undefined) {
+  return clusters ? clusters.split(",").slice(0, 4) : null;
+}
+
+function normalizeOptionalPartitionValue(
+  value: string | undefined
+): string | undefined {
+  const normalized = value?.trim();
+
+  if (!normalized || normalized === "NONE" || normalized === "omit") {
+    return undefined;
+  }
+
+  return normalized;
+}
+
+function normalizePartitionFieldType(
+  value: string | undefined
+): PartitioningFieldType | undefined {
+  const normalized = normalizeOptionalPartitionValue(value);
+  if (
+    normalized === "TIMESTAMP" ||
+    normalized === "DATE" ||
+    normalized === "DATETIME"
+  ) {
+    return normalized;
+  }
+  return undefined;
+}
+
+export function buildPartitioningConfig(params: {
+  timePartitioning: TimePartitioningGranularity | null;
+  timePartitioningField: string | undefined;
+  timePartitioningFieldType: string | undefined;
+  timePartitioningFirestoreField: string | undefined;
+}): ChangeTrackerConfig["partitioning"] {
+  const { timePartitioning } = params;
+  const rawFieldName = params.timePartitioningField?.trim();
+  const rawFieldType = params.timePartitioningFieldType?.trim();
+  const rawFirestoreField = params.timePartitioningFirestoreField?.trim();
+
+  const formatValue = (value: string | undefined): string =>
+    value && value.length > 0 ? `"${value}"` : "(empty)";
+
+  const throwInvalidPartitioningConfig = (detail: string): never => {
+    throw new Error(
+      [
+        "Invalid partitioning configuration for firestore-bigquery-export.",
+        detail,
+        `Received TABLE_PARTITIONING=${formatValue(
+          timePartitioning ?? undefined
+        )},`,
+        `TIME_PARTITIONING_FIELD=${formatValue(rawFieldName)},`,
+        `TIME_PARTITIONING_FIRESTORE_FIELD=${formatValue(rawFirestoreField)},`,
+        `TIME_PARTITIONING_FIELD_TYPE=${formatValue(rawFieldType)}.`,
+        "Valid combinations are:",
+        "1) Ingestion-time: TABLE_PARTITIONING set and all TIME_PARTITIONING_* values empty/NONE/omit.",
+        "2) Timestamp field: TABLE_PARTITIONING set, TIME_PARTITIONING_FIELD=timestamp, TIME_PARTITIONING_FIRESTORE_FIELD empty.",
+        "3) Custom field: TABLE_PARTITIONING set, and TIME_PARTITIONING_FIELD + TIME_PARTITIONING_FIRESTORE_FIELD + TIME_PARTITIONING_FIELD_TYPE all provided.",
+      ].join(" ")
+    );
+  };
+
+  const fieldName = normalizeOptionalPartitionValue(
+    params.timePartitioningField
+  );
+  const fieldType = normalizePartitionFieldType(
+    params.timePartitioningFieldType
+  );
+  const firestoreField = normalizeOptionalPartitionValue(
+    params.timePartitioningFirestoreField
+  );
+
+  if (!timePartitioning) {
+    if (fieldName || fieldType || firestoreField) {
+      return throwInvalidPartitioningConfig(
+        "Partition-specific fields cannot be provided when TABLE_PARTITIONING is NONE."
+      );
+    }
+    return { granularity: "NONE" };
+  }
+
+  if (!fieldName && !firestoreField) {
+    return { granularity: timePartitioning };
+  }
+
+  if (fieldName === "timestamp" && !firestoreField) {
+    return {
+      granularity: timePartitioning,
+      bigqueryColumnName: "timestamp",
+      ...(fieldType ? { bigqueryColumnType: fieldType } : {}),
+    };
+  }
+
+  if (fieldName && firestoreField && fieldType) {
+    return {
+      granularity: timePartitioning,
+      bigqueryColumnName: fieldName,
+      bigqueryColumnType: fieldType,
+      firestoreFieldName: firestoreField,
+    };
+  }
+
+  return throwInvalidPartitioningConfig(
+    "When TABLE_PARTITIONING is set, partitioning fields are either incomplete or invalid."
+  );
+}
+
+function normalizeLogLevel(level: string | undefined): TrackerLogLevel {
+  switch ((level || "").toLowerCase()) {
+    case "debug":
+      return "debug";
+    case "info":
+      return "info";
+    case "warn":
+      return "warn";
+    case "error":
+      return "error";
+    case "silent":
+      return "silent";
+    default:
+      return LogLevel.INFO;
+  }
+}
+
+function normalizePositiveInt(value: string): number | undefined {
+  const normalized = Number.parseInt(value, DECIMAL_RADIX);
+  return normalized > 0 ? normalized : undefined;
+}
+
+/** Coerce an empty-string param value to `undefined`. */
+function optional(value: string): string | undefined {
+  return value.length > 0 ? value : undefined;
+}
+
+/**
+ * Resolves all deploy-time params into an {@link ExportConfig}.
+ *
+ * Param values are read when this is called. During the Firebase deploy-time
+ * discovery pass params return their declared defaults, so the default
+ * `TABLE_PARTITIONING=NONE` keeps {@link buildPartitioningConfig} from throwing.
+ * This is the bridge for the env-driven path: env params in, typed config out,
+ * which the main entry point wires into the exported functions.
+ *
+ * @returns The export configuration assembled from environment params.
+ */
+export function configFromEnv(): ExportConfig {
+  const tablePartitioning = optional(params.tablePartitioning.value());
+
+  return {
+    collectionPath: params.collectionPath.value(),
+    datasetId: params.datasetId.value(),
+    tableId: params.tableId.value(),
+    location: params.databaseRegion.value(),
+    datasetLocation: optional(params.datasetLocation.value()),
+    bqProjectId: optional(params.bigqueryProjectId.value()),
+    projectId: projectID.value(),
+    databaseId: optional(params.database.value()) || "(default)",
+    wildcardIds: params.wildcardIds.value(),
+    excludeOldData: params.excludeOldData.value(),
+    useNewSnapshotQuerySyntax: params.useNewSnapshotQuerySyntax.value(),
+    viewType: (optional(params.viewType.value()) || "view") as ViewType,
+    partitioning: buildPartitioningConfig({
+      timePartitioning: timePartitioning(tablePartitioning),
+      timePartitioningField: params.timePartitioningField.value(),
+      timePartitioningFieldType: params.timePartitioningFieldType.value(),
+      timePartitioningFirestoreField:
+        params.timePartitioningFirestoreField.value(),
+    }),
+    clustering: clustering(optional(params.clustering.value())),
+    maxStaleness: optional(params.maxStaleness.value()),
+    refreshIntervalMinutes: normalizePositiveInt(
+      params.refreshIntervalMinutes.value()
+    ),
+    backupCollectionId: optional(params.backupCollection.value()),
+    transformFunction: optional(params.transformFunction.value()),
+    kmsKeyName: optional(params.kmsKeyName.value()),
+    logLevel: normalizeLogLevel(params.logLevel.value()),
+  };
+}

package/src/events.ts

@@ -0,0 +1,146 @@
+/*
+ * 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 * as eventArc from "firebase-admin/eventarc";
+
+const { getEventarc } = eventArc;
+
+/**
+ * Builds the Eventarc event type for this extension.
+ *
+ * @param eventName The name of the event (e.g., "onStart", "onError", etc.)
+ * @returns The event type string.
+ */
+const getEventTypes = (eventName: string) => [
+  `firebase.extensions.firestore-bigquery-export.v1.${eventName}`,
+];
+
+let eventChannel: eventArc.Channel | undefined;
+
+/**
+ * Sets up the Eventarc channel.
+ *
+ * This function retrieves the Eventarc channel based on the environment variables:
+ * - `EVENTARC_CHANNEL` specifies the channel to use for publishing events.
+ * - `EXT_SELECTED_EVENTS` defines the allowed event types.
+ *
+ * @function setupEventChannel
+ */
+export const setupEventChannel = () => {
+  eventChannel = process.env.EVENTARC_CHANNEL
+    ? getEventarc().channel(process.env.EVENTARC_CHANNEL, {
+        allowedEventTypes: process.env.EXT_SELECTED_EVENTS,
+      })
+    : undefined;
+};
+
+/**
+ * Publishes a "start" event using both OLD and NEW event types.
+ *
+ * @param data The payload to send with the event. Can be a string or an object.
+ * @returns A Promise resolving when both events are published.
+ */
+export const recordStartEvent = async (data: string | object) => {
+  if (!eventChannel) return Promise.resolve();
+
+  const eventTypes = getEventTypes("onStart");
+
+  // Publish events for both OLD and NEW event types
+  return Promise.all(
+    eventTypes.map((type) =>
+      eventChannel.publish({
+        type,
+        data,
+      })
+    )
+  );
+};
+
+/**
+ * Publishes an "error" event using both OLD and NEW event types.
+ *
+ * @param err The Error object containing the error message.
+ * @param subject (Optional) Subject identifier related to the error event.
+ * @returns A Promise resolving when both events are published.
+ */
+export const recordErrorEvent = async (err: Error, subject?: string) => {
+  if (!eventChannel) return Promise.resolve();
+
+  const eventTypes = getEventTypes("onError");
+
+  // Publish events for both OLD and NEW event types
+  return Promise.all(
+    eventTypes.map((type) =>
+      eventChannel.publish({
+        type,
+        data: { message: err.message },
+        subject,
+      })
+    )
+  );
+};
+
+/**
+ * Publishes a "success" event using both OLD and NEW event types.
+ *
+ * @param params An object containing the subject and the event data.
+ * @param params.subject A string representing the subject of the event.
+ * @param params.data The payload to send with the event.
+ * @returns A Promise resolving when both events are published.
+ */
+export const recordSuccessEvent = async ({
+  subject,
+  data,
+}: {
+  subject: string;
+  data: string | object;
+}) => {
+  if (!eventChannel) return Promise.resolve();
+
+  const eventTypes = getEventTypes("onSuccess");
+
+  // Publish events for both OLD and NEW event types
+  return Promise.all(
+    eventTypes.map((type) =>
+      eventChannel.publish({
+        type,
+        subject,
+        data,
+      })
+    )
+  );
+};
+
+/**
+ * Publishes a "completion" event using both OLD and NEW event types.
+ *
+ * @param data The payload to send with the event. Can be a string or an object.
+ * @returns A Promise resolving when both events are published.
+ */
+export const recordCompletionEvent = async (data: string | object) => {
+  if (!eventChannel) return Promise.resolve();
+
+  const eventTypes = getEventTypes("onCompletion");
+
+  // Publish events for both OLD and NEW event types
+  return Promise.all(
+    eventTypes.map((type) =>
+      eventChannel.publish({
+        type,
+        data,
+      })
+    )
+  );
+};