google-auth.js

const AWS = require('aws-sdk');
AWS.config.update({ region: 'us-west-1' });

const jwtDecode = require('jwt-decode');
const util = require('./util.js');

const dynamodb = new AWS.DynamoDB.DocumentClient();
const cognitoidentity = new AWS.CognitoIdentity();
const tableName = process.env.NOTES_TABLE;
const identityPoolId = "us-west-1:87b938db-00c9-4f1d-b259-81316da59e17";

exports.handler = async (event) => {
    try {
        // Get the JWT token from the Authorization header of the HTTP request
        const id_token = util.getIdToken(event.headers);

        // Use the token to retrieve the user's IdentityId and credentials
        let params = {
            IdentityPoolId: identityPoolId,
            Logins: {
                "accounts.google.com": id_token
            }
        };

        // Below method is used to get the identity ID for the user based on the token
        let data = await cognitoidentity.getId(params).promise();

        params = {
            IdentityId: data.IdentityId,
            Logins: {
                "accounts.google.com": id_token
            }
        };

        //below method is used to get temporary credentials for the user.
        data = await cognitoidentity.getCredentialsForIdentity(params).promise();
        
        // Decode the JWT token to get the username
        const decoded = jwtDecode(id_token);
        const userName = decoded.name;

        // Check if the username is present in the query string parameters of the HTTP request
        if (event.queryStringParameters && event.queryStringParameters.username) {
            const username = event.queryStringParameters.username;

            // If the username in the query string matches the username in the JWT token, proceed with the request
            if (username === userName) {
                // Check the HTTP method of the request
                switch (event.httpMethod) {
                    // If it's a GET request, retrieve the user's notes
                    case 'GET':
                        const notes = await getNotes(username);
                        return {
                            statusCode: 200,
                            headers: util.getResponseHeaders(),
                            body: JSON.stringify(notes)
                        };
                    // If it's a POST request, create a new note for the user
                    case 'POST':
                        const note = JSON.parse(event.body);
                        await createNote(username, note);
                        return {
                            statusCode: 201,
                            headers: util.getResponseHeaders(),
                            body: JSON.stringify({
                                message: 'Note created successfully'
                            })
                        };
                    // If it's a PUT request, update an existing note for the user
                    case 'PUT':
                        const noteId = event.pathParameters.id;
                        const updatedNote = JSON.parse(event.body);
                        await updateNote(username, noteId, updatedNote);
                        return {
                            statusCode: 200,
                            headers: util.getResponseHeaders(),
                            body: JSON.stringify({
                                message: 'Note updated successfully'
                            })
                        };
                    // If it's a DELETE request, delete an existing note for the user
                    case 'DELETE':
                        const id = event.pathParameters.id;
                        await deleteNote(username, id);
                        return {
                            statusCode: 200,
                            headers: util.getResponseHeaders(),
                            body: JSON.stringify({
                                message: 'Note deleted successfully'
                            })
                        };
                    default:
                        return {
                            statusCode: 400,
                            headers: util.getResponseHeaders(),
                            body: JSON.stringify({
                                message: 'Unsupported HTTP method'
                            })
                        };
                }
            } else {
                return {
                    statusCode: 400,
                    headers: util.getResponseHeaders(),
                    body: JSON.stringify({
                        message: 'Missing username parameter'
                    })
                };
            }
        }
        } catch (err) {
            console.log("Error", err);
            return {
                statusCode: err.statusCode ? err.statusCode : 500,
                headers: util.getResponseHeaders(),
                body: JSON.stringify({
                    error: err.name ? err.name : "Exception",
                    message: err.message ? err.message : "Unknown error"
                })
            };
        }
    }