feat(backend): some member routes, half-broken avatar uploading

backend/db/avatars.go

@@ -0,0 +1,166 @@
+package db
+
+import (
+	"bytes"
+	"context"
+	"encoding/base64"
+	"io"
+	"os/exec"
+	"strings"
+
+	"emperror.dev/errors"
+	"github.com/minio/minio-go/v7"
+	"github.com/rs/xid"
+)
+
+var (
+	webpArgs = []string{"-quality", "50", "webp:-"}
+	jpgArgs  = []string{"-quality", "50", "jpg:-"}
+)
+
+const ErrInvalidDataURI = errors.Sentinel("invalid data URI")
+const ErrInvalidContentType = errors.Sentinel("invalid avatar content type")
+
+// ConvertAvatar parses an avatar from a data URI, converts it to WebP and JPEG, and returns the results.
+func (db *DB) ConvertAvatar(data string) (
+	webp io.Reader,
+	jpg io.Reader,
+	err error,
+) {
+	data = strings.TrimSpace(data)
+	if !strings.Contains(data, ",") || !strings.Contains(data, ":") || !strings.Contains(data, ";") {
+		return nil, nil, ErrInvalidDataURI
+	}
+	split := strings.Split(data, ",")
+	rest, b64 := split[0], split[1]
+
+	rest = strings.Split(rest, ":")[1]
+	contentType := strings.Split(rest, ";")[0]
+
+	var contentArg []string
+	switch contentType {
+	case "image/png":
+		contentArg = []string{"png:-"}
+	case "image/jpeg":
+		contentArg = []string{"jpg:-"}
+	case "image/gif":
+		contentArg = []string{"gif:-"}
+	case "image/webp":
+		contentArg = []string{"webp:-"}
+	default:
+		return nil, nil, ErrInvalidContentType
+	}
+
+	rawData, err := base64.StdEncoding.DecodeString(b64)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "invalid base64 data")
+	}
+
+	// create webp convert command and get its pipes
+	webpConvert := exec.Command("convert", append(contentArg, webpArgs...)...)
+	stdIn, err := webpConvert.StdinPipe()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "getting webp stdin")
+	}
+	stdOut, err := webpConvert.StdoutPipe()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "getting webp stdout")
+	}
+
+	// start webp command
+	err = webpConvert.Start()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "starting webp command")
+	}
+
+	// write data
+	_, err = stdIn.Write(rawData)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "writing webp data")
+	}
+	err = stdIn.Close()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "closing webp stdin")
+	}
+
+	// read webp output
+	webpBuffer := new(bytes.Buffer)
+	_, err = io.Copy(webpBuffer, stdOut)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "reading webp data")
+	}
+	webp = webpBuffer
+
+	// finish webp command
+	err = webpConvert.Wait()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "running webp command")
+	}
+
+	// create jpg convert command and get its pipes
+	jpgConvert := exec.Command("convert", append(contentArg, jpgArgs...)...)
+	stdIn, err = jpgConvert.StdinPipe()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "getting jpg stdin")
+	}
+	stdOut, err = jpgConvert.StdoutPipe()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "getting jpg stdout")
+	}
+
+	// start jpg command
+	err = jpgConvert.Start()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "starting jpg command")
+	}
+
+	// write data
+	_, err = stdIn.Write(rawData)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "writing jpg data")
+	}
+	err = stdIn.Close()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "closing jpg stdin")
+	}
+
+	// read jpg output
+	jpgBuffer := new(bytes.Buffer)
+	_, err = io.Copy(jpgBuffer, stdOut)
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "reading jpg data")
+	}
+	jpg = jpgBuffer
+
+	// finish jpg command
+	err = jpgConvert.Wait()
+	if err != nil {
+		return nil, nil, errors.Wrap(err, "running jpg command")
+	}
+
+	return webp, jpg, nil
+}
+
+func (db *DB) WriteUserAvatar(ctx context.Context,
+	userID xid.ID, webp io.Reader, jpeg io.Reader,
+) (
+	webpLocation string,
+	jpegLocation string,
+	err error,
+) {
+	webpInfo, err := db.minio.PutObject(ctx, db.minioBucket, "/users/"+userID.String()+".webp", webp, -1, minio.PutObjectOptions{
+		ContentType: "image/webp",
+	})
+	if err != nil {
+		return "", "", errors.Wrap(err, "uploading webp avatar")
+	}
+
+	jpegInfo, err := db.minio.PutObject(ctx, db.minioBucket, "/users/"+userID.String()+".jpg", jpeg, -1, minio.PutObjectOptions{
+		ContentType: "image/jpeg",
+	})
+	if err != nil {
+		return "", "", errors.Wrap(err, "uploading jpeg avatar")
+	}
+
+	return webpInfo.Location, jpegInfo.Location, nil
+}

backend/db/db.go

@@ -10,6 +10,8 @@ import (
 	"github.com/Masterminds/squirrel"
 	"github.com/jackc/pgx/v4/pgxpool"
 	"github.com/mediocregopher/radix/v4"
+	"github.com/minio/minio-go/v7"
+	"github.com/minio/minio-go/v7/pkg/credentials"
 )
 
 var sq = squirrel.StatementBuilder.PlaceholderFormat(squirrel.Dollar)
@@ -20,22 +22,36 @@ type DB struct {
 	*pgxpool.Pool
 
 	Redis radix.Client
+
+	minio       *minio.Client
+	minioBucket string
 }
 
-func New(dsn string) (*DB, error) {
-	pool, err := pgxpool.Connect(context.Background(), dsn)
+func New() (*DB, error) {
+	pool, err := pgxpool.Connect(context.Background(), os.Getenv("DATABASE_URL"))
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "creating postgres client")
 	}
 
 	redis, err := (&radix.PoolConfig{}).New(context.Background(), "tcp", os.Getenv("REDIS"))
 	if err != nil {
-		return nil, err
+		return nil, errors.Wrap(err, "creating redis client")
+	}
+
+	minioClient, err := minio.New(os.Getenv("MINIO_ENDPOINT"), &minio.Options{
+		Creds:  credentials.NewStaticV4(os.Getenv("MINIO_ACCESS_KEY_ID"), os.Getenv("MINIO_ACCESS_KEY_SECRET"), ""),
+		Secure: os.Getenv("MINIO_SSL") == "true",
+	})
+	if err != nil {
+		return nil, errors.Wrap(err, "creating minio client")
 	}
 
 	db := &DB{
 		Pool:  pool,
 		Redis: redis,
+
+		minio:       minioClient,
+		minioBucket: os.Getenv("MINIO_BUCKET"),
 	}
 
 	return db, nil

backend/db/field.go

@@ -121,3 +121,51 @@ func (db *DB) SetUserFields(ctx context.Context, tx pgx.Tx, userID xid.ID, field
 	}
 	return nil
 }
+
+// MemberFields returns the fields associated with the given member ID.
+func (db *DB) MemberFields(ctx context.Context, id xid.ID) (fs []Field, err error) {
+	sql, args, err := sq.
+		Select("id", "name", "favourite", "okay", "jokingly", "friends_only", "avoid").
+		From("member_fields").Where("member_id = ?", id).OrderBy("id ASC").ToSql()
+	if err != nil {
+		return nil, errors.Wrap(err, "building sql")
+	}
+
+	err = pgxscan.Select(ctx, db, &fs, sql, args...)
+	if err != nil {
+		return nil, errors.Cause(err)
+	}
+	return fs, nil
+}
+
+// SetMemberFields updates the fields for the given member.
+func (db *DB) SetMemberFields(ctx context.Context, tx pgx.Tx, memberID xid.ID, fields []Field) (err error) {
+	sql, args, err := sq.Delete("member_fields").Where("member_id = ?", memberID).ToSql()
+	if err != nil {
+		return errors.Wrap(err, "building sql")
+	}
+
+	_, err = tx.Exec(ctx, sql, args...)
+	if err != nil {
+		return errors.Wrap(err, "deleting existing fields")
+	}
+
+	_, err = tx.CopyFrom(ctx,
+		pgx.Identifier{"member_fields"},
+		[]string{"member_id", "name", "favourite", "okay", "jokingly", "friends_only", "avoid"},
+		pgx.CopyFromSlice(len(fields), func(i int) ([]any, error) {
+			return []any{
+				memberID,
+				fields[i].Name,
+				fields[i].Favourite,
+				fields[i].Okay,
+				fields[i].Jokingly,
+				fields[i].FriendsOnly,
+				fields[i].Avoid,
+			}, nil
+		}))
+	if err != nil {
+		return errors.Wrap(err, "inserting new fields")
+	}
+	return nil
+}

backend/db/member.go

@@ -0,0 +1,73 @@
+package db
+
+import (
+	"context"
+
+	"emperror.dev/errors"
+	"github.com/georgysavva/scany/pgxscan"
+	"github.com/jackc/pgx/v4"
+	"github.com/rs/xid"
+)
+
+type Member struct {
+	ID        xid.ID
+	UserID    xid.ID
+	Name      string
+	Bio       *string
+	AvatarURL *string
+	Links     []string
+}
+
+const ErrMemberNotFound = errors.Sentinel("member not found")
+
+func (db *DB) Member(ctx context.Context, id xid.ID) (m Member, err error) {
+	sql, args, err := sq.Select("*").From("members").Where("id = ?", id).ToSql()
+	if err != nil {
+		return m, errors.Wrap(err, "building sql")
+	}
+
+	err = pgxscan.Get(ctx, db, &m, sql, args...)
+	if err != nil {
+		if errors.Cause(err) == pgx.ErrNoRows {
+			return m, ErrMemberNotFound
+		}
+
+		return m, errors.Wrap(err, "retrieving member")
+	}
+	return m, nil
+}
+
+func (db *DB) UserMember(ctx context.Context, userID xid.ID, memberRef string) (m Member, err error) {
+	sql, args, err := sq.Select("*").From("members").
+		Where("user_id = ? and (id = ? or name = ?)", userID, memberRef, memberRef).ToSql()
+	if err != nil {
+		return m, errors.Wrap(err, "building sql")
+	}
+
+	err = pgxscan.Get(ctx, db, &m, sql, args...)
+	if err != nil {
+		if errors.Cause(err) == pgx.ErrNoRows {
+			return m, ErrMemberNotFound
+		}
+
+		return m, errors.Wrap(err, "retrieving member")
+	}
+	return m, nil
+}
+
+func (db *DB) UserMembers(ctx context.Context, userID xid.ID) (ms []Member, err error) {
+	sql, args, err := sq.Select("*").From("members").Where("user_id = ?", userID).ToSql()
+	if err != nil {
+		return nil, errors.Wrap(err, "building sql")
+	}
+
+	err = pgxscan.Select(ctx, db, &ms, sql, args...)
+	if err != nil {
+		return nil, errors.Wrap(err, "retrieving members")
+	}
+
+	if ms == nil {
+		ms = make([]Member, 0)
+	}
+	return ms, nil
+}

backend/db/names_pronouns.go

@@ -170,3 +170,87 @@ func (db *DB) SetUserPronouns(ctx context.Context, tx pgx.Tx, userID xid.ID, nam
 	}
 	return nil
 }
+
+func (db *DB) MemberNames(ctx context.Context, memberID xid.ID) (ns []Name, err error) {
+	sql, args, err := sq.Select("id", "name", "status").From("member_names").Where("member_id = ?", memberID).OrderBy("id").ToSql()
+	if err != nil {
+		return nil, errors.Wrap(err, "building sql")
+	}
+
+	err = pgxscan.Select(ctx, db, &ns, sql, args...)
+	if err != nil {
+		return nil, errors.Wrap(err, "executing query")
+	}
+	return ns, nil
+}
+
+func (db *DB) MemberPronouns(ctx context.Context, memberID xid.ID) (ps []Pronoun, err error) {
+	sql, args, err := sq.
+		Select("id", "display_text", "pronouns", "status").
+		From("member_pronouns").Where("member_id = ?", memberID).
+		OrderBy("id").ToSql()
+	if err != nil {
+		return nil, errors.Wrap(err, "building sql")
+	}
+
+	err = pgxscan.Select(ctx, db, &ps, sql, args...)
+	if err != nil {
+		return nil, errors.Wrap(err, "executing query")
+	}
+	return ps, nil
+}
+
+func (db *DB) SetMemberNames(ctx context.Context, tx pgx.Tx, memberID xid.ID, names []Name) (err error) {
+	sql, args, err := sq.Delete("member_names").Where("member_id = ?", memberID).ToSql()
+	if err != nil {
+		return errors.Wrap(err, "building sql")
+	}
+
+	_, err = tx.Exec(ctx, sql, args...)
+	if err != nil {
+		return errors.Wrap(err, "deleting existing names")
+	}
+
+	_, err = tx.CopyFrom(ctx,
+		pgx.Identifier{"member_names"},
+		[]string{"member_id", "name", "status"},
+		pgx.CopyFromSlice(len(names), func(i int) ([]any, error) {
+			return []any{
+				memberID,
+				names[i].Name,
+				names[i].Status,
+			}, nil
+		}))
+	if err != nil {
+		return errors.Wrap(err, "inserting new names")
+	}
+	return nil
+}
+
+func (db *DB) SetMemberPronouns(ctx context.Context, tx pgx.Tx, memberID xid.ID, names []Pronoun) (err error) {
+	sql, args, err := sq.Delete("member_pronouns").Where("member_id = ?", memberID).ToSql()
+	if err != nil {
+		return errors.Wrap(err, "building sql")
+	}
+
+	_, err = tx.Exec(ctx, sql, args...)
+	if err != nil {
+		return errors.Wrap(err, "deleting existing pronouns")
+	}
+
+	_, err = tx.CopyFrom(ctx,
+		pgx.Identifier{"member_pronouns"},
+		[]string{"member_id", "pronouns", "display_text", "status"},
+		pgx.CopyFromSlice(len(names), func(i int) ([]any, error) {
+			return []any{
+				memberID,
+				names[i].Pronouns,
+				names[i].DisplayText,
+				names[i].Status,
+			}, nil
+		}))
+	if err != nil {
+		return errors.Wrap(err, "inserting new pronouns")
+	}
+	return nil
+}

backend/db/user.go

@@ -19,7 +19,7 @@ type User struct {
 	Bio         *string
 
 	AvatarSource *string
-	AvatarURL    *string
+	AvatarURLs   []string `db:"avatar_urls"`
 	Links        []string
 
 	Discord         *string
@@ -103,12 +103,6 @@ func (u *User) UpdateFromDiscord(ctx context.Context, db pgxscan.Querier, du *di
 		Where("id = ?", u.ID).
 		Suffix("RETURNING *")
 
-	if u.AvatarSource == nil || *u.AvatarSource == "discord" {
-		builder = builder.
-			Set("avatar_source", "discord").
-			Set("avatar_url", du.AvatarURL("1024"))
-	}
-
 	sql, args, err := builder.ToSql()
 	if err != nil {
 		return errors.Wrap(err, "building sql")
@@ -160,6 +154,7 @@ func (db *DB) UpdateUser(
 	tx pgx.Tx, id xid.ID,
 	displayName, bio *string,
 	links *[]string,
+	avatarURLs []string,
 ) (u User, err error) {
 	if displayName == nil && bio == nil && links == nil {
 		return u, ErrNothingToUpdate
@@ -188,6 +183,14 @@ func (db *DB) UpdateUser(
 		}
 	}
 
+	if avatarURLs != nil {
+		if len(avatarURLs) == 0 {
+			builder = builder.Set("avatar_urls", nil)
+		} else {
+			builder = builder.Set("avatar_urls", avatarURLs)
+		}
+	}
+
 	sql, args, err := builder.Suffix("RETURNING *").ToSql()
 	if err != nil {
 		return u, errors.Wrap(err, "building sql")