@chaosity/location-client 0.1.4 → 0.1.6

package/dist/adapters/GeoPlaces.d.ts

@@ -1,27 +1,19 @@
-import type { FeatureCollection } from 'geojson';
+import type { MaplibreGeocoderApi, MaplibreGeocoderApiConfig, MaplibreGeocoderFeatureResults, MaplibreGeocoderPlaceResults, MaplibreGeocoderSuggestionResults } from '@maplibre/maplibre-gl-geocoder';
 import type { Map } from 'maplibre-gl';
 import { GeoPlacesClient } from '../client/GeoPlacesClient';
 /**
  * GeoPlaces - MapLibre adapter for AWS Location Service
  *
- * Uses AWS Location Client commands and utilities for data conversion.
- * Only auth is custom (Bearer token instead of SigV4).
+ * Implements MaplibreGeocoderApi interface for compatibility with @maplibre/maplibre-gl-geocoder
  */
-export declare class GeoPlaces {
+export declare class GeoPlaces implements MaplibreGeocoderApi {
     private client;
     private map;
     constructor(client: GeoPlacesClient, map: Map);
-    forwardGeocode(config: {
-        query: string;
-        limit?: number;
-    }): Promise<FeatureCollection>;
-    reverseGeocode(config: {
-        query: [number, number];
-        limit?: number;
-        click?: boolean;
-    }): Promise<FeatureCollection>;
-    getSuggestions(config: {
-        query: string;
-    }): Promise<FeatureCollection>;
-    searchByPlaceId(placeId: string): Promise<FeatureCollection>;
+    private normalizeLanguage;
+    forwardGeocode(config: MaplibreGeocoderApiConfig): Promise<MaplibreGeocoderFeatureResults>;
+    reverseGeocode(config: MaplibreGeocoderApiConfig): Promise<MaplibreGeocoderFeatureResults>;
+    getSuggestions(config: MaplibreGeocoderApiConfig): Promise<MaplibreGeocoderSuggestionResults>;
+    searchByPlaceId(config: MaplibreGeocoderApiConfig): Promise<MaplibreGeocoderPlaceResults>;
+    localGeocode(config: MaplibreGeocoderApiConfig): Promise<MaplibreGeocoderFeatureResults>;
 }

package/dist/adapters/GeoPlaces.js

@@ -1,58 +1,117 @@
-import { placeToFeatureCollection } from '@aws/amazon-location-utilities-datatypes';
-import { GetPlaceCommand, ReverseGeocodeCommand, SearchNearbyCommand, SuggestCommand } from '@aws-sdk/client-geo-places';
+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
  *
- * Uses AWS Location Client commands and utilities for data conversion.
- * Only auth is custom (Bearer token instead of SigV4).
+ * Implements MaplibreGeocoderApi interface for compatibility with @maplibre/maplibre-gl-geocoder
  */
 export class GeoPlaces {
     constructor(client, map) {
         this.client = client;
         this.map = map;
     }
+    normalizeLanguage(language) {
+        if (Array.isArray(language))
+            return language[0] || 'en';
+        if (typeof language === 'string')
+            return language;
+        return 'en';
+    }
     async forwardGeocode(config) {
+        log('forwardGeocode query=%s', config.query);
         const center = this.map.getCenter();
-        const command = new SuggestCommand({
+        const biasPosition = config.proximity && config.proximity.length >= 2
+            ? [config.proximity[0], config.proximity[1]]
+            : [center.lng, center.lat];
+        const commandInput = {
             QueryText: config.query,
-            BiasPosition: [center.lng, center.lat],
+            BiasPosition: biasPosition,
             MaxResults: config.limit || 5,
-            Language: 'en'
-        });
-        const response = await this.client.send(command);
-        return placeToFeatureCollection(response, { flattenProperties: true });
+            Language: this.normalizeLanguage(config.language),
+        };
+        if (config.countries) {
+            commandInput.Filter = {
+                IncludeCountries: Array.isArray(config.countries) ? config.countries : config.countries.split(','),
+            };
+        }
+        const response = await this.client.send(new GeocodeCommand(commandInput));
+        const result = geocodeResponseToFeatureCollection(response, { flattenProperties: true });
+        log('forwardGeocode returned %d results', result.features?.length ?? 0);
+        return result;
     }
     async reverseGeocode(config) {
-        const command = config.click
-            ? new ReverseGeocodeCommand({
-                QueryPosition: config.query,
-                MaxResults: config.limit || 1,
-                Language: 'en'
-            })
-            : new SearchNearbyCommand({
-                QueryPosition: config.query,
-                MaxResults: config.limit || 15,
-                Language: 'en'
-            });
-        const response = await this.client.send(command);
-        return placeToFeatureCollection(response, { flattenProperties: true });
+        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),
+        };
+        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) {
+        log('getSuggestions query=%s', config.query);
         const center = this.map.getCenter();
-        const command = new SuggestCommand({
+        const biasPosition = config.proximity && config.proximity.length >= 2
+            ? [config.proximity[0], config.proximity[1]]
+            : [center.lng, center.lat];
+        const commandInput = {
             QueryText: config.query,
-            BiasPosition: [center.lng, center.lat],
-            Language: 'en'
-        });
-        const response = await this.client.send(command);
-        return placeToFeatureCollection(response, { flattenProperties: true });
+            BiasPosition: biasPosition,
+            MaxResults: config.limit || 5,
+            Language: this.normalizeLanguage(config.language),
+            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 } : {}),
+                },
+            } : {}),
+        };
+        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 });
+        }
+        log('getSuggestions returned %d suggestions', suggestions.suggestions.length);
+        return suggestions;
     }
-    async searchByPlaceId(placeId) {
+    async searchByPlaceId(config) {
+        log('searchByPlaceId placeId=%s', config.query);
         const command = new GetPlaceCommand({
-            PlaceId: placeId,
-            Language: 'en'
+            PlaceId: config.query,
+            Language: this.normalizeLanguage(config.language),
+            AdditionalFeatures: [
+                GetPlaceAdditionalFeature.ACCESS,
+                GetPlaceAdditionalFeature.SECONDARY_ADDRESSES,
+                GetPlaceAdditionalFeature.CONTACT,
+                GetPlaceAdditionalFeature.TIME_ZONE,
+            ],
         });
         const response = await this.client.send(command);
-        return placeToFeatureCollection(response, { flattenProperties: true });
+        const result = getPlaceResponseToFeatureCollection(response, { flattenProperties: true });
+        const carmenGeojsonFeatures = result.features.map(feature => ({
+            ...feature,
+            text: response.Title || '',
+            place_name: response.Address?.Label || '',
+            place_type: response.PlaceType ? [response.PlaceType] : [],
+            bbox: response.MapView,
+        }));
+        log('searchByPlaceId returned %d features', carmenGeojsonFeatures.length);
+        return { place: carmenGeojsonFeatures };
+    }
+    async localGeocode(config) {
+        return this.forwardGeocode(config);
     }
 }

package/dist/auth/TokenProvider.d.ts

@@ -1,7 +1,6 @@
 export interface TokenResponse {
     success: boolean;
     token?: string;
-    expiresIn?: number;
     expiresAt?: number;
     error?: string;
 }
@@ -26,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!,
@@ -41,10 +40,11 @@ export interface TokenProviderConfig {
 export declare class TokenProvider {
     private config;
     private cachedToken?;
-    private expiresAt?;
-    private oauth2Client;
+    private cachedExpiresAt?;
+    private tokenPromise?;
     constructor(config: TokenProviderConfig);
     getToken(forceRefresh?: boolean): Promise<TokenResponse>;
+    private fetchToken;
     private isExpired;
     clearCache(): void;
 }

package/dist/auth/TokenProvider.js

@@ -1,4 +1,3 @@
-import ClientOAuth2 from 'client-oauth2';
 import debug from 'debug';
 const log = debug('location-client:auth');
 /**
@@ -17,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!,
@@ -39,36 +38,70 @@ 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.expiresAt && !this.isExpired()) {
-            log('Using cached token (expires in %ds)', Math.floor((this.expiresAt - Date.now()) / 1000));
+        if (!forceRefresh && this.cachedToken && !this.isExpired()) {
+            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,
-                expiresAt: this.expiresAt
+                expiresAt: this.cachedExpiresAt
             };
         }
+        // If token fetch is already in progress, wait for it
+        if (this.tokenPromise) {
+            log('Token fetch in progress, waiting for existing request...');
+            return this.tokenPromise;
+        }
+        // Start new token fetch
         const reason = forceRefresh ? 'forced refresh' : (this.cachedToken ? 'token expired' : 'no cached token');
         log('Refreshing token (%s) from %s', reason, this.config.apiUrl);
+        this.tokenPromise = this.fetchToken();
+        try {
+            const result = await this.tokenPromise;
+            return result;
+        }
+        finally {
+            // Clear promise after completion (success or failure)
+            this.tokenPromise = undefined;
+        }
+    }
+    async fetchToken() {
         try {
-            const token = await this.oauth2Client.credentials.getToken();
-            const expiresIn = typeof token.data?.expires_in === 'number'
-                ? token.data.expires_in
-                : parseInt(token.data?.expires_in || '3600');
-            this.cachedToken = token.accessToken;
-            this.expiresAt = Date.now() + (expiresIn * 1000);
+            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,
-                expiresIn,
-                expiresAt: this.expiresAt,
+                expiresAt: this.cachedExpiresAt,
             };
         }
         catch (error) {
@@ -80,12 +113,12 @@ export class TokenProvider {
         }
     }
     isExpired(bufferSeconds = 60) {
-        if (!this.expiresAt)
+        if (!this.cachedExpiresAt)
             return true;
-        return Date.now() >= (this.expiresAt - bufferSeconds * 1000);
+        return Date.now() >= (this.cachedExpiresAt - bufferSeconds * 1000);
     }
     clearCache() {
         this.cachedToken = undefined;
-        this.expiresAt = 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 { AutocompleteCommand, GeocodeCommand, GetPlaceCommand, ReverseGeocodeCommand, SearchNearbyCommand, SearchTextCommand, SuggestCommand, } from '@aws-sdk/client-geo-places';
 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) {
@@ -15,46 +28,45 @@ export class GeoPlacesClient {
     async send(command) {
         const endpoint = this.getEndpoint(command);
         const url = `${this.clientConfig.apiUrl}${endpoint}`;
-        log('Sending %s request to %s', command.constructor.name, endpoint);
+        const commandName = command.constructor.name;
+        const input = command.input;
+        // 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(command)
+            body: JSON.stringify(input),
         });
         const duration = Date.now() - startTime;
         if (!response.ok) {
-            log('Request failed: %s %s (%dms)', response.status, response.statusText, duration);
-            throw new Error(`API request failed: ${response.statusText}`);
+            const errorText = await response.text();
+            logError('Request failed: %s %s (%dms)', response.status, response.statusText, duration);
+            let errorMessage = `API request failed: ${response.statusText}`;
+            try {
+                const errorData = JSON.parse(errorText);
+                if (errorData.message)
+                    errorMessage = errorData.message;
+            }
+            catch {
+                if (errorText)
+                    errorMessage = errorText;
+            }
+            throw new Error(errorMessage);
         }
+        const result = await response.json();
         log('Request successful: %s (%dms)', response.status, duration);
-        return response.json();
+        return result;
     }
     getEndpoint(command) {
-        if (command instanceof AutocompleteCommand) {
-            return '/address/autocomplete';
-        }
-        else if (command instanceof GeocodeCommand) {
-            return '/address/geocode';
-        }
-        else if (command instanceof GetPlaceCommand) {
-            return '/address/place';
-        }
-        else if (command instanceof ReverseGeocodeCommand) {
-            return '/address/search/reverse-geocode';
-        }
-        else if (command instanceof SearchNearbyCommand) {
-            return '/address/search/nearby';
-        }
-        else if (command instanceof SearchTextCommand) {
-            return '/address/search/text';
-        }
-        else if (command instanceof SuggestCommand) {
-            return '/address/suggestion';
+        for (const [CommandClass, endpoint] of ENDPOINT_MAP) {
+            if (command instanceof CommandClass)
+                return endpoint;
         }
-        throw new Error('Unknown command type');
+        throw new Error(`Unknown command type: ${command.constructor?.name ?? typeof command}`);
     }
 }

package/dist/index.d.ts

@@ -1,9 +1,7 @@
-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';
 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';

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
@@ -8,5 +6,7 @@ export * from '@aws-sdk/client-geo-places';
 export * from '@aws/amazon-location-utilities-datatypes';
 // Adapters (Custom - for MapLibre integration)
 export { GeoPlaces } from './adapters/GeoPlaces';
-// Server-only utilities
-export { getClientConfig } from './server/getClientConfig';
+// Maps utilities
+export { createTransformRequest } from './maps/createTransformRequest';
+export { transformRequest } from './maps/Utils';
+// Server-only utilities are available via '@chaosity/location-client/server'

package/dist/maps/Utils.d.ts

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

package/dist/maps/Utils.js

@@ -0,0 +1,5 @@
+import { createTransformRequest } from "./createTransformRequest";
+export function transformRequest(url, config) {
+    const token = config.getToken?.() ?? config.token;
+    return createTransformRequest(config.apiUrl, () => token)(url);
+}

package/dist/maps/createTransformRequest.d.ts

@@ -0,0 +1,10 @@
+import type { RequestTransformFunction } from 'maplibre-gl';
+/**
+ * Creates a transformRequest function for MapLibre that adds authentication
+ * and proper Accept headers for AWS Location Service API requests.
+ *
+ * @param apiUrl - Base URL of the Location Service API
+ * @param getToken - Callback function that returns the current auth token
+ * @returns MapLibre transformRequest function
+ */
+export declare function createTransformRequest(apiUrl: string, getToken: () => string | undefined): RequestTransformFunction;

package/dist/maps/createTransformRequest.js

@@ -0,0 +1,40 @@
+/**
+ * Creates a transformRequest function for MapLibre that adds authentication
+ * and proper Accept headers for AWS Location Service API requests.
+ *
+ * @param apiUrl - Base URL of the Location Service API
+ * @param getToken - Callback function that returns the current auth token
+ * @returns MapLibre transformRequest function
+ */
+export function createTransformRequest(apiUrl, getToken) {
+    return (url, resourceType) => {
+        if (url.startsWith(apiUrl)) {
+            const token = getToken();
+            if (!token) {
+                console.warn('[createTransformRequest] No token available');
+                return { url };
+            }
+            const headers = {
+                'Authorization': `Bearer ${token}`,
+            };
+            // Set appropriate Accept headers based on resource type
+            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 };
+    };
+}

package/dist/server/LocationServiceConnector.d.ts

@@ -0,0 +1,46 @@
+export interface ConnectorConfig {
+    apiUrl?: string;
+    token?: string;
+    getToken?: () => Promise<{
+        token: string;
+    }>;
+}
+export interface SendOptions {
+    headers?: Record<string, string>;
+}
+/**
+ * LocationServiceConnector - Server-side connector for Location Service API
+ *
+ * Optimized for backend-to-backend communication with:
+ * - Automatic configuration from environment variables
+ * - Automatic Origin header handling
+ * - Server-side token management
+ * - Enhanced error handling
+ *
+ * Uses AWS SDK command classes with Bearer token authentication.
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect from environment
+ * const connector = new LocationServiceConnector()
+ *
+ * // Or provide explicit config
+ * const connector = new LocationServiceConnector({
+ *   apiUrl: 'https://api.example.com',
+ *   token: 'your-token'
+ * })
+ *
+ * // Send with custom headers (including Origin)
+ * const result = await connector.send(
+ *   new SearchTextCommand({ QueryText: 'Space Needle' }),
+ *   { headers: { 'Origin': req.headers.origin } }
+ * )
+ * ```
+ */
+export declare class LocationServiceConnector {
+    private configPromise;
+    readonly serviceId: string;
+    constructor(config?: ConnectorConfig);
+    send<TInput, TOutput>(command: TInput, options?: SendOptions): Promise<TOutput>;
+    private getEndpoint;
+}

package/dist/server/LocationServiceConnector.js

@@ -0,0 +1,112 @@
+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');
+/**
+ * LocationServiceConnector - Server-side connector for Location Service API
+ *
+ * Optimized for backend-to-backend communication with:
+ * - Automatic configuration from environment variables
+ * - Automatic Origin header handling
+ * - Server-side token management
+ * - Enhanced error handling
+ *
+ * Uses AWS SDK command classes with Bearer token authentication.
+ *
+ * @example
+ * ```typescript
+ * // Auto-detect from environment
+ * const connector = new LocationServiceConnector()
+ *
+ * // Or provide explicit config
+ * const connector = new LocationServiceConnector({
+ *   apiUrl: 'https://api.example.com',
+ *   token: 'your-token'
+ * })
+ *
+ * // Send with custom headers (including Origin)
+ * const result = await connector.send(
+ *   new SearchTextCommand({ QueryText: 'Space Needle' }),
+ *   { headers: { 'Origin': req.headers.origin } }
+ * )
+ * ```
+ */
+export class LocationServiceConnector {
+    constructor(config) {
+        this.serviceId = 'Geo Places';
+        this.configPromise = config
+            ? Promise.resolve(config)
+            : getClientConfig();
+    }
+    async send(command, options) {
+        const config = await this.configPromise;
+        // Get token - ConnectorConfig may have getToken, ServerClientConfig has static 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');
+        }
+        const endpoint = this.getEndpoint(command);
+        const url = `${config.apiUrl}${endpoint}`;
+        const commandName = command.constructor.name;
+        const input = command.input;
+        log('Sending %s request to %s', commandName, endpoint);
+        const startTime = Date.now();
+        // Merge headers: user headers, then system headers override
+        const headers = {
+            ...(options?.headers || {}),
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${token}`
+        };
+        const response = await fetch(url, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify(input)
+        });
+        const duration = Date.now() - startTime;
+        if (!response.ok) {
+            const errorText = await response.text();
+            log('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) {
+                    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('Request successful: %s (%dms)', response.status, duration);
+        return result;
+    }
+    getEndpoint(command) {
+        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

@@ -1,9 +1,22 @@
 import { ClientConfig } from '../types';
-import { TokenProviderConfig } from '../auth/TokenProvider';
-export type ServerAuthConfig = TokenProviderConfig;
+export interface ServerAuthConfig {
+    apiUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+}
+export interface ServerClientConfig extends ClientConfig {
+    expiresAt?: number;
+}
 /**
  * Get client configuration with OAuth2 authentication.
  *
+ * Automatically reads from environment variables:
+ * - LOCATION_API_URL or LOCATION_SERVICE_API_URL
+ * - LOCATION_CLIENT_ID or LOCATION_SERVICE_CLIENT_ID
+ * - LOCATION_CLIENT_SECRET or LOCATION_SERVICE_CLIENT_SECRET
+ *
+ * You can override any value by passing it explicitly.
+ *
  * WARNING: This function uses client credentials (clientId/clientSecret).
  * Only call this from:
  * - Next.js Server Components/Actions
@@ -12,7 +25,16 @@ export type ServerAuthConfig = TokenProviderConfig;
  *
  * NEVER call from browser/client code as it exposes credentials.
  * For SPA projects, create your own backend endpoint that calls this.
+ *
+ * @example
+ * // Auto-detect from environment
+ * const config = await getClientConfig()
+ *
+ * // Or override specific values
+ * const config = await getClientConfig({ apiUrl: 'https://custom.api.com' })
+ *
+ * // Use getToken() for automatic caching and refresh
+ * const { token } = await config.getToken()
+ * const connector = new LocationServiceConnector({ apiUrl: config.apiUrl, token })
  */
-export declare function getClientConfig(config: ServerAuthConfig): Promise<ClientConfig & {
-    expiresAt?: number;
-}>;
+export declare function getClientConfig(config?: ServerAuthConfig): Promise<ServerClientConfig>;

package/dist/server/getClientConfig.js

@@ -1,7 +1,32 @@
+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.
  *
+ * Automatically reads from environment variables:
+ * - LOCATION_API_URL or LOCATION_SERVICE_API_URL
+ * - LOCATION_CLIENT_ID or LOCATION_SERVICE_CLIENT_ID
+ * - LOCATION_CLIENT_SECRET or LOCATION_SERVICE_CLIENT_SECRET
+ *
+ * You can override any value by passing it explicitly.
+ *
  * WARNING: This function uses client credentials (clientId/clientSecret).
  * Only call this from:
  * - Next.js Server Components/Actions
@@ -10,16 +35,49 @@ import { TokenProvider } from '../auth/TokenProvider';
  *
  * NEVER call from browser/client code as it exposes credentials.
  * For SPA projects, create your own backend endpoint that calls this.
+ *
+ * @example
+ * // Auto-detect from environment
+ * const config = await getClientConfig()
+ *
+ * // Or override specific values
+ * const config = await getClientConfig({ apiUrl: 'https://custom.api.com' })
+ *
+ * // Use getToken() for automatic caching and refresh
+ * const { token } = await config.getToken()
+ * const connector = new LocationServiceConnector({ apiUrl: config.apiUrl, token })
  */
-export async function getClientConfig(config) {
-    const provider = new TokenProvider(config);
+export async function getClientConfig(config = {}) {
+    log('[getClientConfig] Starting with config:', { hasApiUrl: !!config.apiUrl, hasClientId: !!config.clientId });
+    // Auto-detect from environment with fallbacks
+    const apiUrl = config.apiUrl ||
+        process.env.LOCATION_API_URL ||
+        process.env.LOCATION_SERVICE_API_URL;
+    const clientId = config.clientId ||
+        process.env.LOCATION_CLIENT_ID ||
+        process.env.LOCATION_SERVICE_CLIENT_ID;
+    const clientSecret = config.clientSecret ||
+        process.env.LOCATION_CLIENT_SECRET ||
+        process.env.LOCATION_SERVICE_CLIENT_SECRET;
+    log('[getClientConfig] Resolved config:', { apiUrl, clientId: clientId?.substring(0, 10) + '...' });
+    // Validate required values
+    if (!apiUrl || !clientId || !clientSecret) {
+        console.error('[getClientConfig] Missing required configuration');
+        throw new Error('Missing required configuration. Set environment variables: ' +
+            'LOCATION_API_URL, LOCATION_CLIENT_ID, LOCATION_CLIENT_SECRET');
+    }
+    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) {
+        console.error('[getClientConfig] Token fetch failed:', result.error);
         throw new Error(result.error || 'Failed to get token');
     }
+    log('[getClientConfig] Token fetched successfully, length:', result.token.length);
     return {
-        apiUrl: config.apiUrl,
+        apiUrl,
         token: result.token,
-        expiresAt: result.expiresAt,
+        expiresAt: result.expiresAt
     };
 }

package/dist/server/getConnector.d.ts

@@ -0,0 +1,37 @@
+import { LocationServiceConnector } from './LocationServiceConnector';
+export interface ServerAuthConfig {
+    apiUrl?: string;
+    clientId?: string;
+    clientSecret?: string;
+}
+/**
+ * Get LocationServiceConnector with automatic token management.
+ *
+ * Automatically reads from environment variables:
+ * - LOCATION_API_URL or LOCATION_SERVICE_API_URL
+ * - LOCATION_CLIENT_ID or LOCATION_SERVICE_CLIENT_ID
+ * - LOCATION_CLIENT_SECRET or LOCATION_SERVICE_CLIENT_SECRET
+ *
+ * You can override any value by passing it explicitly.
+ *
+ * WARNING: This function uses client credentials (clientId/clientSecret).
+ * Only call this from:
+ * - Next.js Server Components/Actions
+ * - Node.js backend servers
+ * - API routes
+ *
+ * NEVER call from browser/client code as it exposes credentials.
+ *
+ * @example
+ * // Server Action for React provider
+ * 'use server'
+ * export async function getLocationConnector() {
+ *   return getConnector()
+ * }
+ *
+ * // Or with custom config
+ * export async function getLocationConnector() {
+ *   return getConnector({ apiUrl: 'https://custom.api.com' })
+ * }
+ */
+export declare function getConnector(config?: ServerAuthConfig): LocationServiceConnector;

package/dist/server/getConnector.js

@@ -0,0 +1,34 @@
+import { LocationServiceConnector } from './LocationServiceConnector';
+/**
+ * Get LocationServiceConnector with automatic token management.
+ *
+ * Automatically reads from environment variables:
+ * - LOCATION_API_URL or LOCATION_SERVICE_API_URL
+ * - LOCATION_CLIENT_ID or LOCATION_SERVICE_CLIENT_ID
+ * - LOCATION_CLIENT_SECRET or LOCATION_SERVICE_CLIENT_SECRET
+ *
+ * You can override any value by passing it explicitly.
+ *
+ * WARNING: This function uses client credentials (clientId/clientSecret).
+ * Only call this from:
+ * - Next.js Server Components/Actions
+ * - Node.js backend servers
+ * - API routes
+ *
+ * NEVER call from browser/client code as it exposes credentials.
+ *
+ * @example
+ * // Server Action for React provider
+ * 'use server'
+ * export async function getLocationConnector() {
+ *   return getConnector()
+ * }
+ *
+ * // Or with custom config
+ * export async function getLocationConnector() {
+ *   return getConnector({ apiUrl: 'https://custom.api.com' })
+ * }
+ */
+export function getConnector(config) {
+    return new LocationServiceConnector(config);
+}

package/dist/server/index.d.ts

@@ -0,0 +1,6 @@
+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

@@ -0,0 +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,13 +1,25 @@
 {
   "name": "@chaosity/location-client",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Client library for Chaosity Location Service with AWS Location Service compatibility",
+  "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./server": {
+      "types": "./dist/server/index.d.ts",
+      "default": "./dist/server/index.js"
+    }
+  },
   "scripts": {
     "build": "tsc",
     "dev": "tsc --watch",
-    "test": "jest",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "prepublishOnly": "npm run build"
   },
   "keywords": [
@@ -31,11 +43,11 @@
   "dependencies": {
     "@aws-sdk/client-geo-places": "^3.0.0",
     "@aws/amazon-location-utilities-datatypes": "^1.0.0",
-    "client-oauth2": "^4.3.3",
-    "debug": "^4.4.3"
+    "@maplibre/maplibre-gl-geocoder": "^1.9.4",
+"debug": "^4.4.3"
   },
   "peerDependencies": {
-    "maplibre-gl": "^4.0.0"
+    "maplibre-gl": "^5.0.0"
   },
   "peerDependenciesMeta": {
     "maplibre-gl": {
@@ -44,7 +56,13 @@
   },
   "devDependencies": {
     "@types/debug": "^4.1.12",
-    "typescript": "^5.0.0"
+    "@types/node": "^25.0.3",
+    "maplibre-gl": "^5.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
   },
   "files": [
     "dist",