chore: Convert to TS - services selfHosted, access, pull, nav

src/pages/RepoPage/BundlesTab/BundleContent/BundleSelection/BundleSelector.tsx

@@ -101,7 +101,6 @@ const BundleSelector = forwardRef<any, BranchSelectorProps>(
                 history.push(
                   bundlesLink.path({
                     branch,
-                    // @ts-expect-error - useNavLinks needs to be typed
                     bundle: encodeURIComponent(name),
                   })
                 )

src/services/access/useGenerateUserToken.test.jsx → src/services/access/useGenerateUserToken.test.tsx

@@ -2,14 +2,15 @@ import { QueryClient, QueryClientProvider } from '@tanstack/react-query'
 import { renderHook, waitFor } from '@testing-library/react'
 import { graphql, HttpResponse } from 'msw'
 import { setupServer } from 'msw/node'
+import { PropsWithChildren } from 'react'
 import { MemoryRouter, Route } from 'react-router-dom'
 
 import { useGenerateUserToken } from './index'
 
 const queryClient = new QueryClient({
   defaultOptions: { queries: { retry: false } },
 })
-const wrapper = ({ children }) => (
+const wrapper: React.FC<PropsWithChildren> = ({ children }) => (
   <MemoryRouter initialEntries={['/gh']}>
     <Route path="/:provider">
       <QueryClientProvider client={queryClient}>{children}</QueryClientProvider>
@@ -34,25 +35,32 @@ afterAll(() => {
 })
 
 describe('useGenerateUserToken', () => {
-  function setup(dataReturned) {
+  function setup() {
     server.use(
       graphql.mutation(`CreateUserToken`, (info) => {
-        return HttpResponse.json({ data: dataReturned })
+        return HttpResponse.json({
+          data: {
+            createUserToken: {
+              error: null,
+              fullToken: 'some-token',
+            },
+          },
+        })
       })
     )
   }
 
   describe('when called', () => {
     describe('when calling the mutation', () => {
       it('returns success', async () => {
-        setup({ me: null })
+        setup()
 
         const { result } = renderHook(
           () => useGenerateUserToken({ provider }),
           { wrapper }
         )
 
-        result.current.mutate({ sessionid: 1 })
+        result.current.mutate({ name: '1' })
 
         await waitFor(() => expect(result.current.isSuccess).toBeTruthy())
       })

src/services/access/useGenerateUserToken.ts

@@ -0,0 +1,65 @@
+import { useMutation, useQueryClient } from '@tanstack/react-query'
+import { z } from 'zod'
+
+import Api from 'shared/api'
+import { NetworkErrorObject } from 'shared/api/helpers'
+
+import { USER_TOKEN_TYPE } from './constants'
+
+const UseGenerateTokenResponseSchema = z.object({
+  createUserToken: z
+    .object({
+      error: z
+        .union([
+          z.object({
+            __typename: z.literal('ValidationError'),
+            message: z.string(),
+          }),
+          z.object({
+            __typename: z.literal('UnauthenticatedError'),
+            message: z.string(),
+          }),
+        ])
+        .nullable(),
+      fullToken: z.string().nullable(),
+    })
+    .nullable(),
+})
+
+export function useGenerateUserToken({ provider }: { provider: string }) {
+  const queryClient = useQueryClient()
+  return useMutation({
+    mutationFn: ({ name }: { name: string }) => {
+      const query = `
+        mutation CreateUserToken($input: CreateUserTokenInput!) {
+          createUserToken(input: $input) {
+            error {
+              __typename
+            }
+            fullToken
+          }
+        }
+      `
+      const variables = { input: { name, tokenType: USER_TOKEN_TYPE.API } }
+      return Api.graphqlMutation({
+        provider,
+        query,
+        variables,
+        mutationPath: 'createUserToken',
+      })
+    },
+    useErrorBoundary: true,
+    onSuccess: ({ data }) => {
+      queryClient.invalidateQueries(['sessions'])
+
+      const parsedData = UseGenerateTokenResponseSchema.safeParse(data)
+      if (!parsedData.success) {
+        return Promise.reject({
+          status: 404,
+          data: {},
+          dev: 'useGenerateUserToken - 404 failed to parse',
+        } satisfies NetworkErrorObject)
+      }
+    },
+  })
+}

src/services/navigation/normalize.js → src/services/navigation/normalize.ts

@@ -7,7 +7,7 @@ export const ApiFilterEnum = Object.freeze({
 })
 
 // Help convert useForm data to our API
-export function normalizeFormData(data) {
+export function normalizeFormData(data: Record<string, unknown>) {
   return mapValues(data, (value) => {
     if (!value) return ''
     return value

src/services/navigation/useLocationParams.test.jsx → src/services/navigation/useLocationParams.test.tsx

@@ -1,16 +1,16 @@
 import { act, renderHook } from '@testing-library/react'
-import { createMemoryHistory } from 'history'
+import { createMemoryHistory, Location, MemoryHistory } from 'history'
 import { Route, Router } from 'react-router-dom'
 
 import { useLocationParams } from './useLocationParams'
 
 describe('useLocationParams', () => {
-  let testLocation
-  let history
-  let wrapper
+  let testLocation: Location | string
+  let history: MemoryHistory
+  let wrapper: React.FC<React.PropsWithChildren>
 
-  function setup({ location } = {}) {
-    testLocation = location
+  function setup({ location }: { location?: Location | string } = {}) {
+    testLocation = location!
     history = createMemoryHistory()
 
     wrapper = ({ children }) => (

src/services/navigation/useLocationParams.js → src/services/navigation/useLocationParams.ts

@@ -2,7 +2,7 @@ import omitBy from 'lodash/omitBy'
 import qs from 'qs'
 import { useHistory, useLocation } from 'react-router-dom'
 
-export function useLocationParams(defaultParams = {}) {
+export function useLocationParams(defaultParams: Record<string, unknown> = {}) {
   const { push } = useHistory()
   const { pathname, search, state } = useLocation()
   const params = state || {
@@ -12,7 +12,7 @@ export function useLocationParams(defaultParams = {}) {
     }),
   }
 
-  function updateWindowLocation(params) {
+  function updateWindowLocation(params: Record<string, unknown>) {
     const locationParams = omitBy(
       params,
       (value, key) => value === defaultParams[key]
@@ -22,12 +22,12 @@ export function useLocationParams(defaultParams = {}) {
   }
 
   // Create new state
-  function setParams(newParams) {
+  function setParams(newParams: Record<string, unknown>) {
     updateWindowLocation(newParams)
   }
 
   // Retain previous state
-  function updateParams(newParams) {
+  function updateParams(newParams: Record<string, unknown>) {
     updateWindowLocation({
       ...params,
       ...newParams,

src/services/navigation/useNavLinks/useNavLinks.test.jsx → src/services/navigation/useNavLinks/useNavLinks.test.tsx

@@ -1,10 +1,11 @@
 import { renderHook } from '@testing-library/react'
+import { PropsWithChildren } from 'react'
 import { MemoryRouter, Route } from 'react-router-dom'
 
 import { useNavLinks } from './useNavLinks'
 
 const wrapper =
-  (location) =>
+  (location: string): React.FC<PropsWithChildren> =>
   ({ children }) => (
     <MemoryRouter initialEntries={[location]} initialIndex={0}>
       <Route path="/:provider">{children}</Route>