fix: address PR authzed#2775 review feedback

ivanauth · ivanauth · commit 7c53e96c4501 · 2026-01-05T12:59:22.000-05:00
- Add TODO comment for future ERROR_REASON_DATASTORE_NOT_MIGRATED
- Simplify error message format to: "%w. please run migrate"
- Use IsMissingTableError + reassignment pattern (not early return)
- Export PgMissingTable constant, remove duplicates from migration drivers
- Add Spanner IsMissingTableError support in reader.go and caveat.go
- Differentiate CRDB watch service error message for missing tables
- Add ImportBulk error handling in bulk.go
- Update tests for new error message format
diff --git a/internal/datastore/common/errors.go b/internal/datastore/common/errors.go
@@ -184,6 +184,8 @@ type SchemaNotInitializedError struct {
 }
 
 func (err SchemaNotInitializedError) GRPCStatus() *status.Status {
+	// TODO: Create ERROR_REASON_DATASTORE_NOT_MIGRATED in authzed/api and use it here
+	// See: https://github.com/authzed/spicedb/pull/2775
 	return spiceerrors.WithCodeAndDetails(
 		err,
 		codes.FailedPrecondition,
@@ -202,6 +204,6 @@ func (err SchemaNotInitializedError) Unwrap() error {
 // instructing the user to run migrations.
 func NewSchemaNotInitializedError(underlying error) error {
 	return SchemaNotInitializedError{
-		fmt.Errorf("datastore error: the database schema has not been initialized; please run \"spicedb datastore migrate\": %w", underlying),
+		fmt.Errorf("%w. please run \"spicedb datastore migrate\"", underlying),
 	}
 }
diff --git a/internal/datastore/common/errors_test.go b/internal/datastore/common/errors_test.go
@@ -14,7 +14,8 @@ func TestSchemaNotInitializedError(t *testing.T) {
 
 	t.Run("error message contains migration instructions", func(t *testing.T) {
 		require.Contains(t, err.Error(), "spicedb datastore migrate")
-		require.Contains(t, err.Error(), "database schema has not been initialized")
+		// The error message now includes the underlying error first, followed by the instruction
+		require.Contains(t, err.Error(), "relation \"caveat\" does not exist")
 	})
 
 	t.Run("unwrap returns underlying error", func(t *testing.T) {
@@ -40,4 +41,15 @@ func TestSchemaNotInitializedError(t *testing.T) {
 		var schemaErr SchemaNotInitializedError
 		require.ErrorAs(t, wrappedErr, &schemaErr)
 	})
+
+	t.Run("grpc status extractable from wrapped error", func(t *testing.T) {
+		// This tests the scenario where SchemaNotInitializedError is wrapped
+		// by another fmt.Errorf (e.g., in crdb/caveat.go). The gRPC library
+		// uses errors.As to extract GRPCStatus from wrapped errors.
+		wrappedErr := fmt.Errorf("outer context: %w", err)
+		var schemaErr SchemaNotInitializedError
+		require.ErrorAs(t, wrappedErr, &schemaErr)
+		status := schemaErr.GRPCStatus()
+		require.Equal(t, codes.FailedPrecondition, status.Code())
+	})
 }
diff --git a/internal/datastore/crdb/caveat.go b/internal/datastore/crdb/caveat.go
@@ -9,6 +9,7 @@ import (
 	sq "github.com/Masterminds/squirrel"
 	"github.com/jackc/pgx/v5"
 
+	dscommon "github.com/authzed/spicedb/internal/datastore/common"
 	"github.com/authzed/spicedb/internal/datastore/crdb/schema"
 	pgxcommon "github.com/authzed/spicedb/internal/datastore/postgres/common"
 	"github.com/authzed/spicedb/internal/datastore/revisions"
@@ -54,8 +55,8 @@ func (cr *crdbReader) ReadCaveatByName(ctx context.Context, name string) (*core.
 		if errors.Is(err, pgx.ErrNoRows) {
 			err = datastore.NewCaveatNameNotFoundErr(name)
 		}
-		if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {
-			return nil, datastore.NoRevision, wrappedErr
+		if pgxcommon.IsMissingTableError(err) {
+			err = dscommon.NewSchemaNotInitializedError(err)
 		}
 		return nil, datastore.NoRevision, fmt.Errorf(errReadCaveat, name, err)
 	}
@@ -113,8 +114,8 @@ func (cr *crdbReader) lookupCaveats(ctx context.Context, caveatNames []string) (
 		return nil
 	}, sql, args...)
 	if err != nil {
-		if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {
-			return nil, wrappedErr
+		if pgxcommon.IsMissingTableError(err) {
+			err = dscommon.NewSchemaNotInitializedError(err)
 		}
 		return nil, fmt.Errorf(errListCaveats, err)
 	}
diff --git a/internal/datastore/crdb/crdb.go b/internal/datastore/crdb/crdb.go
@@ -573,7 +573,11 @@ func (cds *crdbDatastore) features(ctx context.Context) (*datastore.Features, er
 			}
 
 			features.Watch.Status = datastore.FeatureUnsupported
-			features.Watch.Reason = "Range feeds must be enabled in CockroachDB and the user must have permission to create them in order to enable the Watch API: " + err.Error()
+			if pgxcommon.IsMissingTableError(err) {
+				features.Watch.Reason = "Database schema has not been initialized. Please run \"spicedb datastore migrate\": " + err.Error()
+			} else {
+				features.Watch.Reason = "Range feeds must be enabled in CockroachDB and the user must have permission to create them in order to enable the Watch API: " + err.Error()
+			}
 			return nil
 		}, fmt.Sprintf(cds.beginChangefeedQuery, cds.schema.RelationshipTableName, head, "-1s"))
 	} else {
diff --git a/internal/datastore/crdb/migrations/driver.go b/internal/datastore/crdb/migrations/driver.go
@@ -15,8 +15,6 @@ import (
 const (
 	errUnableToInstantiate = "unable to instantiate CRDBDriver: %w"
 
-	postgresMissingTableErrorCode = "42P01"
-
 	queryLoadVersion  = "SELECT version_num from schema_version"
 	queryWriteVersion = "UPDATE schema_version SET version_num=$1 WHERE version_num=$2"
 )
@@ -52,7 +50,7 @@ func (apd *CRDBDriver) Version(ctx context.Context) (string, error) {
 
 	if err := apd.db.QueryRow(ctx, queryLoadVersion).Scan(&loaded); err != nil {
 		var pgErr *pgconn.PgError
-		if errors.As(err, &pgErr) && pgErr.Code == postgresMissingTableErrorCode {
+		if errors.As(err, &pgErr) && pgErr.Code == pgxcommon.PgMissingTable {
 			return "", nil
 		}
 		return "", fmt.Errorf("unable to load alembic revision: %w", err)
diff --git a/internal/datastore/postgres/common/bulk.go b/internal/datastore/postgres/common/bulk.go
@@ -6,6 +6,7 @@ import (
 	"github.com/ccoveille/go-safecast/v2"
 	"github.com/jackc/pgx/v5"
 
+	dscommon "github.com/authzed/spicedb/internal/datastore/common"
 	"github.com/authzed/spicedb/pkg/datastore"
 	"github.com/authzed/spicedb/pkg/spiceerrors"
 	"github.com/authzed/spicedb/pkg/tuple"
@@ -77,9 +78,15 @@ func BulkLoad(
 		colNames:     colNames,
 	}
 	copied, err := tx.CopyFrom(ctx, pgx.Identifier{tupleTableName}, colNames, adapter)
+	if err != nil {
+		if IsMissingTableError(err) {
+			return 0, dscommon.NewSchemaNotInitializedError(err)
+		}
+		return 0, err
+	}
 	uintCopied, castErr := safecast.Convert[uint64](copied)
 	if castErr != nil {
 		return 0, spiceerrors.MustBugf("number copied was negative: %v", castErr)
 	}
-	return uintCopied, err
+	return uintCopied, nil
 }
diff --git a/internal/datastore/postgres/common/errors.go b/internal/datastore/postgres/common/errors.go
@@ -19,7 +19,10 @@ const (
 	pgReadOnlyTransaction       = "25006"
 	pgQueryCanceled             = "57014"
 	pgInvalidArgument           = "22023"
-	pgMissingTable              = "42P01"
+
+	// PgMissingTable is the Postgres error code for "relation does not exist".
+	// This is used to detect when migrations have not been run.
+	PgMissingTable = "42P01"
 )
 
 var (
@@ -112,7 +115,7 @@ func ConvertToWriteConstraintError(livingTupleConstraints []string, err error) e
 // This typically happens when migrations have not been run.
 func IsMissingTableError(err error) bool {
 	var pgerr *pgconn.PgError
-	return errors.As(err, &pgerr) && pgerr.Code == pgMissingTable
+	return errors.As(err, &pgerr) && pgerr.Code == PgMissingTable
 }
 
 // WrapMissingTableError checks if the error is a missing table error and wraps it with
diff --git a/internal/datastore/postgres/common/errors_test.go b/internal/datastore/postgres/common/errors_test.go
@@ -13,7 +13,7 @@ import (
 func TestIsMissingTableError(t *testing.T) {
 	t.Run("returns true for missing table error", func(t *testing.T) {
 		pgErr := &pgconn.PgError{
-			Code:    pgMissingTable,
+			Code:    PgMissingTable,
 			Message: "relation \"caveat\" does not exist",
 		}
 		require.True(t, IsMissingTableError(pgErr))
@@ -38,7 +38,7 @@ func TestIsMissingTableError(t *testing.T) {
 
 	t.Run("returns true for wrapped missing table error", func(t *testing.T) {
 		pgErr := &pgconn.PgError{
-			Code:    pgMissingTable,
+			Code:    PgMissingTable,
 			Message: "relation \"caveat\" does not exist",
 		}
 		wrappedErr := fmt.Errorf("query failed: %w", pgErr)
@@ -49,7 +49,7 @@ func TestIsMissingTableError(t *testing.T) {
 func TestWrapMissingTableError(t *testing.T) {
 	t.Run("wraps missing table error", func(t *testing.T) {
 		pgErr := &pgconn.PgError{
-			Code:    pgMissingTable,
+			Code:    PgMissingTable,
 			Message: "relation \"caveat\" does not exist",
 		}
 		wrapped := WrapMissingTableError(pgErr)
@@ -79,7 +79,7 @@ func TestWrapMissingTableError(t *testing.T) {
 
 	t.Run("preserves original error in chain", func(t *testing.T) {
 		pgErr := &pgconn.PgError{
-			Code:    pgMissingTable,
+			Code:    PgMissingTable,
 			Message: "relation \"caveat\" does not exist",
 		}
 		wrapped := WrapMissingTableError(pgErr)
@@ -88,12 +88,12 @@ func TestWrapMissingTableError(t *testing.T) {
 		// The original postgres error should be accessible via unwrapping
 		var foundPgErr *pgconn.PgError
 		require.ErrorAs(t, wrapped, &foundPgErr)
-		require.Equal(t, pgMissingTable, foundPgErr.Code)
+		require.Equal(t, PgMissingTable, foundPgErr.Code)
 	})
 
 	t.Run("does not double-wrap already wrapped errors", func(t *testing.T) {
 		pgErr := &pgconn.PgError{
-			Code:    pgMissingTable,
+			Code:    PgMissingTable,
 			Message: "relation \"caveat\" does not exist",
 		}
 		// First wrap
diff --git a/internal/datastore/postgres/migrations/driver.go b/internal/datastore/postgres/migrations/driver.go
@@ -15,8 +15,6 @@ import (
 	"github.com/authzed/spicedb/pkg/migrate"
 )
 
-const postgresMissingTableErrorCode = "42P01"
-
 var tracer = otel.Tracer("spicedb/internal/datastore/common")
 
 // AlembicPostgresDriver implements a schema migration facility for use in
@@ -74,7 +72,7 @@ func (apd *AlembicPostgresDriver) Version(ctx context.Context) (string, error) {
 
 	if err := apd.db.QueryRow(ctx, "SELECT version_num from alembic_version").Scan(&loaded); err != nil {
 		var pgErr *pgconn.PgError
-		if errors.As(err, &pgErr) && pgErr.Code == postgresMissingTableErrorCode {
+		if errors.As(err, &pgErr) && pgErr.Code == pgxcommon.PgMissingTable {
 			return "", nil
 		}
 		return "", fmt.Errorf("unable to load alembic revision: %w", err)
diff --git a/internal/datastore/postgres/reader.go b/internal/datastore/postgres/reader.go
@@ -84,8 +84,8 @@ func (r *pgReader) CountRelationships(ctx context.Context, name string) (int, er
 		return rows.Err()
 	}, sql, args...)
 	if err != nil {
-		if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {
-			return 0, wrappedErr
+		if pgxcommon.IsMissingTableError(err) {
+			err = common.NewSchemaNotInitializedError(err)
 		}
 		return 0, err
 	}
@@ -142,8 +142,8 @@ func (r *pgReader) lookupCounters(ctx context.Context, optionalName string) ([]d
 		return rows.Err()
 	}, sql, args...)
 	if err != nil {
-		if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {
-			return nil, wrappedErr
+		if pgxcommon.IsMissingTableError(err) {
+			err = common.NewSchemaNotInitializedError(err)
 		}
 		return nil, fmt.Errorf("unable to query counters: %w", err)
 	}
@@ -213,8 +213,8 @@ func (r *pgReader) ReadNamespaceByName(ctx context.Context, nsName string) (*cor
 	case err == nil:
 		return loaded, version, nil
 	default:
-		if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {
-			return nil, datastore.NoRevision, wrappedErr
+		if pgxcommon.IsMissingTableError(err) {
+			err = common.NewSchemaNotInitializedError(err)
 		}
 		return nil, datastore.NoRevision, fmt.Errorf(errUnableToReadConfig, err)
 	}
@@ -241,8 +241,8 @@ func (r *pgReader) loadNamespace(ctx context.Context, namespace string, tx pgxco
 func (r *pgReader) ListAllNamespaces(ctx context.Context) ([]datastore.RevisionedNamespace, error) {
 	nsDefsWithRevisions, err := loadAllNamespaces(ctx, r.query, r.aliveFilter)
 	if err != nil {
-		if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {
-			return nil, wrappedErr
+		if pgxcommon.IsMissingTableError(err) {
+			err = common.NewSchemaNotInitializedError(err)
 		}
 		return nil, fmt.Errorf(errUnableToListNamespaces, err)
 	}
@@ -264,8 +264,8 @@ func (r *pgReader) LookupNamespacesWithNames(ctx context.Context, nsNames []stri
 		return r.aliveFilter(original).Where(clause)
 	})
 	if err != nil {
-		if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {
-			return nil, wrappedErr
+		if pgxcommon.IsMissingTableError(err) {
+			err = common.NewSchemaNotInitializedError(err)
 		}
 		return nil, fmt.Errorf(errUnableToListNamespaces, err)
 	}
diff --git a/internal/datastore/postgres/revisions.go b/internal/datastore/postgres/revisions.go
@@ -312,8 +312,8 @@ func createNewTransaction(ctx context.Context, tx pgx.Tx, metadata map[string]an
 
 	cterr := tx.QueryRow(ctx, sql, args...).Scan(&newXID, &newSnapshot, &timestamp)
 	if cterr != nil {
-		if wrappedErr := common.WrapMissingTableError(cterr); wrappedErr != nil {
-			return newXID, newSnapshot, timestamp, wrappedErr
+		if common.IsMissingTableError(cterr) {
+			cterr = dscommon.NewSchemaNotInitializedError(cterr)
 		}
 		err = fmt.Errorf("error when trying to create a new transaction: %w", cterr)
 	}
diff --git a/internal/datastore/spanner/caveat.go b/internal/datastore/spanner/caveat.go
@@ -18,6 +18,9 @@ func (sr spannerReader) ReadCaveatByName(ctx context.Context, name string) (*cor
 	caveatKey := spanner.Key{name}
 	row, err := sr.txSource().ReadRow(ctx, tableCaveat, caveatKey, []string{colCaveatDefinition, colCaveatTS})
 	if err != nil {
+		if IsMissingTableError(err) {
+			return nil, datastore.NoRevision, common.NewSchemaNotInitializedError(err)
+		}
 		if spanner.ErrCode(err) == codes.NotFound {
 			return nil, datastore.NoRevision, datastore.NewCaveatNameNotFoundErr(name)
 		}
@@ -83,6 +86,9 @@ func (sr spannerReader) listCaveats(ctx context.Context, caveatNames []string) (
 
 		return nil
 	}); err != nil {
+		if IsMissingTableError(err) {
+			return nil, common.NewSchemaNotInitializedError(err)
+		}
 		return nil, fmt.Errorf(errUnableToListCaveats, err)
 	}
 
diff --git a/internal/datastore/spanner/errors.go b/internal/datastore/spanner/errors.go
@@ -0,0 +1,21 @@
+package spanner
+
+import (
+	"strings"
+
+	"cloud.google.com/go/spanner"
+	"google.golang.org/grpc/codes"
+)
+
+// IsMissingTableError returns true if the error is a Spanner error indicating a missing table.
+// This typically happens when migrations have not been run.
+func IsMissingTableError(err error) bool {
+	if spanner.ErrCode(err) == codes.NotFound {
+		// Check if it's specifically about a missing table
+		errMsg := err.Error()
+		if strings.Contains(errMsg, "Table not found") {
+			return true
+		}
+	}
+	return false
+}
diff --git a/internal/datastore/spanner/reader.go b/internal/datastore/spanner/reader.go
@@ -297,6 +297,9 @@ func (sr spannerReader) ReadNamespaceByName(ctx context.Context, nsName string)
 		[]string{colNamespaceConfig, colNamespaceTS},
 	)
 	if err != nil {
+		if IsMissingTableError(err) {
+			return nil, datastore.NoRevision, common.NewSchemaNotInitializedError(err)
+		}
 		if spanner.ErrCode(err) == codes.NotFound {
 			return nil, datastore.NoRevision, datastore.NewNamespaceNotFoundErr(nsName)
 		}
@@ -328,6 +331,9 @@ func (sr spannerReader) ListAllNamespaces(ctx context.Context) ([]datastore.Revi
 
 	allNamespaces, err := readAllNamespaces(iter, trace.SpanFromContext(ctx))
 	if err != nil {
+		if IsMissingTableError(err) {
+			return nil, common.NewSchemaNotInitializedError(err)
+		}
 		return nil, fmt.Errorf(errUnableToListNamespaces, err)
 	}
 

Original file line number	Diff line number	Diff line change
`@@ -184,6 +184,8 @@ type SchemaNotInitializedError struct {`
`184`	`184`	`}`
`185`	`185`
`186`	`186`	`func (err SchemaNotInitializedError) GRPCStatus() *status.Status {`
	`187`	`+ // TODO: Create ERROR_REASON_DATASTORE_NOT_MIGRATED in authzed/api and use it here`
	`188`	`+ // See: https://github.com/authzed/spicedb/pull/2775`
`187`	`189`	`return spiceerrors.WithCodeAndDetails(`
`188`	`190`	`err,`
`189`	`191`	`codes.FailedPrecondition,`
`@@ -202,6 +204,6 @@ func (err SchemaNotInitializedError) Unwrap() error {`
`202`	`204`	`// instructing the user to run migrations.`
`203`	`205`	`func NewSchemaNotInitializedError(underlying error) error {`
`204`	`206`	`return SchemaNotInitializedError{`
`205`		`- fmt.Errorf("datastore error: the database schema has not been initialized; please run \"spicedb datastore migrate\": %w", underlying),`
	`207`	`+ fmt.Errorf("%w. please run \"spicedb datastore migrate\"", underlying),`
`206`	`208`	`}`
`207`	`209`	`}`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ import (`
`9`	`9`	`sq "github.com/Masterminds/squirrel"`
`10`	`10`	`"github.com/jackc/pgx/v5"`
`11`	`11`
	`12`	`+ dscommon "github.com/authzed/spicedb/internal/datastore/common"`
`12`	`13`	`"github.com/authzed/spicedb/internal/datastore/crdb/schema"`
`13`	`14`	`pgxcommon "github.com/authzed/spicedb/internal/datastore/postgres/common"`
`14`	`15`	`"github.com/authzed/spicedb/internal/datastore/revisions"`
`@@ -54,8 +55,8 @@ func (cr crdbReader) ReadCaveatByName(ctx context.Context, name string) (core.`
`54`	`55`	`if errors.Is(err, pgx.ErrNoRows) {`
`55`	`56`	`err = datastore.NewCaveatNameNotFoundErr(name)`
`56`	`57`	`}`
`57`		`- if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {`
`58`		`- return nil, datastore.NoRevision, wrappedErr`
	`58`	`+ if pgxcommon.IsMissingTableError(err) {`
	`59`	`+ err = dscommon.NewSchemaNotInitializedError(err)`
`59`	`60`	`}`
`60`	`61`	`return nil, datastore.NoRevision, fmt.Errorf(errReadCaveat, name, err)`
`61`	`62`	`}`
`@@ -113,8 +114,8 @@ func (cr *crdbReader) lookupCaveats(ctx context.Context, caveatNames []string) (`
`113`	`114`	`return nil`
`114`	`115`	`}, sql, args...)`
`115`	`116`	`if err != nil {`
`116`		`- if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {`
`117`		`- return nil, wrappedErr`
	`117`	`+ if pgxcommon.IsMissingTableError(err) {`
	`118`	`+ err = dscommon.NewSchemaNotInitializedError(err)`
`118`	`119`	`}`
`119`	`120`	`return nil, fmt.Errorf(errListCaveats, err)`
`120`	`121`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,6 @@ import (`
`15`	`15`	`"github.com/authzed/spicedb/pkg/migrate"`
`16`	`16`	`)`
`17`	`17`
`18`		`-const postgresMissingTableErrorCode = "42P01"`
`19`		`-`
`20`	`18`	`var tracer = otel.Tracer("spicedb/internal/datastore/common")`
`21`	`19`
`22`	`20`	`// AlembicPostgresDriver implements a schema migration facility for use in`
`@@ -74,7 +72,7 @@ func (apd *AlembicPostgresDriver) Version(ctx context.Context) (string, error) {`
`74`	`72`
`75`	`73`	`if err := apd.db.QueryRow(ctx, "SELECT version_num from alembic_version").Scan(&loaded); err != nil {`
`76`	`74`	`var pgErr *pgconn.PgError`
`77`		`- if errors.As(err, &pgErr) && pgErr.Code == postgresMissingTableErrorCode {`
	`75`	`+ if errors.As(err, &pgErr) && pgErr.Code == pgxcommon.PgMissingTable {`
`78`	`76`	`return "", nil`
`79`	`77`	`}`
`80`	`78`	`return "", fmt.Errorf("unable to load alembic revision: %w", err)`
Original file line number	Diff line number	Diff line change
`@@ -84,8 +84,8 @@ func (r *pgReader) CountRelationships(ctx context.Context, name string) (int, er`
`84`	`84`	`return rows.Err()`
`85`	`85`	`}, sql, args...)`
`86`	`86`	`if err != nil {`
`87`		`- if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {`
`88`		`- return 0, wrappedErr`
	`87`	`+ if pgxcommon.IsMissingTableError(err) {`
	`88`	`+ err = common.NewSchemaNotInitializedError(err)`
`89`	`89`	`}`
`90`	`90`	`return 0, err`
`91`	`91`	`}`
`@@ -142,8 +142,8 @@ func (r *pgReader) lookupCounters(ctx context.Context, optionalName string) ([]d`
`142`	`142`	`return rows.Err()`
`143`	`143`	`}, sql, args...)`
`144`	`144`	`if err != nil {`
`145`		`- if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {`
`146`		`- return nil, wrappedErr`
	`145`	`+ if pgxcommon.IsMissingTableError(err) {`
	`146`	`+ err = common.NewSchemaNotInitializedError(err)`
`147`	`147`	`}`
`148`	`148`	`return nil, fmt.Errorf("unable to query counters: %w", err)`
`149`	`149`	`}`
`@@ -213,8 +213,8 @@ func (r pgReader) ReadNamespaceByName(ctx context.Context, nsName string) (cor`
`213`	`213`	`case err == nil:`
`214`	`214`	`return loaded, version, nil`
`215`	`215`	`default:`
`216`		`- if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {`
`217`		`- return nil, datastore.NoRevision, wrappedErr`
	`216`	`+ if pgxcommon.IsMissingTableError(err) {`
	`217`	`+ err = common.NewSchemaNotInitializedError(err)`
`218`	`218`	`}`
`219`	`219`	`return nil, datastore.NoRevision, fmt.Errorf(errUnableToReadConfig, err)`
`220`	`220`	`}`
`@@ -241,8 +241,8 @@ func (r *pgReader) loadNamespace(ctx context.Context, namespace string, tx pgxco`
`241`	`241`	`func (r *pgReader) ListAllNamespaces(ctx context.Context) ([]datastore.RevisionedNamespace, error) {`
`242`	`242`	`nsDefsWithRevisions, err := loadAllNamespaces(ctx, r.query, r.aliveFilter)`
`243`	`243`	`if err != nil {`
`244`		`- if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {`
`245`		`- return nil, wrappedErr`
	`244`	`+ if pgxcommon.IsMissingTableError(err) {`
	`245`	`+ err = common.NewSchemaNotInitializedError(err)`
`246`	`246`	`}`
`247`	`247`	`return nil, fmt.Errorf(errUnableToListNamespaces, err)`
`248`	`248`	`}`
`@@ -264,8 +264,8 @@ func (r *pgReader) LookupNamespacesWithNames(ctx context.Context, nsNames []stri`
`264`	`264`	`return r.aliveFilter(original).Where(clause)`
`265`	`265`	`})`
`266`	`266`	`if err != nil {`
`267`		`- if wrappedErr := pgxcommon.WrapMissingTableError(err); wrappedErr != nil {`
`268`		`- return nil, wrappedErr`
	`267`	`+ if pgxcommon.IsMissingTableError(err) {`
	`268`	`+ err = common.NewSchemaNotInitializedError(err)`
`269`	`269`	`}`
`270`	`270`	`return nil, fmt.Errorf(errUnableToListNamespaces, err)`
`271`	`271`	`}`