@jovian/type-tools
Version:
TypeTools is a Typescript library for providing extensible tooling runtime validations and type helpers.
1,048 lines (1,047 loc) • 73.8 kB
JavaScript
"use strict";
var __extends = (this && this.__extends) || (function () {
var extendStatics = function (d, b) {
extendStatics = Object.setPrototypeOf ||
({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
return extendStatics(d, b);
};
return function (d, b) {
if (typeof b !== "function" && b !== null)
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
extendStatics(d, b);
function __() { this.constructor = d; }
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
};
})();
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
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) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
var __generator = (this && this.__generator) || function (thisArg, body) {
var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
function verb(n) { return function (v) { return step([n, v]); }; }
function step(op) {
if (f) throw new TypeError("Generator is already executing.");
while (g && (g = 0, op[0] && (_ = 0)), _) try {
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
if (y = 0, t) op = [op[0] & 2, t.value];
switch (op[0]) {
case 0: case 1: t = op; break;
case 4: _.label++; return { value: op[1], done: false };
case 5: _.label++; y = op[1]; op = [0]; continue;
case 7: op = _.ops.pop(); _.trys.pop(); continue;
default:
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
if (t[2]) _.ops.pop();
_.trys.pop(); continue;
}
op = body.call(thisArg, _);
} catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
}
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.pull = exports.push = exports.getFactory = exports.make = exports.dataclass = exports.semver = exports.Upstream = exports.UpstreamExtensionData = exports.UpstreamIndex = exports.txData = exports.TxData = exports.TxInstructionType = exports.UpstreamSync = exports.UpstreamSettings = exports.UpstreamCode = void 0;
var type_tools_1 = require("./type-tools");
var properties_controller_1 = require("./properties-controller");
var class_lineage_1 = require("./class-lineage");
var ephemerals_1 = require("./ephemerals");
var context_1 = require("./context");
var common_iface_1 = require("./upstream/common.iface");
var enum_util_1 = require("./common/util/enum.util");
var prom_util_1 = require("./common/util/prom.util");
var globals_ix_1 = require("./common/globals.ix");
var UpstreamCodeEnum;
(function (UpstreamCodeEnum) {
UpstreamCodeEnum[UpstreamCodeEnum["CREATE_ACK_FAIL"] = 0] = "CREATE_ACK_FAIL";
UpstreamCodeEnum[UpstreamCodeEnum["CREATE_INSERT_FLOW_FAILURE"] = 1] = "CREATE_INSERT_FLOW_FAILURE";
UpstreamCodeEnum[UpstreamCodeEnum["CREATE_INSERT_FLOW_UNSUPPORTED"] = 2] = "CREATE_INSERT_FLOW_UNSUPPORTED";
UpstreamCodeEnum[UpstreamCodeEnum["CREATE_ERROR"] = 3] = "CREATE_ERROR";
UpstreamCodeEnum[UpstreamCodeEnum["INSERT_FLOW_MEMBER_CREATE_ERROR"] = 4] = "INSERT_FLOW_MEMBER_CREATE_ERROR";
UpstreamCodeEnum[UpstreamCodeEnum["CREATE_OFFLINE_BACKLOG"] = 5] = "CREATE_OFFLINE_BACKLOG";
UpstreamCodeEnum[UpstreamCodeEnum["TARGET_HAS_NO_UPSTREAM"] = 6] = "TARGET_HAS_NO_UPSTREAM";
UpstreamCodeEnum[UpstreamCodeEnum["TARGET_TYPE_HAS_NO_UPSTREAM_DEF"] = 7] = "TARGET_TYPE_HAS_NO_UPSTREAM_DEF";
UpstreamCodeEnum[UpstreamCodeEnum["TARGET_UPSTREAM_ROUTER_UNRESOLVABLE"] = 8] = "TARGET_UPSTREAM_ROUTER_UNRESOLVABLE";
UpstreamCodeEnum[UpstreamCodeEnum["TARGET_UPSTREAM_ROUTE_UNRESOLVABLE"] = 9] = "TARGET_UPSTREAM_ROUTE_UNRESOLVABLE";
})(UpstreamCodeEnum || (UpstreamCodeEnum = {}));
exports.UpstreamCode = (0, enum_util_1.ReturnCodeFamily)('UpstreamCode', UpstreamCodeEnum);
var UpstreamSettings = (function (_super) {
__extends(UpstreamSettings, _super);
function UpstreamSettings(init) {
var _this = _super.call(this, init) || this;
_this.extensionUpstream = UpstreamSettings.extensionUpstream;
if (init) {
Object.assign(_this, init);
}
return _this;
}
UpstreamSettings.extensionUpstream = 'Upstream';
return UpstreamSettings;
}(properties_controller_1.PropertiesControllerSettings));
exports.UpstreamSettings = UpstreamSettings;
var UpstreamSync;
(function (UpstreamSync) {
UpstreamSync[UpstreamSync["IMMEDIATE"] = 0] = "IMMEDIATE";
UpstreamSync[UpstreamSync["NEXT_TICK"] = 1] = "NEXT_TICK";
UpstreamSync[UpstreamSync["QUICK"] = 100] = "QUICK";
UpstreamSync[UpstreamSync["DEFAULT"] = 500] = "DEFAULT";
UpstreamSync[UpstreamSync["LONG"] = 1000] = "LONG";
UpstreamSync[UpstreamSync["EXTRA_LONG"] = 2000] = "EXTRA_LONG";
UpstreamSync[UpstreamSync["CUSTOM"] = 9999] = "CUSTOM";
UpstreamSync[UpstreamSync["MANUAL"] = 99999] = "MANUAL";
})(UpstreamSync = exports.UpstreamSync || (exports.UpstreamSync = {}));
var TxInstructionType;
(function (TxInstructionType) {
TxInstructionType[TxInstructionType["NOOP"] = 0] = "NOOP";
TxInstructionType[TxInstructionType["INSERT"] = 1] = "INSERT";
TxInstructionType[TxInstructionType["FETCH"] = 2] = "FETCH";
TxInstructionType[TxInstructionType["UPDATE"] = 3] = "UPDATE";
TxInstructionType[TxInstructionType["DELETE"] = 4] = "DELETE";
})(TxInstructionType = exports.TxInstructionType || (exports.TxInstructionType = {}));
var TxData = (function () {
function TxData(init) {
this.id = makeid(20);
this.vars = {};
this.cursor = 0;
this.txlist = [];
this.t = Date.now();
if (init) {
Object.assign(this, init);
}
}
return TxData;
}());
exports.TxData = TxData;
exports.txData = {};
var UpstreamIndex = (function () {
function UpstreamIndex(type, options, columns) {
this.name = null;
this.type = null;
this.options = null;
this.columns = null;
this.type = type;
this.options = options;
this.columns = columns;
}
UpstreamIndex.prototype.get = function (target, errorCallback) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.lookUp(target, errorCallback)];
case 1: return [2, (_a.sent())[0]];
}
});
});
};
UpstreamIndex.prototype.find = function (target, errorCallback) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_a) {
switch (_a.label) {
case 0: return [4, this.lookUp(target, errorCallback)];
case 1: return [2, _a.sent()];
}
});
});
};
UpstreamIndex.prototype.indexInfo = function () {
return { name: this.name, options: this.options, columns: this.columns, };
};
UpstreamIndex.prototype.lookUp = function (targetLookUp, errorCallback) {
return __awaiter(this, void 0, void 0, function () {
var target, ext, connResult, conn, filter, _i, _a, column, colval, allPromises, found, totalResults, totalErrors, totalResultsFlat, hydrated;
var _b;
var _this = this;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
target = targetLookUp;
ext = Upstream.getExtensionData(targetLookUp);
if (!ext) {
target = new this.type;
Object.assign(target, targetLookUp);
}
return [4, Upstream.getTargetDatastore(target)];
case 1:
connResult = _c.sent();
if (connResult.bad) {
return [2, null];
}
conn = connResult.data;
filter = {};
for (_i = 0, _a = Object.keys(this.columns); _i < _a.length; _i++) {
column = _a[_i];
colval = targetLookUp[column];
if (colval === null || colval === undefined) {
continue;
}
filter[column] = colval;
}
allPromises = [];
found = conn.find(this.type, filter, null, this.name);
allPromises.push(found);
return [4, Promise.all(allPromises)];
case 2:
totalResults = _c.sent();
if (errorCallback) {
totalErrors = totalResults.filter(function (a) { return a && a.bad; });
if (totalErrors.length > 0) {
errorCallback(totalErrors);
}
}
totalResultsFlat = (_b = []).concat.apply(_b, totalResults
.filter(function (a) { return a && a.ok; })
.map(function (a) { return a.data; }));
hydrated = totalResultsFlat.map(function (a) { return Upstream.targetSolidify(_this.type, a); }).filter(function (a) { return a; });
return [2, hydrated];
}
});
});
};
return UpstreamIndex;
}());
exports.UpstreamIndex = UpstreamIndex;
var UpstreamExtensionData = (function () {
function UpstreamExtensionData() {
}
return UpstreamExtensionData;
}());
exports.UpstreamExtensionData = UpstreamExtensionData;
var currentIndexTargetType;
var indexGetter = function (options, columns) {
return new UpstreamIndex(currentIndexTargetType, options, columns);
};
var versionGetter = function (version, nscInfo, cls) {
cls.version = version;
if (nscInfo) {
return dataclass(nscInfo)(cls);
}
return cls;
};
var Upstream = (function () {
function Upstream(settings) {
this.settings = (0, type_tools_1.settingsInitialize)(UpstreamSettings, settings);
}
Upstream.getExtensionData = function (target, settings) {
if (settings === void 0) { settings = UpstreamSettings; }
return type_tools_1.TypeToolsBase.getExtension(target, settings.extensionUpstream, settings);
};
Upstream.typeCheck = function (target, settings) {
if (settings === void 0) { settings = UpstreamSettings; }
return target && !!Upstream.getExtensionData(target, settings);
};
Upstream.implementOn = function (target, settings) {
if (settings === void 0) { settings = UpstreamSettings; }
if (!type_tools_1.TypeToolsBase.checkContext(Upstream)) {
return false;
}
if (!Upstream.getExtensionData(target, settings)) {
ephemerals_1.Ephemerals.implementOn(target);
properties_controller_1.PropertiesController.implementOn(target, settings);
var extension = {
target: target,
class: null,
upstreamMeta: null,
props: {},
localId: (++Upstream.localIdCounter) + '',
version: 0,
versionLastSynced: 0,
push: { explicit: false, locked: false, fullPushPromise: null },
pull: { locked: false, fullPullPromise: null },
};
type_tools_1.TypeToolsBase.addExtension(target, settings.extensionUpstream, extension);
}
return true;
};
Upstream.setupOn = function (target, type, config, settings) {
if (settings === void 0) { settings = UpstreamSettings; }
if (!Upstream.implementOn(target, settings)) {
return;
}
if (type !== context_1.Context.current) {
return;
}
var extension = Upstream.getExtensionData(target, settings);
if (!target._meta) {
type_tools_1.TypeToolsBase.addMetaProperty(target);
}
extension.class = type;
if (!config) {
config = type.upstream;
if (!config) {
config = type.upstream = { index: {} };
}
}
var manageOptions = { alwaysBack: true, order: 9 };
var skel = type_tools_1.TypeToolsBase.getSkeleton(type);
var descriptorsRubric = {};
for (var _i = 0, _b = Object.keys(skel); _i < _b.length; _i++) {
var prop = _b[_i];
if (!extension.props[prop]) {
extension.props[prop] = {};
descriptorsRubric[prop] = { change: function (oldValue, newValue, e) {
Upstream.handlePropUpdate(target, extension, e.property, oldValue, newValue, e).catch(function (e) { });
} };
}
}
properties_controller_1.PropertiesController.manage(target, manageOptions, descriptorsRubric, settings);
};
Upstream.constructMultiverse = function (multiverseMap) {
return multiverseMap;
};
Upstream.class = function (type) {
return type;
};
Upstream.index = function (type, indexDef) {
var _this = this;
var typeAny = type;
if (!type.upstream) {
throw new Error('Cannot define index on class without upstream namespace. Did you forget to add @ns?');
}
var indexMap;
if (indexDef.apply && indexDef.call) {
currentIndexTargetType = type;
indexMap = indexDef(indexGetter);
currentIndexTargetType = null;
}
else {
indexMap = indexDef;
}
if (!typeAny.index) {
typeAny.index = {};
}
if (!typeAny.upstream.index) {
typeAny.index = {};
}
if (!typeAny.upstream.indexColumns) {
typeAny.index = {};
}
Object.assign(typeAny.index, indexMap);
Object.assign(typeAny.upstream.index, indexMap);
var upstreamDefaultIndex = {
parent: new UpstreamIndex(type, {}, { _parent: true }),
};
typeAny.manager = {
dropCollection: function () { return __awaiter(_this, void 0, void 0, function () {
var target, dsResult, dropResult;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
target = type_tools_1.TypeToolsBase.getSampleInstance(type);
return [4, Upstream.getTargetDatastore(target)];
case 1:
dsResult = _b.sent();
if (dsResult.bad) {
return [2, false];
}
return [4, dsResult.data.admin.dropCollection(type)];
case 2:
dropResult = _b.sent();
if (dropResult.bad) {
return [2, false];
}
return [2, dropResult.data];
}
});
}); },
recreateIndexes: function () { return __awaiter(_this, void 0, void 0, function () {
var target, dsResult;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
target = type_tools_1.TypeToolsBase.getSampleInstance(type);
return [4, Upstream.getTargetDatastore(target)];
case 1:
dsResult = _b.sent();
if (dsResult.bad) {
return [2, false];
}
return [4, Upstream.initializeIndexFor(type, dsResult.data, true)];
case 2:
_b.sent();
return [2];
}
});
}); },
};
Object.assign(typeAny.index, upstreamDefaultIndex);
Object.assign(typeAny.upstream.index, upstreamDefaultIndex);
var indexConfig = typeAny.index;
for (var _i = 0, _b = Object.keys(indexConfig); _i < _b.length; _i++) {
var indexName = _b[_i];
var index = indexConfig[indexName];
if (index instanceof UpstreamIndex) {
index.name = indexName;
Object.assign(typeAny.upstream.indexColumns, index.indexInfo().columns);
}
}
return indexConfig;
};
Upstream.admin = function (type) {
var typeAny = type;
return typeAny.manager;
};
Upstream.versions = function (type, versionsDef) {
var typeAny = type;
if (!typeAny.upstream) {
throw new Error('Cannot define index on class without upstream namespace. Did you forget to add @ns?');
}
var map = versionsDef(versionGetter);
typeAny.v = map;
return map;
};
Upstream.add = function (datastore, route) {
var _this = this;
if (route === void 0) { route = common_iface_1.defaultUpstreamRoute; }
if (!route) {
route = common_iface_1.defaultUpstreamRoute;
}
if (!datastore.config.path) {
datastore.config.path = common_iface_1.defaultUpstreamPath;
}
var dsRoute = Upstream.datastore[datastore.config.path];
if (!dsRoute) {
dsRoute = Upstream.datastore[datastore.config.path] = { getRoute: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_b) {
return [2, common_iface_1.defaultUpstreamRoute];
}); }); }, routes: {} };
}
dsRoute.routes[route] = datastore;
return datastore;
};
Upstream.remove = function (path, route) {
var _this = this;
if (route === void 0) { route = common_iface_1.defaultUpstreamRoute; }
if (!route) {
route = common_iface_1.defaultUpstreamRoute;
}
var dsRoute = Upstream.datastore[path];
if (!dsRoute) {
dsRoute = Upstream.datastore[path] = { getRoute: function () { return __awaiter(_this, void 0, void 0, function () { return __generator(this, function (_b) {
return [2, common_iface_1.defaultUpstreamRoute];
}); }); }, routes: {} };
}
if (dsRoute.routes[route]) {
delete dsRoute.routes[route];
}
};
Upstream.stringify = function (target, indent) {
if (indent === void 0) { indent = null; }
var metaSerialSaved = context_1.Context.serializeMeta;
context_1.Context.serializeMeta = true;
var serialized = JSON.stringify(target, null, indent);
context_1.Context.serializeMeta = metaSerialSaved;
return serialized;
};
Upstream.startQueue = function () {
if (Upstream.sharedQueue.started) {
return;
}
Upstream.sharedQueue.started = true;
Upstream.sharedQueue.queue.length = Upstream.sharedQueue.length;
for (var i = 0; i < Upstream.sharedQueue.queue.length; ++i) {
Upstream.sharedQueue.queue[i] = [];
}
Upstream.sharedQueue.last = Date.now();
Upstream.sharedQueueChecker = setInterval(Upstream.tickQueue, Upstream.sharedQueueCheckerInterval);
};
Upstream.asyncWorkload = function (ms, workload) {
Upstream.startQueue();
if (ms > Upstream.sharedQueue.length) {
throw new Error("ms=".concat(ms, "; Cannot add workload past queue maximum ms limit of ").concat(Upstream.sharedQueue.length));
}
var index = ms + Upstream.sharedQueue.deltaOffset + Upstream.sharedQueue.cursor + 33;
while (index >= Upstream.sharedQueue.length) {
index -= Upstream.sharedQueue.length;
}
var msSpot = Upstream.sharedQueue.queue[index];
if (!msSpot) {
msSpot = Upstream.sharedQueue.queue[index] = [];
}
msSpot.push(workload);
};
Upstream.tickQueue = function (forceFlush) {
var _this = this;
if (forceFlush === void 0) { forceFlush = false; }
var now = Date.now();
var delta = now - Upstream.sharedQueue.last;
if (delta > Upstream.sharedQueue.length) {
delta = Upstream.sharedQueue.length;
}
if (forceFlush) {
delta = Upstream.sharedQueue.length;
}
var cursorAt = Upstream.sharedQueue.cursor;
var queueLen = Upstream.sharedQueue.length;
Upstream.sharedQueue.beingHandled = true;
var proms = [];
for (var i = 0; i < delta; ++i) {
var index = cursorAt + i;
while (index >= queueLen) {
index -= queueLen;
}
Upstream.sharedQueue.deltaOffset = i;
var list = Upstream.sharedQueue.queue[index];
var _loop_1 = function (a) {
switch (a[0]) {
case 'push':
{
var target_1 = a[1];
var ext_1 = Upstream.getExtensionData(target_1);
if (!ext_1) {
return "continue";
}
var versionAtModification = a[2];
if (!target_1._gid || ext_1.version === versionAtModification) {
proms.push((0, prom_util_1.promise)(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
var e_1;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
_b.trys.push([0, 2, , 3]);
return [4, Upstream.pushImmediate(target_1, ext_1)];
case 1:
_b.sent();
return [3, 3];
case 2:
e_1 = _b.sent();
return [3, 3];
case 3:
resolve();
return [2];
}
});
}); }));
}
}
break;
case 'pull':
{
var target = a[1];
var ext = Upstream.getExtensionData(target);
if (!ext) {
return "continue";
}
proms.push(Upstream.pullImmediate(target, ext));
}
break;
case 'premake':
{
var type_1 = a[1];
Upstream.typesPremakePending[type_1.fullname] = false;
proms.push(new Promise(function (resolve) { return resolve(Upstream.premake(type_1, null, 1)); }));
}
break;
case 'callback':
{
var callback_1 = a[1];
proms.push(new Promise(function (resolve) { return resolve(callback_1()); }));
}
break;
}
};
for (var _i = 0, list_1 = list; _i < list_1.length; _i++) {
var a = list_1[_i];
_loop_1(a);
}
if (list.length > 0) {
Upstream.sharedQueue.queue[index] = [];
}
}
Upstream.sharedQueue.cursor += delta;
while (Upstream.sharedQueue.cursor >= queueLen) {
Upstream.sharedQueue.cursor -= queueLen;
}
Upstream.sharedQueue.last = now;
Upstream.sharedQueue.deltaOffset = 0;
Upstream.sharedQueue.beingHandled = false;
return proms;
};
Upstream.premakeQueue = function (type, ms) {
if (ms === void 0) { ms = 10; }
var typeAny = type;
var premakeConf = typeAny.premake;
if (!premakeConf || Upstream.typesPremakePending[typeAny.fullname]) {
return;
}
Upstream.typesPremakePending[typeAny.fullname] = true;
Upstream.asyncWorkload(ms, ['premake', type]);
};
Upstream.premake = function (type, count, limitGenerationMs) {
if (limitGenerationMs === void 0) { limitGenerationMs = 0; }
var typeAny = type;
var premakeConf = typeAny.premake;
var targetSize = count ? count : premakeConf.size;
if (premakeConf.list.length >= targetSize) {
return 0;
}
var makeCount = targetSize - premakeConf.list.length;
var start = Date.now();
var totalAdded = 0;
for (var i = 0; i < makeCount; ++i) {
if (limitGenerationMs && Date.now() - start >= limitGenerationMs) {
break;
}
premakeConf.list.push(new type());
++totalAdded;
}
var allAdded = (makeCount - totalAdded === 0);
if (!allAdded && limitGenerationMs === 1) {
Upstream.premakeQueue(type);
}
return makeCount - totalAdded;
};
Upstream.premakeSetSize = function (type, size) {
if (size === void 0) { size = 100; }
var typeAny = type;
if (!typeAny.premake) {
typeAny.premake = { list: [], size: size };
return;
}
var premakeConf = typeAny.premake;
premakeConf.size = size;
Upstream.premakeQueue(type);
};
Upstream.flush = function () {
return __awaiter(this, void 0, void 0, function () {
var proms;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
proms = Upstream.tickQueue(true);
if (!proms.length) return [3, 2];
return [4, prom_util_1.PromUtil.allSettled(proms)];
case 1:
_b.sent();
_b.label = 2;
case 2: return [2];
}
});
});
};
Upstream.connect = function (target, extension) {
if (!extension) {
extension = Upstream.getExtensionData(target);
}
extension.connected = true;
};
Upstream.disconnect = function (target, extension) {
if (!extension) {
extension = Upstream.getExtensionData(target);
}
extension.connected = false;
};
Upstream.pause = function (target, extension) {
if (!extension) {
extension = Upstream.getExtensionData(target);
}
extension.paused = true;
};
Upstream.resume = function (target, extension) {
if (!extension) {
extension = Upstream.getExtensionData(target);
}
extension.paused = false;
if (extension.touched) {
Upstream.pushBaseOnSyncType(target, extension);
}
};
Upstream.push = function (target) {
var _this = this;
return (0, prom_util_1.promise)(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
var extension;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
extension = Upstream.getExtensionData(target);
extension.push.explicit = true;
return [4, Upstream.pushImmediate(target, extension)];
case 1:
_b.sent();
resolve();
return [2];
}
});
}); });
};
Upstream.pushImmediate = function (target, extension, cb) {
var _this = this;
return (0, prom_util_1.promise)(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
var wrappedCb, finalRes, insertFlowJson, updaterVersion_1, updater_1, _i, _b, propName, propDef;
var _this = this;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
wrappedCb = function (r) {
if (cb) {
cb(r === null || r === void 0 ? void 0 : r.ok);
}
if (r === null || r === void 0 ? void 0 : r.ok) {
return resolve();
}
else {
return reject((r === null || r === void 0 ? void 0 : r.error) ? r.error : new Error(r === null || r === void 0 ? void 0 : r.message));
}
};
if (!extension) {
extension = Upstream.getExtensionData(target);
}
if (!context_1.Context.online) {
Upstream.backlog.push(['push', target, extension.version, wrappedCb]);
return [2, exports.UpstreamCode.error('CREATE_OFFLINE_BACKLOG')];
}
if (!extension.push.fullPushPromise) return [3, 2];
return [4, extension.push.fullPushPromise];
case 1:
finalRes = _c.sent();
_c.label = 2;
case 2:
if (!!target._gid) return [3, 4];
insertFlowJson = Upstream.getInsertFlowJson(target, extension);
extension.push.fullPushPromise = Upstream.handleInsertList(insertFlowJson);
return [4, extension.push.fullPushPromise];
case 3:
finalRes = _c.sent();
extension.push.fullPushPromise = null;
if (extension.syncCallback) {
extension.syncCallback(finalRes);
}
return [3, 6];
case 4:
updaterVersion_1 = extension.version;
updater_1 = { set: {} };
for (_i = 0, _b = Object.keys(extension.props); _i < _b.length; _i++) {
propName = _b[_i];
propDef = extension.props[propName];
if (!propDef || !propDef.rootVersionWhenModified) {
continue;
}
if (extension.versionLastSynced < propDef.rootVersionWhenModified) {
updater_1.set[propName] = propDef.newValue;
}
}
extension.push.fullPushPromise = (0, prom_util_1.promise)(function (resolve2) { return __awaiter(_this, void 0, void 0, function () {
var connResult, conn, res, _i, _b, propName, propDef, contextDisabeldBefore;
return __generator(this, function (_c) {
switch (_c.label) {
case 0: return [4, Upstream.getTargetDatastore(target)];
case 1:
connResult = _c.sent();
if (connResult.bad) {
return [2, resolve2((0, enum_util_1.passthru)(connResult))];
}
conn = connResult.data;
return [4, conn.update(extension.class, target._gid, updater_1)];
case 2:
res = _c.sent();
if (res.bad || res.data === false) {
for (_i = 0, _b = Object.keys(extension.props); _i < _b.length; _i++) {
propName = _b[_i];
propDef = extension.props[propName];
if (!propDef) {
continue;
}
if (propDef.lastAcknowledgedValue !== null) {
contextDisabeldBefore = context_1.Context.disabled;
context_1.Context.disabled = true;
target[propName] = propDef.lastAcknowledgedValue;
context_1.Context.disabled = contextDisabeldBefore;
}
}
return [2, resolve2((0, enum_util_1.passthru)(res))];
}
if (updaterVersion_1 > extension.versionLastSynced) {
extension.versionLastSynced = updaterVersion_1;
}
return [2, resolve2((0, enum_util_1.ok)(true))];
}
});
}); });
return [4, extension.push.fullPushPromise];
case 5:
finalRes = _c.sent();
_c.label = 6;
case 6:
wrappedCb(finalRes);
return [2, finalRes];
}
});
}); });
};
Upstream.pushBaseOnSyncType = function (target, extension, cb) {
return __awaiter(this, void 0, void 0, function () {
var _this = this;
return __generator(this, function (_b) {
return [2, (0, prom_util_1.promise)(function (resolve, reject) { return __awaiter(_this, void 0, void 0, function () {
var syncType, pushResolve, delta;
var _this = this;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if (!extension) {
extension = Upstream.getExtensionData(target);
}
syncType = isDefined(extension.syncType) ? extension.syncType : Upstream.defaultSync;
if (!(syncType === UpstreamSync.IMMEDIATE)) return [3, 2];
return [4, Upstream.pushImmediate(target, extension, cb)];
case 1: return [2, _b.sent()];
case 2:
if (syncType === UpstreamSync.MANUAL) {
return [2, resolve()];
}
else {
if (!Upstream.queueStarted) {
Upstream.startQueue();
}
pushResolve = function () { return __awaiter(_this, void 0, void 0, function () {
var _b, e_2;
return __generator(this, function (_c) {
switch (_c.label) {
case 0:
_c.trys.push([0, 2, , 3]);
_b = resolve;
return [4, Upstream.push(target)];
case 1:
_b.apply(void 0, [_c.sent()]);
return [3, 3];
case 2:
e_2 = _c.sent();
reject(e_2);
return [3, 3];
case 3: return [2];
}
});
}); };
if (syncType > Upstream.sharedQueue.length) {
setTimeout(pushResolve, syncType);
}
else {
delta = syncType + (Date.now() - Upstream.sharedQueue.last);
if (delta > Upstream.sharedQueue.length) {
setTimeout(pushResolve, syncType);
}
else {
Upstream.asyncWorkload(delta, ['push', target, extension.version, cb]);
}
}
}
return [2];
}
});
}); })];
});
});
};
Upstream.pullGid = function (type, _gid) {
return __awaiter(this, void 0, void 0, function () {
var reg, target;
var _this = this;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
reg = Upstream.objectRegistry[_gid];
if (!!reg) return [3, 2];
reg = Upstream.objectRegistry[_gid] = { pending: null, obj: null };
reg.pending = new Promise(function (resolve) { return __awaiter(_this, void 0, void 0, function () {
var connResult, conn, res, target;
return __generator(this, function (_b) {
switch (_b.label) {
case 0: return [4, Upstream.getTargetDatastore({ _gid: _gid })];
case 1:
connResult = _b.sent();
if (connResult.bad) {
return [2, (0, enum_util_1.passthru)(connResult)];
}
conn = connResult.data;
return [4, conn.read(type, _gid)];
case 2:
res = _b.sent();
if (res.bad) {
reg.pending = null;
return [2, resolve(null)];
}
target = Upstream.targetSolidify(type, res.data, _gid);
resolve(target);
return [2];
}
});
}); });
return [4, reg.pending];
case 1: return [2, _b.sent()];
case 2:
if (!reg.pending) return [3, 4];
return [4, reg.pending];
case 3:
_b.sent();
_b.label = 4;
case 4:
target = reg.obj;
if (target) {
return [2, Upstream.pull(target)];
}
return [2, null];
}
});
});
};
Upstream.targetSolidify = function (type, data, _gid) {
if (!_gid) {
_gid = data._gid;
}
if (!_gid) {
return null;
}
var reg = Upstream.objectRegistry[_gid];
if (reg && !reg.pending && reg.obj) {
return reg.obj;
}
if (!reg) {
reg = Upstream.objectRegistry[_gid] = { pending: null, obj: null };
}
if (!reg.obj) {
reg.obj = new type();
}
Upstream.targetImportData(reg.obj, data);
var ext = Upstream.getExtensionData(reg.obj);
if (isNaN(ext.version)) {
ext.version = 0;
}
ext.versionLastSynced = ext.version;
ext.push.explicit = true;
if (!reg.obj._gid) {
Object.defineProperty(reg.obj, '_gid', { value: _gid });
}
return reg.obj;
};
Upstream.pull = function (target, extension) {
return __awaiter(this, void 0, void 0, function () {
return __generator(this, function (_b) {
if (!extension) {
extension = Upstream.getExtensionData(target);
}
return [2, new Promise(function (resolve) {
Upstream.pullImmediate(target, extension, function (_) { resolve(target); });
})];
});
});
};
Upstream.getMetadata = function (target) {
return target.__upstream_meta_fields;
};
Upstream.targetImportData = function (target, newData) {
if (!target.__upstream_meta_fields) {
Object.defineProperty(target, '__upstream_meta_fields', { value: {} });
}
var metaProps = target.__upstream_meta_fields;
for (var _i = 0, _b = Object.keys(newData); _i < _b.length; _i++) {
var prop = _b[_i];
if (prop.charAt(0) === '_') {
metaProps[prop] = newData[prop];
continue;
}
try {
target[prop] = newData[prop];
}
catch (e) { }
}
if (!target._gid && newData._gid) {
Object.defineProperty(target, '_gid', { value: newData._gid });
}
};
Upstream.pullImmediate = function (target, extension, cb) {
return __awaiter(this, void 0, void 0, function () {
var clsName, connResult, conn, res;
return __generator(this, function (_b) {
switch (_b.label) {
case 0:
if (!extension) {
extension = Upstream.getExtensionData(target);
}
clsName = extension.class.name;
if (context_1.Context.onlineUpstream[clsName] && !context_1.Context.onlineUpstream[clsName].online) {
Upstream.backlog.push(['pull', target, cb]);
return [2];
}
if (!context_1.Context.online) {
Upstream.backlog.push(['pull', target, cb]);
return [2];
}
return [4, Upstream.getTargetDatastore(target)];
case 1:
connResult = _b.sent();
if (connResult.bad) {
if (cb) {
cb(target);
}
return [2, (0, enum_util_1.passthru)(connResult)];
}
conn = connResult.data;
return [4, conn.read(extension.class, target._gid)];
case 2:
res = _b.sent();
if (res.ok) {
Upstream.targetImportData(target, res.data);
}
if (cb) {
cb(target);
}
return [2];
}
});
});
};
Upstream.getTargetDatastore = function (target) {
var _b;
return __awaiter(this, void 0, void 0, function () {
var extension, type, upstreamDef, path, router, pathResolver, resolvePromise, pathResult, route, conn, result, indexDefinitions, _i, _c, indexName;
return __generator(this, function (_d) {
switch (_d.label) {
case 0:
extension = Upstream.getExtensionData(target);
if (!extension) {
return [2, exports.UpstreamCode.error('TARGET_HAS_NO_UPSTREAM')];
}
type = extension.class;
upstreamDef = type.upstream;
if (!type || !upstreamDef) {
return [2, exports.UpstreamCode.error('TARGET_TYPE_HAS_NO_UPSTREAM_DEF', type.name)];
}
path = target._gid ? (0, common_iface_1.parseGlobalId)(target._gid).path : '';
if (!!path) return [3, 5];
pathResolver = (_b = upstreamDef.universe) === null || _b === void 0 ? void 0 : _b[Upstream.currentUniverse];
if (!!pathResolver) return [3, 1];
path = common_iface_1.defaultUpstreamPath;
return [3, 5];
case 1:
if (!(typeof pathResolver === 'string')) return [3, 2];
path = pathResolver;
return [3, 5];
case 2:
resolvePromise = pathResolver(target);
if (!(typeof resolvePromise === 'string')) return [3, 3];
path = resolvePromise;
return [3, 5];
case 3: return [4, Promise.resolve(resolvePromise)];
case 4:
pathResult = _d.sent();
if (typeof pathResult === 'string') {
path = pathResult;
}
else {
if (pathResult.bad) {
}
path = pathResult.data;
}
_d.label = 5;
case 5:
router = Upstream.datastore[path];
if (!router) {
return [2, exports.UpstreamCode.error('TARGET_UPSTREAM_ROUTER_UNRESOLVABLE', "upstream for path '".concat(path, "' not found. Did you forget to Upstream.add your datastore?"))];