@chaosity/location-client 0.1.5 → 0.1.6

package/dist/adapters/GeoPlaces.js

@@ -1,5 +1,7 @@
-import { GeocodeAdditionalFeature, GeocodeCommand, GetPlaceAdditionalFeature, GetPlaceCommand, ReverseGeocodeCommand } from '@aws-sdk/client-geo-places';
-import { geocodeResponseToFeatureCollection, getPlaceResponseToFeatureCollection, reverseGeocodeResponseToFeatureCollection } from '@aws/amazon-location-utilities-datatypes';
+import { GeocodeCommand, GetPlaceAdditionalFeature, GetPlaceCommand, ReverseGeocodeCommand, SuggestAdditionalFeature, SuggestCommand, } from '@aws-sdk/client-geo-places';
+import { geocodeResponseToFeatureCollection, getPlaceResponseToFeatureCollection, reverseGeocodeResponseToFeatureCollection, } from '@aws/amazon-location-utilities-datatypes';
+import debug from 'debug';
+const log = debug('location-client:geocoder');
 /**
  * GeoPlaces - MapLibre adapter for AWS Location Service
  *
@@ -18,7 +20,7 @@ export class GeoPlaces {
         return 'en';
     }
     async forwardGeocode(config) {
-        console.log('[GeoPlaces] forwardGeocode called with:', config);
+        log('forwardGeocode query=%s', config.query);
         const center = this.map.getCenter();
         const biasPosition = config.proximity && config.proximity.length >= 2
             ? [config.proximity[0], config.proximity[1]]
@@ -29,61 +31,33 @@ export class GeoPlaces {
             MaxResults: config.limit || 5,
             Language: this.normalizeLanguage(config.language),
         };
-        if (config.countries || config.bbox) {
-            commandInput.Filter = {};
-            if (config.countries)
-                commandInput.Filter.IncludeCountries = config.countries;
-            if (config.bbox)
-                commandInput.Filter.BoundingBox = config.bbox;
+        if (config.countries) {
+            commandInput.Filter = {
+                IncludeCountries: Array.isArray(config.countries) ? config.countries : config.countries.split(','),
+            };
         }
-        console.log('[GeoPlaces] Sending SearchTextCommand with:', commandInput);
-        const command = new GeocodeCommand(commandInput);
-        const response = await this.client.send(command);
-        console.log('[GeoPlaces] SearchTextCommand response:', response);
+        const response = await this.client.send(new GeocodeCommand(commandInput));
         const result = geocodeResponseToFeatureCollection(response, { flattenProperties: true });
-        console.log('[GeoPlaces] Converted to FeatureCollection:', result);
+        log('forwardGeocode returned %d results', result.features?.length ?? 0);
         return result;
     }
     async reverseGeocode(config) {
-        console.log('[GeoPlaces] reverseGeocode called with:', config);
+        log('reverseGeocode query=%o', config.query);
         const queryPosition = Array.isArray(config.query) && config.query.length >= 2
             ? [config.query[0], config.query[1]]
             : [0, 0];
         const commandInput = {
             QueryPosition: queryPosition,
             MaxResults: config.limit || 1,
-            Language: this.normalizeLanguage(config.language)
+            Language: this.normalizeLanguage(config.language),
         };
-        if (config.countries) {
-            commandInput.Filter = { IncludeCountries: config.countries };
-        }
-        const command = new ReverseGeocodeCommand(commandInput);
-        const response = await this.client.send(command);
-        const maplibreGeocoderFeatureResults = reverseGeocodeResponseToFeatureCollection(response, { flattenProperties: true });
-        maplibreGeocoderFeatureResults.features.forEach(feature => {
-        });
-        console.log('[GeoPlaces] Converted to FeatureCollection:', maplibreGeocoderFeatureResults);
-        return maplibreGeocoderFeatureResults;
+        const response = await this.client.send(new ReverseGeocodeCommand(commandInput));
+        const result = reverseGeocodeResponseToFeatureCollection(response, { flattenProperties: true });
+        log('reverseGeocode returned %d results', result.features?.length ?? 0);
+        return result;
     }
     async getSuggestions(config) {
-        // const center = this.map.getCenter()
-        // const biasPosition = config.proximity && config.proximity.length >= 2
-        //   ? [config.proximity[0], config.proximity[1]]
-        //   : [center.lng, center.lat]
-        // const commandInput: any = {
-        //   QueryText: config.query as string,
-        //   BiasPosition: biasPosition,
-        //   MaxResults: config.limit || 5,
-        //   Language: this.normalizeLanguage(config.language),
-        //   AdditionalFeatures: [SuggestAdditionalFeature.CORE],
-        // }
-        // if (config.countries || config.bbox) {
-        //   commandInput.Filter = {}
-        //   if (config.countries) commandInput.Filter.IncludeCountries = config.countries
-        //   if (config.bbox) commandInput.Filter.BoundingBox = config.bbox
-        // }
-        // const command = new SuggestCommand(commandInput)
-        // const response = await this.client.send(command) as SuggestResponse
+        log('getSuggestions query=%s', config.query);
         const center = this.map.getCenter();
         const biasPosition = config.proximity && config.proximity.length >= 2
             ? [config.proximity[0], config.proximity[1]]
@@ -93,55 +67,51 @@ export class GeoPlaces {
             BiasPosition: biasPosition,
             MaxResults: config.limit || 5,
             Language: this.normalizeLanguage(config.language),
-            AdditionalFeatures: [GeocodeAdditionalFeature.SECONDARY_ADDRESSES],
+            AdditionalFeatures: [SuggestAdditionalFeature.CORE],
+            ...(config.countries || config.bbox ? {
+                Filter: {
+                    ...(config.countries ? { IncludeCountries: Array.isArray(config.countries) ? config.countries : config.countries.split(',') } : {}),
+                    ...(config.bbox ? { BoundingBox: config.bbox } : {}),
+                },
+            } : {}),
         };
-        if (config.countries || config.bbox) {
-            commandInput.Filter = {};
-            if (config.countries)
-                commandInput.Filter.IncludeCountries = Array.isArray(config.countries) ? config.countries : config.countries.split(',');
-            // if (config.types) commandInput.Filter.IncludePlaceTypes = config.types.split(',').map(type => new GeocodeFilterPlaceType)
+        const response = await this.client.send(new SuggestCommand(commandInput));
+        const suggestions = { suggestions: [] };
+        for (const item of response.ResultItems ?? []) {
+            const text = item.Title;
+            if (!text)
+                continue;
+            const placeId = item.Place?.PlaceId;
+            suggestions.suggestions.push({ text, placeId });
         }
-        console.log('[GeoPlaces] Sending SearchTextCommand with:', commandInput);
-        const command = new GeocodeCommand(commandInput);
-        const response = await this.client.send(command);
-        console.log('[GeoPlaces] SearchTextCommand response:', response);
-        const maplibreGeocoderSuggestionResults = { suggestions: [] };
-        response?.ResultItems?.forEach(item => {
-            const text = item?.Title || item?.Address?.Label;
-            const placeId = item?.PlaceId;
-            if (text) {
-                maplibreGeocoderSuggestionResults.suggestions.push({
-                    text,
-                    placeId,
-                });
-            }
-        });
-        console.log('[GeoPlaces] Converted to MaplibreGeocoderSuggestionResults:', maplibreGeocoderSuggestionResults);
-        return maplibreGeocoderSuggestionResults;
+        log('getSuggestions returned %d suggestions', suggestions.suggestions.length);
+        return suggestions;
     }
     async searchByPlaceId(config) {
-        console.log('[GeoPlaces] searchByPlaceId called with:', config);
-        const placeId = config.query;
+        log('searchByPlaceId placeId=%s', config.query);
         const command = new GetPlaceCommand({
-            PlaceId: placeId,
+            PlaceId: config.query,
             Language: this.normalizeLanguage(config.language),
-            AdditionalFeatures: [GetPlaceAdditionalFeature.ACCESS, GetPlaceAdditionalFeature.SECONDARY_ADDRESSES, GetPlaceAdditionalFeature.CONTACT, GetPlaceAdditionalFeature.TIME_ZONE],
+            AdditionalFeatures: [
+                GetPlaceAdditionalFeature.ACCESS,
+                GetPlaceAdditionalFeature.SECONDARY_ADDRESSES,
+                GetPlaceAdditionalFeature.CONTACT,
+                GetPlaceAdditionalFeature.TIME_ZONE,
+            ],
         });
         const response = await this.client.send(command);
         const result = getPlaceResponseToFeatureCollection(response, { flattenProperties: true });
-        console.log('[GeoPlaces] GetPlaceCommand response converted to FeatureCollection:', result);
         const carmenGeojsonFeatures = result.features.map(feature => ({
             ...feature,
             text: response.Title || '',
             place_name: response.Address?.Label || '',
             place_type: response.PlaceType ? [response.PlaceType] : [],
-            bbox: response.MapView
+            bbox: response.MapView,
         }));
-        console.log('[GeoPlaces] Converted to CarmenGeojsonFeatures:', carmenGeojsonFeatures);
+        log('searchByPlaceId returned %d features', carmenGeojsonFeatures.length);
         return { place: carmenGeojsonFeatures };
     }
     async localGeocode(config) {
-        console.log('[GeoPlaces] localGeocode called with:', config);
         return this.forwardGeocode(config);
     }
 }

package/dist/auth/TokenProvider.d.ts

@@ -1,6 +1,7 @@
 export interface TokenResponse {
     success: boolean;
     token?: string;
+    expiresAt?: number;
     error?: string;
 }
 export interface TokenProviderConfig {
@@ -24,7 +25,7 @@ export interface TokenProviderConfig {
  *
  * @example
  * // ✓ Correct: Server-side usage
- * import { TokenProvider } from '@chaosity/location-client'
+ * import { TokenProvider } from '@chaosity/location-client/server'
  *
  * const provider = new TokenProvider({
  *   apiUrl: process.env.API_URL!,
@@ -39,12 +40,11 @@ export interface TokenProviderConfig {
 export declare class TokenProvider {
     private config;
     private cachedToken?;
-    private oauth2Client;
+    private cachedExpiresAt?;
     private tokenPromise?;
     constructor(config: TokenProviderConfig);
     getToken(forceRefresh?: boolean): Promise<TokenResponse>;
     private fetchToken;
-    private getTokenExpiry;
     private isExpired;
     clearCache(): void;
 }

package/dist/auth/TokenProvider.js

@@ -1,5 +1,3 @@
-import ClientOAuth2 from 'client-oauth2';
-import { decodeJwt } from 'jose';
 import debug from 'debug';
 const log = debug('location-client:auth');
 /**
@@ -18,7 +16,7 @@ const log = debug('location-client:auth');
  *
  * @example
  * // ✓ Correct: Server-side usage
- * import { TokenProvider } from '@chaosity/location-client'
+ * import { TokenProvider } from '@chaosity/location-client/server'
  *
  * const provider = new TokenProvider({
  *   apiUrl: process.env.API_URL!,
@@ -40,19 +38,15 @@ export class TokenProvider {
         }
         log('Initializing TokenProvider for %s', config.apiUrl);
         this.config = config;
-        this.oauth2Client = new ClientOAuth2({
-            clientId: config.clientId,
-            clientSecret: config.clientSecret,
-            accessTokenUri: `${config.apiUrl}/auth/token`,
-        });
     }
     async getToken(forceRefresh = false) {
         if (!forceRefresh && this.cachedToken && !this.isExpired()) {
-            const exp = this.getTokenExpiry();
-            log('Using cached token (expires in %ds)', exp ? Math.floor(exp - Date.now() / 1000) : 'unknown');
+            const expiresIn = this.cachedExpiresAt ? Math.floor((this.cachedExpiresAt - Date.now()) / 1000) : 'unknown';
+            log('Using cached token (expires in %ds)', expiresIn);
             return {
                 success: true,
-                token: this.cachedToken
+                token: this.cachedToken,
+                expiresAt: this.cachedExpiresAt
             };
         }
         // If token fetch is already in progress, wait for it
@@ -75,13 +69,39 @@ export class TokenProvider {
     }
     async fetchToken() {
         try {
-            const token = await this.oauth2Client.credentials.getToken();
-            this.cachedToken = token.accessToken;
-            const exp = this.getTokenExpiry();
-            log('Token acquired successfully (expires in %ds)', exp ? Math.floor(exp - Date.now() / 1000) : 'unknown');
+            const { clientId, clientSecret, apiUrl } = this.config;
+            const credentials = btoa(`${clientId}:${clientSecret}`);
+            const response = await fetch(`${apiUrl}/auth/token`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Basic ${credentials}`,
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                body: new URLSearchParams({ grant_type: 'client_credentials' }).toString(),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                let errorMessage = `Token request failed: ${response.statusText}`;
+                try {
+                    const errorData = JSON.parse(errorText);
+                    if (errorData.error_description)
+                        errorMessage = errorData.error_description;
+                    else if (errorData.error)
+                        errorMessage = errorData.error;
+                }
+                catch { /* use statusText */ }
+                throw new Error(errorMessage);
+            }
+            const data = await response.json();
+            this.cachedToken = data.access_token;
+            // Use expires_in from OAuth2 response; null-coalesce so 0 is not replaced
+            const expiresIn = data.expires_in ?? 900;
+            this.cachedExpiresAt = Date.now() + (expiresIn * 1000);
+            log('Token acquired successfully (expires in %ds)', expiresIn);
             return {
                 success: true,
-                token: this.cachedToken
+                token: this.cachedToken,
+                expiresAt: this.cachedExpiresAt,
             };
         }
         catch (error) {
@@ -92,24 +112,13 @@ export class TokenProvider {
             };
         }
     }
-    getTokenExpiry() {
-        if (!this.cachedToken)
-            return null;
-        try {
-            const decoded = decodeJwt(this.cachedToken);
-            return decoded.exp || null;
-        }
-        catch {
-            return null;
-        }
-    }
     isExpired(bufferSeconds = 60) {
-        const exp = this.getTokenExpiry();
-        if (!exp)
+        if (!this.cachedExpiresAt)
             return true;
-        return Date.now() / 1000 >= (exp - bufferSeconds);
+        return Date.now() >= (this.cachedExpiresAt - bufferSeconds * 1000);
     }
     clearCache() {
         this.cachedToken = undefined;
+        this.cachedExpiresAt = undefined;
     }
 }

package/dist/client/GeoPlacesClient.d.ts

@@ -2,8 +2,10 @@ import { ClientConfig } from '../types';
 /**
  * GeoPlacesClient - AWS Location Service compatible client with custom auth
  *
- * Uses AWS Location Client command classes but replaces SigV4 auth with Bearer token.
+ * Uses AWS SDK command classes but replaces SigV4 auth with Bearer token.
  * All request/response types are identical to AWS Location Service.
+ *
+ * Pass `getToken` in config to support live token refresh without recreating the client.
  */
 export declare class GeoPlacesClient {
     private clientConfig;

package/dist/client/GeoPlacesClient.js

@@ -1,11 +1,24 @@
 import debug from 'debug';
+import { AutocompleteCommand, GeocodeCommand, GetPlaceCommand, ReverseGeocodeCommand, SearchNearbyCommand, SearchTextCommand, SuggestCommand, } from '@aws-sdk/client-geo-places';
 const log = debug('location-client:api');
 const logError = debug('location-client:api:error');
+// Minification-safe endpoint map — uses constructor identity, not class name strings
+const ENDPOINT_MAP = new Map([
+    [AutocompleteCommand, '/address/autocomplete'],
+    [GeocodeCommand, '/address/geocode'],
+    [GetPlaceCommand, '/address/place'],
+    [ReverseGeocodeCommand, '/address/search/reverse-geocode'],
+    [SearchNearbyCommand, '/address/search/nearby'],
+    [SearchTextCommand, '/address/search/text'],
+    [SuggestCommand, '/address/suggestion'],
+]);
 /**
  * GeoPlacesClient - AWS Location Service compatible client with custom auth
  *
- * Uses AWS Location Client command classes but replaces SigV4 auth with Bearer token.
+ * Uses AWS SDK command classes but replaces SigV4 auth with Bearer token.
  * All request/response types are identical to AWS Location Service.
+ *
+ * Pass `getToken` in config to support live token refresh without recreating the client.
  */
 export class GeoPlacesClient {
     constructor(config) {
@@ -17,62 +30,43 @@ export class GeoPlacesClient {
         const url = `${this.clientConfig.apiUrl}${endpoint}`;
         const commandName = command.constructor.name;
         const input = command.input;
-        log(`[GeoPlacesClient] Sending ${commandName} to ${endpoint}`);
-        log('[GeoPlacesClient] Request body:', JSON.stringify(input, null, 2));
-        log('Sending %s request to %s', commandName, endpoint);
+        // Prefer getToken callback (live ref) over static token string
+        const token = this.clientConfig.getToken?.() ?? this.clientConfig.token;
+        log('Sending %s to %s', commandName, endpoint);
         const startTime = Date.now();
         const response = await fetch(url, {
             method: 'POST',
             headers: {
                 'Content-Type': 'application/json',
-                'Authorization': `Bearer ${this.clientConfig.token}`
+                'Authorization': `Bearer ${token}`,
             },
-            body: JSON.stringify(input)
+            body: JSON.stringify(input),
         });
         const duration = Date.now() - startTime;
         if (!response.ok) {
             const errorText = await response.text();
-            log(`[GeoPlacesClient] Request failed: ${response.status} ${response.statusText}`, errorText);
             logError('Request failed: %s %s (%dms)', response.status, response.statusText, duration);
-            // Try to parse error message from response
             let errorMessage = `API request failed: ${response.statusText}`;
             try {
                 const errorData = JSON.parse(errorText);
-                if (errorData.message) {
+                if (errorData.message)
                     errorMessage = errorData.message;
-                }
             }
             catch {
-                // If not JSON, use raw text if available
                 if (errorText)
                     errorMessage = errorText;
             }
             throw new Error(errorMessage);
         }
         const result = await response.json();
-        log(`[GeoPlacesClient] Response (${duration}ms):`, JSON.stringify(result, null, 2));
         log('Request successful: %s (%dms)', response.status, duration);
         return result;
     }
     getEndpoint(command) {
-        const commandName = command.constructor.name;
-        switch (commandName) {
-            case 'AutocompleteCommand':
-                return '/address/autocomplete';
-            case 'GeocodeCommand':
-                return '/address/geocode';
-            case 'GetPlaceCommand':
-                return '/address/place';
-            case 'ReverseGeocodeCommand':
-                return '/address/search/reverse-geocode';
-            case 'SearchNearbyCommand':
-                return '/address/search/nearby';
-            case 'SearchTextCommand':
-                return '/address/search/text';
-            case 'SuggestCommand':
-                return '/address/suggestion';
-            default:
-                throw new Error(`Unknown command type: ${commandName}`);
+        for (const [CommandClass, endpoint] of ENDPOINT_MAP) {
+            if (command instanceof CommandClass)
+                return endpoint;
         }
+        throw new Error(`Unknown command type: ${command.constructor?.name ?? typeof command}`);
     }
 }

package/dist/index.d.ts

@@ -1,5 +1,3 @@
-export { TokenProvider } from './auth/TokenProvider';
-export type { TokenResponse, TokenProviderConfig } from './auth/TokenProvider';
 export { GeoPlacesClient } from './client/GeoPlacesClient';
 export * from '@aws-sdk/client-geo-places';
 export * from '@aws/amazon-location-utilities-datatypes';
@@ -7,7 +5,3 @@ export { GeoPlaces } from './adapters/GeoPlaces';
 export { createTransformRequest } from './maps/createTransformRequest';
 export { transformRequest } from './maps/Utils';
 export type { ClientConfig } from './types';
-export { getClientConfig } from './server/getClientConfig';
-export type { ServerAuthConfig } from './server/getClientConfig';
-export { LocationServiceConnector } from './server/LocationServiceConnector';
-export type { ConnectorConfig } from './server/LocationServiceConnector';

package/dist/index.js

@@ -1,5 +1,3 @@
-// Auth (Custom - only difference from AWS SDK)
-export { TokenProvider } from './auth/TokenProvider';
 // Client (Custom - uses our auth instead of AWS SigV4)
 export { GeoPlacesClient } from './client/GeoPlacesClient';
 // Re-export AWS SDK commands and types
@@ -11,6 +9,4 @@ export { GeoPlaces } from './adapters/GeoPlaces';
 // Maps utilities
 export { createTransformRequest } from './maps/createTransformRequest';
 export { transformRequest } from './maps/Utils';
-// Server-only utilities
-export { getClientConfig } from './server/getClientConfig';
-export { LocationServiceConnector } from './server/LocationServiceConnector';
+// Server-only utilities are available via '@chaosity/location-client/server'

package/dist/maps/Utils.d.ts

@@ -1,8 +1,2 @@
 import { ClientConfig } from "../types";
-export declare function transformRequest(url: string, config: ClientConfig): {
-    url: string;
-    headers: Record<string, string>;
-} | {
-    url: string;
-    headers?: undefined;
-};
+export declare function transformRequest(url: string, config: ClientConfig): import("maplibre-gl").RequestParameters | undefined;

package/dist/maps/Utils.js

@@ -1,24 +1,5 @@
+import { createTransformRequest } from "./createTransformRequest";
 export function transformRequest(url, config) {
-    if (url.startsWith(config.apiUrl)) {
-        const headers = {
-            'Authorization': `Bearer ${config.token}`,
-        };
-        if (url.includes('/tiles/')) {
-            headers['Accept'] = 'application/x-protobuf';
-        }
-        else if (url.includes('/glyphs/')) {
-            headers['Accept'] = 'application/x-protobuf';
-        }
-        else if (url.includes('/sprites/') && url.endsWith('.png')) {
-            headers['Accept'] = 'image/png';
-        }
-        else if (url.includes('/sprites/') && url.endsWith('.json')) {
-            headers['Accept'] = 'application/json';
-        }
-        else if (url.includes('/descriptor')) {
-            headers['Accept'] = 'application/json';
-        }
-        return { url, headers };
-    }
-    return { url };
+    const token = config.getToken?.() ?? config.token;
+    return createTransformRequest(config.apiUrl, () => token)(url);
 }

package/dist/server/LocationServiceConnector.js

@@ -1,3 +1,4 @@
+import { AutocompleteCommand, GeocodeCommand, GetPlaceCommand, ReverseGeocodeCommand, SearchNearbyCommand, SearchTextCommand, SuggestCommand, } from '@aws-sdk/client-geo-places';
 import debug from 'debug';
 import { getClientConfig } from './getClientConfig';
 const log = debug('location-client:connector');
@@ -40,9 +41,14 @@ export class LocationServiceConnector {
     async send(command, options) {
         const config = await this.configPromise;
         // Get token - ConnectorConfig may have getToken, ServerClientConfig has static token
-        const token = 'getToken' in config && config.getToken
-            ? (await config.getToken()).token
-            : config.token;
+        let token;
+        if ('getToken' in config && typeof config.getToken === 'function') {
+            const result = await config.getToken();
+            token = result ? (typeof result === 'string' ? result : result.token) : undefined;
+        }
+        else {
+            token = config.token;
+        }
         if (!token) {
             throw new Error('No token available');
         }
@@ -87,24 +93,20 @@ export class LocationServiceConnector {
         return result;
     }
     getEndpoint(command) {
-        const commandName = command.constructor.name;
-        switch (commandName) {
-            case 'AutocompleteCommand':
-                return '/address/autocomplete';
-            case 'GeocodeCommand':
-                return '/address/geocode';
-            case 'GetPlaceCommand':
-                return '/address/place';
-            case 'ReverseGeocodeCommand':
-                return '/address/search/reverse-geocode';
-            case 'SearchNearbyCommand':
-                return '/address/search/nearby';
-            case 'SearchTextCommand':
-                return '/address/search/text';
-            case 'SuggestCommand':
-                return '/address/suggestion';
-            default:
-                throw new Error(`Unknown command type: ${commandName}`);
-        }
+        if (command instanceof AutocompleteCommand)
+            return '/address/autocomplete';
+        if (command instanceof GeocodeCommand)
+            return '/address/geocode';
+        if (command instanceof GetPlaceCommand)
+            return '/address/place';
+        if (command instanceof ReverseGeocodeCommand)
+            return '/address/search/reverse-geocode';
+        if (command instanceof SearchNearbyCommand)
+            return '/address/search/nearby';
+        if (command instanceof SearchTextCommand)
+            return '/address/search/text';
+        if (command instanceof SuggestCommand)
+            return '/address/suggestion';
+        throw new Error(`Unknown command type: ${command.constructor?.name ?? typeof command}`);
     }
 }

package/dist/server/getClientConfig.d.ts

@@ -5,6 +5,7 @@ export interface ServerAuthConfig {
     clientSecret?: string;
 }
 export interface ServerClientConfig extends ClientConfig {
+    expiresAt?: number;
 }
 /**
  * Get client configuration with OAuth2 authentication.

package/dist/server/getClientConfig.js

@@ -1,6 +1,22 @@
 import debug from 'debug';
 import { TokenProvider } from '../auth/TokenProvider';
 const log = debug('location-client:clientConfig');
+// Singleton instance to prevent race conditions
+let tokenProviderInstance = null;
+let currentConfig = null;
+function getTokenProvider(apiUrl, clientId, clientSecret) {
+    const configKey = `${apiUrl}:${clientId}`;
+    // Reuse existing instance if config matches
+    if (tokenProviderInstance && currentConfig === configKey) {
+        log('[getTokenProvider] Reusing existing TokenProvider instance');
+        return tokenProviderInstance;
+    }
+    // Create new instance if config changed
+    log('[getTokenProvider] Creating new TokenProvider instance');
+    tokenProviderInstance = new TokenProvider({ apiUrl, clientId, clientSecret });
+    currentConfig = configKey;
+    return tokenProviderInstance;
+}
 /**
  * Get client configuration with OAuth2 authentication.
  *
@@ -50,8 +66,8 @@ export async function getClientConfig(config = {}) {
         throw new Error('Missing required configuration. Set environment variables: ' +
             'LOCATION_API_URL, LOCATION_CLIENT_ID, LOCATION_CLIENT_SECRET');
     }
-    log('[getClientConfig] Creating TokenProvider');
-    const provider = new TokenProvider({ apiUrl, clientId, clientSecret });
+    log('[getClientConfig] Getting TokenProvider instance');
+    const provider = getTokenProvider(apiUrl, clientId, clientSecret);
     log('[getClientConfig] Fetching token');
     const result = await provider.getToken();
     if (!result.success || !result.token) {
@@ -61,6 +77,7 @@ export async function getClientConfig(config = {}) {
     log('[getClientConfig] Token fetched successfully, length:', result.token.length);
     return {
         apiUrl,
-        token: result.token
+        token: result.token,
+        expiresAt: result.expiresAt
     };
 }

package/dist/server/index.d.ts

@@ -2,3 +2,5 @@ export { getClientConfig } from './getClientConfig';
 export type { ServerAuthConfig, ServerClientConfig } from './getClientConfig';
 export { LocationServiceConnector } from './LocationServiceConnector';
 export type { ConnectorConfig, SendOptions } from './LocationServiceConnector';
+export { TokenProvider } from '../auth/TokenProvider';
+export type { TokenProviderConfig, TokenResponse } from '../auth/TokenProvider';

package/dist/server/index.js

@@ -1,2 +1,3 @@
 export { getClientConfig } from './getClientConfig';
 export { LocationServiceConnector } from './LocationServiceConnector';
+export { TokenProvider } from '../auth/TokenProvider';

package/dist/types/index.d.ts

@@ -1,4 +1,7 @@
 export interface ClientConfig {
     apiUrl: string;
     token: string;
+    /** Optional callback to get the current token dynamically. When provided,
+     *  called on every request so token updates are reflected without recreating the client. */
+    getToken?: () => string | undefined;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chaosity/location-client",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Client library for Chaosity Location Service with AWS Location Service compatibility",
   "type": "module",
   "main": "dist/index.js",
@@ -18,7 +18,8 @@
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "jest",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -43,9 +44,7 @@
     "@aws-sdk/client-geo-places": "^3.0.0",
     "@aws/amazon-location-utilities-datatypes": "^1.0.0",
     "@maplibre/maplibre-gl-geocoder": "^1.9.4",
-    "client-oauth2": "^4.3.3",
-    "debug": "^4.4.3",
-    "jose": "^5.0.0"
+"debug": "^4.4.3"
   },
   "peerDependencies": {
     "maplibre-gl": "^5.0.0"
@@ -59,7 +58,11 @@
     "@types/debug": "^4.1.12",
     "@types/node": "^25.0.3",
     "maplibre-gl": "^5.0.0",
-    "typescript": "^5.0.0"
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "files": [
     "dist",