feat: improve new place API work

Author: cablate

src/cli.ts

@@ -32,6 +32,7 @@ export async function startServer(port?: number, apiKey?: string): Promise<void>
 
   Logger.log("🚀 Starting Google Maps MCP Server...");
   Logger.log("📍 Available tools: search_nearby, get_place_details, maps_geocode, maps_reverse_geocode, maps_distance_matrix, maps_directions, maps_elevation, echo");
+  Logger.log("ℹ️  Reminder: enable Places API (New) in https://console.cloud.google.com before using the new Place features.");
   Logger.log("");
 
   const startPromises = serverConfigs.map(async (config) => {

src/index.ts

@@ -6,3 +6,6 @@ export const Logger = {
     console.error("[ERROR]", ...args);
   },
 };
+
+export { PlacesSearcher } from "./services/PlacesSearcher.js";
+export { NewPlacesService } from "./services/NewPlacesService.js";

src/services/NewPlacesService.ts

@@ -4,12 +4,12 @@ import { Logger } from "../index.js";
 export class NewPlacesService {
   private client: PlacesClient;
   private readonly defaultLanguage: string = "en";
-
+  private readonly placeFieldMask: string = ["displayName", "name", "id", "formattedAddress", "location", "utcOffsetMinutes", "regularOpeningHours.periods", "regularOpeningHours.weekdayDescriptions", "currentOpeningHours.openNow", "nationalPhoneNumber", "websiteUri", "priceLevel", "rating", "userRatingCount", "reviews.rating", "reviews.text", "reviews.publishTime", "reviews.authorAttribution.displayName", "photos.heightPx", "photos.widthPx", "photos.name"].join(",");
   constructor(apiKey?: string) {
     this.client = new PlacesClient({
       apiKey: apiKey || process.env.GOOGLE_MAPS_API_KEY || "",
     });
-    
+
     if (!apiKey && !process.env.GOOGLE_MAPS_API_KEY) {
       throw new Error("Google Maps API Key is required");
     }
@@ -18,11 +18,20 @@ export class NewPlacesService {
   async getPlaceDetails(placeId: string) {
     try {
       const placeName = `places/${placeId}`;
-      
-      const [place] = await this.client.getPlace({
-        name: placeName,
-        languageCode: this.defaultLanguage,
-      });
+
+      const [place] = await this.client.getPlace(
+        {
+          name: placeName,
+          languageCode: this.defaultLanguage,
+        },
+        {
+          otherArgs: {
+            headers: {
+              "X-Goog-FieldMask": this.placeFieldMask,
+            },
+          },
+        }
+      );
 
       return this.transformPlaceResponse(place);
     } catch (error: any) {
@@ -34,7 +43,7 @@ export class NewPlacesService {
   private transformPlaceResponse(place: any) {
     return {
       name: place.displayName?.text || place.name || "",
-      place_id: place.id || "",
+      place_id: this.extractLegacyPlaceId(place),
       formatted_address: place.formattedAddress || "",
       geometry: {
         location: {
@@ -44,65 +53,155 @@ export class NewPlacesService {
       },
       rating: place.rating || 0,
       user_ratings_total: place.userRatingCount || 0,
-      opening_hours: place.regularOpeningHours ? {
-        open_now: this.isCurrentlyOpen(place.regularOpeningHours),
-        weekday_text: this.formatOpeningHours(place.regularOpeningHours),
-      } : undefined,
+      opening_hours: place.regularOpeningHours
+        ? {
+            open_now: this.isCurrentlyOpen(place.regularOpeningHours, place.utcOffsetMinutes, place.currentOpeningHours),
+            weekday_text: this.formatOpeningHours(place.regularOpeningHours),
+          }
+        : undefined,
       formatted_phone_number: place.nationalPhoneNumber || "",
       website: place.websiteUri || "",
       price_level: place.priceLevel || 0,
-      reviews: place.reviews?.map((review: any) => ({
-        rating: review.rating || 0,
-        text: review.text?.text || "",
-        time: review.publishTime?.seconds || 0,
-        author_name: review.authorAttribution?.displayName || "",
-      })) || [],
-      photos: place.photos?.map((photo: any) => ({
-        photo_reference: photo.name || "",
-        height: photo.heightPx || 0,
-        width: photo.widthPx || 0,
-      })) || [],
+      reviews:
+        place.reviews?.map((review: any) => ({
+          rating: review.rating || 0,
+          text: review.text?.text || "",
+          time: review.publishTime?.seconds || 0,
+          author_name: review.authorAttribution?.displayName || "",
+        })) || [],
+      photos:
+        place.photos?.map((photo: any) => ({
+          photo_reference: photo.name || "",
+          height: photo.heightPx || 0,
+          width: photo.widthPx || 0,
+        })) || [],
     };
   }
 
-  private isCurrentlyOpen(openingHours: any): boolean {
-    if (!openingHours?.weekdayDescriptions) {
+  private extractLegacyPlaceId(place: any): string {
+    const resourceName = place?.name;
+
+    if (typeof resourceName === "string" && resourceName.startsWith("places/")) {
+      const legacyId = resourceName.substring("places/".length);
+      if (legacyId) {
+        return legacyId;
+      }
+    }
+
+    return place?.id || "";
+  }
+
+  private isCurrentlyOpen(openingHours: any, utcOffsetMinutes?: number, currentOpeningHours?: any): boolean {
+    if (typeof currentOpeningHours?.openNow === "boolean") {
+      return currentOpeningHours.openNow;
+    }
+
+    if (typeof openingHours?.openNow === "boolean") {
+      return openingHours.openNow;
+    }
+
+    const periods = openingHours?.periods;
+
+    if (!Array.isArray(periods) || periods.length === 0) {
       return false;
     }
 
-    const now = new Date();
-    const currentDay = now.getDay();
-    const currentTime = now.getHours() * 60 + now.getMinutes();
+    const minutesInDay = 24 * 60;
+    const minutesInWeek = minutesInDay * 7;
+
+    const { day: localDay, minutes: localMinutes } = this.getLocalTimeComponents(utcOffsetMinutes);
+    const localTimeValue = localDay * minutesInDay + localMinutes;
 
     const dayMapping = {
-      "SUNDAY": 0,
-      "MONDAY": 1,
-      "TUESDAY": 2,
-      "WEDNESDAY": 3,
-      "THURSDAY": 4,
-      "FRIDAY": 5,
-      "SATURDAY": 6,
+      SUNDAY: 0,
+      MONDAY: 1,
+      TUESDAY: 2,
+      WEDNESDAY: 3,
+      THURSDAY: 4,
+      FRIDAY: 5,
+      SATURDAY: 6,
     };
 
-    const todayHours = openingHours.weekdayDescriptions.find((desc: string) => {
-      const dayName = Object.keys(dayMapping).find(day => 
-        desc.toUpperCase().includes(day)
-      );
-      return dayName && dayMapping[dayName as keyof typeof dayMapping] === currentDay;
-    });
+    const toDayNumber = (value: any): number | undefined => {
+      if (typeof value === "number" && value >= 0 && value <= 6) {
+        return value;
+      }
+      if (typeof value === "string") {
+        const normalized = value.toUpperCase();
+        if (normalized in dayMapping) {
+          return dayMapping[normalized as keyof typeof dayMapping];
+        }
+      }
+      return undefined;
+    };
 
-    if (!todayHours) {
-      return false;
-    }
+    const toMinutes = (time: any): number | undefined => {
+      if (!time) {
+        return undefined;
+      }
 
-    if (todayHours.toLowerCase().includes("closed")) {
-      return false;
+      const hours = typeof time.hours === "number" ? time.hours : Number(time.hours ?? NaN);
+      const minutes = typeof time.minutes === "number" ? time.minutes : Number(time.minutes ?? NaN);
+
+      if (!Number.isFinite(hours) || !Number.isFinite(minutes)) {
+        return undefined;
+      }
+
+      return hours * 60 + minutes;
+    };
+
+    for (const period of periods) {
+      const openDay = toDayNumber(period?.openDay);
+      const closeDay = toDayNumber(period?.closeDay ?? period?.openDay);
+      const openMinutes = toMinutes(period?.openTime);
+      const closeMinutes = toMinutes(period?.closeTime);
+
+      if (openDay === undefined || openMinutes === undefined) {
+        continue;
+      }
+
+      let start = openDay * minutesInDay + openMinutes;
+      let end: number;
+
+      if (closeDay === undefined || closeMinutes === undefined) {
+        end = start + minutesInDay;
+      } else {
+        end = closeDay * minutesInDay + closeMinutes;
+      }
+
+      if (end <= start) {
+        end += minutesInWeek;
+      }
+
+      let comparableLocalTime = localTimeValue;
+      while (comparableLocalTime < start) {
+        comparableLocalTime += minutesInWeek;
+      }
+
+      if (comparableLocalTime >= start && comparableLocalTime < end) {
+        return true;
+      }
     }
-    if (todayHours.toLowerCase().includes("24 hours")) {
-      return true;
+
+    return false;
+  }
+
+  private getLocalTimeComponents(utcOffsetMinutes?: number): { day: number; minutes: number } {
+    const now = new Date();
+
+    if (typeof utcOffsetMinutes === "number" && Number.isFinite(utcOffsetMinutes)) {
+      const localTime = new Date(now.getTime() + utcOffsetMinutes * 60000);
+
+      return {
+        day: localTime.getUTCDay(),
+        minutes: localTime.getUTCHours() * 60 + localTime.getUTCMinutes(),
+      };
     }
 
-    return true;
+    return {
+      day: now.getDay(),
+      minutes: now.getHours() * 60 + now.getMinutes(),
+    };
   }
 
   private formatOpeningHours(openingHours: any): string[] {
@@ -111,11 +210,11 @@ export class NewPlacesService {
 
   private extractErrorMessage(error: any): string {
     const apiError = error?.message || error?.details || error?.status;
-    
+
     if (apiError) {
       return `${apiError}`;
     }
 
     return error instanceof Error ? error.message : String(error);
   }
-}
+}

src/services/PlacesSearcher.ts

@@ -122,7 +122,7 @@ export class PlacesSearcher {
           phone: details.formatted_phone_number,
           website: details.website,
           price_level: details.price_level,
-          reviews: details.reviews?.map((review) => ({
+          reviews: details.reviews?.map((review: any) => ({
             rating: review.rating,
             text: review.text,
             time: review.time,

test-new-api.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-import { PlacesSearcher } from './dist/services/PlacesSearcher.js';
+import { PlacesSearcher, NewPlacesService } from './dist/index.js';
 
 async function testNewPlacesAPI() {
   console.log('Testing new Places API implementation...');
@@ -15,25 +15,46 @@ async function testNewPlacesAPI() {
 
   try {
     const placesSearcher = new PlacesSearcher(apiKey);
+    const placesService = new NewPlacesService(apiKey);
 
     const testPlaceId = 'ChIJQ2BmJhVwhlQRPkt6FWiet90';
     console.log(`Testing with place ID: ${testPlaceId}`);
 
+    const rawDetails = await placesService.getPlaceDetails(testPlaceId);
+    if (rawDetails.place_id !== testPlaceId) {
+      console.error('❌ Legacy place_id mismatch');
+      console.error(`Expected: ${testPlaceId}`);
+      console.error(`Received: ${rawDetails.place_id}`);
+      process.exit(1);
+    } else {
+      console.log('✅ Legacy place_id preserved');
+    }
+
+    if (rawDetails.opening_hours?.open_now !== undefined) {
+      console.log(`ℹ️  open_now flag from NewPlacesService: ${rawDetails.opening_hours.open_now}`);
+    } else {
+      console.log('ℹ️  open_now flag unavailable for this place (no opening hours data).');
+    }
+    
     const result = await placesSearcher.getPlaceDetails(testPlaceId);
 
     if (result.success) {
-      console.log('✅ Successfully retrieved place details using new Places API!');
+      console.log('✅ Successfully retrieved place details using PlacesSearcher wrapper!');
       console.log('Place details:');
       console.log(JSON.stringify(result.data, null, 2));
     } else {
-      console.error('❌ Failed to retrieve place details:');
+      console.error('❌ Failed to retrieve place details via PlacesSearcher:');
       console.error(result.error);
     }
 
   } catch (error) {
     console.error('❌ Error during test:');
     console.error(error.message);
+    process.exit(1);
   }
 }
 
-testNewPlacesAPI().catch(console.error);
+testNewPlacesAPI().catch((error) => {
+  console.error('❌ Unhandled error during test:', error);
+  process.exit(1);
+});