OwnCord/Server/db/pgdbgen/dm.sql.go

//go:build postgres

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: dm.sql

package pgdbgen

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
)

const closeDM = `-- name: CloseDM :exec
DELETE FROM dm_open_state WHERE user_id = $1 AND channel_id = $2
`

type CloseDMParams struct {
	UserID    int64 `json:"userId"`
	ChannelID int64 `json:"channelId"`
}

func (q *Queries) CloseDM(ctx context.Context, arg CloseDMParams) error {
	_, err := q.db.Exec(ctx, closeDM, arg.UserID, arg.ChannelID)
	return err
}

const findExistingDMChannel = `-- name: FindExistingDMChannel :one
SELECT dp1.channel_id
FROM dm_participants dp1
JOIN dm_participants dp2 ON dp1.channel_id = dp2.channel_id
JOIN channels c ON c.id = dp1.channel_id
WHERE dp1.user_id = $1 AND dp2.user_id = $2 AND c.type = 'dm'
LIMIT 1
`

type FindExistingDMChannelParams struct {
	UserID   int64 `json:"userId"`
	UserID_2 int64 `json:"userId2"`
}

func (q *Queries) FindExistingDMChannel(ctx context.Context, arg FindExistingDMChannelParams) (int64, error) {
	row := q.db.QueryRow(ctx, findExistingDMChannel, arg.UserID, arg.UserID_2)
	var channel_id int64
	err := row.Scan(&channel_id)
	return channel_id, err
}

const getDMParticipantIDs = `-- name: GetDMParticipantIDs :many
SELECT user_id FROM dm_participants WHERE channel_id = $1
`

func (q *Queries) GetDMParticipantIDs(ctx context.Context, channelID int64) ([]int64, error) {
	rows, err := q.db.Query(ctx, getDMParticipantIDs, channelID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []int64{}
	for rows.Next() {
		var user_id int64
		if err := rows.Scan(&user_id); err != nil {
			return nil, err
		}
		items = append(items, user_id)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getUserDMChannels = `-- name: GetUserDMChannels :many
SELECT
    c.id                                          AS channel_id,
    u.id                                          AS recipient_id,
    u.username                                    AS recipient_username,
    COALESCE(u.avatar, '')                        AS recipient_avatar,
    u.status                                      AS recipient_status,
    lm.id                                         AS last_message_id,
    COALESCE(lm.content, '')                      AS last_message,
    COALESCE(lm.timestamp, dos.opened_at)         AS last_message_at,
    COUNT(CASE WHEN m_unread.id > COALESCE(rs.last_message_id, 0)
               AND m_unread.deleted = FALSE THEN 1 END) AS unread_count
FROM dm_open_state dos
JOIN channels c          ON c.id = dos.channel_id AND c.type = 'dm'
JOIN dm_participants dp  ON dp.channel_id = c.id AND dp.user_id != $1
JOIN users u             ON u.id = dp.user_id
LEFT JOIN messages lm    ON lm.id = (
    SELECT MAX(id) FROM messages WHERE channel_id = c.id AND deleted = FALSE
)
LEFT JOIN messages m_unread ON m_unread.channel_id = c.id
LEFT JOIN read_states rs ON rs.channel_id = c.id AND rs.user_id = $2
WHERE dos.user_id = $3
GROUP BY c.id, u.id, lm.id, lm.content, lm.timestamp, dos.opened_at
ORDER BY COALESCE(lm.timestamp, dos.opened_at) DESC
`

type GetUserDMChannelsParams struct {
	UserID   int64 `json:"userId"`
	UserID_2 int64 `json:"userId2"`
	UserID_3 int64 `json:"userId3"`
}

type GetUserDMChannelsRow struct {
	ChannelID         int64              `json:"channelId"`
	RecipientID       int64              `json:"recipientId"`
	RecipientUsername string             `json:"recipientUsername"`
	RecipientAvatar   string             `json:"recipientAvatar"`
	RecipientStatus   string             `json:"recipientStatus"`
	LastMessageID     *int64             `json:"lastMessageId"`
	LastMessage       string             `json:"lastMessage"`
	LastMessageAt     pgtype.Timestamptz `json:"lastMessageAt"`
	UnreadCount       int64              `json:"unreadCount"`
}

// For the "last message at" and "last message content" columns, sqlite
// COALESCEs to ” (empty string). Postgres TIMESTAMPTZ cannot COALESCE to an
// empty string, so we COALESCE to the dm_open_state.opened_at fallback and
// leave conversion to the store wrapper.
func (q *Queries) GetUserDMChannels(ctx context.Context, arg GetUserDMChannelsParams) ([]GetUserDMChannelsRow, error) {
	rows, err := q.db.Query(ctx, getUserDMChannels, arg.UserID, arg.UserID_2, arg.UserID_3)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []GetUserDMChannelsRow{}
	for rows.Next() {
		var i GetUserDMChannelsRow
		if err := rows.Scan(
			&i.ChannelID,
			&i.RecipientID,
			&i.RecipientUsername,
			&i.RecipientAvatar,
			&i.RecipientStatus,
			&i.LastMessageID,
			&i.LastMessage,
			&i.LastMessageAt,
			&i.UnreadCount,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const insertDMChannel = `-- name: InsertDMChannel :one

INSERT INTO channels (name, type) VALUES ('', 'dm') RETURNING id
`

// PostgreSQL variants of the sqlite DM queries.
// InsertDMChannel: sqlite uses :execresult (LastInsertId); postgres uses
// :one with RETURNING id.
// `INSERT OR IGNORE` becomes `INSERT ... ON CONFLICT DO NOTHING`.
func (q *Queries) InsertDMChannel(ctx context.Context) (int64, error) {
	row := q.db.QueryRow(ctx, insertDMChannel)
	var id int64
	err := row.Scan(&id)
	return id, err
}

const insertDMOpenState = `-- name: InsertDMOpenState :exec
INSERT INTO dm_open_state (user_id, channel_id) VALUES ($1, $2), ($3, $4)
ON CONFLICT (user_id, channel_id) DO NOTHING
`

type InsertDMOpenStateParams struct {
	UserID      int64 `json:"userId"`
	ChannelID   int64 `json:"channelId"`
	UserID_2    int64 `json:"userId2"`
	ChannelID_2 int64 `json:"channelId2"`
}

func (q *Queries) InsertDMOpenState(ctx context.Context, arg InsertDMOpenStateParams) error {
	_, err := q.db.Exec(ctx, insertDMOpenState,
		arg.UserID,
		arg.ChannelID,
		arg.UserID_2,
		arg.ChannelID_2,
	)
	return err
}

const insertDMParticipants = `-- name: InsertDMParticipants :exec
INSERT INTO dm_participants (channel_id, user_id) VALUES ($1, $2), ($3, $4)
`

type InsertDMParticipantsParams struct {
	ChannelID   int64 `json:"channelId"`
	UserID      int64 `json:"userId"`
	ChannelID_2 int64 `json:"channelId2"`
	UserID_2    int64 `json:"userId2"`
}

func (q *Queries) InsertDMParticipants(ctx context.Context, arg InsertDMParticipantsParams) error {
	_, err := q.db.Exec(ctx, insertDMParticipants,
		arg.ChannelID,
		arg.UserID,
		arg.ChannelID_2,
		arg.UserID_2,
	)
	return err
}

const isDMParticipant = `-- name: IsDMParticipant :one
SELECT user_id FROM dm_participants WHERE user_id = $1 AND channel_id = $2
`

type IsDMParticipantParams struct {
	UserID    int64 `json:"userId"`
	ChannelID int64 `json:"channelId"`
}

func (q *Queries) IsDMParticipant(ctx context.Context, arg IsDMParticipantParams) (int64, error) {
	row := q.db.QueryRow(ctx, isDMParticipant, arg.UserID, arg.ChannelID)
	var user_id int64
	err := row.Scan(&user_id)
	return user_id, err
}

const openDM = `-- name: OpenDM :exec
INSERT INTO dm_open_state (user_id, channel_id) VALUES ($1, $2)
ON CONFLICT (user_id, channel_id) DO NOTHING
`

type OpenDMParams struct {
	UserID    int64 `json:"userId"`
	ChannelID int64 `json:"channelId"`
}

func (q *Queries) OpenDM(ctx context.Context, arg OpenDMParams) error {
	_, err := q.db.Exec(ctx, openDM, arg.UserID, arg.ChannelID)
	return err
}