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

package actionsdb

import (
	"context"

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

const deleteOrgSecret = `-- name: DeleteOrgSecret :exec
DELETE FROM workflow_secrets WHERE org_id = $1 AND name = $2
`

type DeleteOrgSecretParams struct {
	OrgID pgtype.Int8
	Name  string
}

func (q *Queries) DeleteOrgSecret(ctx context.Context, db DBTX, arg DeleteOrgSecretParams) error {
	_, err := db.Exec(ctx, deleteOrgSecret, arg.OrgID, arg.Name)
	return err
}

const deleteRepoSecret = `-- name: DeleteRepoSecret :exec
DELETE FROM workflow_secrets WHERE repo_id = $1 AND name = $2
`

type DeleteRepoSecretParams struct {
	RepoID pgtype.Int8
	Name   string
}

func (q *Queries) DeleteRepoSecret(ctx context.Context, db DBTX, arg DeleteRepoSecretParams) error {
	_, err := db.Exec(ctx, deleteRepoSecret, arg.RepoID, arg.Name)
	return err
}

const getOrgSecret = `-- name: GetOrgSecret :one
SELECT id, name, ciphertext, nonce
FROM workflow_secrets
WHERE org_id = $1 AND name = $2
`

type GetOrgSecretParams struct {
	OrgID pgtype.Int8
	Name  string
}

type GetOrgSecretRow struct {
	ID         int64
	Name       string
	Ciphertext []byte
	Nonce      []byte
}

func (q *Queries) GetOrgSecret(ctx context.Context, db DBTX, arg GetOrgSecretParams) (GetOrgSecretRow, error) {
	row := db.QueryRow(ctx, getOrgSecret, arg.OrgID, arg.Name)
	var i GetOrgSecretRow
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Ciphertext,
		&i.Nonce,
	)
	return i, err
}

const getRepoSecret = `-- name: GetRepoSecret :one
SELECT id, name, ciphertext, nonce
FROM workflow_secrets
WHERE repo_id = $1 AND name = $2
`

type GetRepoSecretParams struct {
	RepoID pgtype.Int8
	Name   string
}

type GetRepoSecretRow struct {
	ID         int64
	Name       string
	Ciphertext []byte
	Nonce      []byte
}

func (q *Queries) GetRepoSecret(ctx context.Context, db DBTX, arg GetRepoSecretParams) (GetRepoSecretRow, error) {
	row := db.QueryRow(ctx, getRepoSecret, arg.RepoID, arg.Name)
	var i GetRepoSecretRow
	err := row.Scan(
		&i.ID,
		&i.Name,
		&i.Ciphertext,
		&i.Nonce,
	)
	return i, err
}

const listOrgSecrets = `-- name: ListOrgSecrets :many
SELECT id, name, created_by_user_id, created_at, updated_at
FROM workflow_secrets
WHERE org_id = $1
ORDER BY name ASC
`

type ListOrgSecretsRow struct {
	ID              int64
	Name            string
	CreatedByUserID pgtype.Int8
	CreatedAt       pgtype.Timestamptz
	UpdatedAt       pgtype.Timestamptz
}

func (q *Queries) ListOrgSecrets(ctx context.Context, db DBTX, orgID pgtype.Int8) ([]ListOrgSecretsRow, error) {
	rows, err := db.Query(ctx, listOrgSecrets, orgID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListOrgSecretsRow{}
	for rows.Next() {
		var i ListOrgSecretsRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.CreatedByUserID,
			&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 listRepoSecrets = `-- name: ListRepoSecrets :many
SELECT id, name, created_by_user_id, created_at, updated_at
FROM workflow_secrets
WHERE repo_id = $1
ORDER BY name ASC
`

type ListRepoSecretsRow struct {
	ID              int64
	Name            string
	CreatedByUserID pgtype.Int8
	CreatedAt       pgtype.Timestamptz
	UpdatedAt       pgtype.Timestamptz
}

func (q *Queries) ListRepoSecrets(ctx context.Context, db DBTX, repoID pgtype.Int8) ([]ListRepoSecretsRow, error) {
	rows, err := db.Query(ctx, listRepoSecrets, repoID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListRepoSecretsRow{}
	for rows.Next() {
		var i ListRepoSecretsRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.CreatedByUserID,
			&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 upsertOrgSecret = `-- name: UpsertOrgSecret :one
INSERT INTO workflow_secrets (org_id, name, ciphertext, nonce, created_by_user_id)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (org_id, name) WHERE org_id IS NOT NULL DO UPDATE
SET ciphertext = EXCLUDED.ciphertext,
    nonce      = EXCLUDED.nonce,
    updated_at = now()
RETURNING id, repo_id, org_id, name, ciphertext, nonce,
          created_by_user_id, created_at, updated_at
`

type UpsertOrgSecretParams struct {
	OrgID           pgtype.Int8
	Name            string
	Ciphertext      []byte
	Nonce           []byte
	CreatedByUserID pgtype.Int8
}

func (q *Queries) UpsertOrgSecret(ctx context.Context, db DBTX, arg UpsertOrgSecretParams) (WorkflowSecret, error) {
	row := db.QueryRow(ctx, upsertOrgSecret,
		arg.OrgID,
		arg.Name,
		arg.Ciphertext,
		arg.Nonce,
		arg.CreatedByUserID,
	)
	var i WorkflowSecret
	err := row.Scan(
		&i.ID,
		&i.RepoID,
		&i.OrgID,
		&i.Name,
		&i.Ciphertext,
		&i.Nonce,
		&i.CreatedByUserID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const upsertRepoSecret = `-- name: UpsertRepoSecret :one

INSERT INTO workflow_secrets (repo_id, name, ciphertext, nonce, created_by_user_id)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (repo_id, name) WHERE repo_id IS NOT NULL DO UPDATE
SET ciphertext = EXCLUDED.ciphertext,
    nonce      = EXCLUDED.nonce,
    updated_at = now()
RETURNING id, repo_id, org_id, name, ciphertext, nonce,
          created_by_user_id, created_at, updated_at
`

type UpsertRepoSecretParams struct {
	RepoID          pgtype.Int8
	Name            string
	Ciphertext      []byte
	Nonce           []byte
	CreatedByUserID pgtype.Int8
}

// SPDX-License-Identifier: AGPL-3.0-or-later
func (q *Queries) UpsertRepoSecret(ctx context.Context, db DBTX, arg UpsertRepoSecretParams) (WorkflowSecret, error) {
	row := db.QueryRow(ctx, upsertRepoSecret,
		arg.RepoID,
		arg.Name,
		arg.Ciphertext,
		arg.Nonce,
		arg.CreatedByUserID,
	)
	var i WorkflowSecret
	err := row.Scan(
		&i.ID,
		&i.RepoID,
		&i.OrgID,
		&i.Name,
		&i.Ciphertext,
		&i.Nonce,
		&i.CreatedByUserID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}