Containr/app/backend/internal/database/sqlcdb/apwhy.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: apwhy.sql

package sqlcdb

import (
	"context"
	"database/sql"

	"github.com/google/uuid"
)

const countAPKeys = `-- name: CountAPKeys :one
SELECT COUNT(*) FROM api_keys
`

func (q *Queries) CountAPKeys(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, countAPKeys)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const countAPServices = `-- name: CountAPServices :one
SELECT COUNT(*) FROM api_services
`

func (q *Queries) CountAPServices(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, countAPServices)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const getAPServiceBySlug = `-- name: GetAPServiceBySlug :one
SELECT id, upstream_url, route_prefix, upstream_auth_header,
       upstream_auth_value, enabled, rpm_limit, monthly_quota,
       request_timeout_ms
FROM api_services WHERE slug = $1
`

type GetAPServiceBySlugRow struct {
	ID                 uuid.UUID      `json:"id"`
	UpstreamUrl        string         `json:"upstream_url"`
	RoutePrefix        string         `json:"route_prefix"`
	UpstreamAuthHeader sql.NullString `json:"upstream_auth_header"`
	UpstreamAuthValue  sql.NullString `json:"upstream_auth_value"`
	Enabled            int32          `json:"enabled"`
	RpmLimit           sql.NullInt32  `json:"rpm_limit"`
	MonthlyQuota       sql.NullInt32  `json:"monthly_quota"`
	RequestTimeoutMs   sql.NullInt32  `json:"request_timeout_ms"`
}

func (q *Queries) GetAPServiceBySlug(ctx context.Context, slug string) (GetAPServiceBySlugRow, error) {
	row := q.db.QueryRowContext(ctx, getAPServiceBySlug, slug)
	var i GetAPServiceBySlugRow
	err := row.Scan(
		&i.ID,
		&i.UpstreamUrl,
		&i.RoutePrefix,
		&i.UpstreamAuthHeader,
		&i.UpstreamAuthValue,
		&i.Enabled,
		&i.RpmLimit,
		&i.MonthlyQuota,
		&i.RequestTimeoutMs,
	)
	return i, err
}

const getAPServiceForValidate = `-- name: GetAPServiceForValidate :one
SELECT upstream_url, health_path, upstream_auth_header, upstream_auth_value, request_timeout_ms
FROM api_services WHERE id = $1
`

type GetAPServiceForValidateRow struct {
	UpstreamUrl        string         `json:"upstream_url"`
	HealthPath         string         `json:"health_path"`
	UpstreamAuthHeader sql.NullString `json:"upstream_auth_header"`
	UpstreamAuthValue  sql.NullString `json:"upstream_auth_value"`
	RequestTimeoutMs   sql.NullInt32  `json:"request_timeout_ms"`
}

func (q *Queries) GetAPServiceForValidate(ctx context.Context, id uuid.UUID) (GetAPServiceForValidateRow, error) {
	row := q.db.QueryRowContext(ctx, getAPServiceForValidate, id)
	var i GetAPServiceForValidateRow
	err := row.Scan(
		&i.UpstreamUrl,
		&i.HealthPath,
		&i.UpstreamAuthHeader,
		&i.UpstreamAuthValue,
		&i.RequestTimeoutMs,
	)
	return i, err
}

const insertAPKey = `-- name: InsertAPKey :one
INSERT INTO api_keys (
    name, key_hash, key_prefix, plan, allowed_service_ids,
    rpm_limit, monthly_quota, created_at, updated_at
) VALUES ($1, $2, $3, $4, '[]', $5, $6, NOW(), NOW())
RETURNING id
`

type InsertAPKeyParams struct {
	Name         string        `json:"name"`
	KeyHash      string        `json:"key_hash"`
	KeyPrefix    string        `json:"key_prefix"`
	Plan         string        `json:"plan"`
	RpmLimit     sql.NullInt32 `json:"rpm_limit"`
	MonthlyQuota sql.NullInt32 `json:"monthly_quota"`
}

func (q *Queries) InsertAPKey(ctx context.Context, arg InsertAPKeyParams) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, insertAPKey,
		arg.Name,
		arg.KeyHash,
		arg.KeyPrefix,
		arg.Plan,
		arg.RpmLimit,
		arg.MonthlyQuota,
	)
	var id uuid.UUID
	err := row.Scan(&id)
	return id, err
}

const insertAPService = `-- name: InsertAPService :one
INSERT INTO api_services (
    name, slug, upstream_url, route_prefix, health_path,
    rpm_limit, monthly_quota, created_at, updated_at
) VALUES ($1, $2, $3, $4, '/health', $5, $6, NOW(), NOW())
RETURNING id
`

type InsertAPServiceParams struct {
	Name         string        `json:"name"`
	Slug         string        `json:"slug"`
	UpstreamUrl  string        `json:"upstream_url"`
	RoutePrefix  string        `json:"route_prefix"`
	RpmLimit     sql.NullInt32 `json:"rpm_limit"`
	MonthlyQuota sql.NullInt32 `json:"monthly_quota"`
}

func (q *Queries) InsertAPService(ctx context.Context, arg InsertAPServiceParams) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, insertAPService,
		arg.Name,
		arg.Slug,
		arg.UpstreamUrl,
		arg.RoutePrefix,
		arg.RpmLimit,
		arg.MonthlyQuota,
	)
	var id uuid.UUID
	err := row.Scan(&id)
	return id, err
}

const insertGatewayIncident = `-- name: InsertGatewayIncident :exec
INSERT INTO incident_events (service_id, api_key_id, code, message, severity, http_status, occurred_at)
VALUES ($1, $2, $3, $4, $5, $6, NOW())
`

type InsertGatewayIncidentParams struct {
	ServiceID  uuid.NullUUID `json:"service_id"`
	ApiKeyID   uuid.NullUUID `json:"api_key_id"`
	Code       string        `json:"code"`
	Message    string        `json:"message"`
	Severity   string        `json:"severity"`
	HttpStatus sql.NullInt32 `json:"http_status"`
}

func (q *Queries) InsertGatewayIncident(ctx context.Context, arg InsertGatewayIncidentParams) error {
	_, err := q.db.ExecContext(ctx, insertGatewayIncident,
		arg.ServiceID,
		arg.ApiKeyID,
		arg.Code,
		arg.Message,
		arg.Severity,
		arg.HttpStatus,
	)
	return err
}

const insertMetricPoint = `-- name: InsertMetricPoint :exec
INSERT INTO metrics_timeseries (metric, value, labels_json, occurred_at)
VALUES ('gateway_request', 1, $1, NOW())
`

func (q *Queries) InsertMetricPoint(ctx context.Context, labelsJson sql.NullString) error {
	_, err := q.db.ExecContext(ctx, insertMetricPoint, labelsJson)
	return err
}

const insertServiceIncident = `-- name: InsertServiceIncident :exec
INSERT INTO incident_events (service_id, code, message, severity, http_status, occurred_at)
VALUES ($1, 'SERVICE_VALIDATION_FAILED', $2, 'medium', $3, NOW())
`

type InsertServiceIncidentParams struct {
	ServiceID  uuid.NullUUID `json:"service_id"`
	Message    string        `json:"message"`
	HttpStatus sql.NullInt32 `json:"http_status"`
}

func (q *Queries) InsertServiceIncident(ctx context.Context, arg InsertServiceIncidentParams) error {
	_, err := q.db.ExecContext(ctx, insertServiceIncident, arg.ServiceID, arg.Message, arg.HttpStatus)
	return err
}

const listAPKeys = `-- name: ListAPKeys :many
SELECT id, name, key_prefix, plan, enabled, rpm_limit, monthly_quota,
       to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS"Z"') AS created_at,
       to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS"Z"') AS updated_at
FROM api_keys
ORDER BY created_at DESC
`

type ListAPKeysRow struct {
	ID           uuid.UUID     `json:"id"`
	Name         string        `json:"name"`
	KeyPrefix    string        `json:"key_prefix"`
	Plan         string        `json:"plan"`
	Enabled      int32         `json:"enabled"`
	RpmLimit     sql.NullInt32 `json:"rpm_limit"`
	MonthlyQuota sql.NullInt32 `json:"monthly_quota"`
	CreatedAt    string        `json:"created_at"`
	UpdatedAt    string        `json:"updated_at"`
}

func (q *Queries) ListAPKeys(ctx context.Context) ([]ListAPKeysRow, error) {
	rows, err := q.db.QueryContext(ctx, listAPKeys)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListAPKeysRow{}
	for rows.Next() {
		var i ListAPKeysRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.KeyPrefix,
			&i.Plan,
			&i.Enabled,
			&i.RpmLimit,
			&i.MonthlyQuota,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 listAPKeysByPrefix = `-- name: ListAPKeysByPrefix :many
SELECT id, key_hash, enabled, rpm_limit, monthly_quota, allowed_service_ids
FROM api_keys WHERE key_prefix = $1
`

type ListAPKeysByPrefixRow struct {
	ID                uuid.UUID     `json:"id"`
	KeyHash           string        `json:"key_hash"`
	Enabled           int32         `json:"enabled"`
	RpmLimit          sql.NullInt32 `json:"rpm_limit"`
	MonthlyQuota      sql.NullInt32 `json:"monthly_quota"`
	AllowedServiceIds string        `json:"allowed_service_ids"`
}

func (q *Queries) ListAPKeysByPrefix(ctx context.Context, keyPrefix string) ([]ListAPKeysByPrefixRow, error) {
	rows, err := q.db.QueryContext(ctx, listAPKeysByPrefix, keyPrefix)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListAPKeysByPrefixRow{}
	for rows.Next() {
		var i ListAPKeysByPrefixRow
		if err := rows.Scan(
			&i.ID,
			&i.KeyHash,
			&i.Enabled,
			&i.RpmLimit,
			&i.MonthlyQuota,
			&i.AllowedServiceIds,
		); 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 listAPServices = `-- name: ListAPServices :many
SELECT id, name, slug, upstream_url, route_prefix, enabled,
       to_char(created_at, 'YYYY-MM-DD"T"HH24:MI:SS"Z"') AS created_at,
       to_char(updated_at, 'YYYY-MM-DD"T"HH24:MI:SS"Z"') AS updated_at
FROM api_services
ORDER BY created_at DESC
`

type ListAPServicesRow struct {
	ID          uuid.UUID `json:"id"`
	Name        string    `json:"name"`
	Slug        string    `json:"slug"`
	UpstreamUrl string    `json:"upstream_url"`
	RoutePrefix string    `json:"route_prefix"`
	Enabled     int32     `json:"enabled"`
	CreatedAt   string    `json:"created_at"`
	UpdatedAt   string    `json:"updated_at"`
}

func (q *Queries) ListAPServices(ctx context.Context) ([]ListAPServicesRow, error) {
	rows, err := q.db.QueryContext(ctx, listAPServices)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListAPServicesRow{}
	for rows.Next() {
		var i ListAPServicesRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.Slug,
			&i.UpstreamUrl,
			&i.RoutePrefix,
			&i.Enabled,
			&i.CreatedAt,
			&i.UpdatedAt,
		); 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 listClientEventPaths = `-- name: ListClientEventPaths :many
SELECT COALESCE((labels_json::jsonb ->> 'path'), 'unknown') AS path, COUNT(*) AS total
FROM metrics_timeseries
WHERE metric = 'client_event' AND occurred_at >= NOW() - INTERVAL '7 days'
GROUP BY COALESCE((labels_json::jsonb ->> 'path'), 'unknown')
ORDER BY total DESC, path ASC
LIMIT 20
`

type ListClientEventPathsRow struct {
	Path  interface{} `json:"path"`
	Total int64       `json:"total"`
}

func (q *Queries) ListClientEventPaths(ctx context.Context) ([]ListClientEventPathsRow, error) {
	rows, err := q.db.QueryContext(ctx, listClientEventPaths)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListClientEventPathsRow{}
	for rows.Next() {
		var i ListClientEventPathsRow
		if err := rows.Scan(&i.Path, &i.Total); 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 listIncidentStatusCodes = `-- name: ListIncidentStatusCodes :many
SELECT COALESCE(http_status, 0) AS status_code, COALESCE(SUM(count), 0) AS total
FROM incident_events
WHERE occurred_at >= NOW() - INTERVAL '7 days'
GROUP BY COALESCE(http_status, 0)
ORDER BY total DESC, status_code ASC
`

type ListIncidentStatusCodesRow struct {
	StatusCode int32       `json:"status_code"`
	Total      interface{} `json:"total"`
}

func (q *Queries) ListIncidentStatusCodes(ctx context.Context) ([]ListIncidentStatusCodesRow, error) {
	rows, err := q.db.QueryContext(ctx, listIncidentStatusCodes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListIncidentStatusCodesRow{}
	for rows.Next() {
		var i ListIncidentStatusCodesRow
		if err := rows.Scan(&i.StatusCode, &i.Total); 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 listRequestsByDay = `-- name: ListRequestsByDay :many
SELECT TO_CHAR(DATE_TRUNC('day', occurred_at), 'YYYY-MM-DD') AS day_bucket, COUNT(*) AS total
FROM metrics_timeseries
WHERE metric = 'request_total' AND occurred_at >= NOW() - INTERVAL '7 days'
GROUP BY DATE_TRUNC('day', occurred_at)
ORDER BY DATE_TRUNC('day', occurred_at) ASC
`

type ListRequestsByDayRow struct {
	DayBucket string `json:"day_bucket"`
	Total     int64  `json:"total"`
}

func (q *Queries) ListRequestsByDay(ctx context.Context) ([]ListRequestsByDayRow, error) {
	rows, err := q.db.QueryContext(ctx, listRequestsByDay)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListRequestsByDayRow{}
	for rows.Next() {
		var i ListRequestsByDayRow
		if err := rows.Scan(&i.DayBucket, &i.Total); 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 listTopAPServices = `-- name: ListTopAPServices :many
SELECT s.id, s.name, COALESCE(SUM(u.request_count), 0) AS total_requests
FROM api_services s
LEFT JOIN usage_counters u ON u.service_id = s.id
GROUP BY s.id, s.name
ORDER BY total_requests DESC, s.name ASC
LIMIT 10
`

type ListTopAPServicesRow struct {
	ID            uuid.UUID   `json:"id"`
	Name          string      `json:"name"`
	TotalRequests interface{} `json:"total_requests"`
}

func (q *Queries) ListTopAPServices(ctx context.Context) ([]ListTopAPServicesRow, error) {
	rows, err := q.db.QueryContext(ctx, listTopAPServices)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListTopAPServicesRow{}
	for rows.Next() {
		var i ListTopAPServicesRow
		if err := rows.Scan(&i.ID, &i.Name, &i.TotalRequests); 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 setAPKeyEnabled = `-- name: SetAPKeyEnabled :exec
UPDATE api_keys SET enabled = $1, updated_at = NOW() WHERE id = $2
`

type SetAPKeyEnabledParams struct {
	Enabled int32     `json:"enabled"`
	ID      uuid.UUID `json:"id"`
}

func (q *Queries) SetAPKeyEnabled(ctx context.Context, arg SetAPKeyEnabledParams) error {
	_, err := q.db.ExecContext(ctx, setAPKeyEnabled, arg.Enabled, arg.ID)
	return err
}

const setAPServiceEnabled = `-- name: SetAPServiceEnabled :exec
UPDATE api_services SET enabled = $1, updated_at = NOW() WHERE id = $2
`

type SetAPServiceEnabledParams struct {
	Enabled int32     `json:"enabled"`
	ID      uuid.UUID `json:"id"`
}

func (q *Queries) SetAPServiceEnabled(ctx context.Context, arg SetAPServiceEnabledParams) error {
	_, err := q.db.ExecContext(ctx, setAPServiceEnabled, arg.Enabled, arg.ID)
	return err
}

const setAPServiceValidation = `-- name: SetAPServiceValidation :exec
UPDATE api_services
SET last_validation_at = NOW(), last_validation_status = $1, last_validation_message = $2, updated_at = NOW()
WHERE id = $3
`

type SetAPServiceValidationParams struct {
	LastValidationStatus  sql.NullString `json:"last_validation_status"`
	LastValidationMessage sql.NullString `json:"last_validation_message"`
	ID                    uuid.UUID      `json:"id"`
}

func (q *Queries) SetAPServiceValidation(ctx context.Context, arg SetAPServiceValidationParams) error {
	_, err := q.db.ExecContext(ctx, setAPServiceValidation, arg.LastValidationStatus, arg.LastValidationMessage, arg.ID)
	return err
}

const sumRequestMetricSince = `-- name: SumRequestMetricSince :one
SELECT COALESCE(SUM(value), 0)::int
FROM metrics_timeseries
WHERE metric = 'request_total' AND occurred_at >= DATE_TRUNC($1::text, NOW())
`

func (q *Queries) SumRequestMetricSince(ctx context.Context, dollar_1 string) (int32, error) {
	row := q.db.QueryRowContext(ctx, sumRequestMetricSince, dollar_1)
	var column_1 int32
	err := row.Scan(&column_1)
	return column_1, err
}

const sumUsageByKey = `-- name: SumUsageByKey :one
SELECT COALESCE(SUM(request_count), 0)::bigint FROM usage_counters
WHERE api_key_id = $1 AND period_month = $2
`

type SumUsageByKeyParams struct {
	ApiKeyID    uuid.UUID `json:"api_key_id"`
	PeriodMonth string    `json:"period_month"`
}

func (q *Queries) SumUsageByKey(ctx context.Context, arg SumUsageByKeyParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, sumUsageByKey, arg.ApiKeyID, arg.PeriodMonth)
	var column_1 int64
	err := row.Scan(&column_1)
	return column_1, err
}

const sumUsageByService = `-- name: SumUsageByService :one
SELECT COALESCE(SUM(request_count), 0)::bigint FROM usage_counters
WHERE service_id = $1 AND period_month = $2
`

type SumUsageByServiceParams struct {
	ServiceID   uuid.UUID `json:"service_id"`
	PeriodMonth string    `json:"period_month"`
}

func (q *Queries) SumUsageByService(ctx context.Context, arg SumUsageByServiceParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, sumUsageByService, arg.ServiceID, arg.PeriodMonth)
	var column_1 int64
	err := row.Scan(&column_1)
	return column_1, err
}

const sumUsageCounters = `-- name: SumUsageCounters :one
SELECT COALESCE(SUM(request_count), 0) FROM usage_counters
`

func (q *Queries) SumUsageCounters(ctx context.Context) (interface{}, error) {
	row := q.db.QueryRowContext(ctx, sumUsageCounters)
	var coalesce interface{}
	err := row.Scan(&coalesce)
	return coalesce, err
}

const touchAPKeyLastUsed = `-- name: TouchAPKeyLastUsed :exec
UPDATE api_keys SET last_used_at = NOW() WHERE id = $1
`

func (q *Queries) TouchAPKeyLastUsed(ctx context.Context, id uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, touchAPKeyLastUsed, id)
	return err
}

const upsertUsageCounter = `-- name: UpsertUsageCounter :exec
INSERT INTO usage_counters (api_key_id, service_id, period_month, request_count, updated_at)
VALUES ($1, $2, $3, 1, NOW())
ON CONFLICT (api_key_id, service_id, period_month)
DO UPDATE SET request_count = usage_counters.request_count + 1, updated_at = NOW()
`

type UpsertUsageCounterParams struct {
	ApiKeyID    uuid.UUID `json:"api_key_id"`
	ServiceID   uuid.UUID `json:"service_id"`
	PeriodMonth string    `json:"period_month"`
}

func (q *Queries) UpsertUsageCounter(ctx context.Context, arg UpsertUsageCounterParams) error {
	_, err := q.db.ExecContext(ctx, upsertUsageCounter, arg.ApiKeyID, arg.ServiceID, arg.PeriodMonth)
	return err
}