testplane/build/src/utils/worker-error-serialization.js

Tests framework based on mocha and wdio

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.serializeWorkerError = exports.deserializeWorkerError = exports.SERIALIZED_ERROR_MARKER = void 0;
exports.SERIALIZED_ERROR_MARKER = "__testplane_serialized_error__";
const CIRCULAR_REFERENCE_PLACEHOLDER = "[Circular]";
const BASE_ERROR_FIELDS = new Set(["name", "message", "stack"]);
const ENVELOPE_FIELDS = new Set([exports.SERIALIZED_ERROR_MARKER, "isThrownNonError", "value", "message", "stack", "name"]);
const isObject = (value) => value !== null && typeof value === "object";
const isSerializedWorkerError = (value) => isObject(value) && value[exports.SERIALIZED_ERROR_MARKER] === true;
function serializeValue(value, traversed) {
    if (Buffer.isBuffer(value)) {
        return { type: "Buffer", data: Array.from(value) };
    }
    if (value instanceof Error) {
        return serializeError(value, traversed);
    }
    if (!isObject(value)) {
        return value;
    }
    if (traversed.has(value)) {
        return CIRCULAR_REFERENCE_PLACEHOLDER;
    }
    traversed.add(value);
    try {
        if (Array.isArray(value)) {
            return value.map(item => serializeValue(item, traversed));
        }
        return Object.keys(value).reduce((result, key) => {
            result[key] = serializeValue(value[key], traversed);
            return result;
        }, {});
    }
    finally {
        traversed.delete(value);
    }
}
function serializeError(error, traversed) {
    if (traversed.has(error)) {
        return {
            [exports.SERIALIZED_ERROR_MARKER]: true,
            message: error.message,
            stack: error.stack,
            name: error.name,
        };
    }
    traversed.add(error);
    try {
        const serializedError = {
            [exports.SERIALIZED_ERROR_MARKER]: true,
            message: error.message,
            stack: error.stack,
            name: error.name,
        };
        Object.getOwnPropertyNames(error).forEach(key => {
            if (BASE_ERROR_FIELDS.has(key)) {
                return;
            }
            serializedError[key] = serializeValue(error[key], traversed);
        });
        return serializedError;
    }
    finally {
        traversed.delete(error);
    }
}
function deserializeValue(value) {
    if (Array.isArray(value)) {
        return value.map(deserializeValue);
    }
    if (isSerializedWorkerError(value)) {
        return deserializeWorkerError(value);
    }
    if (!isObject(value)) {
        return value;
    }
    if (value.type === "Buffer" && Array.isArray(value.data)) {
        return Buffer.from(value.data);
    }
    return Object.keys(value).reduce((result, key) => {
        result[key] = deserializeValue(value[key]);
        return result;
    }, {});
}
function deserializeWorkerError(value) {
    if (!isSerializedWorkerError(value)) {
        return value;
    }
    if (value.isThrownNonError) {
        return deserializeValue(value.value);
    }
    const message = typeof value.message === "string" ? value.message : "";
    const cause = Object.prototype.hasOwnProperty.call(value, "cause") ? deserializeValue(value.cause) : undefined;
    const error = cause === undefined ? new Error(message) : new Error(message, { cause });
    if (typeof value.stack === "string") {
        error.stack = value.stack;
    }
    if (typeof value.name === "string" && value.name !== "Error") {
        Object.defineProperty(error, "name", {
            value: value.name,
            configurable: true,
            writable: true,
            enumerable: false,
        });
    }
    Object.keys(value).forEach(key => {
        if (ENVELOPE_FIELDS.has(key) || key === "cause") {
            return;
        }
        error[key] = deserializeValue(value[key]);
    });
    return error;
}
exports.deserializeWorkerError = deserializeWorkerError;
function serializeWorkerError(error) {
    if (error instanceof Error) {
        return serializeError(error, new WeakSet());
    }
    return {
        [exports.SERIALIZED_ERROR_MARKER]: true,
        isThrownNonError: true,
        value: serializeValue(error, new WeakSet()),
    };
}
exports.serializeWorkerError = serializeWorkerError;
//# sourceMappingURL=worker-error-serialization.js.map