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

package sqlcdb

import (
	"context"
	"database/sql"

	"github.com/google/uuid"
)

const countGitRepositories = `-- name: CountGitRepositories :one
SELECT COUNT(*)
FROM git_repositories
WHERE provider_id = $1 AND user_id = $2
  AND ($3::text IS NULL OR full_name ILIKE ('%' || $3::text || '%') OR name ILIKE ('%' || $3::text || '%'))
`

type CountGitRepositoriesParams struct {
	ProviderID uuid.UUID `json:"provider_id"`
	UserID     uuid.UUID `json:"user_id"`
	Column3    string    `json:"column_3"`
}

func (q *Queries) CountGitRepositories(ctx context.Context, arg CountGitRepositoriesParams) (int64, error) {
	row := q.db.QueryRowContext(ctx, countGitRepositories, arg.ProviderID, arg.UserID, arg.Column3)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const countUserRepositories = `-- name: CountUserRepositories :one
SELECT COUNT(*) FROM git_repositories WHERE user_id = $1
`

func (q *Queries) CountUserRepositories(ctx context.Context, userID uuid.UUID) (int64, error) {
	row := q.db.QueryRowContext(ctx, countUserRepositories, userID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const deleteGitProvider = `-- name: DeleteGitProvider :execrows
DELETE FROM git_providers WHERE id = $1 AND user_id = $2
`

type DeleteGitProviderParams struct {
	ID     uuid.UUID `json:"id"`
	UserID uuid.UUID `json:"user_id"`
}

func (q *Queries) DeleteGitProvider(ctx context.Context, arg DeleteGitProviderParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, deleteGitProvider, arg.ID, arg.UserID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const getGitProviderForFetch = `-- name: GetGitProviderForFetch :one
SELECT name, api_url, access_token
FROM git_providers
WHERE id = $1 AND user_id = $2
`

type GetGitProviderForFetchParams struct {
	ID     uuid.UUID `json:"id"`
	UserID uuid.UUID `json:"user_id"`
}

type GetGitProviderForFetchRow struct {
	Name        string `json:"name"`
	ApiUrl      string `json:"api_url"`
	AccessToken string `json:"access_token"`
}

func (q *Queries) GetGitProviderForFetch(ctx context.Context, arg GetGitProviderForFetchParams) (GetGitProviderForFetchRow, error) {
	row := q.db.QueryRowContext(ctx, getGitProviderForFetch, arg.ID, arg.UserID)
	var i GetGitProviderForFetchRow
	err := row.Scan(&i.Name, &i.ApiUrl, &i.AccessToken)
	return i, err
}

const getGitProviderForRepos = `-- name: GetGitProviderForRepos :one
SELECT name, display_name, access_token, api_url
FROM git_providers
WHERE id = $1 AND user_id = $2
`

type GetGitProviderForReposParams struct {
	ID     uuid.UUID `json:"id"`
	UserID uuid.UUID `json:"user_id"`
}

type GetGitProviderForReposRow struct {
	Name        string `json:"name"`
	DisplayName string `json:"display_name"`
	AccessToken string `json:"access_token"`
	ApiUrl      string `json:"api_url"`
}

func (q *Queries) GetGitProviderForRepos(ctx context.Context, arg GetGitProviderForReposParams) (GetGitProviderForReposRow, error) {
	row := q.db.QueryRowContext(ctx, getGitProviderForRepos, arg.ID, arg.UserID)
	var i GetGitProviderForReposRow
	err := row.Scan(
		&i.Name,
		&i.DisplayName,
		&i.AccessToken,
		&i.ApiUrl,
	)
	return i, err
}

const getGitProviderName = `-- name: GetGitProviderName :one
SELECT name FROM git_providers WHERE id = $1 AND user_id = $2
`

type GetGitProviderNameParams struct {
	ID     uuid.UUID `json:"id"`
	UserID uuid.UUID `json:"user_id"`
}

func (q *Queries) GetGitProviderName(ctx context.Context, arg GetGitProviderNameParams) (string, error) {
	row := q.db.QueryRowContext(ctx, getGitProviderName, arg.ID, arg.UserID)
	var name string
	err := row.Scan(&name)
	return name, err
}

const getGitProviderNameByID = `-- name: GetGitProviderNameByID :one
SELECT name FROM git_providers WHERE id = $1
`

func (q *Queries) GetGitProviderNameByID(ctx context.Context, id uuid.UUID) (string, error) {
	row := q.db.QueryRowContext(ctx, getGitProviderNameByID, id)
	var name string
	err := row.Scan(&name)
	return name, err
}

const getGitProviderTimestamps = `-- name: GetGitProviderTimestamps :one
SELECT created_at, updated_at FROM git_providers WHERE id = $1
`

type GetGitProviderTimestampsRow struct {
	CreatedAt sql.NullTime `json:"created_at"`
	UpdatedAt sql.NullTime `json:"updated_at"`
}

func (q *Queries) GetGitProviderTimestamps(ctx context.Context, id uuid.UUID) (GetGitProviderTimestampsRow, error) {
	row := q.db.QueryRowContext(ctx, getGitProviderTimestamps, id)
	var i GetGitProviderTimestampsRow
	err := row.Scan(&i.CreatedAt, &i.UpdatedAt)
	return i, err
}

const getGitRepoForPush = `-- name: GetGitRepoForPush :one
SELECT clone_url, full_name, user_id FROM git_repositories WHERE id = $1
`

type GetGitRepoForPushRow struct {
	CloneUrl string    `json:"clone_url"`
	FullName string    `json:"full_name"`
	UserID   uuid.UUID `json:"user_id"`
}

func (q *Queries) GetGitRepoForPush(ctx context.Context, id uuid.UUID) (GetGitRepoForPushRow, error) {
	row := q.db.QueryRowContext(ctx, getGitRepoForPush, id)
	var i GetGitRepoForPushRow
	err := row.Scan(&i.CloneUrl, &i.FullName, &i.UserID)
	return i, err
}

const getGitRepositoryByFullName = `-- name: GetGitRepositoryByFullName :one
SELECT id, provider_id, name, full_name, COALESCE(description, '') AS description,
       clone_url, COALESCE(webhook_url, '') AS webhook_url,
       default_branch, is_private, user_id, created_at, updated_at
FROM git_repositories
WHERE provider_id = $1 AND full_name = $2 AND user_id = $3
`

type GetGitRepositoryByFullNameParams struct {
	ProviderID uuid.UUID `json:"provider_id"`
	FullName   string    `json:"full_name"`
	UserID     uuid.UUID `json:"user_id"`
}

type GetGitRepositoryByFullNameRow struct {
	ID            uuid.UUID      `json:"id"`
	ProviderID    uuid.UUID      `json:"provider_id"`
	Name          string         `json:"name"`
	FullName      string         `json:"full_name"`
	Description   string         `json:"description"`
	CloneUrl      string         `json:"clone_url"`
	WebhookUrl    string         `json:"webhook_url"`
	DefaultBranch sql.NullString `json:"default_branch"`
	IsPrivate     sql.NullBool   `json:"is_private"`
	UserID        uuid.UUID      `json:"user_id"`
	CreatedAt     sql.NullTime   `json:"created_at"`
	UpdatedAt     sql.NullTime   `json:"updated_at"`
}

func (q *Queries) GetGitRepositoryByFullName(ctx context.Context, arg GetGitRepositoryByFullNameParams) (GetGitRepositoryByFullNameRow, error) {
	row := q.db.QueryRowContext(ctx, getGitRepositoryByFullName, arg.ProviderID, arg.FullName, arg.UserID)
	var i GetGitRepositoryByFullNameRow
	err := row.Scan(
		&i.ID,
		&i.ProviderID,
		&i.Name,
		&i.FullName,
		&i.Description,
		&i.CloneUrl,
		&i.WebhookUrl,
		&i.DefaultBranch,
		&i.IsPrivate,
		&i.UserID,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}

const getGitRepositoryProviderID = `-- name: GetGitRepositoryProviderID :one
SELECT provider_id FROM git_repositories WHERE id = $1 AND user_id = $2
`

type GetGitRepositoryProviderIDParams struct {
	ID     uuid.UUID `json:"id"`
	UserID uuid.UUID `json:"user_id"`
}

func (q *Queries) GetGitRepositoryProviderID(ctx context.Context, arg GetGitRepositoryProviderIDParams) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, getGitRepositoryProviderID, arg.ID, arg.UserID)
	var provider_id uuid.UUID
	err := row.Scan(&provider_id)
	return provider_id, err
}

const getGitWebhookForPush = `-- name: GetGitWebhookForPush :one
SELECT webhook_secret, repo_id, provider_id, COALESCE(branch_filter, '') AS branch_filter, active
FROM git_webhooks WHERE id = $1
`

type GetGitWebhookForPushRow struct {
	WebhookSecret string       `json:"webhook_secret"`
	RepoID        uuid.UUID    `json:"repo_id"`
	ProviderID    uuid.UUID    `json:"provider_id"`
	BranchFilter  string       `json:"branch_filter"`
	Active        sql.NullBool `json:"active"`
}

func (q *Queries) GetGitWebhookForPush(ctx context.Context, id uuid.UUID) (GetGitWebhookForPushRow, error) {
	row := q.db.QueryRowContext(ctx, getGitWebhookForPush, id)
	var i GetGitWebhookForPushRow
	err := row.Scan(
		&i.WebhookSecret,
		&i.RepoID,
		&i.ProviderID,
		&i.BranchFilter,
		&i.Active,
	)
	return i, err
}

const insertGitProvider = `-- name: InsertGitProvider :exec
INSERT INTO git_providers (id, name, display_name, api_url, webhook_url, access_token, user_id, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, NOW(), NOW())
`

type InsertGitProviderParams struct {
	ID          uuid.UUID `json:"id"`
	Name        string    `json:"name"`
	DisplayName string    `json:"display_name"`
	ApiUrl      string    `json:"api_url"`
	WebhookUrl  string    `json:"webhook_url"`
	AccessToken string    `json:"access_token"`
	UserID      uuid.UUID `json:"user_id"`
}

func (q *Queries) InsertGitProvider(ctx context.Context, arg InsertGitProviderParams) error {
	_, err := q.db.ExecContext(ctx, insertGitProvider,
		arg.ID,
		arg.Name,
		arg.DisplayName,
		arg.ApiUrl,
		arg.WebhookUrl,
		arg.AccessToken,
		arg.UserID,
	)
	return err
}

const insertGitRepository = `-- name: InsertGitRepository :one
INSERT INTO git_repositories (id, provider_id, name, full_name, description, clone_url, default_branch, is_private, user_id, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW(), NOW())
RETURNING created_at, updated_at
`

type InsertGitRepositoryParams struct {
	ID            uuid.UUID      `json:"id"`
	ProviderID    uuid.UUID      `json:"provider_id"`
	Name          string         `json:"name"`
	FullName      string         `json:"full_name"`
	Description   sql.NullString `json:"description"`
	CloneUrl      string         `json:"clone_url"`
	DefaultBranch sql.NullString `json:"default_branch"`
	IsPrivate     sql.NullBool   `json:"is_private"`
	UserID        uuid.UUID      `json:"user_id"`
}

type InsertGitRepositoryRow struct {
	CreatedAt sql.NullTime `json:"created_at"`
	UpdatedAt sql.NullTime `json:"updated_at"`
}

func (q *Queries) InsertGitRepository(ctx context.Context, arg InsertGitRepositoryParams) (InsertGitRepositoryRow, error) {
	row := q.db.QueryRowContext(ctx, insertGitRepository,
		arg.ID,
		arg.ProviderID,
		arg.Name,
		arg.FullName,
		arg.Description,
		arg.CloneUrl,
		arg.DefaultBranch,
		arg.IsPrivate,
		arg.UserID,
	)
	var i InsertGitRepositoryRow
	err := row.Scan(&i.CreatedAt, &i.UpdatedAt)
	return i, err
}

const listConnectedRepositories = `-- name: ListConnectedRepositories :many
SELECT r.id, r.provider_id, r.name, r.full_name, COALESCE(r.description, '') AS description, r.clone_url,
       r.default_branch, r.is_private, r.user_id, r.created_at, r.updated_at,
       p.name AS provider_name, p.display_name
FROM git_repositories r
JOIN git_providers p ON r.provider_id = p.id
WHERE r.user_id = $1
ORDER BY r.updated_at DESC
LIMIT $2 OFFSET $3
`

type ListConnectedRepositoriesParams struct {
	UserID uuid.UUID `json:"user_id"`
	Limit  int32     `json:"limit"`
	Offset int32     `json:"offset"`
}

type ListConnectedRepositoriesRow struct {
	ID            uuid.UUID      `json:"id"`
	ProviderID    uuid.UUID      `json:"provider_id"`
	Name          string         `json:"name"`
	FullName      string         `json:"full_name"`
	Description   string         `json:"description"`
	CloneUrl      string         `json:"clone_url"`
	DefaultBranch sql.NullString `json:"default_branch"`
	IsPrivate     sql.NullBool   `json:"is_private"`
	UserID        uuid.UUID      `json:"user_id"`
	CreatedAt     sql.NullTime   `json:"created_at"`
	UpdatedAt     sql.NullTime   `json:"updated_at"`
	ProviderName  string         `json:"provider_name"`
	DisplayName   string         `json:"display_name"`
}

func (q *Queries) ListConnectedRepositories(ctx context.Context, arg ListConnectedRepositoriesParams) ([]ListConnectedRepositoriesRow, error) {
	rows, err := q.db.QueryContext(ctx, listConnectedRepositories, arg.UserID, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListConnectedRepositoriesRow{}
	for rows.Next() {
		var i ListConnectedRepositoriesRow
		if err := rows.Scan(
			&i.ID,
			&i.ProviderID,
			&i.Name,
			&i.FullName,
			&i.Description,
			&i.CloneUrl,
			&i.DefaultBranch,
			&i.IsPrivate,
			&i.UserID,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.ProviderName,
			&i.DisplayName,
		); 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 listGitProviders = `-- name: ListGitProviders :many
SELECT id, name, display_name, api_url, webhook_url, user_id, created_at, updated_at
FROM git_providers
WHERE user_id = $1
ORDER BY created_at DESC
`

type ListGitProvidersRow struct {
	ID          uuid.UUID    `json:"id"`
	Name        string       `json:"name"`
	DisplayName string       `json:"display_name"`
	ApiUrl      string       `json:"api_url"`
	WebhookUrl  string       `json:"webhook_url"`
	UserID      uuid.UUID    `json:"user_id"`
	CreatedAt   sql.NullTime `json:"created_at"`
	UpdatedAt   sql.NullTime `json:"updated_at"`
}

func (q *Queries) ListGitProviders(ctx context.Context, userID uuid.UUID) ([]ListGitProvidersRow, error) {
	rows, err := q.db.QueryContext(ctx, listGitProviders, userID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListGitProvidersRow{}
	for rows.Next() {
		var i ListGitProvidersRow
		if err := rows.Scan(
			&i.ID,
			&i.Name,
			&i.DisplayName,
			&i.ApiUrl,
			&i.WebhookUrl,
			&i.UserID,
			&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 listGitRepositories = `-- name: ListGitRepositories :many
SELECT id, provider_id, name, full_name, COALESCE(description, '') AS description,
       clone_url, COALESCE(webhook_url, '') AS webhook_url,
       default_branch, is_private, user_id, created_at, updated_at
FROM git_repositories
WHERE provider_id = $1 AND user_id = $2
  AND ($3::text IS NULL OR full_name ILIKE ('%' || $3::text || '%') OR name ILIKE ('%' || $3::text || '%'))
ORDER BY updated_at DESC
LIMIT $4 OFFSET $5
`

type ListGitRepositoriesParams struct {
	ProviderID uuid.UUID `json:"provider_id"`
	UserID     uuid.UUID `json:"user_id"`
	Column3    string    `json:"column_3"`
	Limit      int32     `json:"limit"`
	Offset     int32     `json:"offset"`
}

type ListGitRepositoriesRow struct {
	ID            uuid.UUID      `json:"id"`
	ProviderID    uuid.UUID      `json:"provider_id"`
	Name          string         `json:"name"`
	FullName      string         `json:"full_name"`
	Description   string         `json:"description"`
	CloneUrl      string         `json:"clone_url"`
	WebhookUrl    string         `json:"webhook_url"`
	DefaultBranch sql.NullString `json:"default_branch"`
	IsPrivate     sql.NullBool   `json:"is_private"`
	UserID        uuid.UUID      `json:"user_id"`
	CreatedAt     sql.NullTime   `json:"created_at"`
	UpdatedAt     sql.NullTime   `json:"updated_at"`
}

func (q *Queries) ListGitRepositories(ctx context.Context, arg ListGitRepositoriesParams) ([]ListGitRepositoriesRow, error) {
	rows, err := q.db.QueryContext(ctx, listGitRepositories,
		arg.ProviderID,
		arg.UserID,
		arg.Column3,
		arg.Limit,
		arg.Offset,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListGitRepositoriesRow{}
	for rows.Next() {
		var i ListGitRepositoriesRow
		if err := rows.Scan(
			&i.ID,
			&i.ProviderID,
			&i.Name,
			&i.FullName,
			&i.Description,
			&i.CloneUrl,
			&i.WebhookUrl,
			&i.DefaultBranch,
			&i.IsPrivate,
			&i.UserID,
			&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 listServicesForPush = `-- name: ListServicesForPush :many
SELECT s.id, s.project_id, s.name,
       COALESCE(s.type, s.service_type, '') AS type, COALESCE(s.status, '') AS status,
       COALESCE(s.image, s.image_name, '') AS image, COALESCE(s.command, s.start_command, '') AS command,
       COALESCE(s.environment, '') AS environment, COALESCE(s.git_repo, s.source_url, '') AS git_repo,
       COALESCE(s.git_branch, '') AS git_branch, COALESCE(s.build_path, '') AS build_path,
       COALESCE(s.cpu, '') AS cpu, COALESCE(s.memory, '') AS memory,
       s.created_at, s.updated_at
FROM services s
WHERE (s.git_branch = $1 OR $1 = '') AND (s.git_repo = $2 OR s.git_repo = $3)
`

type ListServicesForPushParams struct {
	GitBranch sql.NullString `json:"git_branch"`
	GitRepo   sql.NullString `json:"git_repo"`
	GitRepo_2 sql.NullString `json:"git_repo_2"`
}

type ListServicesForPushRow struct {
	ID          uuid.UUID    `json:"id"`
	ProjectID   uuid.UUID    `json:"project_id"`
	Name        string       `json:"name"`
	Type        string       `json:"type"`
	Status      string       `json:"status"`
	Image       string       `json:"image"`
	Command     string       `json:"command"`
	Environment string       `json:"environment"`
	GitRepo     string       `json:"git_repo"`
	GitBranch   string       `json:"git_branch"`
	BuildPath   string       `json:"build_path"`
	Cpu         string       `json:"cpu"`
	Memory      string       `json:"memory"`
	CreatedAt   sql.NullTime `json:"created_at"`
	UpdatedAt   sql.NullTime `json:"updated_at"`
}

func (q *Queries) ListServicesForPush(ctx context.Context, arg ListServicesForPushParams) ([]ListServicesForPushRow, error) {
	rows, err := q.db.QueryContext(ctx, listServicesForPush, arg.GitBranch, arg.GitRepo, arg.GitRepo_2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListServicesForPushRow{}
	for rows.Next() {
		var i ListServicesForPushRow
		if err := rows.Scan(
			&i.ID,
			&i.ProjectID,
			&i.Name,
			&i.Type,
			&i.Status,
			&i.Image,
			&i.Command,
			&i.Environment,
			&i.GitRepo,
			&i.GitBranch,
			&i.BuildPath,
			&i.Cpu,
			&i.Memory,
			&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 upsertGitHubAppProvider = `-- name: UpsertGitHubAppProvider :one
INSERT INTO git_providers (id, name, display_name, api_url, webhook_url, access_token, user_id, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, NOW(), NOW())
ON CONFLICT (name, user_id)
DO UPDATE SET
    display_name = EXCLUDED.display_name,
    api_url = EXCLUDED.api_url,
    webhook_url = EXCLUDED.webhook_url,
    access_token = EXCLUDED.access_token,
    updated_at = NOW()
RETURNING id, created_at, updated_at
`

type UpsertGitHubAppProviderParams struct {
	ID          uuid.UUID `json:"id"`
	Name        string    `json:"name"`
	DisplayName string    `json:"display_name"`
	ApiUrl      string    `json:"api_url"`
	WebhookUrl  string    `json:"webhook_url"`
	AccessToken string    `json:"access_token"`
	UserID      uuid.UUID `json:"user_id"`
}

type UpsertGitHubAppProviderRow struct {
	ID        uuid.UUID    `json:"id"`
	CreatedAt sql.NullTime `json:"created_at"`
	UpdatedAt sql.NullTime `json:"updated_at"`
}

func (q *Queries) UpsertGitHubAppProvider(ctx context.Context, arg UpsertGitHubAppProviderParams) (UpsertGitHubAppProviderRow, error) {
	row := q.db.QueryRowContext(ctx, upsertGitHubAppProvider,
		arg.ID,
		arg.Name,
		arg.DisplayName,
		arg.ApiUrl,
		arg.WebhookUrl,
		arg.AccessToken,
		arg.UserID,
	)
	var i UpsertGitHubAppProviderRow
	err := row.Scan(&i.ID, &i.CreatedAt, &i.UpdatedAt)
	return i, err
}

const upsertGitRepository = `-- name: UpsertGitRepository :exec
INSERT INTO git_repositories (id, provider_id, name, full_name, description, clone_url, default_branch, is_private, user_id, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, NOW(), NOW())
ON CONFLICT (provider_id, full_name)
DO UPDATE SET
    name = EXCLUDED.name,
    description = EXCLUDED.description,
    clone_url = EXCLUDED.clone_url,
    default_branch = EXCLUDED.default_branch,
    is_private = EXCLUDED.is_private,
    updated_at = NOW()
`

type UpsertGitRepositoryParams struct {
	ID            uuid.UUID      `json:"id"`
	ProviderID    uuid.UUID      `json:"provider_id"`
	Name          string         `json:"name"`
	FullName      string         `json:"full_name"`
	Description   sql.NullString `json:"description"`
	CloneUrl      string         `json:"clone_url"`
	DefaultBranch sql.NullString `json:"default_branch"`
	IsPrivate     sql.NullBool   `json:"is_private"`
	UserID        uuid.UUID      `json:"user_id"`
}

func (q *Queries) UpsertGitRepository(ctx context.Context, arg UpsertGitRepositoryParams) error {
	_, err := q.db.ExecContext(ctx, upsertGitRepository,
		arg.ID,
		arg.ProviderID,
		arg.Name,
		arg.FullName,
		arg.Description,
		arg.CloneUrl,
		arg.DefaultBranch,
		arg.IsPrivate,
		arg.UserID,
	)
	return err
}

const upsertGitWebhook = `-- name: UpsertGitWebhook :one
INSERT INTO git_webhooks (id, repo_id, provider_id, events, webhook_secret, active, branch_filter, created_at, updated_at)
VALUES ($1, $2, $3, $4, $5, TRUE, $6, NOW(), NOW())
ON CONFLICT (repo_id, provider_id)
DO UPDATE SET
    events = EXCLUDED.events,
    webhook_secret = EXCLUDED.webhook_secret,
    active = TRUE,
    branch_filter = EXCLUDED.branch_filter,
    updated_at = NOW()
RETURNING id, active, created_at, updated_at
`

type UpsertGitWebhookParams struct {
	ID            uuid.UUID      `json:"id"`
	RepoID        uuid.UUID      `json:"repo_id"`
	ProviderID    uuid.UUID      `json:"provider_id"`
	Events        string         `json:"events"`
	WebhookSecret string         `json:"webhook_secret"`
	BranchFilter  sql.NullString `json:"branch_filter"`
}

type UpsertGitWebhookRow struct {
	ID        uuid.UUID    `json:"id"`
	Active    sql.NullBool `json:"active"`
	CreatedAt sql.NullTime `json:"created_at"`
	UpdatedAt sql.NullTime `json:"updated_at"`
}

func (q *Queries) UpsertGitWebhook(ctx context.Context, arg UpsertGitWebhookParams) (UpsertGitWebhookRow, error) {
	row := q.db.QueryRowContext(ctx, upsertGitWebhook,
		arg.ID,
		arg.RepoID,
		arg.ProviderID,
		arg.Events,
		arg.WebhookSecret,
		arg.BranchFilter,
	)
	var i UpsertGitWebhookRow
	err := row.Scan(
		&i.ID,
		&i.Active,
		&i.CreatedAt,
		&i.UpdatedAt,
	)
	return i, err
}