// Code generated by sqlc. DO NOT EDIT.

// versions:

// sqlc v1.25.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,

templates.activity_bump AS activity_bump,

(

CASE

-- If the extension would push us over the next_autostart

-- interval, then extend the deadline by the full TTL (NOT

-- activity bump) from the autostart time. This will essentially

-- be as if the workspace auto started at the given time and the

-- original TTL was applied.

--

-- Sadly we can't define ` + "`" + `activity_bump_interval` + "`" + ` above since

-- it won't be available for this CASE statement, so we have to

-- copy the cast twice.

WHEN NOW() + (templates.activity_bump / 1000 / 1000 / 1000 || ' seconds')::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 activity bump

(($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 the activity bump duration.

ELSE

(templates.activity_bump / 1000 / 1000 / 1000 || ' seconds')::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.activity_bump > 0

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 the template's configured "activity_bump"

// duration (default 1h). 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 the deadline will never be bumped past it.

// The deadline will never decrease.

// We only bump if the template has an activity bump duration set.

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

-- sqlc.embed(users) would be nice but it does not seem to play well with

-- left joins.

users.username AS user_username,

users.name AS user_name,

users.email AS user_email,

users.created_at AS user_created_at,

users.updated_at AS user_updated_at,

users.last_seen_at AS user_last_seen_at,

users.status AS user_status,

users.login_type AS user_login_type,

users.rbac_roles AS user_roles,

users.avatar_url AS user_avatar_url,

users.deleted AS user_deleted,

users.theme_preference AS user_theme_preference,

users.quiet_hours_schedule AS user_quiet_hours_schedule,

COALESCE(organizations.name, '') AS organization_name,

COALESCE(organizations.display_name, '') AS organization_display_name,

COALESCE(organizations.icon, '') AS organization_icon,

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

)

LEFT JOIN organizations ON audit_logs.organization_id = organizations.id

WHERE

-- Filter resource_type

CASE

WHEN $1 :: text != '' THEN

resource_type = $1 :: resource_type

ELSE true

END

-- Filter resource_id

AND CASE

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

resource_id = $2

ELSE true

END

-- Filter organization_id

AND CASE

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

audit_logs.organization_id = $3

ELSE true

END

-- Filter by resource_target

AND CASE

WHEN $4 :: text != '' THEN

resource_target = $4

ELSE true

END

-- Filter action

AND CASE

WHEN $5 :: text != '' THEN

action = $5 :: audit_action

ELSE true

END

-- Filter by user_id

AND CASE

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

user_id = $6

ELSE true

END

-- Filter by username

AND CASE

WHEN $7 :: text != '' THEN

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

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

-- Authorize Filter clause will be injected below in GetAuthorizedAuditLogsOffset

-- @authorize_filter

ORDER BY

"time" DESC

LIMIT

-- a limit of 0 means "no limit". The audit log table is unbounded

-- in size, and is expected to be quite large. Implement a default

-- limit of 100 to prevent accidental excessively large queries.

COALESCE(NULLIF($13 :: int, 0), 100)

OFFSET

$12

`

type GetAuditLogsOffsetParams struct {

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

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

OrganizationID uuid.UUID `db:"organization_id" json:"organization_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"`

OffsetOpt int32 `db:"offset_opt" json:"offset_opt"`

LimitOpt int32 `db:"limit_opt" json:"limit_opt"`

}

type GetAuditLogsOffsetRow struct {

AuditLog AuditLog `db:"audit_log" json:"audit_log"`

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

UserName sql.NullString `db:"user_name" json:"user_name"`

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

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

UserUpdatedAt sql.NullTime `db:"user_updated_at" json:"user_updated_at"`

UserLastSeenAt sql.NullTime `db:"user_last_seen_at" json:"user_last_seen_at"`

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

UserLoginType NullLoginType `db:"user_login_type" json:"user_login_type"`

UserRoles pq.StringArray `db:"user_roles" json:"user_roles"`

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

UserDeleted sql.NullBool `db:"user_deleted" json:"user_deleted"`

UserThemePreference sql.NullString `db:"user_theme_preference" json:"user_theme_preference"`

UserQuietHoursSchedule sql.NullString `db:"user_quiet_hours_schedule" json:"user_quiet_hours_schedule"`

OrganizationName string `db:"organization_name" json:"organization_name"`

OrganizationDisplayName string `db:"organization_display_name" json:"organization_display_name"`

OrganizationIcon string `db:"organization_icon" json:"organization_icon"`

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.ResourceType,

arg.ResourceID,

arg.OrganizationID,

arg.ResourceTarget,

arg.Action,

arg.UserID,

arg.Username,

arg.Email,

arg.DateFrom,

arg.DateTo,

arg.BuildReason,

arg.OffsetOpt,

arg.LimitOpt,

)

if err != nil {

return nil, err

}

defer rows.Close()

var items []GetAuditLogsOffsetRow

for rows.Next() {

var i GetAuditLogsOffsetRow

if err := rows.Scan(

&i.AuditLog.ID,

&i.AuditLog.Time,

&i.AuditLog.UserID,

&i.AuditLog.OrganizationID,

&i.AuditLog.Ip,

&i.AuditLog.UserAgent,

&i.AuditLog.ResourceType,

&i.AuditLog.ResourceID,

&i.AuditLog.ResourceTarget,

&i.AuditLog.Action,

&i.AuditLog.Diff,

&i.AuditLog.StatusCode,

&i.AuditLog.AdditionalFields,

&i.AuditLog.RequestID,

&i.AuditLog.ResourceIcon,

&i.UserUsername,

&i.UserName,

&i.UserEmail,

&i.UserCreatedAt,

&i.UserUpdatedAt,

&i.UserLastSeenAt,

&i.UserStatus,

&i.UserLoginType,

&i.UserRoles,

&i.UserAvatarUrl,

&i.UserDeleted,

&i.UserThemePreference,

&i.UserQuietHoursSchedule,

&i.OrganizationName,

&i.OrganizationDisplayName,

&i.OrganizationIcon,

&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 deleteCryptoKey = `-- name: DeleteCryptoKey :one

UPDATE crypto_keys

SET secret = NULL, secret_key_id = NULL

WHERE feature = $1 AND sequence = $2 RETURNING feature, sequence, secret, secret_key_id, starts_at, deletes_at

`

type DeleteCryptoKeyParams struct {

Feature CryptoKeyFeature `db:"feature" json:"feature"`

Sequence int32 `db:"sequence" json:"sequence"`

}

func (q *sqlQuerier) DeleteCryptoKey(ctx context.Context, arg DeleteCryptoKeyParams) (CryptoKey, error) {

row := q.db.QueryRowContext(ctx, deleteCryptoKey, arg.Feature, arg.Sequence)

var i CryptoKey

err := row.Scan(

&i.Feature,

&i.Sequence,

&i.Secret,

&i.SecretKeyID,

&i.StartsAt,

&i.DeletesAt,

)

return i, err

}

const getCryptoKeyByFeatureAndSequence = `-- name: GetCryptoKeyByFeatureAndSequence :one

SELECT feature, sequence, secret, secret_key_id, starts_at, deletes_at

FROM crypto_keys

WHERE feature = $1

AND sequence = $2

AND secret IS NOT NULL

`

type GetCryptoKeyByFeatureAndSequenceParams struct {

Feature CryptoKeyFeature `db:"feature" json:"feature"`

Sequence int32 `db:"sequence" json:"sequence"`

}

func (q *sqlQuerier) GetCryptoKeyByFeatureAndSequence(ctx context.Context, arg GetCryptoKeyByFeatureAndSequenceParams) (CryptoKey, error) {

row := q.db.QueryRowContext(ctx, getCryptoKeyByFeatureAndSequence, arg.Feature, arg.Sequence)

var i CryptoKey

err := row.Scan(

&i.Feature,

&i.Sequence,

&i.Secret,

&i.SecretKeyID,

&i.StartsAt,

&i.DeletesAt,

)

return i, err

}

const getCryptoKeys = `-- name: GetCryptoKeys :many

SELECT feature, sequence, secret, secret_key_id, starts_at, deletes_at

FROM crypto_keys

WHERE secret IS NOT NULL

`

func (q *sqlQuerier) GetCryptoKeys(ctx context.Context) ([]CryptoKey, error) {

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

if err != nil {

return nil, err

}

defer rows.Close()

var items []CryptoKey

for rows.Next() {

var i CryptoKey

if err := rows.Scan(

&i.Feature,

&i.Sequence,

&i.Secret,

&i.SecretKeyID,

&i.StartsAt,

&i.DeletesAt,

); 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 getCryptoKeysByFeature = `-- name: GetCryptoKeysByFeature :many

SELECT feature, sequence, secret, secret_key_id, starts_at, deletes_at

FROM crypto_keys

WHERE feature = $1

AND secret IS NOT NULL

ORDER BY sequence DESC

`

func (q *sqlQuerier) GetCryptoKeysByFeature(ctx context.Context, feature CryptoKeyFeature) ([]CryptoKey, error) {

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

if err != nil {

return nil, err

}

defer rows.Close()

var items []CryptoKey

for rows.Next() {

var i CryptoKey

if err := rows.Scan(

&i.Feature,

&i.Sequence,

&i.Secret,

&i.SecretKeyID,

&i.StartsAt,

&i.DeletesAt,

); 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 getLatestCryptoKeyByFeature = `-- name: GetLatestCryptoKeyByFeature :one

SELECT feature, sequence, secret, secret_key_id, starts_at, deletes_at

FROM crypto_keys

WHERE feature = $1

ORDER BY sequence DESC

LIMIT 1

`

func (q *sqlQuerier) GetLatestCryptoKeyByFeature(ctx context.Context, feature CryptoKeyFeature) (CryptoKey, error) {

row := q.db.QueryRowContext(ctx, getLatestCryptoKeyByFeature, feature)

var i CryptoKey

err := row.Scan(

&i.Feature,

&i.Sequence,

&i.Secret,

&i.SecretKeyID,

&i.StartsAt,

&i.DeletesAt,

)

return i, err

}

const insertCryptoKey = `-- name: InsertCryptoKey :one

INSERT INTO crypto_keys (

feature,

sequence,

secret,

starts_at,

secret_key_id

) VALUES (

$1,

$2,

$3,

$4,

$5

) RETURNING feature, sequence, secret, secret_key_id, starts_at, deletes_at

`

type InsertCryptoKeyParams struct {

Feature CryptoKeyFeature `db:"feature" json:"feature"`

Sequence int32 `db:"sequence" json:"sequence"`

Secret sql.NullString `db:"secret" json:"secret"`

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

SecretKeyID sql.NullString `db:"secret_key_id" json:"secret_key_id"`

}

func (q *sqlQuerier) InsertCryptoKey(ctx context.Context, arg InsertCryptoKeyParams) (CryptoKey, error) {

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

arg.Feature,

arg.Sequence,

arg.Secret,

arg.StartsAt,

arg.SecretKeyID,

)

var i CryptoKey

err := row.Scan(

&i.Feature,

&i.Sequence,

&i.Secret,

&i.SecretKeyID,

&i.StartsAt,

&i.DeletesAt,

)

return i, err

}

const updateCryptoKeyDeletesAt = `-- name: UpdateCryptoKeyDeletesAt :one

UPDATE crypto_keys

SET deletes_at = $3

WHERE feature = $1 AND sequence = $2 RETURNING feature, sequence, secret, secret_key_id, starts_at, deletes_at

`

type UpdateCryptoKeyDeletesAtParams struct {

Feature CryptoKeyFeature `db:"feature" json:"feature"`

Sequence int32 `db:"sequence" json:"sequence"`

DeletesAt sql.NullTime `db:"deletes_at" json:"deletes_at"`

}

func (q *sqlQuerier) UpdateCryptoKeyDeletesAt(ctx context.Context, arg UpdateCryptoKeyDeletesAtParams) (CryptoKey, error) {

row := q.db.QueryRowContext(ctx, updateCryptoKeyDeletesAt, arg.Feature, arg.Sequence, arg.DeletesAt)

var i CryptoKey

err := row.Scan(

&i.Feature,

&i.Sequence,

&i.Secret,

&i.SecretKeyID,

&i.StartsAt,

&i.DeletesAt,

)

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,