async-lube 2.0.0 → 2.1.0

package/src/durable/run.js

@@ -43,7 +43,9 @@ export async function cancel(d, key, reason) {
 	}
 	for (;;) {
 		const saved = await load(d.store, key)
-		if (!saved || saved.status == "cancelled" || saved.status == "done") return
+		if (!saved || saved.status == "cancelled" || saved.status == "done") {
+			return
+		}
 		const next = snapshot(saved)
 		delete next.inbox
 		next.error = saved_error(error)
@@ -65,18 +67,26 @@ export async function cancel(d, key, reason) {
 export async function enter(d, key, input, mode) {
 	if (mode != "join") {
 		const problem = json_problem(input)
-		if (problem) throw TypeError(
-			`The input of run "${key}" is not a JSON value: ${problem}`
-		)
+		if (problem) {
+			throw TypeError(
+				`The input of run "${key}" is not a JSON value: ${problem}`
+			)
+		}
 	}
 	for (;;) {
 		check_halted(d)
 		const running = d.live.get(key)
-		if (running) return mode == "start" ? false : follow(d, key, running.outcome)
+		if (running) {
+			return mode == "start" ? false : follow(d, key, running.outcome)
+		}
 		const saved = await load(d.store, key)
-		if (d.live.has(key)) continue
+		if (d.live.has(key)) {
+			continue
+		}
 		if (!saved) {
-			if (mode == "join") throw Error(`There is no run "${key}"`)
+			if (mode == "join") {
+				throw Error(`There is no run "${key}"`)
+			}
 			/** @type {SavedRun} */
 			const created = {
 				input: copy(input),
@@ -87,15 +97,25 @@ export async function enter(d, key, input, mode) {
 				status: "running",
 				version: 1
 			}
-			if (await d.store.put(key, created, void 0)) return launch(d, key, created, mode)
+			if (await d.store.put(key, created, void 0)) {
+				return launch(d, key, created, mode)
+			}
 			continue
 		}
-		if (mode == "start" && saved.status != "pending") return false
-		if (saved.status == "done") return saved.result
-		if (saved.status == "cancelled" || mode == "join" && saved.status == "failed") throw error_of(saved)
+		if (mode == "start" && saved.status != "pending") {
+			return false
+		}
+		if (saved.status == "done") {
+			return saved.result
+		}
+		if (saved.status == "cancelled" || mode == "join" && saved.status == "failed") {
+			throw error_of(saved)
+		}
 		if (mode != "join" && (saved.status == "failed" || saved.status == "pending") || is_due(d, saved)) {
 			const claimed = await claim(d, key, saved, input)
-			if (!claimed) continue
+			if (!claimed) {
+				continue
+			}
 			return launch(d, key, claimed, mode)
 		}
 		return outcome_of(d, key)
@@ -110,7 +130,8 @@ export async function enter(d, key, input, mode) {
 function execute(d, key, saved) {
 	/** @type {(reason: typeof LOST | typeof SUSPENDED | { cancel: unknown }) => void} */
 	let interrupt = noop
-	const interrupted = /** @type {Promise<typeof LOST | typeof SUSPENDED | { cancel: unknown }>} */(new Promise(resolve => interrupt = resolve))/**/
+	/** @type {Promise<typeof LOST | typeof SUSPENDED | { cancel: unknown }>} */
+	const interrupted = new Promise(resolve => interrupt = resolve)
 	/** @type {() => void} */
 	let leave = noop
 	/** @type {Promise<void>} */
@@ -147,17 +168,22 @@ function execute(d, key, saved) {
 	d.live.set(key, execution)
 	const renew = setInterval(
 		() => {
-			if (!execution.writing) void persist(d, execution)
-			else if (expiring(d, execution)) lose(
-				execution,
-				store_error(execution.fault)
-			)
+			if (!execution.writing) {
+				void persist(d, execution)
+			} else if (expiring(d, execution)) {
+				lose(
+					execution,
+					store_error(execution.fault)
+				)
+			}
 		},
 		d.renew_ms
 	)
 	execution.outcome = (async () => {
 		try {
-			if (saved.status == "failed") throw error_of(saved)
+			if (saved.status == "failed") {
+				throw error_of(saved)
+			}
 			const result = await Promise.race(
 				[
 					Promise.resolve()
@@ -171,42 +197,60 @@ function execute(d, key, saved) {
 					interrupted
 				]
 			)
-			if (result == LOST || result == SUSPENDED) return DETACHED
-			if ("cancel" in result) throw result.cancel
+			if (result == LOST || result == SUSPENDED) {
+				return DETACHED
+			}
+			if ("cancel" in result) {
+				throw result.cancel
+			}
 			const problem = json_problem(result.value)
-			if (problem) throw TypeError(
-				`The result of run "${key}" is not a JSON value: ${problem}`
-			)
+			if (problem) {
+				throw TypeError(
+					`The result of run "${key}" is not a JSON value: ${problem}`
+				)
+			}
 			execution.finished = true
 			saved.result = result.value
 			saved.status = "done"
 			unclaim(saved)
-			if (!await save(d, execution)) return DETACHED
+			if (!await save(d, execution)) {
+				return DETACHED
+			}
 			return { value: result.value }
 		} catch (error) {
-			if (execution.lost) return DETACHED
+			if (execution.lost) {
+				return DETACHED
+			}
 			execution.finished = true
 			if (saved.status != "cancelled") {
 				rewind(execution, error)
 				saved.error = saved_error(error)
 				saved.status = "failed"
 				unclaim(saved)
-				if (!await save(d, execution)) return DETACHED
+				if (!await save(d, execution)) {
+					return DETACHED
+				}
 			}
 			return { error }
 		} finally {
 			clearInterval(renew)
 			clearInterval(execution.inbox_timer)
 			for (const list of execution.waiters.values()) {
-				for (const waiter of list) waiter.clear()
+				for (const waiter of list) {
+					waiter.clear()
+				}
+			}
+			if (d.live.get(key) == execution) {
+				d.live.delete(key)
 			}
-			if (d.live.get(key) == execution) d.live.delete(key)
 			leave()
 		}
 	})()
 		.then(
 			outcome => {
-				if (!("detached" in outcome)) notify(d, key, outcome)
+				if (!("detached" in outcome)) {
+					notify(d, key, outcome)
+				}
 				return outcome
 			}
 		)
@@ -220,8 +264,12 @@ function execute(d, key, saved) {
  */
 async function follow(d, key, outcome) {
 	const settled = await outcome
-	if ("detached" in settled) return outcome_of(d, key)
-	if ("error" in settled) throw settled.error
+	if ("detached" in settled) {
+		return outcome_of(d, key)
+	}
+	if ("error" in settled) {
+		throw settled.error
+	}
 	return settled.value
 }
 /**
@@ -233,7 +281,9 @@ async function follow(d, key, outcome) {
  */
 function launch(d, key, saved, mode) {
 	const outcome = execute(d, key, saved)
-	if (mode != "start") return follow(d, key, outcome)
+	if (mode != "start") {
+		return follow(d, key, outcome)
+	}
 	void outcome.then(
 		settled => report(d, key, saved, settled)
 	)
@@ -247,8 +297,12 @@ function launch(d, key, saved, mode) {
  * @returns {void}
  */
 function report(d, key, saved, outcome) {
-	if (!("error" in outcome) || saved.status != "failed") return
-	for (const reporter of d.reporters) reporter(outcome.error, key)
+	if (!("error" in outcome) || saved.status != "failed") {
+		return
+	}
+	for (const reporter of d.reporters) {
+		reporter(outcome.error, key)
+	}
 }
 /**
  * @param {DurableWorker} d
@@ -256,12 +310,20 @@ function report(d, key, saved, outcome) {
  * @returns {Promise<void>}
  */
 export async function resume(d, key) {
-	if (d.halted || d.live.has(key)) return
+	if (d.halted || d.live.has(key)) {
+		return
+	}
 	const saved = await load(d.store, key)
-	if (!saved || d.live.has(key) || !is_due(d, saved)) return
-	if (d.halted) return
+	if (!saved || d.live.has(key) || !is_due(d, saved)) {
+		return
+	}
+	if (d.halted) {
+		return
+	}
 	const claimed = await claim(d, key, saved)
-	if (claimed && !d.live.has(key) && !d.halted) void execute(d, key, claimed).then(
-		outcome => report(d, key, claimed, outcome)
-	)
+	if (claimed && !d.live.has(key) && !d.halted) {
+		void execute(d, key, claimed).then(
+			outcome => report(d, key, claimed, outcome)
+		)
+	}
 }

package/src/durable/send.js

@@ -21,9 +21,11 @@ import { load } from "./store.js"
  */
 export async function send(d, key, name, value) {
 	const problem = value === void 0 ? "undefined" : json_problem(value)
-	if (problem) throw TypeError(
-		`The value sent to "${name}" of run "${key}" is not a JSON value: ${problem}`
-	)
+	if (problem) {
+		throw TypeError(
+			`The value sent to "${name}" of run "${key}" is not a JSON value: ${problem}`
+		)
+	}
 	const kept = copy(value)
 	for (;;) {
 		check_halted(d)
@@ -38,20 +40,30 @@ export async function send(d, key, name, value) {
 			running.unsaved.add(event)
 			const needed = running.taken + 1
 			await persist(d, running)
-			if (running.written >= needed) return
+			if (running.written >= needed) {
+				return
+			}
 			const list = running.saved.events?.[name]
 			if (running.unsaved.delete(event) && list?.includes(event)) {
 				list.splice(list.indexOf(event), 1)
-				if (!list.length) delete running.saved.events?.[name]
+				if (!list.length) {
+					delete running.saved.events?.[name]
+				}
+			}
+			if (running.fault !== void 0) {
+				throw running.fault
 			}
-			if (running.fault !== void 0) throw running.fault
 			continue
 		}
 		const saved = await load(d.store, key)
-		if (d.live.has(key)) continue
-		if (saved && (saved.status == "cancelled" || saved.status == "done")) throw Error(
-			`The run "${key}" is ${saved.status}`
-		)
+		if (d.live.has(key)) {
+			continue
+		}
+		if (saved && (saved.status == "cancelled" || saved.status == "done")) {
+			throw Error(
+				`The run "${key}" is ${saved.status}`
+			)
+		}
 		/** @type {SavedRun} */
 		const next = saved
 			? snapshot(saved)
@@ -62,9 +74,12 @@ export async function send(d, key, name, value) {
 				version: 1
 			}
 		if (next.status == "running" && next.owner && next.owner != d.owner) {
-			(next.inbox ??= []).push({ at, name, value: kept })
+			const inbox = next.inbox ??= []
+			inbox.push({ at, name, value: kept })
 			if (await d.store.put(key, next, saved?.version)) {
-				if (is_due(d, next)) void resume(d, key).catch(noop)
+				if (is_due(d, next)) {
+					void resume(d, key).catch(noop)
+				}
 				return
 			}
 			continue
@@ -79,7 +94,9 @@ export async function send(d, key, name, value) {
 			unclaim(next)
 		}
 		if (await d.store.put(key, next, saved?.version)) {
-			if (revive) void resume(d, key).catch(noop)
+			if (revive) {
+				void resume(d, key).catch(noop)
+			}
 			return
 		}
 	}

package/src/durable/serve.js

@@ -25,38 +25,32 @@ export async function serve(d, serve_options = {}) {
 		interval = 1000,
 		onError = noop
 	} = serve_options
-	if (!(Number.isInteger(batch) && batch > 0)) throw TypeError(
-		"The batch of serve() must be a positive integer"
-	)
-	if (!(Number.isFinite(interval) && interval > 0)) throw TypeError(
-		"The interval of serve() must be a positive number of milliseconds"
-	)
-	if (typeof onError != "function") throw TypeError(
-		"The onError of serve() must be a function"
-	)
+	if (!(Number.isInteger(batch) && batch > 0)) {
+		throw TypeError(
+			"The batch of serve() must be a positive integer"
+		)
+	}
+	if (!(Number.isFinite(interval) && interval > 0)) {
+		throw TypeError(
+			"The interval of serve() must be a positive number of milliseconds"
+		)
+	}
+	if (typeof onError != "function") {
+		throw TypeError(
+			"The onError of serve() must be a function"
+		)
+	}
 	check_halted(d)
 	const controller = new AbortController()
 	const unlink = link_signal(controller, serve_options.signal)
-	/**
-	 * @param {unknown} error
-	 * @param {string=} key
-	 * @returns {void}
-	 */
-	function reporter(error, key) {
-		onError(error, key)
-	}
-	/**
-	 * @returns {void}
-	 */
-	function stop() {
-		controller.abort()
-	}
 	d.reporters.add(reporter)
 	d.stoppers.add(stop)
 	try {
 		while (!controller.signal.aborted) {
 			try {
-				for (const key of await d.store.due(Date.now(), batch)) void resume(d, key).catch(error => reporter(error, key))
+				for (const key of await d.store.due(Date.now(), batch)) {
+					void resume(d, key).catch(error => reporter(error, key))
+				}
 			} catch (error) {
 				reporter(error)
 			}
@@ -67,4 +61,16 @@ export async function serve(d, serve_options = {}) {
 		d.stoppers.delete(stop)
 		unlink()
 	}
+	/**
+	 * @param {unknown} error
+	 * @param {string=} key
+	 * @returns {void}
+	 */
+	function reporter(error, key) {
+		onError(error, key)
+	}
+	/** @returns {void} */
+	function stop() {
+		controller.abort()
+	}
 }

package/src/durable/state.js

@@ -5,14 +5,18 @@
  */
 export function absorb(saved) {
 	const { inbox } = saved
-	if (!inbox) return
+	if (!inbox) {
+		return
+	}
 	delete saved.inbox
-	for (const item of inbox) push_event(
-		saved,
-		item.name,
-		item.at,
-		item.value
-	)
+	for (const item of inbox) {
+		push_event(
+			saved,
+			item.name,
+			item.at,
+			item.value
+		)
+	}
 }
 /**
  * When a worker should pick the run up, in milliseconds since the epoch: the end of the lease of a running run, 0 for one
@@ -22,8 +26,12 @@ export function absorb(saved) {
  * @returns {number | undefined}
  */
 export function dueAt(saved) {
-	if (saved.status == "running") return saved.owner ? saved.lease ?? 0 : 0
-	if (saved.status == "sleeping" || saved.status == "waiting") return saved.wake
+	if (saved.status == "running") {
+		return saved.owner ? saved.lease ?? 0 : 0
+	}
+	if (saved.status == "sleeping" || saved.status == "waiting") {
+		return saved.wake
+	}
 	return void 0
 }
 /**
@@ -36,7 +44,8 @@ export function dueAt(saved) {
 export function push_event(saved, name, at, value) {
 	const event = { at, value }
 	const events = saved.events ??= {}
-	;(events[name] ??= []).push(event)
+	const queue = events[name] ??= []
+	queue.push(event)
 	return event
 }
 /**
@@ -63,10 +72,14 @@ export function snapshot(saved) {
 	if (saved.events) {
 		/** @type {NonNullable<SavedRun["events"]>} */
 		const events = {}
-		for (const [ name, list ] of Object.entries(saved.events)) events[name] = [ ...list ]
+		for (const [ name, list ] of Object.entries(saved.events)) {
+			events[name] = [ ...list ]
+		}
 		next.events = events
 	}
-	if (saved.inbox) next.inbox = [ ...saved.inbox ]
+	if (saved.inbox) {
+		next.inbox = [ ...saved.inbox ]
+	}
 	return next
 }
 /**
@@ -80,7 +93,9 @@ export function take_event(saved, name) {
 	list.shift()
 	if (!list.length) {
 		delete events[name]
-		if (!Object.keys(events).length) delete saved.events
+		if (!Object.keys(events).length) {
+			delete saved.events
+		}
 	}
 }
 /**

package/src/durable/store.js

@@ -8,14 +8,15 @@ const encoded = new WeakMap()
  */
 function encode(saved) {
 	const { journal, ...rest } = saved
-	let json = JSON.stringify(rest).slice(0, -1)
-	json += json.length > 1 ? ",\"journal\":[" : "\"journal\":["
+	let json = `${JSON.stringify(rest).slice(0, -1)},"journal":[`
 	for (let index = 0; index < journal.length; index++) {
 		const entry = /** @type {JournalEntry} */(journal[index])/**/
 		let text = entry.done ? encoded.get(entry) : void 0
 		if (text == null) {
 			text = JSON.stringify(entry)
-			if (entry.done) encoded.set(entry, text)
+			if (entry.done) {
+				encoded.set(entry, text)
+			}
 		}
 		json += index ? `,${text}` : text
 	}
@@ -41,17 +42,23 @@ export function memory() {
 			/** @type {string[]} */
 			const keys = []
 			for (const [ key, row ] of rows) {
-				if (keys.length >= limit) break
-				if ((row.due ?? Infinity) <= now) keys.push(key)
+				if (keys.length >= limit) {
+					break
+				}
+				if ((row.due ?? Infinity) <= now) {
+					keys.push(key)
+				}
 			}
 			return keys
 		},
 		get(key) {
 			const row = rows.get(key)
-			return row && /** @type {SavedRun} */(JSON.parse(row.data))/**/
+			return row && JSON.parse(row.data)
 		},
 		put(key, saved, expected) {
-			if (rows.get(key)?.version !== expected) return false
+			if (rows.get(key)?.version !== expected) {
+				return false
+			}
 			rows.set(
 				key,
 				{
@@ -71,9 +78,11 @@ export function memory() {
  * @returns {DurableStore}
  */
 export function sqlite(db, table = "durable_runs") {
-	if (!/^[a-z_]\w*$/i.test(table)) throw TypeError(
-		`The table name must be an identifier: ${table}`
-	)
+	if (!/^[a-z_]\w*$/i.test(table)) {
+		throw TypeError(
+			`The table name must be an identifier: ${table}`
+		)
+	}
 	db.exec(
 		`create table if not exists ${table} (key text primary key, version integer not null, due integer, data text not null)`
 	)

package/src/durable/watch.js

@@ -17,24 +17,35 @@ const finished_statuses = new Set(
  */
 async function check(d, key, poller) {
 	poller.timer = void 0
-	if (d.live.has(key)) return
+	if (d.live.has(key)) {
+		return
+	}
 	poller.checking = true
 	const saved = await load(d.store, key).catch(noop)
-	if (saved && is_due(d, saved) && d.pollers.get(key) == poller) await resume(d, key).catch(noop)
+	if (saved && is_due(d, saved) && d.pollers.get(key) == poller) {
+		await resume(d, key).catch(noop)
+	}
 	poller.checking = false
-	if (d.pollers.get(key) != poller) return
+	if (d.pollers.get(key) != poller) {
+		return
+	}
 	if (saved && finished_statuses.has(saved.status)) {
 		settle(
 			d,
 			key,
 			watcher => {
-				if (saved.status == "done") watcher.resolve(saved.result)
-				else watcher.reject(error_of(saved))
+				if (saved.status == "done") {
+					watcher.resolve(saved.result)
+				} else {
+					watcher.reject(error_of(saved))
+				}
 			}
 		)
 		return
 	}
-	if (d.live.has(key)) return
+	if (d.live.has(key)) {
+		return
+	}
 	const { delay } = poller
 	poller.delay = Math.min(delay * 2, d.poll_cap)
 	const left = (saved && dueAt(saved) || 0) - Date.now()
@@ -56,8 +67,11 @@ export function notify(d, key, outcome) {
 		d,
 		key,
 		watcher => {
-			if ("error" in outcome) watcher.reject(outcome.error)
-			else watcher.resolve(outcome.value)
+			if ("error" in outcome) {
+				watcher.reject(outcome.error)
+			} else {
+				watcher.resolve(outcome.value)
+			}
 		}
 	)
 }
@@ -98,9 +112,13 @@ export function settle(d, key, each) {
 		d.pollers.delete(key)
 	}
 	const waiting = d.watchers.get(key)
-	if (!waiting) return
+	if (!waiting) {
+		return
+	}
 	d.watchers.delete(key)
-	for (const watcher of waiting) each(watcher)
+	for (const watcher of waiting) {
+		each(watcher)
+	}
 }
 /**
  * @param {DurableWorker} d
@@ -118,7 +136,9 @@ function watch(d, key) {
 		d.pollers.set(key, poller)
 	}
 	poller.delay = d.poll_ms
-	if (poller.checking) return
+	if (poller.checking) {
+		return
+	}
 	clearTimeout(poller.timer)
 	void check(d, key, poller)
 }

package/src/errors.js

@@ -3,7 +3,9 @@
  * @returns {string | undefined}
  */
 function get_message(data) {
-	if (!data || typeof data != "object") return
+	if (!data || typeof data != "object") {
+		return
+	}
 	for (const key of [
 		"message",
 		"error",
@@ -11,8 +13,12 @@ function get_message(data) {
 		"title"
 	]) {
 		const value = /** @type {Record<string, unknown>} */(data)/**/[key]
-		if (typeof value == "string" && value) return value
-		if (value && typeof value == "object" && typeof /** @type {{ message?: unknown }} */(value)/**/.message == "string") return /** @type {{ message: string }} */(value)/**/.message
+		if (typeof value == "string" && value) {
+			return value
+		}
+		if (value && typeof value == "object" && typeof /** @type {{ message?: unknown }} */(value)/**/.message == "string") {
+			return /** @type {{ message: string }} */(value)/**/.message
+		}
 	}
 	return undefined
 }