Files
archie/internal/infrastructure/postgres/postgresdb/edastore.sql.go
T

1381 lines
35 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, workspace_id
FROM bindings WHERE source = $1 AND status = 'armed' AND ($2::text IS NULL OR org_id = $2) ORDER BY created_at DESC
`
type ArmedBindingsForSourceParams struct {
Source string
ScopeOrg pgtype.Text
}
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
WorkspaceID string
}
func (q *Queries) ArmedBindingsForSource(ctx context.Context, arg ArmedBindingsForSourceParams) ([]ArmedBindingsForSourceRow, error) {
rows, err := q.db.Query(ctx, armedBindingsForSource, arg.Source, arg.ScopeOrg)
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,
&i.WorkspaceID,
); 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 cr WHERE refused_at >= $1
AND ($2::text IS NULL
OR EXISTS (SELECT 1 FROM sources s WHERE s.path = cr.source AND s.org_id = $2))
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 CaptureRefusalSummaryParams struct {
Since time.Time
ScopeOrg pgtype.Text
}
type CaptureRefusalSummaryRow struct {
Source string
Refused int64
Accepted int64
Addrs []string
}
func (q *Queries) CaptureRefusalSummary(ctx context.Context, arg CaptureRefusalSummaryParams) ([]CaptureRefusalSummaryRow, error) {
rows, err := q.db.Query(ctx, captureRefusalSummary, arg.Since, arg.ScopeOrg)
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 AND ($2::text IS NULL OR org_id = $2)
`
type DeleteBindingParams struct {
ID string
ScopeOrg pgtype.Text
}
func (q *Queries) DeleteBinding(ctx context.Context, arg DeleteBindingParams) (int64, error) {
result, err := q.db.Exec(ctx, deleteBinding, arg.ID, arg.ScopeOrg)
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 AS c
WHERE c.org_id = (SELECT m.org_id FROM captures AS m WHERE m.id = $1)
AND c.id NOT IN (
SELECT k.id FROM captures AS k
WHERE k.org_id = (SELECT m.org_id FROM captures AS m WHERE m.id = $1)
ORDER BY k.received_at DESC
LIMIT $2
)
AND NOT (
c.event_type <> '' AND (c.authenticated OR c.unsigned)
AND EXISTS (
SELECT 1 FROM bindings b JOIN mappings m ON m.id = b.mapping
WHERE b.org_id = c.org_id AND 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.delivery = c.delivery)
)
)
`
type DeleteCapturesBeyondCountParams struct {
CaptureID string
MaxEvents int32
}
// Count retention stays within the just-inserted capture's org: one org's
// volume must never evict another org's recent captures. It never evicts a
// capture ListUndispatchedCaptures would still offer: that is accepted work.
func (q *Queries) DeleteCapturesBeyondCount(ctx context.Context, arg DeleteCapturesBeyondCountParams) error {
_, err := q.db.Exec(ctx, deleteCapturesBeyondCount, arg.CaptureID, arg.MaxEvents)
return err
}
const deleteCapturesOlderThan = `-- name: DeleteCapturesOlderThan :exec
DELETE FROM captures AS c
WHERE c.received_at < $1
AND NOT (
c.event_type <> '' AND (c.authenticated OR c.unsigned)
AND EXISTS (
SELECT 1 FROM bindings b JOIN mappings m ON m.id = b.mapping
WHERE b.org_id = c.org_id AND 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.delivery = c.delivery)
)
)
`
// Age retention spares what DeleteCapturesBeyondCount spares: a capture
// ListUndispatchedCaptures would still offer is accepted work.
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 AND ($2::text IS NULL OR org_id = $2)
`
type DeleteEventTypeParams struct {
ID string
ScopeOrg pgtype.Text
}
func (q *Queries) DeleteEventType(ctx context.Context, arg DeleteEventTypeParams) (int64, error) {
result, err := q.db.Exec(ctx, deleteEventType, arg.ID, arg.ScopeOrg)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const deleteMapping = `-- name: DeleteMapping :execrows
DELETE FROM mappings WHERE id = $1 AND ($2::text IS NULL OR org_id = $2)
`
type DeleteMappingParams struct {
ID string
ScopeOrg pgtype.Text
}
func (q *Queries) DeleteMapping(ctx context.Context, arg DeleteMappingParams) (int64, error) {
result, err := q.db.Exec(ctx, deleteMapping, arg.ID, arg.ScopeOrg)
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 deleteUnboundSource = `-- name: DeleteUnboundSource :execrows
DELETE FROM sources s WHERE s.path = $1 AND ($2::text IS NULL OR s.org_id = $2)
AND NOT EXISTS (SELECT 1 FROM bindings b WHERE b.source = s.path AND b.status = 'armed')
`
type DeleteUnboundSourceParams struct {
Path string
ScopeOrg pgtype.Text
}
// A source an armed binding fires on is not deleted: the binding would
// silently stop receiving events.
func (q *Queries) DeleteUnboundSource(ctx context.Context, arg DeleteUnboundSourceParams) (int64, error) {
result, err := q.db.Exec(ctx, deleteUnboundSource, arg.Path, arg.ScopeOrg)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
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, workspace_id
FROM bindings WHERE id = $1 AND ($2::text IS NULL OR org_id = $2)
`
type GetBindingParams struct {
ID string
ScopeOrg pgtype.Text
}
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
WorkspaceID string
}
func (q *Queries) GetBinding(ctx context.Context, arg GetBindingParams) (GetBindingRow, error) {
row := q.db.QueryRow(ctx, getBinding, arg.ID, arg.ScopeOrg)
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,
&i.WorkspaceID,
)
return i, err
}
const getEventType = `-- name: GetEventType :one
SELECT id, source, name, rule, schema, created_at, updated_at, org_id, workspace_id
FROM event_types WHERE id = $1 AND ($2::text IS NULL OR org_id = $2)
`
type GetEventTypeParams struct {
ID string
ScopeOrg pgtype.Text
}
func (q *Queries) GetEventType(ctx context.Context, arg GetEventTypeParams) (EventType, error) {
row := q.db.QueryRow(ctx, getEventType, arg.ID, arg.ScopeOrg)
var i EventType
err := row.Scan(
&i.ID,
&i.Source,
&i.Name,
&i.Rule,
&i.Schema,
&i.CreatedAt,
&i.UpdatedAt,
&i.OrgID,
&i.WorkspaceID,
)
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 AND ($2::text IS NULL OR org_id = $2)
`
type GetMappingParams struct {
ID string
ScopeOrg pgtype.Text
}
type GetMappingRow struct {
Mapping Mapping
MatchCount int64
LastMatchedAt time.Time
}
func (q *Queries) GetMapping(ctx context.Context, arg GetMappingParams) (GetMappingRow, error) {
row := q.db.QueryRow(ctx, getMapping, arg.ID, arg.ScopeOrg)
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, name, delivery_header FROM sources WHERE path = $1 AND ($2::text IS NULL OR org_id = $2)
`
type GetSourceParams struct {
Path string
ScopeOrg pgtype.Text
}
func (q *Queries) GetSource(ctx context.Context, arg GetSourceParams) (Source, error) {
row := q.db.QueryRow(ctx, getSource, arg.Path, arg.ScopeOrg)
var i Source
err := row.Scan(
&i.Path,
&i.Signing,
&i.Secret,
&i.CreatedAt,
&i.UpdatedAt,
&i.OrgID,
&i.WorkspaceID,
&i.Name,
&i.DeliveryHeader,
)
return i, err
}
const insertBinding = `-- name: InsertBinding :exec
INSERT INTO bindings (id, name, source, mapping, filter, workflow, owner, repo, version, status, inputs, repo_param, org_id, workspace_id)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, 1,
$9, $10, $11, $12,
COALESCE((SELECT s.workspace_id FROM sources s WHERE s.path = $3 AND s.org_id = $12), 'default'))
`
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
OrgID string
}
// A binding lives in its source's workspace.
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,
arg.OrgID,
)
return err
}
const insertBindingDispatch = `-- name: InsertBindingDispatch :execrows
INSERT INTO binding_dispatches (binding, binding_version, capture, task_id, reason, delivery)
SELECT $1, $2, c.id, $3, $4, c.delivery
FROM captures c WHERE c.id = $5
`
type InsertBindingDispatchParams struct {
Binding string
BindingVersion int64
TaskID int64
Reason string
Capture string
}
func (q *Queries) InsertBindingDispatch(ctx context.Context, arg InsertBindingDispatchParams) (int64, error) {
result, err := q.db.Exec(ctx, insertBindingDispatch,
arg.Binding,
arg.BindingVersion,
arg.TaskID,
arg.Reason,
arg.Capture,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const insertCapture = `-- name: InsertCapture :exec
INSERT INTO captures (id, source, remote_addr, content_type, headers, body, authenticated, received_at, unsigned, event_type, delivery, org_id, workspace_id)
SELECT $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11,
COALESCE(s.org_id, $12::text), COALESCE(s.workspace_id, $13::text)
FROM (SELECT 1) intake LEFT JOIN sources s ON s.path = $2
`
type InsertCaptureParams struct {
ID string
Source string
RemoteAddr string
ContentType string
Headers string
Body string
Authenticated bool
ReceivedAt time.Time
Unsigned bool
EventType string
Delivery string
DefaultOrg string
DefaultWorkspace 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,
arg.Delivery,
arg.DefaultOrg,
arg.DefaultWorkspace,
)
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, org_id, workspace_id)
VALUES ($1, $2, $3, $4, $5, $6,
COALESCE((SELECT s.workspace_id FROM sources s WHERE s.path = $2 AND s.org_id = $6), 'default'))
`
type InsertEventTypeParams struct {
ID string
Source string
Name string
Rule string
Schema string
OrgID string
}
// An event type lives in its source's workspace.
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,
arg.OrgID,
)
return err
}
const insertMapping = `-- name: InsertMapping :exec
INSERT INTO mappings (id, name, source_hint, event_type, fields, org_id, workspace_id)
VALUES ($1, $2, $3, $4, $5, $6,
COALESCE((SELECT y.workspace_id FROM event_types y WHERE y.id = $4 AND y.org_id = $6), 'default'))
`
type InsertMappingParams struct {
ID string
Name string
SourceHint string
EventType string
Fields string
OrgID string
}
// A mapping lives in its event type's workspace; one with no event type in
// the org's default workspace.
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,
arg.OrgID,
)
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 :execrows
INSERT INTO sources (path, signing, secret, org_id, workspace_id)
SELECT $1, $2, $3, w.org_id, w.id
FROM workspaces w WHERE w.org_id = $4 AND w.id = $5
`
type InsertSourceParams struct {
Path string
Signing string
Secret string
OrgID string
WorkspaceID string
}
// Inserts nothing when the workspace is not one of the org's.
func (q *Queries) InsertSource(ctx context.Context, arg InsertSourceParams) (int64, error) {
result, err := q.db.Exec(ctx, insertSource,
arg.Path,
arg.Signing,
arg.Secret,
arg.OrgID,
arg.WorkspaceID,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const insertToolCall = `-- name: InsertToolCall :exec
INSERT INTO tool_calls (id, task_id, attempt, tool, result, error, called_at, org_id, workspace_id)
SELECT $1, t.id, $2, $3, $4, $5, $6, t.org_id, t.workspace_id
FROM tasks t WHERE t.id = $7
`
type InsertToolCallParams struct {
ID string
Attempt int64
Tool string
Result string
Error string
CalledAt time.Time
TaskID int64
}
func (q *Queries) InsertToolCall(ctx context.Context, arg InsertToolCallParams) error {
_, err := q.db.Exec(ctx, insertToolCall,
arg.ID,
arg.Attempt,
arg.Tool,
arg.Result,
arg.Error,
arg.CalledAt,
arg.TaskID,
)
return err
}
const listBindingDispatches = `-- name: ListBindingDispatches :many
SELECT d.binding, d.binding_version, d.capture, d.task_id, d.reason, d.dispatched_at
FROM binding_dispatches d JOIN bindings b ON b.id = d.binding
WHERE ($1::text IS NULL OR b.org_id = $1)
AND ($2::text IS NULL OR d.binding = $2)
AND ($3::text IS NULL OR d.capture = $3)
AND ($4::bigint IS NULL OR d.task_id = $4)
ORDER BY d.dispatched_at DESC
LIMIT $5
`
type ListBindingDispatchesParams struct {
ScopeOrg pgtype.Text
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.ScopeOrg,
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, workspace_id
FROM bindings WHERE ($1::text IS NULL OR org_id = $1) 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
WorkspaceID string
}
func (q *Queries) ListBindings(ctx context.Context, scopeOrg pgtype.Text) ([]ListBindingsRow, error) {
rows, err := q.db.Query(ctx, listBindings, scopeOrg)
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,
&i.WorkspaceID,
); 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, delivery
FROM captures
WHERE org_id = $2
ORDER BY received_at DESC
LIMIT $1
`
type ListCapturesParams struct {
Limit int32
OrgID string
}
func (q *Queries) ListCaptures(ctx context.Context, arg ListCapturesParams) ([]Capture, error) {
rows, err := q.db.Query(ctx, listCaptures, arg.Limit, arg.OrgID)
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,
&i.Delivery,
); 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 WHERE ($1::text IS NULL OR org_id = $1) ORDER BY source, name
`
func (q *Queries) ListEventTypes(ctx context.Context, scopeOrg pgtype.Text) ([]EventType, error) {
rows, err := q.db.Query(ctx, listEventTypes, scopeOrg)
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 WHERE ($1::text IS NULL OR org_id = $1) ORDER BY created_at DESC
`
type ListMappingsRow struct {
Mapping Mapping
MatchCount int64
LastMatchedAt time.Time
}
func (q *Queries) ListMappings(ctx context.Context, scopeOrg pgtype.Text) ([]ListMappingsRow, error) {
rows, err := q.db.Query(ctx, listMappings, scopeOrg)
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, name, delivery_header FROM sources WHERE ($1::text IS NULL OR org_id = $1) ORDER BY created_at DESC, path
`
func (q *Queries) ListSources(ctx context.Context, scopeOrg pgtype.Text) ([]Source, error) {
rows, err := q.db.Query(ctx, listSources, scopeOrg)
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,
&i.Name,
&i.DeliveryHeader,
); 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, c.delivery
FROM captures c
WHERE c.org_id = $1
AND c.event_type <> ''
AND (c.authenticated OR c.unsigned)
AND EXISTS (
SELECT 1 FROM bindings b JOIN mappings m ON m.id = b.mapping
WHERE b.org_id = c.org_id AND b.source = c.source AND b.status = 'armed' AND m.event_type = c.event_type
AND b.id = ANY($2::text[])
AND NOT EXISTS (SELECT 1 FROM binding_dispatches d WHERE d.binding = b.id AND d.delivery = c.delivery)
)
ORDER BY c.received_at, c.id
LIMIT $3
`
type ListUndispatchedCapturesParams struct {
OrgID string
Bindings []string
EntryLimit int32
}
// Oldest first, so sustained intake cannot starve accepted work. Only
// dispatchable captures (signed, or from an approved unsigned source) that one
// of the named bindings still owes a dispatch are listed: no other capture
// would ever be dispatched, so it would hold the batch.
func (q *Queries) ListUndispatchedCaptures(ctx context.Context, arg ListUndispatchedCapturesParams) ([]Capture, error) {
rows, err := q.db.Query(ctx, listUndispatchedCaptures, arg.OrgID, arg.Bindings, 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,
&i.Delivery,
); 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 AND ($2::text IS NULL OR org_id = $2)
`
type SetBindingArmedParams struct {
ID string
ScopeOrg pgtype.Text
}
func (q *Queries) SetBindingArmed(ctx context.Context, arg SetBindingArmedParams) (int64, error) {
result, err := q.db.Exec(ctx, setBindingArmed, arg.ID, arg.ScopeOrg)
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 setSourceDeliveryHeader = `-- name: SetSourceDeliveryHeader :execrows
UPDATE sources SET delivery_header = $1, updated_at = now() WHERE path = $2 AND ($3::text IS NULL OR org_id = $3)
`
type SetSourceDeliveryHeaderParams struct {
DeliveryHeader string
Path string
ScopeOrg pgtype.Text
}
func (q *Queries) SetSourceDeliveryHeader(ctx context.Context, arg SetSourceDeliveryHeaderParams) (int64, error) {
result, err := q.db.Exec(ctx, setSourceDeliveryHeader, arg.DeliveryHeader, arg.Path, arg.ScopeOrg)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const setSourceName = `-- name: SetSourceName :execrows
UPDATE sources SET name = $1, updated_at = now() WHERE path = $2 AND ($3::text IS NULL OR org_id = $3)
`
type SetSourceNameParams struct {
Name string
Path string
ScopeOrg pgtype.Text
}
func (q *Queries) SetSourceName(ctx context.Context, arg SetSourceNameParams) (int64, error) {
result, err := q.db.Exec(ctx, setSourceName, arg.Name, arg.Path, arg.ScopeOrg)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const setSourceSecret = `-- name: SetSourceSecret :execrows
UPDATE sources SET secret = $1, updated_at = now() WHERE path = $2 AND ($3::text IS NULL OR org_id = $3)
`
type SetSourceSecretParams struct {
Secret string
Path string
ScopeOrg pgtype.Text
}
func (q *Queries) SetSourceSecret(ctx context.Context, arg SetSourceSecretParams) (int64, error) {
result, err := q.db.Exec(ctx, setSourceSecret, arg.Secret, arg.Path, arg.ScopeOrg)
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 AND ($4::text IS NULL OR org_id = $4)
`
type SetSourceSigningParams struct {
ToSigning string
Path string
FromSigning string
ScopeOrg pgtype.Text
}
func (q *Queries) SetSourceSigning(ctx context.Context, arg SetSourceSigningParams) (int64, error) {
result, err := q.db.Exec(ctx, setSourceSigning,
arg.ToSigning,
arg.Path,
arg.FromSigning,
arg.ScopeOrg,
)
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 AND ($2::text IS NULL OR org_id = $2) ORDER BY called_at ASC
`
type TaskToolCallsParams struct {
TaskID int64
ScopeOrg pgtype.Text
}
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, arg TaskToolCallsParams) ([]TaskToolCallsRow, error) {
rows, err := q.db.Query(ctx, taskToolCalls, arg.TaskID, arg.ScopeOrg)
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 transitionBindingStatus = `-- name: TransitionBindingStatus :execrows
UPDATE bindings SET status = $1, updated_at = now()
WHERE id = $2 AND status = $3 AND ($4::text IS NULL OR org_id = $4)
`
type TransitionBindingStatusParams struct {
ToStatus string
ID string
FromStatus string
ScopeOrg pgtype.Text
}
func (q *Queries) TransitionBindingStatus(ctx context.Context, arg TransitionBindingStatusParams) (int64, error) {
result, err := q.db.Exec(ctx, transitionBindingStatus,
arg.ToStatus,
arg.ID,
arg.FromStatus,
arg.ScopeOrg,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const updateBinding = `-- name: UpdateBinding :execrows
UPDATE bindings
SET name = $1, source = $2, mapping = $3, filter = $4,
workflow = $5, owner = $6, repo = $7,
version = version + 1, status = $8, inputs = $9, repo_param = $10, updated_at = now(),
workspace_id = COALESCE((SELECT s.workspace_id FROM sources s WHERE s.path = $2 AND s.org_id = bindings.org_id), 'default')
WHERE bindings.id = $11 AND ($12::text IS NULL OR bindings.org_id = $12)
`
type UpdateBindingParams struct {
Name string
Source string
Mapping string
Filter string
Workflow string
Owner string
Repo string
Status string
Inputs string
RepoParam string
ID string
ScopeOrg pgtype.Text
}
func (q *Queries) UpdateBinding(ctx context.Context, arg UpdateBindingParams) (int64, error) {
result, err := q.db.Exec(ctx, updateBinding,
arg.Name,
arg.Source,
arg.Mapping,
arg.Filter,
arg.Workflow,
arg.Owner,
arg.Repo,
arg.Status,
arg.Inputs,
arg.RepoParam,
arg.ID,
arg.ScopeOrg,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const updateEventType = `-- name: UpdateEventType :execrows
UPDATE event_types SET name = $1, rule = $2, updated_at = now()
WHERE id = $3 AND ($4::text IS NULL OR org_id = $4)
`
type UpdateEventTypeParams struct {
Name string
Rule string
ID string
ScopeOrg pgtype.Text
}
func (q *Queries) UpdateEventType(ctx context.Context, arg UpdateEventTypeParams) (int64, error) {
result, err := q.db.Exec(ctx, updateEventType,
arg.Name,
arg.Rule,
arg.ID,
arg.ScopeOrg,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}
const updateMapping = `-- name: UpdateMapping :execrows
UPDATE mappings
SET name = $1, source_hint = $2, event_type = $3, fields = $4, updated_at = now(),
workspace_id = COALESCE((SELECT y.workspace_id FROM event_types y WHERE y.id = $3 AND y.org_id = mappings.org_id), 'default')
WHERE mappings.id = $5 AND ($6::text IS NULL OR mappings.org_id = $6)
`
type UpdateMappingParams struct {
Name string
SourceHint string
EventType string
Fields string
ID string
ScopeOrg pgtype.Text
}
func (q *Queries) UpdateMapping(ctx context.Context, arg UpdateMappingParams) (int64, error) {
result, err := q.db.Exec(ctx, updateMapping,
arg.Name,
arg.SourceHint,
arg.EventType,
arg.Fields,
arg.ID,
arg.ScopeOrg,
)
if err != nil {
return 0, err
}
return result.RowsAffected(), nil
}