@firebaseextensions/firestore-bigquery-change-tracker 1.1.39 → 1.1.40

package/lib/bigquery/index.d.ts

@@ -1,5 +1,6 @@
 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;
@@ -22,6 +23,7 @@ export interface FirestoreBigQueryEventHistoryTrackerConfig {
     useIncrementalMaterializedView?: boolean;
     maxStaleness?: string;
     refreshIntervalMinutes?: number;
+    logLevel?: LogLevel | string;
 }
 /**
  * An FirestoreEventHistoryTracker that exports data to BigQuery.

package/lib/bigquery/index.js

@@ -14,6 +14,7 @@ const clustering_1 = require("./clustering");
 const checkUpdates_1 = require("./checkUpdates");
 const utils_1 = require("./utils");
 const initializeLatestView_1 = require("./initializeLatestView");
+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; } });
@@ -35,6 +36,7 @@ class FirestoreBigQueryEventHistoryTracker {
         if (!this.config.datasetLocation) {
             this.config.datasetLocation = "us";
         }
+        logger_1.logger.setLogLevel(this.config.logLevel || logger_1.LogLevel.INFO);
     }
     async record(events) {
         if (!this.config.skipInit) {

package/lib/index.d.ts

@@ -1,2 +1,3 @@
 export { FirestoreBigQueryEventHistoryTracker, RawChangelogSchema, RawChangelogViewSchema, } from "./bigquery";
 export { ChangeType, FirestoreDocumentChangeEvent, FirestoreEventHistoryTracker, } from "./tracker";
+export { LogLevel, Logger } from "./logger";

package/lib/index.js

@@ -15,10 +15,13 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChangeType = exports.RawChangelogViewSchema = exports.RawChangelogSchema = exports.FirestoreBigQueryEventHistoryTracker = void 0;
+exports.Logger = exports.LogLevel = exports.ChangeType = exports.RawChangelogViewSchema = exports.RawChangelogSchema = exports.FirestoreBigQueryEventHistoryTracker = void 0;
 var bigquery_1 = require("./bigquery");
 Object.defineProperty(exports, "FirestoreBigQueryEventHistoryTracker", { enumerable: true, get: function () { return bigquery_1.FirestoreBigQueryEventHistoryTracker; } });
 Object.defineProperty(exports, "RawChangelogSchema", { enumerable: true, get: function () { return bigquery_1.RawChangelogSchema; } });
 Object.defineProperty(exports, "RawChangelogViewSchema", { enumerable: true, get: function () { return bigquery_1.RawChangelogViewSchema; } });
 var tracker_1 = require("./tracker");
 Object.defineProperty(exports, "ChangeType", { enumerable: true, get: function () { return tracker_1.ChangeType; } });
+var logger_1 = require("./logger");
+Object.defineProperty(exports, "LogLevel", { enumerable: true, get: function () { return logger_1.LogLevel; } });
+Object.defineProperty(exports, "Logger", { enumerable: true, get: function () { return logger_1.Logger; } });

package/lib/logger.d.ts

@@ -0,0 +1,19 @@
+export declare enum LogLevel {
+    DEBUG = "debug",
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error",
+    SILENT = "silent"
+}
+export declare class Logger {
+    private logLevel;
+    constructor(logLevel?: LogLevel | string);
+    setLogLevel(logLevel: LogLevel | string): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    log(...args: any[]): void;
+    private runIfLogLevel;
+}
+export declare const logger: Logger;

package/lib/logger.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.Logger = exports.LogLevel = void 0;
+/*
+ * 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.
+ */
+const firebase_functions_1 = require("firebase-functions");
+var LogLevel;
+(function (LogLevel) {
+    LogLevel["DEBUG"] = "debug";
+    LogLevel["INFO"] = "info";
+    LogLevel["WARN"] = "warn";
+    LogLevel["ERROR"] = "error";
+    LogLevel["SILENT"] = "silent";
+})(LogLevel = exports.LogLevel || (exports.LogLevel = {}));
+const levels = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    silent: 4,
+};
+class Logger {
+    constructor(logLevel = LogLevel.INFO) {
+        this.setLogLevel(logLevel);
+    }
+    setLogLevel(logLevel) {
+        if (typeof logLevel === "string") {
+            this.logLevel = levels[logLevel] ?? levels.info;
+        }
+        else {
+            this.logLevel = levels[logLevel];
+        }
+    }
+    debug(...args) {
+        this.runIfLogLevel(levels.debug, firebase_functions_1.logger.debug, ...args);
+    }
+    info(...args) {
+        this.runIfLogLevel(levels.info, firebase_functions_1.logger.info, ...args);
+    }
+    warn(...args) {
+        this.runIfLogLevel(levels.warn, firebase_functions_1.logger.warn, ...args);
+    }
+    error(...args) {
+        this.runIfLogLevel(levels.error, firebase_functions_1.logger.error, ...args);
+    }
+    log(...args) {
+        this.info(...args);
+    }
+    runIfLogLevel(level, func, ...args) {
+        if (this.logLevel <= level) {
+            func(...args);
+        }
+    }
+}
+exports.Logger = Logger;
+exports.logger = new Logger();

package/lib/logs.js

@@ -16,208 +16,208 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.updatingMetadata = exports.failedToInitializeWait = exports.tableCreationError = exports.invalidClustering = exports.invalidClusteringTypes = exports.hourAndDatePartitioningWarning = exports.invalidTableReference = exports.invalidProjectIdWarning = exports.cannotPartitionExistingTable = exports.removedClustering = exports.updatedClustering = exports.bigQueryTableInsertErrors = exports.firestoreTimePartitioningParametersWarning = exports.firestoreTimePartitionFieldError = exports.addPartitionFieldColumn = exports.addNewColumn = exports.timestampMissingValue = exports.error = exports.dataTypeInvalid = exports.dataInserting = exports.dataInsertRetried = exports.dataInserted = exports.complete = exports.bigQueryViewValidating = exports.bigQueryViewValidated = exports.bigQueryViewUpToDate = exports.bigQueryViewUpdating = exports.bigQueryViewUpdated = exports.bigQueryViewAlreadyExists = exports.bigQueryViewCreating = exports.bigQueryViewCreated = exports.bigQueryUserDefinedFunctionCreated = exports.bigQueryUserDefinedFunctionCreating = exports.bigQueryTableValidating = exports.bigQueryTableValidated = exports.bigQueryTableUpToDate = exports.bigQueryTableUpdating = exports.bigQueryTableUpdated = exports.bigQueryTableCreating = exports.bigQueryTableCreated = exports.bigQueryTableAlreadyExists = exports.bigQuerySchemaViewCreated = exports.bigQueryLatestSnapshotViewQueryCreated = exports.bigQueryErrorRecordingDocumentChange = exports.bigQueryDatasetExists = exports.bigQueryDatasetCreating = exports.bigQueryDatasetCreated = exports.arrayFieldInvalid = void 0;
-const firebase_functions_1 = require("firebase-functions");
+const logger_1 = require("./logger");
 const arrayFieldInvalid = (fieldName) => {
-    firebase_functions_1.logger.warn(`Array field '${fieldName}' does not contain an array, skipping`);
+    logger_1.logger.warn(`Array field '${fieldName}' does not contain an array, skipping`);
 };
 exports.arrayFieldInvalid = arrayFieldInvalid;
 const bigQueryDatasetCreated = (datasetId) => {
-    firebase_functions_1.logger.log(`Created BigQuery dataset: ${datasetId}`);
+    logger_1.logger.info(`Created BigQuery dataset: ${datasetId}`);
 };
 exports.bigQueryDatasetCreated = bigQueryDatasetCreated;
 const bigQueryDatasetCreating = (datasetId) => {
-    firebase_functions_1.logger.log(`Creating BigQuery dataset: ${datasetId}`);
+    logger_1.logger.debug(`Creating BigQuery dataset: ${datasetId}`);
 };
 exports.bigQueryDatasetCreating = bigQueryDatasetCreating;
 const bigQueryDatasetExists = (datasetId) => {
-    firebase_functions_1.logger.log(`BigQuery dataset already exists: ${datasetId}`);
+    logger_1.logger.info(`BigQuery dataset already exists: ${datasetId}`);
 };
 exports.bigQueryDatasetExists = bigQueryDatasetExists;
 const bigQueryErrorRecordingDocumentChange = (e) => {
-    firebase_functions_1.logger.error(`Error recording document changes.`, e);
+    logger_1.logger.error(`Error recording document changes.`, e);
 };
 exports.bigQueryErrorRecordingDocumentChange = bigQueryErrorRecordingDocumentChange;
 const bigQueryLatestSnapshotViewQueryCreated = (query) => {
-    firebase_functions_1.logger.log(`BigQuery latest snapshot view query:\n${query}`);
+    logger_1.logger.debug(`BigQuery latest snapshot view query:\n${query}`);
 };
 exports.bigQueryLatestSnapshotViewQueryCreated = bigQueryLatestSnapshotViewQueryCreated;
 const bigQuerySchemaViewCreated = (name) => {
-    firebase_functions_1.logger.log(`BigQuery created schema view ${name}\n`);
+    logger_1.logger.debug(`BigQuery created schema view ${name}\n`);
 };
 exports.bigQuerySchemaViewCreated = bigQuerySchemaViewCreated;
 const bigQueryTableAlreadyExists = (tableName, datasetName) => {
-    firebase_functions_1.logger.log(`BigQuery table with name ${tableName} already ` +
+    logger_1.logger.debug(`BigQuery table with name ${tableName} already ` +
         `exists in dataset ${datasetName}!`);
 };
 exports.bigQueryTableAlreadyExists = bigQueryTableAlreadyExists;
 const bigQueryTableCreated = (tableName) => {
-    firebase_functions_1.logger.log(`Created BigQuery table: ${tableName}`);
+    logger_1.logger.info(`Created BigQuery table: ${tableName}`);
 };
 exports.bigQueryTableCreated = bigQueryTableCreated;
 const bigQueryTableCreating = (tableName) => {
-    firebase_functions_1.logger.log(`Creating BigQuery table: ${tableName}`);
+    logger_1.logger.debug(`Creating BigQuery table: ${tableName}`);
 };
 exports.bigQueryTableCreating = bigQueryTableCreating;
 const bigQueryTableUpdated = (tableName) => {
-    firebase_functions_1.logger.log(`Updated existing BigQuery table: ${tableName}`);
+    logger_1.logger.info(`Updated existing BigQuery table: ${tableName}`);
 };
 exports.bigQueryTableUpdated = bigQueryTableUpdated;
 const bigQueryTableUpdating = (tableName) => {
-    firebase_functions_1.logger.log(`Updating existing BigQuery table: ${tableName}`);
+    logger_1.logger.debug(`Updating existing BigQuery table: ${tableName}`);
 };
 exports.bigQueryTableUpdating = bigQueryTableUpdating;
 const bigQueryTableUpToDate = (tableName) => {
-    firebase_functions_1.logger.log(`BigQuery table: ${tableName} is up to date`);
+    logger_1.logger.info(`BigQuery table: ${tableName} is up to date`);
 };
 exports.bigQueryTableUpToDate = bigQueryTableUpToDate;
 const bigQueryTableValidated = (tableName) => {
-    firebase_functions_1.logger.log(`Validated existing BigQuery table: ${tableName}`);
+    logger_1.logger.info(`Validated existing BigQuery table: ${tableName}`);
 };
 exports.bigQueryTableValidated = bigQueryTableValidated;
 const bigQueryTableValidating = (tableName) => {
-    firebase_functions_1.logger.log(`Validating existing BigQuery table: ${tableName}`);
+    logger_1.logger.debug(`Validating existing BigQuery table: ${tableName}`);
 };
 exports.bigQueryTableValidating = bigQueryTableValidating;
 const bigQueryUserDefinedFunctionCreating = (functionName) => {
-    firebase_functions_1.logger.log(`Creating BigQuery user-defined function ${functionName}`);
+    logger_1.logger.debug(`Creating BigQuery user-defined function ${functionName}`);
 };
 exports.bigQueryUserDefinedFunctionCreating = bigQueryUserDefinedFunctionCreating;
 const bigQueryUserDefinedFunctionCreated = (functionName) => {
-    firebase_functions_1.logger.log(`Created BigQuery user-defined function ${functionName}`);
+    logger_1.logger.info(`Created BigQuery user-defined function ${functionName}`);
 };
 exports.bigQueryUserDefinedFunctionCreated = bigQueryUserDefinedFunctionCreated;
 const bigQueryViewCreated = (viewName) => {
-    firebase_functions_1.logger.log(`Created BigQuery view: ${viewName}`);
+    logger_1.logger.info(`Created BigQuery view: ${viewName}`);
 };
 exports.bigQueryViewCreated = bigQueryViewCreated;
 const bigQueryViewCreating = (viewName, query) => {
-    firebase_functions_1.logger.log(`Creating BigQuery view: ${viewName}\nQuery:\n${query}`);
+    logger_1.logger.debug(`Creating BigQuery view: ${viewName}\nQuery:\n${query}`);
 };
 exports.bigQueryViewCreating = bigQueryViewCreating;
 const bigQueryViewAlreadyExists = (viewName, datasetName) => {
-    firebase_functions_1.logger.log(`View with id ${viewName} already exists in dataset ${datasetName}.`);
+    logger_1.logger.info(`View with id ${viewName} already exists in dataset ${datasetName}.`);
 };
 exports.bigQueryViewAlreadyExists = bigQueryViewAlreadyExists;
 const bigQueryViewUpdated = (viewName) => {
-    firebase_functions_1.logger.log(`Updated existing BigQuery view: ${viewName}`);
+    logger_1.logger.info(`Updated existing BigQuery view: ${viewName}`);
 };
 exports.bigQueryViewUpdated = bigQueryViewUpdated;
 const bigQueryViewUpdating = (viewName) => {
-    firebase_functions_1.logger.log(`Updating existing BigQuery view: ${viewName}`);
+    logger_1.logger.debug(`Updating existing BigQuery view: ${viewName}`);
 };
 exports.bigQueryViewUpdating = bigQueryViewUpdating;
 const bigQueryViewUpToDate = (viewName) => {
-    firebase_functions_1.logger.log(`BigQuery view: ${viewName} is up to date`);
+    logger_1.logger.info(`BigQuery view: ${viewName} is up to date`);
 };
 exports.bigQueryViewUpToDate = bigQueryViewUpToDate;
 const bigQueryViewValidated = (viewName) => {
-    firebase_functions_1.logger.log(`Validated existing BigQuery view: ${viewName}`);
+    logger_1.logger.info(`Validated existing BigQuery view: ${viewName}`);
 };
 exports.bigQueryViewValidated = bigQueryViewValidated;
 const bigQueryViewValidating = (viewName) => {
-    firebase_functions_1.logger.log(`Validating existing BigQuery view: ${viewName}`);
+    logger_1.logger.debug(`Validating existing BigQuery view: ${viewName}`);
 };
 exports.bigQueryViewValidating = bigQueryViewValidating;
 const complete = () => {
-    firebase_functions_1.logger.log("Completed mod execution");
+    logger_1.logger.info("Completed mod execution");
 };
 exports.complete = complete;
 const dataInserted = (rowCount) => {
-    firebase_functions_1.logger.log(`Inserted ${rowCount} row(s) of data into BigQuery`);
+    logger_1.logger.debug(`Inserted ${rowCount} row(s) of data into BigQuery`);
 };
 exports.dataInserted = dataInserted;
 const dataInsertRetried = (rowCount) => {
-    firebase_functions_1.logger.log(`Retried to insert ${rowCount} row(s) of data into BigQuery (ignoring unknown columns)`);
+    logger_1.logger.debug(`Retried to insert ${rowCount} row(s) of data into BigQuery (ignoring unknown columns)`);
 };
 exports.dataInsertRetried = dataInsertRetried;
 const dataInserting = (rowCount) => {
-    firebase_functions_1.logger.log(`Inserting ${rowCount} row(s) of data into BigQuery`);
+    logger_1.logger.debug(`Inserting ${rowCount} row(s) of data into BigQuery`);
 };
 exports.dataInserting = dataInserting;
 const dataTypeInvalid = (fieldName, fieldType, dataType) => {
-    firebase_functions_1.logger.warn(`Field '${fieldName}' has invalid data. Expected: ${fieldType}, received: ${dataType}`);
+    logger_1.logger.warn(`Field '${fieldName}' has invalid data. Expected: ${fieldType}, received: ${dataType}`);
 };
 exports.dataTypeInvalid = dataTypeInvalid;
 const error = (err) => {
-    firebase_functions_1.logger.error("Error when mirroring data to BigQuery", err);
+    logger_1.logger.error("Error when mirroring data to BigQuery", err);
 };
 exports.error = error;
 const timestampMissingValue = (fieldName) => {
-    firebase_functions_1.logger.warn(`Missing value for timestamp field: ${fieldName}, using default timestamp instead.`);
+    logger_1.logger.warn(`Missing value for timestamp field: ${fieldName}, using default timestamp instead.`);
 };
 exports.timestampMissingValue = timestampMissingValue;
 const addNewColumn = (table, field) => {
-    firebase_functions_1.logger.log(`Updated '${table}' table with a '${field}' column`);
+    logger_1.logger.info(`Updated '${table}' table with a '${field}' column`);
 };
 exports.addNewColumn = addNewColumn;
 const addPartitionFieldColumn = (table, field) => {
-    firebase_functions_1.logger.log(`Updated '${table}' table with a partition field '${field}' column`);
+    logger_1.logger.info(`Updated '${table}' table with a partition field '${field}' column`);
 };
 exports.addPartitionFieldColumn = addPartitionFieldColumn;
 const firestoreTimePartitionFieldError = (documentName, fieldName, firestoreFieldName, firestoreFieldData) => {
-    firebase_functions_1.logger.warn(`Wrong type of Firestore Field for TimePartitioning. Accepts only strings in BigQuery format (DATE, DATETIME, TIMESTAMP) and Firestore Timestamp. Firestore Document field path: ${documentName}. Field name: ${firestoreFieldName}. Field data: ${firestoreFieldData}. Schema field "${fieldName}" value will be null.`);
+    logger_1.logger.warn(`Wrong type of Firestore Field for TimePartitioning. Accepts only strings in BigQuery format (DATE, DATETIME, TIMESTAMP) and Firestore Timestamp. Firestore Document field path: ${documentName}. Field name: ${firestoreFieldName}. Field data: ${firestoreFieldData}. Schema field "${fieldName}" value will be null.`);
 };
 exports.firestoreTimePartitionFieldError = firestoreTimePartitionFieldError;
 const firestoreTimePartitioningParametersWarning = (fieldName, fieldType, firestoreFieldName, dataFirestoreField) => {
-    firebase_functions_1.logger.warn("All TimePartitioning option parameters need to be available to create new custom schema field");
-    !fieldName && firebase_functions_1.logger.warn(`Parameter missing: TIME_PARTITIONING_FIELD`);
-    !fieldType && firebase_functions_1.logger.warn(`Parameter missing: TIME_PARTITIONING_FIELD_TYPE`);
+    logger_1.logger.warn("All TimePartitioning option parameters need to be available to create new custom schema field");
+    !fieldName && logger_1.logger.warn(`Parameter missing: TIME_PARTITIONING_FIELD`);
+    !fieldType && logger_1.logger.warn(`Parameter missing: TIME_PARTITIONING_FIELD_TYPE`);
     !firestoreFieldName &&
-        firebase_functions_1.logger.warn(`Parameter missing: TIME_PARTITIONING_FIRESTORE_FIELD`);
+        logger_1.logger.warn(`Parameter missing: TIME_PARTITIONING_FIRESTORE_FIELD`);
     !dataFirestoreField &&
-        firebase_functions_1.logger.warn(`No data found in Firestore Document under selected field: "${firestoreFieldName}"`);
+        logger_1.logger.warn(`No data found in Firestore Document under selected field: "${firestoreFieldName}"`);
 };
 exports.firestoreTimePartitioningParametersWarning = firestoreTimePartitioningParametersWarning;
 const bigQueryTableInsertErrors = (insertErrors) => {
-    firebase_functions_1.logger.warn(`Error when inserting data to table.`);
+    logger_1.logger.warn(`Error when inserting data to table.`);
     insertErrors?.forEach((error) => {
-        firebase_functions_1.logger.warn("ROW DATA JSON:");
-        firebase_functions_1.logger.warn(error.row);
-        error.errors?.forEach((error) => firebase_functions_1.logger.warn(`ROW ERROR MESSAGE: ${error.message}`));
+        logger_1.logger.warn("ROW DATA JSON:");
+        logger_1.logger.warn(error.row);
+        error.errors?.forEach((error) => logger_1.logger.warn(`ROW ERROR MESSAGE: ${error.message}`));
     });
 };
 exports.bigQueryTableInsertErrors = bigQueryTableInsertErrors;
 const updatedClustering = (fields) => {
-    firebase_functions_1.logger.info(`Clustering updated with new settings fields: ${fields}`);
+    logger_1.logger.info(`Clustering updated with new settings fields: ${fields}`);
 };
 exports.updatedClustering = updatedClustering;
 const removedClustering = (tableName) => {
-    firebase_functions_1.logger.info(`Clustering removed on ${tableName}`);
+    logger_1.logger.info(`Clustering removed on ${tableName}`);
 };
 exports.removedClustering = removedClustering;
 const cannotPartitionExistingTable = (table) => {
-    firebase_functions_1.logger.warn(`Cannot partition an existing table ${table.dataset.id}_${table.id}`);
+    logger_1.logger.warn(`Cannot partition an existing table ${table.dataset.id}_${table.id}`);
 };
 exports.cannotPartitionExistingTable = cannotPartitionExistingTable;
 function invalidProjectIdWarning(bqProjectId) {
-    firebase_functions_1.logger.warn(`Invalid project Id ${bqProjectId}, data cannot be synchronized`);
+    logger_1.logger.warn(`Invalid project Id ${bqProjectId}, data cannot be synchronized`);
 }
 exports.invalidProjectIdWarning = invalidProjectIdWarning;
 function invalidTableReference() {
-    firebase_functions_1.logger.warn(`No valid table reference is available. Skipping partitioning`);
+    logger_1.logger.warn(`No valid table reference is available. Skipping partitioning`);
 }
 exports.invalidTableReference = invalidTableReference;
 function hourAndDatePartitioningWarning() {
-    firebase_functions_1.logger.warn(`Cannot partition table with hour partitioning and Date. For DATE columns, the partitions can have daily, monthly, or yearly granularity. Skipping partitioning`);
+    logger_1.logger.warn(`Cannot partition table with hour partitioning and Date. For DATE columns, the partitions can have daily, monthly, or yearly granularity. Skipping partitioning`);
 }
 exports.hourAndDatePartitioningWarning = hourAndDatePartitioningWarning;
 function invalidClusteringTypes(fields) {
-    firebase_functions_1.logger.warn(`Unable to add clustering, field(s) ${fields} have invalid types.`);
+    logger_1.logger.warn(`Unable to add clustering, field(s) ${fields} have invalid types.`);
 }
 exports.invalidClusteringTypes = invalidClusteringTypes;
 function invalidClustering(fields) {
-    firebase_functions_1.logger.warn(`Unable to add clustering, field(s) ${fields} do not exist on the expected table`);
+    logger_1.logger.warn(`Unable to add clustering, field(s) ${fields} do not exist on the expected table`);
 }
 exports.invalidClustering = invalidClustering;
 const tableCreationError = (table, message) => {
-    firebase_functions_1.logger.warn(`Error caught creating table`, message);
+    logger_1.logger.warn(`Error caught creating table`, message);
 };
 exports.tableCreationError = tableCreationError;
 const failedToInitializeWait = (message) => {
-    firebase_functions_1.logger.warn(`Failed while waiting to initialize.`, message);
+    logger_1.logger.warn(`Failed while waiting to initialize.`, message);
 };
 exports.failedToInitializeWait = failedToInitializeWait;
 const updatingMetadata = (tableName, resources) => {
-    firebase_functions_1.logger.info(`Updated Metadata on ${tableName}, ${JSON.stringify(resources)})`);
+    logger_1.logger.info(`Updated Metadata on ${tableName}, ${JSON.stringify(resources)})`);
 };
 exports.updatingMetadata = updatingMetadata;

package/package.json

@@ -5,7 +5,7 @@
     "url": "github.com/firebase/extensions.git",
     "directory": "firestore-bigquery-export/firestore-bigquery-change-tracker"
   },
-  "version": "1.1.39",
+  "version": "1.1.40",
   "description": "Core change-tracker library for Cloud Firestore Collection BigQuery Exports",
   "main": "./lib/index.js",
   "scripts": {