feat(location): support RouteCalculator

packages/@aws-cdk/aws-location-alpha/README.md

@@ -49,3 +49,28 @@ declare const role: iam.Role;
 const placeIndex = new location.PlaceIndex(this, 'PlaceIndex');
 placeIndex.grantSearch(role);
 ```
+
+## Route Calculator
+
+Route calculator resources allow you to find routes and estimate travel time based on up-to-date road network and live traffic information from your chosen data provider.
+
+For more information, see [Routes](https://docs.aws.amazon.com/location/latest/developerguide/route-concepts.html).
+
+To create a place index, define a `RouteCalculator`:
+
+```ts
+new location.RouteCalculator(this, 'RouteCalculator', {
+  routeCalculatorName: 'MyRouteCalculator', // optional, defaults to a generated name
+  dataSource: location.DataSource.HERE, // optional, defaults to Esri
+});
+```
+
+Use the `grant()` or `grantRead()` method to grant the given identity permissions to perform actions
+on the place index:
+
+```ts
+declare const role: iam.Role;
+
+const routeCalculator = new location.RouteCalculator(this, 'RouteCalculator');
+routeCalculator.grantRead(role);
+```

packages/@aws-cdk/aws-location-alpha/lib/index.ts

@@ -1,3 +1,4 @@
 export * from './place-index';
+export * from './route-calculator';
 
 // AWS::Location CloudFormation Resources:

packages/@aws-cdk/aws-location-alpha/lib/place-index.ts

@@ -66,6 +66,13 @@ export enum DataSource {
    */
   ESRI = 'Esri',
 
+  /**
+   * Grab provides routing functionality for Southeast Asia.
+   *
+   * @see https://docs.aws.amazon.com/location/latest/developerguide/grab.html
+   */
+  GRAB = 'Grab',
+
   /**
    * HERE
    *

packages/@aws-cdk/aws-location-alpha/lib/route-calculator.ts

@@ -0,0 +1,158 @@
+import * as iam from 'aws-cdk-lib/aws-iam';
+import { ArnFormat, IResource, Lazy, Resource, Stack, Token } from 'aws-cdk-lib/core';
+import { Construct } from 'constructs';
+import { CfnRouteCalculator } from 'aws-cdk-lib/aws-location';
+import { DataSource } from './place-index';
+import { generateUniqueId } from './util';
+
+/**
+ * A Route Calculator
+ */
+export interface IRouteCalculator extends IResource {
+  /**
+   * The name of the route calculator
+   *
+   * @attribute
+   */
+  readonly routeCalculatorName: string;
+
+  /**
+   * The Amazon Resource Name (ARN) of the route calculator resource
+   *
+   * @attribute Arn,CalculatorArn
+   */
+  readonly routeCalculatorArn: string;
+}
+
+/**
+ * Properties for a route calculator
+ */
+export interface RouteCalculatorProps {
+  /**
+   * A name for the route calculator
+   *
+   * @default - A name is automatically generated
+   */
+  readonly routeCalculatorName?: string;
+
+  /**
+   * Data source for the route calculator
+   *
+   * @default DataSource.ESRI
+   */
+  readonly dataSource?: DataSource;
+
+  /**
+   * A description for the route calculator
+   *
+   * @default - no description
+   */
+  readonly description?: string;
+}
+
+abstract class RouteCalculatorBase extends Resource implements IRouteCalculator {
+  public abstract readonly routeCalculatorName: string;
+  public abstract readonly routeCalculatorArn: string;
+
+  /**
+   * Grant the given principal identity permissions to perform the actions on this route calculator.
+   */
+  public grant(grantee: iam.IGrantable, ...actions: string[]): iam.Grant {
+    return iam.Grant.addToPrincipal({
+      grantee: grantee,
+      actions: actions,
+      resourceArns: [this.routeCalculatorArn],
+    });
+  }
+
+  /**
+   * Grant the given identity permissions to access to a route calculator resource to calculate a route.
+   *
+   * https://docs.aws.amazon.com/location/latest/developerguide/security_iam_id-based-policy-examples.html#security_iam_id-based-policy-examples-calculate-route
+   */
+  public grantRead(grantee: iam.IGrantable): iam.Grant {
+    return this.grant(grantee,
+      'geo:CalculateRoute',
+    );
+  }
+}
+
+/**
+ * A Route Calculator
+ *
+ * @see https://docs.aws.amazon.com/location/latest/developerguide/places-concepts.html
+ */
+export class RouteCalculator extends RouteCalculatorBase {
+  /**
+   * Use an existing route calculator by name
+   */
+  public static fromRouteCalculatorName(scope: Construct, id: string, routeCalculatorName: string): IRouteCalculator {
+    const routeCalculatorArn = Stack.of(scope).formatArn({
+      service: 'geo',
+      resource: 'route-calculator',
+      resourceName: routeCalculatorName,
+    });
+
+    return RouteCalculator.fromRouteCalculatorArn(scope, id, routeCalculatorArn);
+  }
+
+  /**
+   * Use an existing route calculator by ARN
+   */
+  public static fromRouteCalculatorArn(scope: Construct, id: string, routeCalculatorArn: string): IRouteCalculator {
+    const parsedArn = Stack.of(scope).splitArn(routeCalculatorArn, ArnFormat.SLASH_RESOURCE_NAME);
+
+    if (!parsedArn.resourceName) {
+      throw new Error(`Route Calculator Arn ${routeCalculatorArn} does not have a resource name.`);
+    }
+
+    class Import extends RouteCalculatorBase {
+      public readonly routeCalculatorName = parsedArn.resourceName!;
+      public readonly routeCalculatorArn = routeCalculatorArn;
+    }
+
+    return new Import(scope, id, {
+      account: parsedArn.account,
+      region: parsedArn.region,
+    });
+  }
+
+  public readonly routeCalculatorName: string;
+
+  public readonly routeCalculatorArn: string;
+
+  /**
+   * The timestamp for when the route calculator resource was created in ISO 8601 forma
+   *
+   * @attribute
+   */
+  public readonly routeCalculatorCreateTime: string;
+
+  /**
+   * The timestamp for when the route calculator resource was last updated in ISO 8601 format
+   *
+   * @attribute
+   */
+  public readonly routeCalculatorUpdateTime: string;
+
+  constructor(scope: Construct, id: string, props: RouteCalculatorProps = {}) {
+    if (props.routeCalculatorName && !Token.isUnresolved(props.routeCalculatorName) && !/^[-.\w]{1,100}$/.test(props.routeCalculatorName)) {
+      throw new Error(`Invalid route calculator name. The route calculator name must be between 1 and 100 characters and contain only alphanumeric characters, hyphens, periods and underscores. Received: ${props.routeCalculatorName}`);
+    }
+
+    super(scope, id, {
+      physicalName: props.routeCalculatorName ?? Lazy.string({ produce: () => generateUniqueId(this) }),
+    });
+
+    const routeCalculator = new CfnRouteCalculator(this, 'Resource', {
+      calculatorName: this.physicalName,
+      dataSource: props.dataSource ?? DataSource.ESRI,
+      description: props.description,
+    });
+
+    this.routeCalculatorName = routeCalculator.ref;
+    this.routeCalculatorArn = routeCalculator.attrArn;
+    this.routeCalculatorCreateTime = routeCalculator.attrCreateTime;
+    this.routeCalculatorUpdateTime = routeCalculator.attrUpdateTime;
+  }
+}

packages/@aws-cdk/aws-location-alpha/lib/util.ts

@@ -0,0 +1,9 @@
+import { Names } from 'aws-cdk-lib/core';
+
+export function generateUniqueId(context: any): string {
+  const name = Names.uniqueId(context);
+  if (name.length > 100) {
+    return name.substring(0, 50) + name.substring(name.length - 50);
+  }
+  return name;
+}

packages/@aws-cdk/aws-location-alpha/test/integ.route-calculator.js.snapshot/cdk-integ-location-route-calculator.template.json

@@ -0,0 +1,45 @@
+{
+ "Resources": {
+  "RouteCalculator0F2D109D": {
+   "Type": "AWS::Location::RouteCalculator",
+   "Properties": {
+    "CalculatorName": "cdkinteglocationroutecalculatorRouteCalculator916939B5",
+    "DataSource": "Esri"
+   }
+  }
+ },
+ "Parameters": {
+  "BootstrapVersion": {
+   "Type": "AWS::SSM::Parameter::Value<String>",
+   "Default": "/cdk-bootstrap/hnb659fds/version",
+   "Description": "Version of the CDK Bootstrap resources in this environment, automatically retrieved from SSM Parameter Store. [cdk:skip]"
+  }
+ },
+ "Rules": {
+  "CheckBootstrapVersion": {
+   "Assertions": [
+    {
+     "Assert": {
+      "Fn::Not": [
+       {
+        "Fn::Contains": [
+         [
+          "1",
+          "2",
+          "3",
+          "4",
+          "5"
+         ],
+         {
+          "Ref": "BootstrapVersion"
+         }
+        ]
+       }
+      ]
+     },
+     "AssertDescription": "CDK bootstrap stack version 6 required. Please run 'cdk bootstrap' with a recent version of the CDK CLI."
+    }
+   ]
+  }
+ }
+}