@temporalio/common/lib/internal-non-workflow/codec-helpers.js

Common library for code that's used across the Client, Worker, and/or Workflow

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.decode = decode;
exports.encode = encode;
exports.encodeOptional = encodeOptional;
exports.decodeOptional = decodeOptional;
exports.encodeOptionalSingle = encodeOptionalSingle;
exports.decodeOptionalSingle = decodeOptionalSingle;
exports.decodeOptionalSinglePayload = decodeOptionalSinglePayload;
exports.encodeToPayload = encodeToPayload;
exports.decodeArrayFromPayloads = decodeArrayFromPayloads;
exports.decodeFromPayloadsAtIndex = decodeFromPayloadsAtIndex;
exports.decodeOptionalFailureToOptionalError = decodeOptionalFailureToOptionalError;
exports.decodeOptionalMap = decodeOptionalMap;
exports.encodeToPayloads = encodeToPayloads;
exports.encodeToPayloadsWithContext = encodeToPayloadsWithContext;
exports.decodeMapFromPayloads = decodeMapFromPayloads;
exports.encodeMap = encodeMap;
exports.encodeMapToPayloads = encodeMapToPayloads;
exports.encodeErrorToFailure = encodeErrorToFailure;
exports.encodeFailure = encodeFailure;
exports.decodeFailure = decodeFailure;
exports.encodeOptionalFailure = encodeOptionalFailure;
exports.decodeOptionalFailure = decodeOptionalFailure;
exports.noopEncodeMap = noopEncodeMap;
exports.noopEncodeSearchAttrs = noopEncodeSearchAttrs;
exports.noopDecodeMap = noopDecodeMap;
exports.encodeUserMetadata = encodeUserMetadata;
exports.decodeUserMetadata = decodeUserMetadata;
const payload_converter_1 = require("../converter/payload-converter");
const errors_1 = require("../errors");
/**
 * Decode through each codec, starting with the last codec.
 */
async function decode(codecs, payloads, context) {
    for (let i = codecs.length - 1; i >= 0; i--) {
        payloads = await codecs[i].decode(payloads, context);
    }
    return payloads;
}
/**
 * Encode through each codec, starting with the first codec.
 */
async function encode(codecs, payloads, context) {
    for (let i = 0; i < codecs.length; i++) {
        payloads = await codecs[i].encode(payloads, context);
    }
    return payloads;
}
/** Run {@link PayloadCodec.encode} on `payloads` */
async function encodeOptional(codecs, payloads, context) {
    if (payloads == null)
        return payloads;
    return await encode(codecs, payloads, context);
}
/** Run {@link PayloadCodec.decode} on `payloads` */
async function decodeOptional(codecs, payloads, context) {
    if (payloads == null)
        return payloads;
    return await decode(codecs, payloads, context);
}
async function encodeSingle(codecs, payload, context) {
    const encodedPayloads = await encode(codecs, [payload], context);
    return encodedPayloads[0];
}
async function decodeSingle(codecs, payload, context) {
    const [decodedPayload] = await decode(codecs, [payload], context);
    return decodedPayload;
}
/** Run {@link PayloadCodec.encode} on a single Payload */
async function encodeOptionalSingle(codecs, payload, context) {
    if (payload == null)
        return payload;
    return await encodeSingle(codecs, payload, context);
}
/** Run {@link PayloadCodec.decode} on a single Payload */
async function decodeOptionalSingle(codecs, payload, context) {
    if (payload == null)
        return payload;
    return await decodeSingle(codecs, payload, context);
}
/** Run {@link PayloadCodec.decode} and convert from a single Payload */
async function decodeOptionalSinglePayload(dataConverter, payload, context) {
    const { payloadConverter, payloadCodecs } = dataConverter;
    const decoded = await decodeOptionalSingle(payloadCodecs, payload, context);
    if (decoded == null)
        return decoded;
    return payloadConverter.fromPayload(decoded, context);
}
/**
 * Run {@link PayloadConverter.toPayload} on value, and then encode it.
 */
async function encodeToPayload(converter, value, context) {
    const { payloadConverter, payloadCodecs } = converter;
    return await encodeSingle(payloadCodecs, payloadConverter.toPayload(value, context), context);
}
/**
 * Decode `payloads` and then return {@link arrayFromPayloads}`.
 */
async function decodeArrayFromPayloads(converter, payloads, context) {
    const { payloadConverter, payloadCodecs } = converter;
    return (0, payload_converter_1.arrayFromPayloads)(payloadConverter, await decodeOptional(payloadCodecs, payloads, context), context);
}
/**
 * Decode `payloads` and then return {@link fromPayloadsAtIndex}.
 */
async function decodeFromPayloadsAtIndex(converter, index, payloads, context) {
    const { payloadConverter, payloadCodecs } = converter;
    return await (0, payload_converter_1.fromPayloadsAtIndex)(payloadConverter, index, await decodeOptional(payloadCodecs, payloads, context), context);
}
/**
 * Run {@link decodeFailure} and then return {@link failureToError}.
 */
async function decodeOptionalFailureToOptionalError(converter, failure, context) {
    const { failureConverter, payloadConverter, payloadCodecs } = converter;
    return failure
        ? failureConverter.failureToError(await decodeFailure(payloadCodecs, failure, context), payloadConverter, context)
        : undefined;
}
async function decodeOptionalMap(codecs, payloads, context) {
    if (payloads == null)
        return payloads;
    return Object.fromEntries(await Promise.all(Object.entries(payloads).map(async ([k, v]) => [k, (await decode(codecs, [v], context))[0]])));
}
/**
 * Run {@link PayloadConverter.toPayload} on values, and then encode them.
 */
async function encodeToPayloads(converter, ...values) {
    return encodeToPayloadsWithContext(converter, undefined, values);
}
/**
 * Run {@link PayloadConverter.toPayload} on values with an optional serialization context, and then encode them.
 */
async function encodeToPayloadsWithContext(converter, context, values) {
    const { payloadConverter, payloadCodecs } = converter;
    if (values.length === 0) {
        return undefined;
    }
    const payloads = (0, payload_converter_1.toPayloadsWithContext)(payloadConverter, context, values);
    return payloads ? await encode(payloadCodecs, payloads, context) : undefined;
}
/**
 * Run {@link PayloadCodec.decode} and then {@link PayloadConverter.fromPayload} on values in `map`.
 */
async function decodeMapFromPayloads(converter, map, context) {
    if (!map)
        return undefined;
    const { payloadConverter, payloadCodecs } = converter;
    return Object.fromEntries(await Promise.all(Object.entries(map).map(async ([k, payload]) => {
        const [decodedPayload] = await decode(payloadCodecs, [payload], context);
        const value = payloadConverter.fromPayload(decodedPayload, context);
        return [k, value];
    })));
}
/** Run {@link PayloadCodec.encode} on all values in `map` */
async function encodeMap(codecs, map, context) {
    if (map === null)
        return null;
    if (map === undefined)
        return undefined;
    return Object.fromEntries(await Promise.all(Object.entries(map).map(async ([k, payload]) => {
        return [k, await encodeSingle(codecs, payload, context)];
    })));
}
/**
 * Run {@link PayloadConverter.toPayload} and then {@link PayloadCodec.encode} on values in `map`.
 */
async function encodeMapToPayloads(converter, map, context) {
    const { payloadConverter, payloadCodecs } = converter;
    return Object.fromEntries(await Promise.all(Object.entries(map).map(async ([k, v]) => {
        const payload = payloadConverter.toPayload(v, context);
        if (payload === undefined)
            throw new errors_1.PayloadConverterError(`Failed to encode entry: ${k}: ${v}`);
        const [encodedPayload] = await encode(payloadCodecs, [payload], context);
        return [k, encodedPayload];
    })));
}
/**
 * Run {@link errorToFailure} on `error`, and then {@link encodeFailure}.
 */
async function encodeErrorToFailure(dataConverter, error, context) {
    const { failureConverter, payloadConverter, payloadCodecs } = dataConverter;
    return await encodeFailure(payloadCodecs, failureConverter.errorToFailure(error, payloadConverter, context), context);
}
/**
 * Return a new {@link ProtoFailure} with `codec.encode()` run on all the {@link Payload}s.
 */
async function encodeFailure(codecs, failure, context) {
    return {
        ...failure,
        encodedAttributes: failure.encodedAttributes
            ? (await encode(codecs, [failure.encodedAttributes], context))[0]
            : undefined,
        cause: failure.cause ? await encodeFailure(codecs, failure.cause, context) : null,
        applicationFailureInfo: failure.applicationFailureInfo
            ? {
                ...failure.applicationFailureInfo,
                details: failure.applicationFailureInfo.details
                    ? {
                        payloads: await encode(codecs, failure.applicationFailureInfo.details.payloads ?? [], context),
                    }
                    : undefined,
            }
            : undefined,
        timeoutFailureInfo: failure.timeoutFailureInfo
            ? {
                ...failure.timeoutFailureInfo,
                lastHeartbeatDetails: failure.timeoutFailureInfo.lastHeartbeatDetails
                    ? {
                        payloads: await encode(codecs, failure.timeoutFailureInfo.lastHeartbeatDetails.payloads ?? [], context),
                    }
                    : undefined,
            }
            : undefined,
        canceledFailureInfo: failure.canceledFailureInfo
            ? {
                ...failure.canceledFailureInfo,
                details: failure.canceledFailureInfo.details
                    ? {
                        payloads: await encode(codecs, failure.canceledFailureInfo.details.payloads ?? [], context),
                    }
                    : undefined,
            }
            : undefined,
        resetWorkflowFailureInfo: failure.resetWorkflowFailureInfo
            ? {
                ...failure.resetWorkflowFailureInfo,
                lastHeartbeatDetails: failure.resetWorkflowFailureInfo.lastHeartbeatDetails
                    ? {
                        payloads: await encode(codecs, failure.resetWorkflowFailureInfo.lastHeartbeatDetails.payloads ?? [], context),
                    }
                    : undefined,
            }
            : undefined,
    };
}
/**
 * Return a new {@link ProtoFailure} with `codec.decode()` run on all the {@link Payload}s.
 */
async function decodeFailure(codecs, failure, context) {
    return {
        ...failure,
        encodedAttributes: failure.encodedAttributes
            ? (await decode(codecs, [failure.encodedAttributes], context))[0]
            : undefined,
        cause: failure.cause ? await decodeFailure(codecs, failure.cause, context) : null,
        applicationFailureInfo: failure.applicationFailureInfo
            ? {
                ...failure.applicationFailureInfo,
                details: failure.applicationFailureInfo.details
                    ? {
                        payloads: await decode(codecs, failure.applicationFailureInfo.details.payloads ?? [], context),
                    }
                    : undefined,
            }
            : undefined,
        timeoutFailureInfo: failure.timeoutFailureInfo
            ? {
                ...failure.timeoutFailureInfo,
                lastHeartbeatDetails: failure.timeoutFailureInfo.lastHeartbeatDetails
                    ? {
                        payloads: await decode(codecs, failure.timeoutFailureInfo.lastHeartbeatDetails.payloads ?? [], context),
                    }
                    : undefined,
            }
            : undefined,
        canceledFailureInfo: failure.canceledFailureInfo
            ? {
                ...failure.canceledFailureInfo,
                details: failure.canceledFailureInfo.details
                    ? {
                        payloads: await decode(codecs, failure.canceledFailureInfo.details.payloads ?? [], context),
                    }
                    : undefined,
            }
            : undefined,
        resetWorkflowFailureInfo: failure.resetWorkflowFailureInfo
            ? {
                ...failure.resetWorkflowFailureInfo,
                lastHeartbeatDetails: failure.resetWorkflowFailureInfo.lastHeartbeatDetails
                    ? {
                        payloads: await decode(codecs, failure.resetWorkflowFailureInfo.lastHeartbeatDetails.payloads ?? [], context),
                    }
                    : undefined,
            }
            : undefined,
    };
}
/**
 * Return a new {@link ProtoFailure} with `codec.encode()` run on all the {@link Payload}s.
 */
async function encodeOptionalFailure(codecs, failure, context) {
    if (failure == null)
        return failure;
    return await encodeFailure(codecs, failure, context);
}
/**
 * Return a new {@link ProtoFailure} with `codec.encode()` run on all the {@link Payload}s.
 */
async function decodeOptionalFailure(codecs, failure, context) {
    if (failure == null)
        return failure;
    return await decodeFailure(codecs, failure, context);
}
/**
 * Mark all values in the map as encoded.
 * Use this for headers, which we don't encode.
 */
function noopEncodeMap(map) {
    return map;
}
function noopEncodeSearchAttrs(attrs) {
    if (!attrs) {
        return attrs;
    }
    return {
        indexedFields: noopEncodeMap(attrs.indexedFields),
    };
}
/**
 * Mark all values in the map as decoded.
 * Use this for headers, which we don't encode.
 */
function noopDecodeMap(map) {
    return map;
}
async function encodeUserMetadata(dataConverter, staticSummary, staticDetails, context) {
    if (staticSummary == null && staticDetails == null)
        return undefined;
    const { payloadConverter, payloadCodecs } = dataConverter;
    const summary = await encodeOptionalSingle(payloadCodecs, (0, payload_converter_1.convertOptionalToPayload)(payloadConverter, staticSummary, context), context);
    const details = await encodeOptionalSingle(payloadCodecs, (0, payload_converter_1.convertOptionalToPayload)(payloadConverter, staticDetails, context), context);
    if (summary == null && details == null)
        return undefined;
    return { summary, details };
}
async function decodeUserMetadata(dataConverter, metadata, context) {
    const res = { staticSummary: undefined, staticDetails: undefined };
    if (metadata == null)
        return res;
    const staticSummary = (await decodeOptionalSinglePayload(dataConverter, metadata.summary, context)) ?? undefined;
    const staticDetails = (await decodeOptionalSinglePayload(dataConverter, metadata.details, context)) ?? undefined;
    return { staticSummary, staticDetails };
}
//# sourceMappingURL=codec-helpers.js.map