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

package/tests/helper-values.test.ts

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2026 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 {
+  BigQueryDate,
+  BigQueryDatetime,
+  BigQueryTime,
+  BigQueryTimestamp,
+} from "@google-cloud/bigquery";
+import { Timestamp } from "firebase-admin/firestore";
+import { describe, expect, test } from "vitest";
+import {
+  convertUnsupportedDataTypes,
+  parseTransferConfigName,
+  parseTransferRunName,
+} from "../src/helper";
+import type { FirestoreRow } from "../src/types";
+
+describe("parseTransferRunName", () => {
+  test("parses ids containing hyphens", () => {
+    expect(
+      parseTransferRunName(
+        "projects/project-123/locations/us-central1/transferConfigs/642f3a36-0000-2fbb-ad1d-001a114e2fa6/runs/648762e0-0000-28ef-9109-001a11446b2a"
+      )
+    ).toEqual({
+      projectId: "project-123",
+      location: "us-central1",
+      transferConfigId: "642f3a36-0000-2fbb-ad1d-001a114e2fa6",
+      runId: "648762e0-0000-28ef-9109-001a11446b2a",
+    });
+  });
+
+  test("rejects a name without a runs segment", () => {
+    expect(() =>
+      parseTransferRunName("projects/p/locations/l/transferConfigs/c")
+    ).toThrow("Invalid transfer run name format");
+  });
+
+  test("rejects an empty name", () => {
+    expect(() => parseTransferRunName("")).toThrow(
+      "Invalid transfer run name format"
+    );
+  });
+});
+
+describe("parseTransferConfigName", () => {
+  test("parses ids containing hyphens", () => {
+    expect(
+      parseTransferConfigName(
+        "projects/project-123/locations/us-central1/transferConfigs/642f3a36-0000-2fbb-ad1d-001a114e2fa6"
+      )
+    ).toEqual({
+      projectId: "project-123",
+      location: "us-central1",
+      transferConfigId: "642f3a36-0000-2fbb-ad1d-001a114e2fa6",
+    });
+  });
+
+  test("rejects a transfer run name", () => {
+    expect(() =>
+      parseTransferConfigName("projects/p/locations/l/transferConfigs/c/runs/r")
+    ).toThrow("Invalid transfer config name format");
+  });
+
+  test("rejects an empty name", () => {
+    expect(() => parseTransferConfigName("")).toThrow(
+      "Invalid transfer config name format"
+    );
+  });
+});
+
+describe("convertUnsupportedDataTypes", () => {
+  test("returns null and primitives unchanged", () => {
+    expect(convertUnsupportedDataTypes(null)).toBeNull();
+    expect(convertUnsupportedDataTypes("string")).toBe("string");
+    expect(convertUnsupportedDataTypes(123)).toBe(123);
+    expect(convertUnsupportedDataTypes(true)).toBe(true);
+  });
+
+  test("converts timestamp, date, and datetime values to Firestore Timestamps", () => {
+    const converted = convertUnsupportedDataTypes({
+      timestamp: new BigQueryTimestamp("2023-01-15T10:30:00Z"),
+      date: new BigQueryDate("2023-01-15"),
+      datetime: new BigQueryDatetime("2023-01-15T10:30:00"),
+    });
+
+    expect((converted.timestamp as Timestamp).toDate().toISOString()).toBe(
+      "2023-01-15T10:30:00.000Z"
+    );
+    expect((converted.date as Timestamp).toDate().toISOString()).toBe(
+      "2023-01-15T00:00:00.000Z"
+    );
+    // A DATETIME carries no offset, so the conversion reads it in the
+    // machine's zone rather than UTC.
+    expect(converted.datetime).toEqual(
+      Timestamp.fromDate(new Date("2023-01-15T10:30:00"))
+    );
+  });
+
+  test("throws on a TIME value, which no Date can represent", () => {
+    expect(() =>
+      convertUnsupportedDataTypes({ time: new BigQueryTime("10:30:00") })
+    ).toThrow('Value for argument "seconds" is not a valid integer.');
+  });
+
+  test("converts a plain Date to a Firestore Timestamp", () => {
+    const converted = convertUnsupportedDataTypes({
+      date: new Date("2023-01-15T10:30:00Z"),
+    });
+
+    expect((converted.date as Timestamp).toDate().toISOString()).toBe(
+      "2023-01-15T10:30:00.000Z"
+    );
+  });
+
+  test("converts a Buffer to a Uint8Array of the same bytes", () => {
+    const converted = convertUnsupportedDataTypes({
+      data: Buffer.from([1, 2, 3, 4]),
+    });
+
+    expect(converted.data).toBeInstanceOf(Uint8Array);
+    // Buffer extends Uint8Array, so only this pins the conversion.
+    expect(converted.data).not.toBeInstanceOf(Buffer);
+    expect(Array.from(converted.data as Uint8Array)).toEqual([1, 2, 3, 4]);
+  });
+
+  test("descends into nested objects and arrays", () => {
+    const converted = convertUnsupportedDataTypes({
+      outer: {
+        inner: { timestamp: new BigQueryTimestamp("2023-01-15T10:30:00Z") },
+      },
+      items: [
+        { timestamp: new BigQueryTimestamp("2023-01-15T10:30:00Z") },
+        { value: "plain" },
+      ],
+    });
+
+    const inner = (converted.outer as FirestoreRow).inner as FirestoreRow;
+    const items = converted.items as FirestoreRow[];
+    expect(inner.timestamp).toBeInstanceOf(Timestamp);
+    expect(items[0].timestamp).toBeInstanceOf(Timestamp);
+    expect(items[1].value).toBe("plain");
+  });
+
+  test("preserves null values at every depth", () => {
+    const converted = convertUnsupportedDataTypes({
+      name: "test",
+      nullField: null,
+      nested: { alsoNull: null },
+    });
+
+    expect(converted.nullField).toBeNull();
+    expect((converted.nested as FirestoreRow).alsoNull).toBeNull();
+  });
+});

package/tests/helper.test.ts

@@ -14,14 +14,21 @@
  * limitations under the License.
  */
 
-import { Geography } from "@google-cloud/bigquery";
-import { Timestamp } from "firebase-admin/firestore";
-import { describe, expect, test } from "vitest";
+import { type BigQuery, Geography } from "@google-cloud/bigquery";
+import { type Firestore, Timestamp } from "firebase-admin/firestore";
+import { describe, expect, test, vi } from "vitest";
+import { resolveConfig } from "../src/export-config";
 import {
   convertUnsupportedDataTypes,
   parseTransferConfigName,
   parseTransferRunName,
+  type ResultHandlerContext,
+  writeRunResultsToFirestore,
 } from "../src/helper";
+import * as logs from "../src/logs";
+import type { TransferRunMessage } from "../src/types";
+
+vi.mock("../src/logs", { spy: true });
 
 describe("transfer resource parsing", () => {
   test("parses config and run resource names", () => {
@@ -72,3 +79,58 @@ describe("convertUnsupportedDataTypes", () => {
     expect(converted.nested).toEqual([{ value: true }]);
   });
 });
+
+describe("writeRunResultsToFirestore", () => {
+  test("logs the run id after reading results and before writing rows", async () => {
+    const add = vi.fn().mockResolvedValue({});
+    const set = vi.fn().mockResolvedValue({});
+    const db = {
+      collection: vi.fn(() => ({ add, doc: vi.fn(() => ({ set })) })),
+      runTransaction: vi.fn(
+        async (fn: (transaction: unknown) => Promise<void>) =>
+          fn({
+            get: vi.fn().mockResolvedValue({ data: () => undefined }),
+            set: vi.fn(),
+          })
+      ),
+    } as unknown as Firestore;
+    const getQueryResults = vi.fn().mockResolvedValue([[{ value: 1 }]]);
+    const bigquery = {
+      createQueryJob: vi
+        .fn()
+        .mockResolvedValue([{ id: "job-1", getQueryResults }]),
+    } as unknown as BigQuery;
+    const config = resolveConfig({
+      bigqueryDatasetLocation: "US",
+      projectId: "test-project",
+      instanceId: "users-export",
+      datasetId: "analytics",
+      tableName: "out",
+      queryString: "SELECT * FROM source.users",
+      displayName: "Users export",
+      schedule: "every 24 hours",
+    });
+    const message = {
+      json: {
+        name: "projects/test-project/locations/us/transferConfigs/config-1/runs/run-1",
+        runTime: "2026-08-20T10:05:39Z",
+        state: "SUCCEEDED",
+        destinationDatasetId: "analytics",
+        params: { destination_table_name_template: 'out_{run_time|"%H%M%S"}' },
+      },
+    } as TransferRunMessage;
+    const ctx = { db, bigquery, config } as ResultHandlerContext;
+
+    await writeRunResultsToFirestore(ctx, message);
+
+    const logSpy = vi.mocked(logs.writeRunResultsToFirestore);
+    expect(logSpy).toHaveBeenCalledTimes(1);
+    expect(logSpy).toHaveBeenCalledWith("run-1");
+    expect(logSpy.mock.invocationCallOrder[0]).toBeGreaterThan(
+      getQueryResults.mock.invocationCallOrder[0]
+    );
+    expect(logSpy.mock.invocationCallOrder[0]).toBeLessThan(
+      add.mock.invocationCallOrder[0]
+    );
+  });
+});

package/tests/notification-topic.test.ts

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2026 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 { beforeEach, describe, expect, test, vi } from "vitest";
+import { resolveConfig } from "../src/export-config";
+import type { HandlerContext } from "../src/handlers";
+
+const mocks = vi.hoisted(() => ({
+  createTransferConfig: vi.fn(),
+  getTransferConfig: vi.fn(),
+  updateTransferConfig: vi.fn(),
+  topicCreated: vi.fn(),
+}));
+
+vi.mock("../src/dts", () => ({
+  createTransferConfig: mocks.createTransferConfig,
+  getTransferConfig: mocks.getTransferConfig,
+  updateTransferConfig: mocks.updateTransferConfig,
+}));
+
+vi.mock("../src/logs", () => ({
+  complete: vi.fn(),
+  error: vi.fn(),
+  start: vi.fn(),
+  topicCreated: mocks.topicCreated,
+}));
+
+import { handleUpsertTransferConfig } from "../src/handlers";
+
+const config = resolveConfig({
+  bigqueryDatasetLocation: "US",
+  projectId: "test-project",
+  instanceId: "users-export",
+  datasetId: "analytics",
+  tableName: "users",
+  queryString: "SELECT * FROM source.users",
+  displayName: "Users export",
+  schedule: "every 24 hours",
+});
+
+function makeContext(options: { topicExists: boolean }) {
+  const set = vi.fn();
+  const exists = vi.fn().mockResolvedValue([options.topicExists]);
+  const topic = vi.fn(() => ({ exists }));
+  const createTopic = vi.fn().mockResolvedValue(undefined);
+  const collection = vi.fn(() => ({
+    doc: vi.fn(() => ({ set })),
+    where: vi.fn(() => ({
+      limit: vi.fn(() => ({
+        get: vi.fn().mockResolvedValue({ empty: true, docs: [] }),
+      })),
+    })),
+  }));
+
+  return {
+    ctx: {
+      db: { collection },
+      bigquery: {},
+      dataTransfer: {},
+      pubsub: { topic, createTopic },
+      config,
+    } as unknown as HandlerContext,
+    topic,
+    createTopic,
+  };
+}
+
+/** gRPC status codes surfaced by the Pub/Sub admin client. */
+const ALREADY_EXISTS = 6;
+const PERMISSION_DENIED = 7;
+
+function grpcError(code: number, message: string): Error {
+  return Object.assign(new Error(message), { code });
+}
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  mocks.createTransferConfig.mockResolvedValue({
+    name: "projects/p/locations/us/transferConfigs/config-1",
+  });
+});
+
+describe("ensureNotificationTopic", () => {
+  test("does not create the topic when it already exists", async () => {
+    const { ctx, topic, createTopic } = makeContext({ topicExists: true });
+
+    await handleUpsertTransferConfig(ctx);
+
+    expect(topic).toHaveBeenCalledWith(config.pubSubTopic);
+    expect(createTopic).not.toHaveBeenCalled();
+    expect(mocks.topicCreated).not.toHaveBeenCalled();
+  });
+
+  test("creates the topic when it does not exist", async () => {
+    const { ctx, createTopic } = makeContext({ topicExists: false });
+
+    await handleUpsertTransferConfig(ctx);
+
+    expect(createTopic).toHaveBeenCalledWith(config.pubSubTopic);
+    expect(mocks.topicCreated).toHaveBeenCalledWith(config.pubSubTopic);
+  });
+
+  test("swallows ALREADY_EXISTS from a concurrent create", async () => {
+    const { ctx, createTopic } = makeContext({ topicExists: false });
+    createTopic.mockRejectedValue(
+      grpcError(ALREADY_EXISTS, "Topic already exists")
+    );
+
+    await expect(handleUpsertTransferConfig(ctx)).resolves.toBeUndefined();
+
+    expect(mocks.topicCreated).not.toHaveBeenCalled();
+    expect(mocks.createTransferConfig).toHaveBeenCalledOnce();
+  });
+
+  test("rethrows other gRPC failures and skips the transfer config", async () => {
+    const { ctx, createTopic } = makeContext({ topicExists: false });
+    createTopic.mockRejectedValue(
+      grpcError(PERMISSION_DENIED, "User not authorized")
+    );
+
+    await expect(handleUpsertTransferConfig(ctx)).rejects.toThrow(
+      "User not authorized"
+    );
+
+    expect(mocks.createTransferConfig).not.toHaveBeenCalled();
+  });
+
+  test("rethrows errors that carry no gRPC status code", async () => {
+    const { ctx, createTopic } = makeContext({ topicExists: false });
+    createTopic.mockRejectedValue(new Error("network unreachable"));
+
+    await expect(handleUpsertTransferConfig(ctx)).rejects.toThrow(
+      "network unreachable"
+    );
+
+    expect(mocks.createTransferConfig).not.toHaveBeenCalled();
+  });
+});