@aptpod/iscp-ts/lib/node/encoding/converter/downstream.js

iSCP 2.0 client library for TypeScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.ProtoToWire = exports.WireToProto = void 0;
const uuid_1 = require("../../utils/uuid");
const object_1 = require("../../utils/object");
const exceptions_1 = require("../../exceptions");
const message_1 = require("../../message");
const metadata_1 = require("../../message/metadata");
const common_1 = require("./common");
const result_code_1 = require("./result-code");
const metadata_2 = require("./metadata");
class WireToProto {
    static upstreamInfo(wire) {
        return {
            sessionId: wire.sessionId,
            streamId: (0, uuid_1.stringToBytes)(wire.streamId),
            sourceNodeId: wire.sourceNodeId,
        };
    }
    static downstreamOpenRequestExtensionFields(_wire) {
        return {};
    }
    static downstreamOpenResponseExtensionFields(_wire) {
        return {};
    }
    static downstreamResumeRequestExtensionFields(_wire) {
        return {};
    }
    static downstreamResumeResponseExtensionFields(_wire) {
        return {};
    }
    static downstreamCloseRequestExtensionFields(_wire) {
        return {};
    }
    static downstreamCloseResponseExtensionFields(_wire) {
        return {};
    }
    static downstreamChunkExtensionFields(_wire) {
        return {};
    }
    static downstreamChunkAckExtensionFields(_wire) {
        return {};
    }
    static downstreamChunkAckCompleteExtensionFields(_wire) {
        return {};
    }
    static downstreamMetadataExtensionFields(_wire) {
        return {};
    }
    static downstreamMetadataAckExtensionFields(_wire) {
        return {};
    }
    static downstreamChunkResultExtensionFields(_wire) {
        return {};
    }
    static downstreamChunkResult(wire) {
        return {
            streamIdOfUpstream: (0, uuid_1.stringToBytes)(wire.streamIdOfUpstream),
            sequenceNumberInUpstream: wire.sequenceNumberInUpstream,
            resultCode: result_code_1.WireToProto.resultCode(wire.resultCode),
            resultString: wire.resultString,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamChunkResultExtensionFields(wire.extensionFields),
        };
    }
    static downstreamOpenRequest(wire) {
        return {
            requestId: wire.requestId,
            desiredStreamIdAlias: wire.desiredStreamIdAlias,
            downstreamFilters: wire.downstreamFilters.map((downstreamFilter) => {
                return common_1.WireToProto.downstreamFilter(downstreamFilter);
            }),
            expiryInterval: wire.expiryInterval,
            dataIdAliases: (0, object_1.map)({
                source: wire.dataIdAliases,
                keyConverter: (alias) => Number(alias),
                valueConverter: (dataId) => ({
                    name: dataId.name,
                    type: dataId.type,
                }),
            }),
            qos: common_1.WireToProto.qos(wire.qos),
            omitEmptyChunk: wire.omitEmptyChunk,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamOpenRequestExtensionFields(wire.extensionFields),
        };
    }
    static downstreamOpenResponse(wire) {
        return {
            requestId: wire.requestId,
            assignedStreamId: (0, uuid_1.stringToBytes)(wire.assignedStreamId),
            serverTime: wire.serverTime,
            resultCode: result_code_1.WireToProto.resultCode(wire.resultCode),
            resultString: wire.resultString,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamOpenResponseExtensionFields(wire.extensionFields),
        };
    }
    static downstreamResumeRequest(wire) {
        return {
            requestId: wire.requestId,
            streamId: (0, uuid_1.stringToBytes)(wire.streamId),
            desiredStreamIdAlias: wire.desiredStreamIdAlias,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamResumeRequestExtensionFields(wire.extensionFields),
        };
    }
    static downstreamResumeResponse(wire) {
        return {
            requestId: wire.requestId,
            resultCode: result_code_1.WireToProto.resultCode(wire.resultCode),
            resultString: wire.resultString,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamResumeResponseExtensionFields(wire.extensionFields),
        };
    }
    static downstreamCloseRequest(wire) {
        return {
            requestId: wire.requestId,
            streamId: (0, uuid_1.stringToBytes)(wire.streamId),
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamCloseRequestExtensionFields(wire.extensionFields),
        };
    }
    static downstreamCloseResponse(wire) {
        return {
            requestId: wire.requestId,
            resultCode: result_code_1.WireToProto.resultCode(wire.resultCode),
            resultString: wire.resultString,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamCloseResponseExtensionFields(wire.extensionFields),
        };
    }
    static upstreamOrAlias(wire) {
        if (wire instanceof message_1.UpstreamInfo) {
            return {
                oneofKind: 'upstreamInfo',
                upstreamInfo: WireToProto.upstreamInfo(wire),
            };
        }
        else if (typeof wire === 'number') {
            return {
                oneofKind: 'upstreamAlias',
                upstreamAlias: wire,
            };
        }
        throw new exceptions_1.ISCPMalformedMessageError('Unrecognized upstreamOrAlias.');
    }
    static downstreamChunk(wire) {
        return {
            streamIdAlias: wire.streamIdAlias,
            upstreamOrAlias: WireToProto.upstreamOrAlias(wire.upstreamOrAlias),
            streamChunk: common_1.WireToProto.streamChunk(wire.streamChunk),
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamChunkExtensionFields(wire.extensionFields),
        };
    }
    static downstreamChunkAck(wire) {
        return {
            streamIdAlias: wire.streamIdAlias,
            ackId: wire.ackId,
            results: wire.results.map((result) => WireToProto.downstreamChunkResult(result)),
            upstreamAliases: (0, object_1.map)({
                source: wire.upstreamAliases,
                keyConverter: (key) => Number(key),
                valueConverter: (value) => WireToProto.upstreamInfo(value),
            }),
            dataIdAliases: (0, object_1.map)({
                source: wire.dataIdAliases,
                keyConverter: (key) => Number(key),
                valueConverter: (value) => common_1.WireToProto.dataId(value),
            }),
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamChunkAckExtensionFields(wire.extensionFields),
        };
    }
    static downstreamChunkAckComplete(wire) {
        return {
            streamIdAlias: wire.streamIdAlias,
            ackId: wire.ackId,
            resultCode: result_code_1.WireToProto.resultCode(wire.resultCode),
            resultString: wire.resultString,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamChunkAckCompleteExtensionFields(wire.extensionFields),
        };
    }
    static metadata(wire) {
        if (wire instanceof metadata_1.BaseTime) {
            return {
                oneofKind: 'baseTime',
                baseTime: metadata_2.WireToProto.baseTime(wire),
            };
        }
        else if (wire instanceof metadata_1.UpstreamOpen) {
            return {
                oneofKind: 'upstreamOpen',
                upstreamOpen: metadata_2.WireToProto.upstreamOpen(wire),
            };
        }
        else if (wire instanceof metadata_1.UpstreamAbnormalClose) {
            return {
                oneofKind: 'upstreamAbnormalClose',
                upstreamAbnormalClose: metadata_2.WireToProto.upstreamAbnormalClose(wire),
            };
        }
        else if (wire instanceof metadata_1.UpstreamResume) {
            return {
                oneofKind: 'upstreamResume',
                upstreamResume: metadata_2.WireToProto.upstreamResume(wire),
            };
        }
        else if (wire instanceof metadata_1.UpstreamNormalClose) {
            return {
                oneofKind: 'upstreamNormalClose',
                upstreamNormalClose: metadata_2.WireToProto.upstreamNormalClose(wire),
            };
        }
        else if (wire instanceof metadata_1.DownstreamOpen) {
            return {
                oneofKind: 'downstreamOpen',
                downstreamOpen: metadata_2.WireToProto.downstreamOpen(wire),
            };
        }
        else if (wire instanceof metadata_1.DownstreamAbnormalClose) {
            return {
                oneofKind: 'downstreamAbnormalClose',
                downstreamAbnormalClose: metadata_2.WireToProto.downstreamAbnormalClose(wire),
            };
        }
        else if (wire instanceof metadata_1.DownstreamResume) {
            return {
                oneofKind: 'downstreamResume',
                downstreamResume: metadata_2.WireToProto.downstreamResume(wire),
            };
        }
        else if (wire instanceof metadata_1.DownstreamNormalClose) {
            return {
                oneofKind: 'downstreamNormalClose',
                downstreamNormalClose: metadata_2.WireToProto.downstreamNormalClose(wire),
            };
        }
        throw new exceptions_1.ISCPMalformedMessageError('Unrecognized metadata.');
    }
    static downstreamMetadata(wire) {
        return {
            requestId: wire.requestId,
            metadata: WireToProto.metadata(wire.metadata),
            sourceNodeId: wire.sourceNodeId,
            streamIdAlias: wire.streamIdAlias,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamMetadataExtensionFields(wire.extensionFields),
        };
    }
    static downstreamMetadataAck(wire) {
        return {
            requestId: wire.requestId,
            resultCode: result_code_1.WireToProto.resultCode(wire.resultCode),
            resultString: wire.resultString,
            extensionFields: typeof wire.extensionFields === 'undefined'
                ? undefined
                : WireToProto.downstreamMetadataAckExtensionFields(wire.extensionFields),
        };
    }
}
exports.WireToProto = WireToProto;
class ProtoToWire {
    static upstreamInfo(proto) {
        return new message_1.UpstreamInfo({
            sessionId: proto.sessionId,
            streamId: (0, uuid_1.bytesToString)(proto.streamId),
            sourceNodeId: proto.sourceNodeId,
        });
    }
    static downstreamOpenRequestExtensionFields(_proto) {
        return new message_1.DownstreamOpenRequestExtensionFields();
    }
    static downstreamOpenResponseExtensionFields(_proto) {
        return new message_1.DownstreamOpenResponseExtensionFields();
    }
    static downstreamResumeRequestExtensionFields(_proto) {
        return new message_1.DownstreamResumeRequestExtensionFields();
    }
    static downstreamResumeResponseExtensionFields(_proto) {
        return new message_1.DownstreamResumeResponseExtensionFields();
    }
    static downstreamCloseRequestExtensionFields(_proto) {
        return new message_1.DownstreamCloseRequestExtensionFields();
    }
    static downstreamCloseResponseExtensionFields(_proto) {
        return new message_1.DownstreamCloseResponseExtensionFields();
    }
    static downstreamChunkExtensionFields(_proto) {
        return new message_1.DownstreamChunkExtensionFields();
    }
    static downstreamChunkAckExtensionFields(_proto) {
        return new message_1.DownstreamChunkAckExtensionFields();
    }
    static downstreamChunkAckCompleteExtensionFields(_proto) {
        return new message_1.DownstreamChunkAckCompleteExtensionFields();
    }
    static downstreamMetadataExtensionFields(_proto) {
        return new message_1.DownstreamMetadataExtensionFields();
    }
    static downstreamMetadataAckExtensionFields(_proto) {
        return new message_1.DownstreamMetadataAckExtensionFields();
    }
    static downstreamChunkResultExtensionFields(_proto) {
        return new message_1.DownstreamChunkResultExtensionFields();
    }
    static downstreamChunkResult(proto) {
        return new message_1.DownstreamChunkResult({
            streamIdOfUpstream: (0, uuid_1.bytesToString)(proto.streamIdOfUpstream),
            sequenceNumberInUpstream: proto.sequenceNumberInUpstream,
            resultCode: result_code_1.ProtoToWire.resultCode(proto.resultCode),
            resultString: proto.resultString,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamChunkResultExtensionFields(proto.extensionFields),
        });
    }
    static downstreamOpenRequest(proto) {
        return new message_1.DownstreamOpenRequest({
            requestId: proto.requestId,
            desiredStreamIdAlias: proto.desiredStreamIdAlias,
            downstreamFilters: proto.downstreamFilters.map((downstreamFilter) => {
                return common_1.ProtoToWire.downstreamFilter(downstreamFilter);
            }),
            expiryInterval: proto.expiryInterval,
            dataIdAliases: (0, object_1.map)({
                source: proto.dataIdAliases,
                keyConverter: (alias) => Number(alias),
                valueConverter: (dataId) => {
                    return new message_1.DataId({
                        name: dataId.name,
                        type: dataId.type,
                    });
                },
            }),
            qos: common_1.ProtoToWire.qos(proto.qos),
            omitEmptyChunk: proto.omitEmptyChunk,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamOpenRequestExtensionFields(proto.extensionFields),
        });
    }
    static downstreamOpenResponse(proto) {
        return new message_1.DownstreamOpenResponse({
            requestId: proto.requestId,
            assignedStreamId: (0, uuid_1.bytesToString)(proto.assignedStreamId),
            serverTime: proto.serverTime,
            resultCode: result_code_1.ProtoToWire.resultCode(proto.resultCode),
            resultString: proto.resultString,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamOpenResponseExtensionFields(proto.extensionFields),
        });
    }
    static downstreamResumeRequest(proto) {
        return new message_1.DownstreamResumeRequest({
            requestId: proto.requestId,
            streamId: (0, uuid_1.bytesToString)(proto.streamId),
            desiredStreamIdAlias: proto.desiredStreamIdAlias,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamResumeRequestExtensionFields(proto.extensionFields),
        });
    }
    static downstreamResumeResponse(proto) {
        return new message_1.DownstreamResumeResponse({
            requestId: proto.requestId,
            resultCode: result_code_1.ProtoToWire.resultCode(proto.resultCode),
            resultString: proto.resultString,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamResumeResponseExtensionFields(proto.extensionFields),
        });
    }
    static downstreamCloseRequest(proto) {
        return new message_1.DownstreamCloseRequest({
            requestId: proto.requestId,
            streamId: (0, uuid_1.bytesToString)(proto.streamId),
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamCloseRequestExtensionFields(proto.extensionFields),
        });
    }
    static downstreamCloseResponse(proto) {
        return new message_1.DownstreamCloseResponse({
            requestId: proto.requestId,
            resultCode: result_code_1.ProtoToWire.resultCode(proto.resultCode),
            resultString: proto.resultString,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamCloseResponseExtensionFields(proto.extensionFields),
        });
    }
    static upstreamOrAlias(proto) {
        switch (proto.oneofKind) {
            case 'upstreamInfo':
                return ProtoToWire.upstreamInfo(proto.upstreamInfo);
            case 'upstreamAlias':
                return proto.upstreamAlias;
            default:
                throw new exceptions_1.ISCPMalformedMessageError('Unrecognized upstreamOrAlias.');
        }
    }
    static downstreamChunk(proto) {
        if (typeof proto.streamChunk === 'undefined') {
            throw new exceptions_1.ISCPMalformedMessageError('Unrecognized DownstreamChunk.streamChunk.');
        }
        return new message_1.DownstreamChunk({
            streamIdAlias: proto.streamIdAlias,
            upstreamOrAlias: ProtoToWire.upstreamOrAlias(proto.upstreamOrAlias),
            streamChunk: common_1.ProtoToWire.streamChunk(proto.streamChunk),
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamChunkExtensionFields(proto.extensionFields),
        });
    }
    static downstreamChunkAck(proto) {
        return new message_1.DownstreamChunkAck({
            streamIdAlias: proto.streamIdAlias,
            ackId: proto.ackId,
            results: proto.results.map((result) => ProtoToWire.downstreamChunkResult(result)),
            upstreamAliases: (0, object_1.map)({
                source: proto.upstreamAliases,
                keyConverter: (key) => Number(key),
                valueConverter: (value) => ProtoToWire.upstreamInfo(value),
            }),
            dataIdAliases: (0, object_1.map)({
                source: proto.dataIdAliases,
                keyConverter: (key) => Number(key),
                valueConverter: (value) => common_1.ProtoToWire.dataId(value),
            }),
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamChunkAckExtensionFields(proto.extensionFields),
        });
    }
    static downstreamChunkAckComplete(proto) {
        return new message_1.DownstreamChunkAckComplete({
            streamIdAlias: proto.streamIdAlias,
            ackId: proto.ackId,
            resultCode: result_code_1.ProtoToWire.resultCode(proto.resultCode),
            resultString: proto.resultString,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamChunkAckCompleteExtensionFields(proto.extensionFields),
        });
    }
    static metadata(proto) {
        switch (proto.oneofKind) {
            case 'baseTime':
                return metadata_2.ProtoToWire.baseTime(proto.baseTime);
            case 'upstreamOpen':
                return metadata_2.ProtoToWire.upstreamOpen(proto.upstreamOpen);
            case 'upstreamAbnormalClose':
                return metadata_2.ProtoToWire.upstreamAbnormalClose(proto.upstreamAbnormalClose);
            case 'upstreamResume':
                return metadata_2.ProtoToWire.upstreamResume(proto.upstreamResume);
            case 'upstreamNormalClose':
                return metadata_2.ProtoToWire.upstreamNormalClose(proto.upstreamNormalClose);
            case 'downstreamOpen':
                return metadata_2.ProtoToWire.downstreamOpen(proto.downstreamOpen);
            case 'downstreamAbnormalClose':
                return metadata_2.ProtoToWire.downstreamAbnormalClose(proto.downstreamAbnormalClose);
            case 'downstreamResume':
                return metadata_2.ProtoToWire.downstreamResume(proto.downstreamResume);
            case 'downstreamNormalClose':
                return metadata_2.ProtoToWire.downstreamNormalClose(proto.downstreamNormalClose);
            default:
                throw new exceptions_1.ISCPMalformedMessageError('Unrecognized metadata.');
        }
    }
    static downstreamMetadata(proto) {
        return new message_1.DownstreamMetadata({
            requestId: proto.requestId,
            metadata: ProtoToWire.metadata(proto.metadata),
            sourceNodeId: proto.sourceNodeId,
            streamIdAlias: proto.streamIdAlias,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamMetadataExtensionFields(proto.extensionFields),
        });
    }
    static downstreamMetadataAck(proto) {
        return new message_1.DownstreamMetadataAck({
            requestId: proto.requestId,
            resultCode: result_code_1.ProtoToWire.resultCode(proto.resultCode),
            resultString: proto.resultString,
            extensionFields: typeof proto.extensionFields === 'undefined'
                ? undefined
                : ProtoToWire.downstreamMetadataAckExtensionFields(proto.extensionFields),
        });
    }
}
exports.ProtoToWire = ProtoToWire;
//# sourceMappingURL=downstream.js.map