what_to_do.txt

can select the web framework

can select the database

can do transaction

can select the log library

can store the log into file

create a documentation

refactor the internal code

create a tutorial for gogen

add to go-awesome

https://github.com/Redocly/redoc

interactive command line

adding timeout in usecase

create unit testing


go mod ast

func ReadAllAvailablePackageFromImport(parsedGoFile string) ([]string, error) {

	const goModFileName = "go.mod"

	mapOfRequire := map[string]string{}

	dataInBytes, err := os.ReadFile(goModFileName)
	if err != nil {
		return nil, err
	}

	parsedGoMod, err := modfile.Parse(goModFileName, dataInBytes, nil)
	if err != nil {
		return nil, err
	}

	for _, r := range parsedGoMod.Require {

		if len(r.Syntax.Token) == 1 {
			mapOfRequire[r.Syntax.Token[0]] = fmt.Sprintf("%v/pkg/mod/%v", build.Default.GOPATH, r.Syntax.Token[0])
			continue
		}

		mapOfRequire[r.Syntax.Token[0]] = fmt.Sprintf("%v/pkg/mod/%v@%v", build.Default.GOPATH, r.Syntax.Token[0], r.Syntax.Token[1])
	}

	file, err := parser.ParseFile(token.NewFileSet(), parsedGoFile, nil, parser.ImportsOnly)
	if err != nil {
		return nil, err
	}

	packages := make([]string, 0)

	ast.Inspect(file, func(node ast.Node) bool {

		if err != nil {
			return false
		}

		switch n := node.(type) {

		case *ast.ImportSpec:

			pathValue := strings.Trim(n.Path.Value, `"`)

			for k, m := range mapOfRequire {

				if strings.HasPrefix(pathValue, k) {

					pathToLib := fmt.Sprintf("%v%v", m, pathValue[len(k):])

					pkgs, err := parser.ParseDir(token.NewFileSet(), pathToLib, nil, parser.PackageClauseOnly)
					if err != nil {
						return false
					}

					for _, pkg := range pkgs {
						packages = append(packages, pkg.Name)
					}

				}
			}

		}

		return true
	})

	return packages, nil
}