wip

mangezmieux-backend/internal/acl/sql/dao.go

@@ -0,0 +1,39 @@
+package sql
+
+import (
+	"github.com/google/uuid"
+	"mangezmieux-backend/internal/acl/model"
+	model2 "mangezmieux-backend/internal/model"
+)
+
+type Dao interface {
+	//Role
+	GetRole(id uuid.UUID) (*model.Role, error)
+	GetRoleByName(name string) (*model.Role, error)
+	AddRole(roleName string, metadata model2.Metadata) (*model.Role, error)
+	DeleteRole(id uuid.UUID) error
+	GetAllRole() ([]*model.Role, error)
+
+	//Resource
+	AddResource(resourceName string, metadata model2.Metadata) (*model.Resource, error)
+	DeleteResource(id uuid.UUID) error
+	GetResource(id uuid.UUID) (*model.Resource, error)
+	GetResourceByName(name string) (*model.Resource, error)
+	GetAllResource() ([]*model.Resource, error)
+
+	//RoleVerbResource
+	GetRoleVerbResource(id uuid.UUID) (*model.RoleVerbResource, error)
+	GetRoleVerbResourceByRoleResourceAndVerb(roleId, resourceId uuid.UUID, verb string) (*model.RoleVerbResource, error)
+	GetRoleVerbResourceByRoleResource(roleId, resourceId uuid.UUID) ([]*model.RoleVerbResource, error)
+	GetRoleVerbResourceByRole(roleId uuid.UUID) ([]*model.RoleVerbResource, error)
+	AddRoleVerbResource(roleId, resourceId uuid.UUID, verb string, metadata model2.Metadata) (*model.RoleVerbResource, error)
+	DeleteRoleVerbResource(id uuid.UUID) error
+
+	//UserRole
+	GetUserRole(id uuid.UUID) (*model.UserRole, error)
+	GetUserRoleByUserAndRole(userId, roleId uuid.UUID) (*model.UserRole, error)
+	GetUserRoleByUser(userId uuid.UUID) ([]*model.UserRole, error)
+	GetUserRoleByRole(role uuid.UUID) ([]*model.UserRole, error)
+	AddUserRole(userId, roleId uuid.UUID, metadata model2.Metadata) (*model.UserRole, error)
+	DeleteUserRole(id uuid.UUID) error
+}

mangezmieux-backend/internal/acl/sql/sql.go

@@ -0,0 +1,13 @@
+package sql
+
+import (
+	"database/sql"
+)
+
+type dao struct {
+	client *sql.DB
+}
+
+func NewDao(client *sql.DB) Dao {
+	return &dao{client: client}
+}

mangezmieux-backend/internal/acl/sql/sql_resource.go

@@ -0,0 +1,121 @@
+package sql
+
+import (
+	"database/sql"
+	"errors"
+	"github.com/google/uuid"
+	"github.com/lib/pq"
+	"mangezmieux-backend/internal/acl/model"
+	model2 "mangezmieux-backend/internal/model"
+	"mangezmieux-backend/internal/postgres"
+)
+
+func (sqlDAO dao) AddResource(resourceName string, metadata model2.Metadata) (*model.Resource, error) {
+	var Id uuid.UUID
+	q := `
+			INSERT INTO mangezmieux.resource
+				(name, creation_date, creation_user)
+			VALUES
+				($1, $2, $3)
+			RETURNING
+				Id`
+
+	err := sqlDAO.client.QueryRow(q, resourceName, metadata.CreationDate, metadata.CreationUser).Scan(&Id)
+
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	resource, err := sqlDAO.GetResource(Id)
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	return resource, nil
+}
+
+func (sqlDAO dao) DeleteResource(Id uuid.UUID) error {
+	q := `
+		DELETE FROM mangezmieux.resource
+		WHERE Id = $1 
+	`
+
+	_, err := sqlDAO.client.Exec(q, Id.String())
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return postgres.HandlePgError(errPq)
+	}
+	return err
+}
+
+func (sqlDAO dao) GetResource(Id uuid.UUID) (*model.Resource, error) {
+	q := `
+		SELECT Id, name, creation_date, last_update_date
+		FROM mangezmieux.resource r
+		WHERE r.Id = $1
+	`
+	row := sqlDAO.client.QueryRow(q, Id.String())
+
+	resource := &model.Resource{}
+	err := row.Scan(&resource.Id, &resource.Name, &resource.CreationDate, &resource.LastUpdateDate)
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+	}
+	return resource, nil
+}
+
+func (sqlDAO dao) GetResourceByName(name string) (*model.Resource, error) {
+	q := `
+		SELECT Id, name, creation_date, last_update_date
+		FROM mangezmieux.resource r
+		WHERE r.name = $1
+	`
+	row := sqlDAO.client.QueryRow(q, name)
+
+	resource := &model.Resource{}
+	err := row.Scan(&resource.Id, &resource.Name, &resource.CreationDate, &resource.LastUpdateDate)
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+	}
+	return resource, nil
+}
+
+func (sqlDAO dao) GetAllResource() ([]*model.Resource, error) {
+	q := `
+		SELECT Id, name, creation_date, last_update_date
+		FROM mangezmieux.resource r
+	`
+	rows, err := sqlDAO.client.Query(q)
+	if err != nil {
+		return nil, err
+	}
+
+	if rows.Err() != nil {
+		return nil, rows.Err()
+	}
+
+	defer rows.Close()
+	resources := make([]*model.Resource, 0)
+	for rows.Next() {
+		resource := &model.Resource{}
+		err := rows.Scan(&resource.Id, &resource.Name, &resource.CreationDate, &resource.LastUpdateDate)
+		var errPq *pq.Error
+		if errors.As(err, &errPq) {
+			return nil, postgres.HandlePgError(errPq)
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+		}
+		resources = append(resources, resource)
+	}
+	return resources, nil
+}

mangezmieux-backend/internal/acl/sql/sql_role.go

@@ -0,0 +1,121 @@
+package sql
+
+import (
+	"database/sql"
+	"errors"
+	"github.com/google/uuid"
+	"github.com/lib/pq"
+	"mangezmieux-backend/internal/acl/model"
+	model2 "mangezmieux-backend/internal/model"
+	"mangezmieux-backend/internal/postgres"
+)
+
+func (sqlDAO dao) GetRole(id uuid.UUID) (*model.Role, error) {
+	q := `
+		SELECT id, name, creation_date, last_update_date
+		FROM mangezmieux.role r
+		WHERE r.id = $1
+	`
+	row := sqlDAO.client.QueryRow(q, id.String())
+
+	role := &model.Role{}
+	err := row.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+	}
+	return role, nil
+}
+
+func (sqlDAO dao) GetRoleByName(name string) (*model.Role, error) {
+	q := `
+		SELECT id, name, creation_date, last_update_date
+		FROM mangezmieux.role r
+		WHERE r.name = $1
+	`
+	row := sqlDAO.client.QueryRow(q, name)
+
+	role := &model.Role{}
+	err := row.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+	}
+	return role, nil
+}
+
+func (sqlDAO dao) AddRole(roleName string, metadata model2.Metadata) (*model.Role, error) {
+	var id uuid.UUID
+	q := `
+			INSERT INTO mangezmieux.role
+				(name, creation_date, creation_user)
+			VALUES
+				($1,$2,$3)
+			RETURNING
+				id`
+
+	err := sqlDAO.client.QueryRow(q, roleName, metadata.CreationDate, metadata.CreationUser).Scan(&id)
+
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	role, err := sqlDAO.GetRole(id)
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	return role, nil
+}
+
+func (sqlDAO dao) DeleteRole(id uuid.UUID) error {
+	q := `
+		DELETE FROM mangezmieux.role
+		WHERE id = $1 
+	`
+
+	_, err := sqlDAO.client.Exec(q, id.String())
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return postgres.HandlePgError(errPq)
+	}
+	return err
+}
+
+func (sqlDAO dao) GetAllRole() ([]*model.Role, error) {
+	q := `
+		SELECT id, name, creation_date, last_update_date
+		FROM mangezmieux.role r
+	`
+	rows, err := sqlDAO.client.Query(q)
+	if err != nil {
+		return nil, err
+	}
+
+	if rows.Err() != nil {
+		return nil, rows.Err()
+	}
+
+	defer rows.Close()
+	roles := make([]*model.Role, 0)
+	for rows.Next() {
+		role := &model.Role{}
+		err := rows.Scan(&role.Id, &role.Name, &role.CreationDate, &role.LastUpdateDate)
+		var errPq *pq.Error
+		if errors.As(err, &errPq) {
+			return nil, postgres.HandlePgError(errPq)
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+		}
+		roles = append(roles, role)
+	}
+	return roles, nil
+}

mangezmieux-backend/internal/acl/sql/sql_role_verb_resource.go

@@ -0,0 +1,191 @@
+package sql
+
+import (
+	"database/sql"
+	"errors"
+	"mangezmieux-backend/internal/acl/model"
+	model2 "mangezmieux-backend/internal/model"
+	"mangezmieux-backend/internal/postgres"
+
+	"github.com/google/uuid"
+	"github.com/lib/pq"
+)
+
+func (sqlDAO dao) GetRoleVerbResource(id uuid.UUID) (*model.RoleVerbResource, error) {
+	q := `
+		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
+		FROM mangezmieux.role_verb_resource r
+		WHERE r.id = $1
+	`
+	row := sqlDAO.client.QueryRow(q, id.String())
+
+	roleVerbResource := &model.RoleVerbResource{}
+	err := row.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+	}
+	return roleVerbResource, nil
+}
+
+func (sqlDAO dao) GetRoleVerbResourceByRoleResourceAndVerb(roleId, resourceId uuid.UUID, verb string) (*model.RoleVerbResource, error) {
+	q := `
+		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
+		FROM mangezmieux.role_verb_resource r
+		WHERE r.role_id = $1 
+		AND r.resource_id = $2
+		AND r.verb = $3
+	`
+	row := sqlDAO.client.QueryRow(q, roleId.String(), resourceId.String(), verb)
+
+	roleVerbResource := &model.RoleVerbResource{}
+	err := row.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+	}
+	return roleVerbResource, nil
+}
+
+func (sqlDAO dao) GetRoleVerbResourceByResourceAndVerb(resourceId uuid.UUID, verb string) ([]*model.RoleVerbResource, error) {
+	q := `
+		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
+		FROM mangezmieux.role_verb_resource r
+		WHERE r.resource_id = $1
+		AND r.verb = $2
+	`
+	rows, err := sqlDAO.client.Query(q, resourceId.String(), verb)
+	if err != nil {
+		return nil, err
+	}
+
+	if rows.Err() != nil {
+		return nil, rows.Err()
+	}
+
+	defer rows.Close()
+	roleVerResources := make([]*model.RoleVerbResource, 0)
+	for rows.Next() {
+		roleVerbResource := &model.RoleVerbResource{}
+		err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
+		var errPq *pq.Error
+		if errors.As(err, &errPq) {
+			return nil, postgres.HandlePgError(errPq)
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+		}
+		roleVerResources = append(roleVerResources, roleVerbResource)
+	}
+	return roleVerResources, nil
+}
+
+func (sqlDAO dao) GetRoleVerbResourceByRoleResource(roleId, resourceId uuid.UUID) ([]*model.RoleVerbResource, error) {
+	q := `
+		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
+		FROM mangezmieux.role_verb_resource r
+		WHERE r.role_id = $1 
+		AND r.resource_id = $2
+	`
+	rows, err := sqlDAO.client.Query(q, roleId.String(), resourceId.String())
+	if err != nil {
+		return nil, err
+	}
+
+	if rows.Err() != nil {
+		return nil, rows.Err()
+	}
+
+	defer rows.Close()
+	roleVerResources := make([]*model.RoleVerbResource, 0)
+	for rows.Next() {
+		roleVerbResource := &model.RoleVerbResource{}
+		err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
+		var errPq *pq.Error
+		if errors.As(err, &errPq) {
+			return nil, postgres.HandlePgError(errPq)
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+		}
+		roleVerResources = append(roleVerResources, roleVerbResource)
+	}
+	return roleVerResources, nil
+}
+
+func (sqlDAO dao) GetRoleVerbResourceByRole(roleId uuid.UUID) ([]*model.RoleVerbResource, error) {
+	q := `
+		SELECT id, role_id, verb, resource_id, creation_date, last_update_date
+		FROM mangezmieux.role_verb_resource r
+		WHERE r.role_id = $1 
+	`
+	rows, err := sqlDAO.client.Query(q, roleId.String())
+	if err != nil {
+		return nil, err
+	}
+
+	if rows.Err() != nil {
+		return nil, rows.Err()
+	}
+
+	defer rows.Close()
+	roleVerResources := make([]*model.RoleVerbResource, 0)
+	for rows.Next() {
+		roleVerbResource := &model.RoleVerbResource{}
+		err := rows.Scan(&roleVerbResource.Id, &roleVerbResource.RoleId, &roleVerbResource.Verb, &roleVerbResource.ResourceId, &roleVerbResource.CreationDate, &roleVerbResource.LastUpdateDate)
+		var errPq *pq.Error
+		if errors.As(err, &errPq) {
+			return nil, postgres.HandlePgError(errPq)
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+		}
+		roleVerResources = append(roleVerResources, roleVerbResource)
+	}
+	return roleVerResources, nil
+}
+
+func (sqlDAO dao) AddRoleVerbResource(roleId, resourceId uuid.UUID, verb string, metadata model2.Metadata) (*model.RoleVerbResource, error) {
+	var Id uuid.UUID
+	q := `
+			INSERT INTO mangezmieux.role_verb_resource
+				(role_id, verb, resource_id, creation_date, creation_user)
+			VALUES
+				($1,$2,$3,$4,$5)
+			RETURNING
+				Id`
+
+	err := sqlDAO.client.QueryRow(q, roleId.String(), verb, resourceId.String(), metadata.CreationDate, metadata.CreationUser).Scan(&Id)
+
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	roleVerbResource, err := sqlDAO.GetRoleVerbResource(Id)
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	return roleVerbResource, nil
+}
+
+func (sqlDAO dao) DeleteRoleVerbResource(id uuid.UUID) error {
+	q := `
+		DELETE FROM mangezmieux.role_verb_resource
+		WHERE Id = $1 
+	`
+
+	_, err := sqlDAO.client.Exec(q, id.String())
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return postgres.HandlePgError(errPq)
+	}
+	return err
+}

mangezmieux-backend/internal/acl/sql/sql_user_role.go

@@ -0,0 +1,161 @@
+package sql
+
+import (
+	"database/sql"
+	"errors"
+	"mangezmieux-backend/internal/acl/model"
+	model2 "mangezmieux-backend/internal/model"
+	"mangezmieux-backend/internal/postgres"
+
+	"github.com/google/uuid"
+	"github.com/lib/pq"
+)
+
+func (sqlDAO dao) GetUserRole(id uuid.UUID) (*model.UserRole, error) {
+	q := `
+		SELECT id, role_id, user_id, creation_date, last_update_date
+		FROM mangezmieux.user_role r
+		WHERE r.id = $1
+	`
+	row := sqlDAO.client.QueryRow(q, id.String())
+
+	userRole := &model.UserRole{}
+	err := row.Scan(&userRole.Id, &userRole.RoleId, &userRole.UserId, &userRole.CreationDate, &userRole.LastUpdateDate)
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+	}
+	return userRole, nil
+}
+
+func (sqlDAO dao) GetUserRoleByUserAndRole(userId, roleId uuid.UUID) (*model.UserRole, error) {
+	q := `
+		SELECT id, role_id, user_id, creation_date, last_update_date
+		FROM mangezmieux.user_role r
+		WHERE r.role_id = $1 
+		AND r.user_id = $2
+	`
+	row := sqlDAO.client.QueryRow(q, roleId.String(), userId.String())
+
+	userRole := &model.UserRole{}
+	err := row.Scan(&userRole.Id, &userRole.RoleId, &userRole.UserId, &userRole.CreationDate, &userRole.LastUpdateDate)
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+	if errors.Is(err, sql.ErrNoRows) {
+		return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+	}
+	return userRole, nil
+}
+
+func (sqlDAO dao) GetUserRoleByUser(userId uuid.UUID) ([]*model.UserRole, error) {
+	q := `
+		SELECT id, role_id, user_id, creation_date, last_update_date
+		FROM mangezmieux.user_role r
+		WHERE r.user_id = $1
+	`
+	rows, err := sqlDAO.client.Query(q, userId.String())
+	if errors.Is(err, sql.ErrNoRows) {
+		return make([]*model.UserRole, 0), nil
+	}
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	if rows.Err() != nil {
+		return nil, rows.Err()
+	}
+
+	defer rows.Close()
+	userRoles := make([]*model.UserRole, 0)
+	for rows.Next() {
+		userRole := &model.UserRole{}
+		err := rows.Scan(&userRole.Id, &userRole.RoleId, &userRole.UserId, &userRole.CreationDate, &userRole.LastUpdateDate)
+		var errPq *pq.Error
+		if errors.As(err, &errPq) {
+			return nil, postgres.HandlePgError(errPq)
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+		}
+		userRoles = append(userRoles, userRole)
+	}
+	return userRoles, nil
+}
+
+func (sqlDAO dao) GetUserRoleByRole(role uuid.UUID) ([]*model.UserRole, error) {
+	q := `
+		SELECT id, role_id, user_id, creation_date, last_update_date
+		FROM mangezmieux.user_role r
+		WHERE r.role_id = $1
+	`
+	rows, err := sqlDAO.client.Query(q, role.String())
+	if err != nil {
+		return nil, err
+	}
+
+	if rows.Err() != nil {
+		return nil, rows.Err()
+	}
+
+	defer rows.Close()
+	userRoles := make([]*model.UserRole, 0)
+	for rows.Next() {
+		userRole := &model.UserRole{}
+		err := rows.Scan(&userRole.Id, &userRole.RoleId, &userRole.UserId, &userRole.CreationDate, &userRole.LastUpdateDate)
+		var errPq *pq.Error
+		if errors.As(err, &errPq) {
+			return nil, postgres.HandlePgError(errPq)
+		}
+		if errors.Is(err, sql.ErrNoRows) {
+			return nil, postgres.NewDAOError(postgres.ErrTypeNotFound, err)
+		}
+		userRoles = append(userRoles, userRole)
+	}
+	return userRoles, nil
+}
+
+func (sqlDAO dao) AddUserRole(userId, roleId uuid.UUID, metadata model2.Metadata) (*model.UserRole, error) {
+	var Id uuid.UUID
+	q := `
+			INSERT INTO mangezmieux.user_role
+				(user_id, role_id, creation_date, creation_user)
+			VALUES
+				($1,$2,$3,$4)
+			RETURNING
+				Id`
+
+	err := sqlDAO.client.QueryRow(q, userId.String(), roleId.String(), metadata.CreationDate, metadata.CreationUser).Scan(&Id)
+
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	userRole, err := sqlDAO.GetUserRole(Id)
+	if errors.As(err, &errPq) {
+		return nil, postgres.HandlePgError(errPq)
+	}
+
+	return userRole, nil
+}
+
+func (sqlDAO dao) DeleteUserRole(id uuid.UUID) error {
+	q := `
+		DELETE FROM mangezmieux.user_role
+		WHERE Id = $1 
+	`
+
+	_, err := sqlDAO.client.Exec(q, id.String())
+	var errPq *pq.Error
+	if errors.As(err, &errPq) {
+		return postgres.HandlePgError(errPq)
+	}
+	return err
+}