push all website files

website/node_modules/firebase-functions/lib/providers/database.js

@@ -0,0 +1,315 @@
+"use strict";
+// The MIT License (MIT)
+//
+// Copyright (c) 2017 Firebase
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+Object.defineProperty(exports, "__esModule", { value: true });
+const _ = require("lodash");
+const apps_1 = require("../apps");
+const cloud_functions_1 = require("../cloud-functions");
+const utils_1 = require("../utils");
+const config_1 = require("../config");
+/** @internal */
+exports.provider = 'google.firebase.database';
+/** @internal */
+exports.service = 'firebaseio.com';
+// NOTE(inlined): Should we relax this a bit to allow staging or alternate implementations of our API?
+const databaseURLRegex = new RegExp('https://([^.]+).firebaseio.com');
+/**
+ * Selects a database instance that will trigger the function.
+ * If omitted, will pick the default database for your project.
+ * @param instance The Realtime Database instance to use.
+ */
+function instance(instance) {
+    return _instanceWithOpts(instance, {});
+}
+exports.instance = instance;
+/**
+ * Select Firebase Realtime Database Reference to listen to.
+ *
+ * This method behaves very similarly to the method of the same name in the
+ * client and Admin Firebase SDKs. Any change to the Database that affects the
+ * data at or below the provided `path` will fire an event in Cloud Functions.
+ *
+ * There are three important differences between listening to a Realtime
+ * Database event in Cloud Functions and using the Realtime Database in the
+ * client and Admin SDKs:
+ * 1. Cloud Functions allows wildcards in the `path` name. Any `path` component
+ *    in curly brackets (`{}`) is a wildcard that matches all strings. The value
+ *    that matched a certain invocation of a Cloud Function is returned as part
+ *    of the `context.params` object. For example, `ref("messages/{messageId}")`
+ *    matches changes at `/messages/message1` or `/messages/message2`, resulting
+ *    in  `context.params.messageId` being set to `"message1"` or `"message2"`,
+ *    respectively.
+ * 2. Cloud Functions do not fire an event for data that already existed before
+ *    the Cloud Function was deployed.
+ * 3. Cloud Function events have access to more information, including information
+ *    about the user who triggered the Cloud Function.
+ * @param ref Path of the database to listen to.
+ */
+function ref(path) {
+    return _refWithOpts(path, {});
+}
+exports.ref = ref;
+/** @internal */
+function _instanceWithOpts(instance, opts) {
+    return new InstanceBuilder(instance, opts);
+}
+exports._instanceWithOpts = _instanceWithOpts;
+class InstanceBuilder {
+    /* @internal */
+    constructor(instance, opts) {
+        this.instance = instance;
+        this.opts = opts;
+    }
+    ref(path) {
+        const normalized = utils_1.normalizePath(path);
+        return new RefBuilder(apps_1.apps(), () => `projects/_/instances/${this.instance}/refs/${normalized}`, this.opts);
+    }
+}
+exports.InstanceBuilder = InstanceBuilder;
+/** @internal */
+function _refWithOpts(path, opts) {
+    const resourceGetter = () => {
+        const normalized = utils_1.normalizePath(path);
+        const databaseURL = config_1.firebaseConfig().databaseURL;
+        if (!databaseURL) {
+            throw new Error('Missing expected firebase config value databaseURL, ' +
+                'config is actually' +
+                JSON.stringify(config_1.firebaseConfig()) +
+                '\n If you are unit testing, please set process.env.FIREBASE_CONFIG');
+        }
+        const match = databaseURL.match(databaseURLRegex);
+        if (!match) {
+            throw new Error('Invalid value for config firebase.databaseURL: ' + databaseURL);
+        }
+        const subdomain = match[1];
+        return `projects/_/instances/${subdomain}/refs/${normalized}`;
+    };
+    return new RefBuilder(apps_1.apps(), resourceGetter, opts);
+}
+exports._refWithOpts = _refWithOpts;
+/** Builder used to create Cloud Functions for Firebase Realtime Database References. */
+class RefBuilder {
+    /** @internal */
+    constructor(apps, triggerResource, opts) {
+        this.apps = apps;
+        this.triggerResource = triggerResource;
+        this.opts = opts;
+        this.changeConstructor = (raw) => {
+            let [dbInstance, path] = resourceToInstanceAndPath(raw.context.resource.name);
+            let before = new DataSnapshot(raw.data.data, path, this.apps.admin, dbInstance);
+            let after = new DataSnapshot(utils_1.applyChange(raw.data.data, raw.data.delta), path, this.apps.admin, dbInstance);
+            return {
+                before: before,
+                after: after,
+            };
+        };
+    }
+    /** Respond to any write that affects a ref. */
+    onWrite(handler) {
+        return this.onOperation(handler, 'ref.write', this.changeConstructor);
+    }
+    /** Respond to update on a ref. */
+    onUpdate(handler) {
+        return this.onOperation(handler, 'ref.update', this.changeConstructor);
+    }
+    /** Respond to new data on a ref. */
+    onCreate(handler) {
+        let dataConstructor = (raw) => {
+            let [dbInstance, path] = resourceToInstanceAndPath(raw.context.resource.name);
+            return new DataSnapshot(raw.data.delta, path, this.apps.admin, dbInstance);
+        };
+        return this.onOperation(handler, 'ref.create', dataConstructor);
+    }
+    /** Respond to all data being deleted from a ref. */
+    onDelete(handler) {
+        let dataConstructor = (raw) => {
+            let [dbInstance, path] = resourceToInstanceAndPath(raw.context.resource.name);
+            return new DataSnapshot(raw.data.data, path, this.apps.admin, dbInstance);
+        };
+        return this.onOperation(handler, 'ref.delete', dataConstructor);
+    }
+    onOperation(handler, eventType, dataConstructor) {
+        return cloud_functions_1.makeCloudFunction({
+            handler,
+            provider: exports.provider,
+            service: exports.service,
+            eventType,
+            legacyEventType: `providers/${exports.provider}/eventTypes/${eventType}`,
+            triggerResource: this.triggerResource,
+            dataConstructor: dataConstructor,
+            before: event => this.apps.retain(),
+            after: event => this.apps.release(),
+            opts: this.opts,
+        });
+    }
+}
+exports.RefBuilder = RefBuilder;
+/* Utility function to extract database reference from resource string */
+/** @internal */
+function resourceToInstanceAndPath(resource) {
+    let resourceRegex = `projects/([^/]+)/instances/([^/]+)/refs(/.+)?`;
+    let match = resource.match(new RegExp(resourceRegex));
+    if (!match) {
+        throw new Error(`Unexpected resource string for Firebase Realtime Database event: ${resource}. ` +
+            'Expected string in the format of "projects/_/instances/{firebaseioSubdomain}/refs/{ref=**}"');
+    }
+    let [, project, dbInstanceName, path] = match;
+    if (project !== '_') {
+        throw new Error(`Expect project to be '_' in a Firebase Realtime Database event`);
+    }
+    let dbInstance = 'https://' + dbInstanceName + '.firebaseio.com';
+    return [dbInstance, path];
+}
+exports.resourceToInstanceAndPath = resourceToInstanceAndPath;
+class DataSnapshot {
+    constructor(data, path, // path will be undefined for the database root
+    app, instance) {
+        this.app = app;
+        if (instance) {
+            // SDK always supplies instance, but user's unit tests may not
+            this.instance = instance;
+        }
+        else if (app) {
+            this.instance = app.options.databaseURL;
+        }
+        else if (process.env.GCLOUD_PROJECT) {
+            this.instance =
+                'https://' + process.env.GCLOUD_PROJECT + '.firebaseio.com';
+        }
+        this._path = path;
+        this._data = data;
+    }
+    /** Ref returns a reference to the database with full admin access. */
+    get ref() {
+        if (!this.app) {
+            // may be unpopulated in user's unit tests
+            throw new Error('Please supply a Firebase app in the constructor for DataSnapshot' +
+                ' in order to use the .ref method.');
+        }
+        if (!this._ref) {
+            this._ref = this.app.database(this.instance).ref(this._fullPath());
+        }
+        return this._ref;
+    }
+    get key() {
+        let last = _.last(utils_1.pathParts(this._fullPath()));
+        return !last || last === '' ? null : last;
+    }
+    val() {
+        let parts = utils_1.pathParts(this._childPath);
+        let source = this._data;
+        let node = _.cloneDeep(parts.length ? _.get(source, parts, null) : source);
+        return this._checkAndConvertToArray(node);
+    }
+    // TODO(inlined): figure out what to do here
+    exportVal() {
+        return this.val();
+    }
+    // TODO(inlined): figure out what to do here
+    getPriority() {
+        return 0;
+    }
+    exists() {
+        return !_.isNull(this.val());
+    }
+    child(childPath) {
+        if (!childPath) {
+            return this;
+        }
+        return this._dup(childPath);
+    }
+    forEach(action) {
+        let val = this.val();
+        if (_.isPlainObject(val)) {
+            return _.some(val, (value, key) => action(this.child(key)) === true);
+        }
+        return false;
+    }
+    hasChild(childPath) {
+        return this.child(childPath).exists();
+    }
+    hasChildren() {
+        let val = this.val();
+        return _.isPlainObject(val) && _.keys(val).length > 0;
+    }
+    numChildren() {
+        let val = this.val();
+        return _.isPlainObject(val) ? Object.keys(val).length : 0;
+    }
+    /**
+     * Prints the value of the snapshot; use '.previous.toJSON()' and '.current.toJSON()' to explicitly see
+     * the previous and current values of the snapshot.
+     */
+    toJSON() {
+        return this.val();
+    }
+    /* Recursive function to check if keys are numeric & convert node object to array if they are */
+    _checkAndConvertToArray(node) {
+        if (node === null || typeof node === 'undefined') {
+            return null;
+        }
+        if (typeof node !== 'object') {
+            return node;
+        }
+        let obj = {};
+        let numKeys = 0;
+        let maxKey = 0;
+        let allIntegerKeys = true;
+        for (let key in node) {
+            if (!node.hasOwnProperty(key)) {
+                continue;
+            }
+            let childNode = node[key];
+            obj[key] = this._checkAndConvertToArray(childNode);
+            numKeys++;
+            const integerRegExp = /^(0|[1-9]\d*)$/;
+            if (allIntegerKeys && integerRegExp.test(key)) {
+                maxKey = Math.max(maxKey, Number(key));
+            }
+            else {
+                allIntegerKeys = false;
+            }
+        }
+        if (allIntegerKeys && maxKey < 2 * numKeys) {
+            // convert to array.
+            let array = [];
+            _.forOwn(obj, (val, key) => {
+                array[key] = val;
+            });
+            return array;
+        }
+        return obj;
+    }
+    _dup(childPath) {
+        let dup = new DataSnapshot(this._data, undefined, this.app, this.instance);
+        [dup._path, dup._childPath] = [this._path, this._childPath];
+        if (childPath) {
+            dup._childPath = utils_1.joinPath(dup._childPath, childPath);
+        }
+        return dup;
+    }
+    _fullPath() {
+        let out = (this._path || '') + '/' + (this._childPath || '');
+        return out;
+    }
+}
+exports.DataSnapshot = DataSnapshot;