Kazier/backend/internal/db/rebac_relations.sql.go

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

package db

import (
	"context"

	"github.com/google/uuid"
)

const createRebacRelation = `-- name: CreateRebacRelation :one
INSERT INTO rebac_relations (resource_id, subject_user_id, role, granted_by)
VALUES ($1, $2, $3, $4)
RETURNING id, resource_id, subject_user_id, role, granted_by, created_at
`

type CreateRebacRelationParams struct {
	ResourceID    uuid.UUID `json:"resource_id"`
	SubjectUserID uuid.UUID `json:"subject_user_id"`
	Role          string    `json:"role"`
	GrantedBy     uuid.UUID `json:"granted_by"`
}

func (q *Queries) CreateRebacRelation(ctx context.Context, arg CreateRebacRelationParams) (RebacRelation, error) {
	row := q.db.QueryRowContext(ctx, createRebacRelation,
		arg.ResourceID,
		arg.SubjectUserID,
		arg.Role,
		arg.GrantedBy,
	)
	var i RebacRelation
	err := row.Scan(
		&i.ID,
		&i.ResourceID,
		&i.SubjectUserID,
		&i.Role,
		&i.GrantedBy,
		&i.CreatedAt,
	)
	return i, err
}

const deleteRebacRelation = `-- name: DeleteRebacRelation :exec
DELETE FROM rebac_relations
WHERE resource_id = $1 AND subject_user_id = $2
`

type DeleteRebacRelationParams struct {
	ResourceID    uuid.UUID `json:"resource_id"`
	SubjectUserID uuid.UUID `json:"subject_user_id"`
}

func (q *Queries) DeleteRebacRelation(ctx context.Context, arg DeleteRebacRelationParams) error {
	_, err := q.db.ExecContext(ctx, deleteRebacRelation, arg.ResourceID, arg.SubjectUserID)
	return err
}

const deleteRebacRelationsByResource = `-- name: DeleteRebacRelationsByResource :exec
DELETE FROM rebac_relations
WHERE resource_id = $1
`

func (q *Queries) DeleteRebacRelationsByResource(ctx context.Context, resourceID uuid.UUID) error {
	_, err := q.db.ExecContext(ctx, deleteRebacRelationsByResource, resourceID)
	return err
}

const getRebacRelation = `-- name: GetRebacRelation :one
SELECT id, resource_id, subject_user_id, role, granted_by, created_at FROM rebac_relations
WHERE resource_id = $1 AND subject_user_id = $2
LIMIT 1
`

type GetRebacRelationParams struct {
	ResourceID    uuid.UUID `json:"resource_id"`
	SubjectUserID uuid.UUID `json:"subject_user_id"`
}

func (q *Queries) GetRebacRelation(ctx context.Context, arg GetRebacRelationParams) (RebacRelation, error) {
	row := q.db.QueryRowContext(ctx, getRebacRelation, arg.ResourceID, arg.SubjectUserID)
	var i RebacRelation
	err := row.Scan(
		&i.ID,
		&i.ResourceID,
		&i.SubjectUserID,
		&i.Role,
		&i.GrantedBy,
		&i.CreatedAt,
	)
	return i, err
}

const hasRebacRelation = `-- name: HasRebacRelation :one
SELECT EXISTS(
    SELECT 1 FROM rebac_relations
    WHERE resource_id = $1 AND subject_user_id = $2 AND role = $3
)
`

type HasRebacRelationParams struct {
	ResourceID    uuid.UUID `json:"resource_id"`
	SubjectUserID uuid.UUID `json:"subject_user_id"`
	Role          string    `json:"role"`
}

func (q *Queries) HasRebacRelation(ctx context.Context, arg HasRebacRelationParams) (bool, error) {
	row := q.db.QueryRowContext(ctx, hasRebacRelation, arg.ResourceID, arg.SubjectUserID, arg.Role)
	var exists bool
	err := row.Scan(&exists)
	return exists, err
}

const listRebacRelationsByResource = `-- name: ListRebacRelationsByResource :many
SELECT id, resource_id, subject_user_id, role, granted_by, created_at FROM rebac_relations
WHERE resource_id = $1
ORDER BY created_at ASC
`

func (q *Queries) ListRebacRelationsByResource(ctx context.Context, resourceID uuid.UUID) ([]RebacRelation, error) {
	rows, err := q.db.QueryContext(ctx, listRebacRelationsByResource, resourceID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []RebacRelation
	for rows.Next() {
		var i RebacRelation
		if err := rows.Scan(
			&i.ID,
			&i.ResourceID,
			&i.SubjectUserID,
			&i.Role,
			&i.GrantedBy,
			&i.CreatedAt,
		); 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 listRebacRelationsBySubject = `-- name: ListRebacRelationsBySubject :many
SELECT id, resource_id, subject_user_id, role, granted_by, created_at FROM rebac_relations
WHERE subject_user_id = $1
ORDER BY created_at ASC
`

func (q *Queries) ListRebacRelationsBySubject(ctx context.Context, subjectUserID uuid.UUID) ([]RebacRelation, error) {
	rows, err := q.db.QueryContext(ctx, listRebacRelationsBySubject, subjectUserID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []RebacRelation
	for rows.Next() {
		var i RebacRelation
		if err := rows.Scan(
			&i.ID,
			&i.ResourceID,
			&i.SubjectUserID,
			&i.Role,
			&i.GrantedBy,
			&i.CreatedAt,
		); 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 resolveEffectiveRole = `-- name: ResolveEffectiveRole :one
SELECT resolve_effective_role($1, $2) AS role
`

type ResolveEffectiveRoleParams struct {
	PUserID     uuid.UUID `json:"p_user_id"`
	PResourceID uuid.UUID `json:"p_resource_id"`
}

func (q *Queries) ResolveEffectiveRole(ctx context.Context, arg ResolveEffectiveRoleParams) (string, error) {
	row := q.db.QueryRowContext(ctx, resolveEffectiveRole, arg.PUserID, arg.PResourceID)
	var role string
	err := row.Scan(&role)
	return role, err
}