firebase-tools 13.3.0 → 13.4.0

package/lib/firestore/backupUtils.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateRetention = exports.Duration = exports.DURATION_REGEX = void 0;
+const error_1 = require("../error");
+exports.DURATION_REGEX = /^(\d+)([hdmw])$/;
+var Duration;
+(function (Duration) {
+    Duration[Duration["MINUTE"] = 60] = "MINUTE";
+    Duration[Duration["HOUR"] = 3600] = "HOUR";
+    Duration[Duration["DAY"] = 86400] = "DAY";
+    Duration[Duration["WEEK"] = 604800] = "WEEK";
+})(Duration = exports.Duration || (exports.Duration = {}));
+const DURATIONS = {
+    m: Duration.MINUTE,
+    h: Duration.HOUR,
+    d: Duration.DAY,
+    w: Duration.WEEK,
+};
+function calculateRetention(flag) {
+    const match = exports.DURATION_REGEX.exec(flag);
+    if (!match) {
+        throw new error_1.FirebaseError(`"retention" flag must be a duration string (e.g. 24h, 2w, or 7d)`);
+    }
+    const d = parseInt(match[1], 10) * DURATIONS[match[2]];
+    if (isNaN(d)) {
+        throw new error_1.FirebaseError(`Failed to parse provided retention time "${flag}"`);
+    }
+    return d;
+}
+exports.calculateRetention = calculateRetention;

package/lib/firestore/pretty-print.js

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PrettyPrint = void 0;
+const clc = require("colorette");
+const Table = require("cli-table");
+const sort = require("./api-sort");
+const types = require("./api-types");
+const logger_1 = require("../logger");
+const util = require("./util");
+class PrettyPrint {
+    prettyPrintIndexes(indexes) {
+        if (indexes.length === 0) {
+            logger_1.logger.info("None");
+            return;
+        }
+        const sortedIndexes = indexes.sort(sort.compareApiIndex);
+        sortedIndexes.forEach((index) => {
+            logger_1.logger.info(this.prettyIndexString(index));
+        });
+    }
+    prettyPrintDatabases(databases) {
+        if (databases.length === 0) {
+            logger_1.logger.info("No databases found.");
+            return;
+        }
+        const sortedDatabases = databases.sort(sort.compareApiDatabase);
+        const table = new Table({
+            head: ["Database Name"],
+            colWidths: [Math.max(...sortedDatabases.map((database) => database.name.length + 5), 20)],
+        });
+        table.push(...sortedDatabases.map((database) => [this.prettyDatabaseString(database)]));
+        logger_1.logger.info(table.toString());
+    }
+    prettyPrintDatabase(database) {
+        const table = new Table({
+            head: ["Field", "Value"],
+            colWidths: [25, Math.max(50, 5 + database.name.length)],
+        });
+        table.push(["Name", clc.yellow(database.name)], ["Create Time", clc.yellow(database.createTime)], ["Last Update Time", clc.yellow(database.updateTime)], ["Type", clc.yellow(database.type)], ["Location", clc.yellow(database.locationId)], ["Delete Protection State", clc.yellow(database.deleteProtectionState)], ["Point In Time Recovery", clc.yellow(database.pointInTimeRecoveryEnablement)], ["Earliest Version Time", clc.yellow(database.earliestVersionTime)], ["Version Retention Period", clc.yellow(database.versionRetentionPeriod)]);
+        logger_1.logger.info(table.toString());
+    }
+    prettyPrintBackups(backups) {
+        if (backups.length === 0) {
+            logger_1.logger.info("No backups found.");
+            return;
+        }
+        const sortedBackups = backups.sort(sort.compareApiBackup);
+        const table = new Table({
+            head: ["Backup Name", "Database Name", "Snapshot Time", "State"],
+            colWidths: [
+                Math.max(...sortedBackups.map((backup) => backup.name.length + 5), 20),
+                Math.max(...sortedBackups.map((backup) => backup.database.length + 5), 20),
+                30,
+                10,
+            ],
+        });
+        table.push(...sortedBackups.map((backup) => [
+            this.prettyBackupString(backup),
+            this.prettyDatabaseString(backup.database || ""),
+            backup.snapshotTime,
+            backup.state,
+        ]));
+        logger_1.logger.info(table.toString());
+    }
+    prettyPrintBackupSchedules(backupSchedules, databaseId) {
+        if (backupSchedules.length === 0) {
+            logger_1.logger.info(`No backup schedules for database ${databaseId} found.`);
+            return;
+        }
+        const sortedBackupSchedules = backupSchedules.sort(sort.compareApiBackupSchedule);
+        sortedBackupSchedules.forEach((schedule) => this.prettyPrintBackupSchedule(schedule));
+    }
+    prettyPrintBackupSchedule(backupSchedule) {
+        const table = new Table({
+            head: ["Field", "Value"],
+            colWidths: [25, Math.max(50, 5 + backupSchedule.name.length)],
+        });
+        table.push(["Name", clc.yellow(backupSchedule.name)], ["Create Time", clc.yellow(backupSchedule.createTime)], ["Last Update Time", clc.yellow(backupSchedule.updateTime)], ["Retention", clc.yellow(backupSchedule.retention)], ["Recurrence", this.prettyRecurrenceString(backupSchedule)]);
+        logger_1.logger.info(table.toString());
+    }
+    prettyRecurrenceString(backupSchedule) {
+        if (backupSchedule.dailyRecurrence) {
+            return clc.yellow("DAILY");
+        }
+        else if (backupSchedule.weeklyRecurrence) {
+            return clc.yellow(`WEEKLY (${backupSchedule.weeklyRecurrence.day})`);
+        }
+        return "";
+    }
+    prettyPrintBackup(backup) {
+        const table = new Table({
+            head: ["Field", "Value"],
+            colWidths: [25, Math.max(50, 5 + backup.name.length, 5 + backup.database.length)],
+        });
+        table.push(["Name", clc.yellow(backup.name)], ["Database", clc.yellow(backup.database)], ["Database UID", clc.yellow(backup.databaseUid)], ["State", clc.yellow(backup.state)], ["Snapshot Time", clc.yellow(backup.snapshotTime)], ["Expire Time", clc.yellow(backup.expireTime)], ["Stats", clc.yellow(backup.stats)]);
+        logger_1.logger.info(table.toString());
+    }
+    prettyPrintLocations(locations) {
+        if (locations.length === 0) {
+            logger_1.logger.info("No Locations Available");
+            return;
+        }
+        const table = new Table({
+            head: ["Display Name", "LocationId"],
+            colWidths: [20, 30],
+        });
+        table.push(...locations
+            .sort(sort.compareLocation)
+            .map((location) => [location.displayName, location.locationId]));
+        logger_1.logger.info(table.toString());
+    }
+    printFieldOverrides(fields) {
+        if (fields.length === 0) {
+            logger_1.logger.info("None");
+            return;
+        }
+        const sortedFields = fields.sort(sort.compareApiField);
+        sortedFields.forEach((field) => {
+            logger_1.logger.info(this.prettyFieldString(field));
+        });
+    }
+    prettyIndexString(index, includeState = true) {
+        let result = "";
+        if (index.state && includeState) {
+            const stateMsg = `[${index.state}] `;
+            if (index.state === types.State.READY) {
+                result += clc.green(stateMsg);
+            }
+            else if (index.state === types.State.CREATING) {
+                result += clc.yellow(stateMsg);
+            }
+            else {
+                result += clc.red(stateMsg);
+            }
+        }
+        const nameInfo = util.parseIndexName(index.name);
+        result += clc.cyan(`(${nameInfo.collectionGroupId})`);
+        result += " -- ";
+        index.fields.forEach((field) => {
+            if (field.fieldPath === "__name__") {
+                return;
+            }
+            const orderOrArrayConfig = field.order ? field.order : field.arrayConfig;
+            result += `(${field.fieldPath},${orderOrArrayConfig}) `;
+        });
+        return result;
+    }
+    prettyBackupString(backup) {
+        return clc.yellow(backup.name || "");
+    }
+    prettyBackupScheduleString(backupSchedule) {
+        return clc.yellow(backupSchedule.name || "");
+    }
+    prettyDatabaseString(database) {
+        return clc.yellow(typeof database === "string" ? database : database.name);
+    }
+    prettyFieldString(field) {
+        let result = "";
+        const parsedName = util.parseFieldName(field.name);
+        result +=
+            "[" +
+                clc.cyan(parsedName.collectionGroupId) +
+                "." +
+                clc.yellow(parsedName.fieldPath) +
+                "] --";
+        const fieldIndexes = field.indexConfig.indexes || [];
+        if (fieldIndexes.length > 0) {
+            fieldIndexes.forEach((index) => {
+                const firstField = index.fields[0];
+                const mode = firstField.order || firstField.arrayConfig;
+                result += ` (${mode})`;
+            });
+        }
+        else {
+            result += " (no indexes)";
+        }
+        const fieldTtl = field.ttlConfig;
+        if (fieldTtl) {
+            result += ` TTL(${fieldTtl.state})`;
+        }
+        return result;
+    }
+}
+exports.PrettyPrint = PrettyPrint;

package/lib/functions/secrets.js

@@ -44,7 +44,7 @@ function toUpperSnakeCase(key) {
 }
 function ensureApi(options) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
-    return ensureApiEnabled.ensure(projectId, "secretmanager.googleapis.com", "secretmanager", true);
+    return ensureApiEnabled.ensure(projectId, api_1.secretManagerOrigin, "secretmanager", true);
 }
 exports.ensureApi = ensureApi;
 async function ensureValidKey(key, options) {

package/lib/gcp/apphosting.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getNextRolloutId = exports.ensureApiEnabled = exports.listLocations = exports.updateTraffic = exports.listRollouts = exports.createRollout = exports.createBuild = exports.listBuilds = exports.getBuild = exports.deleteBackend = exports.listBackends = exports.getBackend = exports.createBackend = exports.client = exports.API_VERSION = exports.API_HOST = void 0;
+exports.getNextRolloutId = exports.ensureApiEnabled = exports.listLocations = exports.updateTraffic = exports.listRollouts = exports.createRollout = exports.createBuild = exports.listBuilds = exports.getBuild = exports.deleteBackend = exports.listBackends = exports.getBackend = exports.createBackend = exports.client = exports.API_VERSION = void 0;
 const proto = require("../gcp/proto");
 const apiv2_1 = require("../apiv2");
 const projectUtils_1 = require("../projectUtils");
@@ -9,7 +9,6 @@ const ensureApiEnabled_1 = require("../ensureApiEnabled");
 const deploymentTool = require("../deploymentTool");
 const error_1 = require("../error");
 const metaprogramming_1 = require("../metaprogramming");
-exports.API_HOST = new URL(api_1.apphostingOrigin).host;
 exports.API_VERSION = "v1alpha";
 exports.client = new apiv2_1.Client({
     urlPrefix: api_1.apphostingOrigin,
@@ -73,8 +72,8 @@ async function createBuild(projectId, location, backendId, buildId, buildInput)
     return res.body;
 }
 exports.createBuild = createBuild;
-async function createRollout(projectId, location, backendId, rolloutId, rollout) {
-    const res = await exports.client.post(`projects/${projectId}/locations/${location}/backends/${backendId}/rollouts`, Object.assign(Object.assign({}, rollout), { labels: Object.assign(Object.assign({}, rollout.labels), deploymentTool.labels()) }), { queryParams: { rolloutId } });
+async function createRollout(projectId, location, backendId, rolloutId, rollout, validateOnly = false) {
+    const res = await exports.client.post(`projects/${projectId}/locations/${location}/backends/${backendId}/rollouts`, Object.assign(Object.assign({}, rollout), { labels: Object.assign(Object.assign({}, rollout.labels), deploymentTool.labels()) }), { queryParams: { rolloutId, validateOnly: validateOnly ? "true" : "false" } });
     return res.body;
 }
 exports.createRollout = createRollout;
@@ -126,7 +125,7 @@ async function listLocations(projectId) {
 exports.listLocations = listLocations;
 async function ensureApiEnabled(options) {
     const projectId = (0, projectUtils_1.needProjectId)(options);
-    return await (0, ensureApiEnabled_1.ensure)(projectId, exports.API_HOST, "app hosting", true);
+    return await (0, ensureApiEnabled_1.ensure)(projectId, api_1.apphostingOrigin, "app hosting", true);
 }
 exports.ensureApiEnabled = ensureApiEnabled;
 async function getNextRolloutId(projectId, location, backendId, counter) {

package/lib/gcp/auth.js

@@ -5,12 +5,15 @@ const apiv2_1 = require("../apiv2");
 const api_1 = require("../api");
 const apiClient = new apiv2_1.Client({ urlPrefix: api_1.identityOrigin, auth: true });
 async function getAuthDomains(project) {
-    const res = await apiClient.get(`/admin/v2/projects/${project}/config`);
+    const res = await apiClient.get(`/admin/v2/projects/${project}/config`, { headers: { "x-goog-user-project": project } });
     return res.body.authorizedDomains;
 }
 exports.getAuthDomains = getAuthDomains;
 async function updateAuthDomains(project, authDomains) {
-    const res = await apiClient.patch(`/admin/v2/projects/${project}/config`, { authorizedDomains: authDomains }, { queryParams: { update_mask: "authorizedDomains" } });
+    const res = await apiClient.patch(`/admin/v2/projects/${project}/config`, { authorizedDomains: authDomains }, {
+        queryParams: { update_mask: "authorizedDomains" },
+        headers: { "x-goog-user-project": project },
+    });
     return res.body.authorizedDomains;
 }
 exports.updateAuthDomains = updateAuthDomains;

package/lib/gcp/cloudbuild.js

@@ -46,9 +46,14 @@ async function deleteConnection(projectId, location, connectionId) {
     return res.body;
 }
 exports.deleteConnection = deleteConnection;
-async function fetchLinkableRepositories(projectId, location, connectionId) {
+async function fetchLinkableRepositories(projectId, location, connectionId, pageToken = "", pageSize = 1000) {
     const name = `projects/${projectId}/locations/${location}/connections/${connectionId}:fetchLinkableRepositories`;
-    const res = await client.get(name);
+    const res = await client.get(name, {
+        queryParams: {
+            pageSize,
+            pageToken,
+        },
+    });
     return res.body;
 }
 exports.fetchLinkableRepositories = fetchLinkableRepositories;

package/lib/gcp/firestore.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deleteDocuments = exports.deleteDocument = exports.listCollectionIds = exports.getDatabase = void 0;
+exports.getBackupSchedule = exports.listBackupSchedules = exports.getBackup = exports.listBackups = exports.deleteBackupSchedule = exports.deleteBackup = exports.updateBackupSchedule = exports.createBackupSchedule = exports.deleteDocuments = exports.deleteDocument = exports.listCollectionIds = exports.getDatabase = exports.DayOfWeek = void 0;
 const api_1 = require("../api");
 const apiv2_1 = require("../apiv2");
 const logger_1 = require("../logger");
+const proto_1 = require("./proto");
+const error_1 = require("../error");
 const prodOnlyClient = new apiv2_1.Client({
     auth: true,
     apiVersion: "v1",
@@ -14,6 +16,16 @@ const emuOrProdClient = new apiv2_1.Client({
     apiVersion: "v1",
     urlPrefix: api_1.firestoreOriginOrEmulator,
 });
+var DayOfWeek;
+(function (DayOfWeek) {
+    DayOfWeek["MONDAY"] = "MONDAY";
+    DayOfWeek["TUEDAY"] = "TUESDAY";
+    DayOfWeek["WEDNESDAY"] = "WEDNESDAY";
+    DayOfWeek["THURSDAY"] = "THURSDAY";
+    DayOfWeek["FRIDAY"] = "FRIDAY";
+    DayOfWeek["SATURDAY"] = "SATURDAY";
+    DayOfWeek["SUNDAY"] = "SUNDAY";
+})(DayOfWeek = exports.DayOfWeek || (exports.DayOfWeek = {}));
 async function getDatabase(project, database, allowEmulator = false) {
     const apiClient = allowEmulator ? emuOrProdClient : prodOnlyClient;
     const url = `projects/${project}/databases/${database}`;
@@ -54,3 +66,65 @@ async function deleteDocuments(project, docs, allowEmulator = false) {
     return res.body.writeResults.length;
 }
 exports.deleteDocuments = deleteDocuments;
+async function createBackupSchedule(project, databaseId, retention, dailyRecurrence, weeklyRecurrence) {
+    const url = `projects/${project}/databases/${databaseId}/backupSchedules`;
+    const data = {
+        retention: (0, proto_1.durationFromSeconds)(retention),
+        dailyRecurrence,
+        weeklyRecurrence,
+    };
+    (0, proto_1.assertOneOf)("BackupSchedule", data, "recurrence", "dailyRecurrence", "weeklyRecurrence");
+    const res = await prodOnlyClient.post(url, data);
+    return res.body;
+}
+exports.createBackupSchedule = createBackupSchedule;
+async function updateBackupSchedule(backupScheduleName, retention) {
+    const data = {
+        retention: (0, proto_1.durationFromSeconds)(retention),
+    };
+    const res = await prodOnlyClient.patch(backupScheduleName, data);
+    return res.body;
+}
+exports.updateBackupSchedule = updateBackupSchedule;
+async function deleteBackup(backupName) {
+    await prodOnlyClient.delete(backupName);
+}
+exports.deleteBackup = deleteBackup;
+async function deleteBackupSchedule(backupScheduleName) {
+    await prodOnlyClient.delete(backupScheduleName);
+}
+exports.deleteBackupSchedule = deleteBackupSchedule;
+async function listBackups(project, location) {
+    const url = `/projects/${project}/locations/${location}/backups`;
+    const res = await prodOnlyClient.get(url);
+    return res.body;
+}
+exports.listBackups = listBackups;
+async function getBackup(backupName) {
+    const res = await prodOnlyClient.get(backupName);
+    const backup = res.body;
+    if (!backup) {
+        throw new error_1.FirebaseError("Not found");
+    }
+    return backup;
+}
+exports.getBackup = getBackup;
+async function listBackupSchedules(project, database) {
+    const url = `/projects/${project}/databases/${database}/backupSchedules`;
+    const res = await prodOnlyClient.get(url);
+    const backupSchedules = res.body.backupSchedules;
+    if (!backupSchedules) {
+        return [];
+    }
+    return backupSchedules;
+}
+exports.listBackupSchedules = listBackupSchedules;
+async function getBackupSchedule(backupScheduleName) {
+    const res = await prodOnlyClient.get(backupScheduleName);
+    const backupSchedule = res.body;
+    if (!backupSchedule) {
+        throw new error_1.FirebaseError("Not found");
+    }
+    return backupSchedule;
+}
+exports.getBackupSchedule = getBackupSchedule;

package/lib/gcp/storage.js

@@ -10,7 +10,7 @@ const logger_1 = require("../logger");
 const ensureApiEnabled_1 = require("../ensureApiEnabled");
 async function getDefaultBucket(projectId) {
     var _a;
-    await (0, ensureApiEnabled_1.ensure)(projectId, "firebasestorage.googleapis.com", "storage", false);
+    await (0, ensureApiEnabled_1.ensure)(projectId, api_1.firebaseStorageOrigin, "storage", false);
     try {
         const localAPIClient = new apiv2_1.Client({ urlPrefix: api_1.firebaseStorageOrigin, apiVersion: "v1alpha" });
         const response = await localAPIClient.get(`/projects/${projectId}/defaultBucket`);