Skip to content
← Public packages

@kentcdodds/quiet-hours

Quiet hours for Kent's bots: 10 PM to 8 AM MT (DST-aware) clock, shared overnight queue, override, and the 8 AM digest of finished work and open decisions.

FollowFork

Files

store.ts

163 lines · 4.5 KB · TypeScript
import { packageStorage } from 'kody:runtime'
import type { ItemKind, Priority, QueueItem, QuietOverride } from './types.ts'

type SqlValue = string | number | null
type SqlResult = { rows?: Array<Record<string, SqlValue>> }

async function sql(query: string, bindings: Array<SqlValue> = []): Promise<SqlResult> {
	return (await packageStorage().sql(query, bindings)) as SqlResult
}

let schemaReady: Promise<void> | null = null

/** Create tables once per isolate. */
export function ensureSchema(): Promise<void> {
	if (!schemaReady) {
		schemaReady = (async () => {
			await sql(`CREATE TABLE IF NOT EXISTS quiet_items (
				id TEXT PRIMARY KEY,
				created_at TEXT NOT NULL,
				bot TEXT NOT NULL,
				kind TEXT NOT NULL,
				priority TEXT NOT NULL,
				title TEXT NOT NULL,
				link TEXT,
				detail TEXT,
				deadline TEXT,
				delivered_at TEXT,
				digest_id TEXT,
				waiting_on_me TEXT
			)`)
			await sql(
				'CREATE INDEX IF NOT EXISTS quiet_items_undelivered ON quiet_items (delivered_at, created_at)',
			)
			await sql(`CREATE TABLE IF NOT EXISTS quiet_state (
				key TEXT PRIMARY KEY,
				value TEXT NOT NULL,
				updated_at TEXT NOT NULL
			)`)
		})().catch((error) => {
			schemaReady = null
			throw error
		})
	}
	return schemaReady
}

/** Test seam: forget the per-isolate schema cache. */
export function resetSchemaCacheForTests() {
	schemaReady = null
}

function str(value: SqlValue | undefined): string | null {
	return typeof value === 'string' && value ? value : null
}

function rowToItem(row: Record<string, SqlValue>): QueueItem {
	let waitingOnMe: QueueItem['waitingOnMe'] = null
	if (typeof row.waiting_on_me === 'string' && row.waiting_on_me) {
		try {
			waitingOnMe = JSON.parse(row.waiting_on_me)
		} catch {
			waitingOnMe = null
		}
	}
	return {
		id: String(row.id),
		createdAt: String(row.created_at),
		bot: String(row.bot),
		kind: String(row.kind) as ItemKind,
		priority: String(row.priority) as Priority,
		title: String(row.title),
		link: str(row.link),
		detail: str(row.detail),
		deadline: str(row.deadline),
		deliveredAt: str(row.delivered_at),
		digestId: str(row.digest_id),
		waitingOnMe,
	}
}

export async function insertItem(item: QueueItem): Promise<void> {
	await ensureSchema()
	await sql(
		`INSERT INTO quiet_items (id, created_at, bot, kind, priority, title, link, detail, deadline, delivered_at, digest_id, waiting_on_me)
		 VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, NULL, NULL, NULL)`,
		[
			item.id,
			item.createdAt,
			item.bot,
			item.kind,
			item.priority,
			item.title,
			item.link,
			item.detail,
			item.deadline,
		],
	)
}

export async function setWaitingOnMe(id: string, value: QueueItem['waitingOnMe']) {
	await ensureSchema()
	await sql('UPDATE quiet_items SET waiting_on_me = ? WHERE id = ?', [
		value ? JSON.stringify(value) : null,
		id,
	])
}

/** Items not yet delivered in a digest, oldest first. */
export async function listUndelivered(limit = 500): Promise<QueueItem[]> {
	await ensureSchema()
	const result = await sql(
		'SELECT * FROM quiet_items WHERE delivered_at IS NULL ORDER BY created_at ASC, id ASC LIMIT ?',
		[limit],
	)
	return (result.rows ?? []).map(rowToItem)
}

export async function markDelivered(ids: string[], digestId: string, at: string) {
	await ensureSchema()
	for (const id of ids) {
		await sql(
			'UPDATE quiet_items SET delivered_at = ?, digest_id = ? WHERE id = ? AND delivered_at IS NULL',
			[at, digestId, id],
		)
	}
}

export async function getState<T>(key: string): Promise<T | null> {
	await ensureSchema()
	const result = await sql('SELECT value FROM quiet_state WHERE key = ?', [key])
	const raw = result.rows?.[0]?.value
	if (typeof raw !== 'string') return null
	try {
		return JSON.parse(raw) as T
	} catch {
		return null
	}
}

export async function setState(key: string, value: unknown) {
	await ensureSchema()
	await sql(
		`INSERT INTO quiet_state (key, value, updated_at) VALUES (?, ?, ?)
		 ON CONFLICT(key) DO UPDATE SET value = excluded.value, updated_at = excluded.updated_at`,
		[key, JSON.stringify(value), new Date().toISOString()],
	)
}

export async function deleteState(key: string) {
	await ensureSchema()
	await sql('DELETE FROM quiet_state WHERE key = ?', [key])
}

export const OVERRIDE_KEY = 'override'
export const LAST_DIGEST_KEY = 'last-digest'
export const SETTINGS_KEY = 'settings'

export type LastDigest = { id: string; at: string; via: string; count: number }
export type Settings = { fallbackChannelId?: string }

export async function readOverride(): Promise<QuietOverride | null> {
	return getState<QuietOverride>(OVERRIDE_KEY)
}