initial commit

server/node_modules/firebase-admin/lib/security-rules/index.d.ts

@@ -0,0 +1,50 @@
+/*! firebase-admin v13.5.0 */
+/*!
+ * Copyright 2020 Google Inc.
+ *
+ * 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.
+ */
+/**
+ * Security Rules for Cloud Firestore and Cloud Storage.
+ *
+ * @packageDocumentation
+ */
+import { App } from '../app';
+import { SecurityRules } from './security-rules';
+export { RulesFile, Ruleset, RulesetMetadata, RulesetMetadataList, SecurityRules, } from './security-rules';
+/**
+ * Gets the {@link SecurityRules} service for the default app or a given app.
+ *
+ * `admin.securityRules()` can be called with no arguments to access the
+ * default app's `SecurityRules` service, or as `admin.securityRules(app)` to access
+ * the `SecurityRules` service associated with a specific app.
+ *
+ * @example
+ * ```javascript
+ * // Get the SecurityRules service for the default app
+ * const defaultSecurityRules = getSecurityRules();
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Get the SecurityRules service for a given app
+ * const otherSecurityRules = getSecurityRules(otherApp);
+ * ```
+ *
+ * @param app - Optional app to return the `SecurityRules` service
+ *     for. If not provided, the default `SecurityRules` service
+ *     is returned.
+ * @returns The default `SecurityRules` service if no app is provided, or the
+ *   `SecurityRules` service associated with the provided app.
+ */
+export declare function getSecurityRules(app?: App): SecurityRules;

server/node_modules/firebase-admin/lib/security-rules/index.js

@@ -0,0 +1,63 @@
+/*! firebase-admin v13.5.0 */
+"use strict";
+/*!
+ * Copyright 2020 Google Inc.
+ *
+ * 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.SecurityRules = exports.RulesetMetadataList = exports.Ruleset = void 0;
+exports.getSecurityRules = getSecurityRules;
+/**
+ * Security Rules for Cloud Firestore and Cloud Storage.
+ *
+ * @packageDocumentation
+ */
+const app_1 = require("../app");
+const security_rules_1 = require("./security-rules");
+var security_rules_2 = require("./security-rules");
+Object.defineProperty(exports, "Ruleset", { enumerable: true, get: function () { return security_rules_2.Ruleset; } });
+Object.defineProperty(exports, "RulesetMetadataList", { enumerable: true, get: function () { return security_rules_2.RulesetMetadataList; } });
+Object.defineProperty(exports, "SecurityRules", { enumerable: true, get: function () { return security_rules_2.SecurityRules; } });
+/**
+ * Gets the {@link SecurityRules} service for the default app or a given app.
+ *
+ * `admin.securityRules()` can be called with no arguments to access the
+ * default app's `SecurityRules` service, or as `admin.securityRules(app)` to access
+ * the `SecurityRules` service associated with a specific app.
+ *
+ * @example
+ * ```javascript
+ * // Get the SecurityRules service for the default app
+ * const defaultSecurityRules = getSecurityRules();
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Get the SecurityRules service for a given app
+ * const otherSecurityRules = getSecurityRules(otherApp);
+ * ```
+ *
+ * @param app - Optional app to return the `SecurityRules` service
+ *     for. If not provided, the default `SecurityRules` service
+ *     is returned.
+ * @returns The default `SecurityRules` service if no app is provided, or the
+ *   `SecurityRules` service associated with the provided app.
+ */
+function getSecurityRules(app) {
+    if (typeof app === 'undefined') {
+        app = (0, app_1.getApp)();
+    }
+    const firebaseApp = app;
+    return firebaseApp.getOrInitService('securityRules', (app) => new security_rules_1.SecurityRules(app));
+}

server/node_modules/firebase-admin/lib/security-rules/security-rules-api-client-internal.d.ts

@@ -0,0 +1,75 @@
+/*! firebase-admin v13.5.0 */
+/*!
+ * Copyright 2019 Google Inc.
+ *
+ * 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 { App } from '../app';
+export interface Release {
+    readonly name: string;
+    readonly rulesetName: string;
+    readonly createTime?: string;
+    readonly updateTime?: string;
+}
+export interface RulesetContent {
+    readonly source: {
+        readonly files: Array<{
+            name: string;
+            content: string;
+        }>;
+    };
+}
+export interface RulesetResponse extends RulesetContent {
+    readonly name: string;
+    readonly createTime: string;
+}
+export interface ListRulesetsResponse {
+    readonly rulesets: Array<{
+        name: string;
+        createTime: string;
+    }>;
+    readonly nextPageToken?: string;
+}
+/**
+ * Class that facilitates sending requests to the Firebase security rules backend API.
+ *
+ * @private
+ */
+export declare class SecurityRulesApiClient {
+    private readonly app;
+    private readonly httpClient;
+    private projectIdPrefix?;
+    constructor(app: App);
+    getRuleset(name: string): Promise<RulesetResponse>;
+    createRuleset(ruleset: RulesetContent): Promise<RulesetResponse>;
+    deleteRuleset(name: string): Promise<void>;
+    listRulesets(pageSize?: number, pageToken?: string): Promise<ListRulesetsResponse>;
+    getRelease(name: string): Promise<Release>;
+    updateOrCreateRelease(name: string, rulesetName: string): Promise<Release>;
+    updateRelease(name: string, rulesetName: string): Promise<Release>;
+    createRelease(name: string, rulesetName: string): Promise<Release>;
+    private getUrl;
+    private getProjectIdPrefix;
+    /**
+     * Gets the specified resource from the rules API. Resource names must be the short names without project
+     * ID prefix (e.g. `rulesets/ruleset-name`).
+     *
+     * @param {string} name Full qualified name of the resource to get.
+     * @returns {Promise<T>} A promise that fulfills with the resource.
+     */
+    private getResource;
+    private getReleaseDescription;
+    private getRulesetName;
+    private sendRequest;
+    private toFirebaseError;
+}

server/node_modules/firebase-admin/lib/security-rules/security-rules-api-client-internal.js

@@ -0,0 +1,248 @@
+/*! firebase-admin v13.5.0 */
+"use strict";
+/*!
+ * Copyright 2019 Google Inc.
+ *
+ * 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.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 utils = require("../utils/index");
+const validator = require("../utils/validator");
+const RULES_V1_API = 'https://firebaserules.googleapis.com/v1';
+const FIREBASE_VERSION_HEADER = {
+    'X-Firebase-Client': `fire-admin-node/${utils.getSdkVersion()}`,
+};
+/**
+ * Class that facilitates sending requests to the Firebase security rules backend API.
+ *
+ * @private
+ */
+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.');
+        }
+        this.httpClient = new api_request_1.AuthorizedHttpClient(app);
+    }
+    getRuleset(name) {
+        return Promise.resolve()
+            .then(() => {
+            return this.getRulesetName(name);
+        })
+            .then((rulesetName) => {
+            return this.getResource(rulesetName);
+        });
+    }
+    createRuleset(ruleset) {
+        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.');
+            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)}`);
+                return Promise.reject(err);
+            }
+        }
+        return this.getUrl()
+            .then((url) => {
+            const request = {
+                method: 'POST',
+                url: `${url}/rulesets`,
+                data: ruleset,
+            };
+            return this.sendRequest(request);
+        });
+    }
+    deleteRuleset(name) {
+        return this.getUrl()
+            .then((url) => {
+            const rulesetName = this.getRulesetName(name);
+            const request = {
+                method: 'DELETE',
+                url: `${url}/${rulesetName}`,
+            };
+            return this.sendRequest(request);
+        });
+    }
+    listRulesets(pageSize = 100, pageToken) {
+        if (!validator.isNumber(pageSize)) {
+            const err = new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', '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.');
+            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.');
+            return Promise.reject(err);
+        }
+        const data = {
+            pageSize,
+            pageToken,
+        };
+        if (!pageToken) {
+            delete data.pageToken;
+        }
+        return this.getUrl()
+            .then((url) => {
+            const request = {
+                method: 'GET',
+                url: `${url}/rulesets`,
+                data,
+            };
+            return this.sendRequest(request);
+        });
+    }
+    getRelease(name) {
+        return this.getResource(`releases/${name}`);
+    }
+    updateOrCreateRelease(name, rulesetName) {
+        return this.updateRelease(name, rulesetName).catch((error) => {
+            // if ruleset update failed with a NOT_FOUND error, attempt to create instead.
+            if (error.code === `security-rules/${ERROR_CODE_MAPPING.NOT_FOUND}`) {
+                return this.createRelease(name, rulesetName);
+            }
+            throw error;
+        });
+    }
+    updateRelease(name, rulesetName) {
+        return this.getUrl()
+            .then((url) => {
+            return this.getReleaseDescription(name, rulesetName)
+                .then((release) => {
+                const request = {
+                    method: 'PATCH',
+                    url: `${url}/releases/${name}`,
+                    data: { release },
+                };
+                return this.sendRequest(request);
+            });
+        });
+    }
+    createRelease(name, rulesetName) {
+        return this.getUrl()
+            .then((url) => {
+            return this.getReleaseDescription(name, rulesetName)
+                .then((release) => {
+                const request = {
+                    method: 'POST',
+                    url: `${url}/releases`,
+                    data: release,
+                };
+                return this.sendRequest(request);
+            });
+        });
+    }
+    getUrl() {
+        return this.getProjectIdPrefix()
+            .then((projectIdPrefix) => {
+            return `${RULES_V1_API}/${projectIdPrefix}`;
+        });
+    }
+    getProjectIdPrefix() {
+        if (this.projectIdPrefix) {
+            return Promise.resolve(this.projectIdPrefix);
+        }
+        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.');
+            }
+            this.projectIdPrefix = `projects/${projectId}`;
+            return this.projectIdPrefix;
+        });
+    }
+    /**
+     * Gets the specified resource from the rules API. Resource names must be the short names without project
+     * ID prefix (e.g. `rulesets/ruleset-name`).
+     *
+     * @param {string} name Full qualified name of the resource to get.
+     * @returns {Promise<T>} A promise that fulfills with the resource.
+     */
+    getResource(name) {
+        return this.getUrl()
+            .then((url) => {
+            const request = {
+                method: 'GET',
+                url: `${url}/${name}`,
+            };
+            return this.sendRequest(request);
+        });
+    }
+    getReleaseDescription(name, rulesetName) {
+        return this.getProjectIdPrefix()
+            .then((projectIdPrefix) => {
+            return {
+                name: `${projectIdPrefix}/releases/${name}`,
+                rulesetName: `${projectIdPrefix}/${this.getRulesetName(rulesetName)}`,
+            };
+        });
+    }
+    getRulesetName(name) {
+        if (!validator.isNonEmptyString(name)) {
+            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', '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.');
+        }
+        return `rulesets/${name}`;
+    }
+    sendRequest(request) {
+        request.headers = FIREBASE_VERSION_HEADER;
+        return this.httpClient.send(request)
+            .then((resp) => {
+            return resp.data;
+        })
+            .catch((err) => {
+            throw this.toFirebaseError(err);
+        });
+    }
+    toFirebaseError(err) {
+        if (err instanceof error_1.PrefixedFirebaseError) {
+            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}`);
+        }
+        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);
+    }
+}
+exports.SecurityRulesApiClient = SecurityRulesApiClient;
+const ERROR_CODE_MAPPING = {
+    INVALID_ARGUMENT: 'invalid-argument',
+    NOT_FOUND: 'not-found',
+    RESOURCE_EXHAUSTED: 'resource-exhausted',
+    UNAUTHENTICATED: 'authentication-error',
+    UNKNOWN: 'unknown-error',
+};

server/node_modules/firebase-admin/lib/security-rules/security-rules-internal.d.ts

@@ -0,0 +1,21 @@
+/*! firebase-admin v13.5.0 */
+/*!
+ * Copyright 2019 Google Inc.
+ *
+ * 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 { PrefixedFirebaseError } from '../utils/error';
+export type SecurityRulesErrorCode = 'already-exists' | 'authentication-error' | 'internal-error' | 'invalid-argument' | 'invalid-server-response' | 'not-found' | 'resource-exhausted' | 'service-unavailable' | 'unknown-error';
+export declare class FirebaseSecurityRulesError extends PrefixedFirebaseError {
+    constructor(code: SecurityRulesErrorCode, message: string);
+}

server/node_modules/firebase-admin/lib/security-rules/security-rules-internal.js

@@ -0,0 +1,26 @@
+/*! firebase-admin v13.5.0 */
+"use strict";
+/*!
+ * Copyright 2019 Google Inc.
+ *
+ * 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 = void 0;
+const error_1 = require("../utils/error");
+class FirebaseSecurityRulesError extends error_1.PrefixedFirebaseError {
+    constructor(code, message) {
+        super('security-rules', code, message);
+    }
+}
+exports.FirebaseSecurityRulesError = FirebaseSecurityRulesError;

server/node_modules/firebase-admin/lib/security-rules/security-rules-namespace.d.ts

@@ -0,0 +1,69 @@
+/*! firebase-admin v13.5.0 */
+/*!
+ * Copyright 2021 Google Inc.
+ *
+ * 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 { App } from '../app';
+import { RulesFile as TRulesFile, Ruleset as TRuleset, RulesetMetadata as TRulesetMetadata, RulesetMetadataList as TRulesetMetadataList, SecurityRules as TSecurityRules } from './security-rules';
+/**
+ * Gets the {@link firebase-admin.security-rules#SecurityRules} service for the default
+ * app or a given app.
+ *
+ * `admin.securityRules()` can be called with no arguments to access the
+ * default app's {@link firebase-admin.security-rules#SecurityRules}
+ * service, or as `admin.securityRules(app)` to access
+ * the {@link firebase-admin.security-rules#SecurityRules}
+ * service associated with a specific app.
+ *
+ * @example
+ * ```javascript
+ * // Get the SecurityRules service for the default app
+ * var defaultSecurityRules = admin.securityRules();
+ * ```
+ *
+ * @example
+ * ```javascript
+ * // Get the SecurityRules service for a given app
+ * var otherSecurityRules = admin.securityRules(otherApp);
+ * ```
+ *
+ * @param app - Optional app to return the `SecurityRules` service
+ *     for. If not provided, the default `SecurityRules` service
+ *     is returned.
+ * @returns The default `SecurityRules` service if no app is provided, or the
+ *   `SecurityRules` service associated with the provided app.
+ */
+export declare function securityRules(app?: App): securityRules.SecurityRules;
+export declare namespace securityRules {
+    /**
+     * Type alias to {@link firebase-admin.security-rules#RulesFile}.
+     */
+    type RulesFile = TRulesFile;
+    /**
+     * Type alias to {@link firebase-admin.security-rules#Ruleset}.
+     */
+    type Ruleset = TRuleset;
+    /**
+     * Type alias to {@link firebase-admin.security-rules#RulesetMetadata}.
+     */
+    type RulesetMetadata = TRulesetMetadata;
+    /**
+     * Type alias to {@link firebase-admin.security-rules#RulesetMetadataList}.
+     */
+    type RulesetMetadataList = TRulesetMetadataList;
+    /**
+     * Type alias to {@link firebase-admin.security-rules#SecurityRules}.
+     */
+    type SecurityRules = TSecurityRules;
+}

server/node_modules/firebase-admin/lib/security-rules/security-rules-namespace.js

@@ -0,0 +1,18 @@
+/*! firebase-admin v13.5.0 */
+"use strict";
+/*!
+ * Copyright 2021 Google Inc.
+ *
+ * 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 });

server/node_modules/firebase-admin/lib/security-rules/security-rules.d.ts

@@ -0,0 +1,195 @@
+/*! firebase-admin v13.5.0 */
+/*!
+ * Copyright 2019 Google Inc.
+ *
+ * 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 { App } from '../app';
+/**
+ * A source file containing some Firebase security rules. The content includes raw
+ * source code including text formatting, indentation and comments. Use the
+ * {@link SecurityRules.createRulesFileFromSource} method to create new instances of this type.
+ */
+export interface RulesFile {
+    readonly name: string;
+    readonly content: string;
+}
+/**
+ * Required metadata associated with a ruleset.
+ */
+export interface RulesetMetadata {
+    /**
+     * Name of the `Ruleset` as a short string. This can be directly passed into APIs
+     * like {@link SecurityRules.getRuleset} and {@link SecurityRules.deleteRuleset}.
+     */
+    readonly name: string;
+    /**
+     * Creation time of the `Ruleset` as a UTC timestamp string.
+     */
+    readonly createTime: string;
+}
+/**
+ * A page of ruleset metadata.
+ */
+export declare class RulesetMetadataList {
+    /**
+     * A batch of ruleset metadata.
+     */
+    readonly rulesets: RulesetMetadata[];
+    /**
+     * The next page token if available. This is needed to retrieve the next batch.
+     */
+    readonly nextPageToken?: string;
+}
+/**
+ * A set of Firebase security rules.
+ */
+export declare class Ruleset implements RulesetMetadata {
+    /**
+     * {@inheritdoc RulesetMetadata.name}
+     */
+    readonly name: string;
+    /**
+     * {@inheritdoc RulesetMetadata.createTime}
+     */
+    readonly createTime: string;
+    readonly source: RulesFile[];
+}
+/**
+ * The Firebase `SecurityRules` service interface.
+ */
+export declare class SecurityRules {
+    readonly app: App;
+    private static readonly CLOUD_FIRESTORE;
+    private static readonly FIREBASE_STORAGE;
+    private readonly client;
+    /**
+     * Gets the {@link Ruleset} identified by the given
+     * name. The input name should be the short name string without the project ID
+     * prefix. For example, to retrieve the `projects/project-id/rulesets/my-ruleset`,
+     * pass the short name "my-ruleset". Rejects with a `not-found` error if the
+     * specified `Ruleset` cannot be found.
+     *
+     * @param name - Name of the `Ruleset` to retrieve.
+     * @returns A promise that fulfills with the specified `Ruleset`.
+     */
+    getRuleset(name: string): Promise<Ruleset>;
+    /**
+     * Gets the {@link Ruleset} currently applied to
+     * Cloud Firestore. Rejects with a `not-found` error if no ruleset is applied
+     * on Firestore.
+     *
+     * @returns A promise that fulfills with the Firestore ruleset.
+     */
+    getFirestoreRuleset(): Promise<Ruleset>;
+    /**
+     * Creates a new {@link Ruleset} from the given
+     * source, and applies it to Cloud Firestore.
+     *
+     * @param source - Rules source to apply.
+     * @returns A promise that fulfills when the ruleset is created and released.
+     */
+    releaseFirestoreRulesetFromSource(source: string | Buffer): Promise<Ruleset>;
+    /**
+     * Applies the specified {@link Ruleset} ruleset
+     * to Cloud Firestore.
+     *
+     * @param ruleset - Name of the ruleset to apply or a `RulesetMetadata` object
+     *   containing the name.
+     * @returns A promise that fulfills when the ruleset is released.
+     */
+    releaseFirestoreRuleset(ruleset: string | RulesetMetadata): Promise<void>;
+    /**
+     * Gets the {@link Ruleset} currently applied to a
+     * Cloud Storage bucket. Rejects with a `not-found` error if no ruleset is applied
+     * on the bucket.
+     *
+     * @param bucket - Optional name of the Cloud Storage bucket to be retrieved. If not
+     *   specified, retrieves the ruleset applied on the default bucket configured via
+     *   `AppOptions`.
+     * @returns A promise that fulfills with the Cloud Storage ruleset.
+     */
+    getStorageRuleset(bucket?: string): Promise<Ruleset>;
+    /**
+     * Creates a new {@link Ruleset} from the given
+     * source, and applies it to a Cloud Storage bucket.
+     *
+     * @param source - Rules source to apply.
+     * @param bucket - Optional name of the Cloud Storage bucket to apply the rules on. If
+     *   not specified, applies the ruleset on the default bucket configured via
+     *   {@link firebase-admin.app#AppOptions}.
+     * @returns A promise that fulfills when the ruleset is created and released.
+     */
+    releaseStorageRulesetFromSource(source: string | Buffer, bucket?: string): Promise<Ruleset>;
+    /**
+     * Applies the specified {@link Ruleset} ruleset
+     * to a Cloud Storage bucket.
+     *
+     * @param ruleset - Name of the ruleset to apply or a `RulesetMetadata` object
+     *   containing the name.
+     * @param bucket - Optional name of the Cloud Storage bucket to apply the rules on. If
+     *   not specified, applies the ruleset on the default bucket configured via
+     *   {@link firebase-admin.app#AppOptions}.
+     * @returns A promise that fulfills when the ruleset is released.
+     */
+    releaseStorageRuleset(ruleset: string | RulesetMetadata, bucket?: string): Promise<void>;
+    /**
+     * Creates a {@link RulesFile} with the given name
+     * and source. Throws an error if any of the arguments are invalid. This is a local
+     * operation, and does not involve any network API calls.
+     *
+     * @example
+     * ```javascript
+     * const source = '// Some rules source';
+     * const rulesFile = admin.securityRules().createRulesFileFromSource(
+     *   'firestore.rules', source);
+     * ```
+     *
+     * @param name - Name to assign to the rules file. This is usually a short file name that
+     *   helps identify the file in a ruleset.
+     * @param source - Contents of the rules file.
+     * @returns A new rules file instance.
+     */
+    createRulesFileFromSource(name: string, source: string | Buffer): RulesFile;
+    /**
+     * Creates a new {@link Ruleset} from the given {@link RulesFile}.
+     *
+     * @param file - Rules file to include in the new `Ruleset`.
+     * @returns A promise that fulfills with the newly created `Ruleset`.
+     */
+    createRuleset(file: RulesFile): Promise<Ruleset>;
+    /**
+     * Deletes the {@link Ruleset} identified by the given
+     * name. The input name should be the short name string without the project ID
+     * prefix. For example, to delete the `projects/project-id/rulesets/my-ruleset`,
+     * pass the  short name "my-ruleset". Rejects with a `not-found` error if the
+     * specified `Ruleset` cannot be found.
+     *
+     * @param name - Name of the `Ruleset` to delete.
+     * @returns A promise that fulfills when the `Ruleset` is deleted.
+     */
+    deleteRuleset(name: string): Promise<void>;
+    /**
+     * Retrieves a page of ruleset metadata.
+     *
+     * @param pageSize - The page size, 100 if undefined. This is also the maximum allowed
+     *   limit.
+     * @param nextPageToken - The next page token. If not specified, returns rulesets
+     *   starting without any offset.
+     * @returns A promise that fulfills with a page of rulesets.
+     */
+    listRulesetMetadata(pageSize?: number, nextPageToken?: string): Promise<RulesetMetadataList>;
+    private getRulesetForRelease;
+    private releaseRuleset;
+    private getBucketName;
+}

server/node_modules/firebase-admin/lib/security-rules/security-rules.js

@@ -0,0 +1,319 @@
+/*! firebase-admin v13.5.0 */
+"use strict";
+/*!
+ * Copyright 2019 Google Inc.
+ *
+ * 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.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");
+/**
+ * A page of ruleset metadata.
+ */
+class RulesetMetadataList {
+    /**
+     * @internal
+     */
+    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)}`);
+        }
+        this.rulesets = response.rulesets.map((rs) => {
+            return {
+                name: stripProjectIdPrefix(rs.name),
+                createTime: new Date(rs.createTime).toUTCString(),
+            };
+        });
+        if (response.nextPageToken) {
+            this.nextPageToken = response.nextPageToken;
+        }
+    }
+}
+exports.RulesetMetadataList = RulesetMetadataList;
+/**
+ * A set of Firebase security rules.
+ */
+class Ruleset {
+    /**
+     * @internal
+     */
+    constructor(ruleset) {
+        if (!validator.isNonNullObject(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)}`);
+        }
+        this.name = stripProjectIdPrefix(ruleset.name);
+        this.createTime = new Date(ruleset.createTime).toUTCString();
+        this.source = ruleset.source.files || [];
+    }
+}
+exports.Ruleset = Ruleset;
+/**
+ * The Firebase `SecurityRules` service interface.
+ */
+class SecurityRules {
+    /**
+     * @param app - The app for this SecurityRules service.
+     * @constructor
+     * @internal
+     */
+    constructor(app) {
+        this.app = app;
+        this.client = new security_rules_api_client_internal_1.SecurityRulesApiClient(app);
+    }
+    /**
+     * Gets the {@link Ruleset} identified by the given
+     * name. The input name should be the short name string without the project ID
+     * prefix. For example, to retrieve the `projects/project-id/rulesets/my-ruleset`,
+     * pass the short name "my-ruleset". Rejects with a `not-found` error if the
+     * specified `Ruleset` cannot be found.
+     *
+     * @param name - Name of the `Ruleset` to retrieve.
+     * @returns A promise that fulfills with the specified `Ruleset`.
+     */
+    getRuleset(name) {
+        return this.client.getRuleset(name)
+            .then((rulesetResponse) => {
+            return new Ruleset(rulesetResponse);
+        });
+    }
+    /**
+     * Gets the {@link Ruleset} currently applied to
+     * Cloud Firestore. Rejects with a `not-found` error if no ruleset is applied
+     * on Firestore.
+     *
+     * @returns A promise that fulfills with the Firestore ruleset.
+     */
+    getFirestoreRuleset() {
+        return this.getRulesetForRelease(SecurityRules.CLOUD_FIRESTORE);
+    }
+    /**
+     * Creates a new {@link Ruleset} from the given
+     * source, and applies it to Cloud Firestore.
+     *
+     * @param source - Rules source to apply.
+     * @returns A promise that fulfills when the ruleset is created and released.
+     */
+    releaseFirestoreRulesetFromSource(source) {
+        return Promise.resolve()
+            .then(() => {
+            const rulesFile = this.createRulesFileFromSource('firestore.rules', source);
+            return this.createRuleset(rulesFile);
+        })
+            .then((ruleset) => {
+            return this.releaseFirestoreRuleset(ruleset)
+                .then(() => {
+                return ruleset;
+            });
+        });
+    }
+    /**
+     * Applies the specified {@link Ruleset} ruleset
+     * to Cloud Firestore.
+     *
+     * @param ruleset - Name of the ruleset to apply or a `RulesetMetadata` object
+     *   containing the name.
+     * @returns A promise that fulfills when the ruleset is released.
+     */
+    releaseFirestoreRuleset(ruleset) {
+        return this.releaseRuleset(ruleset, SecurityRules.CLOUD_FIRESTORE);
+    }
+    /**
+     * Gets the {@link Ruleset} currently applied to a
+     * Cloud Storage bucket. Rejects with a `not-found` error if no ruleset is applied
+     * on the bucket.
+     *
+     * @param bucket - Optional name of the Cloud Storage bucket to be retrieved. If not
+     *   specified, retrieves the ruleset applied on the default bucket configured via
+     *   `AppOptions`.
+     * @returns A promise that fulfills with the Cloud Storage ruleset.
+     */
+    getStorageRuleset(bucket) {
+        return Promise.resolve()
+            .then(() => {
+            return this.getBucketName(bucket);
+        })
+            .then((bucketName) => {
+            return this.getRulesetForRelease(`${SecurityRules.FIREBASE_STORAGE}/${bucketName}`);
+        });
+    }
+    /**
+     * Creates a new {@link Ruleset} from the given
+     * source, and applies it to a Cloud Storage bucket.
+     *
+     * @param source - Rules source to apply.
+     * @param bucket - Optional name of the Cloud Storage bucket to apply the rules on. If
+     *   not specified, applies the ruleset on the default bucket configured via
+     *   {@link firebase-admin.app#AppOptions}.
+     * @returns A promise that fulfills when the ruleset is created and released.
+     */
+    releaseStorageRulesetFromSource(source, bucket) {
+        return Promise.resolve()
+            .then(() => {
+            // Bucket name is not required until the last step. But since there's a createRuleset step
+            // before then, make sure to run this check and fail early if the bucket name is invalid.
+            this.getBucketName(bucket);
+            const rulesFile = this.createRulesFileFromSource('storage.rules', source);
+            return this.createRuleset(rulesFile);
+        })
+            .then((ruleset) => {
+            return this.releaseStorageRuleset(ruleset, bucket)
+                .then(() => {
+                return ruleset;
+            });
+        });
+    }
+    /**
+     * Applies the specified {@link Ruleset} ruleset
+     * to a Cloud Storage bucket.
+     *
+     * @param ruleset - Name of the ruleset to apply or a `RulesetMetadata` object
+     *   containing the name.
+     * @param bucket - Optional name of the Cloud Storage bucket to apply the rules on. If
+     *   not specified, applies the ruleset on the default bucket configured via
+     *   {@link firebase-admin.app#AppOptions}.
+     * @returns A promise that fulfills when the ruleset is released.
+     */
+    releaseStorageRuleset(ruleset, bucket) {
+        return Promise.resolve()
+            .then(() => {
+            return this.getBucketName(bucket);
+        })
+            .then((bucketName) => {
+            return this.releaseRuleset(ruleset, `${SecurityRules.FIREBASE_STORAGE}/${bucketName}`);
+        });
+    }
+    /**
+     * Creates a {@link RulesFile} with the given name
+     * and source. Throws an error if any of the arguments are invalid. This is a local
+     * operation, and does not involve any network API calls.
+     *
+     * @example
+     * ```javascript
+     * const source = '// Some rules source';
+     * const rulesFile = admin.securityRules().createRulesFileFromSource(
+     *   'firestore.rules', source);
+     * ```
+     *
+     * @param name - Name to assign to the rules file. This is usually a short file name that
+     *   helps identify the file in a ruleset.
+     * @param source - Contents of the rules file.
+     * @returns A new rules file instance.
+     */
+    createRulesFileFromSource(name, source) {
+        if (!validator.isNonEmptyString(name)) {
+            throw new security_rules_internal_1.FirebaseSecurityRulesError('invalid-argument', 'Name must be a non-empty string.');
+        }
+        let content;
+        if (validator.isNonEmptyString(source)) {
+            content = source;
+        }
+        else if (validator.isBuffer(source)) {
+            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.');
+        }
+        return {
+            name,
+            content,
+        };
+    }
+    /**
+     * Creates a new {@link Ruleset} from the given {@link RulesFile}.
+     *
+     * @param file - Rules file to include in the new `Ruleset`.
+     * @returns A promise that fulfills with the newly created `Ruleset`.
+     */
+    createRuleset(file) {
+        const ruleset = {
+            source: {
+                files: [file],
+            },
+        };
+        return this.client.createRuleset(ruleset)
+            .then((rulesetResponse) => {
+            return new Ruleset(rulesetResponse);
+        });
+    }
+    /**
+     * Deletes the {@link Ruleset} identified by the given
+     * name. The input name should be the short name string without the project ID
+     * prefix. For example, to delete the `projects/project-id/rulesets/my-ruleset`,
+     * pass the  short name "my-ruleset". Rejects with a `not-found` error if the
+     * specified `Ruleset` cannot be found.
+     *
+     * @param name - Name of the `Ruleset` to delete.
+     * @returns A promise that fulfills when the `Ruleset` is deleted.
+     */
+    deleteRuleset(name) {
+        return this.client.deleteRuleset(name);
+    }
+    /**
+     * Retrieves a page of ruleset metadata.
+     *
+     * @param pageSize - The page size, 100 if undefined. This is also the maximum allowed
+     *   limit.
+     * @param nextPageToken - The next page token. If not specified, returns rulesets
+     *   starting without any offset.
+     * @returns A promise that fulfills with a page of rulesets.
+     */
+    listRulesetMetadata(pageSize = 100, nextPageToken) {
+        return this.client.listRulesets(pageSize, nextPageToken)
+            .then((response) => {
+            return new RulesetMetadataList(response);
+        });
+    }
+    getRulesetForRelease(releaseName) {
+        return this.client.getRelease(releaseName)
+            .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}.`);
+            }
+            return this.getRuleset(stripProjectIdPrefix(rulesetName));
+        });
+    }
+    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.');
+            return Promise.reject(err);
+        }
+        const rulesetName = validator.isString(ruleset) ? ruleset : ruleset.name;
+        return this.client.updateOrCreateRelease(releaseName, rulesetName)
+            .then(() => {
+            return;
+        });
+    }
+    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.');
+        }
+        return bucketName;
+    }
+}
+exports.SecurityRules = SecurityRules;
+SecurityRules.CLOUD_FIRESTORE = 'cloud.firestore';
+SecurityRules.FIREBASE_STORAGE = 'firebase.storage';
+function stripProjectIdPrefix(name) {
+    return name.split('/').pop();
+}