@rdlabo/workers-hono-kit 0.10.5 → 0.10.6

package/dist/cache/kv-cache.js

@@ -121,14 +121,11 @@ export class KVCache {
         if (!key) {
             return undefined;
         }
-        let data;
-        try {
-            data = await this.#kv.get(key);
-        }
-        catch (error) {
+        const read = async () => this.#kv.get(key);
+        const data = await read().catch((error) => {
             this.#reportError(error, { operation: 'read', table });
-            return undefined;
-        }
+            return null;
+        });
         if (!data) {
             return undefined;
         }
@@ -179,7 +176,8 @@ export class KVCache {
             return;
         }
         const ttl = Math.max(this.#minTtl, lifetime ?? this.#defaultLifetime);
-        await this.#kv.put(key, payload, { expirationTtl: ttl }).catch((error) => {
+        const write = async () => this.#kv.put(key, payload, { expirationTtl: ttl });
+        await write().catch((error) => {
             this.#reportError(error, { operation: 'write', table });
         });
     }
@@ -243,7 +241,8 @@ export class KVCache {
         if (!key) {
             return;
         }
-        await this.#kv.delete(key).catch((error) => {
+        const remove = async () => this.#kv.delete(key);
+        await remove().catch((error) => {
             this.#reportError(error, { operation: 'delete', table });
         });
     }

package/dist/db/database.js

@@ -70,8 +70,8 @@ export function createHyperdriveDatabase(options) {
             return retryWhenDeadlock(() => dz.transaction(fn));
         },
         /** @deprecated Workers cleans up invocation-scoped connections automatically. */
-        dispose() {
-            return Promise.resolve();
+        async dispose() {
+            return;
         },
     };
 }

package/dist/db/retry.js

@@ -27,17 +27,17 @@
  */
 export async function retryWhenDeadlock(fn, retries = 3, delay = 100) {
     for (let attempt = 0; attempt < retries; attempt++) {
-        try {
-            return await fn();
+        const invoke = async () => fn();
+        const outcome = await invoke().then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+        if (outcome.ok) {
+            return outcome.value;
         }
-        catch (error) {
-            const code = error.code;
-            if (code === 'ER_LOCK_DEADLOCK' && attempt < retries - 1) {
-                await new Promise((resolve) => setTimeout(resolve, delay * (attempt + 1)));
-                continue;
-            }
-            throw error;
+        const code = outcome.error.code;
+        if (code === 'ER_LOCK_DEADLOCK' && attempt < retries - 1) {
+            await new Promise((resolve) => setTimeout(resolve, delay * (attempt + 1)));
+            continue;
         }
+        throw outcome.error;
     }
     // Unreachable: the loop returns on success and throws on the final failed attempt.
     throw new Error('retryWhenDeadlock: exhausted retries');

package/dist/middleware/auth.js

@@ -43,7 +43,7 @@ export function createAuthMiddleware(options) {
     return async (c, next) => {
         let stage = 'token';
         let tokenPresent = false;
-        try {
+        const authenticate = async () => {
             const token = c.req.header(tokenHeader) ?? '';
             tokenPresent = token.trim().length > 0;
             if (!tokenPresent && rejectMissingToken) {
@@ -57,24 +57,23 @@ export function createAuthMiddleware(options) {
             const userId = resolveUserId ? await resolveUserId(verified, c, appInfo) : undefined;
             stage = 'setContext';
             setContext(c, { verified, appInfo, userId });
-        }
-        catch (e) {
+        };
+        const outcome = await authenticate().then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+        if (!outcome.ok) {
             const details = { stage, tokenPresent };
             if (reportFailure) {
-                try {
-                    await reportFailure(e, c, details);
-                }
-                catch (reportingError) {
+                const report = async () => reportFailure(outcome.error, c, details);
+                await report().catch((reportingError) => {
                     // Observability must never alter the authentication response.
                     console.error(reportingError);
-                }
+                });
             }
             else {
                 // Preserve the historical default for consumers that have not adopted classified reporting.
-                console.error(e);
+                console.error(outcome.error);
             }
             if (onFailure) {
-                return onFailure(e, c, details);
+                return onFailure(outcome.error, c, details);
             }
             throw new HTTPException(failureStatus, { message: failureMessage });
         }

package/dist/middleware/perf-log.js

@@ -98,12 +98,13 @@ export function perfLog(options = {}) {
         // In-code sampling thins Analytics Engine writes only; Workers Logs volume is controlled separately
         // by the observability `head_sampling_rate`. Low-traffic Workers should leave `sampleRate` at 1.
         if (sink && (rate >= 1 || Math.random() < rate)) {
+            const point = {
+                doubles: [tApp, cold ? 1 : 0, status],
+                blobs: [path, colo, method],
+                indexes: [analyticsIndex(path)],
+            };
             try {
-                sink.writeDataPoint({
-                    doubles: [tApp, cold ? 1 : 0, status],
-                    blobs: [path, colo, method],
-                    indexes: [analyticsIndex(path)],
-                });
+                sink.writeDataPoint(point);
             }
             catch (error) {
                 // Telemetry must never replace an otherwise successful application response with a 500.

package/dist/queue/consumer.js

@@ -69,28 +69,30 @@ export async function processBatch(batch, handler, options) {
     let discarded = 0;
     let failed = 0;
     for (const message of batch.messages) {
-        try {
+        const processMessage = async () => {
             await handler(message.body, message);
             message.ack();
+        };
+        const outcome = await processMessage().then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+        if (outcome.ok) {
             processed++;
+            continue;
+        }
+        try {
+            onError(outcome.error, message);
         }
-        catch (error) {
-            try {
-                onError(error, message);
-            }
-            catch (reportingError) {
-                // Reporting is best-effort. Preserve the domain error's disposition, but never let a broken
-                // custom reporter make a permanent failure disappear without any local trace.
-                console.error(`[queue:${batch.queue}] onError failed for message ${message.id}`, reportingError, 'original error:', error);
-            }
-            if (isNonRetryableQueueError(error)) {
-                message.ack();
-                discarded++;
-                continue;
-            }
-            message.retry(retryOptions);
-            failed++;
+        catch (reportingError) {
+            // Reporting is best-effort. Preserve the domain error's disposition, but never let a broken
+            // custom reporter make a permanent failure disappear without any local trace.
+            console.error(`[queue:${batch.queue}] onError failed for message ${message.id}`, reportingError, 'original error:', outcome.error);
+        }
+        if (isNonRetryableQueueError(outcome.error)) {
+            message.ack();
+            discarded++;
+            continue;
         }
+        message.retry(retryOptions);
+        failed++;
     }
     return { processed, discarded, failed };
 }

package/dist/realtime/retry.js

@@ -27,16 +27,16 @@ export async function retryDurableObjectOperation(operation, options = {}) {
     const random = options.random ?? Math.random;
     const wait = options.wait ?? defaultWait;
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-        try {
-            return await operation(attempt);
+        const invoke = async () => operation(attempt);
+        const outcome = await invoke().then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+        if (outcome.ok) {
+            return outcome.value;
         }
-        catch (error) {
-            if (!isRetryableDurableObjectError(error) || attempt + 1 >= maxAttempts) {
-                throw error;
-            }
-            const delayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt * random());
-            await wait(delayMs);
+        if (!isRetryableDurableObjectError(outcome.error) || attempt + 1 >= maxAttempts) {
+            throw outcome.error;
         }
+        const delayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt * random());
+        await wait(delayMs);
     }
     throw new Error('Durable Object retry exhausted');
 }

package/dist/stripe/failure.js

@@ -162,28 +162,26 @@ export function parsePaymentFailure(receipt) {
     if (!receipt) {
         return null;
     }
+    let parsed;
     try {
-        const parsed = JSON.parse(receipt);
-        const r = asRecord(parsed);
-        if (!r) {
-            return null;
-        }
-        if (asRecord(r.reason)) {
-            if ((r.source !== undefined && typeof r.source !== 'string') ||
-                (r.occurredAt !== undefined && typeof r.occurredAt !== 'string')) {
-                return null;
-            }
-            return parsed;
-        }
-        // IAP rows store the reason itself. `code` is required so arbitrary JSON is not accepted as a reason.
-        if (typeof r.code === 'string') {
-            return { reason: parsed };
-        }
-        return null;
+        parsed = JSON.parse(receipt);
     }
     catch {
         return null;
     }
+    const r = asRecord(parsed);
+    if (!r) {
+        return null;
+    }
+    if (asRecord(r.reason)) {
+        if ((r.source !== undefined && typeof r.source !== 'string') ||
+            (r.occurredAt !== undefined && typeof r.occurredAt !== 'string')) {
+            return null;
+        }
+        return parsed;
+    }
+    // IAP rows store the reason itself. `code` is required so arbitrary JSON is not accepted as a reason.
+    return typeof r.code === 'string' ? { reason: parsed } : null;
 }
 /**
  * HTTP error for a synchronous card decline, carrying a user-facing Japanese message.

package/dist/testing/db.js

@@ -83,14 +83,13 @@ export function createTestDb(options) {
             await pool.query(`INSERT INTO \`${table}\` (${columnList}) VALUES (${placeholders})`, Object.values(row));
         },
         async mysqlReachable() {
-            try {
-                const c = await createConnection({ ...connection });
-                await c.end();
-                return true;
-            }
-            catch {
+            const connect = async () => createConnection({ ...connection });
+            const c = await connect().catch(() => undefined);
+            if (!c) {
                 return false;
             }
+            const close = async () => c.end();
+            return close().then(() => true, () => false);
         },
     };
 }

package/dist/testing/workers-bindings.js

@@ -21,16 +21,14 @@ export function fakeQueue() {
         get batchCount() {
             return batchCount;
         },
-        send(body) {
+        async send(body) {
             sent.push(body);
-            return Promise.resolve();
         },
-        sendBatch(messages) {
+        async sendBatch(messages) {
             batchCount++;
             for (const m of messages) {
                 sent.push(m.body);
             }
-            return Promise.resolve();
         },
     };
 }
@@ -47,16 +45,14 @@ export function fakeQueue() {
 export function fakeKv() {
     const store = new Map();
     return {
-        get: (key) => Promise.resolve(store.get(key) ?? null),
-        put: (key, value) => {
+        get: async (key) => store.get(key) ?? null,
+        put: async (key, value) => {
             store.set(key, value);
-            return Promise.resolve();
         },
-        delete: (key) => {
+        delete: async (key) => {
             store.delete(key);
-            return Promise.resolve();
         },
-        list: () => Promise.resolve({ keys: [], list_complete: true, cacheStatus: null }),
-        getWithMetadata: () => Promise.resolve({ value: null, metadata: null, cacheStatus: null }),
+        list: async () => ({ keys: [], list_complete: true, cacheStatus: null }),
+        getWithMetadata: async () => ({ value: null, metadata: null, cacheStatus: null }),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdlabo/workers-hono-kit",
-  "version": "0.10.5",
+  "version": "0.10.6",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -33,6 +33,13 @@
   "engines": {
     "node": ">=20.0.0"
   },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": "^20.19.0 || ^22.13.0 || >=24.0.0",
+      "onFail": "error"
+    }
+  },
   "files": [
     "dist",
     "scripts",
@@ -120,8 +127,13 @@
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.84",
     "@ai-sdk/openai": "^3.0.71",
+    "@angular-eslint/template-parser": "^21.4.0",
+    "@angular/core": "^21.2.20",
+    "@angular/forms": "^21.2.20",
+    "@angular/router": "^21.2.20",
     "@hono/eslint-config": "^2.1.0",
     "@hono/zod-validator": "^0.8.0",
+    "@rdlabo/eslint-plugin-rules": "^21.2.6",
     "@types/node": "^22.19.21",
     "ai": "^6.0.204",
     "ai-gateway-provider": "^3.1.3",