Use std library errors

assets/static/flow.go

@@ -2,12 +2,11 @@ package static
 
 import (
 	"encoding/json"
+	"errors"
 
+	"github.com/buger/jsonparser"
 	"github.com/nyaruka/gocommon/jsonx"
 	"github.com/nyaruka/goflow/assets"
-
-	"github.com/buger/jsonparser"
-	"github.com/pkg/errors"
 )
 
 // Flow is a JSON serializable implementation of a flow asset

assets/static/source.go

@@ -3,13 +3,13 @@ package static
 
 import (
 	"encoding/json"
+	"fmt"
 	"os"
 	"strings"
 
 	"github.com/nyaruka/goflow/assets"
 	"github.com/nyaruka/goflow/envs"
 	"github.com/nyaruka/goflow/utils"
-	"github.com/pkg/errors"
 )
 
 // StaticSource is an asset source which loads assets from a static JSON file
@@ -40,7 +40,7 @@ func NewEmptySource() *StaticSource {
 func NewSource(data json.RawMessage) (*StaticSource, error) {
 	s := &StaticSource{}
 	if err := utils.UnmarshalAndValidate(data, &s.s); err != nil {
-		return nil, errors.Wrap(err, "unable to read assets")
+		return nil, fmt.Errorf("unable to read assets: %w", err)
 	}
 	return s, nil
 }
@@ -49,7 +49,7 @@ func NewSource(data json.RawMessage) (*StaticSource, error) {
 func LoadSource(path string) (*StaticSource, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
-		return nil, errors.Wrapf(err, "error reading file '%s'", path)
+		return nil, fmt.Errorf("error reading file '%s': %w", path, err)
 	}
 	return NewSource(data)
 }
@@ -88,7 +88,7 @@ func (s *StaticSource) FlowByUUID(uuid assets.FlowUUID) (assets.Flow, error) {
 			return flow, nil
 		}
 	}
-	return nil, errors.Errorf("no such flow with UUID '%s'", uuid)
+	return nil, fmt.Errorf("no such flow with UUID '%s'", uuid)
 }
 
 // Flow returns the flow asset with the given UUID
@@ -98,7 +98,7 @@ func (s *StaticSource) FlowByName(name string) (assets.Flow, error) {
 			return flow, nil
 		}
 	}
-	return nil, errors.Errorf("no such flow with name '%s'", name)
+	return nil, fmt.Errorf("no such flow with name '%s'", name)
 }
 
 // Globals returns all global assets

cmd/classify/main.go

@@ -11,7 +11,6 @@ import (
 	"github.com/nyaruka/goflow/flows"
 	"github.com/nyaruka/goflow/services/classification/luis"
 	"github.com/nyaruka/goflow/services/classification/wit"
-	"github.com/pkg/errors"
 )
 
 const usage = `usage: classify [flags] <input>`
@@ -72,7 +71,7 @@ func classify(svcs map[string]flows.ClassificationService, input string) (map[st
 	for t, s := range svcs {
 		c, err := s.Classify(nil, input, log.Log)
 		if err != nil {
-			return nil, log.Logs, errors.Wrapf(err, "error classifying with %s", t)
+			return nil, log.Logs, fmt.Errorf("error classifying with %s: %w", t, err)
 		}
 		res[t] = c
 	}

cmd/docgen/completion/completion.go

@@ -2,8 +2,6 @@ package completion
 
 import (
 	"fmt"
-
-	"github.com/pkg/errors"
 )
 
 // types available in root of context even without a session
@@ -47,13 +45,13 @@ func (c *Completion) Validate() error {
 	for _, t := range c.Types {
 		for _, ref := range t.TypeRefs() {
 			if !knownTypes[ref] {
-				return errors.Errorf("context type %s references unknown type %s", t.Name(), ref)
+				return fmt.Errorf("context type %s references unknown type %s", t.Name(), ref)
 			}
 		}
 	}
 	for _, p := range c.Root {
 		if !knownTypes[p.Type] {
-			return errors.Errorf("context root references unknown type %s", p.Type)
+			return fmt.Errorf("context root references unknown type %s", p.Type)
 		}
 	}
 	return nil

cmd/docgen/docs/base.go

@@ -8,8 +8,6 @@ import (
 
 	"github.com/nyaruka/gocommon/dates"
 	"github.com/nyaruka/goflow/utils/po"
-
-	"github.com/pkg/errors"
 )
 
 const (
@@ -40,7 +38,7 @@ func Generate(baseDir, outputDir, localeDir string) error {
 	// extract all documented items from the source code
 	taggedItems, err := FindAllTaggedItems(baseDir)
 	if err != nil {
-		return errors.Wrap(err, "error extracting tagged items")
+		return fmt.Errorf("error extracting tagged items: %w", err)
 	}
 
 	for k, v := range taggedItems {
@@ -72,7 +70,7 @@ func Generate(baseDir, outputDir, localeDir string) error {
 
 	// and merge with existing locale files
 	if err := locales.Update(poDomain, pot); err != nil {
-		return errors.Wrap(err, "error updating locale files")
+		return fmt.Errorf("error updating locale files: %w", err)
 	}
 
 	return nil
@@ -92,7 +90,7 @@ func generateForLang(baseDir, outputDir string, items map[string][]*TaggedItem,
 	// load PO file for translations
 	po, err := locales.Load(locale, poDomain)
 	if err != nil {
-		return errors.Wrapf(err, "error loading PO file for '%s'", locale)
+		return fmt.Errorf("error loading PO file for '%s': %w", locale, err)
 	}
 
 	// create gettext function which will keep track of all unique message IDs
@@ -108,7 +106,7 @@ func generateForLang(baseDir, outputDir string, items map[string][]*TaggedItem,
 		fmt.Printf("Invoking generator: %s...\n", g.Name())
 
 		if err := g.Generate(baseDir, genDir, items, gettext); err != nil {
-			return errors.Wrapf(err, "error invoking generator %s", g.Name())
+			return fmt.Errorf("error invoking generator %s: %w", g.Name(), err)
 		}
 	}
 

cmd/docgen/docs/editor_support.go

@@ -10,8 +10,6 @@ import (
 	"github.com/nyaruka/gocommon/jsonx"
 	"github.com/nyaruka/gocommon/urns"
 	"github.com/nyaruka/goflow/cmd/docgen/completion"
-
-	"github.com/pkg/errors"
 )
 
 func init() {
@@ -90,7 +88,7 @@ func (g *editorSupportGenerator) buildContextCompletion(items map[string][]*Tagg
 		for i, propDesc := range item.examples {
 			prop := completion.ParseProperty(propDesc)
 			if prop == nil {
-				return nil, errors.Errorf("invalid format for property description \"%s\"", propDesc)
+				return nil, fmt.Errorf("invalid format for property description \"%s\"", propDesc)
 			}
 			prop.Help = gettext(prop.Help)
 			properties[i] = prop

cmd/docgen/docs/html.go

@@ -16,8 +16,6 @@ import (
 	"github.com/nyaruka/goflow/envs"
 	"github.com/nyaruka/goflow/flows"
 	"github.com/nyaruka/goflow/test"
-
-	"github.com/pkg/errors"
 )
 
 func init() {
@@ -63,15 +61,15 @@ func (g *htmlDocsGenerator) Name() string {
 
 func (g *htmlDocsGenerator) Generate(baseDir, outputDir string, items map[string][]*TaggedItem, gettext func(string) string) error {
 	if err := renderTemplateDocs(baseDir, outputDir, items); err != nil {
-		return errors.Wrap(err, "error rendering templates")
+		return fmt.Errorf("error rendering templates: %w", err)
 	}
 
 	// copy static resources to docs dir
 	for _, res := range Resources {
 		src := path.Join(baseDir, templateDir, res)
 		dst := path.Join(outputDir, res)
 		if err := copyFile(src, dst); err != nil {
-			return errors.Wrap(err, "error copying resource")
+			return fmt.Errorf("error copying resource: %w", err)
 		}
 		fmt.Printf(" > Copied %s > %s\n", src, dst)
 	}
@@ -82,7 +80,7 @@ func renderTemplateDocs(baseDir string, outputDir string, items map[string][]*Ta
 	// render items as context for the main doc templates
 	context, err := buildTemplateContext(items)
 	if err != nil {
-		return errors.Wrap(err, "error building docs context")
+		return fmt.Errorf("error building docs context: %w", err)
 	}
 
 	// to post-process templates to resolve links between templates
@@ -102,14 +100,14 @@ func renderTemplateDocs(baseDir string, outputDir string, items map[string][]*Ta
 		htmlPath := path.Join(outputDir, template.Path[0:len(template.Path)-3]+".html")
 
 		if err := renderTemplate(templatePath, renderedPath, context, linkResolver, linkTargets); err != nil {
-			return errors.Wrapf(err, "error rendering template %s", templatePath)
+			return fmt.Errorf("error rendering template %s: %w", templatePath, err)
 		}
 
 		htmlTemplate := path.Join(baseDir, "cmd/docgen/templates/template.html")
 		htmlContext := map[string]string{"title": template.Title}
 
 		if err := renderHTML(renderedPath, htmlPath, htmlTemplate, template.TOC, htmlContext); err != nil {
-			return errors.Wrapf(err, "error rendering HTML from %s to %s", renderedPath, htmlPath)
+			return fmt.Errorf("error rendering HTML from %s to %s: %w", renderedPath, htmlPath, err)
 		}
 
 		fmt.Printf(" > Rendered %s > %s > %s\n", templatePath, renderedPath, htmlPath)
@@ -123,12 +121,12 @@ func renderTemplate(src, dst string, context map[string]string, resolver urlReso
 	// generate our complete docs
 	docTpl, err := template.ParseFiles(src)
 	if err != nil {
-		return errors.Wrap(err, "error reading template file")
+		return fmt.Errorf("error reading template file: %w", err)
 	}
 
 	output := &strings.Builder{}
 	if err := docTpl.Execute(output, context); err != nil {
-		return errors.Wrap(err, "error executing template")
+		return fmt.Errorf("error executing template: %w", err)
 	}
 
 	processed := resolveLinks(output.String(), resolver, linkTargets)
@@ -177,7 +175,7 @@ func createLinkResolver(items map[string][]*TaggedItem) (urlResolver, map[string
 	return func(tag string, val string) (string, error) {
 		linkTpl := typeTemplates[tag]
 		if linkTpl == "" {
-			return "", errors.Errorf("no link template for type %s", tag)
+			return "", fmt.Errorf("no link template for type %s", tag)
 		}
 		return fmt.Sprintf(linkTpl, val), nil
 	}, linkTargets
@@ -224,12 +222,12 @@ func buildTemplateContext(items map[string][]*TaggedItem) (map[string]string, er
 
 	session, _, err := test.CreateTestSession(server.URL, envs.RedactionPolicyNone)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating example session")
+		return nil, fmt.Errorf("error creating example session: %w", err)
 	}
 
 	voiceSession, _, err := test.CreateTestVoiceSession(server.URL)
 	if err != nil {
-		return nil, errors.Wrap(err, "error creating example session")
+		return nil, fmt.Errorf("error creating example session: %w", err)
 	}
 
 	context := make(map[string]string)