fix!: use singular name for package (#101)

> In go, package names are not plural. This is surprising to programmers who came from other languages and are retaining an old habit of pluralizing names. Don’t name a package httputils, but httputil!

See https://rakyll.org/style-packages.

dialer.go

@@ -25,7 +25,7 @@ import (
 	"sync/atomic"
 	"time"
 
-	"cloud.google.com/go/cloudsqlconn/errtypes"
+	"cloud.google.com/go/cloudsqlconn/errtype"
 	"cloud.google.com/go/cloudsqlconn/internal/cloudsql"
 	"cloud.google.com/go/cloudsqlconn/internal/trace"
 	"github.com/google/uuid"
@@ -197,22 +197,22 @@ func (d *Dialer) Dial(ctx context.Context, instance string, opts ...DialOption)
 	if err != nil {
 		// refresh the instance info in case it caused the connection failure
 		i.ForceRefresh()
-		return nil, errtypes.NewDialError("failed to dial", i.String(), err)
+		return nil, errtype.NewDialError("failed to dial", i.String(), err)
 	}
 	if c, ok := conn.(*net.TCPConn); ok {
 		if err := c.SetKeepAlive(true); err != nil {
-			return nil, errtypes.NewDialError("failed to set keep-alive", i.String(), err)
+			return nil, errtype.NewDialError("failed to set keep-alive", i.String(), err)
 		}
 		if err := c.SetKeepAlivePeriod(cfg.tcpKeepAlive); err != nil {
-			return nil, errtypes.NewDialError("failed to set keep-alive period", i.String(), err)
+			return nil, errtype.NewDialError("failed to set keep-alive period", i.String(), err)
 		}
 	}
 	tlsConn := tls.Client(conn, tlsCfg)
 	if err := tlsConn.Handshake(); err != nil {
 		// refresh the instance info in case it caused the handshake failure
 		i.ForceRefresh()
 		_ = tlsConn.Close() // best effort close attempt
-		return nil, errtypes.NewDialError("handshake failed", i.String(), err)
+		return nil, errtype.NewDialError("handshake failed", i.String(), err)
 	}
 	latency := time.Since(startTime).Milliseconds()
 	go func() {

dialer_test.go

@@ -23,7 +23,7 @@ import (
 	"testing"
 	"time"
 
-	"cloud.google.com/go/cloudsqlconn/errtypes"
+	"cloud.google.com/go/cloudsqlconn/errtype"
 	"cloud.google.com/go/cloudsqlconn/internal/mock"
 )
 
@@ -93,7 +93,7 @@ func TestDialWithAdminAPIErrors(t *testing.T) {
 	d.sqladmin = svc
 
 	_, err = d.Dial(context.Background(), "bad-instance-name")
-	var wantErr1 *errtypes.ConfigError
+	var wantErr1 *errtype.ConfigError
 	if !errors.As(err, &wantErr1) {
 		t.Fatalf("when instance name is invalid, want = %T, got = %v", wantErr1, err)
 	}
@@ -107,7 +107,7 @@ func TestDialWithAdminAPIErrors(t *testing.T) {
 	}
 
 	_, err = d.Dial(context.Background(), "my-project:my-region:my-instance")
-	var wantErr2 *errtypes.RefreshError
+	var wantErr2 *errtype.RefreshError
 	if !errors.As(err, &wantErr2) {
 		t.Fatalf("when API call fails, want = %T, got = %v", wantErr2, err)
 	}
@@ -139,13 +139,13 @@ func TestDialWithConfigurationErrors(t *testing.T) {
 	}()
 
 	_, err = d.Dial(context.Background(), "my-project:my-region:my-instance", WithPrivateIP())
-	var wantErr1 *errtypes.ConfigError
+	var wantErr1 *errtype.ConfigError
 	if !errors.As(err, &wantErr1) {
 		t.Fatalf("when IP type is invalid, want = %T, got = %v", wantErr1, err)
 	}
 
 	_, err = d.Dial(context.Background(), "my-project:my-region:my-instance")
-	var wantErr2 *errtypes.DialError
+	var wantErr2 *errtype.DialError
 	if !errors.As(err, &wantErr2) {
 		t.Fatalf("when server proxy socket is unavailable, want = %T, got = %v", wantErr2, err)
 	}

errtypes/doc.go → errtype/doc.go

@@ -12,6 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-// Package errtypes provides a number of concrete types which are used by the
+// Package errtype provides a number of concrete types which are used by the
 // cloudsqlconn package.
-package errtypes // import "cloud.google.com/go/cloudsqlconn/errtypes"
+package errtype // import "cloud.google.com/go/cloudsqlconn/errtype"

errtypes/errors.go → errtype/errors.go

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package errtypes
+package errtype
 
 import "fmt"
 

errtypes/errors_test.go → errtype/errors_test.go

@@ -12,13 +12,13 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-package errtypes_test
+package errtype_test
 
 import (
 	"errors"
 	"testing"
 
-	"cloud.google.com/go/cloudsqlconn/errtypes"
+	"cloud.google.com/go/cloudsqlconn/errtype"
 )
 
 func TestErrorFormatting(t *testing.T) {
@@ -29,22 +29,22 @@ func TestErrorFormatting(t *testing.T) {
 	}{
 		{
 			desc: "config error message",
-			err:  errtypes.NewConfigError("error message", "proj:reg:inst"),
+			err:  errtype.NewConfigError("error message", "proj:reg:inst"),
 			want: "Config error: error message (connection name = \"proj:reg:inst\")",
 		},
 		{
 			desc: "refresh error message without internal error",
-			err:  errtypes.NewRefreshError("error message", "proj:reg:inst", nil),
+			err:  errtype.NewRefreshError("error message", "proj:reg:inst", nil),
 			want: "Refresh error: error message (connection name = \"proj:reg:inst\")",
 		},
 		{
 			desc: "refresh error message with internal error",
-			err:  errtypes.NewRefreshError("error message", "proj:reg:inst", errors.New("inner-error")),
+			err:  errtype.NewRefreshError("error message", "proj:reg:inst", errors.New("inner-error")),
 			want: "Refresh error: error message (connection name = \"proj:reg:inst\"): inner-error",
 		},
 		{
 			desc: "Dial error without inner error",
-			err: errtypes.NewDialError(
+			err: errtype.NewDialError(
 				"message",
 				"proj:reg:inst",
 				nil, // no error here
@@ -53,7 +53,7 @@ func TestErrorFormatting(t *testing.T) {
 		},
 		{
 			desc: "Dial error with inner error",
-			err: errtypes.NewDialError(
+			err: errtype.NewDialError(
 				"message",
 				"proj:reg:inst",
 				errors.New("inner-error"),

internal/cloudsql/instance.go

@@ -23,7 +23,7 @@ import (
 	"sync"
 	"time"
 
-	"cloud.google.com/go/cloudsqlconn/errtypes"
+	errtype "cloud.google.com/go/cloudsqlconn/errtype"
 	"golang.org/x/oauth2"
 	sqladmin "google.golang.org/api/sqladmin/v1beta4"
 )
@@ -56,7 +56,7 @@ func parseConnName(cn string) (connName, error) {
 	b := []byte(cn)
 	m := connNameRegex.FindSubmatch(b)
 	if m == nil {
-		err := errtypes.NewConfigError(
+		err := errtype.NewConfigError(
 			"invalid instance connection name, expected PROJECT:REGION:INSTANCE",
 			cn,
 		)
@@ -191,7 +191,7 @@ func (i *Instance) ConnectInfo(ctx context.Context, ipType string) (string, *tls
 	}
 	addr, ok := res.md.ipAddrs[ipType]
 	if !ok {
-		err := errtypes.NewConfigError(
+		err := errtype.NewConfigError(
 			fmt.Sprintf("instance does not have IP of type %q", ipType),
 			i.String(),
 		)

internal/cloudsql/instance_test.go

@@ -22,7 +22,7 @@ import (
 	"testing"
 	"time"
 
-	"cloud.google.com/go/cloudsqlconn/errtypes"
+	"cloud.google.com/go/cloudsqlconn/errtype"
 	"cloud.google.com/go/cloudsqlconn/internal/mock"
 )
 
@@ -165,7 +165,7 @@ func TestConnectInfoErrors(t *testing.T) {
 	}
 
 	_, _, err = im.ConnectInfo(ctx, PublicIP)
-	var wantErr *errtypes.DialError
+	var wantErr *errtype.DialError
 	if !errors.As(err, &wantErr) {
 		t.Fatalf("when connect info fails, want = %T, got = %v", wantErr, err)
 	}

internal/cloudsql/refresh.go

@@ -23,7 +23,7 @@ import (
 	"fmt"
 	"time"
 
-	"cloud.google.com/go/cloudsqlconn/errtypes"
+	"cloud.google.com/go/cloudsqlconn/errtype"
 	"cloud.google.com/go/cloudsqlconn/internal/trace"
 	"golang.org/x/oauth2"
 	"golang.org/x/time/rate"
@@ -50,15 +50,15 @@ func fetchMetadata(ctx context.Context, client *sqladmin.Service, inst connName)
 	defer func() { end(err) }()
 	db, err := client.Instances.Get(inst.project, inst.name).Context(ctx).Do()
 	if err != nil {
-		return metadata{}, errtypes.NewRefreshError("failed to get instance metadata", inst.String(), err)
+		return metadata{}, errtype.NewRefreshError("failed to get instance metadata", inst.String(), err)
 	}
 	// validate the instance is supported for authenticated connections
 	if db.Region != inst.region {
 		msg := fmt.Sprintf("provided region was mismatched - got %s, want %s", inst.region, db.Region)
-		return metadata{}, errtypes.NewRefreshError(msg, inst.String(), nil)
+		return metadata{}, errtype.NewRefreshError(msg, inst.String(), nil)
 	}
 	if db.BackendType != "SECOND_GEN" {
-		return metadata{}, errtypes.NewConfigError(
+		return metadata{}, errtype.NewConfigError(
 			"unsupported instance - only Second Generation instances are supported",
 			inst.String(),
 		)
@@ -75,7 +75,7 @@ func fetchMetadata(ctx context.Context, client *sqladmin.Service, inst connName)
 		}
 	}
 	if len(ipAddrs) == 0 {
-		return metadata{}, errtypes.NewConfigError(
+		return metadata{}, errtype.NewConfigError(
 			"cannot connect to instance - it has no supported IP addresses",
 			inst.String(),
 		)
@@ -84,11 +84,11 @@ func fetchMetadata(ctx context.Context, client *sqladmin.Service, inst connName)
 	// parse the server-side CA certificate
 	b, _ := pem.Decode([]byte(db.ServerCaCert.Cert))
 	if b == nil {
-		return metadata{}, errtypes.NewRefreshError("failed to decode valid PEM cert", inst.String(), nil)
+		return metadata{}, errtype.NewRefreshError("failed to decode valid PEM cert", inst.String(), nil)
 	}
 	cert, err := x509.ParseCertificate(b.Bytes)
 	if err != nil {
-		return metadata{}, errtypes.NewRefreshError(
+		return metadata{}, errtype.NewRefreshError(
 			fmt.Sprintf("failed to parse as X.509 certificate: %v", err),
 			inst.String(),
 			nil,
@@ -140,7 +140,7 @@ func fetchEphemeralCert(
 		var tokErr error
 		tok, tokErr = ts.Token()
 		if tokErr != nil {
-			return tls.Certificate{}, errtypes.NewRefreshError(
+			return tls.Certificate{}, errtype.NewRefreshError(
 				"failed to retrieve Oauth2 token",
 				inst.String(),
 				tokErr,
@@ -150,7 +150,7 @@ func fetchEphemeralCert(
 		// the future.
 		tok, tokErr = refreshToken(ts, tok)
 		if tokErr != nil {
-			return tls.Certificate{}, errtypes.NewRefreshError(
+			return tls.Certificate{}, errtype.NewRefreshError(
 				"failed to refresh Oauth2 token",
 				inst.String(),
 				tokErr,
@@ -160,7 +160,7 @@ func fetchEphemeralCert(
 	}
 	resp, err := client.Connect.GenerateEphemeralCert(inst.project, inst.name, &req).Context(ctx).Do()
 	if err != nil {
-		return tls.Certificate{}, errtypes.NewRefreshError(
+		return tls.Certificate{}, errtype.NewRefreshError(
 			"create ephemeral cert failed",
 			inst.String(),
 			err,
@@ -170,15 +170,15 @@ func fetchEphemeralCert(
 	// parse the client cert
 	b, _ := pem.Decode([]byte(resp.EphemeralCert.Cert))
 	if b == nil {
-		return tls.Certificate{}, errtypes.NewRefreshError(
+		return tls.Certificate{}, errtype.NewRefreshError(
 			"failed to decode valid PEM cert",
 			inst.String(),
 			nil,
 		)
 	}
 	clientCert, err := x509.ParseCertificate(b.Bytes)
 	if err != nil {
-		return tls.Certificate{}, errtypes.NewRefreshError(
+		return tls.Certificate{}, errtype.NewRefreshError(
 			fmt.Sprintf("failed to parse as X.509 certificate: %v", err),
 			inst.String(),
 			nil,
@@ -230,22 +230,22 @@ func createTLSConfig(inst connName, m metadata, cert tls.Certificate) *tls.Confi
 func genVerifyPeerCertificateFunc(cn connName, pool *x509.CertPool) func(rawCerts [][]byte, _ [][]*x509.Certificate) error {
 	return func(rawCerts [][]byte, _ [][]*x509.Certificate) error {
 		if len(rawCerts) == 0 {
-			return errtypes.NewDialError("no certificate to verify", cn.String(), nil)
+			return errtype.NewDialError("no certificate to verify", cn.String(), nil)
 		}
 
 		cert, err := x509.ParseCertificate(rawCerts[0])
 		if err != nil {
-			return errtypes.NewDialError("failed to parse X.509 certificate", cn.String(), err)
+			return errtype.NewDialError("failed to parse X.509 certificate", cn.String(), err)
 		}
 
 		opts := x509.VerifyOptions{Roots: pool}
 		if _, err = cert.Verify(opts); err != nil {
-			return errtypes.NewDialError("failed to verify certificate", cn.String(), err)
+			return errtype.NewDialError("failed to verify certificate", cn.String(), err)
 		}
 
 		certInstanceName := fmt.Sprintf("%s:%s", cn.project, cn.name)
 		if cert.Subject.CommonName != certInstanceName {
-			return errtypes.NewDialError(
+			return errtype.NewDialError(
 				fmt.Sprintf("certificate had CN %q, expected %q",
 					cert.Subject.CommonName, certInstanceName),
 				cn.String(),
@@ -299,7 +299,7 @@ func (r refresher) performRefresh(ctx context.Context, cn connName, k *rsa.Priva
 	// avoid refreshing too often to try not to tax the SQL Admin API quotas
 	err = r.clientLimiter.Wait(ctx)
 	if err != nil {
-		return metadata{}, nil, time.Time{}, errtypes.NewDialError(
+		return metadata{}, nil, time.Time{}, errtype.NewDialError(
 			"refresh was throttled until context expired",
 			cn.String(),
 			nil,