lopata 0.7.0 → 0.8.2

package/src/bindings/durable-object.ts

@@ -1,6 +1,8 @@
 import { Database, type SQLQueryBindings } from 'bun:sqlite'
 import { existsSync, mkdirSync, rmSync, statSync } from 'node:fs'
 import { join } from 'node:path'
+import type { Clock } from '../testing/clock'
+import { realClock } from '../testing/clock'
 import { persistError, startSpan } from '../tracing/span'
 import type { ContainerContext } from './container'
 import type { ContainerConfig } from './container'
@@ -84,20 +86,23 @@ export class SqlStorageCursor implements Iterable<Record<string, unknown>> {
 // --- SQL Storage API ---
 
 export class SqlStorage {
-	private _dbPath: string
+	private _dbPath: string | null
 	private _db: Database | null = null
 
-	constructor(dbPath: string) {
+	constructor(dbPath: string | null) {
 		this._dbPath = dbPath
 	}
 
 	private _getDb(): Database {
 		if (!this._db) {
-			// Ensure parent directory exists
-			const dir = this._dbPath.substring(0, this._dbPath.lastIndexOf('/'))
-			mkdirSync(dir, { recursive: true })
-			this._db = new Database(this._dbPath, { create: true })
-			this._db.run('PRAGMA journal_mode=WAL')
+			if (this._dbPath) {
+				const dir = this._dbPath.substring(0, this._dbPath.lastIndexOf('/'))
+				mkdirSync(dir, { recursive: true })
+				this._db = new Database(this._dbPath, { create: true })
+				this._db.run('PRAGMA journal_mode=WAL')
+			} else {
+				this._db = new Database(':memory:')
+			}
 		}
 		return this._db
 	}
@@ -123,6 +128,11 @@ export class SqlStorage {
 	}
 
 	get databaseSize(): number {
+		if (!this._dbPath) {
+			const db = this._getDb()
+			const row = db.query('SELECT page_count * page_size as size FROM pragma_page_count(), pragma_page_size()').get() as { size: number } | null
+			return row?.size ?? 0
+		}
 		try {
 			return statSync(this._dbPath).size
 		} catch {
@@ -273,10 +283,9 @@ export class SqliteDurableObjectStorage {
 
 	get sql(): SqlStorage {
 		if (!this._sql) {
-			if (!this._dataDir) {
-				throw new Error('SQL storage not available: dataDir not configured')
-			}
-			const dbPath = join(this._dataDir, 'do-sql', this.namespace, `${this.id}.sqlite`)
+			const dbPath = this._dataDir
+				? join(this._dataDir, 'do-sql', this.namespace, `${this.id}.sqlite`)
+				: null
 			this._sql = new SqlStorage(dbPath)
 		}
 		return this._sql
@@ -740,14 +749,17 @@ export class DurableObjectNamespaceImpl {
 	private _containerConfig?: ContainerConfig
 	private _factoryOverride?: DOExecutorFactory
 	private _defaultFactory?: DOExecutorFactory
+	private _generationId?: number
+	private clock: Clock
 
-	constructor(db: Database, namespaceName: string, dataDir?: string, limits?: DurableObjectLimits, factory?: DOExecutorFactory) {
+	constructor(db: Database, namespaceName: string, dataDir?: string, limits?: DurableObjectLimits, factory?: DOExecutorFactory, clock?: Clock) {
 		this.db = db
 		this.namespaceName = namespaceName
 		this.dataDir = dataDir
 		this.limits = limits
 		this._factoryOverride = factory
 		this._evictionTimeoutMs = limits?.evictionTimeoutMs ?? 120_000
+		this.clock = clock ?? realClock
 		if (this._evictionTimeoutMs > 0) {
 			this._evictionTimer = setInterval(() => this._evictIdle(), 30_000)
 		}
@@ -763,9 +775,19 @@ export class DurableObjectNamespaceImpl {
 	}
 
 	/** Called after worker module is loaded to wire the actual class */
-	_setClass(cls: new(ctx: DurableObjectStateImpl, env: unknown) => DurableObjectBase, env: unknown) {
+	_setClass(cls: new(ctx: DurableObjectStateImpl, env: unknown) => DurableObjectBase, env: unknown, generationId?: number) {
+		// Dispose existing executors so next request creates new ones with the new class
+		for (const [idStr, executor] of this._executors) {
+			if (executor.activeWebSocketCount() === 0) {
+				executor.dispose().catch(() => {})
+				this._executors.delete(idStr)
+				this._lastActivity.delete(idStr)
+			}
+		}
+
 		this._class = cls
 		this._env = env
+		this._generationId = generationId
 		// Restore persisted alarms on startup
 		this._restoreAlarms()
 	}
@@ -791,7 +813,7 @@ export class DurableObjectNamespaceImpl {
 		const existing = this.alarmTimers.get(idStr)
 		if (existing) clearTimeout(existing)
 
-		const delay = Math.max(0, scheduledTime - Date.now())
+		const delay = Math.max(0, scheduledTime - this.clock.now())
 		const timer = setTimeout(() => {
 			this.alarmTimers.delete(idStr)
 			this._fireAlarm(idStr, 0)
@@ -804,7 +826,7 @@ export class DurableObjectNamespaceImpl {
 		const executor = this._getOrCreateExecutor(idStr)
 		if (!executor) return
 
-		this._lastActivity.set(idStr, Date.now())
+		this._lastActivity.set(idStr, this.clock.now())
 
 		// Delete alarm from DB before calling handler (matching CF behavior)
 		this.db
@@ -819,6 +841,7 @@ export class DurableObjectNamespaceImpl {
 					'do.namespace': this.namespaceName,
 					'do.id': idStr,
 					'do.alarm.retryCount': retryCount,
+					...(this._generationId != null ? { 'lopata.generation_id': this._generationId } : {}),
 				},
 			}, () => executor.executeAlarm(retryCount))
 		} catch (e) {
@@ -826,7 +849,7 @@ export class DurableObjectNamespaceImpl {
 			if (retryCount < MAX_ALARM_RETRIES) {
 				// Exponential backoff: 1s, 2s, 4s, 8s, 16s, 32s
 				const backoffMs = Math.pow(2, retryCount) * 1000
-				const retryTime = Date.now() + backoffMs
+				const retryTime = this.clock.now() + backoffMs
 				// Re-persist alarm for retry
 				this.db
 					.query('INSERT OR REPLACE INTO do_alarms (namespace, id, alarm_time) VALUES (?, ?, ?)')
@@ -876,13 +899,13 @@ export class DurableObjectNamespaceImpl {
 		})
 
 		this._executors.set(idStr, executor)
-		this._lastActivity.set(idStr, Date.now())
+		this._lastActivity.set(idStr, this.clock.now())
 		return executor
 	}
 
 	/** @internal Evict idle executors */
 	private _evictIdle() {
-		const now = Date.now()
+		const now = this.clock.now()
 		for (const [idStr, lastActivity] of this._lastActivity) {
 			const executor = this._executors.get(idStr)
 			if (!executor) continue
@@ -944,6 +967,23 @@ export class DurableObjectNamespaceImpl {
 		return this._executors.get(idStr) ?? null
 	}
 
+	/** @internal List active executors with their WebSocket counts */
+	_listActiveExecutors(): Array<{ id: string; wsCount: number }> {
+		const result: Array<{ id: string; wsCount: number }> = []
+		for (const [id, executor] of this._executors) {
+			result.push({ id, wsCount: executor.activeWebSocketCount() })
+		}
+		return result
+	}
+
+	/** @internal List all instance IDs in this namespace (from DB). */
+	_listInstanceIds(): string[] {
+		const rows = this.db
+			.query('SELECT id FROM do_instances WHERE namespace = ? ORDER BY created_at ASC')
+			.all(this.namespaceName) as { id: string }[]
+		return rows.map(r => r.id)
+	}
+
 	/** Whether the DO class defines an alarm() handler */
 	hasAlarmHandler(): boolean {
 		return typeof this._class?.prototype?.alarm === 'function'
@@ -958,6 +998,25 @@ export class DurableObjectNamespaceImpl {
 		return this._fireAlarm(idStr, 0)
 	}
 
+	/** @internal Fire all alarms whose scheduled time is <= clock.now(). Returns an array of promises. */
+	_fireReadyAlarms(): Promise<void>[] {
+		const now = this.clock.now()
+		const rows = this.db
+			.query('SELECT id, alarm_time FROM do_alarms WHERE namespace = ?')
+			.all(this.namespaceName) as { id: string; alarm_time: number }[]
+		const results: Promise<void>[] = []
+		for (const row of rows) {
+			if (row.alarm_time <= now) {
+				// Cancel the existing setTimeout timer
+				const existing = this.alarmTimers.get(row.id)
+				if (existing) clearTimeout(existing)
+				this.alarmTimers.delete(row.id)
+				results.push(this._fireAlarm(row.id, 0))
+			}
+		}
+		return results
+	}
+
 	/** @internal Cancel a scheduled alarm without firing it */
 	cancelAlarm(idStr: string): void {
 		const timer = this.alarmTimers.get(idStr)
@@ -1058,7 +1117,7 @@ export class DurableObjectNamespaceImpl {
 				if (prop === 'fetch') {
 					return async (input: Request | string | URL, init?: RequestInit) => {
 						const executor = self._getOrCreateExecutor(idStr, id)!
-						self._lastActivity.set(idStr, Date.now())
+						self._lastActivity.set(idStr, self.clock.now())
 						const request = input instanceof Request ? input : new Request(input instanceof URL ? input.href : input, init)
 						return await executor.executeFetch(request)
 					}
@@ -1067,7 +1126,7 @@ export class DurableObjectNamespaceImpl {
 				// RPC: return a callable that also acts as a thenable for property access
 				const rpcCallable = (...args: unknown[]) => {
 					const executor = self._getOrCreateExecutor(idStr, id)!
-					self._lastActivity.set(idStr, Date.now())
+					self._lastActivity.set(idStr, self.clock.now())
 					return executor.executeRpc(String(prop), args)
 				}
 
@@ -1077,7 +1136,7 @@ export class DurableObjectNamespaceImpl {
 					onRejected?: ((reason: unknown) => unknown) | null,
 				) => {
 					const executor = self._getOrCreateExecutor(idStr, id)!
-					self._lastActivity.set(idStr, Date.now())
+					self._lastActivity.set(idStr, self.clock.now())
 					const promise = executor.executeRpcGet(String(prop))
 					return promise.then(onFulfilled, onRejected)
 				}

package/src/bindings/kv.ts

@@ -1,4 +1,6 @@
 import type { Database } from 'bun:sqlite'
+import type { Clock } from '../testing/clock'
+import { realClock } from '../testing/clock'
 
 export interface KVLimits {
 	maxKeySize?: number // default 512 (bytes)
@@ -22,11 +24,13 @@ export class SqliteKVNamespace {
 	private db: Database
 	private namespace: string
 	private limits: Required<KVLimits>
+	private clock: Clock
 
-	constructor(db: Database, namespace: string, limits?: KVLimits) {
+	constructor(db: Database, namespace: string, limits?: KVLimits, clock?: Clock) {
 		this.db = db
 		this.namespace = namespace
 		this.limits = { ...KV_DEFAULTS, ...limits }
+		this.clock = clock ?? realClock
 	}
 
 	private validateKey(key: string): void {
@@ -76,7 +80,7 @@ export class SqliteKVNamespace {
 
 		if (!row) return null
 
-		if (row.expiration && row.expiration < Date.now() / 1000) {
+		if (row.expiration && row.expiration < this.clock.now() / 1000) {
 			this.db.run('DELETE FROM kv WHERE namespace = ? AND key = ?', [this.namespace, keyOrKeys])
 			return null
 		}
@@ -101,7 +105,7 @@ export class SqliteKVNamespace {
 		if (type === 'arrayBuffer' || type === 'stream') {
 			throw new Error(`KV bulk get does not support type "${type}"`)
 		}
-		const now = Date.now() / 1000
+		const now = this.clock.now() / 1000
 
 		if (keys.length === 0) return result
 
@@ -157,7 +161,7 @@ export class SqliteKVNamespace {
 
 		if (!row) return { value: null, metadata: null, cacheStatus: null }
 
-		if (row.expiration && row.expiration < Date.now() / 1000) {
+		if (row.expiration && row.expiration < this.clock.now() / 1000) {
 			this.db.run('DELETE FROM kv WHERE namespace = ? AND key = ?', [this.namespace, keyOrKeys])
 			return { value: null, metadata: null, cacheStatus: null }
 		}
@@ -184,7 +188,7 @@ export class SqliteKVNamespace {
 		if (type === 'arrayBuffer' || type === 'stream') {
 			throw new Error(`KV bulk get does not support type "${type}"`)
 		}
-		const now = Date.now() / 1000
+		const now = this.clock.now() / 1000
 
 		if (keys.length === 0) return result
 
@@ -233,7 +237,7 @@ export class SqliteKVNamespace {
 			this.validateTtl(options.expirationTtl)
 		}
 		if (options?.expiration !== undefined) {
-			const minExpiration = Date.now() / 1000 + this.limits.minTtlSeconds
+			const minExpiration = this.clock.now() / 1000 + this.limits.minTtlSeconds
 			if (options.expiration < minExpiration) {
 				throw new Error(`KV expiration must be at least ${this.limits.minTtlSeconds} seconds in the future`)
 			}
@@ -241,7 +245,7 @@ export class SqliteKVNamespace {
 
 		let expiration: number | null = null
 		if (options?.expiration) expiration = options.expiration
-		else if (options?.expirationTtl) expiration = Date.now() / 1000 + options.expirationTtl
+		else if (options?.expirationTtl) expiration = this.clock.now() / 1000 + options.expirationTtl
 
 		let metadata: string | null = null
 		if (options?.metadata !== undefined) {
@@ -263,7 +267,7 @@ export class SqliteKVNamespace {
 		const limit = Math.min(options?.limit ?? 1000, 1000)
 		const cursor = options?.cursor ?? ''
 
-		const now = Date.now() / 1000
+		const now = this.clock.now() / 1000
 
 		// Lazily delete expired entries for this namespace
 		this.db.run(

package/src/bindings/queue.ts

@@ -2,6 +2,8 @@ import { randomUUIDv7 } from 'bun'
 import type { Database } from 'bun:sqlite'
 import crypto from 'node:crypto'
 import { ExecutionContext } from '../execution-context'
+import type { Clock } from '../testing/clock'
+import { realClock } from '../testing/clock'
 import { persistError, startSpan } from '../tracing/span'
 
 // --- Types ---
@@ -108,12 +110,14 @@ export class SqliteQueueProducer {
 	private queueName: string
 	private defaultDelay: number
 	private limits: Required<QueueLimits>
+	private clock: Clock
 
-	constructor(db: Database, queueName: string, defaultDelay: number = 0, limits?: QueueLimits) {
+	constructor(db: Database, queueName: string, defaultDelay: number = 0, limits?: QueueLimits, clock?: Clock) {
 		this.db = db
 		this.queueName = queueName
 		this.defaultDelay = defaultDelay
 		this.limits = { ...QUEUE_DEFAULTS, ...limits }
+		this.clock = clock ?? realClock
 	}
 
 	async send(message: unknown, options?: SendOptions): Promise<void> {
@@ -130,7 +134,7 @@ export class SqliteQueueProducer {
 			throw new Error(`Message exceeds max size of ${this.limits.maxMessageSize} bytes`)
 		}
 
-		const now = Date.now()
+		const now = this.clock.now()
 		const visibleAt = now + delaySeconds * 1000
 
 		this.db.run(
@@ -147,7 +151,7 @@ export class SqliteQueueProducer {
 		const stmt = this.db.prepare(
 			'INSERT INTO queue_messages (id, queue, body, content_type, attempts, visible_at, created_at) VALUES (?, ?, ?, ?, 0, ?, ?)',
 		)
-		const now = Date.now()
+		const now = this.clock.now()
 
 		// Pre-encode all messages and validate total size
 		const encoded: { data: Uint8Array; contentType: string; delaySeconds: number }[] = []
@@ -199,18 +203,22 @@ export class QueueConsumer {
 	private polling = false
 	private _activeDeliveries = 0
 
+	private clock: Clock
+
 	constructor(
 		db: Database,
 		config: ConsumerConfig,
 		handler: QueueHandler,
 		env: Record<string, unknown>,
 		workerName?: string,
+		clock?: Clock,
 	) {
 		this.db = db
 		this.config = config
 		this.handler = handler
 		this.env = env
 		this.workerName = workerName
+		this.clock = clock ?? realClock
 	}
 
 	start(intervalMs: number = 1000): void {
@@ -237,7 +245,7 @@ export class QueueConsumer {
 		if (this.config.maxConcurrency && this._activeDeliveries >= this.config.maxConcurrency) return
 		this.polling = true
 		try {
-			const now = Date.now()
+			const now = this.clock.now()
 
 			// Periodically clean up completed messages beyond retention period
 			const retentionMs = (this.config.retentionPeriodSeconds ?? 345600) * 1000
@@ -343,7 +351,7 @@ export class QueueConsumer {
 
 			if (!decision || decision.type === 'ack') {
 				// Ack (explicit or default) — mark as acked
-				this.db.run("UPDATE queue_messages SET status = 'acked', completed_at = ? WHERE id = ?", [Date.now(), row.id])
+				this.db.run("UPDATE queue_messages SET status = 'acked', completed_at = ? WHERE id = ?", [this.clock.now(), row.id])
 			} else {
 				// Retry
 				const delay = decision.delaySeconds ?? this.config.retryDelay ?? 0
@@ -352,17 +360,17 @@ export class QueueConsumer {
 					if (this.config.deadLetterQueue) {
 						this.db.run(
 							"UPDATE queue_messages SET queue = ?, visible_at = ?, status = 'pending' WHERE id = ?",
-							[this.config.deadLetterQueue, Date.now(), row.id],
+							[this.config.deadLetterQueue, this.clock.now(), row.id],
 						)
 					} else {
 						console.warn(`[lopata] Queue message ${row.id} exceeded max retries (${this.config.maxRetries}), discarding`)
-						this.db.run("UPDATE queue_messages SET status = 'failed', completed_at = ? WHERE id = ?", [Date.now(), row.id])
+						this.db.run("UPDATE queue_messages SET status = 'failed', completed_at = ? WHERE id = ?", [this.clock.now(), row.id])
 					}
 				} else {
 					// Retry with delay
 					this.db.run(
 						'UPDATE queue_messages SET visible_at = ? WHERE id = ?',
-						[Date.now() + delay * 1000, row.id],
+						[this.clock.now() + delay * 1000, row.id],
 					)
 				}
 			}
@@ -400,16 +408,18 @@ const DEFAULT_PULL_BATCH_SIZE = 10
 export class QueuePullConsumer {
 	private db: Database
 	private queueName: string
+	private clock: Clock
 
-	constructor(db: Database, queueName: string) {
+	constructor(db: Database, queueName: string, clock?: Clock) {
 		this.db = db
 		this.queueName = queueName
+		this.clock = clock ?? realClock
 	}
 
 	pull(options?: PullRequest): PullResponse {
 		const batchSize = options?.batch_size ?? DEFAULT_PULL_BATCH_SIZE
 		const visibilityTimeoutMs = options?.visibility_timeout_ms ?? DEFAULT_VISIBILITY_TIMEOUT_MS
-		const now = Date.now()
+		const now = this.clock.now()
 
 		// Clean up expired leases — make messages visible again
 		this.db.run(
@@ -472,7 +482,7 @@ export class QueuePullConsumer {
 	ack(request: AckRequest): { acked: number; retried: number } {
 		let acked = 0
 		let retried = 0
-		const now = Date.now()
+		const now = this.clock.now()
 
 		const tx = this.db.transaction(() => {
 			// Process acks
@@ -487,7 +497,7 @@ export class QueuePullConsumer {
 					).get(lease_id, this.queueName, now)
 
 					if (lease) {
-						this.db.run("UPDATE queue_messages SET status = 'acked', completed_at = ? WHERE id = ?", [Date.now(), lease.message_id])
+						this.db.run("UPDATE queue_messages SET status = 'acked', completed_at = ? WHERE id = ?", [this.clock.now(), lease.message_id])
 						this.db.run('DELETE FROM queue_leases WHERE lease_id = ?', [lease_id])
 						acked++
 					}