toiljs 0.0.54 → 0.0.56

package/build/devserver/database.js

@@ -0,0 +1,416 @@
+const STORE = new Map();
+const VIEWS = new Map();
+const MEMBERS = new Map();
+const COUNTERS = new Map();
+const EVENTS = new Map();
+const CAPACITY = new Map();
+function capLedger(sk) {
+    let l = CAPACITY.get(sk);
+    if (l === undefined) {
+        l = { total: 0n, confirmed: 0n, holds: new Map(), nextId: 1n };
+        CAPACITY.set(sk, l);
+    }
+    return l;
+}
+function capPrune(l, nowMs) {
+    for (const [id, h] of l.holds)
+        if (h.expiresMs <= nowMs)
+            l.holds.delete(id);
+}
+function capHeld(l) {
+    let sum = 0n;
+    for (const h of l.holds.values())
+        sum += h.amount;
+    return sum;
+}
+const MAX_NAME = 512;
+const MAX_KEY = 4096;
+const MAX_VALUE = 256 * 1024;
+const I64_MIN = -(2n ** 63n);
+const I64_MAX = 2n ** 63n - 1n;
+function satI64(v) {
+    return v < I64_MIN ? I64_MIN : v > I64_MAX ? I64_MAX : v;
+}
+const ABSENT = -2;
+const TOO_SMALL = -1;
+const INVALID_HANDLE = -1001;
+const PRODUCT_ERR = -1000;
+export function freshDbState() {
+    return { handles: [], lastResult: null };
+}
+function mem(ref) {
+    if (!ref.memory)
+        throw new Error('data host import called before memory was bound');
+    return Buffer.from(ref.memory.buffer);
+}
+function readCopy(ref, ptr, len) {
+    const m = mem(ref);
+    if (ptr < 0 || len < 0 || ptr + len > m.length)
+        throw new Error(`data read out of bounds: ptr=${String(ptr)} len=${String(len)}`);
+    return Buffer.from(m.subarray(ptr, ptr + len));
+}
+function storeKey(collection, key) {
+    return collection + '\0' + key.toString('latin1');
+}
+function collOf(db, handle) {
+    return handle >= 0 && handle < db.handles.length ? db.handles[handle] : null;
+}
+export function buildDatabaseImports(ref, db) {
+    return {
+        'data.resolve_collection': (namePtr, nameLen, outHandlePtr) => {
+            if (nameLen < 0 || nameLen > MAX_NAME)
+                throw new Error('data: collection name too long');
+            const name = readCopy(ref, namePtr, nameLen).toString('utf8');
+            const handle = db.handles.length;
+            db.handles.push(name);
+            const m = mem(ref);
+            if (outHandlePtr < 0 || outHandlePtr + 4 > m.length)
+                throw new Error('data: resolve out-handle out of bounds');
+            m.writeUInt32LE(handle, outHandlePtr);
+            return 0;
+        },
+        'data.get': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY)
+                throw new Error('data: key too long');
+            const v = STORE.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            if (v === undefined)
+                return ABSENT;
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.get_many': (handle, keysPtr, keysLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keysLen > MAX_VALUE)
+                throw new Error('data: keys blob too large');
+            const blob = readCopy(ref, keysPtr, keysLen);
+            let off = 0;
+            const count = blob.readUInt32LE(off);
+            off += 4;
+            if (count > 1024)
+                return PRODUCT_ERR;
+            const header = Buffer.alloc(4);
+            header.writeUInt32LE(count, 0);
+            const parts = [header];
+            for (let i = 0; i < count; i++) {
+                const len = blob.readUInt32LE(off);
+                off += 4;
+                const key = blob.subarray(off, off + len);
+                off += len;
+                const v = STORE.get(storeKey(coll, key));
+                if (v === undefined) {
+                    parts.push(Buffer.from([0]));
+                }
+                else {
+                    const h = Buffer.alloc(5);
+                    h.writeUInt8(1, 0);
+                    h.writeUInt32LE(v.length, 1);
+                    parts.push(h, v);
+                }
+            }
+            db.lastResult = Buffer.concat(parts);
+            return db.lastResult.length;
+        },
+        'data.exists': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            return STORE.has(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ? 1 : 0;
+        },
+        'data.create': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
+                throw new Error('data: key/value too large');
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            if (STORE.has(sk))
+                return PRODUCT_ERR;
+            STORE.set(sk, readCopy(ref, valPtr, valLen));
+            return 0;
+        },
+        'data.patch': (handle, keyPtr, keyLen, patchPtr, patchLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || patchLen > MAX_VALUE)
+                throw new Error('data: key/patch too large');
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            if (!STORE.has(sk))
+                return PRODUCT_ERR;
+            const v = readCopy(ref, patchPtr, patchLen);
+            STORE.set(sk, v);
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.delete': (handle, keyPtr, keyLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            STORE.delete(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            return 0;
+        },
+        'data.get_delete': (handle, keyPtr, keyLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            const v = STORE.get(sk);
+            if (v === undefined)
+                return ABSENT;
+            STORE.delete(sk);
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.unique_lookup': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const v = STORE.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            if (v === undefined)
+                return ABSENT;
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.unique_claim': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
+                throw new Error('data: key/value too large');
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            const owner = readCopy(ref, valPtr, valLen);
+            const existing = STORE.get(sk);
+            if (existing === undefined) {
+                STORE.set(sk, owner);
+                return 0;
+            }
+            if (existing.equals(owner))
+                return 2;
+            db.lastResult = existing;
+            return 1;
+        },
+        'data.unique_release': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            const existing = STORE.get(sk);
+            if (existing === undefined)
+                return 0;
+            if (!existing.equals(readCopy(ref, valPtr, valLen)))
+                return PRODUCT_ERR;
+            STORE.delete(sk);
+            return 0;
+        },
+        'data.membership_contains': (handle, setPtr, setLen, memberPtr, memberLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
+            if (set === undefined)
+                return 0;
+            return set.has(readCopy(ref, memberPtr, memberLen).toString('latin1')) ? 1 : 0;
+        },
+        'data.membership_add': (handle, setPtr, setLen, memberPtr, memberLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (setLen > MAX_KEY || memberLen > MAX_VALUE)
+                throw new Error('data: set/member too large');
+            const sk = storeKey(coll, readCopy(ref, setPtr, setLen));
+            const member = readCopy(ref, memberPtr, memberLen);
+            let set = MEMBERS.get(sk);
+            if (set === undefined) {
+                set = new Map();
+                MEMBERS.set(sk, set);
+            }
+            set.set(member.toString('latin1'), member);
+            return 0;
+        },
+        'data.membership_remove': (handle, setPtr, setLen, memberPtr, memberLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
+            if (set !== undefined)
+                set.delete(readCopy(ref, memberPtr, memberLen).toString('latin1'));
+            return 0;
+        },
+        'data.membership_list': (handle, setPtr, setLen, limit) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const set = MEMBERS.get(storeKey(coll, readCopy(ref, setPtr, setLen)));
+            const n = Math.max(0, Math.min(limit, 0xffff));
+            const members = set === undefined ? [] : Array.from(set.values()).sort(Buffer.compare).slice(0, n);
+            const header = Buffer.alloc(4);
+            header.writeUInt32LE(members.length, 0);
+            const parts = [header];
+            for (const m of members) {
+                const h = Buffer.alloc(4);
+                h.writeUInt32LE(m.length, 0);
+                parts.push(h, m);
+            }
+            db.lastResult = Buffer.concat(parts);
+            return db.lastResult.length;
+        },
+        'data.view_get': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const v = VIEWS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            if (v === undefined)
+                return ABSENT;
+            db.lastResult = v;
+            return v.length;
+        },
+        'data.view_publish': (handle, keyPtr, keyLen, valPtr, valLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || valLen > MAX_VALUE)
+                throw new Error('data: key/view too large');
+            VIEWS.set(storeKey(coll, readCopy(ref, keyPtr, keyLen)), readCopy(ref, valPtr, valLen));
+            return 0;
+        },
+        'data.counter_get': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const sum = COUNTERS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ?? 0n;
+            const out = Buffer.alloc(8);
+            out.writeBigInt64LE(sum);
+            db.lastResult = out;
+            return out.length;
+        },
+        'data.counter_add': (handle, keyPtr, keyLen, delta, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            COUNTERS.set(sk, satI64((COUNTERS.get(sk) ?? 0n) + BigInt(delta)));
+            return 0;
+        },
+        'data.append': (handle, keyPtr, keyLen, evPtr, evLen, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            if (keyLen > MAX_KEY || evLen > MAX_VALUE)
+                throw new Error('data: key/event too large');
+            const sk = storeKey(coll, readCopy(ref, keyPtr, keyLen));
+            const log = EVENTS.get(sk);
+            const ev = readCopy(ref, evPtr, evLen);
+            if (log === undefined)
+                EVENTS.set(sk, [ev]);
+            else
+                log.push(ev);
+            return 0;
+        },
+        'data.latest': (handle, keyPtr, keyLen, limit) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const log = EVENTS.get(storeKey(coll, readCopy(ref, keyPtr, keyLen))) ?? [];
+            const n = Math.max(0, Math.min(limit, 0xffff));
+            const newest = log.slice(Math.max(0, log.length - n)).reverse();
+            let size = 4;
+            for (const ev of newest)
+                size += 4 + ev.length;
+            const out = Buffer.alloc(size);
+            let off = out.writeUInt32LE(newest.length, 0);
+            for (const ev of newest) {
+                off = out.writeUInt32LE(ev.length, off);
+                off += ev.copy(out, off);
+            }
+            db.lastResult = out;
+            return out.length;
+        },
+        'data.capacity_set_total': (handle, keyPtr, keyLen, total, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            const t = BigInt(total);
+            l.total = satI64(t < 0n ? 0n : t);
+            return 0;
+        },
+        'data.capacity_available': (handle, keyPtr, keyLen) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            capPrune(l, Date.now());
+            const avail = l.total - l.confirmed - capHeld(l);
+            const out = Buffer.alloc(8);
+            out.writeBigInt64LE(avail < 0n ? 0n : avail);
+            db.lastResult = out;
+            return out.length;
+        },
+        'data.capacity_reserve': (handle, keyPtr, keyLen, amount, ttlMs, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const want = BigInt(amount);
+            if (want <= 0n)
+                return ABSENT;
+            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            const now = Date.now();
+            capPrune(l, now);
+            if (l.total - l.confirmed - capHeld(l) < want)
+                return ABSENT;
+            const id = l.nextId++;
+            l.holds.set(id, { amount: want, expiresMs: now + Math.max(0, Number(ttlMs)) });
+            const out = Buffer.alloc(8);
+            out.writeBigUInt64LE(id);
+            db.lastResult = out;
+            return out.length;
+        },
+        'data.capacity_confirm': (handle, keyPtr, keyLen, reservationId, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            capPrune(l, Date.now());
+            const h = l.holds.get(BigInt(reservationId));
+            if (h === undefined)
+                return 0;
+            l.holds.delete(BigInt(reservationId));
+            l.confirmed = satI64(l.confirmed + h.amount);
+            return 1;
+        },
+        'data.capacity_cancel': (handle, keyPtr, keyLen, reservationId, _idemPtr) => {
+            const coll = collOf(db, handle);
+            if (coll === null)
+                return INVALID_HANDLE;
+            const l = capLedger(storeKey(coll, readCopy(ref, keyPtr, keyLen)));
+            capPrune(l, Date.now());
+            return l.holds.delete(BigInt(reservationId)) ? 1 : 0;
+        },
+        'data.take_result': (outPtr, outCap) => {
+            const v = db.lastResult;
+            if (v === null)
+                return 0;
+            if (v.length > outCap)
+                return TOO_SMALL;
+            const m = mem(ref);
+            if (outPtr < 0 || outPtr + v.length > m.length)
+                throw new Error('data: take_result out of bounds');
+            v.copy(m, outPtr);
+            db.lastResult = null;
+            return v.length;
+        },
+    };
+}
+export function __resetDbForTests() {
+    STORE.clear();
+    VIEWS.clear();
+    MEMBERS.clear();
+    COUNTERS.clear();
+    EVENTS.clear();
+    CAPACITY.clear();
+}

package/build/devserver/email/config.js

@@ -46,7 +46,9 @@ export function resolveEmailConfig(cfg, reserved) {
     else if (providerId === 'gmail' || providerId === 'smtp') {
         provider = 'smtp';
         const isGmail = providerId === 'gmail';
-        const host = envOf(reserved, 'SMTP_HOST') ?? c.smtp?.host?.trim() ?? (isGmail ? 'smtp.gmail.com' : '');
+        const host = envOf(reserved, 'SMTP_HOST') ??
+            c.smtp?.host?.trim() ??
+            (isGmail ? 'smtp.gmail.com' : '');
         if (!host) {
             return { config: null, warning: 'provider `smtp` requires TOIL_EMAIL_SMTP_HOST' };
         }
@@ -55,7 +57,10 @@ export function resolveEmailConfig(cfg, reserved) {
         smtp = { host, port, user };
     }
     else {
-        return { config: null, warning: `unknown email provider "${providerId}" (resend|gmail|smtp)` };
+        return {
+            config: null,
+            warning: `unknown email provider "${providerId}" (resend|gmail|smtp)`,
+        };
     }
     return {
         config: {

package/build/devserver/email/validate.js

@@ -10,10 +10,7 @@ export function validRecipient(s) {
     if (parts.length !== 2)
         return false;
     const [local, domain] = parts;
-    return (local.length > 0 &&
-        domain.includes('.') &&
-        !domain.startsWith('.') &&
-        !domain.endsWith('.'));
+    return (local.length > 0 && domain.includes('.') && !domain.startsWith('.') && !domain.endsWith('.'));
 }
 export function validFrom(s) {
     return (Buffer.byteLength(s, 'utf8') <= 320 &&

package/build/devserver/host.d.ts

@@ -1,4 +1,5 @@
 import { type CryptoState } from './crypto.js';
+import { type DbDevState } from './database.js';
 export declare class WasmAbortError extends Error {
     constructor(message: string, fileName: string, line: number, column: number);
 }
@@ -9,6 +10,7 @@ export interface DispatchState {
     sendfile: string | null;
     clientIp: string;
     crypto: CryptoState;
+    db: DbDevState;
 }
 export declare function freshDispatchState(): DispatchState;
 export interface MemoryRef {

package/build/devserver/host.js

@@ -1,5 +1,5 @@
 import { buildCryptoImports, freshCryptoState } from './crypto.js';
-import { buildKvImports } from './kv.js';
+import { buildDatabaseImports, freshDbState } from './database.js';
 import { EmailStatus, getEmailService } from './email/index.js';
 import { parseEmailBlob } from './email/wire.js';
 import { devEnvGet, devEnvGetSecure } from './env.js';
@@ -24,6 +24,7 @@ export function freshDispatchState() {
         sendfile: null,
         clientIp: '',
         crypto: freshCryptoState(),
+        db: freshDbState(),
     };
 }
 function mem(ref) {
@@ -141,7 +142,7 @@ export function buildHostImports(ref, state) {
             thread_spawn: (_startArg) => -1,
             'Date.now': () => Date.now(),
             ...buildCryptoImports(ref, state.crypto),
-            ...buildKvImports(ref),
+            ...buildDatabaseImports(ref, state.db),
         },
     };
 }

package/build/devserver/index.d.ts

@@ -1,6 +1,6 @@
 import type { EmailBackendConfig } from 'toiljs/shared';
 import { type ViteTarget } from './proxy.js';
-export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult } from './envelope.js';
+export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './envelope.js';
 export type { EnvelopeRequest, EnvelopeResponse } from './envelope.js';
 export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './module.js';
 export type { WasmDispatchResult } from './module.js';

package/build/devserver/index.js

@@ -7,7 +7,7 @@ import { initEmailService } from './email/index.js';
 import { METHOD_CODES } from './envelope.js';
 import { WasmServerModule } from './module.js';
 import { proxyToVite, wireWebsocketProxy } from './proxy.js';
-export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult } from './envelope.js';
+export { METHOD_CODES, encodeRequestEnvelope, decodeResponseEnvelope, unpackHandleResult, } from './envelope.js';
 export { WasmServerModule, WasmAbortError, UNHANDLED_HEADER } from './module.js';
 export { buildHostImports, freshDispatchState } from './host.js';
 const DEFAULT_MAX_BODY_LENGTH = 1024 * 1024 * 8;
@@ -146,7 +146,8 @@ export async function startDevServer(options) {
                 }
             }
             catch (e) {
-                process.stdout.write(pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) + '\n');
+                process.stdout.write(pc.red(`  ✗ ${request.method} ${request.path} server error: ${String(e)}`) +
+                    '\n');
                 response.status(500).send('internal error\n');
                 return;
             }

package/build/devserver/module.js

@@ -5,13 +5,58 @@ export { WasmAbortError } from './host.js';
 export const UNHANDLED_HEADER = 'x-toil-unhandled';
 const WASM_PAGE = 65536;
 const PROVIDED_IMPORTS = new Set([
-    'abort', 'set_status', 'set_header', 'respond_file', 'thread_spawn', 'Date.now',
-    'client_ip', 'ratelimit_check', 'email_send', 'env_get', 'env_get_secure',
-    'crypto.fill_random', 'crypto.random_uuid', 'crypto.take_result', 'crypto.digest',
-    'crypto.import_key', 'crypto.export_key', 'crypto.encrypt', 'crypto.decrypt',
-    'crypto.sign', 'crypto.verify', 'crypto.derive_bits',
-    'crypto.mldsa_verify', 'crypto.mlkem_decapsulate', 'crypto.voprf_evaluate',
-    'kv.put', 'kv.get', 'kv.getdel',
+    'abort',
+    'set_status',
+    'set_header',
+    'respond_file',
+    'thread_spawn',
+    'Date.now',
+    'client_ip',
+    'ratelimit_check',
+    'email_send',
+    'env_get',
+    'env_get_secure',
+    'crypto.fill_random',
+    'crypto.random_uuid',
+    'crypto.take_result',
+    'crypto.digest',
+    'crypto.import_key',
+    'crypto.export_key',
+    'crypto.encrypt',
+    'crypto.decrypt',
+    'crypto.sign',
+    'crypto.verify',
+    'crypto.derive_bits',
+    'crypto.mldsa_verify',
+    'crypto.mlkem_decapsulate',
+    'crypto.voprf_evaluate',
+    'data.resolve_collection',
+    'data.get',
+    'data.get_many',
+    'data.exists',
+    'data.create',
+    'data.patch',
+    'data.delete',
+    'data.get_delete',
+    'data.unique_lookup',
+    'data.unique_claim',
+    'data.unique_release',
+    'data.view_get',
+    'data.view_publish',
+    'data.membership_contains',
+    'data.membership_add',
+    'data.membership_remove',
+    'data.membership_list',
+    'data.counter_get',
+    'data.counter_add',
+    'data.append',
+    'data.latest',
+    'data.capacity_set_total',
+    'data.capacity_available',
+    'data.capacity_reserve',
+    'data.capacity_confirm',
+    'data.capacity_cancel',
+    'data.take_result',
 ]);
 export class WasmServerModule {
     wasmPath;

package/build/devserver/proxy.js

@@ -90,7 +90,8 @@ export function wireWebsocketProxy(app, target) {
                 pending.push(m);
         });
         ws.on('close', () => {
-            if (upstream.readyState === WebSocket.OPEN || upstream.readyState === WebSocket.CONNECTING) {
+            if (upstream.readyState === WebSocket.OPEN ||
+                upstream.readyState === WebSocket.CONNECTING) {
                 upstream.close();
             }
         });