How to get the size of zipped folder

Use case is:
I want to zip a folder which could contain n number of files with difference sizes. I want to add limit like if the zip size > x (MB|GB) then do not create the zip and throw error. I tried to get the size of zip file after the zip is created after iterating the folder but not able to do so. Request help here. I am using io.writer to create zip file instead buffer. Sample code is

Note: I am able to calculate the size when using "buf := new(bytes.Buffer)" but I want to calculate using io.writer as seen below

filepath - Path to the folder
downloadLimit - the limit I want to set for downloaded zip file. Like zip file size should not be more then 100 MB

func GetZipFileSize(filepath string, downloadLimit int, w io.Writer) error {
	
	zipWriter := zip.NewWriter(w)

	// List files
	var files []FileAndPath
	var err error
	
    // We have function to fetch files in variable "files" which is used below

	// ZIP files
	for _, file := range files {
		
		// Determine filename in ZIP
		zipFilename := file.Path
		
		filename := fp.Join(SOME_PATH, file.Path)

		// Create ZIP entry
		fileToZip, err := os.Open(filename)
		if err != nil {
			return SOME_ERROR
		}
		info, err := fileToZip.Stat()
		if err != nil {
			return err
		}
		header, err := zip.FileInfoHeader(info)
		if err != nil {
			return err
		}
		header.Name = zipFilename
		header.Method = zip.Deflate
		writer, err := zipWriter.CreateHeader(header)
		if err != nil {
			return err
		}

		// Set content for ZIP entry
		if _, err = io.Copy(writer, fileToZip); err != nil {
			return err
		}
		if err = fileToZip.Close(); err != nil {
			// Nothing
		}
	}

	// Wrap-up
	if err := zipWriter.Close(); err != nil {
		return err
	}

	return nil
}

Above function create zip file, but I want it to stop creation as soon the limit is reached and exit OR at least get the size of the zip file created

The standard API does not provide an io.Writer implementaion to do that, afaik. It exists a LimitReader but it is of little use for your case and would led us to write rather complex code.

Instead, you can write your own io.Writer wrapper implementation to ensure that if the total amount of bytes written onto it exceeds some length, or is about to, return an error.

package main

import (
	"errors"
	"fmt"
	"io"
	"os"
	"strings"
)

func main() {
	bigBuf := strings.NewReader(strings.Repeat("borng string", 10000))

	dst := &LimitWriter{Writer: os.Stdout, N: 20}

	n, err := io.Copy(dst, bigBuf)
	fmt.Println("n=", n)
	fmt.Println("err=", err)
}

var ErrWriteOverflow = errors.New("write overflow, data is too large")

type LimitWriter struct {
	io.Writer
	N       int64
	written int64
}

func (l *LimitWriter) Write(p []byte) (n int, err error) {
	if l.written+int64(len(p)) >= l.N {
		return 0, ErrWriteOverflow
	}
	n, err = l.Writer.Write(p)
	l.written += int64(n)
	return
}

https://play.golang.org/p/ktgF-pOzFjm

Here's a suggestion how you could solve this. Explaination in the code.
I think there is no (easy) way to calculate/estimate the size of a future zip file without executing the actual compression.

Line 1 of the code assumes you already have some kind of byte representation of the file(s) you want to zip.

func main() {    	
// Create a buffer to write our archive to (in memory)
buf := new(bytes.Buffer)
// Create a new zip archive writer, that writes to our in memory buffer
archiveWriter := zip.NewWriter(buf)
// ensure to close your zip writer later
defer archiveWriter.Close()
// you probably want to do this in a loop and repeat for each file you want add to the zip archive
// this is the content of a file you want to zip / instead read it from disk with ioutil.ReadFile() or some other approach
dummyBytes := []byte("ThisCouldBeTheContentOfYourSourceFile")
fileWriter, _ := archiveWriter.Create("fileNameOfSourceFileInZip")
_, _ = fileWriter.Write(dummyBytes)
// validate the in memory representation of the zip file does not exceed your limit
if buf.Len() > 1000 {
// todo raise error
return
}
// write the zip file to the disk, you could ofc also use io.writer
_ = ioutil.WriteFile("TargetZipFile.zip", buf.Bytes(), 0644)
}

Please note that I did not implement any error handling - you probably want to add that.