Nick changes

Author: spalmurray-codecov

src/services/events/amplitude/amplitude.ts

@@ -1,10 +1,12 @@
 import * as amplitude from '@amplitude/analytics-browser'
 
+import config from 'config'
+
 import { providerToInternalProvider } from 'shared/utils/provider'
 
 import { Event, EventContext, EventTracker, Identity } from '../types'
 
-const AMPLITUDE_API_KEY = process.env.REACT_APP_AMPLITUDE_API_KEY
+const AMPLITUDE_API_KEY = config.AMPLITUDE_API_KEY
 
 export function initAmplitude() {
   if (!AMPLITUDE_API_KEY) {
@@ -24,7 +26,7 @@ export class AmplitudeEventTracker implements EventTracker {
   identity?: Identity
 
   identify(identity: Identity) {
-    if (JSON.stringify(this.identity) === JSON.stringify(identity)) {
+    if (this.identity?.userOwnerId === identity.userOwnerId) {
       // Don't identify this user again this session.
       return
     }

src/services/events/events.ts

@@ -1,13 +1,19 @@
 import { captureException } from '@sentry/react'
-import { useEffect } from 'react'
+import { useQuery as useQueryV5 } from '@tanstack/react-queryV5'
+import { useRef } from 'react'
 import { useParams } from 'react-router'
 
-import { useRepo } from 'services/repo'
-import { useOwner } from 'services/user'
+import { Provider } from 'shared/api/helpers'
 
 import { AmplitudeEventTracker, initAmplitude } from './amplitude/amplitude'
-import { StubbedEventTracker } from './stub'
-import { EventTracker } from './types'
+import { OwnerContextQueryOpts, RepoContextQueryOpts } from './hooks'
+import { Event, EventContext, EventTracker, Identity } from './types'
+
+class StubbedEventTracker implements EventTracker {
+  identify(_identity: Identity): void {}
+  track(_event: Event): void {}
+  setContext(_context: EventContext): void {}
+}
 
 // EventTracker singleton
 let EVENT_TRACKER: EventTracker = new StubbedEventTracker()
@@ -19,7 +25,7 @@ export function initEventTracker(): void {
     EVENT_TRACKER = new AmplitudeEventTracker()
   } catch (e) {
     if (process.env.REACT_APP_ENV === 'production') {
-      // If in production, we need to know this has occured.
+      // If in production, we need to know this has occurred.
       captureException(e)
     }
   }
@@ -33,32 +39,39 @@ export function eventTracker(): EventTracker {
 // Hook to keep the global EventTracker's context up-to-date.
 export function useEventContext() {
   const { provider, owner, repo } = useParams<{
-    provider?: string
+    provider: Provider
     owner?: string
     repo?: string
   }>()
+  const context = useRef<EventContext>({})
 
-  const { data: ownerData } = useOwner({ username: owner })
-  const { data: repoData } = useRepo({
-    provider: provider || '',
-    owner: owner || '',
-    repo: repo || '',
-    opts: { enabled: !!(provider && owner && repo) },
-  })
+  const { data: ownerData } = useQueryV5(
+    OwnerContextQueryOpts({ provider, owner })
+  )
+  const { data: repoData } = useQueryV5(
+    RepoContextQueryOpts({ provider, owner, repo })
+  )
 
-  useEffect(() => {
-    EVENT_TRACKER.setContext({
+  if (
+    ownerData?.ownerid !== context.current.owner?.id ||
+    repoData?.repoid !== context.current.repo?.id
+  ) {
+    // only update if this is a new owner or repo
+    const newContext: EventContext = {
       owner: ownerData?.ownerid
         ? {
             id: ownerData?.ownerid,
           }
         : undefined,
-      repo: repoData?.repository
+      repo: repoData?.repoid
         ? {
-            id: repoData?.repository?.repoid,
-            isPrivate: repoData?.repository.private || undefined,
+            id: repoData.repoid,
+            isPrivate: repoData.private === null ? undefined : repoData.private,
           }
         : undefined,
-    })
-  }, [ownerData, repoData])
+    }
+    console.log(newContext)
+    EVENT_TRACKER.setContext(newContext)
+    context.current = newContext
+  }
 }

src/services/events/hooks.tsx

@@ -0,0 +1,175 @@
+import { queryOptions as queryOptionsV5 } from '@tanstack/react-queryV5'
+import { z } from 'zod'
+
+import {
+  RepoNotFoundErrorSchema,
+  RepoOwnerNotActivatedErrorSchema,
+} from 'services/repo'
+import Api from 'shared/api'
+import { Provider, rejectNetworkError } from 'shared/api/helpers'
+import A from 'ui/A'
+
+const OwnerContextSchema = z.object({
+  owner: z
+    .object({
+      ownerid: z.number().nullable(),
+    })
+    .nullable(),
+})
+
+const ownerContextQuery = `
+  query OwnerContext($owner: String!) {
+    owner(username: $owner) {
+      ownerid
+    }
+  }
+`
+
+interface OwnerContextQueryOptsArgs {
+  provider: Provider
+  owner?: string
+}
+
+export const OwnerContextQueryOpts = ({
+  provider,
+  owner,
+}: OwnerContextQueryOptsArgs) =>
+  queryOptionsV5({
+    queryKey: ['OwnerContext', provider, owner],
+    queryFn: ({ signal }) =>
+      Api.graphql({
+        provider,
+        query: ownerContextQuery,
+        signal,
+        variables: {
+          owner,
+        },
+      }).then((res) => {
+        const parsedRes = OwnerContextSchema.safeParse(res.data)
+
+        console.log('aewsr')
+
+        if (!parsedRes.success) {
+          return rejectNetworkError({
+            status: 404,
+            data: {},
+            dev: 'OwnerContextQueryOpts - 404 Failed to parse data',
+          })
+        }
+
+        return parsedRes.data.owner
+      }),
+    enabled: !!owner,
+    // Fetch this data only once per session
+    staleTime: Infinity,
+    gcTime: Infinity,
+  })
+
+const RepositorySchema = z.object({
+  __typename: z.literal('Repository'),
+  repoid: z.number(),
+  private: z.boolean().nullable(),
+})
+
+const RepoContextSchema = z.object({
+  owner: z
+    .object({
+      repository: z
+        .discriminatedUnion('__typename', [
+          RepositorySchema,
+          RepoNotFoundErrorSchema,
+          RepoOwnerNotActivatedErrorSchema,
+        ])
+        .nullable(),
+    })
+    .nullable(),
+})
+
+const repoContextQuery = `
+  query RepoContext($owner: String!, $repo: String!) {
+    owner(username: $owner) {
+      repository(name: $repo) {
+        __typename
+        ... on Repository {
+          repoid
+          private
+        }
+        ... on NotFoundError {
+          message
+        }
+        ... on OwnerNotActivatedError {
+          message
+        }
+      }
+    }
+  }
+`
+
+interface RepoContextQueryOptsArgs {
+  provider: Provider
+  owner?: string
+  repo?: string
+}
+
+export const RepoContextQueryOpts = ({
+  provider,
+  owner,
+  repo,
+}: RepoContextQueryOptsArgs) =>
+  queryOptionsV5({
+    queryKey: ['RepoContext', provider, owner, repo],
+    queryFn: ({ signal }) =>
+      Api.graphql({
+        provider,
+        query: repoContextQuery,
+        signal,
+        variables: {
+          owner,
+          repo,
+        },
+      }).then((res) => {
+        const parsedRes = RepoContextSchema.safeParse(res.data)
+
+        if (!parsedRes.success) {
+          return rejectNetworkError({
+            status: 404,
+            data: {},
+            dev: 'RepoContextQueryOpts - 404 Failed to parse data',
+          })
+        }
+
+        if (parsedRes.data?.owner?.repository?.__typename === 'NotFoundError') {
+          return rejectNetworkError({
+            status: 404,
+            data: {},
+            dev: 'RepoContextQueryOpts - 404 NotFoundError',
+          })
+        }
+
+        if (
+          parsedRes.data?.owner?.repository?.__typename ===
+          'OwnerNotActivatedError'
+        ) {
+          return rejectNetworkError({
+            status: 403,
+            data: {
+              detail: (
+                <p>
+                  Activation is required to view this repo, please{' '}
+                  {/* @ts-expect-error - A hasn't been typed yet */}
+                  <A to={{ pageName: 'membersTab' }}>click here </A> to activate
+                  your account.
+                </p>
+              ),
+            },
+            dev: 'RepoContextQueryOpts - 404 OwnerNotActivatedError',
+          })
+        }
+
+        return parsedRes.data.owner?.repository
+      }),
+    enabled: !!owner && !!repo,
+    // Fetch this data only once per session
+    staleTime: Infinity,
+    gcTime: Infinity,
+  })

src/services/events/stub.ts

@@ -18,19 +18,23 @@ import { Provider } from 'shared/api/helpers'
 //    accidental correlation of unrelated events.
 //  - Never include names, only use ids. E.g., use repoid instead of repo name.
 //
+//
+// If this union type grows too unwieldy, we can split each event out into its
+// own type.
+//
 
 export type Event =
   | {
       type: 'Button Clicked'
       properties: {
-        buttonType: 'Install GitHub App' | 'Configure Repo'
+        buttonType: ButtonType
         buttonLocation?: string
       }
     }
   | {
       type: 'Page Viewed'
       properties: {
-        pageName: 'Owner Page'
+        pageName: PageName
       }
     }
 
@@ -74,3 +78,11 @@ export abstract class EventTracker {
     )
   }
 }
+
+//
+// String union types to make the above Event type easier to visually parse.
+// Extend as needed.
+//
+
+type ButtonType = 'Install GitHub App' | 'Configure Repo'
+type PageName = 'Owner Page'