// Code generated by sqlc. DO NOT EDIT.

// versions:

// sqlc v1.16.0

package database

import (

"context"

"database/sql"

"encoding/json"

"time"

"github.com/coder/coder/coderd/database/dbtype"

"github.com/google/uuid"

"github.com/lib/pq"

"github.com/tabbed/pqtype"

)

const deleteOldAgentStats = `-- name: DeleteOldAgentStats :exec

DELETE FROM agent_stats WHERE created_at < NOW() - INTERVAL '30 days'

`

func (q *sqlQuerier) DeleteOldAgentStats(ctx context.Context) error {

_, err := q.db.ExecContext(ctx, deleteOldAgentStats)

return err

}

const getDeploymentDAUs = `-- name: GetDeploymentDAUs :many

SELECT

(created_at at TIME ZONE 'UTC')::date as date,

user_id

FROM

agent_stats

GROUP BY

date, user_id

ORDER BY

date ASC

`

type GetDeploymentDAUsRow struct {

Date time.Time `db:"date" json:"date"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

}

func (q *sqlQuerier) GetDeploymentDAUs(ctx context.Context) ([]GetDeploymentDAUsRow, error) {

rows, err := q.db.QueryContext(ctx, getDeploymentDAUs)

if err != nil {

return nil, err

}

defer rows.Close()

var items []GetDeploymentDAUsRow

for rows.Next() {

var i GetDeploymentDAUsRow

if err := rows.Scan(&i.Date, &i.UserID); err != nil {

return nil, err

}

items = append(items, i)

}

if err := rows.Close(); err != nil {

return nil, err

}

if err := rows.Err(); err != nil {

return nil, err

}

return items, nil

}

const getTemplateDAUs = `-- name: GetTemplateDAUs :many

SELECT

(created_at at TIME ZONE 'UTC')::date as date,

user_id

FROM

agent_stats

WHERE

template_id = $1

GROUP BY

date, user_id

ORDER BY

date ASC

`

type GetTemplateDAUsRow struct {

Date time.Time `db:"date" json:"date"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

}

func (q *sqlQuerier) GetTemplateDAUs(ctx context.Context, templateID uuid.UUID) ([]GetTemplateDAUsRow, error) {

rows, err := q.db.QueryContext(ctx, getTemplateDAUs, templateID)

if err != nil {

return nil, err

}

defer rows.Close()

var items []GetTemplateDAUsRow

for rows.Next() {

var i GetTemplateDAUsRow

if err := rows.Scan(&i.Date, &i.UserID); err != nil {

return nil, err

}

items = append(items, i)

}

if err := rows.Close(); err != nil {

return nil, err

}

if err := rows.Err(); err != nil {

return nil, err

}

return items, nil

}

const insertAgentStat = `-- name: InsertAgentStat :one

INSERT INTO

agent_stats (

id,

created_at,

user_id,

workspace_id,

template_id,

agent_id,

payload

)

VALUES

($1, $2, $3, $4, $5, $6, $7) RETURNING id, created_at, user_id, agent_id, workspace_id, template_id, payload

`

type InsertAgentStatParams struct {

ID uuid.UUID `db:"id" json:"id"`

CreatedAt time.Time `db:"created_at" json:"created_at"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

WorkspaceID uuid.UUID `db:"workspace_id" json:"workspace_id"`

TemplateID uuid.UUID `db:"template_id" json:"template_id"`

AgentID uuid.UUID `db:"agent_id" json:"agent_id"`

Payload json.RawMessage `db:"payload" json:"payload"`

}

func (q *sqlQuerier) InsertAgentStat(ctx context.Context, arg InsertAgentStatParams) (AgentStat, error) {

row := q.db.QueryRowContext(ctx, insertAgentStat,

arg.ID,

arg.CreatedAt,

arg.UserID,

arg.WorkspaceID,

arg.TemplateID,

arg.AgentID,

arg.Payload,

)

var i AgentStat

err := row.Scan(

&i.ID,

&i.CreatedAt,

&i.UserID,

&i.AgentID,

&i.WorkspaceID,

&i.TemplateID,

&i.Payload,

)

return i, err

}

const deleteAPIKeyByID = `-- name: DeleteAPIKeyByID :exec

DELETE

FROM

api_keys

WHERE

id = $1

`

func (q *sqlQuerier) DeleteAPIKeyByID(ctx context.Context, id string) error {

_, err := q.db.ExecContext(ctx, deleteAPIKeyByID, id)

return err

}

const deleteAPIKeysByUserID = `-- name: DeleteAPIKeysByUserID :exec

DELETE FROM

api_keys

WHERE

user_id = $1

`

func (q *sqlQuerier) DeleteAPIKeysByUserID(ctx context.Context, userID uuid.UUID) error {

_, err := q.db.ExecContext(ctx, deleteAPIKeysByUserID, userID)

return err

}

const getAPIKeyByID = `-- name: GetAPIKeyByID :one

SELECT

id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope

FROM

api_keys

WHERE

id = $1

LIMIT

1

`

func (q *sqlQuerier) GetAPIKeyByID(ctx context.Context, id string) (APIKey, error) {

row := q.db.QueryRowContext(ctx, getAPIKeyByID, id)

var i APIKey

err := row.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

)

return i, err

}

const getAPIKeysByLoginType = `-- name: GetAPIKeysByLoginType :many

SELECT id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope FROM api_keys WHERE login_type = $1

`

func (q *sqlQuerier) GetAPIKeysByLoginType(ctx context.Context, loginType LoginType) ([]APIKey, error) {

rows, err := q.db.QueryContext(ctx, getAPIKeysByLoginType, loginType)

if err != nil {

return nil, err

}

defer rows.Close()

var items []APIKey

for rows.Next() {

var i APIKey

if err := rows.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

); err != nil {

return nil, err

}

items = append(items, i)

}

if err := rows.Close(); err != nil {

return nil, err

}

if err := rows.Err(); err != nil {

return nil, err

}

return items, nil

}

const getAPIKeysLastUsedAfter = `-- name: GetAPIKeysLastUsedAfter :many

SELECT id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope FROM api_keys WHERE last_used > $1

`

func (q *sqlQuerier) GetAPIKeysLastUsedAfter(ctx context.Context, lastUsed time.Time) ([]APIKey, error) {

rows, err := q.db.QueryContext(ctx, getAPIKeysLastUsedAfter, lastUsed)

if err != nil {

return nil, err

}

defer rows.Close()

var items []APIKey

for rows.Next() {

var i APIKey

if err := rows.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

); err != nil {

return nil, err

}

items = append(items, i)

}

if err := rows.Close(); err != nil {

return nil, err

}

if err := rows.Err(); err != nil {

return nil, err

}

return items, nil

}

const insertAPIKey = `-- name: InsertAPIKey :one

INSERT INTO

api_keys (

id,

lifetime_seconds,

hashed_secret,

ip_address,

user_id,

last_used,

expires_at,

created_at,

updated_at,

login_type,

scope

)

VALUES

($1,

-- If the lifetime is set to 0, default to 24hrs

CASE $2::bigint

WHEN 0 THEN 86400

ELSE $2::bigint

END

, $3, $4, $5, $6, $7, $8, $9, $10, $11) RETURNING id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope

`

type InsertAPIKeyParams struct {

ID string `db:"id" json:"id"`

LifetimeSeconds int64 `db:"lifetime_seconds" json:"lifetime_seconds"`

HashedSecret []byte `db:"hashed_secret" json:"hashed_secret"`

IPAddress pqtype.Inet `db:"ip_address" json:"ip_address"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

LastUsed time.Time `db:"last_used" json:"last_used"`

ExpiresAt time.Time `db:"expires_at" json:"expires_at"`

CreatedAt time.Time `db:"created_at" json:"created_at"`

UpdatedAt time.Time `db:"updated_at" json:"updated_at"`

LoginType LoginType `db:"login_type" json:"login_type"`

Scope APIKeyScope `db:"scope" json:"scope"`

}

func (q *sqlQuerier) InsertAPIKey(ctx context.Context, arg InsertAPIKeyParams) (APIKey, error) {

row := q.db.QueryRowContext(ctx, insertAPIKey,

arg.ID,

arg.LifetimeSeconds,

arg.HashedSecret,

arg.IPAddress,

arg.UserID,

arg.LastUsed,

arg.ExpiresAt,

arg.CreatedAt,

arg.UpdatedAt,

arg.LoginType,

arg.Scope,

)

var i APIKey

err := row.Scan(

&i.ID,

&i.HashedSecret,

&i.UserID,

&i.LastUsed,

&i.ExpiresAt,

&i.CreatedAt,

&i.UpdatedAt,

&i.LoginType,

&i.LifetimeSeconds,

&i.IPAddress,

&i.Scope,

)

return i, err

}

const updateAPIKeyByID = `-- name: UpdateAPIKeyByID :exec

UPDATE

api_keys

SET

last_used = $2,

expires_at = $3,

ip_address = $4

WHERE

id = $1

`

type UpdateAPIKeyByIDParams struct {

ID string `db:"id" json:"id"`

LastUsed time.Time `db:"last_used" json:"last_used"`

ExpiresAt time.Time `db:"expires_at" json:"expires_at"`

IPAddress pqtype.Inet `db:"ip_address" json:"ip_address"`

}

func (q *sqlQuerier) UpdateAPIKeyByID(ctx context.Context, arg UpdateAPIKeyByIDParams) error {

_, err := q.db.ExecContext(ctx, updateAPIKeyByID,

arg.ID,

arg.LastUsed,

arg.ExpiresAt,

arg.IPAddress,

)

return err

}

const getAuditLogsOffset = `-- name: GetAuditLogsOffset :many

SELECT

audit_logs.id, audit_logs.time, audit_logs.user_id, audit_logs.organization_id, audit_logs.ip, audit_logs.user_agent, audit_logs.resource_type, audit_logs.resource_id, audit_logs.resource_target, audit_logs.action, audit_logs.diff, audit_logs.status_code, audit_logs.additional_fields, audit_logs.request_id, audit_logs.resource_icon,

users.username AS user_username,

users.email AS user_email,

users.created_at AS user_created_at,

users.status AS user_status,

users.rbac_roles AS user_roles,

users.avatar_url AS user_avatar_url,

COUNT(audit_logs.*) OVER () AS count

FROM

audit_logs

LEFT JOIN users ON audit_logs.user_id = users.id

LEFT JOIN

-- First join on workspaces to get the initial workspace create

-- to workspace build 1 id. This is because the first create is

-- is a different audit log than subsequent starts.

workspaces ON

audit_logs.resource_type = 'workspace' AND

audit_logs.resource_id = workspaces.id

LEFT JOIN

workspace_builds ON

-- Get the reason from the build if the resource type

-- is a workspace_build

(

audit_logs.resource_type = 'workspace_build'

AND audit_logs.resource_id = workspace_builds.id

)

OR

-- Get the reason from the build #1 if this is the first

-- workspace create.

(

audit_logs.resource_type = 'workspace' AND

audit_logs.action = 'create' AND

workspaces.id = workspace_builds.workspace_id AND

workspace_builds.build_number = 1

)

WHERE

-- Filter resource_type

CASE

WHEN $3 :: text != '' THEN

resource_type = $3 :: resource_type

ELSE true

END

-- Filter resource_id

AND CASE

WHEN $4 :: uuid != '00000000-0000-0000-0000-000000000000'::uuid THEN

resource_id = $4

ELSE true

END

-- Filter by resource_target

AND CASE

WHEN $5 :: text != '' THEN

resource_target = $5

ELSE true

END

-- Filter action

AND CASE

WHEN $6 :: text != '' THEN

action = $6 :: audit_action

ELSE true

END

-- Filter by username

AND CASE

WHEN $7 :: text != '' THEN

users.username = $7

ELSE true

END

-- Filter by user_email

AND CASE

WHEN $8 :: text != '' THEN

users.email = $8

ELSE true

END

-- Filter by date_from

AND CASE

WHEN $9 :: timestamp with time zone != '0001-01-01 00:00:00Z' THEN

"time" >= $9

ELSE true

END

-- Filter by date_to

AND CASE

WHEN $10 :: timestamp with time zone != '0001-01-01 00:00:00Z' THEN

"time" <= $10

ELSE true

END

-- Filter by build_reason

AND CASE

WHEN $11::text != '' THEN

workspace_builds.reason::text = $11

ELSE true

END

ORDER BY

"time" DESC

LIMIT

$1

OFFSET

$2

`

type GetAuditLogsOffsetParams struct {

Limit int32 `db:"limit" json:"limit"`

Offset int32 `db:"offset" json:"offset"`

ResourceType string `db:"resource_type" json:"resource_type"`

ResourceID uuid.UUID `db:"resource_id" json:"resource_id"`

ResourceTarget string `db:"resource_target" json:"resource_target"`

Action string `db:"action" json:"action"`

Username string `db:"username" json:"username"`

Email string `db:"email" json:"email"`

DateFrom time.Time `db:"date_from" json:"date_from"`

DateTo time.Time `db:"date_to" json:"date_to"`

BuildReason string `db:"build_reason" json:"build_reason"`

}

type GetAuditLogsOffsetRow struct {

ID uuid.UUID `db:"id" json:"id"`

Time time.Time `db:"time" json:"time"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"`

Ip pqtype.Inet `db:"ip" json:"ip"`

UserAgent sql.NullString `db:"user_agent" json:"user_agent"`

ResourceType ResourceType `db:"resource_type" json:"resource_type"`

ResourceID uuid.UUID `db:"resource_id" json:"resource_id"`

ResourceTarget string `db:"resource_target" json:"resource_target"`

Action AuditAction `db:"action" json:"action"`

Diff json.RawMessage `db:"diff" json:"diff"`

StatusCode int32 `db:"status_code" json:"status_code"`

AdditionalFields json.RawMessage `db:"additional_fields" json:"additional_fields"`

RequestID uuid.UUID `db:"request_id" json:"request_id"`

ResourceIcon string `db:"resource_icon" json:"resource_icon"`

UserUsername sql.NullString `db:"user_username" json:"user_username"`

UserEmail sql.NullString `db:"user_email" json:"user_email"`

UserCreatedAt sql.NullTime `db:"user_created_at" json:"user_created_at"`

UserStatus NullUserStatus `db:"user_status" json:"user_status"`

UserRoles []string `db:"user_roles" json:"user_roles"`

UserAvatarUrl sql.NullString `db:"user_avatar_url" json:"user_avatar_url"`

Count int64 `db:"count" json:"count"`

}

// GetAuditLogsBefore retrieves `row_limit` number of audit logs before the provided

// ID.

func (q *sqlQuerier) GetAuditLogsOffset(ctx context.Context, arg GetAuditLogsOffsetParams) ([]GetAuditLogsOffsetRow, error) {

rows, err := q.db.QueryContext(ctx, getAuditLogsOffset,

arg.Limit,

arg.Offset,

arg.ResourceType,

arg.ResourceID,

arg.ResourceTarget,

arg.Action,

arg.Username,

arg.Email,

arg.DateFrom,

arg.DateTo,

arg.BuildReason,

)

if err != nil {

return nil, err

}

defer rows.Close()

var items []GetAuditLogsOffsetRow

for rows.Next() {

var i GetAuditLogsOffsetRow

if err := rows.Scan(

&i.ID,

&i.Time,

&i.UserID,

&i.OrganizationID,

&i.Ip,

&i.UserAgent,

&i.ResourceType,

&i.ResourceID,

&i.ResourceTarget,

&i.Action,

&i.Diff,

&i.StatusCode,

&i.AdditionalFields,

&i.RequestID,

&i.ResourceIcon,

&i.UserUsername,

&i.UserEmail,

&i.UserCreatedAt,

&i.UserStatus,

pq.Array(&i.UserRoles),

&i.UserAvatarUrl,

&i.Count,

); err != nil {

return nil, err

}

items = append(items, i)

}

if err := rows.Close(); err != nil {

return nil, err

}

if err := rows.Err(); err != nil {

return nil, err

}

return items, nil

}

const insertAuditLog = `-- name: InsertAuditLog :one

INSERT INTO

audit_logs (

id,

"time",

user_id,

organization_id,

ip,

user_agent,

resource_type,

resource_id,

resource_target,

action,

diff,

status_code,

additional_fields,

request_id,

resource_icon

)

VALUES

($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15) RETURNING id, time, user_id, organization_id, ip, user_agent, resource_type, resource_id, resource_target, action, diff, status_code, additional_fields, request_id, resource_icon

`

type InsertAuditLogParams struct {

ID uuid.UUID `db:"id" json:"id"`

Time time.Time `db:"time" json:"time"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

OrganizationID uuid.UUID `db:"organization_id" json:"organization_id"`

Ip pqtype.Inet `db:"ip" json:"ip"`

UserAgent sql.NullString `db:"user_agent" json:"user_agent"`

ResourceType ResourceType `db:"resource_type" json:"resource_type"`

ResourceID uuid.UUID `db:"resource_id" json:"resource_id"`

ResourceTarget string `db:"resource_target" json:"resource_target"`

Action AuditAction `db:"action" json:"action"`

Diff json.RawMessage `db:"diff" json:"diff"`

StatusCode int32 `db:"status_code" json:"status_code"`

AdditionalFields json.RawMessage `db:"additional_fields" json:"additional_fields"`

RequestID uuid.UUID `db:"request_id" json:"request_id"`

ResourceIcon string `db:"resource_icon" json:"resource_icon"`

}

func (q *sqlQuerier) InsertAuditLog(ctx context.Context, arg InsertAuditLogParams) (AuditLog, error) {

row := q.db.QueryRowContext(ctx, insertAuditLog,

arg.ID,

arg.Time,

arg.UserID,

arg.OrganizationID,

arg.Ip,

arg.UserAgent,

arg.ResourceType,

arg.ResourceID,

arg.ResourceTarget,

arg.Action,

arg.Diff,

arg.StatusCode,

arg.AdditionalFields,

arg.RequestID,

arg.ResourceIcon,

)

var i AuditLog

err := row.Scan(

&i.ID,

&i.Time,

&i.UserID,

&i.OrganizationID,

&i.Ip,

&i.UserAgent,

&i.ResourceType,

&i.ResourceID,

&i.ResourceTarget,

&i.Action,

&i.Diff,

&i.StatusCode,

&i.AdditionalFields,

&i.RequestID,

&i.ResourceIcon,

)

return i, err

}

const getFileByHashAndCreator = `-- name: GetFileByHashAndCreator :one

SELECT

hash, created_at, created_by, mimetype, data, id

FROM

files

WHERE

hash = $1

AND

created_by = $2

LIMIT

1

`

type GetFileByHashAndCreatorParams struct {

Hash string `db:"hash" json:"hash"`

CreatedBy uuid.UUID `db:"created_by" json:"created_by"`

}

func (q *sqlQuerier) GetFileByHashAndCreator(ctx context.Context, arg GetFileByHashAndCreatorParams) (File, error) {

row := q.db.QueryRowContext(ctx, getFileByHashAndCreator, arg.Hash, arg.CreatedBy)

var i File

err := row.Scan(

&i.Hash,

&i.CreatedAt,

&i.CreatedBy,

&i.Mimetype,

&i.Data,

&i.ID,

)

return i, err

}

const getFileByID = `-- name: GetFileByID :one

SELECT

hash, created_at, created_by, mimetype, data, id

FROM

files

WHERE

id = $1

LIMIT

1

`

func (q *sqlQuerier) GetFileByID(ctx context.Context, id uuid.UUID) (File, error) {

row := q.db.QueryRowContext(ctx, getFileByID, id)

var i File

err := row.Scan(

&i.Hash,

&i.CreatedAt,

&i.CreatedBy,

&i.Mimetype,

&i.Data,

&i.ID,

)

return i, err

}

const insertFile = `-- name: InsertFile :one

INSERT INTO

files (id, hash, created_at, created_by, mimetype, "data")

VALUES

($1, $2, $3, $4, $5, $6) RETURNING hash, created_at, created_by, mimetype, data, id

`

type InsertFileParams struct {

ID uuid.UUID `db:"id" json:"id"`

Hash string `db:"hash" json:"hash"`

CreatedAt time.Time `db:"created_at" json:"created_at"`

CreatedBy uuid.UUID `db:"created_by" json:"created_by"`

Mimetype string `db:"mimetype" json:"mimetype"`

Data []byte `db:"data" json:"data"`

}

func (q *sqlQuerier) InsertFile(ctx context.Context, arg InsertFileParams) (File, error) {

row := q.db.QueryRowContext(ctx, insertFile,

arg.ID,

arg.Hash,

arg.CreatedAt,

arg.CreatedBy,

arg.Mimetype,

arg.Data,

)

var i File

err := row.Scan(

&i.Hash,

&i.CreatedAt,

&i.CreatedBy,

&i.Mimetype,

&i.Data,

&i.ID,

)

return i, err

}

const getGitAuthLink = `-- name: GetGitAuthLink :one

SELECT provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry FROM git_auth_links WHERE provider_id = $1 AND user_id = $2

`

type GetGitAuthLinkParams struct {

ProviderID string `db:"provider_id" json:"provider_id"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

}

func (q *sqlQuerier) GetGitAuthLink(ctx context.Context, arg GetGitAuthLinkParams) (GitAuthLink, error) {

row := q.db.QueryRowContext(ctx, getGitAuthLink, arg.ProviderID, arg.UserID)

var i GitAuthLink

err := row.Scan(

&i.ProviderID,

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.OAuthAccessToken,

&i.OAuthRefreshToken,

&i.OAuthExpiry,

)

return i, err

}

const insertGitAuthLink = `-- name: InsertGitAuthLink :one

INSERT INTO git_auth_links (

provider_id,

user_id,

created_at,

updated_at,

oauth_access_token,

oauth_refresh_token,

oauth_expiry

) VALUES (

$1,

$2,

$3,

$4,

$5,

$6,

$7

) RETURNING provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry

`

type InsertGitAuthLinkParams struct {

ProviderID string `db:"provider_id" json:"provider_id"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

CreatedAt time.Time `db:"created_at" json:"created_at"`

UpdatedAt time.Time `db:"updated_at" json:"updated_at"`

OAuthAccessToken string `db:"oauth_access_token" json:"oauth_access_token"`

OAuthRefreshToken string `db:"oauth_refresh_token" json:"oauth_refresh_token"`

OAuthExpiry time.Time `db:"oauth_expiry" json:"oauth_expiry"`

}

func (q *sqlQuerier) InsertGitAuthLink(ctx context.Context, arg InsertGitAuthLinkParams) (GitAuthLink, error) {

row := q.db.QueryRowContext(ctx, insertGitAuthLink,

arg.ProviderID,

arg.UserID,

arg.CreatedAt,

arg.UpdatedAt,

arg.OAuthAccessToken,

arg.OAuthRefreshToken,

arg.OAuthExpiry,

)

var i GitAuthLink

err := row.Scan(

&i.ProviderID,

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.OAuthAccessToken,

&i.OAuthRefreshToken,

&i.OAuthExpiry,

)

return i, err

}

const updateGitAuthLink = `-- name: UpdateGitAuthLink :exec

UPDATE git_auth_links SET

updated_at = $3,

oauth_access_token = $4,

oauth_refresh_token = $5,

oauth_expiry = $6

WHERE provider_id = $1 AND user_id = $2

`

type UpdateGitAuthLinkParams struct {

ProviderID string `db:"provider_id" json:"provider_id"`

UserID uuid.UUID `db:"user_id" json:"user_id"`

UpdatedAt time.Time `db:"updated_at" json:"updated_at"`

OAuthAccessToken string `db:"oauth_access_token" json:"oauth_access_token"`

OAuthRefreshToken string `db:"oauth_refresh_token" json:"oauth_refresh_token"`

OAuthExpiry time.Time `db:"oauth_expiry" json:"oauth_expiry"`

}

func (q *sqlQuerier) UpdateGitAuthLink(ctx context.Context, arg UpdateGitAuthLinkParams) error {

_, err := q.db.ExecContext(ctx, updateGitAuthLink,

arg.ProviderID,

arg.UserID,

arg.UpdatedAt,

arg.OAuthAccessToken,

arg.OAuthRefreshToken,

arg.OAuthExpiry,

)

return err

}

const deleteGitSSHKey = `-- name: DeleteGitSSHKey :exec

DELETE FROM

gitsshkeys

WHERE

user_id = $1

`

func (q *sqlQuerier) DeleteGitSSHKey(ctx context.Context, userID uuid.UUID) error {

_, err := q.db.ExecContext(ctx, deleteGitSSHKey, userID)

return err

}

const getGitSSHKey = `-- name: GetGitSSHKey :one

SELECT

user_id, created_at, updated_at, private_key, public_key

FROM

gitsshkeys

WHERE

user_id = $1

`

func (q *sqlQuerier) GetGitSSHKey(ctx context.Context, userID uuid.UUID) (GitSSHKey, error) {

row := q.db.QueryRowContext(ctx, getGitSSHKey, userID)

var i GitSSHKey

err := row.Scan(

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.PrivateKey,

&i.PublicKey,

)

return i, err

}

const insertGitSSHKey = `-- name: InsertGitSSHKey :one

INSERT INTO

gitsshkeys (

user_id,

created_at,

updated_at,

private_key,

public_key

)

VALUES

($1, $2, $3, $4, $5) RETURNING user_id, created_at, updated_at, private_key, public_key

`

type InsertGitSSHKeyParams struct {

UserID uuid.UUID `db:"user_id" json:"user_id"`

CreatedAt time.Time `db:"created_at" json:"created_at"`

UpdatedAt time.Time `db:"updated_at" json:"updated_at"`

PrivateKey string `db:"private_key" json:"private_key"`

PublicKey string `db:"public_key" json:"public_key"`

}

func (q *sqlQuerier) InsertGitSSHKey(ctx context.Context, arg InsertGitSSHKeyParams) (GitSSHKey, error) {

row := q.db.QueryRowContext(ctx, insertGitSSHKey,

arg.UserID,

arg.CreatedAt,

arg.UpdatedAt,

arg.PrivateKey,

arg.PublicKey,

)

var i GitSSHKey

err := row.Scan(

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.PrivateKey,

&i.PublicKey,

)

return i, err

}

const updateGitSSHKey = `-- name: UpdateGitSSHKey :one

UPDATE

gitsshkeys

SET

updated_at = $2,

private_key = $3,

public_key = $4

WHERE

user_id = $1

RETURNING

user_id, created_at, updated_at, private_key, public_key

`

type UpdateGitSSHKeyParams struct {

UserID uuid.UUID `db:"user_id" json:"user_id"`

UpdatedAt time.Time `db:"updated_at" json:"updated_at"`

PrivateKey string `db:"private_key" json:"private_key"`

PublicKey string `db:"public_key" json:"public_key"`

}

func (q *sqlQuerier) UpdateGitSSHKey(ctx context.Context, arg UpdateGitSSHKeyParams) (GitSSHKey, error) {

row := q.db.QueryRowContext(ctx, updateGitSSHKey,

arg.UserID,

arg.UpdatedAt,

arg.PrivateKey,

arg.PublicKey,

)

var i GitSSHKey

err := row.Scan(

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.PrivateKey,

&i.PublicKey,

)

return i, err

}

const deleteGroupMemberFromGroup = `-- name: DeleteGroupMemberFromGroup :exec

DELETE FROM

group_members

WHERE

user_id = $1 AND

group_id = $2

`

type DeleteGroupMemberFromGroupParams struct {

UserID uuid.UUID `db:"user_id" json:"user_id"`

GroupID uuid.UUID `db:"group_id" json:"group_id"`

}

func (q *sqlQuerier) DeleteGroupMemberFromGroup(ctx context.Context, arg DeleteGroupMemberFromGroupParams) error {

_, err := q.db.ExecContext(ctx, deleteGroupMemberFromGroup, arg.UserID, arg.GroupID)

return err

}

const deleteGroupMembersByOrgAndUser = `-- name: DeleteGroupMembersByOrgAndUser :exec

DELETE FROM