lambda-live-debugger
Version:
Debug Lambda functions locally like it is running in the cloud
400 lines (399 loc) • 15.6 kB
JavaScript
import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody } from "@aws-sdk/core";
import { requestBuilder as rb } from "@smithy/core";
import { _json, collectBody, decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectLong as __expectLong, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, isSerializableHeaderValue, LazyJsonString as __LazyJsonString, map, take, withBaseException, } from "@smithy/smithy-client";
import { IoTDataPlaneServiceException as __BaseException } from "../models/IoTDataPlaneServiceException";
import { ConflictException, InternalFailureException, InvalidRequestException, MethodNotAllowedException, RequestEntityTooLargeException, ResourceNotFoundException, ServiceUnavailableException, ThrottlingException, UnauthorizedException, UnsupportedDocumentEncodingException, } from "../models/models_0";
export const se_DeleteThingShadowCommand = async (input, context) => {
const b = rb(input, context);
const headers = {};
b.bp("/things/{thingName}/shadow");
b.p("thingName", () => input.thingName, "{thingName}", false);
const query = map({
[_n]: [, input[_sN]],
});
let body;
b.m("DELETE").h(headers).q(query).b(body);
return b.build();
};
export const se_GetRetainedMessageCommand = async (input, context) => {
const b = rb(input, context);
const headers = {};
b.bp("/retainedMessage/{topic}");
b.p("topic", () => input.topic, "{topic}", false);
let body;
b.m("GET").h(headers).b(body);
return b.build();
};
export const se_GetThingShadowCommand = async (input, context) => {
const b = rb(input, context);
const headers = {};
b.bp("/things/{thingName}/shadow");
b.p("thingName", () => input.thingName, "{thingName}", false);
const query = map({
[_n]: [, input[_sN]],
});
let body;
b.m("GET").h(headers).q(query).b(body);
return b.build();
};
export const se_ListNamedShadowsForThingCommand = async (input, context) => {
const b = rb(input, context);
const headers = {};
b.bp("/api/things/shadow/ListNamedShadowsForThing/{thingName}");
b.p("thingName", () => input.thingName, "{thingName}", false);
const query = map({
[_nT]: [, input[_nT]],
[_pS]: [() => input.pageSize !== void 0, () => input[_pS].toString()],
});
let body;
b.m("GET").h(headers).q(query).b(body);
return b.build();
};
export const se_ListRetainedMessagesCommand = async (input, context) => {
const b = rb(input, context);
const headers = {};
b.bp("/retainedMessage");
const query = map({
[_nT]: [, input[_nT]],
[_mR]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
});
let body;
b.m("GET").h(headers).q(query).b(body);
return b.build();
};
export const se_PublishCommand = async (input, context) => {
const b = rb(input, context);
const headers = map({}, isSerializableHeaderValue, {
"content-type": "application/octet-stream",
[_xamup]: [
() => isSerializableHeaderValue(input[_uP]),
() => context.base64Encoder(Buffer.from(__LazyJsonString.from(input[_uP]))),
],
[_xampfi]: input[_pFI],
[_xamcd]: input[_cD],
});
b.bp("/topics/{topic}");
b.p("topic", () => input.topic, "{topic}", false);
const query = map({
[_q]: [() => input.qos !== void 0, () => input[_q].toString()],
[_r]: [() => input.retain !== void 0, () => input[_r].toString()],
[_cT]: [, input[_cT]],
[_rT]: [, input[_rT]],
[_mE]: [() => input.messageExpiry !== void 0, () => input[_mE].toString()],
});
let body;
if (input.payload !== undefined) {
body = input.payload;
}
b.m("POST").h(headers).q(query).b(body);
return b.build();
};
export const se_UpdateThingShadowCommand = async (input, context) => {
const b = rb(input, context);
const headers = {
"content-type": "application/octet-stream",
};
b.bp("/things/{thingName}/shadow");
b.p("thingName", () => input.thingName, "{thingName}", false);
const query = map({
[_n]: [, input[_sN]],
});
let body;
if (input.payload !== undefined) {
body = input.payload;
}
b.m("POST").h(headers).q(query).b(body);
return b.build();
};
export const de_DeleteThingShadowCommand = async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = map({
$metadata: deserializeMetadata(output),
});
const data = await collectBody(output.body, context);
contents.payload = data;
return contents;
};
export const de_GetRetainedMessageCommand = async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = map({
$metadata: deserializeMetadata(output),
});
const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
const doc = take(data, {
lastModifiedTime: __expectLong,
payload: context.base64Decoder,
qos: __expectInt32,
topic: __expectString,
userProperties: context.base64Decoder,
});
Object.assign(contents, doc);
return contents;
};
export const de_GetThingShadowCommand = async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = map({
$metadata: deserializeMetadata(output),
});
const data = await collectBody(output.body, context);
contents.payload = data;
return contents;
};
export const de_ListNamedShadowsForThingCommand = async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = map({
$metadata: deserializeMetadata(output),
});
const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
const doc = take(data, {
nextToken: __expectString,
results: _json,
timestamp: __expectLong,
});
Object.assign(contents, doc);
return contents;
};
export const de_ListRetainedMessagesCommand = async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = map({
$metadata: deserializeMetadata(output),
});
const data = __expectNonNull(__expectObject(await parseBody(output.body, context)), "body");
const doc = take(data, {
nextToken: __expectString,
retainedTopics: _json,
});
Object.assign(contents, doc);
return contents;
};
export const de_PublishCommand = async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = map({
$metadata: deserializeMetadata(output),
});
await collectBody(output.body, context);
return contents;
};
export const de_UpdateThingShadowCommand = async (output, context) => {
if (output.statusCode !== 200 && output.statusCode >= 300) {
return de_CommandError(output, context);
}
const contents = map({
$metadata: deserializeMetadata(output),
});
const data = await collectBody(output.body, context);
contents.payload = data;
return contents;
};
const de_CommandError = async (output, context) => {
const parsedOutput = {
...output,
body: await parseErrorBody(output.body, context),
};
const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
switch (errorCode) {
case "InternalFailureException":
case "com.amazonaws.iotdataplane#InternalFailureException":
throw await de_InternalFailureExceptionRes(parsedOutput, context);
case "InvalidRequestException":
case "com.amazonaws.iotdataplane#InvalidRequestException":
throw await de_InvalidRequestExceptionRes(parsedOutput, context);
case "MethodNotAllowedException":
case "com.amazonaws.iotdataplane#MethodNotAllowedException":
throw await de_MethodNotAllowedExceptionRes(parsedOutput, context);
case "ResourceNotFoundException":
case "com.amazonaws.iotdataplane#ResourceNotFoundException":
throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
case "ServiceUnavailableException":
case "com.amazonaws.iotdataplane#ServiceUnavailableException":
throw await de_ServiceUnavailableExceptionRes(parsedOutput, context);
case "ThrottlingException":
case "com.amazonaws.iotdataplane#ThrottlingException":
throw await de_ThrottlingExceptionRes(parsedOutput, context);
case "UnauthorizedException":
case "com.amazonaws.iotdataplane#UnauthorizedException":
throw await de_UnauthorizedExceptionRes(parsedOutput, context);
case "UnsupportedDocumentEncodingException":
case "com.amazonaws.iotdataplane#UnsupportedDocumentEncodingException":
throw await de_UnsupportedDocumentEncodingExceptionRes(parsedOutput, context);
case "ConflictException":
case "com.amazonaws.iotdataplane#ConflictException":
throw await de_ConflictExceptionRes(parsedOutput, context);
case "RequestEntityTooLargeException":
case "com.amazonaws.iotdataplane#RequestEntityTooLargeException":
throw await de_RequestEntityTooLargeExceptionRes(parsedOutput, context);
default:
const parsedBody = parsedOutput.body;
return throwDefaultError({
output,
parsedBody,
errorCode,
});
}
};
const throwDefaultError = withBaseException(__BaseException);
const de_ConflictExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new ConflictException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_InternalFailureExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new InternalFailureException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new InvalidRequestException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_MethodNotAllowedExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new MethodNotAllowedException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_RequestEntityTooLargeExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new RequestEntityTooLargeException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new ResourceNotFoundException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_ServiceUnavailableExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new ServiceUnavailableException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_ThrottlingExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new ThrottlingException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new UnauthorizedException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const de_UnsupportedDocumentEncodingExceptionRes = async (parsedOutput, context) => {
const contents = map({});
const data = parsedOutput.body;
const doc = take(data, {
message: __expectString,
});
Object.assign(contents, doc);
const exception = new UnsupportedDocumentEncodingException({
$metadata: deserializeMetadata(parsedOutput),
...contents,
});
return __decorateServiceException(exception, parsedOutput.body);
};
const deserializeMetadata = (output) => ({
httpStatusCode: output.statusCode,
requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
extendedRequestId: output.headers["x-amz-id-2"],
cfId: output.headers["x-amz-cf-id"],
});
const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body));
const _cD = "correlationData";
const _cT = "contentType";
const _mE = "messageExpiry";
const _mR = "maxResults";
const _n = "name";
const _nT = "nextToken";
const _pFI = "payloadFormatIndicator";
const _pS = "pageSize";
const _q = "qos";
const _r = "retain";
const _rT = "responseTopic";
const _sN = "shadowName";
const _uP = "userProperties";
const _xamcd = "x-amz-mqtt5-correlation-data";
const _xampfi = "x-amz-mqtt5-payload-format-indicator";
const _xamup = "x-amz-mqtt5-user-properties";