@jovian/type-tools
Version:
TypeTools is a Typescript library for providing extensible tooling runtime validations and type helpers.
329 lines • 12.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ReturnCodeFamily = exports.Unum = exports.EnumJoin = exports.passthruCurrent = exports.passthruError = exports.passthru = exports.passthruResult = exports.errorResult = exports.partialOk = exports.partialOkResult = exports.ok = exports.okResult = exports.Result = exports.GenericResult = exports.EnumType = void 0;
var base58_util_1 = require("./base58.util");
var env_util_1 = require("./env.util");
var sha512_util_1 = require("./sha512.util");
var stack_util_1 = require("./stack.util");
function getEnumData(e) {
if (!e.__enum_data) {
Object.defineProperty(e, '__enum_data', { value: {} });
}
if (!e.__error_history) {
Object.defineProperty(e, '__error_history', { value: {} });
}
return e.__enum_data;
}
function getEnumErrorHistory(e) {
if (!e.__enum_data) {
Object.defineProperty(e, '__enum_data', { value: {} });
}
if (!e.__error_history) {
Object.defineProperty(e, '__error_history', { value: {} });
}
return e.__error_history;
}
var EnumType = (function () {
function EnumType() {
var init = [];
for (var _i = 0; _i < arguments.length; _i++) {
init[_i] = arguments[_i];
}
this.SUCCESS = '';
this.SUCCESS = this.add('SUCCESS', 'generic success', null, EnumType.genericSuccessCode);
var keysMap = {};
var collisions = [];
for (var i = 0; i < init.length; ++i) {
var enumObj = init[i];
if (!enumObj) {
continue;
}
for (var _b = 0, _c = Object.keys(enumObj); _b < _c.length; _b++) {
var name_1 = _c[_b];
if (name_1 === 'SUCCESS') {
continue;
}
var firstChar = name_1.charCodeAt(0);
var isNumeric = (firstChar >= 48 && firstChar <= 57);
if (!isNumeric) {
if (keysMap[name_1]) {
collisions.push(name_1);
continue;
}
this[name_1] = this.add(name_1);
keysMap[name_1] = enumObj;
}
}
}
if (collisions.length > 0) {
throw new Error("enumJoin failed due to collisions: ".concat(collisions.join(', ')));
}
}
EnumType.prototype.add = function (name, message, codeNumeric, codeOverride) {
var code = codeOverride ? codeOverride : EnumType.prefix + (0, base58_util_1.base58Encode)((0, sha512_util_1.utilSha512)(name)).substring(0, 14);
var enumData = getEnumData(this);
var enumInfo = { name: name, code: code, message: message, codeNumeric: codeNumeric };
var prevReg = enumData[name] || enumData[code];
if (prevReg) {
var regInfo = codeNumeric >= 0 ? "".concat(name, ":").concat(codeNumeric) : name;
var numericInfo = codeNumeric >= 0 ? ", numeric=".concat(codeNumeric) : '';
throw new Error("Cannot add '".concat(regInfo, "' to this enum; already registered ") +
"with '".concat(prevReg.name, "' (code=").concat(prevReg.code).concat(numericInfo, ")"));
}
if (!enumData[name]) {
enumData[name] = enumInfo;
}
if (!enumData[code]) {
enumData[code] = enumInfo;
}
return code;
};
EnumType.prototype.addErrorHistory = function (e, code) {
var _b;
var name = this.getByCode(code).name;
var historyData = getEnumErrorHistory(this);
var source = (0, stack_util_1.spot)(e);
var errorCodeHistory = historyData[code];
if (!errorCodeHistory) {
errorCodeHistory = historyData[code] = { firstSource: source, first: null, last: null, history: [] };
}
if (this.uniqueMode && source !== errorCodeHistory.firstSource) {
throw new Error("Cannot use the same error enum code (".concat(name, ") again ") +
"in a different source location. " +
"(uniqueMode=1, firstSource=".concat(errorCodeHistory.firstSource, ", currentSource=").concat(source, ")"));
}
if (!errorCodeHistory.first) {
errorCodeHistory.first = e;
}
errorCodeHistory.last = e;
if (!((_b = this.__error_reuse) === null || _b === void 0 ? void 0 : _b.enabled)) {
errorCodeHistory.history.push(e);
}
};
EnumType.prototype.setErrorObjectReuse = function (v) {
if (!this.__error_reuse) {
Object.defineProperty(this, '__error_reuse', { value: { enabled: v } });
}
this.__error_reuse.enabled = v;
};
EnumType.prototype.getByName = function (name) {
var enumData = getEnumData(this);
return enumData[name];
};
EnumType.prototype.getByCode = function (code) {
var enumData = getEnumData(this);
return enumData[code];
};
EnumType.prototype.getMessage = function (code) {
var _b;
var enumData = getEnumData(this);
return (_b = enumData[code]) === null || _b === void 0 ? void 0 : _b.message;
};
EnumType.prototype.getErrorHistory = function (code) {
var historyData = getEnumErrorHistory(this);
return historyData[code];
};
EnumType.prototype.ok = function (data, misc) {
if (!misc.code) {
misc.code = EnumType.genericSuccessCode;
}
if (!misc.codeName) {
misc.codeName = this.getByCode(misc.code).name;
}
return okResult(data, misc);
};
EnumType.prototype.error = function (codeName, errorOverride, misc) {
var _b, _c;
var info = this.getByName(codeName);
var code = info.code;
var reusableError;
if ((_b = this.__error_reuse) === null || _b === void 0 ? void 0 : _b.enabled) {
reusableError = (_c = this.getErrorHistory(info.code)) === null || _c === void 0 ? void 0 : _c.first;
}
var error;
var message;
if (errorOverride instanceof Error) {
if (!errorOverride.message) {
errorOverride.message = '';
}
message = "[".concat(codeName, "::").concat(code, "] ").concat(errorOverride.message);
error = reusableError ? reusableError : new Error(errorOverride.message);
this.addErrorHistory(error, code);
error.stack = errorOverride.stack;
}
else {
if (errorOverride) {
message = typeof errorOverride === 'string' ? errorOverride : errorOverride();
}
else {
message = info.message;
}
if (!message) {
message = '';
}
message = "[".concat(codeName, "::").concat(code, "] ").concat(message);
error = reusableError ? reusableError : new Error(message);
this.addErrorHistory(error, code);
}
var baseObj = {};
if (this.codeFamily) {
baseObj.codeFamily = this.codeFamily;
}
Object.assign(baseObj, { codeName: codeName, code: code, message: message });
if (reusableError) {
reusableError.message = message;
}
Object.assign(baseObj, misc);
return errorResult(error, baseObj);
};
var _a;
_a = EnumType;
EnumType.prefix = 'X_';
EnumType.genericSuccessCode = 'X__SUCCESS_GENERIC';
EnumType.reuseErrorObject = true;
EnumType.protectedSettings = env_util_1.ClassSettings.protect(_a);
return EnumType;
}());
exports.EnumType = EnumType;
var GenericResult = (function () {
function GenericResult(init) {
if (init) {
Object.assign(this, init);
}
if (init.errorStack) {
this.errorObject = new Error(init.errorMessage);
this.errorObject.stack = init.errorStack;
}
}
Object.defineProperty(GenericResult.prototype, "ok", {
get: function () { return this.status === 'ok'; },
enumerable: false,
configurable: true
});
Object.defineProperty(GenericResult.prototype, "good", {
get: function () { return this.status === 'ok'; },
enumerable: false,
configurable: true
});
Object.defineProperty(GenericResult.prototype, "passed", {
get: function () { return this.status === 'ok'; },
enumerable: false,
configurable: true
});
Object.defineProperty(GenericResult.prototype, "bad", {
get: function () { return this.status !== 'ok'; },
enumerable: false,
configurable: true
});
Object.defineProperty(GenericResult.prototype, "failed", {
get: function () { return this.status !== 'ok'; },
enumerable: false,
configurable: true
});
Object.defineProperty(GenericResult.prototype, "error", {
get: function () {
if (this.status !== 'ok') {
return this.errorObject ? this.errorObject : true;
}
else {
return this.errorObject;
}
},
set: function (e) { this.errorObject = e; },
enumerable: false,
configurable: true
});
GenericResult.prototype.isResultKind = function () { return true; };
GenericResult.prototype.toJSON = function () {
return {
status: this.status ? this.status : 'error',
code: this.code,
codeName: this.codeName,
codeFamily: this.codeFamily,
statusCode: this.statusCode,
data: this.data,
meta: this.meta,
message: this.message,
errorMessage: this.errorObject ? this.errorObject.message : null,
errorStack: this.errorObject ? this.errorObject.message : null,
};
};
GenericResult.prototype.toString = function () { return JSON.stringify(this); };
GenericResult.lastError = null;
GenericResult.lastOk = null;
return GenericResult;
}());
exports.GenericResult = GenericResult;
exports.Result = GenericResult;
function okResult(data, misc) {
var init = { status: 'ok', data: data, code: EnumType.genericSuccessCode };
if (misc) {
Object.assign(init, misc);
}
var okres = new GenericResult(init);
GenericResult.lastError = null;
GenericResult.lastOk = okres;
return okres;
}
exports.okResult = okResult;
exports.ok = okResult;
function partialOkResult(data, misc) {
return okResult(data, misc);
}
exports.partialOkResult = partialOkResult;
exports.partialOk = partialOkResult;
function errorResult(error, misc) {
var init = { status: 'error', error: error };
if (misc) {
Object.assign(init, misc);
}
var eres = new GenericResult(init);
GenericResult.lastError = eres;
GenericResult.lastOk = null;
return eres;
}
exports.errorResult = errorResult;
function passthruResult(obj) {
if (!obj) {
return passthruCurrent();
}
return obj;
}
exports.passthruResult = passthruResult;
exports.passthru = passthruResult;
exports.passthruError = passthruResult;
function passthruCurrent() {
var obj;
if (GenericResult.lastError) {
obj = GenericResult.lastError;
}
else if (GenericResult.lastOk) {
obj = GenericResult.lastOk;
}
if (!obj) {
throw new Error("Cannot passthru result that is null");
}
return obj;
}
exports.passthruCurrent = passthruCurrent;
function EnumJoin(a, b, c, d, e, f, g, h, i, j) {
var enumObj = new EnumType(a, b, c, d, e, f, g, h, i, j);
if (EnumType.reuseErrorObject) {
enumObj.setErrorObjectReuse(true);
}
return enumObj;
}
exports.EnumJoin = EnumJoin;
function Unum(a, b, c, d, e, f, g, h, i, j) {
var enumObj = EnumJoin(a, b, c, d, e, f, g, h, j);
Object.defineProperty(enumObj, 'uniqueMode', { value: true, writable: true });
return enumObj;
}
exports.Unum = Unum;
function ReturnCodeFamily(codeFamilyName, a, b, c, d, e, f, g, h, i, j) {
var enumObj = EnumJoin(a, b, c, d, e, f, g, h, j);
Object.defineProperty(enumObj, 'codeFamily', { value: codeFamilyName, writable: true });
return enumObj;
}
exports.ReturnCodeFamily = ReturnCodeFamily;
//# sourceMappingURL=enum.util.js.map