• restaurant -> Pickup or Origin
• customer -> Dropoff or Destination
• internal provider -> instant delivery provider

• investigate golang implementation

• lerna packages
• simulator
• root README

• Address all cfn-nag warnings and add relative comment where the item cannot be addressed
• add cdk-nag to the solution

Switch architecture flag to arm64

Currently we create origin/destination records for the simulator with randomly generated coordinates that lead to routing errors in the dispatcher.

Instead, let's generate these records with real (routable) locations. We still keep the area definitions and radius, but the number will act as a max number.

https://overpass-turbo.eu/ - this open API helps to extract POIs from openstreetmap data, so we can easily run queries like the following and get enough locations back:

[out:json][timeout:25];
(
  node["amenity"~"cafe|restaurant"](around:5000.0,-6.1813448922772185,106.8372344970703);
);
out body;
>;
out skel qt;

Obviously around and lat/long coordinate values will be passed as parameters.

The key amenity seems to be quite extensively filled out (building tag is not e.g.: in Jakarta).

Query language guide here if needed to extend the above query.

• API call: POST https://overpass-api.de/api/interpreter
• Payload: { data: thatQueryStringAbove }
• Consume result: const { lat, lon } = response.elements[i]

• switch over from custom shell scripts

• research the possibility to run traveldistance calculations parallel on GPU cores

A) Current H3 distance cache can be built for a pre-defined polygon (MM) at resolution 9 (174m/hexagon edge -- ~5600x5600 matrix) in around 4.5 hours on a c6g.metal graviton instance. The goal is to be able to build a resolution 10 (65m/hexagon edge) distance matrix (40k x 40k) in reasonable time.
Also, the current 5600x5600 matrix is ~600MB that is easy to load to memory, but a 40k x 40k matrix size would be around ~30gb --> should be separated to a distancematrix service with fast lookup.

B) direct distanceMatrix build for incoming lat/lng values on GPU with the ability to build ~1000x1000 matrices

• eg. Bastion, DispatchInstance

• Test https://github.com/valhalla/valhalla

• e.g. skip geoclustering in instant delivery provider
• deploy-time / runtime

• most config parameters are in prototype/infra/config/local-XXXXX.json (gitignored) and only can be extracted from code
• prototype/infra/config/test.json doesn't have all the parameters as an example

Similarly to #142 split the config for parameterStoreKeys. Also make the values structured

parameterStoreKeys:
  locationService:
    geoTrackingApiUrl: /Hyperlocal/LocationService/Api/GeoTracking/Url
                                                             ^^
  instantDelivery:
    xxx: yyy

  sameDayDirectPudo:
    ...
    hubsTableName: /HyperLocal/SameDayDirectPudo/Ddb/Hubs/TableName
    ...

• Also update application.properties files in apps for delivery-dispatch.
• Update parameterStoreKeys type in infra project

packages/@prototype/simulator/src/SimulatorManagerStack/GraphhopperManager/@lambda/src/index.js
runTask uses config.securityGroups, while config exposes securityGroup

also, in CDKv2 we pass securityGroupId, to investigate if that's ok to use in the lambda

Current dynamic config parameters are stored in application.config, some of them need to be moved to parameter store or secrets manager.

To move:

• driver API url

To remove:

• s3 bucket for maps

depends on #25

• add root config and use findup to read it in different parts of the project (e.g. namespace)

1. Research
2. Implement

As mentioned in #162:

ProviderStack , OrderManager and CustomResourcesStack still need to be generalized to support variable number of external providers set in config

search string: SECURITY_GROUP: props.securityGroup.securityGroupId

after CDKv2 update, ec2.SecurityGroup doesn't have the property securityGroupName, but only securityGroupId is available. Make sure that the for lambdas that use this pattern will be properly functional (usually ECS runTask operations)

To research:

• Switch from Elasticache Redis to Amazon MemoryDB
• Elasticache Redis Cluster -> Elasticache Replication Group
• Elasticache Autoscaling

• currently using custom functions to set a permission on a resource e.g.: readDDBTable(ddbTable)
• rather, use cdk built-in ddbTable.grantRead(resource)

1. add SameDayDeliveryDispatchService
2. rename DispatchEcsService to InstantDeliveryDispatchEcsService
3. review if bucketAccess still needed for the task role

• measure lambda runtime with higher memory allocation to make sure that runtime cost can be minimized

• Move v1 to separate branch and rename to mixed-pickup-dropoff
• Rename v2 to one-order-per-driver
• Cleanup configs/constraints

Currently is hardcoded to 8xlarge x2 ;)

Add same-day delivery dispatcher domain, where orders are picked up and dropped off directly, without incorporating any warehouse concepts.

Refactor all CDK code to use CDK v2

• first candidate would be depcheck.
• to make sure that there are no missing dependencies in any packages

• CDK bundling vs lambda layers
• or: lerna package and add as a dependency + nohoist in lambda handler

Refactor instant delivery provider to return orders as list of segments that can also have mixed pick-up/drop-off. The same structure will be used for same day delivery

{
  jobId: '',
  driverId: '', // only for instant delivery
  driverIdentity: '', // only for instant delivery
  route: {
    distance: {
      value: 1152,
      unit: 'm', // meter
    },
    time: {
      value: 1160,
      unit: 'sec' //seconds
    },
    pointsEncoded: 'cxl_cBqwvnS|Dy@ogFyxmAf`IsnA|CjFzCsHluD_k@hi@ljL', //as per path polyline
  },
  segments: [
    {
      orderId: '',
      index: 1,
      from: { lat: 1, long: 2 },
      to: { lat: 1, long: 2 },
      segmentType: 'TO_ORIGIN',
      route: {
        distance: {
          value: 1152,
          unit: 'm', // meter
        },
        time: {
          value: 1160,
          unit: 'sec' //seconds
        },
        pointsEncoded: 'cxl_cBqwvnS|Dy@ogFyxmAf`IsnA|CjFzCsHluD_k@hi@ljL', //as per path polyline
      },
    },
    {
      orderId: '',
      index: 2,
      from: { lat: 1, long: 2 },
      to: { lat: 1, long: 2 },
      segmentType: 'TO_DESTINATION',
      route: {
        distance: {
          value: 478,
          unit: 'm', // meter
        },
        time: {
          value: 68,
          unit: 'sec' //seconds
        },
        pointsEncoded: '_p~iF~ps|U_ulLnnqC_mqNvxq`@, //as per path polyline
      },
    },
  ],
}

• Similar to quarkus/springboot project generator

• Tags.of(this).add(..., ...) for highest level construct

• Instant delivery
  • Sequential
  • Mixed Pickup-Dropoff

MAYBE

• Same day delivery
  • With warehouse
  • Direct PUDO

• review CDK bundler as well

consider using lambda powertools: https://github.com/awslabs/aws-lambda-powertools-typescript/