Forem: Anzhari Purnomo

Parse cookie information from AWS Lambda

Anzhari Purnomo — Sat, 30 Jul 2022 02:22:06 +0000

Recently I had a chance to work with a lot of AWS Lambda based service. I found out somehow there are not a lot of library to help extract the cookies out of lambda's request?

I ended up writing an NPM module for this issue:
https://www.npmjs.com/package/@anzp/aws-lambda-cookie

An example on how to use it:

API Gateway HTTP API Proxy Event

Consider this as your event:

{
  "version": "2.0",
  "routeKey": "$default",
  "rawPath": "/path/to/resource",
  "rawQueryString": "parameter1=value1&parameter1=value2&parameter2=value",
  "cookies": [
    "nevergonnagiveyouup",
    "nevergonna=bringyoudown; secure; httponly; samesite=strict; path=/; domain=.example.com; max-age=3600; expires=Mon, 01-Jan-2020 00:00:00 GMT; version=1; comment=something; commenturl=http://example.com/"
  ],
  "headers": {
    "Header1": "value1",
    "Header2": "value1,value2"
  },
  "queryStringParameters": {
    "parameter1": "value1,value2",
    "parameter2": "value"
  },
  "requestContext": {
    "accountId": "123456789012",
    "apiId": "api-id",
    "authentication": {
      "clientCert": {
        "clientCertPem": "CERT_CONTENT",
        "subjectDN": "www.example.com",
        "issuerDN": "Example issuer",
        "serialNumber": "a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1:a1",
        "validity": {
          "notBefore": "May 28 12:30:02 2019 GMT",
          "notAfter": "Aug  5 09:36:04 2021 GMT"
        }
      }
    },
    "authorizer": {
      "jwt": {
        "claims": {
          "claim1": "value1",
          "claim2": "value2"
        },
        "scopes": [
          "scope1",
          "scope2"
        ]
      }
    },
    "domainName": "id.execute-api.us-east-1.amazonaws.com",
    "domainPrefix": "id",
    "http": {
      "method": "POST",
      "path": "/path/to/resource",
      "protocol": "HTTP/1.1",
      "sourceIp": "192.168.0.1/32",
      "userAgent": "agent"
    },
    "requestId": "id",
    "routeKey": "$default",
    "stage": "$default",
    "time": "12/Mar/2020:19:03:58 +0000",
    "timeEpoch": 1583348638390
  },
  "body": "eyJ0ZXN0IjoiYm9keSJ9",
  "pathParameters": {
    "parameter1": "value1"
  },
  "isBase64Encoded": true,
  "stageVariables": {
    "stageVariable1": "value1",
    "stageVariable2": "value2"
  }
}

And this is your lambda code:

let response;
const {
  ApiGatewayHttpApiProxyEventHandler,
} = require("@anzp/aws-lambda-apig-cookie");
exports.lambdaHandler = async (event, context) => {
  try {
    const handler = new ApiGatewayHttpApiProxyEventHandler(event);
    const cookies = handler.getCookies();
    console.log({ cookies });
    response = {
      statusCode: 200,
      body: JSON.stringify({
        message: JSON.stringify(cookies),
        // location: ret.data.trim()
      }),
    };
  } catch (err) {
    console.log(err);
    return err;
  }

  return response;
};

This will be the parsed cookies:

const cookies = {
  cookieObjects: [
    { name: "nevergonnagiveyouup", value: "" },
    {
      name: "nevergonna",
      value: "bringyoudown",
      comment: "something",
      commenturl: "http://example.com/",
      domain: ".example.com",
      expires: new Date("2020-01-01T00:00:00.000Z"),
      httpOnly: true,
      maxAge: 3600,
      path: "/",
      sameSite: "strict",
      secure: true,
      version: "1",
    },
  ],
  cookieStrings: [
    "nevergonnagiveyouup",
    "nevergonna=bringyoudown; secure; httponly; samesite=strict; path=/; domain=.example.com; max-age=3600; expires=Mon, 01-Jan-2020 00:00:00 GMT; version=1; comment=something; commenturl=http://example.com/",
  ],
};

Cloudfront Viewer Request Event (Lambda@Edge)

Consider this as your event:

{
    "Records": [
        {
            "cf": {
                "config": {
                    "distributionId": "EXAMPLE"
                },
                "request": {
                    "uri": "/test",
                    "method": "GET",
                    "clientIp": "2001:cdba::3257:9652",
                    "headers": {
                        "user-agent": [
                            {
                                "key": "User-Agent",
                                "value": "Test Agent"
                            }
                        ],
                        "host": [
                            {
                                "key": "Host",
                                "value": "d123.cf.net"
                            }
                        ],
                        "cookie": [
                            {
                                "key": "Cookie",
                                "value": "nevergonnagiveyouup"
                            },
                            {
                                "key": "Cookie",
                                "value": "nevergonna=bringyoudown; secure; httponly; samesite=strict; path=/; domain=.example.com; max-age=3600; expires=Mon, 01-Jan-2020 00:00:00 GMT; version=1; comment=something; commenturl=http://example.com/"
                            }
                        ]
                    }
                }
            }
        }
    ]
}

And this is your lambda code:

let response;
const {
  CloudfrontViewerRequestEventHandler,
} = require("@anzp/aws-lambda-apig-cookie");
exports.lambdaHandler = async (event, context, callback) => {
  try {
    const request = event.Records[0].cf.request;
    const handler = new CloudfrontViewerRequestEventHandler(event);
    const cookies = handler.getCookies();
    console.log({ cookies });
  } catch (err) {
    console.log(err);
    response = {
      statusCode: 500,
    };
    callback(null, response)
  }
  callback(null, request)
};

This will be the parsed cookies:

const cookies = {
  cookieObjects: [
    { name: "nevergonnagiveyouup", value: "" },
    {
      name: "nevergonna",
      value: "bringyoudown",
      comment: "something",
      commenturl: "http://example.com/",
      domain: ".example.com",
      expires: new Date("2020-01-01T00:00:00.000Z"),
      httpOnly: true,
      maxAge: 3600,
      path: "/",
      sameSite: "strict",
      secure: true,
      version: "1",
    },
  ],
  cookieStrings: [
    "nevergonnagiveyouup",
    "nevergonna=bringyoudown; secure; httponly; samesite=strict; path=/; domain=.example.com; max-age=3600; expires=Mon, 01-Jan-2020 00:00:00 GMT; version=1; comment=something; commenturl=http://example.com/",
  ],
};

Hopefully it can help anybody struggling with the similar issue.

Pitch to me: why should I use Svelte?

Anzhari Purnomo — Fri, 24 Jun 2022 01:13:28 +0000

I've been using Vue (Vue2 and Vue3) for several years, and now I keep hearing how great Svelte is. I looked at their quickstart guide, and it seems cool. I'd like to hear from people already using Svelte, probably on commercial/production environment. Much better if you can share the link, so I can take a look at your product.
Looking forward to your input.
Thanks!

Parse multipart/form-data in Azure Functions

Anzhari Purnomo — Tue, 06 Apr 2021 11:35:55 +0000

Recently I have to work with quite a lot of Azure based services. I had to write a Function that accept a file upload. Which then I realized, that Azure Functions does not have built in mechanism or API to handle file upload easily.

I ended up writing an npm module for this issue: https://www.npmjs.com/package/@anzp/azure-function-multipart

An example on how to use it:

import { AzureFunction, Context, HttpRequest } from "@azure/functions";
import parseMultipartFormData from "@anzp/azure-function-multipart";

const httpTrigger: AzureFunction = async function (
  context: Context,
  req: HttpRequest
): Promise<void> {
  const { fields, files } = await parseMultipartFormData(req);
  context.log("HTTP trigger function processed a request.");
  const name = req.query.name || (req.body && req.body.name);
  const responseMessage = {
    fields,
    files,
  };

  context.res = {
    // status: 200, /* Defaults to 200 */
    body: responseMessage,
  };
};

export default httpTrigger;

Example client request using CURL:

curl --request POST \
  --url http://localhost:7071/api/HttpTrigger1 \
  --header 'Content-Type: multipart/form-data; boundary=---011000010111000001101001' \
  --form update=false \
  --form collection=@/Users/anzhari/masterdata/managements.json

This is the example reponse received on the client:

{
  "fields": [
    {
      "fieldname": "update",
      "value": "false",
      "fieldnameTruncated": false,
      "valueTruncated": false,
      "encoding": "7bit",
      "mimetype": "text/plain"
    }
  ],
  "files": [
    {
      "fieldname": "file",
      "bufferFile": {
        "type": "Buffer",
        "data": [
          91,
          10,
          ...
          10,
          93
        ]
      },
      "filename": "managements.json",
      "encoding": "7bit",
      "mimetype": "application/json"
    }
  ]
}

Hope it can help anybody struggling with this issue!

Today I Learned: Searching Inside a Sorted Matrix

Anzhari Purnomo — Thu, 14 Jan 2021 09:40:32 +0000

Problem Statement

Write a function that takes in a sorted matrix of unique integers and a target integer, and returns an array of row and column indices of the target integer. Return [-1, -1] if the target integer is not found. The matrix could have a different height and width.

Sample Input

matrix = [
            [1, 4, 7, 12, 15, 1000],
            [2, 5, 19, 31, 32, 1001],
            [3, 8, 24, 33, 35, 1002],
            [40, 41, 42, 44, 45, 1003],
            [99, 100, 103, 106, 128, 1004],
        ]
target = 44

Sample Result

[3, 3]

Code #1

def search_in_sorted_matrix(matrix, target):
    ptr_row = 0
    ptr_col = len(matrix[0]) - 1
    while ptr_row > -1 and ptr_col > -1 and ptr_row < len(matrix) and ptr_col < len(matrix[0]):
        if target > matrix[ptr_row][ptr_col]:
            ptr_row += 1
        elif target < matrix[ptr_row][ptr_col]:
            ptr_col -= 1
        else:
            return [ptr_row, ptr_col]

    return [-1, -1]

Notes

Try starting the search from the top-right corner of the matrix, then increment or decrement the row or column indices appropriately.

Credits

Algoexpert for the problem statement
XKCD for the cover image

Azure Functions' Cold-Start Behavior

Anzhari Purnomo — Mon, 11 Jan 2021 02:03:16 +0000

In January 2021, I had a project that utilizes the Azure Functions HttpTrigger Functions. During my time implementing the project, I came across Azure Functions' cold-start behavior. I had a goal to prevent the cold-start state to improve the service response time, while also benefitting from Azure Functions' scaling and pricing structure.

Several notes I have made when testing the behavior:

So far I have not found the official documentation that states the idle duration that will trigger the cold-start state. However, I found this and this unofficial blog posts stating that the idle duration to trigger a cold-start state is around 20 minutes.
There is no way to configure the cold-start behavior for the Functions. I have not found any configuration reference on the documentations.
It seems the cold-start state is isolated per Functions, not per Azure Functions App. I found this when I tried to create a TimerTrigger in an attempt to prevent the cold-start state on the HttpTrigger endpoint. When I tried to set a TimerTrigger Functions to run for every 10 minutes within the same Azure Functions App with an HttpTrigger, the HttpTrigger Functions still experience a cold-start state (indicated by consistent >4 seconds response time in the App Insight page, instead of just <1 second response time for warmed-up state):
I tried to call the HttpTrigger functions through a cron job, and the average response time improved to around 1 - 2 seconds, even though there is occasional >4 seconds response time. I explored this further through App Insight, and it seems Azure is moving around my Functions' host for around every one hour, indicated by multiple hostname in my Azure Functions App log:

So far, the conclusion that I made:

Using only TimerTrigger does not improve the response time.
Using TimerTrigger could improve the response time, as long the TimerTrigger is calling the HttpTrigger API.
Manually triggering the HttpTrigger API frequently (e.g. every 10 minutes) does not completely remove the cold-start state, as Azure Functions forcibly moves the Functions across multiple Host periodically.
Occasional response time spike (sometimes over 10 seconds) cannot be mitigated by manually triggering the Functions on an interval.
The only solution is to upgrade to the Premium Plan and utilize the pre-warmed instance feature.

Those who transitioned from management to technical role, what is your reason and how well the transition was?

Anzhari Purnomo — Thu, 05 Nov 2020 04:35:05 +0000

I did this transition early this year. I was in a tech lead/manager/pre-sales engineer mix of roles for around 3 years, and planned to focus on a pure technical role.

Opportunity arise around August, and I made a switch to another company as a software engineer, despite the quarantine and the market uncertainty.

I am wondering how it has been for you guys who experienced the similar situation with me. Maybe you could share some of your issues and your tips with me.

Please share your story, and thanks!

COVID19 Summary gRPC API written in Typescript

Anzhari Purnomo — Sat, 26 Sep 2020 08:15:06 +0000

This is a gRPC API sample implementation on Node.JS written with Typescript.

You can check my sample code here: https://github.com/anzharip/covid19-id-grpc. Live demo on: 52.148.115.205:10080

You can access the live demo with any gRPC client or for GUI client, you can use BloomRPC:

The live demo is hosted on Azure Container service with 1 vCPU and 0.5 GB RAM. I benchmarked the service and it is running quite fast serving ~500 request per second without any optimization:

The datasets are retrieved from https://covid19api.com.

Notes:

You will need to compile the .proto files into Typescript definitions to create gRPC API in Typescript. You can follow the steps to do that here and here.

Cosmos DB SQL API for NestJS and Dynamic Module

Anzhari Purnomo — Sat, 19 Sep 2020 14:04:35 +0000

So recently, I need to use Azure Cosmos DB with their Core SQL API as my data persistence layer for my NestJS application. I looked around NestJS documentation, and the ORM we can use for NestJS (TypeORM, Mongoose, Sequelize, and Prisma) only support either PostgreSQL, MySQL/MariaDB, MongoDB, and other database engines, but not Cosmos DB SQL API.

Thanks to the beauty of open-source software, usually within a 30 minutes search, I would find a module that would satisfy my needs. So, I searched far and wide and found @nest/azure-database.

I tried it and asked a question on Stackoverflow on using the module for my use case, and finally, I decided that at its current state, I am not confident enough to use it in my application.

I noticed that Cosmos DB provided us with a Javascript NodeJS SDK, so I am thinking, is it possible to use the SDK API on NestJS directly?

So this question leads me to this Reddit post, this dev.to post and this Stackoverflow post, which indicates that it is possible and to make it happen, we need to use NestJS Dynamic Module.

To quote the explanation from the docs:

… dynamic modules provide an API for importing one module into another, and customizing the properties and behavior of that module when it is imported, as opposed to using the static bindings we've seen so far.

Also, there are two sample implementations you can refer to by Jay McDoniel where the author is using dynamic module with NodeJS pg module and apparently in NestJS sample directory where the sample is using NodeJS Mongoose module without using the NestJS' version.

So, for now, I will see if I can utilize NestJS' dynamic module for my use case and will share my sample implementation in my future post.

Note to Self: Handling Exception on Nest JS and Interceptor

Anzhari Purnomo — Tue, 15 Sep 2020 12:37:06 +0000

How do you handle exceptions from the service provider? For example, I have this service "UserService.ts":

import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { User } from './users.entity';
import * as bcrypt from 'bcrypt';
import { CreateUserDto } from './dto/create-user.dto';
import { AuthenticateUserDto } from './dto/authenticate-user.dto'

@Injectable()
export class UsersService {
    constructor(
        @InjectRepository(User)
        private readonly userRepository: Repository<User>,
    ) {}

    async register(createUserDto: CreateUserDto): Promise<User | undefined> {
        const user = new User();
        const saltRounds = 10;

        user.username = createUserDto.username;
        user.email = createUserDto.email; 
        user.password = bcrypt.hashSync(createUserDto.password, saltRounds)

        return this.userRepository.save(user);
    }
}

How do I handle exceptions generated from "register" method? For example, if there is an exception caused by unique constraint when I insert a value.

Currently I am using Interceptor Exception Mapping on the controller method, but I feel it is not quite intuitive yet for me.

Cover Image: Glenn Carstens-Peters

Today I Learned: Remove Kth Node from the End of a Single Linked List

Anzhari Purnomo — Mon, 14 Sep 2020 13:34:49 +0000

Problem Statement

Write a function that takes in the head of a single linked list and integer k which represents the kth node to remove from the end of the linked list.

Sample Input

head = 0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9
k = 4

Sample Result

# node 6 is removed
0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 7 -> 8 -> 9

Code #1

class LinkedList:
    def __init__(self, value):
        self.value = value
        self.next = None


def remove_kth_node_from_end(head, k):
    ptr_1 = head
    ptr_2 = head
    ctr = 0

    # Move ptr_2
    while ctr < k:
        # Return early if k is longer than list's length
        if ctr < k and ptr_2 is None:
            return
        ptr_2 = ptr_2.next
        ctr += 1

    # Check if removing the first element on the list
    if ptr_2 is None:
        head.value = head.next.value
        head.next = head.next.next
        return head

    while ptr_2.next is not None:
        ptr_1 = ptr_1.next
        ptr_2 = ptr_2.next

    # Remove kth node from end
    ptr_1.next = ptr_1.next.next
    return head

Notes

Since this is a single linked list, we cannot traverse to the end of the list and then trace back the kth node.
Utilize two pointers to track the beginning and the end node of the linked list.

Credits

Algoexpert for the problem statement
Chris Leipelt.

Why is GraphQL TokenAuth is Using Mutation Instead of Query?

Anzhari Purnomo — Fri, 11 Sep 2020 15:11:49 +0000

Adding more context into the question, what confuses me are why some library (e.g. Django GraphQL JWT and Apollo Server) implement the TokenAuth as a mutation (mutation as in GraphQL mutation operation) instead of a GraphQL query operation.

What I understand from the term is "mutation" means change in the data. A TokenAuth operation to generate JWT shouldn't mutate any data, only checking the credentials provided whether it is valid or not, which should be more appropriate to use "query" operation instead.

Found the answer here: https://stackoverflow.com/questions/50189364/shouldnt-the-login-be-a-query-in-graphql

An excerpt:

In the context of that example, login should be a Query instead of a Mutation assuming its resolver has no side-effects, at least according to the spec. However, there's a couple of reasons you probably won't see that done in the wild:

If you're implementing authentication, you'll probably want to log your users' account activity, either by maintaining some data about login/logout events or at least including some sort of "last login" field on the account's record. Modifying that data would be a side effect.

A convention has evolved that treats any operations that result from user actions as Mutations, regardless of side-effects. You see this with react-apollo, for example, where useQuery fires the associated query on mount, while useMutation only provides a function that can be called to fire that query. If you're planning on using Apollo client-side, it's worthwhile to consider those sort of client features when designing your schema.

Mutations are ran sequentially, while queries are ran simultaneously. That means it'd be foreseeable to fire a login mutation and one or more other mutations after it within the same call, allowing you to utilize an authenticated context for the subsequent calls. The same could not be said for queries -- if login is a query and you include other queries with it in the same operation, they will all begin resolving at the same time.

Outside of how they're executed (sequentially vs simultaneously), on the server-side, queries and mutations are effectively interchangeable. You could have queries with side-effects and mutations with no side effects. You probably should stick with conventions, but I think sometimes there's valid reasons where you may have to throw those conventions out the window.

Also, this stackoverflow post outlines that GraphQL mutation must be executed sequentially, as described by GraphQL specification:

If the operation is a mutation, the result of the operation is the result of executing the mutation’s top level selection set on the mutation root object type. This selection set should be executed serially.
It is expected that the top level fields in a mutation operation perform side‐effects on the underlying data system. Serial execution of the provided mutations ensures against race conditions during these side‐effects.

Note to self: dependency injection

Anzhari Purnomo — Thu, 10 Sep 2020 13:56:15 +0000

Stuck on deciding between deep-diving into dependency injection pattern for stronger foundation or straight away learning NestJS for faster deliverables.

Credit:

Glenn Carstens-Peters for the cover image (https://unsplash.com/@glenncarstenspeters).