1137 lines
26 KiB
Go
1137 lines
26 KiB
Go
// Code generated by sqlc. DO NOT EDIT.
|
|
// versions:
|
|
// sqlc v1.31.1
|
|
// source: edastore.sql
|
|
|
|
package postgresdb
|
|
|
|
import (
|
|
"context"
|
|
"time"
|
|
|
|
"github.com/jackc/pgx/v5/pgtype"
|
|
)
|
|
|
|
const armedBindingsForSource = `-- name: ArmedBindingsForSource :many
|
|
SELECT id, name, source, mapping, workflow, owner, repo, version, status, created_at, updated_at, filter, inputs, repo_param, org_id
|
|
FROM bindings WHERE source = $1 AND status = 'armed' ORDER BY created_at DESC
|
|
`
|
|
|
|
type ArmedBindingsForSourceRow struct {
|
|
ID string
|
|
Name string
|
|
Source string
|
|
Mapping string
|
|
Workflow string
|
|
Owner string
|
|
Repo string
|
|
Version int64
|
|
Status string
|
|
CreatedAt time.Time
|
|
UpdatedAt time.Time
|
|
Filter string
|
|
Inputs string
|
|
RepoParam string
|
|
OrgID string
|
|
}
|
|
|
|
func (q *Queries) ArmedBindingsForSource(ctx context.Context, source string) ([]ArmedBindingsForSourceRow, error) {
|
|
rows, err := q.db.Query(ctx, armedBindingsForSource, source)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ArmedBindingsForSourceRow
|
|
for rows.Next() {
|
|
var i ArmedBindingsForSourceRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Source,
|
|
&i.Mapping,
|
|
&i.Workflow,
|
|
&i.Owner,
|
|
&i.Repo,
|
|
&i.Version,
|
|
&i.Status,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.Filter,
|
|
&i.Inputs,
|
|
&i.RepoParam,
|
|
&i.OrgID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const captureRefusalSummary = `-- name: CaptureRefusalSummary :many
|
|
WITH r AS (
|
|
SELECT source, count(*) AS refused, array_agg(DISTINCT addr ORDER BY addr)::text[] AS addrs
|
|
FROM capture_refusals WHERE refused_at >= $1 GROUP BY source
|
|
), a AS (
|
|
SELECT source, count(*) AS accepted FROM captures WHERE received_at >= $1 GROUP BY source
|
|
)
|
|
SELECT r.source, r.refused, COALESCE(a.accepted, 0)::bigint AS accepted, r.addrs
|
|
FROM r LEFT JOIN a ON a.source = r.source
|
|
ORDER BY r.source
|
|
`
|
|
|
|
type CaptureRefusalSummaryRow struct {
|
|
Source string
|
|
Refused int64
|
|
Accepted int64
|
|
Addrs []string
|
|
}
|
|
|
|
func (q *Queries) CaptureRefusalSummary(ctx context.Context, refusedAt time.Time) ([]CaptureRefusalSummaryRow, error) {
|
|
rows, err := q.db.Query(ctx, captureRefusalSummary, refusedAt)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []CaptureRefusalSummaryRow
|
|
for rows.Next() {
|
|
var i CaptureRefusalSummaryRow
|
|
if err := rows.Scan(
|
|
&i.Source,
|
|
&i.Refused,
|
|
&i.Accepted,
|
|
&i.Addrs,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const deleteBinding = `-- name: DeleteBinding :execrows
|
|
DELETE FROM bindings WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteBinding(ctx context.Context, id string) (int64, error) {
|
|
result, err := q.db.Exec(ctx, deleteBinding, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const deleteCaptureRefusalsBefore = `-- name: DeleteCaptureRefusalsBefore :exec
|
|
DELETE FROM capture_refusals WHERE refused_at < $1
|
|
`
|
|
|
|
func (q *Queries) DeleteCaptureRefusalsBefore(ctx context.Context, refusedAt time.Time) error {
|
|
_, err := q.db.Exec(ctx, deleteCaptureRefusalsBefore, refusedAt)
|
|
return err
|
|
}
|
|
|
|
const deleteCapturesBeyondCount = `-- name: DeleteCapturesBeyondCount :exec
|
|
DELETE FROM captures WHERE id NOT IN (
|
|
SELECT id FROM captures ORDER BY received_at DESC LIMIT $1
|
|
)
|
|
`
|
|
|
|
func (q *Queries) DeleteCapturesBeyondCount(ctx context.Context, limit int32) error {
|
|
_, err := q.db.Exec(ctx, deleteCapturesBeyondCount, limit)
|
|
return err
|
|
}
|
|
|
|
const deleteCapturesOlderThan = `-- name: DeleteCapturesOlderThan :exec
|
|
DELETE FROM captures WHERE received_at < $1
|
|
`
|
|
|
|
func (q *Queries) DeleteCapturesOlderThan(ctx context.Context, receivedAt time.Time) error {
|
|
_, err := q.db.Exec(ctx, deleteCapturesOlderThan, receivedAt)
|
|
return err
|
|
}
|
|
|
|
const deleteEventType = `-- name: DeleteEventType :execrows
|
|
DELETE FROM event_types WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteEventType(ctx context.Context, id string) (int64, error) {
|
|
result, err := q.db.Exec(ctx, deleteEventType, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const deleteMapping = `-- name: DeleteMapping :execrows
|
|
DELETE FROM mappings WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) DeleteMapping(ctx context.Context, id string) (int64, error) {
|
|
result, err := q.db.Exec(ctx, deleteMapping, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const deletePlaybookDispatches = `-- name: DeletePlaybookDispatches :exec
|
|
DELETE FROM playbook_dispatches WHERE playbook_id = $1
|
|
`
|
|
|
|
func (q *Queries) DeletePlaybookDispatches(ctx context.Context, playbookID string) error {
|
|
_, err := q.db.Exec(ctx, deletePlaybookDispatches, playbookID)
|
|
return err
|
|
}
|
|
|
|
const deriveSources = `-- name: DeriveSources :exec
|
|
SELECT derive_sources()
|
|
`
|
|
|
|
func (q *Queries) DeriveSources(ctx context.Context) error {
|
|
_, err := q.db.Exec(ctx, deriveSources)
|
|
return err
|
|
}
|
|
|
|
const eventTypesForSource = `-- name: EventTypesForSource :many
|
|
SELECT id, source, name, rule, schema, created_at, updated_at, org_id, workspace_id
|
|
FROM event_types WHERE source = $1 ORDER BY name
|
|
`
|
|
|
|
func (q *Queries) EventTypesForSource(ctx context.Context, source string) ([]EventType, error) {
|
|
rows, err := q.db.Query(ctx, eventTypesForSource, source)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []EventType
|
|
for rows.Next() {
|
|
var i EventType
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Source,
|
|
&i.Name,
|
|
&i.Rule,
|
|
&i.Schema,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const getBinding = `-- name: GetBinding :one
|
|
SELECT id, name, source, mapping, workflow, owner, repo, version, status, created_at, updated_at, filter, inputs, repo_param, org_id
|
|
FROM bindings WHERE id = $1
|
|
`
|
|
|
|
type GetBindingRow struct {
|
|
ID string
|
|
Name string
|
|
Source string
|
|
Mapping string
|
|
Workflow string
|
|
Owner string
|
|
Repo string
|
|
Version int64
|
|
Status string
|
|
CreatedAt time.Time
|
|
UpdatedAt time.Time
|
|
Filter string
|
|
Inputs string
|
|
RepoParam string
|
|
OrgID string
|
|
}
|
|
|
|
func (q *Queries) GetBinding(ctx context.Context, id string) (GetBindingRow, error) {
|
|
row := q.db.QueryRow(ctx, getBinding, id)
|
|
var i GetBindingRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Source,
|
|
&i.Mapping,
|
|
&i.Workflow,
|
|
&i.Owner,
|
|
&i.Repo,
|
|
&i.Version,
|
|
&i.Status,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.Filter,
|
|
&i.Inputs,
|
|
&i.RepoParam,
|
|
&i.OrgID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getEventType = `-- name: GetEventType :one
|
|
SELECT id, source, name, rule, schema, created_at, updated_at
|
|
FROM event_types WHERE id = $1
|
|
`
|
|
|
|
type GetEventTypeRow struct {
|
|
ID string
|
|
Source string
|
|
Name string
|
|
Rule string
|
|
Schema string
|
|
CreatedAt time.Time
|
|
UpdatedAt time.Time
|
|
}
|
|
|
|
func (q *Queries) GetEventType(ctx context.Context, id string) (GetEventTypeRow, error) {
|
|
row := q.db.QueryRow(ctx, getEventType, id)
|
|
var i GetEventTypeRow
|
|
err := row.Scan(
|
|
&i.ID,
|
|
&i.Source,
|
|
&i.Name,
|
|
&i.Rule,
|
|
&i.Schema,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getMapping = `-- name: GetMapping :one
|
|
SELECT mappings.id, mappings.name, mappings.source_hint, mappings.fields, mappings.created_at, mappings.updated_at, mappings.event_type, mappings.org_id, mappings.workspace_id,
|
|
(SELECT count(*) FROM mapping_matches mm WHERE mm.mapping = mappings.id)::bigint AS match_count,
|
|
COALESCE((SELECT max(mm.matched_at) FROM mapping_matches mm WHERE mm.mapping = mappings.id), 'epoch')::timestamptz AS last_matched_at
|
|
FROM mappings WHERE id = $1
|
|
`
|
|
|
|
type GetMappingRow struct {
|
|
Mapping Mapping
|
|
MatchCount int64
|
|
LastMatchedAt time.Time
|
|
}
|
|
|
|
func (q *Queries) GetMapping(ctx context.Context, id string) (GetMappingRow, error) {
|
|
row := q.db.QueryRow(ctx, getMapping, id)
|
|
var i GetMappingRow
|
|
err := row.Scan(
|
|
&i.Mapping.ID,
|
|
&i.Mapping.Name,
|
|
&i.Mapping.SourceHint,
|
|
&i.Mapping.Fields,
|
|
&i.Mapping.CreatedAt,
|
|
&i.Mapping.UpdatedAt,
|
|
&i.Mapping.EventType,
|
|
&i.Mapping.OrgID,
|
|
&i.Mapping.WorkspaceID,
|
|
&i.MatchCount,
|
|
&i.LastMatchedAt,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const getSource = `-- name: GetSource :one
|
|
SELECT path, signing, secret, created_at, updated_at, org_id, workspace_id FROM sources WHERE path = $1
|
|
`
|
|
|
|
func (q *Queries) GetSource(ctx context.Context, path string) (Source, error) {
|
|
row := q.db.QueryRow(ctx, getSource, path)
|
|
var i Source
|
|
err := row.Scan(
|
|
&i.Path,
|
|
&i.Signing,
|
|
&i.Secret,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
)
|
|
return i, err
|
|
}
|
|
|
|
const insertBinding = `-- name: InsertBinding :exec
|
|
INSERT INTO bindings (id, name, source, mapping, filter, workflow, owner, repo, version, status, inputs, repo_param)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 1, $9, $10, $11)
|
|
`
|
|
|
|
type InsertBindingParams struct {
|
|
ID string
|
|
Name string
|
|
Source string
|
|
Mapping string
|
|
Filter string
|
|
Workflow string
|
|
Owner string
|
|
Repo string
|
|
Status string
|
|
Inputs string
|
|
RepoParam string
|
|
}
|
|
|
|
func (q *Queries) InsertBinding(ctx context.Context, arg InsertBindingParams) error {
|
|
_, err := q.db.Exec(ctx, insertBinding,
|
|
arg.ID,
|
|
arg.Name,
|
|
arg.Source,
|
|
arg.Mapping,
|
|
arg.Filter,
|
|
arg.Workflow,
|
|
arg.Owner,
|
|
arg.Repo,
|
|
arg.Status,
|
|
arg.Inputs,
|
|
arg.RepoParam,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertBindingDispatch = `-- name: InsertBindingDispatch :exec
|
|
INSERT INTO binding_dispatches (binding, binding_version, capture, task_id, reason)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
`
|
|
|
|
type InsertBindingDispatchParams struct {
|
|
Binding string
|
|
BindingVersion int64
|
|
Capture string
|
|
TaskID int64
|
|
Reason string
|
|
}
|
|
|
|
func (q *Queries) InsertBindingDispatch(ctx context.Context, arg InsertBindingDispatchParams) error {
|
|
_, err := q.db.Exec(ctx, insertBindingDispatch,
|
|
arg.Binding,
|
|
arg.BindingVersion,
|
|
arg.Capture,
|
|
arg.TaskID,
|
|
arg.Reason,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertCapture = `-- name: InsertCapture :exec
|
|
|
|
INSERT INTO captures (id, source, remote_addr, content_type, headers, body, authenticated, received_at, unsigned, event_type)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)
|
|
`
|
|
|
|
type InsertCaptureParams struct {
|
|
ID string
|
|
Source string
|
|
RemoteAddr string
|
|
ContentType string
|
|
Headers string
|
|
Body string
|
|
Authenticated bool
|
|
ReceivedAt time.Time
|
|
Unsigned bool
|
|
EventType string
|
|
}
|
|
|
|
// EDA queries: captures, mappings, bindings, dispatch ledgers, tool_calls.
|
|
func (q *Queries) InsertCapture(ctx context.Context, arg InsertCaptureParams) error {
|
|
_, err := q.db.Exec(ctx, insertCapture,
|
|
arg.ID,
|
|
arg.Source,
|
|
arg.RemoteAddr,
|
|
arg.ContentType,
|
|
arg.Headers,
|
|
arg.Body,
|
|
arg.Authenticated,
|
|
arg.ReceivedAt,
|
|
arg.Unsigned,
|
|
arg.EventType,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertCaptureRefusal = `-- name: InsertCaptureRefusal :exec
|
|
INSERT INTO capture_refusals (source, addr, refused_at) VALUES ($1, $2, $3)
|
|
`
|
|
|
|
type InsertCaptureRefusalParams struct {
|
|
Source string
|
|
Addr string
|
|
RefusedAt time.Time
|
|
}
|
|
|
|
func (q *Queries) InsertCaptureRefusal(ctx context.Context, arg InsertCaptureRefusalParams) error {
|
|
_, err := q.db.Exec(ctx, insertCaptureRefusal, arg.Source, arg.Addr, arg.RefusedAt)
|
|
return err
|
|
}
|
|
|
|
const insertEventType = `-- name: InsertEventType :exec
|
|
INSERT INTO event_types (id, source, name, rule, schema)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
`
|
|
|
|
type InsertEventTypeParams struct {
|
|
ID string
|
|
Source string
|
|
Name string
|
|
Rule string
|
|
Schema string
|
|
}
|
|
|
|
func (q *Queries) InsertEventType(ctx context.Context, arg InsertEventTypeParams) error {
|
|
_, err := q.db.Exec(ctx, insertEventType,
|
|
arg.ID,
|
|
arg.Source,
|
|
arg.Name,
|
|
arg.Rule,
|
|
arg.Schema,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertMapping = `-- name: InsertMapping :exec
|
|
INSERT INTO mappings (id, name, source_hint, event_type, fields)
|
|
VALUES ($1, $2, $3, $4, $5)
|
|
`
|
|
|
|
type InsertMappingParams struct {
|
|
ID string
|
|
Name string
|
|
SourceHint string
|
|
EventType string
|
|
Fields string
|
|
}
|
|
|
|
func (q *Queries) InsertMapping(ctx context.Context, arg InsertMappingParams) error {
|
|
_, err := q.db.Exec(ctx, insertMapping,
|
|
arg.ID,
|
|
arg.Name,
|
|
arg.SourceHint,
|
|
arg.EventType,
|
|
arg.Fields,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertMappingMatch = `-- name: InsertMappingMatch :exec
|
|
INSERT INTO mapping_matches (mapping, capture) VALUES ($1, $2)
|
|
ON CONFLICT DO NOTHING
|
|
`
|
|
|
|
type InsertMappingMatchParams struct {
|
|
Mapping string
|
|
Capture string
|
|
}
|
|
|
|
func (q *Queries) InsertMappingMatch(ctx context.Context, arg InsertMappingMatchParams) error {
|
|
_, err := q.db.Exec(ctx, insertMappingMatch, arg.Mapping, arg.Capture)
|
|
return err
|
|
}
|
|
|
|
const insertPlaybookDispatch = `-- name: InsertPlaybookDispatch :exec
|
|
INSERT INTO playbook_dispatches (playbook_id, playbook_version, event_id, action_id)
|
|
VALUES ($1, $2, $3, $4)
|
|
`
|
|
|
|
type InsertPlaybookDispatchParams struct {
|
|
PlaybookID string
|
|
PlaybookVersion string
|
|
EventID string
|
|
ActionID string
|
|
}
|
|
|
|
func (q *Queries) InsertPlaybookDispatch(ctx context.Context, arg InsertPlaybookDispatchParams) error {
|
|
_, err := q.db.Exec(ctx, insertPlaybookDispatch,
|
|
arg.PlaybookID,
|
|
arg.PlaybookVersion,
|
|
arg.EventID,
|
|
arg.ActionID,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const insertSource = `-- name: InsertSource :exec
|
|
INSERT INTO sources (path, signing, secret) VALUES ($1, $2, $3)
|
|
`
|
|
|
|
type InsertSourceParams struct {
|
|
Path string
|
|
Signing string
|
|
Secret string
|
|
}
|
|
|
|
func (q *Queries) InsertSource(ctx context.Context, arg InsertSourceParams) error {
|
|
_, err := q.db.Exec(ctx, insertSource, arg.Path, arg.Signing, arg.Secret)
|
|
return err
|
|
}
|
|
|
|
const insertToolCall = `-- name: InsertToolCall :exec
|
|
INSERT INTO tool_calls (id, task_id, attempt, tool, result, error, called_at)
|
|
VALUES ($1, $2, $3, $4, $5, $6, $7)
|
|
`
|
|
|
|
type InsertToolCallParams struct {
|
|
ID string
|
|
TaskID int64
|
|
Attempt int64
|
|
Tool string
|
|
Result string
|
|
Error string
|
|
CalledAt time.Time
|
|
}
|
|
|
|
func (q *Queries) InsertToolCall(ctx context.Context, arg InsertToolCallParams) error {
|
|
_, err := q.db.Exec(ctx, insertToolCall,
|
|
arg.ID,
|
|
arg.TaskID,
|
|
arg.Attempt,
|
|
arg.Tool,
|
|
arg.Result,
|
|
arg.Error,
|
|
arg.CalledAt,
|
|
)
|
|
return err
|
|
}
|
|
|
|
const listBindingDispatches = `-- name: ListBindingDispatches :many
|
|
SELECT binding, binding_version, capture, task_id, reason, dispatched_at
|
|
FROM binding_dispatches
|
|
WHERE ($1::text IS NULL OR binding = $1)
|
|
AND ($2::text IS NULL OR capture = $2)
|
|
AND ($3::bigint IS NULL OR task_id = $3)
|
|
ORDER BY dispatched_at DESC
|
|
LIMIT $4
|
|
`
|
|
|
|
type ListBindingDispatchesParams struct {
|
|
Binding pgtype.Text
|
|
Capture pgtype.Text
|
|
TaskID pgtype.Int8
|
|
EntryLimit int32
|
|
}
|
|
|
|
type ListBindingDispatchesRow struct {
|
|
Binding string
|
|
BindingVersion int64
|
|
Capture string
|
|
TaskID int64
|
|
Reason string
|
|
DispatchedAt time.Time
|
|
}
|
|
|
|
func (q *Queries) ListBindingDispatches(ctx context.Context, arg ListBindingDispatchesParams) ([]ListBindingDispatchesRow, error) {
|
|
rows, err := q.db.Query(ctx, listBindingDispatches,
|
|
arg.Binding,
|
|
arg.Capture,
|
|
arg.TaskID,
|
|
arg.EntryLimit,
|
|
)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListBindingDispatchesRow
|
|
for rows.Next() {
|
|
var i ListBindingDispatchesRow
|
|
if err := rows.Scan(
|
|
&i.Binding,
|
|
&i.BindingVersion,
|
|
&i.Capture,
|
|
&i.TaskID,
|
|
&i.Reason,
|
|
&i.DispatchedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listBindings = `-- name: ListBindings :many
|
|
SELECT id, name, source, mapping, workflow, owner, repo, version, status, created_at, updated_at, filter, inputs, repo_param, org_id
|
|
FROM bindings ORDER BY created_at DESC
|
|
`
|
|
|
|
type ListBindingsRow struct {
|
|
ID string
|
|
Name string
|
|
Source string
|
|
Mapping string
|
|
Workflow string
|
|
Owner string
|
|
Repo string
|
|
Version int64
|
|
Status string
|
|
CreatedAt time.Time
|
|
UpdatedAt time.Time
|
|
Filter string
|
|
Inputs string
|
|
RepoParam string
|
|
OrgID string
|
|
}
|
|
|
|
func (q *Queries) ListBindings(ctx context.Context) ([]ListBindingsRow, error) {
|
|
rows, err := q.db.Query(ctx, listBindings)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListBindingsRow
|
|
for rows.Next() {
|
|
var i ListBindingsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Name,
|
|
&i.Source,
|
|
&i.Mapping,
|
|
&i.Workflow,
|
|
&i.Owner,
|
|
&i.Repo,
|
|
&i.Version,
|
|
&i.Status,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.Filter,
|
|
&i.Inputs,
|
|
&i.RepoParam,
|
|
&i.OrgID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listCaptures = `-- name: ListCaptures :many
|
|
SELECT id, source, remote_addr, content_type, headers, body, authenticated, received_at, unsigned, event_type, org_id, workspace_id
|
|
FROM captures
|
|
ORDER BY received_at DESC
|
|
LIMIT $1
|
|
`
|
|
|
|
func (q *Queries) ListCaptures(ctx context.Context, limit int32) ([]Capture, error) {
|
|
rows, err := q.db.Query(ctx, listCaptures, limit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Capture
|
|
for rows.Next() {
|
|
var i Capture
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Source,
|
|
&i.RemoteAddr,
|
|
&i.ContentType,
|
|
&i.Headers,
|
|
&i.Body,
|
|
&i.Authenticated,
|
|
&i.ReceivedAt,
|
|
&i.Unsigned,
|
|
&i.EventType,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listEventTypes = `-- name: ListEventTypes :many
|
|
SELECT id, source, name, rule, schema, created_at, updated_at, org_id, workspace_id
|
|
FROM event_types ORDER BY source, name
|
|
`
|
|
|
|
func (q *Queries) ListEventTypes(ctx context.Context) ([]EventType, error) {
|
|
rows, err := q.db.Query(ctx, listEventTypes)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []EventType
|
|
for rows.Next() {
|
|
var i EventType
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Source,
|
|
&i.Name,
|
|
&i.Rule,
|
|
&i.Schema,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listMappings = `-- name: ListMappings :many
|
|
SELECT mappings.id, mappings.name, mappings.source_hint, mappings.fields, mappings.created_at, mappings.updated_at, mappings.event_type, mappings.org_id, mappings.workspace_id,
|
|
(SELECT count(*) FROM mapping_matches mm WHERE mm.mapping = mappings.id)::bigint AS match_count,
|
|
COALESCE((SELECT max(mm.matched_at) FROM mapping_matches mm WHERE mm.mapping = mappings.id), 'epoch')::timestamptz AS last_matched_at
|
|
FROM mappings ORDER BY created_at DESC
|
|
`
|
|
|
|
type ListMappingsRow struct {
|
|
Mapping Mapping
|
|
MatchCount int64
|
|
LastMatchedAt time.Time
|
|
}
|
|
|
|
func (q *Queries) ListMappings(ctx context.Context) ([]ListMappingsRow, error) {
|
|
rows, err := q.db.Query(ctx, listMappings)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []ListMappingsRow
|
|
for rows.Next() {
|
|
var i ListMappingsRow
|
|
if err := rows.Scan(
|
|
&i.Mapping.ID,
|
|
&i.Mapping.Name,
|
|
&i.Mapping.SourceHint,
|
|
&i.Mapping.Fields,
|
|
&i.Mapping.CreatedAt,
|
|
&i.Mapping.UpdatedAt,
|
|
&i.Mapping.EventType,
|
|
&i.Mapping.OrgID,
|
|
&i.Mapping.WorkspaceID,
|
|
&i.MatchCount,
|
|
&i.LastMatchedAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listSources = `-- name: ListSources :many
|
|
SELECT path, signing, secret, created_at, updated_at, org_id, workspace_id FROM sources ORDER BY created_at DESC, path
|
|
`
|
|
|
|
func (q *Queries) ListSources(ctx context.Context) ([]Source, error) {
|
|
rows, err := q.db.Query(ctx, listSources)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Source
|
|
for rows.Next() {
|
|
var i Source
|
|
if err := rows.Scan(
|
|
&i.Path,
|
|
&i.Signing,
|
|
&i.Secret,
|
|
&i.CreatedAt,
|
|
&i.UpdatedAt,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const listUndispatchedCaptures = `-- name: ListUndispatchedCaptures :many
|
|
SELECT c.id, c.source, c.remote_addr, c.content_type, c.headers, c.body, c.authenticated, c.received_at, c.unsigned, c.event_type, c.org_id, c.workspace_id
|
|
FROM captures c
|
|
WHERE c.source = ANY($1::text[])
|
|
AND c.event_type <> ''
|
|
AND EXISTS (
|
|
SELECT 1 FROM bindings b JOIN mappings m ON m.id = b.mapping
|
|
WHERE b.source = c.source AND b.status = 'armed' AND m.event_type = c.event_type
|
|
AND NOT EXISTS (SELECT 1 FROM binding_dispatches d WHERE d.binding = b.id AND d.capture = c.id)
|
|
)
|
|
ORDER BY c.received_at DESC
|
|
LIMIT $2
|
|
`
|
|
|
|
type ListUndispatchedCapturesParams struct {
|
|
Sources []string
|
|
EntryLimit int32
|
|
}
|
|
|
|
func (q *Queries) ListUndispatchedCaptures(ctx context.Context, arg ListUndispatchedCapturesParams) ([]Capture, error) {
|
|
rows, err := q.db.Query(ctx, listUndispatchedCaptures, arg.Sources, arg.EntryLimit)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []Capture
|
|
for rows.Next() {
|
|
var i Capture
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.Source,
|
|
&i.RemoteAddr,
|
|
&i.ContentType,
|
|
&i.Headers,
|
|
&i.Body,
|
|
&i.Authenticated,
|
|
&i.ReceivedAt,
|
|
&i.Unsigned,
|
|
&i.EventType,
|
|
&i.OrgID,
|
|
&i.WorkspaceID,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const lockEventTypeSource = `-- name: LockEventTypeSource :exec
|
|
SELECT pg_advisory_xact_lock(hashtext('event_types:' || $1::text))
|
|
`
|
|
|
|
// Serialises saves per source so two concurrent saves cannot each pass the
|
|
// overlap check against a set that excludes the other.
|
|
func (q *Queries) LockEventTypeSource(ctx context.Context, source string) error {
|
|
_, err := q.db.Exec(ctx, lockEventTypeSource, source)
|
|
return err
|
|
}
|
|
|
|
const setBindingArmed = `-- name: SetBindingArmed :execrows
|
|
UPDATE bindings SET status = 'armed', updated_at = now() WHERE id = $1
|
|
`
|
|
|
|
func (q *Queries) SetBindingArmed(ctx context.Context, id string) (int64, error) {
|
|
result, err := q.db.Exec(ctx, setBindingArmed, id)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const setBindingDispatchTask = `-- name: SetBindingDispatchTask :exec
|
|
UPDATE binding_dispatches SET task_id = $3 WHERE binding = $1 AND capture = $2
|
|
`
|
|
|
|
type SetBindingDispatchTaskParams struct {
|
|
Binding string
|
|
Capture string
|
|
TaskID int64
|
|
}
|
|
|
|
func (q *Queries) SetBindingDispatchTask(ctx context.Context, arg SetBindingDispatchTaskParams) error {
|
|
_, err := q.db.Exec(ctx, setBindingDispatchTask, arg.Binding, arg.Capture, arg.TaskID)
|
|
return err
|
|
}
|
|
|
|
const setSourceSecret = `-- name: SetSourceSecret :execrows
|
|
UPDATE sources SET secret = $2, updated_at = now() WHERE path = $1
|
|
`
|
|
|
|
type SetSourceSecretParams struct {
|
|
Path string
|
|
Secret string
|
|
}
|
|
|
|
func (q *Queries) SetSourceSecret(ctx context.Context, arg SetSourceSecretParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, setSourceSecret, arg.Path, arg.Secret)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const setSourceSigning = `-- name: SetSourceSigning :execrows
|
|
UPDATE sources SET signing = $1, updated_at = now()
|
|
WHERE path = $2 AND signing = $3
|
|
`
|
|
|
|
type SetSourceSigningParams struct {
|
|
ToSigning string
|
|
Path string
|
|
FromSigning string
|
|
}
|
|
|
|
func (q *Queries) SetSourceSigning(ctx context.Context, arg SetSourceSigningParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, setSourceSigning, arg.ToSigning, arg.Path, arg.FromSigning)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const sourceExists = `-- name: SourceExists :one
|
|
SELECT EXISTS (SELECT 1 FROM sources WHERE path = $1)
|
|
`
|
|
|
|
func (q *Queries) SourceExists(ctx context.Context, path string) (bool, error) {
|
|
row := q.db.QueryRow(ctx, sourceExists, path)
|
|
var exists bool
|
|
err := row.Scan(&exists)
|
|
return exists, err
|
|
}
|
|
|
|
const taskToolCalls = `-- name: TaskToolCalls :many
|
|
SELECT id, task_id, attempt, tool, result, error, called_at
|
|
FROM tool_calls WHERE task_id = $1 ORDER BY called_at ASC
|
|
`
|
|
|
|
type TaskToolCallsRow struct {
|
|
ID string
|
|
TaskID int64
|
|
Attempt int64
|
|
Tool string
|
|
Result string
|
|
Error string
|
|
CalledAt time.Time
|
|
}
|
|
|
|
func (q *Queries) TaskToolCalls(ctx context.Context, taskID int64) ([]TaskToolCallsRow, error) {
|
|
rows, err := q.db.Query(ctx, taskToolCalls, taskID)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
defer rows.Close()
|
|
var items []TaskToolCallsRow
|
|
for rows.Next() {
|
|
var i TaskToolCallsRow
|
|
if err := rows.Scan(
|
|
&i.ID,
|
|
&i.TaskID,
|
|
&i.Attempt,
|
|
&i.Tool,
|
|
&i.Result,
|
|
&i.Error,
|
|
&i.CalledAt,
|
|
); err != nil {
|
|
return nil, err
|
|
}
|
|
items = append(items, i)
|
|
}
|
|
if err := rows.Err(); err != nil {
|
|
return nil, err
|
|
}
|
|
return items, nil
|
|
}
|
|
|
|
const updateBinding = `-- name: UpdateBinding :execrows
|
|
UPDATE bindings
|
|
SET name = $2, source = $3, mapping = $4, filter = $5, workflow = $6, owner = $7, repo = $8,
|
|
version = version + 1, status = $9, inputs = $10, repo_param = $11, updated_at = now()
|
|
WHERE id = $1
|
|
`
|
|
|
|
type UpdateBindingParams struct {
|
|
ID string
|
|
Name string
|
|
Source string
|
|
Mapping string
|
|
Filter string
|
|
Workflow string
|
|
Owner string
|
|
Repo string
|
|
Status string
|
|
Inputs string
|
|
RepoParam string
|
|
}
|
|
|
|
func (q *Queries) UpdateBinding(ctx context.Context, arg UpdateBindingParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, updateBinding,
|
|
arg.ID,
|
|
arg.Name,
|
|
arg.Source,
|
|
arg.Mapping,
|
|
arg.Filter,
|
|
arg.Workflow,
|
|
arg.Owner,
|
|
arg.Repo,
|
|
arg.Status,
|
|
arg.Inputs,
|
|
arg.RepoParam,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const updateEventType = `-- name: UpdateEventType :execrows
|
|
UPDATE event_types SET name = $2, rule = $3, updated_at = now() WHERE id = $1
|
|
`
|
|
|
|
type UpdateEventTypeParams struct {
|
|
ID string
|
|
Name string
|
|
Rule string
|
|
}
|
|
|
|
func (q *Queries) UpdateEventType(ctx context.Context, arg UpdateEventTypeParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, updateEventType, arg.ID, arg.Name, arg.Rule)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|
|
|
|
const updateMapping = `-- name: UpdateMapping :execrows
|
|
UPDATE mappings
|
|
SET name = $2, source_hint = $3, event_type = $4, fields = $5, updated_at = now()
|
|
WHERE id = $1
|
|
`
|
|
|
|
type UpdateMappingParams struct {
|
|
ID string
|
|
Name string
|
|
SourceHint string
|
|
EventType string
|
|
Fields string
|
|
}
|
|
|
|
func (q *Queries) UpdateMapping(ctx context.Context, arg UpdateMappingParams) (int64, error) {
|
|
result, err := q.db.Exec(ctx, updateMapping,
|
|
arg.ID,
|
|
arg.Name,
|
|
arg.SourceHint,
|
|
arg.EventType,
|
|
arg.Fields,
|
|
)
|
|
if err != nil {
|
|
return 0, err
|
|
}
|
|
return result.RowsAffected(), nil
|
|
}
|