@firebaseextensions/firestore-bigquery-change-tracker 1.1.42 → 2.0.0

package/lib/bigquery/checkUpdates.d.ts

@@ -1,8 +1,8 @@
 import { Table, TableMetadata } from "@google-cloud/bigquery/build/src/table";
-import { FirestoreBigQueryEventHistoryTrackerConfig } from ".";
+import { Config } from ".";
 interface TableRequiresUpdateOptions {
     table: Table;
-    config: FirestoreBigQueryEventHistoryTrackerConfig;
+    config: Config;
     documentIdColExists: boolean;
     pathParamsColExists: boolean;
     oldDataColExists: boolean;
@@ -10,7 +10,7 @@ interface TableRequiresUpdateOptions {
 export declare function tableRequiresUpdate({ table, config, documentIdColExists, pathParamsColExists, oldDataColExists, }: TableRequiresUpdateOptions): Promise<boolean>;
 interface ViewRequiresUpdateOptions {
     metadata?: TableMetadata;
-    config: FirestoreBigQueryEventHistoryTrackerConfig;
+    config: Config;
     documentIdColExists: boolean;
     pathParamsColExists: boolean;
     oldDataColExists: boolean;

package/lib/bigquery/checkUpdates.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.viewRequiresUpdate = exports.tableRequiresUpdate = void 0;
 const partitioning_1 = require("./partitioning");
+const config_1 = require("./partitioning/config");
 async function tableRequiresUpdate({ table, config, documentIdColExists, pathParamsColExists, oldDataColExists, }) {
     /* Setup checks */
     const { metadata } = table;
@@ -20,7 +21,8 @@ async function tableRequiresUpdate({ table, config, documentIdColExists, pathPar
     if (!oldDataColExists)
         return true;
     /** Check partitioning */
-    const partitioning = new partitioning_1.Partitioning(config, table);
+    const partitioningConfig = new config_1.PartitioningConfig(config.partitioning);
+    const partitioning = new partitioning_1.Partitioning(partitioningConfig, table);
     const isValidPartition = await partitioning.isValidPartitionForExistingTable();
     if (isValidPartition)
         return true;

package/lib/bigquery/clustering.d.ts

@@ -1,11 +1,11 @@
-import { FirestoreBigQueryEventHistoryTrackerConfig } from ".";
+import { Config } from ".";
 import * as bigquery from "@google-cloud/bigquery";
 import { TableMetadata } from "@google-cloud/bigquery";
 export declare class Clustering {
-    config: FirestoreBigQueryEventHistoryTrackerConfig;
+    config: Config;
     table: bigquery.Table;
     schema: object;
-    constructor(config: FirestoreBigQueryEventHistoryTrackerConfig, table?: bigquery.Table, schema?: object);
+    constructor(config: Config, table?: bigquery.Table, schema?: object);
     hasValidTableReference(): boolean;
     private hasInvalidFields;
     private updateCluster;

package/lib/bigquery/handleFailedTransactions.d.ts

@@ -1,3 +1,3 @@
-import { FirestoreBigQueryEventHistoryTrackerConfig } from ".";
-declare const _default: (rows: any[], config: FirestoreBigQueryEventHistoryTrackerConfig, e: Error) => Promise<void>;
+import { Config } from ".";
+declare const _default: (rows: any[], config: Config, e: Error) => Promise<void>;
 export default _default;

package/lib/bigquery/index.d.ts

@@ -1,31 +1,9 @@
 import * as bigquery from "@google-cloud/bigquery";
 import { FirestoreEventHistoryTracker, FirestoreDocumentChangeEvent } from "../tracker";
-import { LogLevel } from "../logger";
 export { RawChangelogSchema, RawChangelogViewSchema } from "./schema";
-export interface FirestoreBigQueryEventHistoryTrackerConfig {
-    datasetId: string;
-    tableId: string;
-    firestoreInstanceId?: string;
-    datasetLocation?: string | undefined;
-    transformFunction?: string | undefined;
-    timePartitioning?: string | undefined;
-    timePartitioningField?: string | undefined;
-    timePartitioningFieldType?: string | undefined;
-    timePartitioningFirestoreField?: string | undefined;
-    clustering: string[] | null;
-    databaseId?: string | undefined;
-    wildcardIds?: boolean;
-    bqProjectId?: string | undefined;
-    backupTableId?: string | undefined;
-    useNewSnapshotQuerySyntax?: boolean;
-    skipInit?: boolean;
-    kmsKeyName?: string | undefined;
-    useMaterializedView?: boolean;
-    useIncrementalMaterializedView?: boolean;
-    maxStaleness?: string;
-    refreshIntervalMinutes?: number;
-    logLevel?: LogLevel | string;
-}
+import type { Config } from "./types";
+import { PartitioningConfig } from "./partitioning/config";
+export type { Config } from "./types";
 /**
  * An FirestoreEventHistoryTracker that exports data to BigQuery.
  *
@@ -36,10 +14,11 @@ export interface FirestoreBigQueryEventHistoryTrackerConfig {
  * If any subsequent data export fails, it will attempt to reinitialize.
  */
 export declare class FirestoreBigQueryEventHistoryTracker implements FirestoreEventHistoryTracker {
-    config: FirestoreBigQueryEventHistoryTrackerConfig;
+    config: Config;
     bq: bigquery.BigQuery;
     _initialized: boolean;
-    constructor(config: FirestoreBigQueryEventHistoryTrackerConfig);
+    partitioningConfig: PartitioningConfig;
+    constructor(config: Config);
     record(events: FirestoreDocumentChangeEvent[]): Promise<void>;
     private transformRows;
     serializeData(eventData: any): any;

package/lib/bigquery/index.js

@@ -33,6 +33,7 @@ const logger_1 = require("../logger");
 var schema_2 = require("./schema");
 Object.defineProperty(exports, "RawChangelogSchema", { enumerable: true, get: function () { return schema_2.RawChangelogSchema; } });
 Object.defineProperty(exports, "RawChangelogViewSchema", { enumerable: true, get: function () { return schema_2.RawChangelogViewSchema; } });
+const config_1 = require("./partitioning/config");
 /**
  * An FirestoreEventHistoryTracker that exports data to BigQuery.
  *
@@ -48,6 +49,7 @@ class FirestoreBigQueryEventHistoryTracker {
         this._initialized = false;
         this.bq = new bigquery.BigQuery();
         this.bq.projectId = config.bqProjectId || process.env.PROJECT_ID;
+        this.partitioningConfig = new config_1.PartitioningConfig(this.config.partitioning);
         if (!this.config.datasetLocation) {
             this.config.datasetLocation = "us";
         }
@@ -59,7 +61,7 @@ class FirestoreBigQueryEventHistoryTracker {
         if (!this.config.skipInit) {
             await this.initialize();
         }
-        const partitionHandler = new partitioning_1.Partitioning(this.config);
+        const partitionHandler = new partitioning_1.Partitioning(this.partitioningConfig);
         const rows = events.map((event) => {
             const partitionValue = partitionHandler.getPartitionValue(event);
             const { documentId, ...pathParams } = event.pathParams || {};
@@ -251,6 +253,7 @@ class FirestoreBigQueryEventHistoryTracker {
             }
             catch (ex) {
                 logs.tableCreationError(this.config.datasetId, ex.message);
+                throw ex;
             }
         }
         return dataset;
@@ -263,7 +266,7 @@ class FirestoreBigQueryEventHistoryTracker {
         const dataset = this.bigqueryDataset();
         const table = dataset.table(changelogName);
         const [tableExists] = await table.exists();
-        const partitioning = new partitioning_1.Partitioning(this.config, table);
+        const partitioning = new partitioning_1.Partitioning(this.partitioningConfig, table);
         const clustering = new clustering_1.Clustering(this.config, table);
         if (tableExists) {
             logs.bigQueryTableAlreadyExists(table.id, dataset.id);
@@ -329,6 +332,7 @@ class FirestoreBigQueryEventHistoryTracker {
             }
             catch (ex) {
                 logs.tableCreationError(changelogName, ex.message);
+                throw ex;
             }
         }
         return table;

package/lib/bigquery/initializeLatestMaterializedView.d.ts

@@ -1,15 +1,15 @@
 import { BigQuery, Table } from "@google-cloud/bigquery";
-import { FirestoreBigQueryEventHistoryTrackerConfig } from ".";
+import { Config } from ".";
 interface InitializeLatestMaterializedViewOptions {
     bq: BigQuery;
-    changeTrackerConfig: FirestoreBigQueryEventHistoryTrackerConfig;
+    changeTrackerConfig: Config;
     view: Table;
     viewExists: boolean;
     rawChangeLogTableName: string;
     rawLatestViewName: string;
     schema?: any;
 }
-export declare function shouldRecreateMaterializedView(view: Table, config: FirestoreBigQueryEventHistoryTrackerConfig, source: string): Promise<boolean>;
+export declare function shouldRecreateMaterializedView(view: Table, config: Config, source: string): Promise<boolean>;
 /**
  * Creates the latest materialized view.
  */

package/lib/bigquery/initializeLatestView.d.ts

@@ -1,8 +1,8 @@
 import { BigQuery, Dataset, Table } from "@google-cloud/bigquery";
-import { FirestoreBigQueryEventHistoryTrackerConfig } from ".";
+import { Config } from ".";
 interface InitializeLatestViewOptions {
     bq: BigQuery;
-    changeTrackerConfig: FirestoreBigQueryEventHistoryTrackerConfig;
+    changeTrackerConfig: Config;
     dataset: Dataset;
     view: Table;
     viewExists: boolean;

package/lib/bigquery/schema.d.ts

@@ -1,4 +1,3 @@
-import { FirestoreBigQueryEventHistoryTrackerConfig } from ".";
 export type BigQueryFieldMode = "NULLABLE" | "REPEATED" | "REQUIRED";
 export type BigQueryFieldType = "BOOLEAN" | "NUMERIC" | "RECORD" | "STRING" | "TIMESTAMP";
 export type BigQueryField = {
@@ -48,9 +47,3 @@ export declare const RawChangelogSchema: {
         description: string;
     }[];
 };
-export declare const getNewPartitionField: (config: FirestoreBigQueryEventHistoryTrackerConfig) => {
-    name: string;
-    mode: string;
-    type: string;
-    description: string;
-};

package/lib/bigquery/schema.js

@@ -15,7 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNewPartitionField = exports.RawChangelogSchema = exports.RawChangelogViewSchema = exports.oldDataField = exports.documentPathParams = exports.documentIdField = exports.longitudeField = exports.latitudeField = exports.timestampField = exports.operationField = exports.eventIdField = exports.documentNameField = exports.dataField = void 0;
+exports.RawChangelogSchema = exports.RawChangelogViewSchema = exports.oldDataField = exports.documentPathParams = exports.documentIdField = exports.longitudeField = exports.latitudeField = exports.timestampField = exports.operationField = exports.eventIdField = exports.documentNameField = exports.dataField = void 0;
 const bigQueryField = (name, type, mode, fields) => ({
     fields,
     mode: mode || "NULLABLE",
@@ -135,14 +135,3 @@ exports.RawChangelogSchema = {
         exports.documentIdField,
     ],
 };
-// Helper function for Partitioned Changelogs field
-const getNewPartitionField = (config) => {
-    const { timePartitioningField, timePartitioningFieldType } = config;
-    return {
-        name: timePartitioningField,
-        mode: "NULLABLE",
-        type: timePartitioningFieldType,
-        description: "The document TimePartition partition field selected by user",
-    };
-};
-exports.getNewPartitionField = getNewPartitionField;

package/lib/bigquery/types.d.ts

@@ -0,0 +1,26 @@
+import { PartitioningStrategy } from "./partitioning/config";
+/**
+ * Base configuration for all variants. Includes all parameters
+ * that are not dependent on the partitioning strategy.
+ */
+export interface Config {
+    datasetId: string;
+    tableId: string;
+    firestoreInstanceId?: string;
+    datasetLocation?: string;
+    transformFunction?: string;
+    partitioning?: PartitioningStrategy;
+    clustering?: string[] | null;
+    databaseId?: string;
+    wildcardIds?: boolean;
+    bqProjectId?: string;
+    backupTableId?: string;
+    useNewSnapshotQuerySyntax?: boolean;
+    skipInit?: boolean;
+    kmsKeyName?: string;
+    useMaterializedView?: boolean;
+    useIncrementalMaterializedView?: boolean;
+    maxStaleness?: string;
+    refreshIntervalMinutes?: number;
+    logLevel?: "debug" | "info" | "warn" | "error" | "silent";
+}

package/lib/bigquery/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -2,10 +2,10 @@
   "name": "@firebaseextensions/firestore-bigquery-change-tracker",
   "repository": {
     "type": "git",
-    "url": "github.com/firebase/extensions.git",
+    "url": "git+https://github.com/firebase/extensions.git",
     "directory": "firestore-bigquery-export/firestore-bigquery-change-tracker"
   },
-  "version": "1.1.42",
+  "version": "2.0.0",
   "description": "Core change-tracker library for Cloud Firestore Collection BigQuery Exports",
   "main": "./lib/index.js",
   "scripts": {
@@ -29,9 +29,6 @@
     "@google-cloud/resource-manager": "^5.1.0",
     "firebase-admin": "^13.2.0",
     "firebase-functions": "^6.3.2",
-    "generate-schema": "^2.6.0",
-    "inquirer": "^6.4.0",
-    "lodash": "^4.17.14",
     "node-fetch": "^2.6.1",
     "sql-formatter": "^2.3.3",
     "traverse": "^0.6.6"
@@ -50,6 +47,7 @@
     "nyc": "^17.1.0",
     "rimraf": "^2.6.3",
     "ts-jest": "29.1.2",
-    "typescript": "^4.9.4"
+    "typescript": "^4.9.4",
+    "wait-for-expect": "^3.0.2"
   }
 }

package/lib/bigquery/partitioning.d.ts

@@ -1,29 +0,0 @@
-import { FirestoreBigQueryEventHistoryTrackerConfig } from ".";
-import { FirestoreDocumentChangeEvent } from "..";
-import * as bigquery from "@google-cloud/bigquery";
-export declare class Partitioning {
-    config: FirestoreBigQueryEventHistoryTrackerConfig;
-    table: bigquery.Table;
-    schema: object;
-    constructor(config: FirestoreBigQueryEventHistoryTrackerConfig, table?: bigquery.Table, schema?: object);
-    private isPartitioningEnabled;
-    private isValidPartitionTypeString;
-    private metaDataSchemaFields;
-    private isValidPartitionTypeDate;
-    private hasHourAndDatePartitionConfig;
-    private hasValidCustomPartitionConfig;
-    private hasValidTimePartitionOption;
-    private hasValidTimePartitionType;
-    hasExistingSchema(): Promise<boolean>;
-    hasValidTableReference(): boolean;
-    private isTablePartitioned;
-    isValidPartitionForExistingTable(): Promise<boolean>;
-    convertDateValue(fieldValue: Date): string;
-    getPartitionValue(event: FirestoreDocumentChangeEvent): {
-        [x: string]: any;
-    };
-    customFieldExists(fields?: any[]): boolean;
-    private shouldAddPartitioningToSchema;
-    addPartitioningToSchema(fields?: any[]): Promise<void>;
-    updateTableMetadata(options: bigquery.TableMetadata): Promise<void>;
-}

package/lib/bigquery/partitioning.js

@@ -1,277 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Partitioning = void 0;
-const __1 = require("..");
-const firebase = require("firebase-admin");
-const logs = require("../logs");
-const functions = require("firebase-functions");
-const schema_1 = require("./schema");
-const bigquery_1 = require("@google-cloud/bigquery");
-const types_1 = require("../types");
-class Partitioning {
-    constructor(config, table, schema) {
-        this.config = config;
-        this.table = table;
-        this.schema = schema;
-    }
-    isPartitioningEnabled() {
-        const { timePartitioning } = this.config;
-        return !!timePartitioning;
-    }
-    isValidPartitionTypeString(value) {
-        return typeof value === "string";
-    }
-    async metaDataSchemaFields() {
-        let metadata;
-        try {
-            [metadata] = await this.table.getMetadata();
-        }
-        catch {
-            console.log("No metadata found");
-            return null;
-        }
-        /** Return null if no valid schema on table **/
-        if (!metadata.schema)
-            return null;
-        return metadata.schema.fields;
-    }
-    isValidPartitionTypeDate(value) {
-        /* Check if valid timestamp value from sdk */
-        // if (value instanceof firebase.firestore.Timestamp) return true;
-        if (isTimestampLike(value))
-            return true;
-        /* Check if valid date/timstemap, expedted result from production  */
-        if (value && value.toDate && value.toDate())
-            return true;
-        /* Check if valid date/time value from the console, expected result from testing locally */
-        return Object.prototype.toString.call(value) === "[object Date]";
-    }
-    hasHourAndDatePartitionConfig() {
-        if (this.config.timePartitioning === "HOUR" &&
-            this.config.timePartitioningFieldType === "DATE") {
-            logs.hourAndDatePartitioningWarning();
-            return true;
-        }
-        return false;
-    }
-    hasValidCustomPartitionConfig() {
-        /* Return false if partition type option has not been set*/
-        if (!this.isPartitioningEnabled())
-            return false;
-        const { timePartitioningField, timePartitioningFieldType, timePartitioningFirestoreField, } = this.config;
-        const hasNoCustomOptions = !timePartitioningField &&
-            !timePartitioningFieldType &&
-            !timePartitioningFirestoreField;
-        /* No custom config has been set, use partition value option only */
-        if (hasNoCustomOptions)
-            return true;
-        /* check if all valid combinations have been provided*/
-        const hasOnlyTimestamp = timePartitioningField === "timestamp" &&
-            !timePartitioningFieldType &&
-            !timePartitioningFirestoreField;
-        return (hasOnlyTimestamp ||
-            (!!timePartitioningField &&
-                !!timePartitioningFieldType &&
-                !!timePartitioningFirestoreField));
-    }
-    hasValidTimePartitionOption() {
-        const { timePartitioning } = this.config;
-        return ["HOUR", "DAY", "MONTH", "YEAR"].includes(timePartitioning);
-    }
-    hasValidTimePartitionType() {
-        const { timePartitioningFieldType } = this.config;
-        if (!timePartitioningFieldType || timePartitioningFieldType === undefined)
-            return true;
-        return ["TIMESTAMP", "DATE", "DATETIME"].includes(timePartitioningFieldType);
-    }
-    async hasExistingSchema() {
-        const [metadata] = await this.table.getMetadata();
-        return !!metadata.schema;
-    }
-    hasValidTableReference() {
-        if (!this.table) {
-            logs.invalidTableReference();
-        }
-        return !!this.table;
-    }
-    async isTablePartitioned() {
-        const [tableExists] = await this.table.exists();
-        if (!this.table || !tableExists)
-            return false;
-        /* Return true if partition metadata already exists */
-        const [metadata] = await this.table.getMetadata();
-        if (metadata.timePartitioning) {
-            logs.cannotPartitionExistingTable(this.table);
-            return true;
-        }
-        /** Find schema fields **/
-        const schemaFields = await this.metaDataSchemaFields();
-        /** Return false if no schema exists */
-        if (!schemaFields)
-            return false;
-        /* Return false if time partition field not found */
-        return schemaFields.some((column) => column.name === this.config.timePartitioningField);
-    }
-    async isValidPartitionForExistingTable() {
-        /** Return false if partition type option has not been set */
-        if (!this.isPartitioningEnabled())
-            return false;
-        /* Return false if table is already partitioned */
-        const isPartitioned = await this.isTablePartitioned();
-        if (isPartitioned)
-            return false;
-        return this.hasValidCustomPartitionConfig();
-    }
-    convertDateValue(fieldValue) {
-        const { timePartitioningFieldType } = this.config;
-        /* Return as Datetime value */
-        if (timePartitioningFieldType === types_1.PartitionFieldType.DATETIME) {
-            return bigquery_1.BigQuery.datetime(fieldValue.toISOString()).value;
-        }
-        /* Return as Date value */
-        if (timePartitioningFieldType === types_1.PartitionFieldType.DATE) {
-            return bigquery_1.BigQuery.date(fieldValue.toISOString().substring(0, 10)).value;
-        }
-        /* Return as Timestamp  */
-        return bigquery_1.BigQuery.timestamp(fieldValue).value;
-    }
-    /*
-      Extracts a valid Partition field from the Document Change Event.
-      Matches result based on a pre-defined Firestore field matching the event data object.
-      Return an empty object if no field name or value provided.
-      Returns empty object if not a string or timestamp (or result of serializing a timestamp)
-      Logs warning if not a valid datatype
-      Delete changes events have no data, return early as cannot partition on empty data.
-    **/
-    getPartitionValue(event) {
-        // When old data is disabled and the operation is delete
-        // the data and old data will be null
-        if (event.data == null && event.oldData == null)
-            return {};
-        const firestoreFieldName = this.config.timePartitioningFirestoreField;
-        const fieldName = this.config.timePartitioningField;
-        const fieldValue = event.operation === __1.ChangeType.DELETE
-            ? event.oldData[firestoreFieldName]
-            : event.data[firestoreFieldName];
-        if (!fieldName || !fieldValue) {
-            return {};
-        }
-        if (this.isValidPartitionTypeString(fieldValue)) {
-            return { [fieldName]: fieldValue };
-        }
-        if (this.isValidPartitionTypeDate(fieldValue)) {
-            /* Return converted console value */
-            if (isTimestampLike(fieldValue)) {
-                const convertedTimestampFieldValue = convertToTimestamp(fieldValue);
-                return {
-                    [fieldName]: this.convertDateValue(convertedTimestampFieldValue.toDate()),
-                };
-            }
-            if (fieldValue.toDate) {
-                return { [fieldName]: this.convertDateValue(fieldValue.toDate()) };
-            }
-            /* Return standard date value */
-            return { [fieldName]: fieldValue };
-        }
-        logs.firestoreTimePartitionFieldError(event.documentName, fieldName, firestoreFieldName, fieldValue);
-        return {};
-    }
-    customFieldExists(fields = []) {
-        /** Extract the time partioning field name */
-        const { timePartitioningField } = this.config;
-        /** Return based the field already exist */
-        return fields.map(($) => $.name).includes(timePartitioningField);
-    }
-    async shouldAddPartitioningToSchema(fields) {
-        if (!this.isPartitioningEnabled()) {
-            return { proceed: false, message: "Partitioning not enabled" };
-        }
-        if (!this.hasValidTableReference()) {
-            return { proceed: false, message: "Invalid table reference" };
-        }
-        if (!this.hasValidCustomPartitionConfig()) {
-            return { proceed: false, message: "Invalid partition config" };
-        }
-        if (!this.hasValidTimePartitionType()) {
-            return { proceed: false, message: "Invalid partition type" };
-        }
-        if (!this.hasValidTimePartitionOption()) {
-            return { proceed: false, message: "Invalid partition option" };
-        }
-        if (this.hasHourAndDatePartitionConfig()) {
-            return {
-                proceed: false,
-                message: "Invalid partitioning and field type combination",
-            };
-        }
-        if (this.customFieldExists(fields)) {
-            return { proceed: false, message: "Field already exists on schema" };
-        }
-        if (await this.isTablePartitioned()) {
-            return { proceed: false, message: "Table is already partitioned" };
-        }
-        if (!this.config.timePartitioningField) {
-            return { proceed: false, message: "Partition field not provided" };
-        }
-        return { proceed: true, message: "" };
-    }
-    async addPartitioningToSchema(fields = []) {
-        const { proceed, message } = await this.shouldAddPartitioningToSchema(fields);
-        if (!proceed) {
-            functions.logger.warn(`Did not add partitioning to schema: ${message}`);
-            return;
-        }
-        // Add new partitioning field
-        fields.push((0, schema_1.getNewPartitionField)(this.config));
-        functions.logger.log(`Added new partition field: ${this.config.timePartitioningField} to table ID: ${this.table.id}`);
-    }
-    async updateTableMetadata(options) {
-        /** Return if partition type option has not been set */
-        if (!this.isPartitioningEnabled())
-            return;
-        /** Return if class has invalid table reference */
-        if (!this.hasValidTableReference())
-            return;
-        /** Return if table is already partitioned **/
-        if (await this.isTablePartitioned())
-            return;
-        /** Return if an invalid partition type has been requested**/
-        if (!this.hasValidCustomPartitionConfig())
-            return;
-        /** Return if an invalid partition type has been requested**/
-        if (!this.hasValidTimePartitionType())
-            return;
-        /** Update fields with new schema option ** */
-        if (!this.hasValidTimePartitionOption())
-            return;
-        /** Return if invalid partitioning and field type combination */
-        if (this.hasHourAndDatePartitionConfig())
-            return;
-        if (this.config.timePartitioning) {
-            options.timePartitioning = { type: this.config.timePartitioning };
-        }
-        //TODO: Add check for skipping adding views partition field, this is not a feature that can be added .
-        if (this.config.timePartitioningField) {
-            options.timePartitioning = {
-                ...options.timePartitioning,
-                field: this.config.timePartitioningField,
-            };
-        }
-    }
-}
-exports.Partitioning = Partitioning;
-const isTimestampLike = (value) => {
-    if (value instanceof firebase.firestore.Timestamp)
-        return true;
-    return (typeof value === "object" &&
-        value !== null &&
-        "_seconds" in value &&
-        typeof value["_seconds"] === "number" &&
-        "_nanoseconds" in value &&
-        typeof value["_nanoseconds"] === "number");
-};
-const convertToTimestamp = (value) => {
-    if (value instanceof firebase.firestore.Timestamp)
-        return value;
-    return new firebase.firestore.Timestamp(value._seconds, value._nanoseconds);
-};

package/lib/bigquery/utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/bigquery/utils.test.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("./utils");
-const logs = require("../logs");
-jest.mock("@google-cloud/bigquery");
-jest.mock("../../logs");
-const dataset = {
-    exists: jest.fn(),
-    table: jest.fn(),
-};
-const table = {
-    exists: jest.fn(),
-};
-const changelogName = "testTable";
-describe("waitForInitialization", () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        dataset.table.mockReturnValue(table);
-    });
-    test("should successfully find the dataset and table", async () => {
-        dataset.exists.mockResolvedValue([true]);
-        table.exists.mockResolvedValue([true]);
-        const result = await (0, utils_1.waitForInitialization)({
-            dataset: dataset,
-            changelogName,
-        });
-        expect(result).toBe(table);
-        expect(dataset.exists).toHaveBeenCalledTimes(1);
-        expect(table.exists).toHaveBeenCalledTimes(1);
-    });
-    test("should fail after max attempts if table does not exist", async () => {
-        dataset.exists.mockResolvedValue([true]);
-        table.exists.mockResolvedValue([false]);
-        await expect((0, utils_1.waitForInitialization)({ dataset: dataset, changelogName }, 3)).rejects.toThrow("Initialization timed out. Dataset or table could not be verified to exist after multiple attempts.");
-        expect(dataset.exists).toHaveBeenCalledTimes(3);
-        expect(table.exists).toHaveBeenCalledTimes(3);
-    });
-    test("should handle and throw an error if dataset.exists throws", async () => {
-        const error = new Error("Access denied");
-        dataset.exists.mockRejectedValue(error);
-        await expect((0, utils_1.waitForInitialization)({
-            dataset: dataset,
-            changelogName,
-        })).rejects.toThrow("Access denied");
-        expect(logs.failedToInitializeWait).toHaveBeenCalledWith(error.message);
-    });
-    test("should handle and throw an error if table.exists throws", async () => {
-        dataset.exists.mockResolvedValue([true]);
-        const error = new Error("Table error");
-        table.exists.mockRejectedValue(error);
-        await expect((0, utils_1.waitForInitialization)({
-            dataset: dataset,
-            changelogName,
-        })).rejects.toThrow("Table error");
-        expect(logs.failedToInitializeWait).toHaveBeenCalledWith(error.message);
-    });
-    test("should handle unexpected error types gracefully", async () => {
-        dataset.exists.mockRejectedValue("String error");
-        await expect((0, utils_1.waitForInitialization)({
-            dataset: dataset,
-            changelogName,
-        })).rejects.toThrow("An unexpected error occurred");
-        expect(logs.failedToInitializeWait).toHaveBeenCalledWith("An unexpected error occurred");
-    });
-});