feat: add venue import from Google Maps

.env.example

@@ -18,7 +18,7 @@ NUXT_PUBLIC_POSTHOG_DISABLED=true
 # Maps and Auth
 GOOGLE_CLIENT_ID=GOOGLE_CLIENT_ID
 GOOGLE_CLIENT_SECRET=GOOGLE_CLIENT_SECRET
-GOOGLE_MAPS_API_KEY=GOOGLE_MAPS_API_KEY
+NUXT_GOOGLE_MAPS_API_KEY=GOOGLE_MAPS_API_KEY
 GOOGLE_MAPS_API_KEY_BACKEND=GOOGLE_MAPS_API_KEY_BACKEND
 FIREBASE_SALT_SEPARATOR=c2U=
 FIREBASE_SIGNER_KEY=c29tZS12ZXJ5LXNlY3JldC1zdHJpbmc=

components/inputs/VenueInput.vue

@@ -24,7 +24,6 @@ function getVenue(address: any) {
 
   return $client.profiles.findVenueOrCreate.mutate({
     placeId: address.place_id,
-    googleMapsPlace: address,
   })
 }
 

prisma/schema.prisma

@@ -201,10 +201,6 @@ model Profile {
 
   calendars Calendar[] @relation("calendar_owner")
 
-  ConversationAsA Conversation[] @relation("AProfile")
-  ConversationAsB Conversation[] @relation("BProfile")
-  messages        Message[]
-
   @@index([photo])
   @@index([userId])
   @@index([cityId])
@@ -295,8 +291,9 @@ model Event {
   guests          Guest[]          @relation("event_guests")
   ticketPurchases TicketPurchase[] @relation("event_purchases")
 
-  createdAt      DateTime        @default(now())
-  updatedAt      DateTime        @updatedAt
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
   calendarEvents CalendarEvent[] @relation("calendar_event_to_event")
 }
 
@@ -603,7 +600,7 @@ model Calendar {
   name String @default("")
 
   profileId String
-  profile   Profile @relation("calendar_owner", fields: [profileId], references: [id])
+  profile   Profile @relation("calendar_owner", fields: [profileId], references: [id], onDelete: Cascade)
 
   state        String    @default("pending") // pending, processing, processed, failed
   lastSyncedAt DateTime?
@@ -652,42 +649,3 @@ model CalendarEvent {
   @@index([calendarId, startDate])
   @@index([facebookId])
 }
-
-model Conversation {
-  id            String    @id @default(cuid())
-  pairKey       String    @unique // `${min(aId,bId)}-${max(aId,bId)}`
-  aId           String
-  bId           String
-  aLastSeenAt   DateTime?
-  bLastSeenAt   DateTime?
-  lastMessageId String?   @unique
-  lastMessage   Message?  @relation("LastMessage", fields: [lastMessageId], references: [id])
-
-  messages Message[] @relation("ConversationMessages")
-
-  a Profile @relation("AProfile", fields: [aId], references: [id])
-  b Profile @relation("BProfile", fields: [bId], references: [id])
-
-  createdAt DateTime @default(now())
-  updatedAt DateTime @updatedAt
-
-  @@unique([aId, bId])
-  @@index([aId, updatedAt])
-  @@index([bId, updatedAt])
-}
-
-model Message {
-  id             String        @id @default(cuid())
-  conversationId String
-  senderId       String
-  content        String        @db.Text
-  createdAt      DateTime      @default(now())
-  updatedAt      DateTime      @updatedAt
-  lastMessageFor Conversation? @relation("LastMessage")
-
-  conversation Conversation @relation("ConversationMessages", fields: [conversationId], references: [id], onDelete: Cascade)
-  sender       Profile      @relation(fields: [senderId], references: [id])
-
-  @@index([conversationId, createdAt])
-  @@index([senderId, createdAt])
-}

server/trpc/routers/cities.ts

@@ -1,7 +1,7 @@
 import { publicProcedure, router } from '~/server/trpc/init'
 import { prisma } from '~/server/prisma'
 import { z } from 'zod'
-import { addCity } from '~/server/utils/city'
+import { findOrCreateCity } from '~/server/utils/city'
 
 export const citiesRouter = router({
   popular: publicProcedure.query(async ({ ctx }) => {
@@ -106,6 +106,6 @@ export const citiesRouter = router({
     .mutation(async ({ ctx, input }) => {
       const { city } = input
 
-      return await addCity(city)
+      return await findOrCreateCity(city.id)
     }),
 })

server/trpc/routers/profiles.ts

@@ -3,6 +3,15 @@ import { publicProcedure, router } from '~/server/trpc/init'
 import { prisma } from '~/server/prisma'
 import { getServerSession } from '#auth'
 import { privacySettingsSchema } from '~/schemas/profile'
+import {
+  getCityIdFromGooglePlace,
+  getPlaceDetails,
+} from '~/server/utils/google_maps'
+import { TRPCError } from '@trpc/server'
+import { findOrCreateCity } from '~/server/utils/city'
+import { getSlug } from '~/utils/slug'
+import { AddressType } from '@googlemaps/google-maps-services-js'
+import { toCalendar } from '@internationalized/date'
 
 const profileUpdateSchema = z.object({
   bio: z.string().optional(),
@@ -304,21 +313,95 @@ export const profilesRouter = router({
 
       return { profiles, totalCount, hasMore, nextPage }
     }),
+
   findVenueOrCreate: publicProcedure
-    .input(z.object({ placeId: z.string(), googleMapsPlace: z.any() }))
+    .input(z.object({ placeId: z.string() }))
     .mutation(async ({ input }) => {
-      const { placeId, googleMapsPlace } = input
+      const { placeId } = input
+      const place = await getPlaceDetails(placeId)
+      if (!place || !place.name) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'Invalid Google Place ID or place has no name.',
+        })
+      }
+      const placeTypes = place.types || []
+      if (
+        placeTypes.includes(AddressType.locality) ||
+        placeTypes.includes(AddressType.administrative_area_level_1) ||
+        placeTypes.includes(AddressType.country)
+      ) {
+        throw new TRPCError({
+          code: 'BAD_REQUEST',
+          message: 'Please select a specific venue, not a city or region.',
+        })
+      }
+      return await prisma.$transaction(async (tx) => {
+        const existingVenue = await tx.profile.findFirst({
+          where: { placeId },
+        })
+        if (existingVenue) {
+          return existingVenue
+        }
 
-      const existingVenue = await prisma.profile.findFirst({
-        where: {
-          placeId,
-        },
-      })
+        // Get the city's unique Place ID from the venue's data.
+        const cityPlaceId = await getCityIdFromGooglePlace(place)
 
-      if (existingVenue) {
-        return existingVenue
-      }
+        if (!cityPlaceId) {
+          throw new TRPCError({
+            code: 'BAD_REQUEST',
+            message: 'Could not determine a city for the selected venue.',
+          })
+        }
+
+        let city
+        try {
+          city = await findOrCreateCity(cityPlaceId)
+        } catch (error) {
+          console.error('Error in findOrCreateCity', error)
+          throw new TRPCError({
+            code: 'INTERNAL_SERVER_ERROR',
+            message: `Failed to create city: ${error}`,
+          })
+        }
 
-      throw new Error('Venue not found')
+        // Generate a unique username for the venue to avoid conflicts.
+        const baseSlug = getSlug(place.name!)
+        let username = baseSlug
+        const existingProfile = await tx.profile.findFirst({
+          where: { username },
+        })
+        if (existingProfile) {
+          username = getSlug(`${place.name!}-${city.name}`)
+          const anotherExisting = await tx.profile.findFirst({
+            where: { username },
+          })
+          if (anotherExisting) {
+            throw new Error(
+              `Could not generate a unique username for this venue.`
+            )
+          }
+        }
+        try {
+          const newVenue = await tx.profile.create({
+            data: {
+              name: place.name!,
+              username,
+              type: 'Venue',
+              placeId,
+              cityId: city.id,
+              formattedAddress: place.formatted_address,
+              website: place.website || null,
+              phone: place.international_phone_number || null,
+              lat: place.geometry?.location?.lat || null,
+              lng: place.geometry?.location?.lng || null,
+              mapUrl: place.url || null,
+            },
+          })
+          return newVenue
+        } catch (error) {
+          throw error
+        }
+      })
     }),
 })

server/utils/city.ts

@@ -1,7 +1,6 @@
 import { getCountryCode } from '~/utils/country'
 import { getSlug } from '~/utils/slug'
 import { prisma } from '~/server/prisma'
-import fetch from 'node-fetch'
 
 const addressPart = (result: any, type: string) => {
   if (!result || !result.address_components) {
@@ -45,7 +44,7 @@ const getAddress = (places: any) => {
 
 const getAddressFromPlaceId = async (placeId: string) => {
   if (!placeId) {
-    return {}
+    return null
   }
 
   const apiKey = useRuntimeConfig().public.googleMapsApiKey
@@ -60,51 +59,63 @@ const getAddressFromPlaceId = async (placeId: string) => {
   return getAddress(data.results)
 }
 
-export async function addCity(city: any) {
-  const address = await getAddressFromPlaceId(city.id)
-
-  const existingCity = await prisma.city.findUnique({
-    where: { id: city.id },
+export async function findOrCreateCity(placeId: string) {
+  const existing = await prisma.city.findUnique({
+    where: { id: placeId },
   })
+  if (existing) return existing
 
-  if (!!existingCity) {
-    return existingCity
-  }
+  const address = await getAddressFromPlaceId(placeId)
 
-  const { locality, region, country } = address
+  if (!address || !address.locality || !address.country) {
+    throw new Error("Couldn't determine city from Google data")
+  }
+  const { locality, region, country, lat, lng } = address
 
   let slug = getSlug(locality)
-
-  let existingLocality = await prisma.city.findFirst({
+  const existingLocality = await prisma.city.findFirst({
     where: { slug },
   })
 
-  if (!!existingLocality) {
-    slug = getSlug([region, locality].join('-'))
+  if (existingLocality) {
+    slug = getSlug(`${region} ${locality}`)
   }
-
-  let existingRegion = await prisma.city.findFirst({
+  const existingRegion = await prisma.city.findFirst({
     where: { slug },
   })
-
-  if (!!existingRegion) {
-    throw new Error(`city: region-locality slug already exists: ${slug}`)
+  if (existingRegion) {
+    throw new Error(
+      `City slug conflict: A city with slug "${slug}" already exists.`
+    )
   }
 
-  const result = {
-    id: city.id,
+  const countryCode = await getCountryCode(country)
+
+  const createData = {
+    id: placeId,
     name: locality,
-    region,
-    slug,
-    countryCode: await getCountryCode(country),
-    description: '',
-    lat: address.lat,
-    lng: address.lng,
+    region: region || '',
+    slug: slug,
+    countryCode,
+    lat: address.lat ?? 0,
+    lng: address.lng ?? 0,
+  }
+  const updateData = {
+    name: locality,
+    region: region || '',
+    countryCode,
+    lat: address.lat ?? 0,
+    lng: address.lng ?? 0,
   }
 
-  const newCity = await prisma.city.create({
-    data: result,
-  })
-
-  return newCity
+  try {
+    const city = await prisma.city.upsert({
+      where: { id: placeId },
+      create: createData,
+      update: updateData,
+    })
+    return city
+  } catch (error) {
+    throw error
+  }
 }