realm-object-server
Version:
306 lines • 10.3 kB
JavaScript
;
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
Object.defineProperty(exports, "__esModule", { value: true });
const virtPath_1 = require("./virtPath");
const errors = require("../errors");
const URI = require("urijs");
const RealmProblem_1 = require("../errors/RealmProblem");
const RealmType_1 = require("../realms/RealmType");
function Promisify(callback, ...args) {
return new Promise((resolve, reject) => {
callback(...args, (err, result) => {
if (err) {
reject(err);
}
else {
resolve(result);
}
});
});
}
exports.Promisify = Promisify;
class TimeoutError extends Error {
constructor(ms) {
super(`Operation failed to complete within ${ms}ms`);
this.ms = ms;
}
}
exports.TimeoutError = TimeoutError;
function timeout(promise, ms) {
const timeoutPromise = new Promise((resolve, reject) => {
const id = setTimeout(() => {
clearTimeout(id);
reject(new TimeoutError(ms));
}, ms);
});
return Promise.race([promise, timeoutPromise]);
}
exports.timeout = timeout;
function delay(ms) {
return new Promise((resolve) => setTimeout(resolve, ms));
}
exports.delay = delay;
function validateRealmPath(path, userId) {
if (!path) {
throw new errors.realm.MissingParameters("path");
}
let decodedPath = URI.decode(path);
if (decodedPath.includes("~")) {
if (userId) {
decodedPath = decodedPath.replace("~", userId);
}
else {
throw new errors.realm.InvalidParameters({
name: "path",
reason: "path cannot contain a ~. Please use a full absolute path when trying to find the realmFile."
});
}
}
if (!decodedPath.startsWith("/")) {
decodedPath = "/" + decodedPath;
}
const { error } = virtPath_1.mapVirtToRealmPath("/", decodedPath);
if (error) {
throw new errors.realm.InvalidParameters({
name: "path",
reason: `The path '${path}' (decoded: '${decodedPath}') is invalid: ${error}`,
});
}
return decodedPath;
}
exports.validateRealmPath = validateRealmPath;
function getUserIdFromRealmPath(path) {
if (path === "" || path[0] !== "/") {
return undefined;
}
const segments = new URI(path).segment();
const partialIndex = segments.indexOf("__partial");
if (partialIndex !== -1) {
return segments[partialIndex + 1];
}
else {
return segments[0];
}
}
exports.getUserIdFromRealmPath = getUserIdFromRealmPath;
function writeAsync(realm, callback) {
return __awaiter(this, void 0, void 0, function* () {
yield downloadAllServerChanges(realm);
realm.write(callback);
yield uploadAllLocalChanges(realm);
});
}
exports.writeAsync = writeAsync;
function downloadAllServerChanges(realm) {
return __awaiter(this, void 0, void 0, function* () {
if (process.env.DISABLE_SYNCHRONOUS_REQUESTS !== "true" &&
realm.syncSession) {
yield realm.syncSession.downloadAllServerChanges();
}
});
}
exports.downloadAllServerChanges = downloadAllServerChanges;
function uploadAllLocalChanges(realm) {
return __awaiter(this, void 0, void 0, function* () {
if (process.env.DISABLE_SYNCHRONOUS_REQUESTS !== "true" &&
realm.syncSession) {
yield realm.syncSession.uploadAllLocalChanges();
}
});
}
exports.uploadAllLocalChanges = uploadAllLocalChanges;
function closeAfterUpload(realm) {
uploadAllLocalChanges(realm).then(() => realm.close()).catch();
}
exports.closeAfterUpload = closeAfterUpload;
function convertHttpError(error) {
if (error.response && error.response.body) {
const body = error.response.body;
if (body.hasOwnProperty("code") && body.hasOwnProperty("status")) {
if (body.hasOwnProperty("invalid_params")) {
const params = body.invalid_params;
if (body.code === 602) {
return new RealmProblem_1.MissingParameters(...params.map(p => p.name));
}
return new RealmProblem_1.InvalidParameters(...params);
}
return new RealmProblem_1.GenericRealmProblem(body.code, body);
}
}
return error;
}
exports.convertHttpError = convertHttpError;
function waitAsync(getter, verifier, timeout = 5000, throwOnTimeout = true) {
return __awaiter(this, void 0, void 0, function* () {
const msDelay = 50;
if (!verifier) {
verifier = (res) => !!res;
}
let result;
for (let i = 0; i < timeout / msDelay; i++) {
result = yield Promise.resolve(getter());
if (verifier(result)) {
return result;
}
else {
yield delay(msDelay);
}
}
if (throwOnTimeout) {
throw new TimeoutError(timeout);
}
return undefined;
});
}
exports.waitAsync = waitAsync;
function retryRequest(retries = 1, delay = 100, shouldRetry = _ => true) {
return function (request) {
request["callback"] = function callback(error, response) {
if ((error || (!this._isResponseOK(response) && shouldRetry(response))) && retries-- > 0) {
return setTimeout(() => this._retry(), delay);
}
this.__proto__.callback.call(this, error, response);
};
};
}
exports.retryRequest = retryRequest;
const partial = "/__partial/";
function isPartialPath(path) {
return path.indexOf(partial) > -1;
}
exports.isPartialPath = isPartialPath;
function extractPartialInfo(path) {
const partialIndex = path.indexOf(partial);
const isPartial = partialIndex > -1;
return {
partialIndex,
isPartial,
canonicalPath: isPartial ? path.substring(0, partialIndex) : path,
customIdentifier: isPartial ? path.substring(partialIndex + partial.length) : undefined,
fullPath: path,
};
}
exports.extractPartialInfo = extractPartialInfo;
function getValueIfResolved(promise) {
return __awaiter(this, void 0, void 0, function* () {
let result;
promise.then((value) => result = value);
yield delay(1);
return result;
});
}
exports.getValueIfResolved = getValueIfResolved;
function enumerateObject(obj) {
return Object.keys(obj).map(key => obj[key]);
}
exports.enumerateObject = enumerateObject;
function enumValues(enumObject) {
return Reflect.ownKeys(enumObject).filter(isNaN);
}
exports.enumValues = enumValues;
function mapEnum(enumObject, func) {
return enumValues(enumObject).reduce((acc, cur) => {
acc[cur] = func(cur);
return acc;
}, {});
}
exports.mapEnum = mapEnum;
function createPromise() {
let resolve;
let reject;
const promise = new Promise((res, rej) => {
resolve = res;
reject = rej;
});
return { promise, resolve, reject };
}
exports.createPromise = createPromise;
function waitForEvent(emitter, eventName) {
const { promise, resolve } = createPromise();
emitter.on(eventName, (args) => resolve(args));
return promise;
}
exports.waitForEvent = waitForEvent;
function gaussianRandom(array) {
const mean = 1.0 * array.reduce((a, b) => a + b) / array.length;
const deviation = array.length < 2 ? 0 : Math.sqrt(array.reduce((previous, current) => previous + Math.pow(current - mean, 2)) / (array.length - 1));
return gaussianRandomImpl(mean, deviation);
}
exports.gaussianRandom = gaussianRandom;
function startStopwatch() {
return process.hrtime();
}
exports.startStopwatch = startStopwatch;
function readStopwatch(stopwatch) {
const now = process.hrtime(stopwatch);
return Math.round((now[0] * 1000) + (now[1] / 1000000));
}
exports.readStopwatch = readStopwatch;
function measureTime(toMeasure) {
return __awaiter(this, void 0, void 0, function* () {
const stopwatch = startStopwatch();
const result = yield toMeasure();
return { result, time: readStopwatch(stopwatch) };
});
}
exports.measureTime = measureTime;
function ensureRealmOfType(requiredType, actualType) {
if (!(actualType in RealmType_1.RealmType)) {
actualType = RealmType_1.RealmType.full;
}
if (actualType !== requiredType) {
throw new errors.realm.InvalidRealmType(requiredType, actualType);
}
}
exports.ensureRealmOfType = ensureRealmOfType;
function getValueOrDefault(value, defaultValue) {
if (value !== undefined) {
return value;
}
return defaultValue;
}
exports.getValueOrDefault = getValueOrDefault;
let spareRandom;
function gaussianRandomImpl(mean, deviation) {
let normalRandom;
if (spareRandom !== undefined) {
normalRandom = spareRandom;
spareRandom = undefined;
}
else {
const u1 = 1.0 - Math.random();
const u2 = 1.0 - Math.random();
normalRandom = Math.sqrt(-2.0 * Math.log(u1)) * Math.sin(2 * Math.PI * u2);
spareRandom = Math.sqrt(-2.0 * Math.log(u1)) * Math.cos(2 * Math.PI * u2);
}
return mean + normalRandom * deviation;
}
function isArrayEmpty(arr) {
return !arr || arr.length === 0;
}
exports.isArrayEmpty = isArrayEmpty;
function getAccessLevel(permissions) {
if (permissions.mayManage) {
return "admin";
}
if (permissions.mayWrite) {
return "write";
}
if (permissions.mayRead) {
return "read";
}
return "none";
}
exports.getAccessLevel = getAccessLevel;
function nameof(name) {
return name;
}
exports.nameof = nameof;
//# sourceMappingURL=util.js.map