@touca/node
Version:
Touca SDK for JavaScript
335 lines • 13.1 kB
JavaScript
// Copyright 2022 Touca, Inc. Subject to Apache-2.0 License.
var __values = (this && this.__values) || function(o) {
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
if (m) return m.call(o);
if (o && typeof o.length === "number") return {
next: function () {
if (o && i >= o.length) o = void 0;
return { value: o && o[i++], done: !o };
}
};
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
};
var __read = (this && this.__read) || function (o, n) {
var m = typeof Symbol === "function" && o[Symbol.iterator];
if (!m) return o;
var i = m.call(o), r, ar = [], e;
try {
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
}
catch (error) { e = { error: error }; }
finally {
try {
if (r && !r.done && (m = i["return"])) m.call(i);
}
finally { if (e) throw e.error; }
}
return ar;
};
import { readFileSync } from 'node:fs';
import { createHash } from 'crypto';
import * as schema from './schema.js';
var BlobType = /** @class */ (function () {
function BlobType(value) {
this.value = value;
}
BlobType.fromFile = function (reference) {
var content = readFileSync(reference);
var digest = createHash('sha256').update(content).digest('hex');
return new BlobType({ reference: reference, digest: digest });
};
BlobType.fromBytes = function (content) {
var digest = createHash('sha256').update(content).digest('hex');
return new BlobType({ content: content, digest: digest, mimetype: 'image/jpg' });
};
BlobType.prototype.binary = function () {
return 'content' in this.value
? this.value.content
: readFileSync(this.value.reference);
};
BlobType.prototype.json = function () {
return 'reference' in this.value ? this.value.reference : 'binary';
};
BlobType.prototype.serialize = function (builder) {
var fbs = {
digest: builder.createString(this.value.digest),
mimetype: 'reference' in this.value
? undefined
: builder.createString(this.value.mimetype),
reference: 'reference' in this.value
? builder.createString(this.value.reference)
: undefined
};
schema.Blob.startBlob(builder);
if (fbs.digest) {
schema.Blob.addDigest(builder, fbs.digest);
}
if (fbs.mimetype) {
schema.Blob.addMimetype(builder, fbs.mimetype);
}
if (fbs.reference) {
schema.Blob.addReference(builder, fbs.reference);
}
var value = schema.Blob.endBlob(builder);
schema.TypeWrapper.startTypeWrapper(builder);
schema.TypeWrapper.addValue(builder, value);
schema.TypeWrapper.addValueType(builder, schema.Type.Blob);
return schema.TypeWrapper.endTypeWrapper(builder);
};
return BlobType;
}());
export { BlobType };
var BoolType = /** @class */ (function () {
function BoolType(value) {
this.value = value;
}
BoolType.prototype.json = function () {
return this.value;
};
BoolType.prototype.serialize = function (builder) {
schema.Bool.startBool(builder);
schema.Bool.addValue(builder, this.value);
var value = schema.Bool.endBool(builder);
schema.TypeWrapper.startTypeWrapper(builder);
schema.TypeWrapper.addValue(builder, value);
schema.TypeWrapper.addValueType(builder, schema.Type.Bool);
return schema.TypeWrapper.endTypeWrapper(builder);
};
return BoolType;
}());
var DecimalType = /** @class */ (function () {
function DecimalType(value) {
this._value = value;
}
DecimalType.prototype.json = function () {
return this._value;
};
DecimalType.prototype.serialize = function (builder, options) {
var ruleOffset = this.serializeRule(builder, options === null || options === void 0 ? void 0 : options.rule);
schema.Double.startDouble(builder);
schema.Double.addValue(builder, this._value);
if (ruleOffset) {
schema.Double.addRule(builder, ruleOffset);
}
var value = schema.Double.endDouble(builder);
schema.TypeWrapper.startTypeWrapper(builder);
schema.TypeWrapper.addValue(builder, value);
schema.TypeWrapper.addValueType(builder, schema.Type.Double);
return schema.TypeWrapper.endTypeWrapper(builder);
};
DecimalType.prototype.serializeRule = function (builder, rule) {
if (!rule || rule.type !== 'number') {
return;
}
var mode = rule.mode === 'absolute'
? schema.ComparisonRuleMode.Absolute
: schema.ComparisonRuleMode.Relative;
schema.ComparisonRuleDouble.startComparisonRuleDouble(builder);
schema.ComparisonRuleDouble.addMode(builder, mode);
if (rule.max !== undefined) {
schema.ComparisonRuleDouble.addMax(builder, rule.max);
}
if (rule.mode === 'absolute' && rule.min !== undefined) {
schema.ComparisonRuleDouble.addMin(builder, rule.min);
}
if (rule.mode === 'relative' && rule.percent !== undefined) {
schema.ComparisonRuleDouble.addPercent(builder, rule.percent);
}
return schema.ComparisonRuleDouble.endComparisonRuleDouble(builder);
};
return DecimalType;
}());
export { DecimalType };
var IntegerType = /** @class */ (function () {
function IntegerType(value) {
this._value = value;
}
IntegerType.prototype.increment = function () {
this._value += 1;
};
IntegerType.prototype.json = function () {
return this._value;
};
IntegerType.prototype.serialize = function (builder) {
schema.Int.startInt(builder);
schema.Int.addValue(builder, BigInt(this._value));
var value = schema.Int.endInt(builder);
schema.TypeWrapper.startTypeWrapper(builder);
schema.TypeWrapper.addValue(builder, value);
schema.TypeWrapper.addValueType(builder, schema.Type.Int);
return schema.TypeWrapper.endTypeWrapper(builder);
};
return IntegerType;
}());
export { IntegerType };
var StringType = /** @class */ (function () {
function StringType(value) {
this.value = value;
}
StringType.prototype.json = function () {
return this.value;
};
StringType.prototype.serialize = function (builder) {
var content = builder.createString(this.value);
schema.T_String.startString(builder);
schema.T_String.addValue(builder, content);
var value = schema.T_String.endString(builder);
schema.TypeWrapper.startTypeWrapper(builder);
schema.TypeWrapper.addValue(builder, value);
schema.TypeWrapper.addValueType(builder, schema.Type.String);
return schema.TypeWrapper.endTypeWrapper(builder);
};
return StringType;
}());
var VectorType = /** @class */ (function () {
function VectorType() {
this._value = [];
}
VectorType.prototype.add = function (value) {
this._value.push(value);
};
VectorType.prototype.json = function () {
return this._value.map(function (v) { return v.json(); });
};
VectorType.prototype.serialize = function (builder) {
var items = this._value.map(function (v) { return v.serialize(builder); });
var values = schema.Array.createValuesVector(builder, items);
schema.Array.startArray(builder);
schema.Array.addValues(builder, values);
var value = schema.Array.endArray(builder);
schema.TypeWrapper.startTypeWrapper(builder);
schema.TypeWrapper.addValue(builder, value);
schema.TypeWrapper.addValueType(builder, schema.Type.Array);
return schema.TypeWrapper.endTypeWrapper(builder);
};
return VectorType;
}());
export { VectorType };
var ObjectType = /** @class */ (function () {
function ObjectType(name) {
this.name = name;
this._values = new Map();
}
ObjectType.prototype.add = function (key, value) {
this._values.set(key, value);
};
ObjectType.prototype.json = function () {
var e_1, _a;
var values = {};
try {
for (var _b = __values(this._values), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), k = _d[0], v = _d[1];
values[k] = v.json();
}
}
catch (e_1_1) { e_1 = { error: e_1_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_1) throw e_1.error; }
}
return values;
};
ObjectType.prototype.serialize = function (builder) {
var e_2, _a;
var fbs_name = builder.createString(this.name);
var members = [];
try {
for (var _b = __values(Array.from(this._values.entries()).reverse()), _c = _b.next(); !_c.done; _c = _b.next()) {
var _d = __read(_c.value, 2), k = _d[0], v = _d[1];
var member_key = builder.createString(k);
var member_value = v.serialize(builder);
schema.ObjectMember.startObjectMember(builder);
schema.ObjectMember.addName(builder, member_key);
schema.ObjectMember.addValue(builder, member_value);
members.push(schema.ObjectMember.endObjectMember(builder));
}
}
catch (e_2_1) { e_2 = { error: e_2_1 }; }
finally {
try {
if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
}
finally { if (e_2) throw e_2.error; }
}
var fbs_members = schema.T_Object.createValuesVector(builder, members);
schema.T_Object.startObject(builder);
schema.T_Object.addKey(builder, fbs_name);
schema.T_Object.addValues(builder, fbs_members);
var value = schema.T_Object.endObject(builder);
schema.TypeWrapper.startTypeWrapper(builder);
schema.TypeWrapper.addValue(builder, value);
schema.TypeWrapper.addValueType(builder, schema.Type.Object);
return schema.TypeWrapper.endTypeWrapper(builder);
};
return ObjectType;
}());
var TypeHandler = /** @class */ (function () {
function TypeHandler() {
this._primitives = {
boolean: function (x) { return new BoolType(x); },
number: function (x) {
return Number.isInteger(x) && !x.toString().includes('.')
? new IntegerType(x)
: new DecimalType(x);
},
string: function (x) { return new StringType(x); },
undefined: function (x) { return new StringType('undefined'); }
};
this._types = new Map([
['Date', function (x) { return ({ v: x.toISOString() }); }]
]);
}
TypeHandler.prototype.transform = function (value) {
var e_3, _a;
if (typeof value in this._primitives) {
return this._primitives[typeof value](value);
}
if (value === null) {
return new StringType('null');
}
if (Buffer.isBuffer(value)) {
return BlobType.fromBytes(value);
}
// eslint-disable-next-line @typescript-eslint/ban-types
var name = value.constructor.name;
if (this._types.has(name)) {
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
return this.transform(this._types.get(name)(value));
}
// eslint-disable-next-line @typescript-eslint/no-explicit-any
if (typeof value[Symbol.iterator] === 'function') {
var v_obj_2 = value;
var vec = new VectorType();
try {
for (var v_obj_1 = __values(v_obj_2), v_obj_1_1 = v_obj_1.next(); !v_obj_1_1.done; v_obj_1_1 = v_obj_1.next()) {
var v = v_obj_1_1.value;
vec.add(this.transform(v));
}
}
catch (e_3_1) { e_3 = { error: e_3_1 }; }
finally {
try {
if (v_obj_1_1 && !v_obj_1_1.done && (_a = v_obj_1.return)) _a.call(v_obj_1);
}
finally { if (e_3) throw e_3.error; }
}
return vec;
}
var v_obj = value;
var obj = new ObjectType(name);
for (var k in v_obj) {
obj.add(k, this.transform(v_obj[k]));
}
return obj;
};
TypeHandler.prototype.add_serializer = function (datatype,
// eslint-disable-next-line @typescript-eslint/no-explicit-any
serializer) {
this._types.set(datatype, serializer);
};
return TypeHandler;
}());
export { TypeHandler };
//# sourceMappingURL=types.js.map