// 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 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, mappings.built_in, (SELECT count(*) FROM mapping_matches mm WHERE mm.mapping = mappings.id AND ($1::text IS NULL OR EXISTS (SELECT 1 FROM captures c WHERE c.id = mm.capture AND c.org_id = $1)))::bigint AS match_count, COALESCE((SELECT max(mm.matched_at) FROM mapping_matches mm WHERE mm.mapping = mappings.id AND ($1::text IS NULL OR EXISTS (SELECT 1 FROM captures c WHERE c.id = mm.capture AND c.org_id = $1))), 'epoch')::timestamptz AS last_matched_at FROM mappings WHERE mappings.id = $2 AND ($1::text IS NULL OR mappings.org_id = $1 OR mappings.built_in) ` type GetMappingParams struct { ScopeOrg pgtype.Text ID string } 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.ScopeOrg, arg.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.Mapping.BuiltIn, &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, CASE WHEN $2 = 'schedule' AND $12::text <> '' THEN $12::text ELSE COALESCE(s.org_id, $13::text) END, COALESCE(s.workspace_id, $14::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 ScheduleOrg 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.ScheduleOrg, 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, mappings.built_in, (SELECT count(*) FROM mapping_matches mm WHERE mm.mapping = mappings.id AND ($1::text IS NULL OR EXISTS (SELECT 1 FROM captures c WHERE c.id = mm.capture AND c.org_id = $1)))::bigint AS match_count, COALESCE((SELECT max(mm.matched_at) FROM mapping_matches mm WHERE mm.mapping = mappings.id AND ($1::text IS NULL OR EXISTS (SELECT 1 FROM captures c WHERE c.id = mm.capture AND c.org_id = $1))), 'epoch')::timestamptz AS last_matched_at FROM mappings WHERE ($1::text IS NULL OR mappings.org_id = $1 OR mappings.built_in) 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.Mapping.BuiltIn, &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 sourceWorkspace = `-- name: SourceWorkspace :one SELECT workspace_id FROM sources WHERE path = $1 AND org_id = $2 ` type SourceWorkspaceParams struct { Path string OrgID string } // The workspace the binding/mapping SQL derives from a source path, so an // audit snapshots the same value the write stores. func (q *Queries) SourceWorkspace(ctx context.Context, arg SourceWorkspaceParams) (string, error) { row := q.db.QueryRow(ctx, sourceWorkspace, arg.Path, arg.OrgID) var workspace_id string err := row.Scan(&workspace_id) return workspace_id, 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 }