import firebase from '@firebase/app';
import { __extends, __awaiter, __generator } from 'tslib';
import { Component } from '@firebase/component';
/**
* @license
* Copyright 2017 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.
*/
/**
* Standard error codes for different ways a request can fail, as defined by:
* https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
*
* This map is used primarily to convert from a backend error code string to
* a client SDK error code string, and make sure it's in the supported set.
*/
var errorCodeMap = {
OK: 'ok',
CANCELLED: 'cancelled',
UNKNOWN: 'unknown',
INVALID_ARGUMENT: 'invalid-argument',
DEADLINE_EXCEEDED: 'deadline-exceeded',
NOT_FOUND: 'not-found',
ALREADY_EXISTS: 'already-exists',
PERMISSION_DENIED: 'permission-denied',
UNAUTHENTICATED: 'unauthenticated',
RESOURCE_EXHAUSTED: 'resource-exhausted',
FAILED_PRECONDITION: 'failed-precondition',
ABORTED: 'aborted',
OUT_OF_RANGE: 'out-of-range',
UNIMPLEMENTED: 'unimplemented',
INTERNAL: 'internal',
UNAVAILABLE: 'unavailable',
DATA_LOSS: 'data-loss'
};
/**
* An explicit error that can be thrown from a handler to send an error to the
* client that called the function.
*/
var HttpsErrorImpl = /** @class */ (function (_super) {
__extends(HttpsErrorImpl, _super);
function HttpsErrorImpl(code, message, details) {
var _this = _super.call(this, message) || this;
// This is a workaround for a bug in TypeScript when extending Error:
// tslint:disable-next-line
// https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
Object.setPrototypeOf(_this, HttpsErrorImpl.prototype);
_this.code = code;
_this.details = details;
return _this;
}
return HttpsErrorImpl;
}(Error));
/**
* Takes an HTTP status code and returns the corresponding ErrorCode.
* This is the standard HTTP status code -> error mapping defined in:
* https://github.com/googleapis/googleapis/blob/master/google/rpc/code.proto
*
* @param status An HTTP status code.
* @return The corresponding ErrorCode, or ErrorCode.UNKNOWN if none.
*/
function codeForHTTPStatus(status) {
// Make sure any successful status is OK.
if (status >= 200 && status < 300) {
return 'ok';
}
switch (status) {
case 0:
// This can happen if the server returns 500.
return 'internal';
case 400:
return 'invalid-argument';
case 401:
return 'unauthenticated';
case 403:
return 'permission-denied';
case 404:
return 'not-found';
case 409:
return 'aborted';
case 429:
return 'resource-exhausted';
case 499:
return 'cancelled';
case 500:
return 'internal';
case 501:
return 'unimplemented';
case 503:
return 'unavailable';
case 504:
return 'deadline-exceeded';
}
return 'unknown';
}
/**
* Takes an HTTP response and returns the corresponding Error, if any.
*/
function _errorForResponse(status, bodyJSON, serializer) {
var code = codeForHTTPStatus(status);
// Start with reasonable defaults from the status code.
var description = code;
var details = undefined;
// Then look through the body for explicit details.
try {
var errorJSON = bodyJSON && bodyJSON.error;
if (errorJSON) {
var status_1 = errorJSON.status;
if (typeof status_1 === 'string') {
if (!errorCodeMap[status_1]) {
// They must've included an unknown error code in the body.
return new HttpsErrorImpl('internal', 'internal');
}
code = errorCodeMap[status_1];
// TODO(klimt): Add better default descriptions for error enums.
// The default description needs to be updated for the new code.
description = status_1;
}
var message = errorJSON.message;
if (typeof message === 'string') {
description = message;
}
details = errorJSON.details;
if (details !== undefined) {
details = serializer.decode(details);
}
}
}
catch (e) {
// If we couldn't parse explicit error data, that's fine.
}
if (code === 'ok') {
// Technically, there's an edge case where a developer could explicitly
// return an error code of OK, and we will treat it as success, but that
// seems reasonable.
return null;
}
return new HttpsErrorImpl(code, description, details);
}
/**
* Helper class to get metadata that should be included with a function call.
*/
var ContextProvider = /** @class */ (function () {
function ContextProvider(authProvider, messagingProvider) {
var _this = this;
this.auth = null;
this.messaging = null;
this.auth = authProvider.getImmediate({ optional: true });
this.messaging = messagingProvider.getImmediate({
optional: true
});
if (!this.auth) {
authProvider.get().then(function (auth) { return (_this.auth = auth); }, function () {
/* get() never rejects */
});
}
if (!this.messaging) {
messagingProvider.get().then(function (messaging) { return (_this.messaging = messaging); }, function () {
/* get() never rejects */
});
}
}
ContextProvider.prototype.getAuthToken = function () {
return __awaiter(this, void 0, void 0, function () {
var token;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.auth) {
return [2 /*return*/, undefined];
}
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, this.auth.getToken()];
case 2:
token = _a.sent();
if (!token) {
return [2 /*return*/, undefined];
}
return [2 /*return*/, token.accessToken];
case 3:
_a.sent();
// If there's any error when trying to get the auth token, leave it off.
return [2 /*return*/, undefined];
case 4: return [2 /*return*/];
}
});
});
};
ContextProvider.prototype.getInstanceIdToken = function () {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
if (!this.messaging ||
!('Notification' in self) ||
Notification.permission !== 'granted') {
return [2 /*return*/, undefined];
}
_a.label = 1;
case 1:
_a.trys.push([1, 3, , 4]);
return [4 /*yield*/, this.messaging.getToken()];
case 2: return [2 /*return*/, _a.sent()];
case 3:
_a.sent();
// We don't warn on this, because it usually means messaging isn't set up.
// console.warn('Failed to retrieve instance id token.', e);
// If there's any error when trying to get the token, leave it off.
return [2 /*return*/, undefined];
case 4: return [2 /*return*/];
}
});
});
};
ContextProvider.prototype.getContext = function () {
return __awaiter(this, void 0, void 0, function () {
var authToken, instanceIdToken;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, this.getAuthToken()];
case 1:
authToken = _a.sent();
return [4 /*yield*/, this.getInstanceIdToken()];
case 2:
instanceIdToken = _a.sent();
return [2 /*return*/, { authToken: authToken, instanceIdToken: instanceIdToken }];
}
});
});
};
return ContextProvider;
}());
/**
* @license
* Copyright 2017 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.
*/
var LONG_TYPE = 'type.googleapis.com/google.protobuf.Int64Value';
var UNSIGNED_LONG_TYPE = 'type.googleapis.com/google.protobuf.UInt64Value';
function mapValues(
// { [k: string]: unknown } is no longer a wildcard assignment target after typescript 3.5
// eslint-disable-next-line @typescript-eslint/no-explicit-any
o, f) {
var result = {};
for (var key in o) {
if (o.hasOwnProperty(key)) {
result[key] = f(o[key]);
}
}
return result;
}
var Serializer = /** @class */ (function () {
function Serializer() {
}
// Takes data and encodes it in a JSON-friendly way, such that types such as
// Date are preserved.
Serializer.prototype.encode = function (data) {
var _this = this;
if (data == null) {
return null;
}
if (data instanceof Number) {
data = data.valueOf();
}
if (typeof data === 'number' && isFinite(data)) {
// Any number in JS is safe to put directly in JSON and parse as a double
// without any loss of precision.
return data;
}
if (data === true || data === false) {
return data;
}
if (Object.prototype.toString.call(data) === '[object String]') {
return data;
}
if (data instanceof Date) {
return data.toISOString();
}
if (Array.isArray(data)) {
return data.map(function (x) { return _this.encode(x); });
}
if (typeof data === 'function' || typeof data === 'object') {
return mapValues(data, function (x) { return _this.encode(x); });
}
// If we got this far, the data is not encodable.
throw new Error('Data cannot be encoded in JSON: ' + data);
};
// Takes data that's been encoded in a JSON-friendly form and returns a form
// with richer datatypes, such as Dates, etc.
Serializer.prototype.decode = function (json) {
var _this = this;
if (json == null) {
return json;
}
if (json['@type']) {
switch (json['@type']) {
case LONG_TYPE:
// Fall through and handle this the same as unsigned.
case UNSIGNED_LONG_TYPE: {
// Technically, this could work return a valid number for malformed
// data if there was a number followed by garbage. But it's just not
// worth all the extra code to detect that case.
var value = Number(json['value']);
if (isNaN(value)) {
throw new Error('Data cannot be decoded from JSON: ' + json);
}
return value;
}
default: {
throw new Error('Data cannot be decoded from JSON: ' + json);
}
}
}
if (Array.isArray(json)) {
return json.map(function (x) { return _this.decode(x); });
}
if (typeof json === 'function' || typeof json === 'object') {
return mapValues(json, function (x) { return _this.decode(x); });
}
// Anything else is safe to return.
return json;
};
return Serializer;
}());
/**
* @license
* Copyright 2017 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.
*/
/**
* Returns a Promise that will be rejected after the given duration.
* The error will be of type HttpsErrorImpl.
*
* @param millis Number of milliseconds to wait before rejecting.
*/
function failAfter(millis) {
var timer;
var promise = new Promise(function (_, reject) {
timer = setTimeout(function () {
reject(new HttpsErrorImpl('deadline-exceeded', 'deadline-exceeded'));
}, millis);
});
return {
timer: timer,
promise: promise
};
}
/**
* The main class for the Firebase Functions SDK.
*/
var Service = /** @class */ (function () {
/**
* Creates a new Functions service for the given app and (optional) region or custom domain.
* @param app_ The FirebaseApp to use.
* @param regionOrCustomDomain_ one of:
* a) A region to call functions from, such as us-central1
* b) A custom domain to use as a functions prefix, such as https://mydomain.com
*/
function Service(app_, authProvider, messagingProvider, appCheckProvider, regionOrCustomDomain_, fetchImpl) {
var _this = this;
if (regionOrCustomDomain_ === void 0) { regionOrCustomDomain_ = 'us-central1'; }
this.app_ = app_;
this.appCheckProvider = appCheckProvider;
this.fetchImpl = fetchImpl;
this.serializer = new Serializer();
this.emulatorOrigin = null;
this.INTERNAL = {
delete: function () {
return Promise.resolve(_this.deleteService());
}
};
this.contextProvider = new ContextProvider(authProvider, messagingProvider);
// Cancels all ongoing requests when resolved.
this.cancelAllRequests = new Promise(function (resolve) {
_this.deleteService = function () {
return resolve();
};
});
// Resolve the region or custom domain overload by attempting to parse it.
try {
var url = new URL(regionOrCustomDomain_);
this.customDomain = url.origin;
this.region = 'us-central1';
}
catch (e) {
this.customDomain = null;
this.region = regionOrCustomDomain_;
}
}
Object.defineProperty(Service.prototype, "app", {
get: function () {
return this.app_;
},
enumerable: false,
configurable: true
});
/**
* Returns the URL for a callable with the given name.
* @param name The name of the callable.
*/
Service.prototype._url = function (name) {
var projectId = this.app_.options.projectId;
if (this.emulatorOrigin !== null) {
var origin_1 = this.emulatorOrigin;
return origin_1 + "/" + projectId + "/" + this.region + "/" + name;
}
if (this.customDomain !== null) {
return this.customDomain + "/" + name;
}
return "https://" + this.region + "-" + projectId + ".cloudfunctions.net/" + name;
};
/**
* Modify this instance to communicate with the Cloud Functions emulator.
*
* Note: this must be called before this instance has been used to do any operations.
*
* @param host The emulator host (ex: localhost)
* @param port The emulator port (ex: 5001)
*/
Service.prototype.useEmulator = function (host, port) {
this.emulatorOrigin = "http://" + host + ":" + port;
};
/**
* Changes this instance to point to a Cloud Functions emulator running
* locally. See https://firebase.google.com/docs/functions/local-emulator
*
* @deprecated Prefer the useEmulator(host, port) method.
* @param origin The origin of the local emulator, such as
* "http://localhost:5005".
*/
Service.prototype.useFunctionsEmulator = function (origin) {
this.emulatorOrigin = origin;
};
/**
* Returns a reference to the callable https trigger with the given name.
* @param name The name of the trigger.
*/
Service.prototype.httpsCallable = function (name, options) {
var _this = this;
return function (data) {
return _this.call(name, data, options || {});
};
};
/**
* Does an HTTP POST and returns the completed response.
* @param url The url to post to.
* @param body The JSON body of the post.
* @param headers The HTTP headers to include in the request.
* @return A Promise that will succeed when the request finishes.
*/
Service.prototype.postJSON = function (url, body, headers) {
return __awaiter(this, void 0, void 0, function () {
var appCheckToken, response, json;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
headers['Content-Type'] = 'application/json';
return [4 /*yield*/, this.getAppCheckToken()];
case 1:
appCheckToken = _a.sent();
if (appCheckToken !== null) {
headers['X-Firebase-AppCheck'] = appCheckToken;
}
_a.label = 2;
case 2:
_a.trys.push([2, 4, , 5]);
return [4 /*yield*/, this.fetchImpl(url, {
method: 'POST',
body: JSON.stringify(body),
headers: headers
})];
case 3:
response = _a.sent();
return [3 /*break*/, 5];
case 4:
_a.sent();
// This could be an unhandled error on the backend, or it could be a
// network error. There's no way to know, since an unhandled error on the
// backend will fail to set the proper CORS header, and thus will be
// treated as a network error by fetch.
return [2 /*return*/, {
status: 0,
json: null
}];
case 5:
json = null;
_a.label = 6;
case 6:
_a.trys.push([6, 8, , 9]);
return [4 /*yield*/, response.json()];
case 7:
json = _a.sent();
return [3 /*break*/, 9];
case 8:
_a.sent();
return [3 /*break*/, 9];
case 9: return [2 /*return*/, {
status: response.status,
json: json
}];
}
});
});
};
Service.prototype.getAppCheckToken = function () {
return __awaiter(this, void 0, void 0, function () {
var appCheck, result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0:
appCheck = this.appCheckProvider.getImmediate({ optional: true });
if (!appCheck) return [3 /*break*/, 2];
return [4 /*yield*/, appCheck.getToken()];
case 1:
result = _a.sent();
// If getToken() fails, it will still return a dummy token that also has
// an error field containing the error message. We will send any token
// provided here and show an error if/when it is rejected by the functions
// endpoint.
return [2 /*return*/, result.token];
case 2: return [2 /*return*/, null];
}
});
});
};
/**
* Calls a callable function asynchronously and returns the result.
* @param name The name of the callable trigger.
* @param data The data to pass as params to the function.s
*/
Service.prototype.call = function (name, data, options) {
return __awaiter(this, void 0, void 0, function () {
var url, body, headers, context, timeout, _a, timer, failAfterPromise, response, error, responseData, decodedData;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
url = this._url(name);
// Encode any special types, such as dates, in the input data.
data = this.serializer.encode(data);
body = { data: data };
headers = {};
return [4 /*yield*/, this.contextProvider.getContext()];
case 1:
context = _b.sent();
if (context.authToken) {
headers['Authorization'] = 'Bearer ' + context.authToken;
}
if (context.instanceIdToken) {
headers['Firebase-Instance-ID-Token'] = context.instanceIdToken;
}
timeout = options.timeout || 70000;
_a = failAfter(timeout), timer = _a.timer, failAfterPromise = _a.promise;
return [4 /*yield*/, Promise.race([
clearTimeoutWrapper(timer, this.postJSON(url, body, headers)),
failAfterPromise,
clearTimeoutWrapper(timer, this.cancelAllRequests)
])];
case 2:
response = _b.sent();
// If service was deleted, interrupted response throws an error.
if (!response) {
throw new HttpsErrorImpl('cancelled', 'Firebase Functions instance was deleted.');
}
error = _errorForResponse(response.status, response.json, this.serializer);
if (error) {
throw error;
}
if (!response.json) {
throw new HttpsErrorImpl('internal', 'Response is not valid JSON object.');
}
responseData = response.json.data;
// TODO(klimt): For right now, allow "result" instead of "data", for
// backwards compatibility.
if (typeof responseData === 'undefined') {
responseData = response.json.result;
}
if (typeof responseData === 'undefined') {
// Consider the response malformed.
throw new HttpsErrorImpl('internal', 'Response is missing data field.');
}
decodedData = this.serializer.decode(responseData);
return [2 /*return*/, { data: decodedData }];
}
});
});
};
return Service;
}());
function clearTimeoutWrapper(timer, promise) {
return __awaiter(this, void 0, void 0, function () {
var result;
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4 /*yield*/, promise];
case 1:
result = _a.sent();
// eslint-disable-next-line @typescript-eslint/no-explicit-any
clearTimeout(timer);
return [2 /*return*/, result];
}
});
});
}
/**
* @license
* 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.
*/
/**
* Type constant for Firebase Functions.
*/
var FUNCTIONS_TYPE = 'functions';
function registerFunctions(instance, fetchImpl) {
var namespaceExports = {
// no-inline
Functions: Service
};
function factory(container, _a) {
var regionOrCustomDomain = _a.instanceIdentifier;
// Dependencies
var app = container.getProvider('app').getImmediate();
var authProvider = container.getProvider('auth-internal');
var appCheckProvider = container.getProvider('app-check-internal');
var messagingProvider = container.getProvider('messaging');
// eslint-disable-next-line @typescript-eslint/no-explicit-any
return new Service(app, authProvider, messagingProvider, appCheckProvider, regionOrCustomDomain, fetchImpl);
}
instance.INTERNAL.registerComponent(new Component(FUNCTIONS_TYPE, factory, "PUBLIC" /* PUBLIC */)
.setServiceProps(namespaceExports)
.setMultipleInstances(true));
}
var name = "@firebase/functions";
var version = "0.6.14";
/**
* @license
* Copyright 2017 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.
*/
registerFunctions(firebase, fetch.bind(self));
firebase.registerVersion(name, version);
//# sourceMappingURL=index.esm.js.map