agentic-coding-workflow/internal/acp/sqlc/permissions.sql.go

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

package acpsqlc

import (
	"context"

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

const decidePermissionRequest = `-- name: DecidePermissionRequest :one
UPDATE acp_permission_requests
SET status = $2, chosen_option_id = $3, decided_by = $4, decided_at = now()
WHERE id = $1 AND status = 'pending'
RETURNING id, session_id, agent_request_id, tool_name, tool_call, options, status,
          chosen_option_id, decided_by, decided_at, created_at
`

type DecidePermissionRequestParams struct {
	ID             pgtype.UUID `json:"id"`
	Status         string      `json:"status"`
	ChosenOptionID *string     `json:"chosen_option_id"`
	DecidedBy      pgtype.UUID `json:"decided_by"`
}

func (q *Queries) DecidePermissionRequest(ctx context.Context, arg DecidePermissionRequestParams) (AcpPermissionRequest, error) {
	row := q.db.QueryRow(ctx, decidePermissionRequest,
		arg.ID,
		arg.Status,
		arg.ChosenOptionID,
		arg.DecidedBy,
	)
	var i AcpPermissionRequest
	err := row.Scan(
		&i.ID,
		&i.SessionID,
		&i.AgentRequestID,
		&i.ToolName,
		&i.ToolCall,
		&i.Options,
		&i.Status,
		&i.ChosenOptionID,
		&i.DecidedBy,
		&i.DecidedAt,
		&i.CreatedAt,
	)
	return i, err
}

const expirePendingPermissionRequestsBySession = `-- name: ExpirePendingPermissionRequestsBySession :execrows
UPDATE acp_permission_requests
SET status = 'expired', decided_at = now()
WHERE session_id = $1 AND status = 'pending'
`

func (q *Queries) ExpirePendingPermissionRequestsBySession(ctx context.Context, sessionID pgtype.UUID) (int64, error) {
	result, err := q.db.Exec(ctx, expirePendingPermissionRequestsBySession, sessionID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const expireStalePermissionRequests = `-- name: ExpireStalePermissionRequests :execrows
UPDATE acp_permission_requests
SET status = 'expired', decided_at = now()
WHERE status = 'pending' AND created_at < $1
`

func (q *Queries) ExpireStalePermissionRequests(ctx context.Context, createdAt pgtype.Timestamptz) (int64, error) {
	result, err := q.db.Exec(ctx, expireStalePermissionRequests, createdAt)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected(), nil
}

const getPermissionRequestByID = `-- name: GetPermissionRequestByID :one
SELECT id, session_id, agent_request_id, tool_name, tool_call, options, status,
       chosen_option_id, decided_by, decided_at, created_at
FROM acp_permission_requests
WHERE id = $1
`

func (q *Queries) GetPermissionRequestByID(ctx context.Context, id pgtype.UUID) (AcpPermissionRequest, error) {
	row := q.db.QueryRow(ctx, getPermissionRequestByID, id)
	var i AcpPermissionRequest
	err := row.Scan(
		&i.ID,
		&i.SessionID,
		&i.AgentRequestID,
		&i.ToolName,
		&i.ToolCall,
		&i.Options,
		&i.Status,
		&i.ChosenOptionID,
		&i.DecidedBy,
		&i.DecidedAt,
		&i.CreatedAt,
	)
	return i, err
}

const insertPermissionRequest = `-- name: InsertPermissionRequest :one
INSERT INTO acp_permission_requests (
  id, session_id, agent_request_id, tool_name, tool_call, options, status, chosen_option_id, decided_by, decided_at
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
RETURNING id, session_id, agent_request_id, tool_name, tool_call, options, status,
          chosen_option_id, decided_by, decided_at, created_at
`

type InsertPermissionRequestParams struct {
	ID             pgtype.UUID        `json:"id"`
	SessionID      pgtype.UUID        `json:"session_id"`
	AgentRequestID string             `json:"agent_request_id"`
	ToolName       string             `json:"tool_name"`
	ToolCall       []byte             `json:"tool_call"`
	Options        []byte             `json:"options"`
	Status         string             `json:"status"`
	ChosenOptionID *string            `json:"chosen_option_id"`
	DecidedBy      pgtype.UUID        `json:"decided_by"`
	DecidedAt      pgtype.Timestamptz `json:"decided_at"`
}

func (q *Queries) InsertPermissionRequest(ctx context.Context, arg InsertPermissionRequestParams) (AcpPermissionRequest, error) {
	row := q.db.QueryRow(ctx, insertPermissionRequest,
		arg.ID,
		arg.SessionID,
		arg.AgentRequestID,
		arg.ToolName,
		arg.ToolCall,
		arg.Options,
		arg.Status,
		arg.ChosenOptionID,
		arg.DecidedBy,
		arg.DecidedAt,
	)
	var i AcpPermissionRequest
	err := row.Scan(
		&i.ID,
		&i.SessionID,
		&i.AgentRequestID,
		&i.ToolName,
		&i.ToolCall,
		&i.Options,
		&i.Status,
		&i.ChosenOptionID,
		&i.DecidedBy,
		&i.DecidedAt,
		&i.CreatedAt,
	)
	return i, err
}

const listPendingPermissionRequestsBySession = `-- name: ListPendingPermissionRequestsBySession :many
SELECT id, session_id, agent_request_id, tool_name, tool_call, options, status,
       chosen_option_id, decided_by, decided_at, created_at
FROM acp_permission_requests
WHERE session_id = $1 AND status = 'pending'
ORDER BY created_at ASC
`

func (q *Queries) ListPendingPermissionRequestsBySession(ctx context.Context, sessionID pgtype.UUID) ([]AcpPermissionRequest, error) {
	rows, err := q.db.Query(ctx, listPendingPermissionRequestsBySession, sessionID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AcpPermissionRequest
	for rows.Next() {
		var i AcpPermissionRequest
		if err := rows.Scan(
			&i.ID,
			&i.SessionID,
			&i.AgentRequestID,
			&i.ToolName,
			&i.ToolCall,
			&i.Options,
			&i.Status,
			&i.ChosenOptionID,
			&i.DecidedBy,
			&i.DecidedAt,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listPendingPermissionRequestsByUser = `-- name: ListPendingPermissionRequestsByUser :many
SELECT p.id, p.session_id, p.agent_request_id, p.tool_name, p.tool_call, p.options, p.status,
       p.chosen_option_id, p.decided_by, p.decided_at, p.created_at
FROM acp_permission_requests p
JOIN acp_sessions s ON s.id = p.session_id
WHERE s.user_id = $1 AND p.status = 'pending'
ORDER BY p.created_at ASC
`

func (q *Queries) ListPendingPermissionRequestsByUser(ctx context.Context, userID pgtype.UUID) ([]AcpPermissionRequest, error) {
	rows, err := q.db.Query(ctx, listPendingPermissionRequestsByUser, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []AcpPermissionRequest
	for rows.Next() {
		var i AcpPermissionRequest
		if err := rows.Scan(
			&i.ID,
			&i.SessionID,
			&i.AgentRequestID,
			&i.ToolName,
			&i.ToolCall,
			&i.Options,
			&i.Status,
			&i.ChosenOptionID,
			&i.DecidedBy,
			&i.DecidedAt,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}