// Code generated by sqlc. DO NOT EDIT.

// versions:

// sqlc v1.20.0

package database

import (

"context"

"database/sql"

"encoding/json"

"time"

"github.com/google/uuid"

"github.com/lib/pq"

"github.com/sqlc-dev/pqtype"

)

const activityBumpWorkspace = `-- name: ActivityBumpWorkspace :exec

WITH latest AS (

SELECT

workspace_builds.id::uuid AS build_id,

workspace_builds.deadline::timestamp with time zone AS build_deadline,

workspace_builds.max_deadline::timestamp with time zone AS build_max_deadline,

workspace_builds.transition AS build_transition,

provisioner_jobs.completed_at::timestamp with time zone AS job_completed_at,

(

CASE

-- If the extension would push us over the next_autostart

-- interval, then extend the deadline by the full ttl from

-- the autostart time. This will essentially be as if the

-- workspace auto started at the given time and the original

-- TTL was applied.

WHEN NOW() + ('60 minutes')::interval > $1 :: timestamptz

-- If the autostart is behind now(), then the

-- autostart schedule is either the 0 time and not provided,

-- or it was the autostart in the past, which is no longer

-- relevant. If autostart is > 0 and in the past, then

-- that is a mistake by the caller.

AND $1 > NOW()

THEN

-- Extend to the autostart, then add the TTL

(($1 :: timestamptz) - NOW()) + CASE

WHEN templates.allow_user_autostop

THEN (workspaces.ttl / 1000 / 1000 / 1000 || ' seconds')::interval

ELSE (templates.default_ttl / 1000 / 1000 / 1000 || ' seconds')::interval

END

-- Default to 60 minutes.

ELSE

('60 minutes')::interval

END

) AS ttl_interval

FROM workspace_builds

JOIN provisioner_jobs

ON provisioner_jobs.id = workspace_builds.job_id

JOIN workspaces

ON workspaces.id = workspace_builds.workspace_id

JOIN templates

ON templates.id = workspaces.template_id

WHERE workspace_builds.workspace_id = $2::uuid

ORDER BY workspace_builds.build_number DESC

LIMIT 1

)

UPDATE

workspace_builds wb

SET

updated_at = NOW(),

deadline = CASE

WHEN l.build_max_deadline = '0001-01-01 00:00:00+00'

-- Never reduce the deadline from activity.

THEN GREATEST(wb.deadline, NOW() + l.ttl_interval)

ELSE LEAST(GREATEST(wb.deadline, NOW() + l.ttl_interval), l.build_max_deadline)

END

FROM latest l

WHERE wb.id = l.build_id

AND l.job_completed_at IS NOT NULL

AND l.build_transition = 'start'

AND l.ttl_interval > '0 seconds'::interval

AND l.build_deadline != '0001-01-01 00:00:00+00'

AND l.build_deadline - (l.ttl_interval * 0.95) < NOW()

`

type ActivityBumpWorkspaceParams struct {

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

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

}

// Bumps the workspace deadline by 1 hour. If the workspace bump will

// cross an autostart threshold, then the bump is autostart + TTL. This

// is the deadline behavior if the workspace was to autostart from a stopped

// state.

// Max deadline is respected, and will never be bumped.

// The deadline will never decrease.

// We only bump if the raw interval is positive and non-zero.

// We only bump if workspace shutdown is manual.

// We only bump when 5% of the deadline has elapsed.

func (q *sqlQuerier) ActivityBumpWorkspace(ctx context.Context, arg ActivityBumpWorkspaceParams) error {

_, err := q.db.ExecContext(ctx, activityBumpWorkspace, arg.NextAutostart, arg.WorkspaceID)

return 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 deleteApplicationConnectAPIKeysByUserID = `-- name: DeleteApplicationConnectAPIKeysByUserID :exec

DELETE FROM

api_keys

WHERE

user_id = $1 AND

scope = 'application_connect'::api_key_scope

`

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

_, err := q.db.ExecContext(ctx, deleteApplicationConnectAPIKeysByUserID, 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, token_name

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,

&i.TokenName,

)

return i, err

}

const getAPIKeyByName = `-- name: GetAPIKeyByName :one

SELECT

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

FROM

api_keys

WHERE

user_id = $1 AND

token_name = $2 AND

token_name != ''

LIMIT

1

`

type GetAPIKeyByNameParams struct {

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

TokenName string `db:"token_name" json:"token_name"`

}

// there is no unique constraint on empty token names

func (q *sqlQuerier) GetAPIKeyByName(ctx context.Context, arg GetAPIKeyByNameParams) (APIKey, error) {

row := q.db.QueryRowContext(ctx, getAPIKeyByName, arg.UserID, arg.TokenName)

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,

&i.TokenName,

)

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, token_name 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,

&i.TokenName,

); 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 getAPIKeysByUserID = `-- name: GetAPIKeysByUserID :many

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

`

type GetAPIKeysByUserIDParams struct {

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

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

}

func (q *sqlQuerier) GetAPIKeysByUserID(ctx context.Context, arg GetAPIKeysByUserIDParams) ([]APIKey, error) {

rows, err := q.db.QueryContext(ctx, getAPIKeysByUserID, arg.LoginType, arg.UserID)

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,

&i.TokenName,

); 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, token_name 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,

&i.TokenName,

); 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,

token_name

)

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, $12) RETURNING id, hashed_secret, user_id, last_used, expires_at, created_at, updated_at, login_type, lifetime_seconds, ip_address, scope, token_name

`

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"`

TokenName string `db:"token_name" json:"token_name"`

}

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,

arg.TokenName,

)

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,

&i.TokenName,

)

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 user_id

AND CASE

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

user_id = $7

ELSE true

END

-- Filter by username

AND CASE

WHEN $8 :: text != '' THEN

user_id = (SELECT id FROM users WHERE lower(username) = lower($8) AND deleted = false)

ELSE true

END

-- Filter by user_email

AND CASE

WHEN $9 :: text != '' THEN

users.email = $9

ELSE true

END

-- Filter by date_from

AND CASE

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

"time" >= $10

ELSE true

END

-- Filter by date_to

AND CASE

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

"time" <= $11

ELSE true

END

-- Filter by build_reason

AND CASE

WHEN $12::text != '' THEN

workspace_builds.reason::text = $12

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"`

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

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 pq.StringArray `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.UserID,

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,

&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 getDBCryptKeys = `-- name: GetDBCryptKeys :many

SELECT number, active_key_digest, revoked_key_digest, created_at, revoked_at, test FROM dbcrypt_keys ORDER BY number ASC

`

func (q *sqlQuerier) GetDBCryptKeys(ctx context.Context) ([]DBCryptKey, error) {

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

if err != nil {

return nil, err

}

defer rows.Close()

var items []DBCryptKey

for rows.Next() {

var i DBCryptKey

if err := rows.Scan(

&i.Number,

&i.ActiveKeyDigest,

&i.RevokedKeyDigest,

&i.CreatedAt,

&i.RevokedAt,

&i.Test,

); 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 insertDBCryptKey = `-- name: InsertDBCryptKey :exec

INSERT INTO dbcrypt_keys

(number, active_key_digest, created_at, test)

VALUES ($1::int, $2::text, CURRENT_TIMESTAMP, $3::text)

`

type InsertDBCryptKeyParams struct {

Number int32 `db:"number" json:"number"`

ActiveKeyDigest string `db:"active_key_digest" json:"active_key_digest"`

Test string `db:"test" json:"test"`

}

func (q *sqlQuerier) InsertDBCryptKey(ctx context.Context, arg InsertDBCryptKeyParams) error {

_, err := q.db.ExecContext(ctx, insertDBCryptKey, arg.Number, arg.ActiveKeyDigest, arg.Test)

return err

}

const revokeDBCryptKey = `-- name: RevokeDBCryptKey :exec

UPDATE dbcrypt_keys

SET

revoked_key_digest = active_key_digest,

active_key_digest = revoked_key_digest,

revoked_at = CURRENT_TIMESTAMP

WHERE

active_key_digest = $1::text

AND

revoked_key_digest IS NULL

`

func (q *sqlQuerier) RevokeDBCryptKey(ctx context.Context, activeKeyDigest string) error {

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

return err

}

const getExternalAuthLink = `-- name: GetExternalAuthLink :one

SELECT provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry, oauth_access_token_key_id, oauth_refresh_token_key_id, oauth_extra FROM external_auth_links WHERE provider_id = $1 AND user_id = $2

`

type GetExternalAuthLinkParams struct {

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

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

}

func (q *sqlQuerier) GetExternalAuthLink(ctx context.Context, arg GetExternalAuthLinkParams) (ExternalAuthLink, error) {

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

var i ExternalAuthLink

err := row.Scan(

&i.ProviderID,

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.OAuthAccessToken,

&i.OAuthRefreshToken,

&i.OAuthExpiry,

&i.OAuthAccessTokenKeyID,

&i.OAuthRefreshTokenKeyID,

&i.OAuthExtra,

)

return i, err

}

const getExternalAuthLinksByUserID = `-- name: GetExternalAuthLinksByUserID :many

SELECT provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry, oauth_access_token_key_id, oauth_refresh_token_key_id, oauth_extra FROM external_auth_links WHERE user_id = $1

`

func (q *sqlQuerier) GetExternalAuthLinksByUserID(ctx context.Context, userID uuid.UUID) ([]ExternalAuthLink, error) {

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

if err != nil {

return nil, err

}

defer rows.Close()

var items []ExternalAuthLink

for rows.Next() {

var i ExternalAuthLink

if err := rows.Scan(

&i.ProviderID,

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.OAuthAccessToken,

&i.OAuthRefreshToken,

&i.OAuthExpiry,

&i.OAuthAccessTokenKeyID,

&i.OAuthRefreshTokenKeyID,

&i.OAuthExtra,

); 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 insertExternalAuthLink = `-- name: InsertExternalAuthLink :one

INSERT INTO external_auth_links (

provider_id,

user_id,

created_at,

updated_at,

oauth_access_token,

oauth_access_token_key_id,

oauth_refresh_token,

oauth_refresh_token_key_id,

oauth_expiry,

oauth_extra

) VALUES (

$1,

$2,

$3,

$4,

$5,

$6,

$7,

$8,

$9,

$10

) RETURNING provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry, oauth_access_token_key_id, oauth_refresh_token_key_id, oauth_extra

`

type InsertExternalAuthLinkParams 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"`

OAuthAccessTokenKeyID sql.NullString `db:"oauth_access_token_key_id" json:"oauth_access_token_key_id"`

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

OAuthRefreshTokenKeyID sql.NullString `db:"oauth_refresh_token_key_id" json:"oauth_refresh_token_key_id"`

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

OAuthExtra pqtype.NullRawMessage `db:"oauth_extra" json:"oauth_extra"`

}

func (q *sqlQuerier) InsertExternalAuthLink(ctx context.Context, arg InsertExternalAuthLinkParams) (ExternalAuthLink, error) {

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

arg.ProviderID,

arg.UserID,

arg.CreatedAt,

arg.UpdatedAt,

arg.OAuthAccessToken,

arg.OAuthAccessTokenKeyID,

arg.OAuthRefreshToken,

arg.OAuthRefreshTokenKeyID,

arg.OAuthExpiry,

arg.OAuthExtra,

)

var i ExternalAuthLink

err := row.Scan(

&i.ProviderID,

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.OAuthAccessToken,

&i.OAuthRefreshToken,

&i.OAuthExpiry,

&i.OAuthAccessTokenKeyID,

&i.OAuthRefreshTokenKeyID,

&i.OAuthExtra,

)

return i, err

}

const updateExternalAuthLink = `-- name: UpdateExternalAuthLink :one

UPDATE external_auth_links SET

updated_at = $3,

oauth_access_token = $4,

oauth_access_token_key_id = $5,

oauth_refresh_token = $6,

oauth_refresh_token_key_id = $7,

oauth_expiry = $8,

oauth_extra = $9

WHERE provider_id = $1 AND user_id = $2 RETURNING provider_id, user_id, created_at, updated_at, oauth_access_token, oauth_refresh_token, oauth_expiry, oauth_access_token_key_id, oauth_refresh_token_key_id, oauth_extra

`

type UpdateExternalAuthLinkParams 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"`

OAuthAccessTokenKeyID sql.NullString `db:"oauth_access_token_key_id" json:"oauth_access_token_key_id"`

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

OAuthRefreshTokenKeyID sql.NullString `db:"oauth_refresh_token_key_id" json:"oauth_refresh_token_key_id"`

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

OAuthExtra pqtype.NullRawMessage `db:"oauth_extra" json:"oauth_extra"`

}

func (q *sqlQuerier) UpdateExternalAuthLink(ctx context.Context, arg UpdateExternalAuthLinkParams) (ExternalAuthLink, error) {

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

arg.ProviderID,

arg.UserID,

arg.UpdatedAt,

arg.OAuthAccessToken,

arg.OAuthAccessTokenKeyID,

arg.OAuthRefreshToken,

arg.OAuthRefreshTokenKeyID,

arg.OAuthExpiry,

arg.OAuthExtra,

)

var i ExternalAuthLink

err := row.Scan(

&i.ProviderID,

&i.UserID,

&i.CreatedAt,

&i.UpdatedAt,

&i.OAuthAccessToken,

&i.OAuthRefreshToken,

&i.OAuthExpiry,

&i.OAuthAccessTokenKeyID,

&i.OAuthRefreshTokenKeyID,

&i.OAuthExtra,

)

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,