@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/src/ws-client.ts

@@ -0,0 +1,662 @@
+import { EventEmitter } from "node:events";
+import {
+  AckTimeoutError,
+  AuthError,
+  EVENT,
+  MessageSendError,
+  ProtocolError,
+  StateError,
+  TransportError,
+  isBusinessDispatchEvent,
+  type ConnState,
+  type ConnectPayload,
+  type EmptyPayload,
+  type Envelope,
+  type MessageAckPayload,
+  type MessageErrorPayload,
+  type Transport,
+  type TransportEvents,
+  type TransportState,
+} from "./protocol-types.ts";
+
+export interface WebSocketLike {
+  addEventListener(type: string, listener: (event?: unknown) => void): void;
+  send(data: string): void;
+  close(code?: number, reason?: string): void;
+}
+
+export type WebSocketConstructor = new (url: string) => WebSocketLike;
+
+export function createWebSocketTransport(
+  WebSocketCtor: WebSocketConstructor = globalThis.WebSocket as WebSocketConstructor,
+): Transport {
+  let currentState: TransportState = "closed";
+  let socket: WebSocketLike | undefined;
+
+  return {
+    get state(): TransportState {
+      return currentState;
+    },
+
+    async connect(url: string, handlers: TransportEvents): Promise<void> {
+      if (!WebSocketCtor) {
+        throw new TransportError("global WebSocket is not available");
+      }
+      currentState = "connecting";
+      const activeSocket = new WebSocketCtor(url);
+      socket = activeSocket;
+      const isCurrentSocket = () => socket === activeSocket;
+      await new Promise<void>((resolve, reject) => {
+        let opened = false;
+        let settled = false;
+        const rejectBeforeOpen = (err: Error) => {
+          if (opened || settled) return;
+          settled = true;
+          reject(err);
+        };
+        activeSocket.addEventListener("open", () => {
+          if (!isCurrentSocket()) return;
+          opened = true;
+          settled = true;
+          currentState = "open";
+          handlers.onOpen();
+          resolve();
+        });
+        activeSocket.addEventListener("message", (event) => {
+          if (!isCurrentSocket()) return;
+          const data = (event as { data?: unknown } | undefined)?.data;
+          if (typeof data === "string" || Buffer.isBuffer(data)) {
+            handlers.onMessage(data);
+            return;
+          }
+          if (data instanceof ArrayBuffer) {
+            handlers.onMessage(Buffer.from(data));
+            return;
+          }
+          if (ArrayBuffer.isView(data)) {
+            handlers.onMessage(Buffer.from(data.buffer, data.byteOffset, data.byteLength));
+            return;
+          }
+          handlers.onMessage(String(data ?? ""));
+        });
+        activeSocket.addEventListener("close", (event) => {
+          if (!isCurrentSocket()) return;
+          currentState = "closed";
+          socket = undefined;
+          const close = event as { code?: unknown; reason?: unknown } | undefined;
+          const code = typeof close?.code === "number" ? close.code : 1006;
+          const reason = typeof close?.reason === "string" ? close.reason : "closed";
+          handlers.onClose(code, reason);
+          rejectBeforeOpen(new TransportError(reason));
+        });
+        activeSocket.addEventListener("error", (event) => {
+          if (!isCurrentSocket()) return;
+          const err = event instanceof Error ? event : new Error("websocket error");
+          handlers.onError(err);
+          rejectBeforeOpen(err);
+        });
+      });
+    },
+
+    send(data: string): void {
+      if (currentState !== "open" || !socket) {
+        throw new StateError(`cannot send while transport=${currentState}`);
+      }
+      socket.send(data);
+    },
+
+    close(code = 1000, reason = "client close"): void {
+      if (currentState === "closed") return;
+      socket?.close(code, reason);
+    },
+  };
+}
+
+export interface ClawChatClientOptions {
+  url: string;
+  token: string;
+  deviceId?: string;
+  transport?: Transport;
+  traceIdFactory?: () => string;
+  reconnect?: {
+    enabled?: boolean;
+    initialDelay?: number;
+    maxDelay?: number;
+    maxRetries?: number;
+    jitterRatio?: number;
+  };
+  heartbeat?: { enabled?: boolean; interval?: number; timeout?: number };
+  ack?: { timeout?: number; autoResendOnTimeout?: boolean };
+}
+
+export interface NormalizedClawChatClientOptions {
+  url: string;
+  token: string;
+  deviceId?: string;
+  transport: Transport;
+  traceIdFactory: () => string;
+  reconnect: Required<NonNullable<ClawChatClientOptions["reconnect"]>>;
+  heartbeat: Required<NonNullable<ClawChatClientOptions["heartbeat"]>>;
+  ack: Required<NonNullable<ClawChatClientOptions["ack"]>>;
+}
+
+type PendingAck = {
+  timer: ReturnType<typeof setTimeout>;
+  resolve: (env: Envelope<MessageAckPayload>) => void;
+  reject: (err: Error) => void;
+};
+
+export class ClawChatClient extends EventEmitter {
+  private currentState: ConnState = "idle";
+  private connectResolve?: () => void;
+  private connectReject?: (err: Error) => void;
+  private heartbeatTimer?: ReturnType<typeof setInterval>;
+  private pongTimer?: ReturnType<typeof setTimeout>;
+  private reconnectTimer?: ReturnType<typeof setTimeout>;
+  private reconnectAttempts = 0;
+  private closing = false;
+  private authFailed = false;
+  private expectedConnectTraceId?: string;
+  private readonly pending = new Map<string, PendingAck>();
+  private readonly handledMessageErrorTraces = new Set<string>();
+  private readonly sendQueue: string[] = [];
+
+  constructor(private readonly opts: NormalizedClawChatClientOptions) {
+    super();
+  }
+
+  get state(): ConnState {
+    return this.currentState;
+  }
+
+  get transportState(): TransportState {
+    return this.opts.transport.state;
+  }
+
+  nextTraceId(): string {
+    return this.opts.traceIdFactory();
+  }
+
+  hasPendingAckTrace(traceId: string): boolean {
+    return this.pending.has(traceId);
+  }
+
+  markMessageErrorHandled(traceId: string): void {
+    this.handledMessageErrorTraces.add(traceId);
+  }
+
+  async connect(): Promise<void> {
+    this.closing = false;
+    this.authFailed = false;
+    const ready = new Promise<void>((resolve, reject) => {
+      this.connectResolve = resolve;
+      this.connectReject = reject;
+    });
+    void this.openTransport();
+    return await ready;
+  }
+
+  close(): void {
+    this.closing = true;
+    this.clearTimers();
+    this.rejectPending(new StateError("client closed"));
+    this.sendQueue.length = 0;
+    if (this.opts.transport.state === "closed") {
+      this.transition("disconnected");
+      return;
+    }
+    this.opts.transport.close(1000, "client close");
+  }
+
+  typing(chatId: string, isTyping = true): void {
+    this.sendRawEnvelope({
+      version: "2",
+      event: EVENT.TYPING_UPDATE,
+      trace_id: this.nextTraceId(),
+      emitted_at: Date.now(),
+      chat_id: chatId,
+      payload: { is_typing: isTyping },
+    });
+  }
+
+  emitRaw(event: string, payload: object, routing?: { chat_id?: string }): void {
+    this.sendRawEnvelope({
+      version: "2",
+      event,
+      trace_id: this.nextTraceId(),
+      emitted_at: Date.now(),
+      ...(routing?.chat_id ? { chat_id: routing.chat_id } : {}),
+      payload,
+    });
+  }
+
+  sendWire(wire: string, options: { bypassReconnectQueue?: boolean } = {}): void {
+    if (!options.bypassReconnectQueue && this.shouldQueueOutboundWire()) {
+      this.sendQueue.push(wire);
+      return;
+    }
+    if (this.opts.transport.state !== "open") {
+      throw new StateError(`cannot send while transport=${this.opts.transport.state}`);
+    }
+    this.opts.transport.send(wire);
+  }
+
+  sendRawEnvelope(env: Envelope): void {
+    this.sendWire(JSON.stringify(env), { bypassReconnectQueue: env.event === EVENT.CONNECT });
+  }
+
+  async sendAckableEnvelope(params: {
+    eventName: "message.send" | "message.reply";
+    chatId: string;
+    payload: object;
+  }): Promise<Envelope<MessageAckPayload>> {
+    const traceId = this.nextTraceId();
+    const env: Envelope = {
+      version: "2",
+      event: params.eventName,
+      trace_id: traceId,
+      emitted_at: Date.now(),
+      chat_id: params.chatId,
+      payload: params.payload,
+    };
+    return await new Promise<Envelope<MessageAckPayload>>((resolve, reject) => {
+      const entry: PendingAck = {
+        timer: setTimeout(() => {}, 0),
+        resolve,
+        reject,
+      };
+      const armTimer = () => {
+        entry.timer = setTimeout(() => {
+          if (this.opts.ack.autoResendOnTimeout && this.opts.transport.state === "open") {
+            try {
+              this.sendRawEnvelope(env);
+              armTimer();
+              return;
+            } catch (err) {
+              this.pending.delete(traceId);
+              reject(err instanceof Error ? err : new Error(String(err)));
+              return;
+            }
+          }
+          this.pending.delete(traceId);
+          reject(new AckTimeoutError(traceId, this.opts.ack.timeout));
+        }, this.opts.ack.timeout);
+      };
+      armTimer();
+      this.pending.set(traceId, entry);
+      try {
+        this.sendRawEnvelope(env);
+      } catch (err) {
+        clearTimeout(entry.timer);
+        this.pending.delete(traceId);
+        reject(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+  }
+
+  private async openTransport(): Promise<void> {
+    this.transition("connecting");
+    try {
+      await this.opts.transport.connect(this.opts.url, {
+        onOpen: () => this.transition("challenging"),
+        onMessage: (data) => this.handleWireMessage(data),
+        onClose: (code, reason) => this.handleClose(code, reason),
+        onError: (err) => this.emitError(new TransportError(err.message)),
+      });
+    } catch (err) {
+      const error = err instanceof Error ? new TransportError(err.message) : new TransportError(String(err));
+      this.emitError(error);
+      if (this.closing || this.authFailed || !this.opts.reconnect.enabled) {
+        this.transition("disconnected");
+        this.connectReject?.(error);
+        return;
+      }
+      this.scheduleReconnect(error.message);
+    }
+  }
+
+  private transition(next: ConnState): void {
+    const from = this.currentState;
+    if (from === next) return;
+    this.currentState = next;
+    this.emit("state", { from, to: next });
+  }
+
+  private handleWireMessage(data: string | Buffer): void {
+    let env: Envelope;
+    try {
+      const parsed = JSON.parse(String(data)) as unknown;
+      if (!parsed || typeof parsed !== "object") {
+        throw new ProtocolError("invalid envelope", parsed);
+      }
+      env = parsed as Envelope;
+      if (
+        env.version !== "2" ||
+        typeof env.event !== "string" ||
+        typeof env.trace_id !== "string" ||
+        typeof env.emitted_at !== "number" ||
+        !Object.prototype.hasOwnProperty.call(env, "payload")
+      ) {
+        throw new ProtocolError("invalid envelope", env);
+      }
+    } catch (err) {
+      this.emitError(err instanceof Error ? err : new ProtocolError(String(err)));
+      if (this.isHandshaking()) {
+        this.failHandshake(
+          err instanceof ProtocolError ? err : new ProtocolError(err instanceof Error ? err.message : String(err)),
+          4002,
+          "protocol error",
+        );
+      }
+      return;
+    }
+    this.emit("raw", env);
+    this.dispatchInbound(env);
+  }
+
+  private dispatchInbound(env: Envelope): void {
+    if (env.event === EVENT.CONNECT_CHALLENGE) return this.onChallenge(env);
+    if (env.event === EVENT.HELLO_OK) return this.onHelloOk(env);
+    if (env.event === EVENT.HELLO_FAIL) return this.onHelloFail(env);
+    if (env.event === EVENT.PING) return this.onPing(env);
+    if (env.event === EVENT.PONG) return this.onPong();
+    if (env.event === EVENT.MESSAGE_ACK) return this.onAck(env as Envelope<MessageAckPayload>);
+    if (env.event === EVENT.MESSAGE_ERROR) return this.onMessageError(env as Envelope<MessageErrorPayload>);
+    if (isBusinessDispatchEvent(env.event)) this.emit("message", env);
+    if (env.event === EVENT.MESSAGE_CREATED) this.emit("message:created", env);
+    if (env.event === EVENT.MESSAGE_ADD) this.emit("message:add", env);
+    if (env.event === EVENT.MESSAGE_DONE) this.emit("message:done", env);
+    if (env.event === EVENT.MESSAGE_FAILED) this.emit("message:failed", env);
+    if (env.event === EVENT.TYPING_UPDATE) this.emit("typing", env);
+    if (env.event === EVENT.CHAT_METADATA_INVALIDATED) this.emit("metadata:invalidated", env);
+    if (env.event === EVENT.OFFLINE_DONE) this.emit("offline:done");
+  }
+
+  private onChallenge(env: Envelope): void {
+    if (this.currentState !== "challenging") {
+      if (this.currentState === "connected" || this.currentState === "reconnecting") return;
+      this.failHandshake(new ProtocolError("unexpected challenge", env), 4002, "protocol error");
+      return;
+    }
+    const payload = env.payload && typeof env.payload === "object" ? env.payload as { nonce?: unknown } : {};
+    const nonce = payload.nonce;
+    if (typeof nonce !== "string" || !nonce) {
+      this.failHandshake(new ProtocolError("missing challenge nonce", env), 4002, "protocol error");
+      return;
+    }
+    this.transition("authenticating");
+    const connectPayload: ConnectPayload = {
+      token: this.opts.token,
+      nonce,
+      ...(this.opts.deviceId ? { device_id: this.opts.deviceId } : {}),
+      capabilities: { multi_device: true, device_replay: true, chat_meta_events: true },
+    };
+    const traceId = this.nextTraceId();
+    this.expectedConnectTraceId = traceId;
+    try {
+      this.sendRawEnvelope({
+        version: "2",
+        event: EVENT.CONNECT,
+        trace_id: traceId,
+        emitted_at: Date.now(),
+        payload: connectPayload,
+      });
+    } catch (err) {
+      this.failHandshake(err instanceof Error ? err : new TransportError(String(err)), 4003, "connect send failed");
+    }
+  }
+
+  private onHelloOk(env: Envelope): void {
+    const helloError = this.validateHelloEnvelope(env, "hello-ok");
+    if (helloError) {
+      this.failHandshake(helloError, 4002, "protocol error");
+      return;
+    }
+    this.expectedConnectTraceId = undefined;
+    this.emit("hello:ok", env);
+    this.transition("connected");
+    this.reconnectAttempts = 0;
+    this.startHeartbeat();
+    try {
+      this.flushSendQueue();
+    } catch (err) {
+      this.emitError(err instanceof Error ? err : new TransportError(String(err)));
+      this.opts.transport.close(4000, "queued send failed");
+      return;
+    }
+    this.connectResolve?.();
+    this.connectResolve = undefined;
+    this.connectReject = undefined;
+  }
+
+  private onHelloFail(env: Envelope): void {
+    const helloError = this.validateHelloEnvelope(env, "hello-fail");
+    if (helloError) {
+      this.failHandshake(helloError, 4002, "protocol error");
+      return;
+    }
+    const payload = env.payload && typeof env.payload === "object" ? env.payload as { reason?: unknown } : {};
+    const reason = payload.reason;
+    if (typeof reason !== "string" || !reason) {
+      this.failHandshake(new ProtocolError("invalid hello-fail payload", env), 4002, "protocol error");
+      return;
+    }
+    const err = new AuthError(typeof reason === "string" ? reason : "authentication failed");
+    this.authFailed = true;
+    this.expectedConnectTraceId = undefined;
+    this.sendQueue.length = 0;
+    this.clearTimers();
+    this.rejectPending(err);
+    this.connectReject?.(err);
+    this.connectResolve = undefined;
+    this.connectReject = undefined;
+    this.emitError(err);
+    this.transition("disconnected");
+    if (this.opts.transport.state !== "closed") {
+      this.opts.transport.close(4001, "auth failed");
+    }
+  }
+
+  private onPing(env: Envelope): void {
+    this.sendRawEnvelope({
+      version: "2",
+      event: EVENT.PONG,
+      trace_id: env.trace_id,
+      emitted_at: env.emitted_at,
+      payload: {} satisfies EmptyPayload,
+    });
+  }
+
+  private onPong(): void {
+    if (this.pongTimer) clearTimeout(this.pongTimer);
+    this.pongTimer = undefined;
+  }
+
+  private onAck(env: Envelope<MessageAckPayload>): void {
+    const entry = this.pending.get(env.trace_id);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    this.pending.delete(env.trace_id);
+    entry.resolve(env);
+  }
+
+  private onMessageError(env: Envelope<MessageErrorPayload>): void {
+    const entry = this.pending.get(env.trace_id);
+    if (!entry) {
+      if (this.handledMessageErrorTraces.delete(env.trace_id)) return;
+      console.warn(`clawchat.ws unmatched message.error trace_id=${env.trace_id} chat_id=${env.chat_id ?? "-"}`);
+      return;
+    }
+    clearTimeout(entry.timer);
+    this.pending.delete(env.trace_id);
+    const payload = env.payload && typeof env.payload === "object" ? env.payload : undefined;
+    const code = typeof payload?.code === "string" && payload.code ? payload.code : "unknown";
+    const message = typeof payload?.message === "string" && payload.message ? payload.message : "message send failed";
+    entry.reject(new MessageSendError(env.trace_id, code, message, env.chat_id));
+  }
+
+  private startHeartbeat(): void {
+    if (!this.opts.heartbeat.enabled) return;
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    this.heartbeatTimer = setInterval(() => {
+      try {
+        this.sendRawEnvelope({
+          version: "2",
+          event: EVENT.PING,
+          trace_id: this.nextTraceId(),
+          emitted_at: Date.now(),
+          payload: {} satisfies EmptyPayload,
+        });
+      } catch {
+        this.opts.transport.close(4000, "heartbeat send failed");
+        return;
+      }
+      if (this.pongTimer) clearTimeout(this.pongTimer);
+      this.pongTimer = setTimeout(
+        () => this.opts.transport.close(4000, "heartbeat timeout"),
+        this.opts.heartbeat.timeout,
+      );
+    }, this.opts.heartbeat.interval);
+  }
+
+  private handleClose(code: number, reason: string): void {
+    if (this.currentState === "reconnecting" && this.reconnectTimer) {
+      if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+      if (this.pongTimer) clearTimeout(this.pongTimer);
+      this.heartbeatTimer = undefined;
+      this.pongTimer = undefined;
+      this.emit("close", { code, reason });
+      return;
+    }
+    this.clearTimers();
+    this.emit("close", { code, reason });
+    const closeError = new TransportError(reason || "connection closed");
+    if (!this.closing) this.rejectPending(closeError);
+    if (this.closing || this.authFailed || !this.opts.reconnect.enabled) {
+      this.transition("disconnected");
+      this.connectReject?.(closeError);
+      return;
+    }
+    this.scheduleReconnect(reason || `close ${code}`);
+  }
+
+  private failHandshake(err: Error, code: number, reason: string): void {
+    this.clearTimers();
+    this.rejectPending(err);
+    this.expectedConnectTraceId = undefined;
+    this.sendQueue.length = 0;
+    this.connectReject?.(err);
+    this.connectResolve = undefined;
+    this.connectReject = undefined;
+    this.emitError(err);
+    this.transition("disconnected");
+    if (this.opts.transport.state !== "closed") {
+      this.closing = true;
+      this.opts.transport.close(code, reason);
+    }
+  }
+
+  private scheduleReconnect(reason: string): void {
+    if (this.reconnectTimer) return;
+    if (this.reconnectAttempts >= this.opts.reconnect.maxRetries) {
+      this.sendQueue.length = 0;
+      this.transition("disconnected");
+      this.connectReject?.(new TransportError(reason));
+      return;
+    }
+    this.reconnectAttempts += 1;
+    const baseDelay = Math.min(
+      this.opts.reconnect.maxDelay,
+      this.opts.reconnect.initialDelay * 2 ** Math.max(0, this.reconnectAttempts - 1),
+    );
+    const jitter = baseDelay * this.opts.reconnect.jitterRatio * Math.random();
+    const delay = Math.round(baseDelay + jitter);
+    this.transition("reconnecting");
+    this.emit("reconnect:scheduled", { reason, delay });
+    this.reconnectTimer = setTimeout(() => {
+      this.reconnectTimer = undefined;
+      void this.openTransport();
+    }, delay);
+  }
+
+  private clearTimers(): void {
+    if (this.heartbeatTimer) clearInterval(this.heartbeatTimer);
+    if (this.pongTimer) clearTimeout(this.pongTimer);
+    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
+    this.heartbeatTimer = undefined;
+    this.pongTimer = undefined;
+    this.reconnectTimer = undefined;
+  }
+
+  private rejectPending(err: Error): void {
+    for (const [traceId, entry] of this.pending) {
+      clearTimeout(entry.timer);
+      this.pending.delete(traceId);
+      entry.reject(err);
+    }
+  }
+
+  private emitError(err: Error): void {
+    if (this.listenerCount("error") > 0) this.emit("error", err);
+  }
+
+  private shouldQueueOutboundWire(): boolean {
+    if (!this.opts.reconnect.enabled || this.closing || this.authFailed) return false;
+    if (this.currentState === "reconnecting") return true;
+    return this.reconnectAttempts > 0 && this.isHandshaking();
+  }
+
+  private flushSendQueue(): void {
+    while (this.sendQueue.length > 0) {
+      const wire = this.sendQueue.shift()!;
+      try {
+        this.sendWire(wire);
+      } catch (err) {
+        this.sendQueue.unshift(wire);
+        throw err;
+      }
+    }
+  }
+
+  private isHandshaking(): boolean {
+    return this.currentState === "connecting" || this.currentState === "challenging" || this.currentState === "authenticating";
+  }
+
+  private validateHelloEnvelope(env: Envelope, eventName: "hello-ok" | "hello-fail"): ProtocolError | null {
+    if (this.currentState !== "authenticating" || env.trace_id !== this.expectedConnectTraceId) {
+      return new ProtocolError(`unexpected ${eventName}`, env);
+    }
+    if (!env.payload || typeof env.payload !== "object") {
+      return new ProtocolError(`invalid ${eventName} payload`, env);
+    }
+    return null;
+  }
+}
+
+export function createClawChatClient(options: ClawChatClientOptions): ClawChatClient {
+  return new ClawChatClient({
+    ...options,
+    transport: options.transport ?? createWebSocketTransport(),
+    traceIdFactory:
+      options.traceIdFactory ??
+      (() => `trace-${Date.now()}-${Math.random().toString(36).slice(2)}`),
+    reconnect: {
+      enabled: options.reconnect?.enabled ?? true,
+      initialDelay: options.reconnect?.initialDelay ?? 500,
+      maxDelay: options.reconnect?.maxDelay ?? 15000,
+      maxRetries: options.reconnect?.maxRetries ?? Number.POSITIVE_INFINITY,
+      jitterRatio: options.reconnect?.jitterRatio ?? 0.3,
+    },
+    heartbeat: {
+      enabled: options.heartbeat?.enabled ?? true,
+      interval: options.heartbeat?.interval ?? 20000,
+      timeout: options.heartbeat?.timeout ?? 10000,
+    },
+    ack: {
+      timeout: options.ack?.timeout ?? 15000,
+      autoResendOnTimeout: options.ack?.autoResendOnTimeout ?? false,
+    },
+  });
+}
+
+export type ClawlingChatClient = ClawChatClient;

package/src/ws-log.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from "vitest";
+import { formatWsLog, optionalField } from "./ws-log.ts";
+
+describe("clawchat ws log formatter", () => {
+  it("renders fixed field order and optional placeholders", () => {
+    expect(
+      formatWsLog({
+        event: "auth_failed",
+        accountId: "default",
+        attempt: 2,
+        reconnectCount: 1,
+        state: "auth_failed",
+        action: "stop_reconnect",
+        fields: [
+          ["trace_id", "trace-1"],
+          ["reason", ""],
+        ],
+      }),
+    ).toBe(
+      "clawchat.ws event=auth_failed account_id=default attempt=2 reconnect_count=1 state=auth_failed action=stop_reconnect trace_id=trace-1 reason=-",
+    );
+  });
+
+  it("normalizes absent values", () => {
+    expect(optionalField(undefined)).toBe("-");
+    expect(optionalField(null)).toBe("-");
+    expect(optionalField("")).toBe("-");
+    expect(optionalField("hello")).toBe("hello");
+    expect(optionalField(0)).toBe("0");
+    expect(optionalField(true)).toBe("true");
+  });
+});