Node.js - Amazon Web Services SDK support for TypeScript

import * as AWS from 'aws-sdk'
// Set region

function my_invoke(){
  AWS.config.update({region: 'REGION'});
  var lambda = new AWS.Lambda();
  var params = {
    FunctionName: 'mylambda', /* required */
    //...
  };

  lambda.invoke(params, function(err, data) {
    //...
  });
}

import {CreateTopicCommand, SNSClient, SubscribeCommand, PublishCommand } from "@aws-sdk/client-sns";

const REGION = "REGION"; //e.g. "us-east-1"
// Create SNS service object.
const snsClient = new SNSClient({ region: REGION });

function my_subscribe(protocol, topic_arn, endpoint){
  const params = {
    Protocol: protocol,
    TopicArn: topic_arn, //TOPIC_ARN
    Endpoint: endpoint,
  };
  const data = await snsClient.send(new SubscribeCommand(params));
};

function subcribe_to_foo_topic(){
   const topic_arn = 'arn:aws:sns:us-east-2:123456789012:foo_topic';
   my_subscribe("email", topic_arn, "EMAIL_ADDRESS")
   my_subscribe("sms", topic_arn, "007")
   my_subscribe("lambda", topic_arn, "fooarn:function:lambda_name:v2")
   my_subscribe("sqs", topic_arn, "https://sqs.us-east-2.amazonaws.com/123456789012/foo_queue")

   my_subscribe("http", topic_arn, "http://foourl")
}

function publish_to_foo_topic(){
  const params = {
      Message: "MESSAGE_TEXT", // MESSAGE_TEXT
      TopicArn: 'arn:aws:sns:us-east-2:123456789012:foo_topic'
  };
  const data = await snsClient.send(new PublishCommand(params));
}

// Load the AWS SDK for Node.js
import * as AWS from 'aws-sdk'
// Set the region
AWS.config.update({region: 'REGION'});

// Create S3 service object
s3 = new AWS.S3({apiVersion: '2006-03-01'});

// Create the parameters for calling createBucket
var bucketParams = {
  Bucket : "MyBucket",
  ACL : 'public-read'
};

// call S3 to create the bucket
s3.createBucket(bucketParams, function(err, data) {
  if (err) {
    console.log("Error", err);
  } else {
    console.log("Success", data.Location);
  }
});

params = {
    // ...
    Bucket: "MyBucket"
};
s3.putObject(params, function(err, data) {
    if (err) console.log(err, err.stack); // an error occurred
    else     console.log(data);           // successful response
});

import * as AWS from "aws-sdk";
AWS.config.update({ region: 'REGION' });

const sqs = new AWS.SQS({apiVersion: '2012-11-05'});

const queueUrl = "SQS_QUEUE_URL"

const params = {
    MessageBody: "This is a message",
    QueueUrl: queueUrl,
    MaxNumberOfMessages: 1,
    VisibilityTimeout: 0,
};

class Foo {
  sendMessage(){
    sqs.sendMessage(params, function (err, data) {
        if (err) {
            console.log("Error", err);
        } else {
         console.log("Success", data.MessageId);
        }
    });
 }
}

import * as AWS from "aws-sdk";
AWS.config.update({ region: 'REGION' });

const sqs = new AWS.SQS({apiVersion: '2012-11-05'});

const queueUrl = "SQS_QUEUE_URL"

const params = {
    QueueUrl: queueUrl,
    MaxNumberOfMessages: 1,
    VisibilityTimeout: 0,
};

export class SqsReciver {
    constructor() {
        this.reciver();
    }
    private reciver(): void {
        sqs.receiveMessage(params, (err, data) => {
    // do something
        });
    }
}

import AWSXRay from 'aws-xray-sdk-core'
import AWS from 'aws-sdk'
const AWS = AWSXRay.captureAWS(AWS) // Encapsulate AWS SDK
const DDB = new AWS.DynamoDB({ apiVersion: "2012-10-08" }) // use AWS as usual
const { v1: uuidv1 } = require('uuid');

// environment variables
const { TABLE_NAME, ENDPOINT_OVERRIDE, REGION } = process.env
const options = { region: REGION }
AWS.config.update({ region: REGION })

if (ENDPOINT_OVERRIDE !== "") {
    options.endpoint = ENDPOINT_OVERRIDE
}

const docClient = new AWS.DynamoDB.DocumentClient(options)
// response helper
const response = (statusCode, body, additionalHeaders) => ({
    statusCode,
    body: JSON.stringify(body),
    headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*', ...additionalHeaders },
})

function addRecord(event) {
    let usernameField = {
        "cognito-username": getCognitoUsername(event)
    }

    // auto generated date fields
    let d = new Date()
    let dISO = d.toISOString()
    let auto_fields = {
        "id": uuidv1(),
        "creation_date": dISO,
        "lastupdate_date": dISO
    }

    //merge the json objects
    let item_body = {...usernameField, ...auto_fields, ...JSON.parse(event.body) }

    console.log(item_body);

    //final params to DynamoDB
    const params = {
        TableName: TABLE_NAME,
        Item: item_body
    }

    return docClient.put(params)
}

import * as AWS from 'aws-sdk';

const REGION = "us-east-1";
const kinesis = new AWS.Kinesis({ region: REGION });

const streamName = "data-stream-v2";

function putRecordFunction(): void {
  const params = {
    StreamName: streamName,
    Data: JSON.stringify({ message: "test data" }),
    PartitionKey: "partition1"
  };

  kinesis.putRecord(params, (err: any, data: any) => {
    if (err) console.error(err);
    else console.log(data);
  });
}

const getRecordsFunction = async (): Promise<void> => {
  const iteratorParams = {
    StreamName: streamName,
    ShardId: "shardId-000000000000",
    ShardIteratorType: "LATEST"
  };
  const iteratorData = await kinesis.getShardIterator(iteratorParams).promise();
  const recordsParams = {
    ShardIterator: iteratorData.ShardIterator
  };
  const data = await kinesis.getRecords(recordsParams).promise();
  console.log("Records", data.Records);
};

putRecordFunction();
getRecordsFunction();

import {
  KinesisClient,
  PutRecordCommand,
  GetShardIteratorCommand,
  GetRecordsCommand
} from "@aws-sdk/client-kinesis";

const REGION: string = "us-east-1";
const kinesisClient = new KinesisClient({ region: REGION });

const streamName = "data-stream-v3";

const putRecord = async (): Promise<void> => {
  const params = {
    StreamName: streamName,
    Data: new TextEncoder().encode(JSON.stringify({ message: "test data" })),
    PartitionKey: "partition1"
  };

  try {
    const data = await kinesisClient.send(new PutRecordCommand(params));
    console.log("Success", data.SequenceNumber);
  } catch (err) {
    console.error("Error", err);
  }
};

const getRecords = async (): Promise<void> => {
  try {
    const iteratorParams = {
      StreamName: streamName,
      ShardId: "shardId-000000000000",
      ShardIteratorType: "LATEST"
    };
    const iterator = await kinesisClient.send(new GetShardIteratorCommand(iteratorParams));
    const recordsParams = {
      ShardIterator: iterator.ShardIterator
    };

    const data = await kinesisClient.send(new GetRecordsCommand(recordsParams));
    console.log("Records", data.Records);
  } catch (err) {
    console.log("Error", err);
  }
};

putRecord();
getRecords();