@aws-amplify/geo 3.0.22-unstable.bd1fefd.0 → 3.0.22

package/src/providers/location-service/AmazonLocationServiceProvider.ts

@@ -1,33 +1,34 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import camelcaseKeys from 'camelcase-keys';
-import { Amplify, ConsoleLogger, fetchAuthSession } from '@aws-amplify/core';
+
+import { Amplify, fetchAuthSession, ConsoleLogger } from '@aws-amplify/core';
 import { GeoAction } from '@aws-amplify/core/internals/utils';
 import {
-	BatchDeleteGeofenceCommand,
-	BatchDeleteGeofenceCommandInput,
-	BatchDeleteGeofenceCommandOutput,
+	Place as PlaceResult,
+	LocationClient,
+	SearchPlaceIndexForTextCommand,
+	SearchPlaceIndexForTextCommandInput,
+	SearchPlaceIndexForSuggestionsCommand,
+	SearchPlaceIndexForSuggestionsCommandInput,
+	SearchPlaceIndexForPositionCommand,
+	SearchPlaceIndexForPositionCommandInput,
 	BatchPutGeofenceCommand,
 	BatchPutGeofenceCommandInput,
-	BatchPutGeofenceCommandOutput,
 	BatchPutGeofenceRequestEntry,
-	GetGeofenceCommand,
-	GetGeofenceCommandInput,
-	GetGeofenceCommandOutput,
+	BatchPutGeofenceCommandOutput,
 	GetPlaceCommand,
 	GetPlaceCommandInput,
 	GetPlaceCommandOutput,
+	GetGeofenceCommand,
+	GetGeofenceCommandInput,
+	GetGeofenceCommandOutput,
 	ListGeofencesCommand,
 	ListGeofencesCommandInput,
 	ListGeofencesCommandOutput,
-	LocationClient,
-	Place as PlaceResult,
-	SearchPlaceIndexForPositionCommand,
-	SearchPlaceIndexForPositionCommandInput,
-	SearchPlaceIndexForSuggestionsCommand,
-	SearchPlaceIndexForSuggestionsCommandInput,
-	SearchPlaceIndexForTextCommand,
-	SearchPlaceIndexForTextCommandInput,
+	BatchDeleteGeofenceCommand,
+	BatchDeleteGeofenceCommandInput,
+	BatchDeleteGeofenceCommandOutput,
 } from '@aws-sdk/client-location';
 
 import {
@@ -36,27 +37,28 @@ import {
 	validateGeofenceId,
 	validateGeofencesInput,
 } from '../../util';
+
 import {
-	AmazonLocationServiceBatchGeofenceErrorMessages,
-	AmazonLocationServiceDeleteGeofencesResults,
-	AmazonLocationServiceGeofence,
-	AmazonLocationServiceGeofenceOptions,
-	AmazonLocationServiceGeofenceStatus,
-	AmazonLocationServiceListGeofenceOptions,
-	AmazonLocationServiceMapStyle,
-	Coordinates,
 	GeoConfig,
+	SearchByTextOptions,
+	SearchByCoordinatesOptions,
 	GeoProvider,
+	Place,
+	AmazonLocationServiceMapStyle,
+	Coordinates,
+	SearchForSuggestionsResults,
 	GeofenceId,
 	GeofenceInput,
-	GeofencePolygon,
+	AmazonLocationServiceGeofenceOptions,
+	AmazonLocationServiceListGeofenceOptions,
 	ListGeofenceResults,
-	Place,
+	AmazonLocationServiceGeofenceStatus,
 	SaveGeofencesResults,
-	SearchByCoordinatesOptions,
-	SearchByTextOptions,
-	SearchForSuggestionsResults,
+	AmazonLocationServiceGeofence,
+	GeofencePolygon,
+	AmazonLocationServiceDeleteGeofencesResults,
 	searchByPlaceIdOptions,
+	AmazonLocationServiceBatchGeofenceErrorMessages,
 } from '../../types';
 
 const logger = new ConsoleLogger('AmazonLocationServiceProvider');
@@ -76,7 +78,7 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	 * @param {Object} config - Configuration object for Geo
 	 */
 	constructor(config?: GeoConfig) {
-		this._config = config || {};
+		this._config = config ? config : {};
 		logger.debug('Geo Options', this._config);
 	}
 
@@ -105,10 +107,10 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 
 		const mapStyles: AmazonLocationServiceMapStyle[] = [];
 		const availableMaps = this._config.maps.items;
-		const { region } = this._config;
+		const region = this._config.region;
 
 		for (const mapName in availableMaps) {
-			const { style } = availableMaps[mapName];
+			const style = availableMaps[mapName].style;
 			mapStyles.push({ mapName, style, region });
 		}
 
@@ -123,8 +125,8 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		this._verifyMapResources();
 
 		const mapName = this._config.maps.default;
-		const { style } = this._config.maps.items[mapName];
-		const { region } = this._config;
+		const style = this._config.maps.items[mapName].style;
+		const region = this._config.region;
 
 		return { mapName, style, region };
 	}
@@ -304,6 +306,7 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		if (place) {
 			return camelcaseKeys(place, { deep: true }) as unknown as Place;
 		}
+		return;
 	}
 
 	/**
@@ -369,7 +372,7 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	 * Create geofences inside of a geofence collection
 	 * @param geofences Array of geofence objects to create
 	 * @param options Optional parameters for creating geofences
-	 * @returns a promise that resolves to an object that conforms to {@link SaveGeofencesResults}:
+	 * @returns {Promise<AmazonLocationServiceSaveGeofencesResults>} - Promise that resolves to an object with:
 	 *   successes: list of geofences successfully created
 	 *   errors: list of geofences that failed to create
 	 */
@@ -440,15 +443,14 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 							},
 						});
 					});
-
 					return;
 				}
 
 				// Push all successes to results
 				response.Successes?.forEach(success => {
-					const { GeofenceId: geofenceId, CreateTime, UpdateTime } = success;
+					const { GeofenceId, CreateTime, UpdateTime } = success;
 					results.successes.push({
-						geofenceId: geofenceId!,
+						geofenceId: GeofenceId!,
 						createTime: CreateTime,
 						updateTime: UpdateTime,
 					});
@@ -456,14 +458,14 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 
 				// Push all errors to results
 				response.Errors?.forEach(error => {
-					const { Error, GeofenceId: geofenceId } = error;
+					const { Error, GeofenceId } = error;
 					const { Code, Message } = Error!;
 					results.errors.push({
 						error: {
 							code: Code!,
 							message: Message!,
 						},
-						geofenceId: geofenceId!,
+						geofenceId: GeofenceId!,
 					});
 				});
 			}),
@@ -522,16 +524,10 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		}
 
 		// Convert response to camelCase for return
-		const {
-			GeofenceId: responseGeofenceId,
-			CreateTime,
-			UpdateTime,
-			Status,
-			Geometry,
-		} = response;
+		const { GeofenceId, CreateTime, UpdateTime, Status, Geometry } = response;
 		const geofence: AmazonLocationServiceGeofence = {
 			createTime: CreateTime,
-			geofenceId: responseGeofenceId!,
+			geofenceId: GeofenceId!,
 			geometry: {
 				polygon: Geometry!.Polygon as GeofencePolygon,
 			},
@@ -545,7 +541,7 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	/**
 	 * List geofences from a geofence collection
 	 * @param  options ListGeofenceOptions
-	 * @returns a promise that resolves to an object that conforms to {@link ListGeofenceResults}:
+	 * @returns {Promise<ListGeofencesResults>} - Promise that resolves to an object with:
 	 *   entries: list of geofences - 100 geofences are listed per page
 	 *   nextToken: token for next page of geofences
 	 */
@@ -598,15 +594,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 
 		const results: ListGeofenceResults = {
 			entries: Entries!.map(
-				({
-					GeofenceId: geofenceId,
-					CreateTime,
-					UpdateTime,
-					Status,
-					Geometry,
-				}) => {
+				({ GeofenceId, CreateTime, UpdateTime, Status, Geometry }) => {
 					return {
-						geofenceId: geofenceId!,
+						geofenceId: GeofenceId!,
 						createTime: CreateTime,
 						updateTime: UpdateTime,
 						status: Status,
@@ -626,7 +616,7 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	 * Delete geofences from a geofence collection
 	 * @param geofenceIds string|string[]
 	 * @param options GeofenceOptions
-	 * @returns a promise that resolves to an object that conforms to {@link AmazonLocationServiceDeleteGeofencesResults}:
+	 * @returns {Promise<DeleteGeofencesResults>} - Promise that resolves to an object with:
 	 *  successes: list of geofences successfully deleted
 	 *  errors: list of geofences that failed to delete
 	 */
@@ -652,8 +642,6 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 			} catch (error) {
 				return true;
 			}
-
-			return false;
 		});
 		if (badGeofenceIds.length > 0) {
 			throw new Error(`Invalid geofence ids: ${badGeofenceIds.join(', ')}`);
@@ -693,19 +681,17 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 						};
 						results.errors.push(errorObject);
 					});
-
 					return;
 				}
 
-				const targetBadGeofenceIds = response.Errors.map(
+				const badGeofenceIds = response.Errors.map(
 					({ geofenceId }) => geofenceId,
 				);
 				results.successes.push(
-					...batch.filter(Id => !targetBadGeofenceIds.includes(Id)),
+					...batch.filter(Id => !badGeofenceIds.includes(Id)),
 				);
 			}),
 		);
-
 		return results;
 	}
 
@@ -714,18 +700,16 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	 */
 	private async _ensureCredentials(): Promise<boolean> {
 		try {
-			const { credentials } = await fetchAuthSession();
+			const credentials = (await fetchAuthSession()).credentials;
 			if (!credentials) return false;
 			logger.debug(
 				'Set credentials for storage. Credentials are:',
 				credentials,
 			);
 			this._credentials = credentials;
-
 			return true;
 		} catch (error) {
 			logger.debug('Ensure credentials error. Credentials are:', error);
-
 			return false;
 		}
 	}
@@ -801,7 +785,13 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		});
 		const command = new BatchPutGeofenceCommand(geofenceInput);
 
-		return client.send(command);
+		let response: BatchPutGeofenceCommandOutput;
+		try {
+			response = await client.send(command);
+		} catch (error) {
+			throw error;
+		}
+		return response;
 	}
 
 	private async _AmazonLocationServiceBatchDeleteGeofenceCall(
@@ -822,6 +812,12 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		});
 		const command = new BatchDeleteGeofenceCommand(deleteGeofencesInput);
 
-		return client.send(command);
+		let response: BatchDeleteGeofenceCommandOutput;
+		try {
+			response = await client.send(command);
+		} catch (error) {
+			throw error;
+		}
+		return response;
 	}
 }

package/src/types/AmazonLocationServiceProvider.ts

@@ -1,12 +1,12 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import {
-	DeleteGeofencesResults,
-	Geofence,
-	GeofenceError,
+	MapStyle,
 	GeofenceOptions,
 	ListGeofenceOptions,
-	MapStyle,
+	Geofence,
+	DeleteGeofencesResults,
+	GeofenceError,
 } from './Geo';
 
 // Maps

package/src/types/Geo.ts

@@ -53,20 +53,20 @@ export type SearchByTextOptions =
 	| SearchByTextOptionsWithSearchAreaConstraints;
 
 // Options object for searchByCoordinates
-export interface SearchByCoordinatesOptions {
+export type SearchByCoordinatesOptions = {
 	maxResults?: number;
 	searchIndexName?: string;
 	providerName?: string;
-}
+};
 
-export interface searchByPlaceIdOptions {
+export type searchByPlaceIdOptions = {
 	searchIndexName?: string;
-}
+};
 
 // Geometry object for Place points
-export interface PlaceGeometry {
+export type PlaceGeometry = {
 	point: Coordinates;
-}
+};
 
 // Place object with locality information
 export interface Place {
@@ -88,38 +88,38 @@ export type LinearRing = Coordinates[];
 export type GeofencePolygon = LinearRing[];
 
 // Geometry object for Polygon
-export interface PolygonGeometry {
+export type PolygonGeometry = {
 	polygon: GeofencePolygon;
-}
+};
 
 export type GeofenceId = string;
 
 // Geofence object used as input for saveGeofences
-export interface GeofenceInput {
+export type GeofenceInput = {
 	geofenceId: GeofenceId;
 	geometry: PolygonGeometry;
-}
+};
 
 // Options object for saveGeofences
-export interface GeofenceOptions {
+export type GeofenceOptions = {
 	providerName?: string;
-}
+};
 
 // Error type for errors related to Geofence API calls
-export interface GeofenceError {
+export type GeofenceError = {
 	error: {
 		code: string;
 		message: string;
 	};
 	geofenceId: GeofenceId;
-}
+};
 
 // Base geofence object
-interface GeofenceBase {
+type GeofenceBase = {
 	geofenceId: GeofenceId;
 	createTime?: Date;
 	updateTime?: Date;
-}
+};
 
 // Results object for getGeofence
 export type Geofence = GeofenceBase & {
@@ -127,10 +127,10 @@ export type Geofence = GeofenceBase & {
 };
 
 // Results object for saveGeofences
-export interface SaveGeofencesResults {
+export type SaveGeofencesResults = {
 	successes: GeofenceBase[];
 	errors: GeofenceError[];
-}
+};
 
 // Options object for listGeofence
 export type ListGeofenceOptions = GeofenceOptions & {
@@ -138,21 +138,21 @@ export type ListGeofenceOptions = GeofenceOptions & {
 };
 
 // Results options for listGeofence
-export interface ListGeofenceResults {
+export type ListGeofenceResults = {
 	entries: Geofence[];
 	nextToken: string | undefined;
-}
+};
 
 // Results object for deleteGeofence
-export interface DeleteGeofencesResults {
+export type DeleteGeofencesResults = {
 	successes: GeofenceId[];
 	errors: GeofenceError[];
-}
+};
 
 // Return type for searchForSuggestions
 export type SearchForSuggestionsResults = SearchForSuggestionsResult[];
 
-export interface SearchForSuggestionsResult {
+export type SearchForSuggestionsResult = {
 	text: string;
 	placeId?: string;
-}
+};

package/src/types/Provider.ts

@@ -1,20 +1,20 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import {
+	SearchByTextOptions,
+	SearchByCoordinatesOptions,
+	SearchForSuggestionsResults,
 	Coordinates,
-	DeleteGeofencesResults,
+	Place,
+	MapStyle,
 	Geofence,
 	GeofenceId,
 	GeofenceInput,
 	GeofenceOptions,
 	ListGeofenceOptions,
 	ListGeofenceResults,
-	MapStyle,
-	Place,
 	SaveGeofencesResults,
-	SearchByCoordinatesOptions,
-	SearchByTextOptions,
-	SearchForSuggestionsResults,
+	DeleteGeofencesResults,
 	searchByPlaceIdOptions,
 } from './Geo';
 

package/src/util.ts

@@ -10,21 +10,21 @@ import {
 import { UserAgent } from '@aws-sdk/types';
 
 import {
+	Longitude,
+	Latitude,
 	GeofenceId,
 	GeofenceInput,
 	GeofencePolygon,
-	Latitude,
 	LinearRing,
-	Longitude,
 } from './types';
 
 export function validateCoordinates(lng: Longitude, lat: Latitude): void {
 	if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
 		throw new Error(`Invalid coordinates: [${lng},${lat}]`);
 	}
-	if (lat < -90 || lat > 90) {
+	if (lat < -90 || 90 < lat) {
 		throw new Error('Latitude must be between -90 and 90 degrees inclusive.');
-	} else if (lng < -180 || lng > 180) {
+	} else if (lng < -180 || 180 < lng) {
 		throw new Error(
 			'Longitude must be between -180 and 180 degrees inclusive.',
 		);
@@ -186,18 +186,17 @@ export function mapSearchOptions(options, locationServiceInput) {
 		locationServiceModifiedInput.IndexName = options.searchIndexName;
 	}
 
-	if (options.biasPosition && options.searchAreaConstraints) {
+	if (options['biasPosition'] && options['searchAreaConstraints']) {
 		throw new Error(
 			'BiasPosition and SearchAreaConstraints are mutually exclusive, please remove one or the other from the options object',
 		);
 	}
-	if (options.biasPosition) {
-		locationServiceModifiedInput.BiasPosition = options.biasPosition;
+	if (options['biasPosition']) {
+		locationServiceModifiedInput.BiasPosition = options['biasPosition'];
 	}
-	if (options.searchAreaConstraints) {
-		locationServiceModifiedInput.FilterBBox = options.searchAreaConstraints;
+	if (options['searchAreaConstraints']) {
+		locationServiceModifiedInput.FilterBBox = options['searchAreaConstraints'];
 	}
-
 	return locationServiceModifiedInput;
 }