Function processMessage

packages/vite/src/plugins/vite-node.ts:355–422

(request: ViteNodeRequest)

    socket.setKeepAlive(true, 0)

    async function processMessage (request: ViteNodeRequest) {
      try {
        switch (request.type) {
          case 'manifest': {
            const manifestData = getManifest(nuxt, ssrServer, resolveClientEntry(clientServer.config))
            sendResponse<typeof request.type>(socket, request.id, manifestData)
            return
          }
          case 'invalidates': {
            collectInvalidatedSsrModules()
            const responsePayload = Array.from(invalidates)
            invalidates.clear()
            sendResponse<typeof request.type>(socket, request.id, responsePayload)
            return
          }
          case 'resolve': {
            const { id: resolveId, importer } = request.payload
            if (!resolveId) {
              throw { status: 400, message: 'Missing id for resolve' } satisfies ErrorPartial
            }
            const ssrNode = nuxt.options.experimental.viteEnvironmentApi
              ? ssrServer.environments.ssr.pluginContainer
              : getNode(ssrServer)
            const resolvedResult = await ssrNode.resolveId(resolveId, importer).catch(() => null)
            sendResponse<typeof request.type>(socket, request.id, resolvedResult)
            return
          }
          case 'module': {
            if (request.payload.moduleId === '/') {
              throw { status: 400, message: 'Invalid moduleId' } satisfies ErrorPartial
            }
            const ssrNode = nuxt.options.experimental.viteEnvironmentApi
              ? ssrServer.environments.ssr
              : getNode(ssrServer)
            const response = await ssrNode.fetchModule(request.payload.moduleId)
              .catch(async (err) => {
                const errorData: Record<string, any> = {
                  code: 'VITE_ERROR',
                  id: request.payload.moduleId,
                  stack: err.stack || '',
                  message: err.message || '',
                }
                if (err.frame) { errorData.frame = err.frame }

                if (!errorData.frame && err.code === 'PARSE_ERROR') {
                  try {
                    const clientNode = nuxt.options.experimental.viteEnvironmentApi
                      ? ssrServer.environments.client
                      : getNode(ssrServer)
                    errorData.frame = await clientNode.transformRequest(request.payload.moduleId)
                      .then(res => `${err.message || ''}\n${res?.code}`).catch(() => undefined)
                  } catch {
                    // Ignore transform errors
                  }
                }
                throw { data: errorData, message: err.message || 'Error fetching module' } satisfies ErrorPartial
              }) as Exclude<FetchResult, { cache: true }>
            sendResponse<typeof request.type>(socket, request.id, response)