Method Process

apis/batch.go:179–233

(batch []*core.InternalRequest, timeout time.Duration)

}

func (p *batchProcessor) Process(batch []*core.InternalRequest, timeout time.Duration) error {
	p.results = make([]*BatchRequestResult, 0, len(batch))

	if p.stopCh != nil {
		close(p.stopCh)
	}
	p.stopCh = make(chan struct{}, 1)

	if p.errCh != nil {
		close(p.errCh)
	}
	p.errCh = make(chan error, 1)

	return p.app.RunInTransaction(func(txApp core.App) error {
		// used to interupts the recursive processing calls in case of a timeout or connection close
		defer func() {
			p.stopCh <- struct{}{}
		}()

		go func() {
			err := p.process(txApp, batch, 0)

			if err != nil {
				err = validation.Errors{
					"requests": validation.Errors{
						strconv.Itoa(p.failedIndex): &BatchResponseError{
							code:    "batch_request_failed",
							message: "Batch request failed.",
							err:     router.ToApiError(err),
						},
					},
				}
			}

			// note: to avoid copying and due to the process recursion the final results order is reversed
			if err == nil {
				slices.Reverse(p.results)
			}

			p.errCh <- err
		}()

		select {
		case responseErr := <-p.errCh:
			return responseErr
		case <-time.After(timeout):
			// note: we don't return 408 Reques Timeout error because
			// some browsers perform automatic retry behind the scenes
			// which are hard to debug and unnecessary
			return errors.New("batch transaction timeout")
		case <-p.baseEvent.Request.Context().Done():
			return errors.New("batch request interrupted")
		}
	})
}

func (p *batchProcessor) process(activeApp core.App, batch []*core.InternalRequest, i int) error {
	select {