@aws-amplify/geo 2.3.6-api-v6-models.b3abc9b.0 → 3.0.0

package/lib-esm/util.js

@@ -1,10 +1,10 @@
-import { __assign, __read } from "tslib";
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import booleanClockwise from '@turf/boolean-clockwise';
+import { Category, getAmplifyUserAgent, getAmplifyUserAgentObject, } from '@aws-amplify/core/internals/utils';
 export function validateCoordinates(lng, lat) {
     if (!Number.isFinite(lng) || !Number.isFinite(lat)) {
-        throw new Error("Invalid coordinates: [" + lng + "," + lat + "]");
+        throw new Error(`Invalid coordinates: [${lng},${lat}]`);
     }
     if (lat < -90 || 90 < lat) {
         throw new Error('Latitude must be between -90 and 90 degrees inclusive.');
@@ -14,103 +14,103 @@ export function validateCoordinates(lng, lat) {
     }
 }
 export function validateGeofenceId(geofenceId) {
-    var geofenceIdRegex = /^[-._\p{L}\p{N}]+$/iu;
+    const geofenceIdRegex = /^[-._\p{L}\p{N}]+$/iu;
     // Check if geofenceId is valid
     if (!geofenceIdRegex.test(geofenceId)) {
-        throw new Error("Invalid geofenceId: '" + geofenceId + "' - IDs can only contain alphanumeric characters, hyphens, underscores and periods.");
+        throw new Error(`Invalid geofenceId: '${geofenceId}' - IDs can only contain alphanumeric characters, hyphens, underscores and periods.`);
     }
 }
 export function validateLinearRing(linearRing, geofenceId) {
-    var errorPrefix = geofenceId ? geofenceId + ": " : '';
+    const errorPrefix = geofenceId ? `${geofenceId}: ` : '';
     // Validate LinearRing size, must be at least 4 points
     if (linearRing.length < 4) {
-        throw new Error(errorPrefix + "LinearRing must contain 4 or more coordinates.");
+        throw new Error(`${errorPrefix}LinearRing must contain 4 or more coordinates.`);
     }
     // Validate all coordinates are valid, error with which ones are bad
-    var badCoordinates = [];
-    linearRing.forEach(function (coordinates) {
+    const badCoordinates = [];
+    linearRing.forEach(coordinates => {
         try {
             validateCoordinates(coordinates[0], coordinates[1]);
         }
         catch (error) {
-            badCoordinates.push({ coordinates: coordinates, error: error.message });
+            badCoordinates.push({ coordinates, error: error.message });
         }
     });
     if (badCoordinates.length > 0) {
-        throw new Error(errorPrefix + "One or more of the coordinates in the Polygon LinearRing are not valid: " + JSON.stringify(badCoordinates));
+        throw new Error(`${errorPrefix}One or more of the coordinates in the Polygon LinearRing are not valid: ${JSON.stringify(badCoordinates)}`);
     }
     // Validate first and last coordinates are the same
-    var _a = __read(linearRing[0], 2), lngA = _a[0], latA = _a[1];
-    var _b = __read(linearRing[linearRing.length - 1], 2), lngB = _b[0], latB = _b[1];
+    const [lngA, latA] = linearRing[0];
+    const [lngB, latB] = linearRing[linearRing.length - 1];
     if (lngA !== lngB || latA !== latB) {
-        throw new Error(errorPrefix + "LinearRing's first and last coordinates are not the same");
+        throw new Error(`${errorPrefix}LinearRing's first and last coordinates are not the same`);
     }
     if (booleanClockwise(linearRing)) {
-        throw new Error(errorPrefix + "LinearRing coordinates must be wound counterclockwise");
+        throw new Error(`${errorPrefix}LinearRing coordinates must be wound counterclockwise`);
     }
 }
 export function validatePolygon(polygon, geofenceId) {
-    var errorPrefix = geofenceId ? geofenceId + ": " : '';
+    const errorPrefix = geofenceId ? `${geofenceId}: ` : '';
     if (!Array.isArray(polygon)) {
-        throw new Error(errorPrefix + "Polygon is of incorrect structure. It should be an array of LinearRings");
+        throw new Error(`${errorPrefix}Polygon is of incorrect structure. It should be an array of LinearRings`);
     }
     if (polygon.length < 1) {
-        throw new Error(errorPrefix + "Polygon must have a single LinearRing array.");
+        throw new Error(`${errorPrefix}Polygon must have a single LinearRing array.`);
     }
     if (polygon.length > 1) {
-        throw new Error(errorPrefix + "Polygon must have a single LinearRing array. Note: We do not currently support polygons with holes, multipolygons, polygons that are wound clockwise, or that cross the antimeridian.");
+        throw new Error(`${errorPrefix}Polygon must have a single LinearRing array. Note: We do not currently support polygons with holes, multipolygons, polygons that are wound clockwise, or that cross the antimeridian.`);
     }
-    var verticesCount = polygon.reduce(function (prev, linearRing) { return prev + linearRing.length; }, 0);
+    const verticesCount = polygon.reduce((prev, linearRing) => prev + linearRing.length, 0);
     if (verticesCount > 1000) {
-        throw new Error(errorPrefix + "Polygon has more than the maximum 1000 vertices.");
+        throw new Error(`${errorPrefix}Polygon has more than the maximum 1000 vertices.`);
     }
-    polygon.forEach(function (linearRing) {
+    polygon.forEach(linearRing => {
         validateLinearRing(linearRing, geofenceId);
     });
 }
 export function validateGeofencesInput(geofences) {
-    var geofenceIds = {};
-    geofences.forEach(function (geofence) {
+    const geofenceIds = {};
+    geofences.forEach((geofence) => {
         // verify all required properties are present
         // Validate geofenceId exists
         if (!geofence.geofenceId) {
-            throw new Error("Geofence '" + geofence + "' is missing geofenceId");
+            throw new Error(`Geofence '${geofence}' is missing geofenceId`);
         }
-        var geofenceId = geofence.geofenceId;
+        const { geofenceId } = geofence;
         validateGeofenceId(geofenceId);
         // Validate geofenceId is unique
         if (geofenceIds[geofenceId]) {
-            throw new Error("Duplicate geofenceId: " + geofenceId);
+            throw new Error(`Duplicate geofenceId: ${geofenceId}`);
         }
         else {
             geofenceIds[geofenceId] = true;
         }
         // Validate geometry exists
         if (!geofence.geometry) {
-            throw new Error("Geofence '" + geofenceId + "' is missing geometry");
+            throw new Error(`Geofence '${geofenceId}' is missing geometry`);
         }
-        var geometry = geofence.geometry;
+        const { geometry } = geofence;
         // Validate polygon exists
         if (!geometry.polygon) {
-            throw new Error("Geofence '" + geofenceId + "' is missing geometry.polygon");
+            throw new Error(`Geofence '${geofenceId}' is missing geometry.polygon`);
         }
-        var polygon = geometry.polygon;
+        const { polygon } = geometry;
         // Validate polygon length and structure
         try {
             validatePolygon(polygon, geofenceId);
         }
         catch (error) {
             if (error.message.includes('Polygon has more than the maximum 1000 vertices.')) {
-                throw new Error("Geofence '" + geofenceId + "' has more than the maximum of 1000 vertices");
+                throw new Error(`Geofence '${geofenceId}' has more than the maximum of 1000 vertices`);
             }
         }
         // Validate LinearRing length, structure, and coordinates
-        var _a = __read(polygon, 1), linearRing = _a[0];
+        const [linearRing] = polygon;
         validateLinearRing(linearRing, geofenceId);
     });
 }
 export function mapSearchOptions(options, locationServiceInput) {
-    var locationServiceModifiedInput = __assign({}, locationServiceInput);
+    const locationServiceModifiedInput = { ...locationServiceInput };
     locationServiceModifiedInput.FilterCountries = options.countries;
     locationServiceModifiedInput.MaxResults = options.maxResults;
     if (options.searchIndexName) {
@@ -127,4 +127,15 @@ export function mapSearchOptions(options, locationServiceInput) {
     }
     return locationServiceModifiedInput;
 }
-//# sourceMappingURL=util.js.map
+export function getGeoUserAgent(action) {
+    return getAmplifyUserAgentObject({
+        category: Category.Geo,
+        action,
+    });
+}
+export function getGeoUserAgentString(action) {
+    return getAmplifyUserAgent({
+        category: Category.Geo,
+        action,
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aws-amplify/geo",
-	"version": "2.3.6-api-v6-models.b3abc9b.0+b3abc9b",
+	"version": "3.0.0",
 	"description": "Geo category for aws-amplify",
 	"main": "./lib/index.js",
 	"module": "./lib-esm/index.js",
@@ -19,16 +19,23 @@
 		"test": "yarn run lint && jest -w 1 --coverage",
 		"test:size": "size-limit",
 		"build-with-test": "yarn test && yarn run build",
-		"build:cjs": "node ./build es5 && webpack && webpack --config ./webpack.config.dev.js",
-		"build:esm": "node ./build es6",
-		"build:cjs:watch": "node ./build es5 --watch",
-		"build:esm:watch": "rimraf lib-esm && node ./build es6 --watch",
+		"build:cjs": "rimraf lib && tsc -m commonjs --outDir lib && webpack && webpack --config ./webpack.config.dev.js",
+		"build:esm": "rimraf lib-esm && tsc -m esnext --outDir lib-esm",
+		"build:cjs:watch": "rimraf lib && tsc -m commonjs --outDir lib --watch",
+		"build:esm:watch": "rimraf lib-esm && tsc -m esnext --outDir lib-esm --watch",
 		"build": "yarn clean && yarn build:esm && yarn run build:cjs",
 		"clean": "npm run clean:size && rimraf lib-esm lib dist",
 		"clean:size": "rimraf dual-publish-tmp tmp*",
 		"format": "echo \"Not implemented\"",
 		"lint": "tslint '{__tests__,src}/**/*.ts' && npm run ts-coverage",
-		"ts-coverage": "typescript-coverage-report -p ./tsconfig.build.json -t 86.56"
+		"ts-coverage": "typescript-coverage-report -p ./tsconfig.json -t 84.00"
+	},
+	"typesVersions": {
+		">=4.2": {
+			"pinpoint": [
+				"./lib-esm/providers/pinpoint/AmazonLocationServiceProvider.d.ts"
+			]
+		}
 	},
 	"repository": {
 		"type": "git",
@@ -46,18 +53,24 @@
 		"src"
 	],
 	"dependencies": {
-		"@aws-amplify/core": "5.8.6-api-v6-models.b3abc9b.0+b3abc9b",
-		"@aws-sdk/client-location": "3.186.3",
+		"@aws-sdk/client-location": "3.398.0",
 		"@turf/boolean-clockwise": "6.5.0",
 		"camelcase-keys": "6.2.2",
-		"tslib": "^1.8.0"
+		"tslib": "^2.5.0"
+	},
+	"peerDependencies": {
+		"@aws-amplify/core": "^6.0.0"
+	},
+	"devDependencies": {
+		"@aws-amplify/core": "6.0.0",
+		"typescript": "5.0.2"
 	},
 	"size-limit": [
 		{
 			"name": "Geo (top-level class)",
 			"path": "./lib-esm/index.js",
 			"import": "{ Amplify, Geo }",
-			"limit": "52.12 kB"
+			"limit": "43.9 kB"
 		}
 	],
 	"jest": {
@@ -73,6 +86,7 @@
 						"es2019.object"
 					],
 					"allowJs": true,
+					"noEmitOnError": false,
 					"esModuleInterop": true,
 					"downlevelIteration": true
 				}
@@ -107,11 +121,11 @@
 			}
 		},
 		"coveragePathIgnorePatterns": [
-			"/node_modules/",
+			"node_modules",
 			"dist",
 			"lib",
 			"lib-esm"
 		]
 	},
-	"gitHead": "b3abc9b75f6f1353f4c2fbc10cd3369be498e9fc"
+	"gitHead": "d505105326d7f6214f6bd1e06eb20be3a3651377"
 }

package/src/Geo.ts

@@ -1,11 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import {
-	Amplify,
-	ConsoleLogger as Logger,
-	parseAWSExports,
-} from '@aws-amplify/core';
-import { AmazonLocationServiceProvider } from './Providers/AmazonLocationServiceProvider';
+import { Amplify, ConsoleLogger } from '@aws-amplify/core';
+import { AmazonLocationServiceProvider } from './providers/location-service/AmazonLocationServiceProvider';
 
 import { validateCoordinates } from './util';
 
@@ -28,7 +24,7 @@ import {
 	searchByPlaceIdOptions,
 } from './types';
 
-const logger = new Logger('Geo');
+const logger = new ConsoleLogger('Geo');
 
 const DEFAULT_PROVIDER = 'AmazonLocationService';
 export class GeoClass {
@@ -42,6 +38,15 @@ export class GeoClass {
 	constructor() {
 		this._config = {};
 		this._pluggables = [];
+
+		const amplifyConfig = Amplify.getConfig() ?? {};
+		this._config = Object.assign({}, this._config, amplifyConfig.Geo);
+
+		const locationProvider = new AmazonLocationServiceProvider(
+			amplifyConfig.Geo
+		);
+		this._pluggables.push(locationProvider);
+
 		logger.debug('Geo Options', this._config);
 	}
 
@@ -60,11 +65,6 @@ export class GeoClass {
 	public addPluggable(pluggable: GeoProvider) {
 		if (pluggable && pluggable.getCategory() === 'Geo') {
 			this._pluggables.push(pluggable);
-			const config = pluggable.configure(
-				this._config[pluggable.getProviderName()]
-			);
-
-			return config;
 		}
 	}
 
@@ -93,29 +93,6 @@ export class GeoClass {
 		return;
 	}
 
-	/**
-	 * Configure Geo
-	 * @param {Object} config - Configuration object for Geo
-	 * @return {Object} - Current configuration
-	 */
-	configure(config?) {
-		logger.debug('configure Geo');
-
-		if (!config) return this._config;
-
-		const amplifyConfig = parseAWSExports(config);
-		this._config = Object.assign({}, this._config, amplifyConfig.Geo, config);
-
-		this._pluggables.forEach(pluggable => {
-			pluggable.configure(this._config[pluggable.getProviderName()]);
-		});
-
-		if (this._pluggables.length === 0) {
-			this.addPluggable(new AmazonLocationServiceProvider());
-		}
-		return this._config;
-	}
-
 	/**
 	 * Get the map resources that are currently available through the provider
 	 * @param {string} provider
@@ -331,4 +308,3 @@ export class GeoClass {
 }
 
 export const Geo = new GeoClass();
-Amplify.register(Geo);

package/src/{Providers → providers/location-service}/AmazonLocationServiceProvider.ts

@@ -2,11 +2,8 @@
 // SPDX-License-Identifier: Apache-2.0
 import camelcaseKeys from 'camelcase-keys';
 
-import {
-	ConsoleLogger as Logger,
-	Credentials,
-	getAmplifyUserAgentObject,
-} from '@aws-amplify/core';
+import { Amplify, fetchAuthSession, ConsoleLogger } from '@aws-amplify/core';
+import { GeoAction } from '@aws-amplify/core/internals/utils';
 import {
 	Place as PlaceResult,
 	LocationClient,
@@ -35,10 +32,11 @@ import {
 } from '@aws-sdk/client-location';
 
 import {
+	getGeoUserAgent,
 	mapSearchOptions,
 	validateGeofenceId,
 	validateGeofencesInput,
-} from '../util';
+} from '../../util';
 
 import {
 	GeoConfig,
@@ -60,9 +58,10 @@ import {
 	GeofencePolygon,
 	AmazonLocationServiceDeleteGeofencesResults,
 	searchByPlaceIdOptions,
-} from '../types';
+	AmazonLocationServiceBatchGeofenceErrorMessages,
+} from '../../types';
 
-const logger = new Logger('AmazonLocationServiceProvider');
+const logger = new ConsoleLogger('AmazonLocationServiceProvider');
 
 export class AmazonLocationServiceProvider implements GeoProvider {
 	static CATEGORY = 'Geo';
@@ -72,6 +71,7 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	 * @private
 	 */
 	private _config;
+	private _credentials;
 
 	/**
 	 * Initialize Geo with AWS configurations
@@ -98,18 +98,6 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		return AmazonLocationServiceProvider.PROVIDER_NAME;
 	}
 
-	/**
-	 * Configure Geo part with aws configuration
-	 * @param {Object} config - Configuration of the Geo
-	 * @return {Object} - Current configuration
-	 */
-	public configure(config?): object {
-		logger.debug('configure Amazon Location Service Provider', config);
-		if (!config) return this._config;
-		this._config = Object.assign({}, this._config, config);
-		return this._config;
-	}
-
 	/**
 	 * Get the map resources that are currently available through the provider
 	 * @returns {AmazonLocationServiceMapStyle[]}- Array of available map resources
@@ -179,9 +167,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		}
 
 		const client = new LocationClient({
-			credentials: this._config.credentials,
+			credentials: this._credentials,
 			region: this._config.region,
-			customUserAgent: getAmplifyUserAgentObject(),
+			customUserAgent: getGeoUserAgent(GeoAction.SearchByText),
 		});
 		const command = new SearchPlaceIndexForTextCommand(locationServiceInput);
 
@@ -203,7 +191,7 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		);
 		const results: Place[] = camelcaseKeys(PascalResults, {
 			deep: true,
-		}) as undefined as Place[];
+		}) as unknown as Place[];
 
 		return results;
 	}
@@ -245,9 +233,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		}
 
 		const client = new LocationClient({
-			credentials: this._config.credentials,
+			credentials: this._credentials,
 			region: this._config.region,
-			customUserAgent: getAmplifyUserAgentObject(),
+			customUserAgent: getGeoUserAgent(GeoAction.SearchForSuggestions),
 		});
 		const command = new SearchPlaceIndexForSuggestionsCommand(
 			locationServiceInput
@@ -293,9 +281,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		this._verifyPlaceId(placeId);
 
 		const client = new LocationClient({
-			credentials: this._config.credentials,
+			credentials: this._credentials,
 			region: this._config.region,
-			customUserAgent: getAmplifyUserAgentObject(),
+			customUserAgent: getGeoUserAgent(GeoAction.SearchByPlaceId),
 		});
 
 		const searchByPlaceIdInput: GetPlaceCommandInput = {
@@ -351,9 +339,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		}
 
 		const client = new LocationClient({
-			credentials: this._config.credentials,
+			credentials: this._credentials,
 			region: this._config.region,
-			customUserAgent: getAmplifyUserAgentObject(),
+			customUserAgent: getGeoUserAgent(GeoAction.SearchByCoordinates),
 		});
 		const command = new SearchPlaceIndexForPositionCommand(
 			locationServiceInput
@@ -448,10 +436,10 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 					// If the API call fails, add the geofences to the errors array and move to next batch
 					batch.forEach(geofence => {
 						results.errors.push({
-							geofenceId: geofence.GeofenceId,
+							geofenceId: geofence.GeofenceId!,
 							error: {
 								code: 'APIConnectionError',
-								message: error.message,
+								message: (error as Error).message,
 							},
 						});
 					});
@@ -459,27 +447,25 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 				}
 
 				// Push all successes to results
-				response.Successes.forEach(success => {
+				response.Successes?.forEach(success => {
 					const { GeofenceId, CreateTime, UpdateTime } = success;
 					results.successes.push({
-						geofenceId: GeofenceId,
+						geofenceId: GeofenceId!,
 						createTime: CreateTime,
 						updateTime: UpdateTime,
 					});
 				});
 
 				// Push all errors to results
-				response.Errors.forEach(error => {
-					const {
-						Error: { Code, Message },
-						GeofenceId,
-					} = error;
+				response.Errors?.forEach(error => {
+					const { Error, GeofenceId } = error;
+					const { Code, Message } = Error!;
 					results.errors.push({
 						error: {
-							code: Code,
-							message: Message,
+							code: Code!,
+							message: Message!,
 						},
-						geofenceId: GeofenceId,
+						geofenceId: GeofenceId!,
 					});
 				});
 			})
@@ -515,9 +501,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 
 		// Create Amazon Location Service Client
 		const client = new LocationClient({
-			credentials: this._config.credentials,
+			credentials: this._credentials,
 			region: this._config.region,
-			customUserAgent: getAmplifyUserAgentObject(),
+			customUserAgent: getGeoUserAgent(GeoAction.GetGeofence),
 		});
 
 		// Create Amazon Location Service command
@@ -541,9 +527,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		const { GeofenceId, CreateTime, UpdateTime, Status, Geometry } = response;
 		const geofence: AmazonLocationServiceGeofence = {
 			createTime: CreateTime,
-			geofenceId: GeofenceId,
+			geofenceId: GeofenceId!,
 			geometry: {
-				polygon: Geometry.Polygon as GeofencePolygon,
+				polygon: Geometry!.Polygon as GeofencePolygon,
 			},
 			status: Status as AmazonLocationServiceGeofenceStatus,
 			updateTime: UpdateTime,
@@ -577,9 +563,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 
 		// Create Amazon Location Service Client
 		const client = new LocationClient({
-			credentials: this._config.credentials,
+			credentials: this._credentials,
 			region: this._config.region,
-			customUserAgent: getAmplifyUserAgentObject(),
+			customUserAgent: getGeoUserAgent(GeoAction.ListGeofences),
 		});
 
 		// Create Amazon Location Service input
@@ -607,21 +593,15 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		const { NextToken, Entries } = response;
 
 		const results: ListGeofenceResults = {
-			entries: Entries.map(
-				({
-					GeofenceId,
-					CreateTime,
-					UpdateTime,
-					Status,
-					Geometry: { Polygon },
-				}) => {
+			entries: Entries!.map(
+				({ GeofenceId, CreateTime, UpdateTime, Status, Geometry }) => {
 					return {
-						geofenceId: GeofenceId,
+						geofenceId: GeofenceId!,
 						createTime: CreateTime,
 						updateTime: UpdateTime,
 						status: Status,
 						geometry: {
-							polygon: Polygon as GeofencePolygon,
+							polygon: Geometry!.Polygon as GeofencePolygon,
 						},
 					};
 				}
@@ -693,8 +673,10 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 						const errorObject = {
 							geofenceId,
 							error: {
-								code: error.message,
-								message: error.message,
+								code: (error as Error)
+									.message as AmazonLocationServiceBatchGeofenceErrorMessages,
+								message: (error as Error)
+									.message as AmazonLocationServiceBatchGeofenceErrorMessages,
 							},
 						};
 						results.errors.push(errorObject);
@@ -718,11 +700,13 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	 */
 	private async _ensureCredentials(): Promise<boolean> {
 		try {
-			const credentials = await Credentials.get();
+			const credentials = (await fetchAuthSession()).credentials;
 			if (!credentials) return false;
-			const cred = Credentials.shear(credentials);
-			logger.debug('Set credentials for storage. Credentials are:', cred);
-			this._config.credentials = cred;
+			logger.debug(
+				'Set credentials for storage. Credentials are:',
+				credentials
+			);
+			this._credentials = credentials;
 			return true;
 		} catch (error) {
 			logger.debug('Ensure credentials error. Credentials are:', error);
@@ -730,7 +714,18 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		}
 	}
 
+	private _refreshConfig() {
+		this._config = Amplify.getConfig().Geo?.LocationService;
+		if (!this._config) {
+			const errorString =
+				"No Geo configuration found in amplify config, run 'amplify add geo' to create one and run `amplify push` after";
+			logger.debug(errorString);
+			throw new Error(errorString);
+		}
+	}
+
 	private _verifyMapResources() {
+		this._refreshConfig();
 		if (!this._config.maps) {
 			const errorString =
 				"No map resources found in amplify config, run 'amplify add geo' to create one and run `amplify push` after";
@@ -746,8 +741,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	}
 
 	private _verifySearchIndex(optionalSearchIndex?: string) {
+		this._refreshConfig();
 		if (
-			(!this._config.search_indices || !this._config.search_indices.default) &&
+			(!this._config.searchIndices || !this._config.searchIndices.default) &&
 			!optionalSearchIndex
 		) {
 			const errorString =
@@ -758,6 +754,7 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 	}
 
 	private _verifyGeofenceCollections(optionalGeofenceCollectionName?: string) {
+		this._refreshConfig();
 		if (
 			(!this._config.geofenceCollections ||
 				!this._config.geofenceCollections.default) &&
@@ -782,9 +779,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		};
 
 		const client = new LocationClient({
-			credentials: this._config.credentials,
+			credentials: this._credentials,
 			region: this._config.region,
-			customUserAgent: getAmplifyUserAgentObject(),
+			customUserAgent: getGeoUserAgent(GeoAction.SaveGeofences),
 		});
 		const command = new BatchPutGeofenceCommand(geofenceInput);
 
@@ -809,9 +806,9 @@ export class AmazonLocationServiceProvider implements GeoProvider {
 		};
 
 		const client = new LocationClient({
-			credentials: this._config.credentials,
+			credentials: this._credentials,
 			region: this._config.region,
-			customUserAgent: getAmplifyUserAgentObject(),
+			customUserAgent: getGeoUserAgent(GeoAction.DeleteGeofences),
 		});
 		const command = new BatchDeleteGeofenceCommand(deleteGeofencesInput);