firebase-admin 13.9.0 → 14.0.0

package/lib/remote-config/remote-config.js

@@ -1,4 +1,4 @@
-/*! firebase-admin v13.9.0 */
+/*! firebase-admin v14.0.0 */
 "use strict";
 /*!
  * Copyright 2020 Google LLC
@@ -20,6 +20,7 @@ exports.RemoteConfigFetchResponse = exports.RemoteConfig = void 0;
 const utils = require("../utils/index");
 const validator = require("../utils/validator");
 const remote_config_api_client_internal_1 = require("./remote-config-api-client-internal");
+const error_1 = require("./error");
 const condition_evaluator_internal_1 = require("./condition-evaluator-internal");
 const value_impl_1 = require("./internal/value-impl");
 /**
@@ -136,14 +137,21 @@ class RemoteConfig {
      */
     createTemplateFromJSON(json) {
         if (!validator.isNonEmptyString(json)) {
-            throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'JSON string must be a valid non-empty string');
+            throw new error_1.FirebaseRemoteConfigError({
+                code: 'invalid-argument',
+                message: 'JSON string must be a valid non-empty string'
+            });
         }
         let template;
         try {
             template = JSON.parse(json);
         }
         catch (e) {
-            throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', `Failed to parse the JSON string: ${json}. ` + e);
+            throw new error_1.FirebaseRemoteConfigError({
+                code: 'invalid-argument',
+                message: `Failed to parse the JSON string: ${json}.`,
+                cause: e
+            });
         }
         return new RemoteConfigTemplateImpl(template);
     }
@@ -175,12 +183,18 @@ class RemoteConfigTemplateImpl {
     constructor(config) {
         if (!validator.isNonNullObject(config) ||
             !validator.isNonEmptyString(config.etag)) {
-            throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', `Invalid Remote Config template: ${JSON.stringify(config)}`);
+            throw new error_1.FirebaseRemoteConfigError({
+                code: 'invalid-argument',
+                message: `Invalid Remote Config template: ${JSON.stringify(config)}`
+            });
         }
         this.etagInternal = config.etag;
         if (typeof config.parameters !== 'undefined') {
             if (!validator.isNonNullObject(config.parameters)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Remote Config parameters must be a non-null object');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Remote Config parameters must be a non-null object'
+                });
             }
             this.parameters = config.parameters;
         }
@@ -190,7 +204,10 @@ class RemoteConfigTemplateImpl {
         validateAllParameterExposures(this.parameters);
         if (typeof config.parameterGroups !== 'undefined') {
             if (!validator.isNonNullObject(config.parameterGroups)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Remote Config parameter groups must be a non-null object');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Remote Config parameter groups must be a non-null object'
+                });
             }
             this.parameterGroups = config.parameterGroups;
         }
@@ -204,7 +221,10 @@ class RemoteConfigTemplateImpl {
         }
         if (typeof config.conditions !== 'undefined') {
             if (!validator.isArray(config.conditions)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Remote Config conditions must be an array');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Remote Config conditions must be an array'
+                });
             }
             this.conditions = config.conditions;
         }
@@ -274,7 +294,11 @@ class ServerTemplateImpl {
             }
             catch (e) {
                 // Transforms JSON parse errors to Firebase error.
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', `Failed to parse the JSON string: ${template}. ` + e);
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: `Failed to parse the JSON string: ${template}.`,
+                    cause: e
+                });
             }
         }
         else {
@@ -291,7 +315,10 @@ class ServerTemplateImpl {
             // This is the only place we should throw during evaluation, since it's under the
             // control of application logic. To preserve forward-compatibility, we should only
             // return false in cases where the SDK is unsure how to evaluate the fetched template.
-            throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('failed-precondition', 'No Remote Config Server template in cache. Call load() before calling evaluate().');
+            throw new error_1.FirebaseRemoteConfigError({
+                code: 'failed-precondition',
+                message: 'No Remote Config Server template in cache. Call load() before calling evaluate().'
+            });
         }
         const evaluatedConditions = this.conditionEvaluator.evaluateConditions(this.cache.conditions, context);
         const configValues = {};
@@ -394,7 +421,10 @@ function validateExperimentExposurePercent(parameterValue, parameterName) {
     // Enforce public contract: numeric and within [0, 100].
     if (!validator.isNumber(exposurePercent) || !Number.isFinite(exposurePercent) ||
         exposurePercent < 0 || exposurePercent > 100) {
-        throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', `Experiment exposure percent must be between 0 and 100 (${parameterName})`);
+        throw new error_1.FirebaseRemoteConfigError({
+            code: 'invalid-argument',
+            message: `Experiment exposure percent must be between 0 and 100 (${parameterName})`
+        });
     }
 }
 /**
@@ -404,12 +434,18 @@ class ServerTemplateDataImpl {
     constructor(template) {
         if (!validator.isNonNullObject(template) ||
             !validator.isNonEmptyString(template.etag)) {
-            throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', `Invalid Remote Config template: ${JSON.stringify(template)}`);
+            throw new error_1.FirebaseRemoteConfigError({
+                code: 'invalid-argument',
+                message: `Invalid Remote Config template: ${JSON.stringify(template)}`
+            });
         }
         this.etag = template.etag;
         if (typeof template.parameters !== 'undefined') {
             if (!validator.isNonNullObject(template.parameters)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Remote Config parameters must be a non-null object');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Remote Config parameters must be a non-null object'
+                });
             }
             this.parameters = template.parameters;
         }
@@ -418,7 +454,10 @@ class ServerTemplateDataImpl {
         }
         if (typeof template.conditions !== 'undefined') {
             if (!validator.isArray(template.conditions)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Remote Config conditions must be an array');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Remote Config conditions must be an array'
+                });
             }
             this.conditions = template.conditions;
         }
@@ -436,51 +475,78 @@ class ServerTemplateDataImpl {
 class VersionImpl {
     constructor(version) {
         if (!validator.isNonNullObject(version)) {
-            throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', `Invalid Remote Config version instance: ${JSON.stringify(version)}`);
+            throw new error_1.FirebaseRemoteConfigError({
+                code: 'invalid-argument',
+                message: `Invalid Remote Config version instance: ${JSON.stringify(version)}`
+            });
         }
         if (typeof version.versionNumber !== 'undefined') {
             if (!validator.isNonEmptyString(version.versionNumber) &&
                 !validator.isNumber(version.versionNumber)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version number must be a non-empty string in int64 format or a number');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version number must be a non-empty string in int64 format or a number'
+                });
             }
             if (!Number.isInteger(Number(version.versionNumber))) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version number must be an integer or a string in int64 format');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version number must be an integer or a string in int64 format'
+                });
             }
             this.versionNumber = version.versionNumber;
         }
         if (typeof version.updateOrigin !== 'undefined') {
             if (!validator.isNonEmptyString(version.updateOrigin)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version update origin must be a non-empty string');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version update origin must be a non-empty string'
+                });
             }
             this.updateOrigin = version.updateOrigin;
         }
         if (typeof version.updateType !== 'undefined') {
             if (!validator.isNonEmptyString(version.updateType)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version update type must be a non-empty string');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version update type must be a non-empty string'
+                });
             }
             this.updateType = version.updateType;
         }
         if (typeof version.updateUser !== 'undefined') {
             if (!validator.isNonNullObject(version.updateUser)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version update user must be a non-null object');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version update user must be a non-null object'
+                });
             }
             this.updateUser = version.updateUser;
         }
         if (typeof version.description !== 'undefined') {
             if (!validator.isNonEmptyString(version.description)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version description must be a non-empty string');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version description must be a non-empty string'
+                });
             }
             this.description = version.description;
         }
         if (typeof version.rollbackSource !== 'undefined') {
             if (!validator.isNonEmptyString(version.rollbackSource)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version rollback source must be a non-empty string');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version rollback source must be a non-empty string'
+                });
             }
             this.rollbackSource = version.rollbackSource;
         }
         if (typeof version.isLegacy !== 'undefined') {
             if (!validator.isBoolean(version.isLegacy)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version.isLegacy must be a boolean');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version.isLegacy must be a boolean'
+                });
             }
             this.isLegacy = version.isLegacy;
         }
@@ -489,7 +555,10 @@ class VersionImpl {
         // we could still validate it below.
         if (typeof version.updateTime !== 'undefined') {
             if (!this.isValidTimestamp(version.updateTime)) {
-                throw new remote_config_api_client_internal_1.FirebaseRemoteConfigError('invalid-argument', 'Version update time must be a valid date string');
+                throw new error_1.FirebaseRemoteConfigError({
+                    code: 'invalid-argument',
+                    message: 'Version update time must be a valid date string'
+                });
             }
             this.updateTime = new Date(version.updateTime).toUTCString();
         }

package/lib/security-rules/error.d.ts

@@ -0,0 +1,45 @@
+/*! firebase-admin v14.0.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
+ *
+ *   http://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 { FirebaseError, ErrorInfo } from '../utils/error';
+/**
+ * The constant mapping for valid Security Rules client error codes.
+ */
+export declare const SecurityRulesErrorCode: {
+    readonly ALREADY_EXISTS: "already-exists";
+    readonly AUTHENTICATION_ERROR: "authentication-error";
+    readonly INTERNAL_ERROR: "internal-error";
+    readonly INVALID_ARGUMENT: "invalid-argument";
+    readonly INVALID_SERVER_RESPONSE: "invalid-server-response";
+    readonly NOT_FOUND: "not-found";
+    readonly RESOURCE_EXHAUSTED: "resource-exhausted";
+    readonly SERVICE_UNAVAILABLE: "service-unavailable";
+    readonly UNKNOWN_ERROR: "unknown-error";
+};
+/**
+ * The type definition for valid Security Rules client error codes.
+ */
+export type SecurityRulesErrorCode = typeof SecurityRulesErrorCode[keyof typeof SecurityRulesErrorCode];
+/**
+ * Firebase Security Rules error code structure. This extends `FirebaseError`.
+ */
+export declare class FirebaseSecurityRulesError extends FirebaseError {
+    /**
+     * @param info - The error code info.
+     * @param message - The error message. If provided, this will override the default message.
+     */
+    constructor(info: ErrorInfo, message?: string);
+}

package/lib/security-rules/error.js

@@ -0,0 +1,54 @@
+/*! firebase-admin v14.0.0 */
+"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
+ *
+ *   http://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.FirebaseSecurityRulesError = exports.SecurityRulesErrorCode = void 0;
+const error_1 = require("../utils/error");
+/**
+ * The constant mapping for valid Security Rules client error codes.
+ */
+exports.SecurityRulesErrorCode = {
+    ALREADY_EXISTS: 'already-exists',
+    AUTHENTICATION_ERROR: 'authentication-error',
+    INTERNAL_ERROR: 'internal-error',
+    INVALID_ARGUMENT: 'invalid-argument',
+    INVALID_SERVER_RESPONSE: 'invalid-server-response',
+    NOT_FOUND: 'not-found',
+    RESOURCE_EXHAUSTED: 'resource-exhausted',
+    SERVICE_UNAVAILABLE: 'service-unavailable',
+    UNKNOWN_ERROR: 'unknown-error',
+};
+/**
+ * Firebase Security Rules error code structure. This extends `FirebaseError`.
+ */
+class FirebaseSecurityRulesError extends error_1.FirebaseError {
+    /**
+     * @param info - The error code info.
+     * @param message - The error message. If provided, this will override the default message.
+     */
+    constructor(info, message) {
+        super({
+            code: `security-rules/${info.code}`,
+            message: message || info.message,
+            httpResponse: info.httpResponse,
+            cause: info.cause,
+        });
+        /** @internal */
+        this.codePrefix = 'security-rules';
+    }
+}
+exports.FirebaseSecurityRulesError = FirebaseSecurityRulesError;

package/lib/security-rules/index.d.ts

@@ -1,4 +1,4 @@
-/*! firebase-admin v13.9.0 */
+/*! firebase-admin v14.0.0 */
 /*!
  * Copyright 2020 Google LLC
  *
@@ -48,3 +48,4 @@ export { RulesFile, Ruleset, RulesetMetadata, RulesetMetadataList, SecurityRules
  *   `SecurityRules` service associated with the provided app.
  */
 export declare function getSecurityRules(app?: App): SecurityRules;
+export { FirebaseSecurityRulesError, SecurityRulesErrorCode } from './error';

package/lib/security-rules/index.js

@@ -1,4 +1,4 @@
-/*! firebase-admin v13.9.0 */
+/*! firebase-admin v14.0.0 */
 "use strict";
 /*!
  * Copyright 2020 Google LLC
@@ -16,7 +16,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SecurityRules = exports.RulesetMetadataList = exports.Ruleset = void 0;
+exports.SecurityRulesErrorCode = exports.FirebaseSecurityRulesError = exports.SecurityRules = exports.RulesetMetadataList = exports.Ruleset = void 0;
 exports.getSecurityRules = getSecurityRules;
 /**
  * Security Rules for Cloud Firestore and Cloud Storage.
@@ -61,3 +61,6 @@ function getSecurityRules(app) {
     const firebaseApp = app;
     return firebaseApp.getOrInitService('securityRules', (app) => new security_rules_1.SecurityRules(app));
 }
+var error_1 = require("./error");
+Object.defineProperty(exports, "FirebaseSecurityRulesError", { enumerable: true, get: function () { return error_1.FirebaseSecurityRulesError; } });
+Object.defineProperty(exports, "SecurityRulesErrorCode", { enumerable: true, get: function () { return error_1.SecurityRulesErrorCode; } });

package/lib/security-rules/security-rules-api-client-internal.d.ts

@@ -1,4 +1,4 @@
-/*! firebase-admin v13.9.0 */
+/*! firebase-admin v14.0.0 */
 /*!
  * Copyright 2019 Google LLC
  *

package/lib/security-rules/security-rules-api-client-internal.js

@@ -1,4 +1,4 @@
-/*! firebase-admin v13.9.0 */
+/*! firebase-admin v14.0.0 */
 "use strict";
 /*!
  * Copyright 2019 Google LLC
@@ -19,7 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecurityRulesApiClient = void 0;
 const api_request_1 = require("../utils/api-request");
 const error_1 = require("../utils/error");
-const security_rules_internal_1 = require("./security-rules-internal");
+const error_2 = require("./error");
 const utils = require("../utils/index");
 const validator = require("../utils/validator");
 const RULES_V1_API = 'https://firebaserules.googleapis.com/v1';
@@ -35,8 +35,11 @@ class SecurityRulesApiClient {
     constructor(app) {
         this.app = app;
         if (!validator.isNonNullObject(app) || !('options' in app)) {
-            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'First argument passed to admin.securityRules() must be a valid Firebase app '
-                + 'instance.');
+            throw new error_2.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'First argument passed to admin.securityRules() must be a valid Firebase app ' +
+                    'instance.'
+            });
         }
         this.httpClient = new api_request_1.AuthorizedHttpClient(app);
     }
@@ -53,14 +56,20 @@ class SecurityRulesApiClient {
         if (!validator.isNonNullObject(ruleset) ||
             !validator.isNonNullObject(ruleset.source) ||
             !validator.isNonEmptyArray(ruleset.source.files)) {
-            const err = new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Invalid rules content.');
+            const err = new error_2.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Invalid rules content.'
+            });
             return Promise.reject(err);
         }
         for (const rf of ruleset.source.files) {
             if (!validator.isNonNullObject(rf) ||
                 !validator.isNonEmptyString(rf.name) ||
                 !validator.isNonEmptyString(rf.content)) {
-                const err = new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', `Invalid rules file argument: ${JSON.stringify(rf)}`);
+                const err = new error_2.FirebaseSecurityRulesError({
+                    code: 'invalid-argument',
+                    message: `Invalid rules file argument: ${JSON.stringify(rf)}`
+                });
                 return Promise.reject(err);
             }
         }
@@ -87,15 +96,24 @@ class SecurityRulesApiClient {
     }
     listRulesets(pageSize = 100, pageToken) {
         if (!validator.isNumber(pageSize)) {
-            const err = new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Invalid page size.');
+            const err = new error_2.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Invalid page size.'
+            });
             return Promise.reject(err);
         }
         if (pageSize < 1 || pageSize > 100) {
-            const err = new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Page size must be between 1 and 100.');
+            const err = new error_2.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Page size must be between 1 and 100.'
+            });
             return Promise.reject(err);
         }
         if (typeof pageToken !== 'undefined' && !validator.isNonEmptyString(pageToken)) {
-            const err = new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Next page token must be a non-empty string.');
+            const err = new error_2.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Next page token must be a non-empty string.'
+            });
             return Promise.reject(err);
         }
         const data = {
@@ -168,9 +186,12 @@ class SecurityRulesApiClient {
         return utils.findProjectId(this.app)
             .then((projectId) => {
             if (!validator.isNonEmptyString(projectId)) {
-                throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Failed to determine project ID. Initialize the SDK with service account credentials, or '
-                    + 'set project ID as an app option. Alternatively, set the GOOGLE_CLOUD_PROJECT '
-                    + 'environment variable.');
+                throw new error_2.FirebaseSecurityRulesError({
+                    code: 'invalid-argument',
+                    message: 'Failed to determine project ID. Initialize the SDK with service account credentials, or '
+                        + 'set project ID as an app option. Alternatively, set the GOOGLE_CLOUD_PROJECT '
+                        + 'environment variable.'
+                });
             }
             this.projectIdPrefix = `projects/${projectId}`;
             return this.projectIdPrefix;
@@ -204,10 +225,16 @@ class SecurityRulesApiClient {
     }
     getRulesetName(name) {
         if (!validator.isNonEmptyString(name)) {
-            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Ruleset name must be a non-empty string.');
+            throw new error_2.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Ruleset name must be a non-empty string.'
+            });
         }
         if (name.indexOf('/') !== -1) {
-            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Ruleset name must not contain any "/" characters.');
+            throw new error_2.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Ruleset name must not contain any "/" characters.'
+            });
         }
         return `rulesets/${name}`;
     }
@@ -222,20 +249,25 @@ class SecurityRulesApiClient {
         });
     }
     toFirebaseError(err) {
-        if (err instanceof error_1.PrefixedFirebaseError) {
+        if (err instanceof error_1.FirebaseError) {
             return err;
         }
         const response = err.response;
         if (!response.isJson()) {
-            return new security_rules_internal_1.FirebaseSecurityRulesError('unknown-error', `Unexpected response with status: ${response.status} and body: ${response.text}`);
+            return new error_2.FirebaseSecurityRulesError({
+                code: 'unknown-error',
+                message: `Unexpected response with status: ${response.status} and body: ${response.text}`,
+                httpResponse: (0, error_1.toHttpResponse)(response),
+                cause: err
+            });
         }
         const error = response.data.error || {};
         let code = 'unknown-error';
         if (error.status && error.status in ERROR_CODE_MAPPING) {
             code = ERROR_CODE_MAPPING[error.status];
         }
-        const message = error.message || `Unknown server error: ${response.text}`;
-        return new security_rules_internal_1.FirebaseSecurityRulesError(code, message);
+        const message = error.message || 'Unknown server error';
+        return new error_2.FirebaseSecurityRulesError({ code, message, httpResponse: (0, error_1.toHttpResponse)(response), cause: err });
     }
 }
 exports.SecurityRulesApiClient = SecurityRulesApiClient;

package/lib/security-rules/security-rules.d.ts

@@ -1,4 +1,4 @@
-/*! firebase-admin v13.9.0 */
+/*! firebase-admin v14.0.0 */
 /*!
  * Copyright 2019 Google LLC
  *

package/lib/security-rules/security-rules.js

@@ -1,4 +1,4 @@
-/*! firebase-admin v13.9.0 */
+/*! firebase-admin v14.0.0 */
 "use strict";
 /*!
  * Copyright 2019 Google LLC
@@ -19,7 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecurityRules = exports.Ruleset = exports.RulesetMetadataList = void 0;
 const validator = require("../utils/validator");
 const security_rules_api_client_internal_1 = require("./security-rules-api-client-internal");
-const security_rules_internal_1 = require("./security-rules-internal");
+const error_1 = require("./error");
 /**
  * A page of ruleset metadata.
  */
@@ -29,7 +29,10 @@ class RulesetMetadataList {
      */
     constructor(response) {
         if (!validator.isNonNullObject(response) || !validator.isArray(response.rulesets)) {
-            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', `Invalid ListRulesets response: ${JSON.stringify(response)}`);
+            throw new error_1.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: `Invalid ListRulesets response: ${JSON.stringify(response)}`
+            });
         }
         this.rulesets = response.rulesets.map((rs) => {
             return {
@@ -55,7 +58,10 @@ class Ruleset {
             !validator.isNonEmptyString(ruleset.name) ||
             !validator.isNonEmptyString(ruleset.createTime) ||
             !validator.isNonNullObject(ruleset.source)) {
-            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', `Invalid Ruleset response: ${JSON.stringify(ruleset)}`);
+            throw new error_1.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: `Invalid Ruleset response: ${JSON.stringify(ruleset)}`
+            });
         }
         this.name = stripProjectIdPrefix(ruleset.name);
         this.createTime = new Date(ruleset.createTime).toUTCString();
@@ -217,7 +223,10 @@ class SecurityRules {
      */
     createRulesFileFromSource(name, source) {
         if (!validator.isNonEmptyString(name)) {
-            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Name must be a non-empty string.');
+            throw new error_1.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Name must be a non-empty string.'
+            });
         }
         let content;
         if (validator.isNonEmptyString(source)) {
@@ -227,7 +236,10 @@ class SecurityRules {
             content = source.toString('utf-8');
         }
         else {
-            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Source must be a non-empty string or a Buffer.');
+            throw new error_1.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Source must be a non-empty string or a Buffer.'
+            });
         }
         return {
             name,
@@ -284,7 +296,10 @@ class SecurityRules {
             .then((release) => {
             const rulesetName = release.rulesetName;
             if (!validator.isNonEmptyString(rulesetName)) {
-                throw new security_rules_internal_1.FirebaseSecurityRulesError('not-found', `Ruleset name not found for ${releaseName}.`);
+                throw new error_1.FirebaseSecurityRulesError({
+                    code: 'not-found',
+                    message: `Ruleset name not found for ${releaseName}.`
+                });
             }
             return this.getRuleset(stripProjectIdPrefix(rulesetName));
         });
@@ -292,7 +307,10 @@ class SecurityRules {
     releaseRuleset(ruleset, releaseName) {
         if (!validator.isNonEmptyString(ruleset) &&
             (!validator.isNonNullObject(ruleset) || !validator.isNonEmptyString(ruleset.name))) {
-            const err = new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'ruleset must be a non-empty name or a RulesetMetadata object.');
+            const err = new error_1.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'ruleset must be a non-empty name or a RulesetMetadata object.'
+            });
             return Promise.reject(err);
         }
         const rulesetName = validator.isString(ruleset) ? ruleset : ruleset.name;
@@ -304,9 +322,12 @@ class SecurityRules {
     getBucketName(bucket) {
         const bucketName = (typeof bucket !== 'undefined') ? bucket : this.app.options.storageBucket;
         if (!validator.isNonEmptyString(bucketName)) {
-            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Bucket name not specified or invalid. Specify a default bucket name via the ' +
-                'storageBucket option when initializing the app, or specify the bucket name ' +
-                'explicitly when calling the rules API.');
+            throw new error_1.FirebaseSecurityRulesError({
+                code: 'invalid-argument',
+                message: 'Bucket name not specified or invalid. Specify a default bucket name via the ' +
+                    'storageBucket option when initializing the app, or specify the bucket name ' +
+                    'explicitly when calling the rules API.'
+            });
         }
         return bucketName;
     }