mirror of
https://github.com/gosticks/DefinitelyTyped.git
synced 2025-10-16 12:05:41 +00:00
fbb3688b15
* Make ExpectError locations same for TS 3.8 Error locations changed for some object literals in TS 3.8. This breaks tests that use ExpectError since the ExpectError needs to be closer to the actual error. To fix this, I merged a lot of multi-line object literals into one-line literals. * remove stray edit
1409 lines
47 KiB
TypeScript
1409 lines
47 KiB
TypeScript
declare let str: string;
|
|
declare let strOrNull: string | null;
|
|
declare let strOrUndefined: string | undefined;
|
|
declare let strOrUndefinedOrNull: string | undefined | null;
|
|
declare let date: Date;
|
|
declare let anyObj: any;
|
|
declare let num: number;
|
|
declare let error: Error;
|
|
declare let bool: boolean;
|
|
declare let boolOrUndefined: boolean | undefined;
|
|
declare let boolOrNumOrStr: boolean | number | string;
|
|
declare let numOrUndefined: number | undefined;
|
|
declare let apiGwEvtReqCtx: AWSLambda.APIGatewayEventRequestContext;
|
|
declare let apiGwEvtReqCtxOpt: AWSLambda.APIGatewayEventRequestContext | null | undefined;
|
|
declare let apiGwEvt: AWSLambda.APIGatewayEvent;
|
|
declare let albEvtReqCtx: AWSLambda.ALBEventRequestContext;
|
|
declare let albEvt: AWSLambda.ALBEvent;
|
|
declare let albRes: AWSLambda.ALBResult;
|
|
declare let customAuthorizerEvt: AWSLambda.CustomAuthorizerEvent;
|
|
declare let clientCtx: AWSLambda.ClientContext;
|
|
declare let clientCtxOrUndefined: AWSLambda.ClientContext | undefined;
|
|
declare let clientContextEnv: AWSLambda.ClientContextEnv;
|
|
declare let clientContextClient: AWSLambda.ClientContextClient;
|
|
declare let context: AWSLambda.Context;
|
|
declare let identity: AWSLambda.CognitoIdentity;
|
|
declare let identityOrUndefined: AWSLambda.CognitoIdentity | undefined;
|
|
declare let proxyResult: AWSLambda.ProxyResult;
|
|
declare let authResponse: AWSLambda.AuthResponse;
|
|
declare let policyDocument: AWSLambda.PolicyDocument;
|
|
declare let statement: AWSLambda.Statement;
|
|
declare let authResponseContext: AWSLambda.AuthResponseContext;
|
|
declare let authResponseContextOpt: AWSLambda.AuthResponseContext | null | undefined;
|
|
declare let snsEvt: AWSLambda.SNSEvent;
|
|
declare let snsEvtRecs: AWSLambda.SNSEventRecord[];
|
|
declare let snsEvtRec: AWSLambda.SNSEventRecord;
|
|
declare let snsMsg: AWSLambda.SNSMessage;
|
|
declare let snsMsgAttr: AWSLambda.SNSMessageAttribute;
|
|
declare let snsMsgAttrs: AWSLambda.SNSMessageAttributes;
|
|
const S3EvtRec: AWSLambda.S3EventRecord = {
|
|
eventVersion: '2.1',
|
|
eventSource: 'aws:s3',
|
|
awsRegion: 'us-east-1',
|
|
eventTime: '1970-01-01T00:00:00.000Z',
|
|
eventName: 'ObjectRestore:Completed',
|
|
userIdentity: {
|
|
principalId: 'AIDAJDPLRKLG7UEXAMPLE',
|
|
},
|
|
requestParameters: {
|
|
sourceIPAddress: '127.0.0.1',
|
|
},
|
|
responseElements: {
|
|
'x-amz-request-id': 'C3D13FE58DE4C810',
|
|
'x-amz-id-2': 'FMyUVURIY8/IgAtTv8xRjskZQpcIZ9KG4V5Wp6S7S/JRWeUWerMUE5JgHvANOjpD',
|
|
},
|
|
s3: {
|
|
s3SchemaVersion: '1.0',
|
|
configurationId: 'testConfigRule',
|
|
bucket: {
|
|
name: 'mybucket',
|
|
ownerIdentity: {
|
|
principalId: 'A3NL1KOZZKExample',
|
|
},
|
|
arn: 'arn:aws:s3:::mybucket',
|
|
},
|
|
object: {
|
|
key: 'HappyFace.jpg',
|
|
size: 1024,
|
|
eTag: 'd41d8cd98f00b204e9800998ecf8427e',
|
|
versionId: '096fKKXTRTtl3on89fVO.nfljtsv6qko',
|
|
sequencer: '0055AED6DCD90281E5',
|
|
},
|
|
},
|
|
glacierEventData: {
|
|
restoreEventData: {
|
|
lifecycleRestorationExpiryTime: '1970-01-01T00:00:00.000Z',
|
|
lifecycleRestoreStorageClass: 'glacier-deep-archive',
|
|
},
|
|
},
|
|
};
|
|
|
|
const S3CreateEvent: AWSLambda.S3CreateEvent = {
|
|
Records: [S3EvtRec],
|
|
};
|
|
|
|
declare const cognitoUserPoolEvent: AWSLambda.CognitoUserPoolEvent;
|
|
declare const cloudformationCustomResourceEvent: AWSLambda.CloudFormationCustomResourceEvent;
|
|
declare const cloudformationCustomResourceResponse: AWSLambda.CloudFormationCustomResourceResponse;
|
|
declare const cloudwatchLogsEvent: AWSLambda.CloudWatchLogsEvent;
|
|
declare const cloudwatchLogsDecodedData: AWSLambda.CloudWatchLogsDecodedData;
|
|
declare const scheduledEvent: AWSLambda.ScheduledEvent;
|
|
|
|
/* API Gateway Event request context */
|
|
str = apiGwEvtReqCtx.accountId;
|
|
str = apiGwEvtReqCtx.apiId;
|
|
authResponseContextOpt = apiGwEvtReqCtx.authorizer;
|
|
numOrUndefined = apiGwEvtReqCtx.connectedAt;
|
|
strOrUndefined = apiGwEvtReqCtx.connectionId;
|
|
strOrUndefined = apiGwEvtReqCtx.domainName;
|
|
strOrUndefined = apiGwEvtReqCtx.eventType;
|
|
strOrUndefined = apiGwEvtReqCtx.extendedRequestId;
|
|
str = apiGwEvtReqCtx.httpMethod;
|
|
strOrNull = apiGwEvtReqCtx.identity.accessKey;
|
|
strOrNull = apiGwEvtReqCtx.identity.accountId;
|
|
strOrNull = apiGwEvtReqCtx.identity.apiKey;
|
|
strOrNull = apiGwEvtReqCtx.identity.apiKeyId;
|
|
strOrNull = apiGwEvtReqCtx.identity.caller;
|
|
strOrNull = apiGwEvtReqCtx.identity.cognitoAuthenticationProvider;
|
|
strOrNull = apiGwEvtReqCtx.identity.cognitoAuthenticationType;
|
|
strOrNull = apiGwEvtReqCtx.identity.cognitoIdentityId;
|
|
strOrNull = apiGwEvtReqCtx.identity.cognitoIdentityPoolId;
|
|
strOrNull = apiGwEvtReqCtx.identity.principalOrgId;
|
|
str = apiGwEvtReqCtx.identity.sourceIp;
|
|
strOrNull = apiGwEvtReqCtx.identity.user;
|
|
strOrNull = apiGwEvtReqCtx.identity.userAgent;
|
|
strOrNull = apiGwEvtReqCtx.identity.userArn;
|
|
strOrUndefined = apiGwEvtReqCtx.messageDirection;
|
|
strOrUndefinedOrNull = apiGwEvtReqCtx.messageId;
|
|
str = apiGwEvtReqCtx.path;
|
|
str = apiGwEvtReqCtx.stage;
|
|
str = apiGwEvtReqCtx.requestId;
|
|
strOrUndefined = apiGwEvtReqCtx.requestTime;
|
|
str = apiGwEvtReqCtx.resourceId;
|
|
str = apiGwEvtReqCtx.resourcePath;
|
|
strOrUndefined = apiGwEvtReqCtx.routeKey;
|
|
|
|
/* API Gateway Event */
|
|
strOrNull = apiGwEvt.body;
|
|
str = apiGwEvt.headers['example'];
|
|
str = apiGwEvt.multiValueHeaders['example'][0];
|
|
str = apiGwEvt.httpMethod;
|
|
bool = apiGwEvt.isBase64Encoded;
|
|
str = apiGwEvt.path;
|
|
str = apiGwEvt.pathParameters!['example'];
|
|
str = apiGwEvt.queryStringParameters!['example'];
|
|
str = apiGwEvt.multiValueQueryStringParameters!['example'][0];
|
|
str = apiGwEvt.stageVariables!['example'];
|
|
apiGwEvtReqCtx = apiGwEvt.requestContext;
|
|
str = apiGwEvt.resource;
|
|
|
|
/* Application Load Balancer Event Request Context */
|
|
str = albEvtReqCtx.elb.targetGroupArn;
|
|
|
|
/* Application Load Balancer Event */
|
|
str = albEvt.httpMethod;
|
|
str = albEvt.path;
|
|
str = albEvt.queryStringParameters!['example'];
|
|
str = albEvt.headers!['example'];
|
|
str = albEvt.multiValueQueryStringParameters!['example'][0];
|
|
str = albEvt.multiValueHeaders!['example'][0];
|
|
strOrNull = albEvt.body;
|
|
bool = albEvt.isBase64Encoded;
|
|
|
|
/* Application Load Balancer Result */
|
|
num = albRes.statusCode;
|
|
str = albRes.statusDescription;
|
|
boolOrNumOrStr = albRes.headers!['example'];
|
|
boolOrNumOrStr = albRes.multiValueHeaders!['example'][0];
|
|
str = albRes.body;
|
|
bool = albRes.isBase64Encoded;
|
|
|
|
/* API Gateway CustomAuthorizer Event */
|
|
str = customAuthorizerEvt.type;
|
|
str = customAuthorizerEvt.methodArn;
|
|
strOrUndefined = customAuthorizerEvt.authorizationToken;
|
|
strOrUndefined = customAuthorizerEvt.resource;
|
|
strOrUndefined = customAuthorizerEvt.path;
|
|
strOrUndefined = customAuthorizerEvt.httpMethod;
|
|
str = customAuthorizerEvt.headers!['example'];
|
|
str = customAuthorizerEvt.multiValueHeaders!['example'][0];
|
|
str = customAuthorizerEvt.pathParameters!['example'];
|
|
str = customAuthorizerEvt.queryStringParameters!['example'];
|
|
str = customAuthorizerEvt.multiValueQueryStringParameters!['example'][0];
|
|
str = customAuthorizerEvt.stageVariables!['example'];
|
|
apiGwEvtReqCtxOpt = customAuthorizerEvt.requestContext;
|
|
strOrUndefined = customAuthorizerEvt.domainName;
|
|
strOrUndefined = customAuthorizerEvt.apiId;
|
|
|
|
/* DynamoDB Stream Event */
|
|
const dynamoDBStreamEvent: AWSLambda.DynamoDBStreamEvent = {
|
|
Records: [
|
|
{
|
|
eventID: '1',
|
|
eventVersion: '1.0',
|
|
dynamodb: {
|
|
Keys: {
|
|
Id: {
|
|
N: '101',
|
|
},
|
|
},
|
|
NewImage: {
|
|
Message: {
|
|
S: 'New item!',
|
|
},
|
|
Id: {
|
|
N: '101',
|
|
},
|
|
},
|
|
StreamViewType: 'NEW_AND_OLD_IMAGES',
|
|
SequenceNumber: '111',
|
|
SizeBytes: 26,
|
|
},
|
|
awsRegion: 'us-west-2',
|
|
eventName: 'INSERT',
|
|
eventSourceARN:
|
|
'arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899',
|
|
eventSource: 'aws:dynamodb',
|
|
},
|
|
{
|
|
eventID: '2',
|
|
eventVersion: '1.0',
|
|
dynamodb: {
|
|
OldImage: {
|
|
Message: {
|
|
S: 'New item!',
|
|
},
|
|
Id: {
|
|
N: '101',
|
|
},
|
|
},
|
|
SequenceNumber: '222',
|
|
Keys: {
|
|
Id: {
|
|
N: '101',
|
|
},
|
|
},
|
|
SizeBytes: 59,
|
|
NewImage: {
|
|
Message: {
|
|
S: 'This item has changed',
|
|
},
|
|
Id: {
|
|
N: '101',
|
|
},
|
|
},
|
|
StreamViewType: 'NEW_AND_OLD_IMAGES',
|
|
},
|
|
awsRegion: 'us-west-2',
|
|
eventName: 'MODIFY',
|
|
eventSourceARN:
|
|
'arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899',
|
|
eventSource: 'aws:dynamodb',
|
|
},
|
|
{
|
|
eventID: '3',
|
|
eventVersion: '1.0',
|
|
dynamodb: {
|
|
Keys: {
|
|
Id: {
|
|
N: '101',
|
|
},
|
|
},
|
|
SizeBytes: 38,
|
|
SequenceNumber: '333',
|
|
OldImage: {
|
|
Message: {
|
|
S: 'This item has changed',
|
|
},
|
|
Id: {
|
|
N: '101',
|
|
},
|
|
},
|
|
StreamViewType: 'NEW_AND_OLD_IMAGES',
|
|
},
|
|
awsRegion: 'us-west-2',
|
|
eventName: 'REMOVE',
|
|
eventSourceARN:
|
|
'arn:aws:dynamodb:us-west-2:account-id:table/ExampleTableWithStream/stream/2015-06-27T00:48:05.899',
|
|
eventSource: 'aws:dynamodb',
|
|
},
|
|
],
|
|
};
|
|
|
|
/* SNS Event */
|
|
snsEvtRecs = snsEvt.Records;
|
|
|
|
str = snsEvtRec.EventSource;
|
|
str = snsEvtRec.EventSubscriptionArn;
|
|
str = snsEvtRec.EventVersion;
|
|
snsMsg = snsEvtRec.Sns;
|
|
|
|
str = snsMsg.SignatureVersion;
|
|
str = snsMsg.Timestamp;
|
|
str = snsMsg.Signature;
|
|
str = snsMsg.SigningCertUrl;
|
|
str = snsMsg.MessageId;
|
|
str = snsMsg.Message;
|
|
snsMsgAttrs = snsMsg.MessageAttributes;
|
|
str = snsMsg.Type;
|
|
str = snsMsg.UnsubscribeUrl;
|
|
str = snsMsg.TopicArn;
|
|
str = snsMsg.Subject;
|
|
|
|
snsMsgAttrs['example'] = snsMsgAttr;
|
|
|
|
str = snsMsgAttr.Type;
|
|
str = snsMsgAttr.Value;
|
|
|
|
/* Lambda Proxy Result */
|
|
num = proxyResult.statusCode;
|
|
proxyResult.headers!['example'] = str;
|
|
proxyResult.headers!['example'] = bool;
|
|
proxyResult.headers!['example'] = num;
|
|
proxyResult.multiValueHeaders!['example'][0] = str;
|
|
proxyResult.multiValueHeaders!['example'][0] = bool;
|
|
proxyResult.multiValueHeaders!['example'][0] = num;
|
|
boolOrUndefined = proxyResult.isBase64Encoded;
|
|
str = proxyResult.body;
|
|
|
|
/* API Gateway CustomAuthorizer AuthResponse */
|
|
authResponseContext = {
|
|
stringKey: str,
|
|
numberKey: num,
|
|
booleanKey: bool,
|
|
};
|
|
|
|
statement = {
|
|
Action: str,
|
|
Effect: str,
|
|
Resource: str,
|
|
};
|
|
|
|
// $ExpectError
|
|
statement = { Effect: str, Action: str, Principal: 123, };
|
|
|
|
// Bad Resource
|
|
// $ExpectError
|
|
statement = { Effect: str, Action: str, Resource: 123, };
|
|
|
|
// Bad Resource with valid Principal
|
|
// $ExpectError
|
|
statement = { Effect: str, Action: str, Principal: { Service: str }, Resource: 123, };
|
|
|
|
// Bad principal with valid Resource
|
|
// $ExpectError
|
|
statement = { Effect: str, Action: str, Principal: 123, Resource: str, };
|
|
|
|
// No Effect
|
|
// $ExpectError
|
|
statement = {
|
|
Action: str,
|
|
Principal: str,
|
|
};
|
|
|
|
statement = {
|
|
Sid: str,
|
|
Action: [str, str],
|
|
Effect: str,
|
|
Resource: [str, str],
|
|
Condition: {
|
|
condition1: { key: 'value' },
|
|
condition2: [
|
|
{
|
|
key1: 'value',
|
|
key2: 'value',
|
|
},
|
|
{
|
|
key3: 'value',
|
|
},
|
|
],
|
|
},
|
|
Principal: [str, str],
|
|
NotPrincipal: [str, str],
|
|
};
|
|
|
|
statement = {
|
|
Action: str,
|
|
Principal: str,
|
|
Effect: str,
|
|
};
|
|
|
|
statement = {
|
|
Action: str,
|
|
NotPrincipal: {
|
|
Service: str,
|
|
},
|
|
Effect: str,
|
|
};
|
|
|
|
statement = {
|
|
Effect: str,
|
|
NotAction: str,
|
|
NotResource: str,
|
|
};
|
|
|
|
policyDocument = {
|
|
Version: str,
|
|
Statement: [statement],
|
|
};
|
|
|
|
policyDocument = {
|
|
Version: str,
|
|
Statement: [statement, statement],
|
|
};
|
|
|
|
authResponse = {
|
|
principalId: str,
|
|
policyDocument,
|
|
context: authResponseContext,
|
|
};
|
|
|
|
authResponse = {
|
|
principalId: str,
|
|
policyDocument,
|
|
};
|
|
|
|
// CognitoUserPoolEvent
|
|
num = cognitoUserPoolEvent.version;
|
|
cognitoUserPoolEvent.triggerSource === 'PreSignUp_SignUp';
|
|
cognitoUserPoolEvent.triggerSource === 'PreSignUp_ExternalProvider';
|
|
cognitoUserPoolEvent.triggerSource === 'PostConfirmation_ConfirmSignUp';
|
|
cognitoUserPoolEvent.triggerSource === 'PreAuthentication_Authentication';
|
|
cognitoUserPoolEvent.triggerSource === 'PostAuthentication_Authentication';
|
|
cognitoUserPoolEvent.triggerSource === 'CustomMessage_SignUp';
|
|
cognitoUserPoolEvent.triggerSource === 'CustomMessage_AdminCreateUser';
|
|
cognitoUserPoolEvent.triggerSource === 'CustomMessage_ResendCode';
|
|
cognitoUserPoolEvent.triggerSource === 'CustomMessage_ForgotPassword';
|
|
cognitoUserPoolEvent.triggerSource === 'CustomMessage_UpdateUserAttribute';
|
|
cognitoUserPoolEvent.triggerSource === 'CustomMessage_VerifyUserAttribute';
|
|
cognitoUserPoolEvent.triggerSource === 'CustomMessage_Authentication';
|
|
cognitoUserPoolEvent.triggerSource === 'DefineAuthChallenge_Authentication';
|
|
cognitoUserPoolEvent.triggerSource === 'CreateAuthChallenge_Authentication';
|
|
cognitoUserPoolEvent.triggerSource === 'VerifyAuthChallengeResponse_Authentication';
|
|
cognitoUserPoolEvent.triggerSource === 'PreSignUp_AdminCreateUser';
|
|
cognitoUserPoolEvent.triggerSource === 'PostConfirmation_ConfirmForgotPassword';
|
|
cognitoUserPoolEvent.triggerSource === 'TokenGeneration_HostedAuth';
|
|
cognitoUserPoolEvent.triggerSource === 'TokenGeneration_Authentication';
|
|
cognitoUserPoolEvent.triggerSource === 'TokenGeneration_NewPasswordChallenge';
|
|
cognitoUserPoolEvent.triggerSource === 'TokenGeneration_AuthenticateDevice';
|
|
cognitoUserPoolEvent.triggerSource === 'TokenGeneration_RefreshTokens';
|
|
cognitoUserPoolEvent.triggerSource === 'UserMigration_Authentication';
|
|
cognitoUserPoolEvent.triggerSource === 'UserMigration_ForgotPassword';
|
|
str = cognitoUserPoolEvent.region;
|
|
str = cognitoUserPoolEvent.userPoolId;
|
|
strOrUndefined = cognitoUserPoolEvent.userName;
|
|
str = cognitoUserPoolEvent.callerContext.awsSdkVersion;
|
|
str = cognitoUserPoolEvent.callerContext.clientId;
|
|
str = cognitoUserPoolEvent.request.userAttributes['email'];
|
|
str = cognitoUserPoolEvent.request.validationData!['k1'];
|
|
strOrUndefined = cognitoUserPoolEvent.request.codeParameter;
|
|
strOrUndefined = cognitoUserPoolEvent.request.linkParameter;
|
|
strOrUndefined = cognitoUserPoolEvent.request.usernameParameter;
|
|
boolOrUndefined = cognitoUserPoolEvent.request.newDeviceUsed;
|
|
cognitoUserPoolEvent.request.session![0].challengeName === 'CUSTOM_CHALLENGE';
|
|
cognitoUserPoolEvent.request.session![0].challengeName === 'PASSWORD_VERIFIER';
|
|
cognitoUserPoolEvent.request.session![0].challengeName === 'SMS_MFA';
|
|
cognitoUserPoolEvent.request.session![0].challengeName === 'DEVICE_SRP_AUTH';
|
|
cognitoUserPoolEvent.request.session![0].challengeName === 'DEVICE_PASSWORD_VERIFIER';
|
|
cognitoUserPoolEvent.request.session![0].challengeName === 'ADMIN_NO_SRP_AUTH';
|
|
bool = cognitoUserPoolEvent.request.session![0].challengeResult;
|
|
strOrUndefined = cognitoUserPoolEvent.request.session![0].challengeMetadata;
|
|
strOrUndefined = cognitoUserPoolEvent.request.challengeName;
|
|
str = cognitoUserPoolEvent.request.privateChallengeParameters!['answer'];
|
|
str = cognitoUserPoolEvent.request.challengeAnswer!;
|
|
strOrUndefined = cognitoUserPoolEvent.request.password;
|
|
boolOrUndefined = cognitoUserPoolEvent.response.answerCorrect;
|
|
strOrUndefined = cognitoUserPoolEvent.response.smsMessage;
|
|
strOrUndefined = cognitoUserPoolEvent.response.emailMessage;
|
|
strOrUndefined = cognitoUserPoolEvent.response.emailSubject;
|
|
strOrUndefined = cognitoUserPoolEvent.response.challengeName;
|
|
boolOrUndefined = cognitoUserPoolEvent.response.issueTokens;
|
|
boolOrUndefined = cognitoUserPoolEvent.response.failAuthentication;
|
|
str = cognitoUserPoolEvent.response.publicChallengeParameters!['captchaUrl'];
|
|
str = cognitoUserPoolEvent.response.privateChallengeParameters!['answer'];
|
|
strOrUndefined = cognitoUserPoolEvent.response.challengeMetadata;
|
|
boolOrUndefined = cognitoUserPoolEvent.response.answerCorrect;
|
|
str = cognitoUserPoolEvent.response.userAttributes!['username'];
|
|
cognitoUserPoolEvent.response.finalUserStatus === 'CONFIRMED';
|
|
cognitoUserPoolEvent.response.finalUserStatus === 'RESET_REQUIRED';
|
|
cognitoUserPoolEvent.response.messageAction === 'SUPPRESS';
|
|
cognitoUserPoolEvent.response.desiredDeliveryMediums === ['EMAIL'];
|
|
cognitoUserPoolEvent.response.desiredDeliveryMediums === ['SMS'];
|
|
cognitoUserPoolEvent.response.desiredDeliveryMediums === ['SMS', 'EMAIL'];
|
|
boolOrUndefined = cognitoUserPoolEvent.response.forceAliasCreation;
|
|
// From AWS examples
|
|
cognitoUserPoolEvent.response = {
|
|
claimsOverrideDetails: {
|
|
claimsToAddOrOverride: {
|
|
attribute_key2: 'attribute_value2',
|
|
attribute_key: 'attribute_value',
|
|
},
|
|
claimsToSuppress: ['email'],
|
|
},
|
|
};
|
|
cognitoUserPoolEvent.response = {
|
|
claimsOverrideDetails: {
|
|
claimsToAddOrOverride: {
|
|
attribute_key2: 'attribute_value2',
|
|
attribute_key: 'attribute_value',
|
|
},
|
|
claimsToSuppress: ['email'],
|
|
groupOverrideDetails: {
|
|
groupsToOverride: ['group-A', 'group-B', 'group-C'],
|
|
iamRolesToOverride: [
|
|
'arn:aws:iam::XXXXXXXXXXXX:role/sns_callerA',
|
|
'arn:aws:iam::XXXXXXXXX:role/sns_callerB',
|
|
'arn:aws:iam::XXXXXXXXXX:role/sns_callerC',
|
|
],
|
|
preferredRole: 'arn:aws:iam::XXXXXXXXXXX:role/sns_caller',
|
|
},
|
|
},
|
|
};
|
|
cognitoUserPoolEvent.response.claimsOverrideDetails!.groupOverrideDetails = null;
|
|
|
|
// CloudFormation Custom Resource
|
|
switch (cloudformationCustomResourceEvent.RequestType) {
|
|
case 'Create':
|
|
str = cloudformationCustomResourceEvent.LogicalResourceId;
|
|
str = cloudformationCustomResourceEvent.RequestId;
|
|
anyObj = cloudformationCustomResourceEvent.ResourceProperties;
|
|
str = cloudformationCustomResourceEvent.ResourceProperties.ServiceToken;
|
|
str = cloudformationCustomResourceEvent.ResourceType;
|
|
str = cloudformationCustomResourceEvent.ResponseURL;
|
|
str = cloudformationCustomResourceEvent.ServiceToken;
|
|
str = cloudformationCustomResourceEvent.StackId;
|
|
break;
|
|
case 'Update':
|
|
anyObj = cloudformationCustomResourceEvent.OldResourceProperties;
|
|
break;
|
|
case 'Delete':
|
|
str = cloudformationCustomResourceEvent.PhysicalResourceId;
|
|
break;
|
|
}
|
|
anyObj = cloudformationCustomResourceResponse.Data;
|
|
str = cloudformationCustomResourceResponse.LogicalResourceId;
|
|
str = cloudformationCustomResourceResponse.PhysicalResourceId;
|
|
strOrUndefined = cloudformationCustomResourceResponse.Reason;
|
|
str = cloudformationCustomResourceResponse.RequestId;
|
|
str = cloudformationCustomResourceResponse.StackId;
|
|
str = cloudformationCustomResourceResponse.Status;
|
|
boolOrUndefined = cloudformationCustomResourceResponse.NoEcho;
|
|
|
|
/* ScheduledEvent */
|
|
str = scheduledEvent.account;
|
|
anyObj = scheduledEvent.detail;
|
|
str = scheduledEvent.id;
|
|
str = scheduledEvent.region;
|
|
str = scheduledEvent.resources[0];
|
|
str = scheduledEvent.source;
|
|
str = scheduledEvent.time;
|
|
|
|
/* Context */
|
|
bool = context.callbackWaitsForEmptyEventLoop;
|
|
str = context.functionName;
|
|
str = context.functionVersion;
|
|
str = context.invokedFunctionArn;
|
|
str = context.memoryLimitInMB;
|
|
str = context.awsRequestId;
|
|
str = context.logGroupName;
|
|
str = context.logStreamName;
|
|
identityOrUndefined = context.identity;
|
|
clientCtxOrUndefined = context.clientContext;
|
|
|
|
/* CognitoIdentity */
|
|
str = identity.cognitoIdentityId;
|
|
str = identity.cognitoIdentityPoolId;
|
|
|
|
/* CloudWatch Logs */
|
|
str = cloudwatchLogsEvent.awslogs.data;
|
|
|
|
str = cloudwatchLogsDecodedData.owner;
|
|
str = cloudwatchLogsDecodedData.logGroup;
|
|
str = cloudwatchLogsDecodedData.logStream;
|
|
str = cloudwatchLogsDecodedData.subscriptionFilters[0];
|
|
str = cloudwatchLogsDecodedData.messageType;
|
|
str = cloudwatchLogsDecodedData.logEvents[0].id;
|
|
num = cloudwatchLogsDecodedData.logEvents[0].timestamp;
|
|
str = cloudwatchLogsDecodedData.logEvents[0].message;
|
|
str = cloudwatchLogsDecodedData.logEvents[0].extractedFields!['example'];
|
|
|
|
/* ClientContext */
|
|
clientContextClient = clientCtx.client;
|
|
anyObj = clientCtx.Custom;
|
|
clientContextEnv = clientCtx.env;
|
|
|
|
/* ClientContextEnv */
|
|
str = clientContextEnv.locale;
|
|
str = clientContextEnv.make;
|
|
str = clientContextEnv.model;
|
|
str = clientContextEnv.platform;
|
|
str = clientContextEnv.platformVersion;
|
|
|
|
/* ClientContextClient */
|
|
str = clientContextClient.appPackageName;
|
|
str = clientContextClient.appTitle;
|
|
str = clientContextClient.appVersionCode;
|
|
str = clientContextClient.appVersionName;
|
|
str = clientContextClient.installationId;
|
|
|
|
/* Callback */
|
|
function callback(cb: AWSLambda.Callback) {
|
|
cb();
|
|
cb(null);
|
|
cb(error);
|
|
cb(str); // https://docs.aws.amazon.com/apigateway/latest/developerguide/handle-errors-in-lambda-integration.html
|
|
cb(null, anyObj);
|
|
cb(null, bool);
|
|
cb(null, str);
|
|
cb(null, num);
|
|
}
|
|
|
|
/* Proxy Callback */
|
|
function proxyCallback(cb: AWSLambda.ProxyCallback) {
|
|
cb();
|
|
cb(null);
|
|
cb(error);
|
|
cb(null, proxyResult);
|
|
}
|
|
|
|
/* CustomAuthorizerCallback */
|
|
function customAuthorizerCallback(cb: AWSLambda.CustomAuthorizerCallback) {
|
|
cb();
|
|
cb(null);
|
|
cb(error);
|
|
cb(null, authResponse);
|
|
}
|
|
|
|
/* CodePipeline events https://docs.aws.amazon.com/codepipeline/latest/userguide/actions-invoke-lambda-function.html#actions-invoke-lambda-function-json-event-example */
|
|
const CodePipelineEvent: AWSLambda.CodePipelineEvent = {
|
|
'CodePipeline.job': {
|
|
id: '11111111-abcd-1111-abcd-111111abcdef',
|
|
accountId: '111111111111',
|
|
data: {
|
|
actionConfiguration: {
|
|
configuration: {
|
|
FunctionName: 'MyLambdaFunctionForAWSCodePipeline',
|
|
UserParameters: 'some-input-such-as-a-URL',
|
|
},
|
|
},
|
|
inputArtifacts: [
|
|
{
|
|
location: {
|
|
s3Location: {
|
|
bucketName:
|
|
'the name of the bucket configured as the pipeline artifact store in Amazon S3, for example codepipeline-us-east-2-1234567890',
|
|
objectKey: 'the name of the application, for example CodePipelineDemoApplication.zip',
|
|
},
|
|
type: 'S3',
|
|
},
|
|
revision: null,
|
|
name: 'ArtifactName',
|
|
},
|
|
],
|
|
outputArtifacts: [],
|
|
artifactCredentials: {
|
|
secretAccessKey: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
|
|
sessionToken: `MIICiTCCAfICCQD6m7oRw0uXOjANBgkqhkiG9w
|
|
0BAQUFADCBiDELMAkGA1UEBhMCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZ
|
|
WF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIw
|
|
EAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5
|
|
jb20wHhcNMTEwNDI1MjA0NTIxWhcNMTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBh
|
|
MCVVMxCzAJBgNVBAgTAldBMRAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBb
|
|
WF6b24xFDASBgNVBAsTC0lBTSBDb25zb2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMx
|
|
HzAdBgkqhkiG9w0BCQEWEG5vb25lQGFtYXpvbi5jb20wgZ8wDQYJKoZIhvcNAQE
|
|
BBQADgY0AMIGJAoGBAMaK0dn+a4GmWIWJ21uUSfwfEvySWtC2XADZ4nB+BLYgVI
|
|
k60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9TrDHudUZg3qX4waLG5M43q7Wgc/MbQ
|
|
ITxOUSQv7c7ugFFDzQGBzZswY6786m86gpEIbb3OhjZnzcvQAaRHhdlQWIMm2nr
|
|
AgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4nUhVVxYUntneD9+h8Mg9q6q+auN
|
|
KyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0FkbFFBjvSfpJIlJ00zbhNYS5f6Guo
|
|
EDmFJl0ZxBHjJnyp378OD8uTs7fLvjx79LjSTbNYiytVbZPQUQ5Yaxu2jXnimvw
|
|
3rrszlaEXAMPLE=`,
|
|
accessKeyId: 'AKIAIOSFODNN7EXAMPLE',
|
|
},
|
|
continuationToken: 'A continuation token if continuing job',
|
|
},
|
|
},
|
|
};
|
|
|
|
CodePipelineEvent['CodePipeline.job'].data.encryptionKey = { type: 'KMS', id: 'key' };
|
|
|
|
/* CodePipeline CloudWatch Events
|
|
* see https://docs.aws.amazon.com/codepipeline/latest/userguide/detect-state-changes-cloudwatch-events.html
|
|
* Their documentation says that detail.version is a string, but it is actually an integer
|
|
*/
|
|
const CodePipelineCloudWatchEvent: AWSLambda.CodePipelineCloudWatchEvent = {
|
|
version: '0',
|
|
id: 'event_Id',
|
|
'detail-type': 'CodePipeline Pipeline Execution State Change',
|
|
source: 'aws.codepipeline',
|
|
account: 'Pipeline_Account',
|
|
time: 'TimeStamp',
|
|
region: 'us-east-1',
|
|
resources: ['arn:aws:codepipeline:us-east-1:account_ID:myPipeline'],
|
|
detail: {
|
|
pipeline: 'myPipeline',
|
|
version: 1,
|
|
state: 'STARTED',
|
|
'execution-id': 'execution_Id',
|
|
},
|
|
};
|
|
|
|
/* CloudFront events, see http://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/lambda-event-structure.html */
|
|
const CloudFrontRequestWithCustomOriginEvent: AWSLambda.CloudFrontRequestEvent = {
|
|
Records: [
|
|
{
|
|
cf: {
|
|
config: {
|
|
distributionDomainName: 'd123.cloudfront.net',
|
|
distributionId: 'EDFDVBD6EXAMPLE',
|
|
eventType: 'viewer-request',
|
|
requestId: 'MRVMF7KydIvxMWfJIglgwHQwZsbG2IhRJ07sn9AkKUFSHS9EXAMPLE==',
|
|
},
|
|
request: {
|
|
body: {
|
|
action: 'read-only',
|
|
data: 'eyJ1c2VybmFtZSI6IkxhbWJkYUBFZGdlIiwiY29tbWVudCI6IlRoaXMgaXMgcmVxdWVzdCBib2R5In0=',
|
|
encoding: 'base64',
|
|
inputTruncated: false,
|
|
},
|
|
clientIp: '2001:0db8:85a3:0:0:8a2e:0370:7334',
|
|
querystring: 'size=large',
|
|
uri: '/picture.jpg',
|
|
method: 'GET',
|
|
headers: {
|
|
host: [
|
|
{
|
|
key: 'Host',
|
|
value: 'd111111abcdef8.cloudfront.net',
|
|
},
|
|
],
|
|
'user-agent': [
|
|
{
|
|
key: 'User-Agent',
|
|
value: 'curl/7.51.0',
|
|
},
|
|
],
|
|
},
|
|
origin: {
|
|
custom: {
|
|
customHeaders: {
|
|
'my-origin-custom-header': [
|
|
{
|
|
key: 'My-Origin-Custom-Header',
|
|
value: 'Test',
|
|
},
|
|
],
|
|
},
|
|
domainName: 'example.com',
|
|
keepaliveTimeout: 5,
|
|
path: '/custom_path',
|
|
port: 443,
|
|
protocol: 'https',
|
|
readTimeout: 5,
|
|
sslProtocols: ['TLSv1', 'TLSv1.1'],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
};
|
|
|
|
const CloudFrontRequestWithS3OriginEvent: AWSLambda.CloudFrontRequestEvent = {
|
|
Records: [
|
|
{
|
|
cf: {
|
|
config: {
|
|
distributionDomainName: 'd123.cloudfront.net',
|
|
distributionId: 'EDFDVBD6EXAMPLE',
|
|
eventType: 'viewer-request',
|
|
requestId: 'MRVMF7KydIvxMWfJIglgwHQwZsbG2IhRJ07sn9AkKUFSHS9EXAMPLE==',
|
|
},
|
|
request: {
|
|
body: {
|
|
action: 'read-only',
|
|
data: 'eyJ1c2VybmFtZSI6IkxhbWJkYUBFZGdlIiwiY29tbWVudCI6IlRoaXMgaXMgcmVxdWVzdCBib2R5In0=',
|
|
encoding: 'base64',
|
|
inputTruncated: false,
|
|
},
|
|
clientIp: '2001:0db8:85a3:0:0:8a2e:0370:7334',
|
|
querystring: 'size=large',
|
|
uri: '/picture.jpg',
|
|
method: 'GET',
|
|
headers: {
|
|
host: [
|
|
{
|
|
key: 'Host',
|
|
value: 'd111111abcdef8.cloudfront.net',
|
|
},
|
|
],
|
|
'user-agent': [
|
|
{
|
|
key: 'User-Agent',
|
|
value: 'curl/7.51.0',
|
|
},
|
|
],
|
|
},
|
|
origin: {
|
|
s3: {
|
|
authMethod: 'origin-access-identity',
|
|
customHeaders: {
|
|
'my-origin-custom-header': [
|
|
{
|
|
key: 'My-Origin-Custom-Header',
|
|
value: 'Test',
|
|
},
|
|
],
|
|
},
|
|
domainName: 'my-bucket.s3.amazonaws.com',
|
|
path: '/s3_path',
|
|
region: 'us-east-1',
|
|
},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
};
|
|
|
|
const CloudFrontResponseEvent: AWSLambda.CloudFrontResponseEvent = {
|
|
Records: [
|
|
{
|
|
cf: {
|
|
config: {
|
|
distributionDomainName: 'd123.cloudfront.net',
|
|
distributionId: 'EDFDVBD6EXAMPLE',
|
|
eventType: 'viewer-response',
|
|
requestId: 'xGN7KWpVEmB9Dp7ctcVFQC4E-nrcOcEKS3QyAez--06dV7TEXAMPLE==',
|
|
},
|
|
request: {
|
|
clientIp: '2001:0db8:85a3:0:0:8a2e:0370:7334',
|
|
method: 'GET',
|
|
uri: '/picture.jpg',
|
|
querystring: 'size=large',
|
|
headers: {
|
|
host: [
|
|
{
|
|
key: 'Host',
|
|
value: 'd111111abcdef8.cloudfront.net',
|
|
},
|
|
],
|
|
'user-agent': [
|
|
{
|
|
key: 'User-Agent',
|
|
value: 'curl/7.18.1',
|
|
},
|
|
],
|
|
},
|
|
},
|
|
response: {
|
|
status: '200',
|
|
statusDescription: 'OK',
|
|
headers: {
|
|
server: [
|
|
{
|
|
key: 'Server',
|
|
value: 'MyCustomOrigin',
|
|
},
|
|
],
|
|
'set-cookie': [
|
|
{
|
|
key: 'Set-Cookie',
|
|
value: 'theme=light',
|
|
},
|
|
{
|
|
key: 'Set-Cookie',
|
|
value: 'sessionToken=abc123; Expires=Wed, 09 Jun 2021 10:18:14 GMT',
|
|
},
|
|
],
|
|
},
|
|
},
|
|
},
|
|
},
|
|
],
|
|
};
|
|
|
|
/* Kinesis Data Stream Events */
|
|
declare let kinesisStreamEvent: AWSLambda.KinesisStreamEvent;
|
|
declare let kinesisStreamRecord: AWSLambda.KinesisStreamRecord;
|
|
declare let kinesisStreamRecordPayload: AWSLambda.KinesisStreamRecordPayload;
|
|
|
|
kinesisStreamRecord = kinesisStreamEvent.Records[0];
|
|
|
|
str = kinesisStreamRecord.awsRegion;
|
|
str = kinesisStreamRecord.eventID;
|
|
str = kinesisStreamRecord.eventName;
|
|
str = kinesisStreamRecord.eventSource;
|
|
str = kinesisStreamRecord.eventSourceARN;
|
|
str = kinesisStreamRecord.eventVersion;
|
|
str = kinesisStreamRecord.invokeIdentityArn;
|
|
kinesisStreamRecordPayload = kinesisStreamRecord.kinesis;
|
|
|
|
num = kinesisStreamRecordPayload.approximateArrivalTimestamp;
|
|
str = kinesisStreamRecordPayload.data;
|
|
str = kinesisStreamRecordPayload.kinesisSchemaVersion;
|
|
str = kinesisStreamRecordPayload.partitionKey;
|
|
str = kinesisStreamRecordPayload.sequenceNumber;
|
|
|
|
/* Compatibility functions */
|
|
context.done();
|
|
context.done(error);
|
|
context.done(error, anyObj);
|
|
context.succeed(str);
|
|
context.succeed(anyObj);
|
|
context.succeed(str, anyObj);
|
|
context.fail(error);
|
|
context.fail(str);
|
|
|
|
/* Handler */
|
|
const handler: AWSLambda.Handler = (event: any, context: AWSLambda.Context, cb: AWSLambda.Callback) => {};
|
|
|
|
/* In node8.10 runtime, handlers may return a promise for the result value, so existing async
|
|
* handlers that return Promise<void> before calling the callback will now have a `null` result.
|
|
* Be safe and make that badly typed with a major verson bump to 8.10 so users expect the breaking change,
|
|
* since the upgrade effort should be pretty low in most cases, and it points them at a nicer solution.
|
|
*/
|
|
// $ExpectError
|
|
const legacyAsyncHandler: AWSLambda.APIGatewayProxyHandler = async (
|
|
event: AWSLambda.APIGatewayProxyEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<AWSLambda.APIGatewayProxyResult>,
|
|
) => {
|
|
cb(null, { statusCode: 200, body: 'No longer valid' });
|
|
};
|
|
|
|
const node8AsyncHandler: AWSLambda.APIGatewayProxyHandler = async (
|
|
event: AWSLambda.APIGatewayProxyEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<AWSLambda.APIGatewayProxyResult>,
|
|
) => {
|
|
return { statusCode: 200, body: 'Is now valid!' };
|
|
};
|
|
|
|
const inferredHandler: AWSLambda.S3Handler = (event, context, cb) => {
|
|
// $ExpectType S3Event
|
|
event;
|
|
str = event.Records[0].eventName;
|
|
// $ExpectType Context
|
|
context;
|
|
str = context.functionName;
|
|
// $ExpectType Callback<void>
|
|
cb;
|
|
cb();
|
|
cb(null);
|
|
cb(new Error());
|
|
// $ExpectError
|
|
cb(null, {});
|
|
};
|
|
|
|
// Test using default Callback type still works.
|
|
const defaultCallbackHandler: AWSLambda.APIGatewayProxyHandler = (
|
|
event: AWSLambda.APIGatewayEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback,
|
|
) => {};
|
|
|
|
const albSyncHandler: AWSLambda.ALBHandler = (
|
|
event: AWSLambda.ALBEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.ALBCallback,
|
|
) => {
|
|
cb(null, {
|
|
statusCode: 200,
|
|
statusDescription: '200 OK',
|
|
headers: {},
|
|
body: '',
|
|
isBase64Encoded: false,
|
|
});
|
|
};
|
|
const albAsyncHandler: AWSLambda.ALBHandler = async (
|
|
event: AWSLambda.ALBEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.ALBCallback,
|
|
) => {
|
|
return {
|
|
statusCode: 200,
|
|
statusDescription: '200 OK',
|
|
headers: {},
|
|
body: '',
|
|
isBase64Encoded: false,
|
|
};
|
|
};
|
|
|
|
// Specific types
|
|
let s3Handler: AWSLambda.S3Handler = (
|
|
event: AWSLambda.S3Event,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
// Test old name
|
|
const s3CreateHandler: AWSLambda.S3Handler = (
|
|
event: AWSLambda.S3CreateEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
s3Handler = s3CreateHandler;
|
|
|
|
const dynamoDBStreamHandler: AWSLambda.DynamoDBStreamHandler = (
|
|
event: AWSLambda.DynamoDBStreamEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
const snsHandler: AWSLambda.SNSHandler = (
|
|
event: AWSLambda.SNSEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
const cognitoUserPoolHandler: AWSLambda.CognitoUserPoolTriggerHandler = (
|
|
event: AWSLambda.CognitoUserPoolEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
const cloudFormationCustomResourceHandler: AWSLambda.CloudFormationCustomResourceHandler = (
|
|
event: AWSLambda.CloudFormationCustomResourceEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
const cloudWatchLogsHandler: AWSLambda.CloudWatchLogsHandler = (
|
|
event: AWSLambda.CloudWatchLogsEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
const scheduledHandler: AWSLambda.ScheduledHandler = (
|
|
event: AWSLambda.ScheduledEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
let apiGtwProxyHandler: AWSLambda.APIGatewayProxyHandler = (
|
|
event: AWSLambda.APIGatewayProxyEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.APIGatewayProxyCallback,
|
|
) => {};
|
|
// Test old names
|
|
const proxyHandler: AWSLambda.ProxyHandler = (
|
|
event: AWSLambda.APIGatewayEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.ProxyCallback,
|
|
) => {};
|
|
apiGtwProxyHandler = proxyHandler;
|
|
|
|
const codePipelineHandler: AWSLambda.CodePipelineHandler = (
|
|
event: AWSLambda.CodePipelineEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
const cloudFrontRequestHandler: AWSLambda.CloudFrontRequestHandler = (
|
|
event: AWSLambda.CloudFrontRequestEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.CloudFrontRequestCallback,
|
|
) => {
|
|
event = CloudFrontRequestWithCustomOriginEvent;
|
|
// $ExpectType CloudFrontRequestEvent
|
|
event;
|
|
let request = event.Records[0].cf.request;
|
|
|
|
let s3Origin: AWSLambda.CloudFrontS3Origin = {
|
|
authMethod: 'none',
|
|
customHeaders: {},
|
|
domainName: 'example.com',
|
|
path: '/',
|
|
region: 'us-east-1',
|
|
};
|
|
|
|
if (request.origin && request.origin.custom) {
|
|
request.origin.custom.domainName;
|
|
request.origin.custom.domainName = 'example2.com';
|
|
|
|
// $ExpectError
|
|
s3Origin = request.origin.s3;
|
|
|
|
// $ExpectError
|
|
request.origin.s3.path = '/';
|
|
}
|
|
|
|
let customOrigin: AWSLambda.CloudFrontCustomOrigin = {
|
|
customHeaders: {},
|
|
domainName: 'example.com',
|
|
keepaliveTimeout: 60,
|
|
path: '/',
|
|
port: 80,
|
|
protocol: 'http',
|
|
readTimeout: 30,
|
|
sslProtocols: [],
|
|
};
|
|
|
|
event = CloudFrontRequestWithS3OriginEvent;
|
|
// $ExpectType CloudFrontRequestEvent
|
|
event;
|
|
request = event.Records[0].cf.request;
|
|
if (request.origin && request.origin.s3) {
|
|
request.origin.s3.path;
|
|
request.origin.s3.path = '/new_path';
|
|
|
|
// $ExpectError
|
|
customOrigin = request.origin.custom;
|
|
|
|
// $ExpectError
|
|
request.origin.custom.path = '/';
|
|
}
|
|
|
|
cb();
|
|
cb(null);
|
|
cb(new Error(''));
|
|
cb(null, { clientIp: str, method: str, uri: str, querystring: str, headers: {} });
|
|
cb(null, { status: str });
|
|
// $ExpectError
|
|
cb(null, {});
|
|
};
|
|
|
|
const cloudFrontResponseHandler: AWSLambda.CloudFrontResponseHandler = (
|
|
event: AWSLambda.CloudFrontResponseEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.CloudFrontResponseCallback,
|
|
) => {};
|
|
|
|
const cloudFrontHeaders: AWSLambda.CloudFrontHeaders = {
|
|
'content-type': [{ value: 'text/plain' }],
|
|
'x-foo-bar': [{ key: 'X-Foo-Bar', value: 'example' }],
|
|
};
|
|
|
|
const customAuthorizerHandler: AWSLambda.CustomAuthorizerHandler = (
|
|
event: AWSLambda.CustomAuthorizerEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.CustomAuthorizerCallback,
|
|
) => {};
|
|
|
|
interface CustomEvent {
|
|
eventString: string;
|
|
eventBool: boolean;
|
|
}
|
|
interface CustomResult {
|
|
resultString: string;
|
|
resultBool?: boolean;
|
|
}
|
|
type CustomCallback = AWSLambda.Callback<CustomResult>;
|
|
const customHandler: AWSLambda.Handler<CustomEvent, CustomResult> = (event, context, cb) => {
|
|
// $ExpectType CustomEvent
|
|
event;
|
|
str = event.eventString;
|
|
bool = event.eventBool;
|
|
// $ExpectType Context
|
|
context;
|
|
// $ExpectType Callback<CustomResult>
|
|
cb;
|
|
cb(null, { resultString: str, resultBool: bool });
|
|
// $ExpectError
|
|
cb(null, { resultString: bool });
|
|
};
|
|
|
|
const kinesisStreamHandler: AWSLambda.KinesisStreamHandler = (
|
|
event: AWSLambda.KinesisStreamEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
const SQSMessageHandler: AWSLambda.SQSHandler = (
|
|
event: AWSLambda.SQSEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {};
|
|
|
|
// See https://docs.aws.amazon.com/lambda/latest/dg/eventsources.html#eventsources-sqs
|
|
const SQSEvent: AWSLambda.SQSEvent = {
|
|
Records: [
|
|
{
|
|
messageId: 'c80e8021-a70a-42c7-a470-796e1186f753',
|
|
receiptHandle: 'AQEBJQ+/u6NsnT5t8Q/VbVxgdUl4TMKZ5FqhksRdIQvLBhwNvADoBxYSOVeCBXdnS9P+',
|
|
body: '{"foo":"bar"}',
|
|
attributes: {
|
|
ApproximateReceiveCount: '3',
|
|
SentTimestamp: '1529104986221',
|
|
SenderId: '594035263019',
|
|
ApproximateFirstReceiveTimestamp: '1529104986230',
|
|
},
|
|
messageAttributes: {
|
|
testAttr: {
|
|
stringValue: '100',
|
|
binaryValue: 'base64Str',
|
|
stringListValues: [],
|
|
binaryListValues: [],
|
|
dataType: 'Number',
|
|
},
|
|
},
|
|
md5OfBody: '9bb58f26192e4ba00f01e2e7b136bbd8',
|
|
eventSource: 'aws:sqs',
|
|
eventSourceARN: 'arn:aws:sqs:us-west-2:594035263019:NOTFIFOQUEUE',
|
|
awsRegion: 'us-west-2',
|
|
},
|
|
],
|
|
};
|
|
|
|
const SQSMessageLegacyAsyncHandler: AWSLambda.SQSHandler = async (
|
|
event: AWSLambda.SQSEvent,
|
|
context: AWSLambda.Context,
|
|
cb: AWSLambda.Callback<void>,
|
|
) => {
|
|
// $ExpectType SQSEvent
|
|
event;
|
|
str = event.Records[0].messageId;
|
|
anyObj = event.Records[0].body;
|
|
// $ExpectType Context
|
|
context;
|
|
str = context.functionName;
|
|
// $ExpectType Callback<void>
|
|
cb;
|
|
cb();
|
|
cb(null);
|
|
cb(new Error());
|
|
};
|
|
|
|
const SQSMessageNode8AsyncHandler: AWSLambda.SQSHandler = async (
|
|
event: AWSLambda.SQSEvent,
|
|
context: AWSLambda.Context,
|
|
) => {
|
|
// $ExpectType SQSEvent
|
|
event;
|
|
str = event.Records[0].messageId;
|
|
anyObj = event.Records[0].body;
|
|
strOrUndefined = event.Records[0].messageAttributes.testAttr.stringValue;
|
|
strOrUndefined = event.Records[0].messageAttributes.testAttr.binaryValue;
|
|
str = event.Records[0].messageAttributes.testAttr.dataType;
|
|
|
|
// $ExpectType Context
|
|
context;
|
|
str = context.functionName;
|
|
return;
|
|
};
|
|
|
|
const firehoseEventHandler: AWSLambda.FirehoseTransformationHandler = (
|
|
event: AWSLambda.FirehoseTransformationEvent,
|
|
context: AWSLambda.Context,
|
|
callback: AWSLambda.FirehoseTransformationCallback,
|
|
) => {
|
|
// $ExpectType FirehoseTransformationEvent
|
|
event;
|
|
str = event.records[0].recordId;
|
|
|
|
// $ExpectType Context
|
|
context;
|
|
str = context.functionName;
|
|
callback(null, {
|
|
records: [
|
|
{
|
|
recordId: event.records[0].recordId,
|
|
result: 'Ok' as AWSLambda.FirehoseRecordTransformationStatus,
|
|
data: 'eyJmb28iOiJiYXIifQ==',
|
|
},
|
|
],
|
|
});
|
|
};
|
|
|
|
declare let lexEvent: AWSLambda.LexEvent;
|
|
lexEvent = {
|
|
currentIntent: {
|
|
name: 'intent-name',
|
|
slots: {
|
|
slot1: null,
|
|
slot2: 'value2',
|
|
},
|
|
slotDetails: {
|
|
slot1: {
|
|
resolutions: [{ value: 'value1' }],
|
|
originalValue: 'originalValue',
|
|
},
|
|
},
|
|
confirmationStatus: 'None',
|
|
},
|
|
bot: {
|
|
name: 'bot name',
|
|
alias: 'bot alias',
|
|
version: 'bot version',
|
|
},
|
|
userId: 'User ID specified in the POST request to Amazon Lex.',
|
|
inputTranscript: 'Text used to process the request',
|
|
invocationSource: 'FulfillmentCodeHook',
|
|
outputDialogMode: 'Text',
|
|
messageVersion: '1.0',
|
|
sessionAttributes: {
|
|
key1: 'value1',
|
|
key2: 'value2',
|
|
},
|
|
requestAttributes: {
|
|
key1: 'value1',
|
|
key2: 'value2',
|
|
},
|
|
};
|
|
|
|
declare let lexResult: AWSLambda.LexResult;
|
|
declare let lexDialogAction: AWSLambda.LexDialogAction;
|
|
declare let lexDialogActionBase: AWSLambda.LexDialogActionBase;
|
|
declare let lexDialogActionClose: AWSLambda.LexDialogActionClose;
|
|
declare let lexDialogActionConfirmIntent: AWSLambda.LexDialogActionConfirmIntent;
|
|
declare let lexDialogActionDelegate: AWSLambda.LexDialogActionDelegate;
|
|
declare let lexDialogActionElicitIntent: AWSLambda.LexDialogActionElicitIntent;
|
|
declare let lexDialogActionElicitSlot: AWSLambda.LexDialogActionElicitSlot;
|
|
declare let lexGenericAttachment: AWSLambda.LexGenericAttachment;
|
|
|
|
lexResult = {
|
|
sessionAttributes: {
|
|
attrib1: 'Value One',
|
|
},
|
|
dialogAction: {
|
|
type: 'Close',
|
|
fulfillmentState: 'Failed',
|
|
},
|
|
};
|
|
|
|
str = lexGenericAttachment.title;
|
|
str = lexGenericAttachment.subTitle;
|
|
str = lexGenericAttachment.imageUrl;
|
|
str = lexGenericAttachment.attachmentLinkUrl;
|
|
str = lexGenericAttachment.buttons[0].text;
|
|
str = lexGenericAttachment.buttons[0].value;
|
|
|
|
lexDialogAction.type === 'Close';
|
|
lexDialogAction.type === 'ConfirmIntent';
|
|
lexDialogAction.type === 'Delegate';
|
|
lexDialogAction.type === 'ElicitIntent';
|
|
lexDialogAction.type === 'ElicitSlot';
|
|
|
|
lexDialogActionBase.message!.contentType === 'CustomPayload';
|
|
lexDialogActionBase.message!.contentType === 'PlainText';
|
|
lexDialogActionBase.message!.contentType === 'SSML';
|
|
str = lexDialogActionBase.message!.content;
|
|
num = lexDialogActionBase.responseCard!.version;
|
|
lexDialogActionBase.responseCard!.contentType === 'application/vnd.amazonaws.card.generic';
|
|
// $ExpectType LexGenericAttachment
|
|
lexDialogActionBase.responseCard!.genericAttachments[0];
|
|
|
|
lexDialogActionClose.type === 'Close';
|
|
lexDialogActionClose.fulfillmentState === 'Failed';
|
|
lexDialogActionClose.fulfillmentState === 'Fulfilled';
|
|
|
|
lexDialogActionConfirmIntent.type === 'ConfirmIntent';
|
|
str = lexDialogActionConfirmIntent.intentName;
|
|
strOrNull = lexDialogActionConfirmIntent.slots['example'];
|
|
|
|
lexDialogActionDelegate.type === 'Delegate';
|
|
strOrNull = lexDialogActionDelegate.slots['example'];
|
|
|
|
lexDialogActionElicitIntent.type === 'ElicitIntent';
|
|
lexDialogActionElicitSlot.type === 'ElicitSlot';
|
|
strOrNull = lexDialogActionElicitSlot.slots['example'];
|
|
str = lexDialogActionElicitSlot.slotToElicit;
|
|
str = lexDialogActionElicitSlot.intentName;
|
|
|
|
const lexEventHandler: AWSLambda.LexHandler = async (event: AWSLambda.LexEvent, context: AWSLambda.Context) => {
|
|
// $ExpectType LexEvent
|
|
event;
|
|
|
|
// $ExpectType Context
|
|
context;
|
|
str = context.functionName;
|
|
return lexResult;
|
|
};
|
|
|
|
/**
|
|
* S3 Batch Operations event
|
|
* https://docs.aws.amazon.com/AmazonS3/latest/dev/batch-ops-invoke-lambda.html
|
|
*/
|
|
const S3BatchEvent: AWSLambda.S3BatchEvent = {
|
|
invocationSchemaVersion: '1.0',
|
|
invocationId: 'foo_invocation_id',
|
|
job: { id: 'foo_job_id' },
|
|
tasks: [
|
|
{
|
|
taskId: '11111',
|
|
s3Key: 'example.json',
|
|
s3BucketArn: 'arn:aws:s3:::foo-bucket',
|
|
s3VersionId: null,
|
|
},
|
|
{
|
|
taskId: '11111',
|
|
s3Key: 'example.json',
|
|
s3BucketArn: 'arn:aws:s3:::foo-bucket',
|
|
s3VersionId: 'asdf',
|
|
},
|
|
],
|
|
};
|
|
|
|
const S3BatchResult: AWSLambda.S3BatchResult = {
|
|
invocationSchemaVersion: '1.0',
|
|
treatMissingKeysAs: 'PermanentFailure',
|
|
invocationId: 'foo_invocation_id',
|
|
results: [
|
|
{
|
|
taskId: '11111',
|
|
resultCode: 'Succeeded',
|
|
resultString: 'foo',
|
|
},
|
|
{
|
|
taskId: '22222',
|
|
resultCode: 'TemporaryFailure',
|
|
resultString: 'Error: failure',
|
|
},
|
|
{
|
|
taskId: '33333',
|
|
resultCode: 'PermanentFailure',
|
|
resultString: 'Error: failure',
|
|
},
|
|
],
|
|
};
|
|
|
|
const S3BatchHandler: AWSLambda.S3BatchHandler = async (event: AWSLambda.S3BatchEvent, context: AWSLambda.Context) => {
|
|
// $ExpectType S3BatchEvent
|
|
event;
|
|
|
|
// $ExpectType Context
|
|
context;
|
|
str = context.functionName;
|
|
return S3BatchResult;
|
|
};
|