multica/server/pkg/db/generated/agent.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: agent.sql

package db

import (
	"context"

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

const createAgent = `-- name: CreateAgent :one
INSERT INTO agent (
    workspace_id, name, avatar_url, runtime_mode,
    runtime_config, visibility, max_concurrent_tasks, owner_id
) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
RETURNING id, workspace_id, name, avatar_url, runtime_mode, runtime_config, visibility, status, max_concurrent_tasks, owner_id, created_at, updated_at
`

type CreateAgentParams struct {
	WorkspaceID        pgtype.UUID `json:"workspace_id"`
	Name               string      `json:"name"`
	AvatarUrl          pgtype.Text `json:"avatar_url"`
	RuntimeMode        string      `json:"runtime_mode"`
	RuntimeConfig      []byte      `json:"runtime_config"`
	Visibility         string      `json:"visibility"`
	MaxConcurrentTasks int32       `json:"max_concurrent_tasks"`
	OwnerID            pgtype.UUID `json:"owner_id"`
}

func (q *Queries) CreateAgent(ctx context.Context, arg CreateAgentParams) (Agent, error) {
	row := q.db.QueryRow(ctx, createAgent,
		arg.WorkspaceID,
		arg.Name,
		arg.AvatarUrl,
		arg.RuntimeMode,
		arg.RuntimeConfig,
		arg.Visibility,
		arg.MaxConcurrentTasks,
		arg.OwnerID,
	)
	var i Agent
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Name,
		&i.AvatarUrl,
		&i.RuntimeMode,
		&i.RuntimeConfig,
		&i.Visibility,
		&i.Status,
		&i.MaxConcurrentTasks,
		&i.OwnerID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const deleteAgent = `-- name: DeleteAgent :exec
DELETE FROM agent WHERE id = $1
`

func (q *Queries) DeleteAgent(ctx context.Context, id pgtype.UUID) error {
	_, err := q.db.Exec(ctx, deleteAgent, id)
	return err
}

const getAgent = `-- name: GetAgent :one
SELECT id, workspace_id, name, avatar_url, runtime_mode, runtime_config, visibility, status, max_concurrent_tasks, owner_id, created_at, updated_at FROM agent
WHERE id = $1
`

func (q *Queries) GetAgent(ctx context.Context, id pgtype.UUID) (Agent, error) {
	row := q.db.QueryRow(ctx, getAgent, id)
	var i Agent
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Name,
		&i.AvatarUrl,
		&i.RuntimeMode,
		&i.RuntimeConfig,
		&i.Visibility,
		&i.Status,
		&i.MaxConcurrentTasks,
		&i.OwnerID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const listAgents = `-- name: ListAgents :many
SELECT id, workspace_id, name, avatar_url, runtime_mode, runtime_config, visibility, status, max_concurrent_tasks, owner_id, created_at, updated_at FROM agent
WHERE workspace_id = $1
ORDER BY created_at ASC
`

func (q *Queries) ListAgents(ctx context.Context, workspaceID pgtype.UUID) ([]Agent, error) {
	rows, err := q.db.Query(ctx, listAgents, workspaceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []Agent{}
	for rows.Next() {
		var i Agent
		if err := rows.Scan(
			&i.ID,
			&i.WorkspaceID,
			&i.Name,
			&i.AvatarUrl,
			&i.RuntimeMode,
			&i.RuntimeConfig,
			&i.Visibility,
			&i.Status,
			&i.MaxConcurrentTasks,
			&i.OwnerID,
			&i.CreatedAt,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const updateAgent = `-- name: UpdateAgent :one
UPDATE agent SET
    name = COALESCE($2, name),
    avatar_url = COALESCE($3, avatar_url),
    runtime_config = COALESCE($4, runtime_config),
    visibility = COALESCE($5, visibility),
    status = COALESCE($6, status),
    max_concurrent_tasks = COALESCE($7, max_concurrent_tasks),
    updated_at = now()
WHERE id = $1
RETURNING id, workspace_id, name, avatar_url, runtime_mode, runtime_config, visibility, status, max_concurrent_tasks, owner_id, created_at, updated_at
`

type UpdateAgentParams struct {
	ID                 pgtype.UUID `json:"id"`
	Name               pgtype.Text `json:"name"`
	AvatarUrl          pgtype.Text `json:"avatar_url"`
	RuntimeConfig      []byte      `json:"runtime_config"`
	Visibility         pgtype.Text `json:"visibility"`
	Status             pgtype.Text `json:"status"`
	MaxConcurrentTasks pgtype.Int4 `json:"max_concurrent_tasks"`
}

func (q *Queries) UpdateAgent(ctx context.Context, arg UpdateAgentParams) (Agent, error) {
	row := q.db.QueryRow(ctx, updateAgent,
		arg.ID,
		arg.Name,
		arg.AvatarUrl,
		arg.RuntimeConfig,
		arg.Visibility,
		arg.Status,
		arg.MaxConcurrentTasks,
	)
	var i Agent
	err := row.Scan(
		&i.ID,
		&i.WorkspaceID,
		&i.Name,
		&i.AvatarUrl,
		&i.RuntimeMode,
		&i.RuntimeConfig,
		&i.Visibility,
		&i.Status,
		&i.MaxConcurrentTasks,
		&i.OwnerID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}