queries.sql_sqlc.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: queries.sql

package main

import (
	"context"
	"database/sql"
)

const countInbox = `-- name: CountInbox :one
SELECT count(*) FROM inbox
`

func (q *Queries) CountInbox(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, countInbox)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const countOutbox = `-- name: CountOutbox :one
SELECT count(*) FROM sent_messages WHERE conversation_id = ?
`

func (q *Queries) CountOutbox(ctx context.Context, conversationID string) (int64, error) {
	row := q.db.QueryRowContext(ctx, countOutbox, conversationID)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const deleteInboxItem = `-- name: DeleteInboxItem :exec
DELETE FROM inbox WHERE id = ?
`

func (q *Queries) DeleteInboxItem(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deleteInboxItem, id)
	return err
}

const deleteOldestOutbox = `-- name: DeleteOldestOutbox :exec
DELETE FROM sent_messages
WHERE rowid IN (
    SELECT sm.rowid FROM sent_messages sm
    WHERE sm.conversation_id = ?
    ORDER BY sm.rowid ASC
    LIMIT ?
)
`

type DeleteOldestOutboxParams struct {
	ConversationID string
	Limit          int64
}

func (q *Queries) DeleteOldestOutbox(ctx context.Context, arg DeleteOldestOutboxParams) error {
	_, err := q.db.ExecContext(ctx, deleteOldestOutbox, arg.ConversationID, arg.Limit)
	return err
}

const deleteStaleItems = `-- name: DeleteStaleItems :exec
DELETE FROM inbox WHERE source IN ('heartbeat', 'compact')
`

func (q *Queries) DeleteStaleItems(ctx context.Context) error {
	_, err := q.db.ExecContext(ctx, deleteStaleItems)
	return err
}

const dequeueInbox = `-- name: DequeueInbox :one
DELETE FROM inbox
WHERE id = (
    SELECT id FROM inbox
    ORDER BY priority ASC, id ASC
    LIMIT 1
)
RETURNING id, priority, source, content, reply_to, created_at
`

func (q *Queries) DequeueInbox(ctx context.Context) (Inbox, error) {
	row := q.db.QueryRowContext(ctx, dequeueInbox)
	var i Inbox
	err := row.Scan(
		&i.ID,
		&i.Priority,
		&i.Source,
		&i.Content,
		&i.ReplyTo,
		&i.CreatedAt,
	)
	return i, err
}

const dequeueUserItems = `-- name: DequeueUserItems :many
DELETE FROM inbox
WHERE source = 'user'
RETURNING id, priority, source, content, reply_to, created_at
`

func (q *Queries) DequeueUserItems(ctx context.Context) ([]Inbox, error) {
	rows, err := q.db.QueryContext(ctx, dequeueUserItems)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Inbox
	for rows.Next() {
		var i Inbox
		if err := rows.Scan(
			&i.ID,
			&i.Priority,
			&i.Source,
			&i.Content,
			&i.ReplyTo,
			&i.CreatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const dueReminders = `-- name: DueReminders :many
DELETE FROM reminders
WHERE datetime(fire_at) <= datetime(?)
RETURNING id, fire_at, prompt
`

// datetime() normalizes ISO 8601 variants (Z vs +00:00, T vs space) so
// lexicographic comparison doesn't break on agent-formatted timestamps.
func (q *Queries) DueReminders(ctx context.Context, datetime interface{}) ([]Reminders, error) {
	rows, err := q.db.QueryContext(ctx, dueReminders, datetime)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Reminders
	for rows.Next() {
		var i Reminders
		if err := rows.Scan(&i.ID, &i.FireAt, &i.Prompt); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const enqueueHeartbeatIfEmpty = `-- name: EnqueueHeartbeatIfEmpty :execresult
INSERT INTO inbox (priority, source, content, reply_to)
SELECT ?, 'heartbeat', '', ''
WHERE NOT EXISTS (SELECT 1 FROM inbox WHERE source = 'heartbeat')
`

func (q *Queries) EnqueueHeartbeatIfEmpty(ctx context.Context, priority int64) (sql.Result, error) {
	return q.db.ExecContext(ctx, enqueueHeartbeatIfEmpty, priority)
}

const enqueueInbox = `-- name: EnqueueInbox :exec
INSERT INTO inbox (priority, source, content, reply_to)
VALUES (?, ?, ?, ?)
`

type EnqueueInboxParams struct {
	Priority int64
	Source   string
	Content  string
	ReplyTo  string
}

func (q *Queries) EnqueueInbox(ctx context.Context, arg EnqueueInboxParams) error {
	_, err := q.db.ExecContext(ctx, enqueueInbox,
		arg.Priority,
		arg.Source,
		arg.Content,
		arg.ReplyTo,
	)
	return err
}

const getOutbox = `-- name: GetOutbox :one
SELECT text FROM sent_messages
WHERE conversation_id = ? AND message_id = ?
`

type GetOutboxParams struct {
	ConversationID string
	MessageID      string
}

func (q *Queries) GetOutbox(ctx context.Context, arg GetOutboxParams) (string, error) {
	row := q.db.QueryRowContext(ctx, getOutbox, arg.ConversationID, arg.MessageID)
	var text string
	err := row.Scan(&text)
	return text, err
}

const insertReminder = `-- name: InsertReminder :exec
INSERT INTO reminders (fire_at, prompt) VALUES (?, ?)
`

type InsertReminderParams struct {
	FireAt string
	Prompt string
}

func (q *Queries) InsertReminder(ctx context.Context, arg InsertReminderParams) error {
	_, err := q.db.ExecContext(ctx, insertReminder, arg.FireAt, arg.Prompt)
	return err
}

const peekInbox = `-- name: PeekInbox :one
SELECT id, priority, source, content, reply_to, created_at
FROM inbox
ORDER BY priority ASC, id ASC
LIMIT 1
`

func (q *Queries) PeekInbox(ctx context.Context) (Inbox, error) {
	row := q.db.QueryRowContext(ctx, peekInbox)
	var i Inbox
	err := row.Scan(
		&i.ID,
		&i.Priority,
		&i.Source,
		&i.Content,
		&i.ReplyTo,
		&i.CreatedAt,
	)
	return i, err
}

const upsertOutbox = `-- name: UpsertOutbox :exec
INSERT INTO sent_messages (conversation_id, message_id, text)
VALUES (?, ?, ?)
ON CONFLICT(conversation_id, message_id) DO UPDATE SET text = excluded.text
`

type UpsertOutboxParams struct {
	ConversationID string
	MessageID      string
	Text           string
}

func (q *Queries) UpsertOutbox(ctx context.Context, arg UpsertOutboxParams) error {
	_, err := q.db.ExecContext(ctx, upsertOutbox, arg.ConversationID, arg.MessageID, arg.Text)
	return err
}