rule_instances.sql.go

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

package db

import (
	"context"
	"encoding/json"

	"github.com/google/uuid"
	"github.com/lib/pq"
)

const deleteNonUpdatedRules = `-- name: DeleteNonUpdatedRules :exec
DELETE FROM rule_instances
WHERE profile_id = $1
AND entity_type = $2
AND NOT id = ANY($3::UUID[])
`

type DeleteNonUpdatedRulesParams struct {
	ProfileID  uuid.UUID   `json:"profile_id"`
	EntityType Entities    `json:"entity_type"`
	UpdatedIds []uuid.UUID `json:"updated_ids"`
}

func (q *Queries) DeleteNonUpdatedRules(ctx context.Context, arg DeleteNonUpdatedRulesParams) error {
	_, err := q.db.ExecContext(ctx, deleteNonUpdatedRules, arg.ProfileID, arg.EntityType, pq.Array(arg.UpdatedIds))
	return err
}

const deleteRuleInstanceOfProfileInProject = `-- name: DeleteRuleInstanceOfProfileInProject :exec
DELETE FROM rule_instances WHERE project_id = $1 AND profile_id = $2 AND rule_type_id = $3
`

type DeleteRuleInstanceOfProfileInProjectParams struct {
	ProjectID  uuid.UUID `json:"project_id"`
	ProfileID  uuid.UUID `json:"profile_id"`
	RuleTypeID uuid.UUID `json:"rule_type_id"`
}

func (q *Queries) DeleteRuleInstanceOfProfileInProject(ctx context.Context, arg DeleteRuleInstanceOfProfileInProjectParams) error {
	_, err := q.db.ExecContext(ctx, deleteRuleInstanceOfProfileInProject, arg.ProjectID, arg.ProfileID, arg.RuleTypeID)
	return err
}

const getRuleInstancesEntityInProjects = `-- name: GetRuleInstancesEntityInProjects :many
SELECT id, profile_id, rule_type_id, name, entity_type, def, params, created_at, updated_at, project_id FROM rule_instances
WHERE entity_type = $1
AND project_id = ANY($2::UUID[])
`

type GetRuleInstancesEntityInProjectsParams struct {
	EntityType Entities    `json:"entity_type"`
	ProjectIds []uuid.UUID `json:"project_ids"`
}

func (q *Queries) GetRuleInstancesEntityInProjects(ctx context.Context, arg GetRuleInstancesEntityInProjectsParams) ([]RuleInstance, error) {
	rows, err := q.db.QueryContext(ctx, getRuleInstancesEntityInProjects, arg.EntityType, pq.Array(arg.ProjectIds))
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []RuleInstance{}
	for rows.Next() {
		var i RuleInstance
		if err := rows.Scan(
			&i.ID,
			&i.ProfileID,
			&i.RuleTypeID,
			&i.Name,
			&i.EntityType,
			&i.Def,
			&i.Params,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.ProjectID,
		); 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 getRuleInstancesForProfile = `-- name: GetRuleInstancesForProfile :many
SELECT id, profile_id, rule_type_id, name, entity_type, def, params, created_at, updated_at, project_id FROM rule_instances WHERE profile_id = $1
`

func (q *Queries) GetRuleInstancesForProfile(ctx context.Context, profileID uuid.UUID) ([]RuleInstance, error) {
	rows, err := q.db.QueryContext(ctx, getRuleInstancesForProfile, profileID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []RuleInstance{}
	for rows.Next() {
		var i RuleInstance
		if err := rows.Scan(
			&i.ID,
			&i.ProfileID,
			&i.RuleTypeID,
			&i.Name,
			&i.EntityType,
			&i.Def,
			&i.Params,
			&i.CreatedAt,
			&i.UpdatedAt,
			&i.ProjectID,
		); 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 getRuleTypeIDByRuleNameEntityProfile = `-- name: GetRuleTypeIDByRuleNameEntityProfile :one
SELECT rule_type_id FROM rule_instances
WHERE name = $1
AND entity_type = $2
AND profile_id = $3
`

type GetRuleTypeIDByRuleNameEntityProfileParams struct {
	Name       string    `json:"name"`
	EntityType Entities  `json:"entity_type"`
	ProfileID  uuid.UUID `json:"profile_id"`
}

// intended as a temporary transition query
// this will be removed once rule_instances is used consistently in the engine
func (q *Queries) GetRuleTypeIDByRuleNameEntityProfile(ctx context.Context, arg GetRuleTypeIDByRuleNameEntityProfileParams) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, getRuleTypeIDByRuleNameEntityProfile, arg.Name, arg.EntityType, arg.ProfileID)
	var rule_type_id uuid.UUID
	err := row.Scan(&rule_type_id)
	return rule_type_id, err
}

const upsertRuleInstance = `-- name: UpsertRuleInstance :one

INSERT INTO rule_instances (
    profile_id,
    rule_type_id,
    name,
    entity_type,
    def,
    params,
    project_id,
    created_at,
    updated_at
) VALUES(
    $1,
    $2,
    $3,
    $4,
    $5,
    $6,
    $7,
    NOW(),
    NOW()
)
ON CONFLICT (profile_id, entity_type, lower(name)) DO UPDATE SET
    rule_type_id = $2,
    def = $5,
    params = $6,
    updated_at = NOW()
RETURNING id
`

type UpsertRuleInstanceParams struct {
	ProfileID  uuid.UUID       `json:"profile_id"`
	RuleTypeID uuid.UUID       `json:"rule_type_id"`
	Name       string          `json:"name"`
	EntityType Entities        `json:"entity_type"`
	Def        json.RawMessage `json:"def"`
	Params     json.RawMessage `json:"params"`
	ProjectID  uuid.UUID       `json:"project_id"`
}

// SPDX-FileCopyrightText: Copyright 2024 The Minder Authors
// SPDX-License-Identifier: Apache-2.0
func (q *Queries) UpsertRuleInstance(ctx context.Context, arg UpsertRuleInstanceParams) (uuid.UUID, error) {
	row := q.db.QueryRowContext(ctx, upsertRuleInstance,
		arg.ProfileID,
		arg.RuleTypeID,
		arg.Name,
		arg.EntityType,
		arg.Def,
		arg.Params,
		arg.ProjectID,
	)
	var id uuid.UUID
	err := row.Scan(&id)
	return id, err
}