parse
Version:
Parse JavaScript SDK
334 lines (330 loc) • 11.4 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _uuid = _interopRequireDefault(require("./uuid"));
var _CoreManager = _interopRequireDefault(require("./CoreManager"));
var _ParseError = _interopRequireDefault(require("./ParseError"));
var _promiseUtils = require("./promiseUtils");
var _Xhr = require("./Xhr.weapp");
function _interopRequireDefault(e) {
return e && e.__esModule ? e : {
default: e
};
}
/* global XMLHttpRequest, XDomainRequest */
let useXDomainRequest = false;
// @ts-ignore
if (typeof XDomainRequest !== 'undefined' && !('withCredentials' in new XMLHttpRequest())) {
useXDomainRequest = true;
}
function getPath(base, pathname) {
if (base.endsWith('/')) {
base = base.slice(0, -1);
}
if (!pathname.startsWith('/')) {
pathname = '/' + pathname;
}
return base + pathname;
}
function ajaxIE9(method, url, data, _headers, options) {
return new Promise((resolve, reject) => {
// @ts-ignore
const xdr = new XDomainRequest();
xdr.onload = function () {
let response;
try {
response = JSON.parse(xdr.responseText);
} catch (e) {
reject(e);
}
if (response) {
resolve({
response
});
}
};
xdr.onerror = xdr.ontimeout = function () {
// Let's fake a real error message.
const fakeResponse = {
responseText: JSON.stringify({
code: _ParseError.default.X_DOMAIN_REQUEST,
error: "IE's XDomainRequest does not supply error info."
})
};
reject(fakeResponse);
};
xdr.onprogress = function () {
if (options && typeof options.progress === 'function') {
options.progress(xdr.responseText);
}
};
xdr.open(method, url);
xdr.send(data);
// @ts-ignore
if (options && typeof options.requestTask === 'function') {
// @ts-ignore
options.requestTask(xdr);
}
});
}
const RESTController = {
async ajax(method, url, data, headers, options) {
if (useXDomainRequest) {
return ajaxIE9(method, url, data, headers, options);
}
if (typeof fetch !== 'function') {
throw new Error('Cannot make a request: Fetch API not found.');
}
const promise = (0, _promiseUtils.resolvingPromise)();
const isIdempotent = _CoreManager.default.get('IDEMPOTENCY') && ['POST', 'PUT'].includes(method);
const requestId = isIdempotent ? (0, _uuid.default)() : '';
let attempts = 0;
const dispatch = async function () {
const controller = new AbortController();
const {
signal
} = controller;
headers = headers || {};
if (typeof headers['Content-Type'] !== 'string') {
headers['Content-Type'] = 'text/plain'; // Avoid pre-flight
}
if (_CoreManager.default.get('IS_NODE')) {
headers['User-Agent'] = 'Parse/' + _CoreManager.default.get('VERSION') + ' (NodeJS ' + process.versions.node + ')';
}
if (isIdempotent) {
headers['X-Parse-Request-Id'] = requestId;
}
const customHeaders = _CoreManager.default.get('REQUEST_HEADERS');
for (const key in customHeaders) {
headers[key] = customHeaders[key];
}
// @ts-ignore
if (options && typeof options.requestTask === 'function') {
// @ts-ignore
options.requestTask(controller);
}
try {
const fetchOptions = {
method,
headers,
signal,
redirect: 'manual'
};
if (data) {
fetchOptions.body = data;
}
const response = await fetch(url, fetchOptions);
const {
status
} = response;
if (status >= 200 && status < 300) {
let result;
const responseHeaders = {};
const availableHeaders = response.headers.get('access-control-expose-headers') || '';
availableHeaders.split(', ').forEach(header => {
if (header && response.headers.has(header)) {
responseHeaders[header] = response.headers.get(header);
}
});
if (options && typeof options.progress === 'function' && response.body) {
const reader = response.body.getReader();
const length = +response.headers.get('Content-Length') || 0;
if (length === 0) {
options.progress(null, null, null);
result = await response.json();
} else {
let recieved = 0;
const chunks = [];
while (true) {
const {
done,
value
} = await reader.read();
if (done) {
break;
}
chunks.push(value);
recieved += (value === null || value === void 0 ? void 0 : value.length) || 0;
options.progress(recieved / length, recieved, length);
}
const body = new Uint8Array(recieved);
let offset = 0;
for (const chunk of chunks) {
body.set(chunk, offset);
offset += chunk.length;
}
const jsonString = new TextDecoder().decode(body);
result = JSON.parse(jsonString);
}
} else {
result = await response.json();
}
promise.resolve({
status,
response: result,
headers: responseHeaders
});
} else if (status >= 400 && status < 500) {
const error = await response.json();
promise.reject(error);
} else if ([301, 302, 303, 307, 308].includes(status)) {
const location = response.headers.get('location');
promise.resolve({
status,
location,
method: status === 303 ? 'GET' : method,
dropBody: status === 303
});
} else if (status >= 500 || status === 0) {
// retry on 5XX or library error
if (++attempts < _CoreManager.default.get('REQUEST_ATTEMPT_LIMIT')) {
// Exponentially-growing random delay
const delay = Math.round(Math.random() * 125 * Math.pow(2, attempts));
setTimeout(dispatch, delay);
} else if (status === 0) {
promise.reject('Unable to connect to the Parse API');
} else {
// After the retry limit is reached, fail
const error = await response.json();
promise.reject(error);
}
} else {
promise.reject(response);
}
} catch (error) {
var _error$cause;
if (error.name === 'AbortError') {
promise.resolve({
response: {
results: []
},
status: 0
});
} else if (((_error$cause = error.cause) === null || _error$cause === void 0 ? void 0 : _error$cause.code) === 'ECONNREFUSED') {
promise.reject('Unable to connect to the Parse API');
} else {
promise.reject(error);
}
}
};
dispatch();
return promise;
},
request(method, path, data, options) {
options = options || {};
const url = getPath(_CoreManager.default.get('SERVER_URL'), path);
const payload = {};
if (data && typeof data === 'object') {
for (const k in data) {
payload[k] = data[k];
}
}
// Add context
const context = options.context;
if (context !== undefined) {
payload._context = context;
}
if (method !== 'POST') {
payload._method = method;
method = 'POST';
}
payload._ApplicationId = _CoreManager.default.get('APPLICATION_ID');
const jsKey = _CoreManager.default.get('JAVASCRIPT_KEY');
if (jsKey) {
payload._JavaScriptKey = jsKey;
}
payload._ClientVersion = _CoreManager.default.get('VERSION');
let useMasterKey = options.useMasterKey;
if (typeof useMasterKey === 'undefined') {
useMasterKey = _CoreManager.default.get('USE_MASTER_KEY');
}
if (useMasterKey) {
if (_CoreManager.default.get('MASTER_KEY')) {
delete payload._JavaScriptKey;
payload._MasterKey = _CoreManager.default.get('MASTER_KEY');
} else {
throw new Error('Cannot use the Master Key, it has not been provided.');
}
}
if (options.useMaintenanceKey) {
payload._MaintenanceKey = _CoreManager.default.get('MAINTENANCE_KEY');
}
if (_CoreManager.default.get('FORCE_REVOCABLE_SESSION')) {
payload._RevocableSession = '1';
}
const installationId = options.installationId;
let installationIdPromise;
if (installationId && typeof installationId === 'string') {
installationIdPromise = Promise.resolve(installationId);
} else {
const installationController = _CoreManager.default.getInstallationController();
installationIdPromise = installationController.currentInstallationId();
}
return installationIdPromise.then(iid => {
payload._InstallationId = iid;
const userController = _CoreManager.default.getUserController();
if (options && typeof options.sessionToken === 'string') {
return Promise.resolve(options.sessionToken);
} else if (userController) {
return userController.currentUserAsync().then(user => {
if (user) {
return Promise.resolve(user.getSessionToken());
}
return Promise.resolve(null);
});
}
return Promise.resolve(null);
}).then(token => {
if (token) {
payload._SessionToken = token;
}
const payloadString = JSON.stringify(payload);
return RESTController.ajax(method, url, payloadString, {}, options).then(async result => {
if (result.location) {
let newURL = getPath(result.location, path);
let newMethod = result.method;
let newBody = result.dropBody ? undefined : payloadString;
// Follow up to 5 redirects to avoid loops
for (let i = 0; i < 5; i += 1) {
const r = await RESTController.ajax(newMethod, newURL, newBody, {}, options);
if (!r.location) {
result = r;
break;
}
newURL = getPath(r.location, path);
newMethod = r.method;
newBody = r.dropBody ? undefined : payloadString;
}
}
const {
response,
status,
headers
} = result;
if (options.returnStatus) {
return {
...response,
_status: status,
_headers: headers
};
} else {
return response;
}
});
}).catch(RESTController.handleError);
},
handleError(errorJSON) {
// Transform the error into an instance of ParseError by trying to parse
// the error string as JSON
let error;
if (errorJSON.code || errorJSON.error || errorJSON.message) {
error = new _ParseError.default(errorJSON.code, errorJSON.error || errorJSON.message);
} else {
error = new _ParseError.default(_ParseError.default.CONNECTION_FAILED, 'XMLHttpRequest failed: ' + JSON.stringify(errorJSON));
}
return Promise.reject(error);
}
};
var _default = exports.default = RESTController;