chore: use cloud validations for packages/server api request/response types

packages/server/.gitignore

@@ -0,0 +1 @@
+lib/validations

packages/server/eslint.config.ts

@@ -29,6 +29,6 @@ export default [
     },
   },
   {
-    ignores: ['test/support/fixtures/server/**/*'],
+    ignores: ['test/support/fixtures/server/**/*', 'lib/validations/**/*'],
   },
 ]

packages/server/lib/cloud/api/create_instance.ts

@@ -3,29 +3,13 @@ import { asyncRetry, exponentialBackoff } from '../../util/async_retry'
 import * as errors from '../../errors'
 import { isAxiosError } from 'axios'
 
-const MAX_RETRIES = 3
-
-export interface CreateInstanceResponse {
-  spec: string | null
-  instanceId: string | null
-  claimedInstances: number
-  estimatedWallClockDuration: number | null
-  totalInstances: number
-}
+// Import cloud validation types for better type safety
+import type {
+  PostRunInstanceRequest_v2Type as CreateInstanceRequestBody,
+  PostRunInstanceResponse_v2 as CreateInstanceResponse,
+} from '../../validations/cloudValidations'
 
-export interface CreateInstanceRequestBody {
-  spec: string | null
-  groupId: string
-  machineId: string
-  platform: {
-    browserName: string
-    browserVersion: string
-    osCpus: any[]
-    osMemory: Record<string, any> | null
-    osName: string
-    osVersion: string
-  }
-}
+const MAX_RETRIES = 3
 
 export const createInstance = async (runId: string, instanceData: CreateInstanceRequestBody, timeout: number = 0): Promise<CreateInstanceResponse> => {
   let attemptNumber = 0

packages/server/lib/cloud/api/index.ts

@@ -29,15 +29,25 @@ import type { ProjectBase } from '../../project-base'
 
 import { PUBLIC_KEY_VERSION } from '../constants'
 
-// axios implementation disabled until proxy issues can be diagnosed/fixed
-// TODO: https://github.com/cypress-io/cypress/issues/31490
-//import { createInstance } from './create_instance'
-import type { CreateInstanceRequestBody, CreateInstanceResponse } from './create_instance'
-
 import { transformError } from './axios_middleware/transform_error'
 import { DecryptionError } from './cloud_request_errors'
 import { isNonRetriableCertErrorCode } from '../network/non_retriable_cert_error_codes'
 
+// Import cloud validation types for better type safety
+import type {
+  PostRunRequest_v3Type as CreateRunRequestType,
+  PostRunResponse_v3Type as CreateRunResponseType,
+  PostRunInstanceRequest_v2Type as CreateInstanceRequestType,
+  PostRunInstanceResponse_v2 as CreateInstanceResponse,
+  PostInstanceResultsRequest_v1Type as PostInstanceResultsRequestType,
+  PostInstanceResultsResponse_v1Type as PostInstanceResultsResponseType,
+  PostInstanceTestsResponse_v1Type as PostInstanceTestsResponseType,
+  PutInstanceResponse_v2Type as UpdateInstanceStdoutResponseType,
+  PutInstanceStdoutRequest_v1Type as UpdateInstanceStdoutRequestType,
+} from '../../validations/cloudValidations'
+
+// Define response type for putInstanceArtifacts (returns z.ZodAny with resExample: {})
+type PutInstanceArtifactsResponseType = any
 const debug = debugModule('cypress:server:cloud:api')
 const debugProtocol = debugModule('cypress:server:protocol')
 
@@ -255,47 +265,15 @@ function noProxyPreflightTimeout (): number {
   }
 }
 
-export type CreateRunOptions = {
+// Use cloud validation types for better type safety
+export type CreateRunOptions = CreateRunRequestType & {
   projectRoot: string
-  ci: {
-    params: string
-    provider: string
-  }
-  ciBuildId: string
-  projectId: string
-  recordKey: string
-  commit: string
-  specs: string[]
-  group: string
-  platform: string
-  parallel: boolean
-  specPattern: string[]
-  tags: string[]
-  testingType: 'e2e' | 'component'
-  timeout?: number
   project: ProjectBase
-  autoCancelAfterFailures?: number | undefined
+  timeout?: number
 }
 
-type CreateRunResponse = {
-  groupId: string
-  machineId: string
-  runId: string
-  tags: string[] | null
-  runUrl: string
-  warnings: (Record<string, unknown> & {
-    code: string
-    message: string
-    name: string
-  })[]
-  captureProtocolUrl?: string | undefined
-  capture?: {
-    url?: string
-    tags: string[] | null
-    mountVersion?: number
-    disabledMessage?: string
-  } | undefined
-}
+// Use cloud validation types for better type safety
+type CreateRunResponse = CreateRunResponseType
 
 export type ArtifactMetadata = {
   url: string
@@ -354,26 +332,26 @@ export default {
   rp,
 
   // For internal testing
-  setPreflightResult (toSet) {
+  setPreflightResult (toSet: any): void {
     preflightResult = {
       ...preflightResult,
       ...toSet,
     }
   },
 
-  resetPreflightResult () {
+  resetPreflightResult (): void {
     recordRoutes = apiRoutes
     preflightResult = {
       encrypt: true,
     }
   },
 
-  ping () {
+  ping (): Bluebird<any> {
     return rp.get(apiRoutes.ping())
     .catch(tagError)
   },
 
-  getAuthUrls () {
+  getAuthUrls (): Bluebird<any> {
     return rp.get({
       url: apiRoutes.auth(),
       json: true,
@@ -459,7 +437,7 @@ export default {
         }
       }
 
-      if (script) {
+      if (script && (options.testingType === 'e2e' || options.testingType === 'component')) {
         const config = options.project.getConfig()
 
         await options.project.protocolManager.prepareAndSetupProtocol(script, {
@@ -484,7 +462,7 @@ export default {
     .catch(tagError)
   },
 
-  createInstance (runId: string, body: CreateInstanceRequestBody, timeout?: number): Bluebird<CreateInstanceResponse> {
+  createInstance (runId: string, body: CreateInstanceRequestType, timeout?: number): Bluebird<CreateInstanceResponse> {
     return retryWithBackoff((attemptIndex) => {
       return rp.post({
         body,
@@ -503,7 +481,7 @@ export default {
     }) as Bluebird<CreateInstanceResponse>
   },
 
-  postInstanceTests (options) {
+  postInstanceTests (options: { instanceId: string, runId: string, timeout?: number, [key: string]: any }): Bluebird<PostInstanceTestsResponseType> {
     const { instanceId, runId, timeout, ...body } = options
 
     return retryWithBackoff((attemptIndex) => {
@@ -524,7 +502,7 @@ export default {
     })
   },
 
-  updateInstanceStdout (options) {
+  updateInstanceStdout (options: UpdateInstanceStdoutRequestType & { instanceId: string, runId: string, timeout?: number }): Bluebird<UpdateInstanceStdoutResponseType> {
     return retryWithBackoff((attemptIndex) => {
       return rp.put({
         url: recordRoutes.instanceStdout(options.instanceId),
@@ -544,7 +522,7 @@ export default {
     })
   },
 
-  updateInstanceArtifacts (options: UpdateInstanceArtifactsOptions, body: UpdateInstanceArtifactsPayload) {
+  updateInstanceArtifacts (options: UpdateInstanceArtifactsOptions, body: UpdateInstanceArtifactsPayload): Bluebird<PutInstanceArtifactsResponseType> {
     debug('PUT %s %o', recordRoutes.instanceArtifacts(options.instanceId), body)
 
     return retryWithBackoff((attemptIndex) => {
@@ -564,7 +542,7 @@ export default {
     })
   },
 
-  postInstanceResults (options) {
+  postInstanceResults (options: PostInstanceResultsRequestType & { instanceId: string, runId: string, timeout?: number }): Bluebird<PostInstanceResultsResponseType> {
     return retryWithBackoff((attemptIndex) => {
       return rp.post({
         url: recordRoutes.instanceResults(options.instanceId),
@@ -591,7 +569,7 @@ export default {
     })
   },
 
-  createCrashReport (body, authToken, timeout = 3000) {
+  createCrashReport (body: any, authToken: string, timeout = 3000): Bluebird<any> {
     return rp.post({
       url: apiRoutes.exceptions(),
       json: true,
@@ -604,7 +582,7 @@ export default {
     .catch(tagError)
   },
 
-  postLogout (authToken) {
+  postLogout (authToken: string): Bluebird<any> {
     return Bluebird.join(
       this.getAuthUrls(),
       machineId(),
@@ -625,11 +603,11 @@ export default {
     )
   },
 
-  clearCache () {
+  clearCache (): void {
     responseCache = {}
   },
 
-  sendPreflight (preflightInfo) {
+  sendPreflight (preflightInfo: any): Bluebird<any> {
     return retryWithBackoff(async (attemptIndex) => {
       const { projectRoot, timeout, ...preflightRequestBody } = preflightInfo
 

packages/server/lib/cloud/user.ts

@@ -13,8 +13,10 @@ export = {
     return cache.setUser(user)
   },
 
-  getBaseLoginUrl (): string {
-    return api.getAuthUrls().get('dashboardAuthUrl')
+  async getBaseLoginUrl (): Promise<string> {
+    const res = await api.getAuthUrls()
+
+    return res!.dashboardAuthUrl
   },
 
   logOut () {

packages/server/lib/modes/record.ts

@@ -547,7 +547,7 @@ async function createInstance (options: InstanceOptions) {
   }
 }
 
-const _postInstanceTests = ({
+async function _postInstanceTests ({
   runId,
   instanceId,
   config,
@@ -556,17 +556,18 @@ const _postInstanceTests = ({
   parallel,
   ciBuildId,
   group,
-}) => {
-  return api.postInstanceTests({
-    runId,
-    instanceId,
-    config,
-    tests,
-    hooks,
-  })
-  .catch((err: any) => {
-    throwCloudCannotProceed({ parallel, ciBuildId, group, err })
-  })
+}) {
+  try {
+    return await api.postInstanceTests({
+      runId,
+      instanceId,
+      config,
+      tests,
+      hooks,
+    })
+  } catch (err: unknown) {
+    throw cloudCannotProceedErr({ parallel, ciBuildId, group, err })
+  }
 }
 
 const createRunAndRecordSpecs = (options: any = {}) => {
@@ -793,42 +794,34 @@ const createRunAndRecordSpecs = (options: any = {}) => {
         })
         .value()
 
-        const responseDidFail = {}
-        const response = await _postInstanceTests({
-          runId,
-          instanceId,
-          config: resolvedRuntimeConfig,
-          tests,
-          hooks,
-          parallel,
-          ciBuildId,
-          group,
-        })
-        .catch((err: any) => {
-          onError(err)
-
-          return responseDidFail
-        })
-
-        if (response === responseDidFail) {
-          debug('`responseDidFail` equals `response`, allowing browser to hang until it is killed: Response %o', { responseDidFail })
+        try {
+          const response = await _postInstanceTests({
+            runId,
+            instanceId,
+            config: resolvedRuntimeConfig,
+            tests,
+            hooks,
+            parallel,
+            ciBuildId,
+            group,
+          })
 
-          // dont call the cb, let the browser hang until it's killed
-          return
-        }
+          if (_.some(response.actions, { type: 'SPEC', action: 'SKIP' })) {
+            errorsWarning('CLOUD_CANCEL_SKIPPED_SPEC')
 
-        if (_.some(response.actions, { type: 'SPEC', action: 'SKIP' })) {
-          errorsWarning('CLOUD_CANCEL_SKIPPED_SPEC')
+            // set a property on the response so the browser runner
+            // knows not to start executing tests
+            project.emit('end', { skippedSpec: true, stats: {} })
 
-          // set a property on the response so the browser runner
-          // knows not to start executing tests
-          project.emit('end', { skippedSpec: true, stats: {} })
+            // dont call the cb, let the browser hang until it's killed
+            return
+          }
 
-          // dont call the cb, let the browser hang until it's killed
-          return
+          return cb(response)
+        } catch (err: unknown) {
+          onError(err)
+          debug('postInstanceTests failed, allowing browser to hang until it is killed: Error %o', { err })
         }
-
-        return cb(response)
       })
 
       return runAllSpecs({