@mentra/crust 3.2.1 → 3.3.0-beta.1001

package/src/nativeHttpRequest.test.ts

@@ -0,0 +1,94 @@
+import {nativeHttpRequest, type NativeHttpResult, type NativeHttpTransport} from "./nativeHttpRequest"
+
+const response: NativeHttpResult = {status: 200, statusText: "OK", headers: {}, body: "{}"}
+
+function deferred<T>() {
+  let resolve!: (value: T) => void
+  let reject!: (error: unknown) => void
+  const promise = new Promise<T>((yes, no) => {
+    resolve = yes
+    reject = no
+  })
+  return {promise, resolve, reject}
+}
+
+function transport(request = deferred<NativeHttpResult>()) {
+  const native: NativeHttpTransport = {
+    nativeHttpRequest: jest.fn(() => request.promise),
+    cancelNativeHttpRequest: jest.fn(async () => {}),
+  }
+  return {native, request}
+}
+
+describe("nativeHttpRequest", () => {
+  test("pre-aborted requests do not start or cancel native work", async () => {
+    const {native} = transport()
+    const controller = new AbortController()
+    const reason = new Error("deadline")
+    controller.abort(reason)
+    await expect(nativeHttpRequest(native, "GET", "https://example.com", {}, null, controller.signal)).rejects.toBe(reason)
+    expect(native.nativeHttpRequest).not.toHaveBeenCalled()
+    expect(native.cancelNativeHttpRequest).not.toHaveBeenCalled()
+  })
+
+  test("abort cancels only this request and waits for native cancellation acceptance", async () => {
+    const {native, request} = transport()
+    const cancellation = deferred<void>()
+    native.cancelNativeHttpRequest = jest.fn(() => cancellation.promise)
+    const controller = new AbortController()
+    const remove = jest.spyOn(controller.signal, "removeEventListener")
+    const promise = nativeHttpRequest(native, "POST", "https://example.com", {test: "header"}, "body", controller.signal)
+    const rejected = expect(promise).rejects.toMatchObject({name: "AbortError"})
+    controller.abort()
+    const id = (native.nativeHttpRequest as jest.Mock).mock.calls[0][0]
+    expect(native.cancelNativeHttpRequest).toHaveBeenCalledWith(id)
+    expect(remove).not.toHaveBeenCalled()
+    request.reject(new Error("cancelled socket"))
+    cancellation.resolve()
+    await rejected
+    expect(native.cancelNativeHttpRequest).toHaveBeenCalledTimes(1)
+    expect(remove).toHaveBeenCalledWith("abort", expect.any(Function))
+  })
+
+  test("an abort during native start is cancelled after start and removes its listener", async () => {
+    const {native} = transport()
+    const controller = new AbortController()
+    const order: string[] = []
+    native.nativeHttpRequest = jest.fn(() => {
+      order.push("start")
+      controller.abort()
+      return new Promise<NativeHttpResult>(() => {})
+    })
+    native.cancelNativeHttpRequest = jest.fn(async () => {order.push("cancel")})
+    await expect(nativeHttpRequest(native, "GET", "https://example.com", {}, null, controller.signal)).rejects.toMatchObject({name: "AbortError"})
+    expect(order).toEqual(["start", "cancel"])
+  })
+
+  test.each(["success", "failure"])("%s removes its abort listener and a later abort does not cancel", async (outcome) => {
+    const {native, request} = transport()
+    const controller = new AbortController()
+    const remove = jest.spyOn(controller.signal, "removeEventListener")
+    const promise = nativeHttpRequest(native, "GET", "https://example.com", {}, null, controller.signal)
+    if (outcome === "success") {
+      request.resolve(response)
+      await expect(promise).resolves.toBe(response)
+    } else {
+      request.reject(new Error("offline"))
+      await expect(promise).rejects.toThrow("offline")
+    }
+    controller.abort()
+    expect(remove).toHaveBeenCalledTimes(1)
+    expect(native.cancelNativeHttpRequest).not.toHaveBeenCalled()
+  })
+
+  test("independent calls have separate IDs and unsignalled calls keep the native path", async () => {
+    const {native, request} = transport()
+    const first = nativeHttpRequest(native, "GET", "https://example.com/first", {}, null)
+    const second = nativeHttpRequest(native, "GET", "https://example.com/second", {}, null)
+    const calls = (native.nativeHttpRequest as jest.Mock).mock.calls
+    expect(calls[0][0]).not.toBe(calls[1][0])
+    request.resolve(response)
+    await Promise.all([first, second])
+    expect(native.cancelNativeHttpRequest).not.toHaveBeenCalled()
+  })
+})

package/src/nativeHttpRequest.ts

@@ -0,0 +1,74 @@
+export interface NativeHttpResult {
+  status: number
+  statusText: string
+  headers: Record<string, string>
+  body: string
+}
+
+export interface NativeHttpTransport {
+  nativeHttpRequest(
+    requestId: string,
+    method: string,
+    url: string,
+    headers: Record<string, string>,
+    body: string | null,
+  ): Promise<NativeHttpResult>
+  cancelNativeHttpRequest(requestId: string): Promise<void>
+}
+
+let requestSequence = 0
+
+function abortReason(signal: AbortSignal): unknown {
+  if (signal.reason !== undefined) return signal.reason
+  const error = new Error("Native HTTP request aborted")
+  error.name = "AbortError"
+  return error
+}
+
+/** Keep Android's background-safe HTTP path while cancelling its actual native request. */
+export function nativeHttpRequest(
+  native: NativeHttpTransport,
+  method: string,
+  url: string,
+  headers: Record<string, string>,
+  body: string | null,
+  signal?: AbortSignal,
+): Promise<NativeHttpResult> {
+  if (signal?.aborted) return Promise.reject(abortReason(signal))
+  const requestId = `http-${Date.now().toString(36)}-${++requestSequence}`
+  // Start first, then subscribe: Expo delivers start and cancel on the same serial queue.
+  const request = native.nativeHttpRequest(requestId, method, url, headers, body)
+  if (!signal) return request
+
+  return new Promise((resolve, reject) => {
+    let settled = false
+    let cancelling = false
+    const finish = (action: () => void) => {
+      if (settled) return
+      settled = true
+      signal.removeEventListener("abort", onAbort)
+      action()
+    }
+    const onAbort = () => {
+      if (settled || cancelling) return
+      cancelling = true
+      void native.cancelNativeHttpRequest(requestId).then(
+        () => finish(() => reject(abortReason(signal))),
+        (error: unknown) => finish(() => reject(error)),
+      )
+    }
+    request.then(
+      (result) => {
+        if (signal.aborted) onAbort()
+        else finish(() => resolve(result))
+      },
+      (error: unknown) => {
+        if (signal.aborted) onAbort()
+        else finish(() => reject(error))
+      },
+    )
+    signal.addEventListener("abort", onAbort, {once: true})
+    // Handles an abort fired synchronously during native registration.
+    if (signal.aborted) onAbort()
+  })
+}

package/android/src/internal/AndroidManifest.xml

@@ -1,9 +0,0 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android">
-  <application>
-    <receiver android:name="com.mentra.crust.receivers.CaptionsTesterIncidentReceiver" android:exported="true">
-      <intent-filter>
-        <action android:name="com.mentra.CAPTIONS_TESTER_INCIDENT"/>
-      </intent-filter>
-    </receiver>
-  </application>
-</manifest>

package/android/src/internal/java/com/mentra/crust/receivers/CaptionsTesterIncidentReceiver.kt

@@ -1,46 +0,0 @@
-package com.mentra.crust.receivers
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.util.Log
-import com.mentra.crust.CrustModule
-
-/**
- * Receives broadcasts from the external captions tester and forwards them into React Native so
- * the app can file a normal incident through the existing mobile incident pipeline.
- */
-class CaptionsTesterIncidentReceiver : BroadcastReceiver() {
-  @Suppress("DEPRECATION")
-  override fun onReceive(context: Context?, intent: Intent?) {
-    if (intent == null) {
-      Log.w("CaptionsTesterIncident", "Received null intent")
-      return
-    }
-
-    val body =
-      hashMapOf<String, Any>(
-        "action" to (intent.action ?: "unknown"),
-        "timestamp" to System.currentTimeMillis(),
-      )
-
-    intent.getStringExtra("failure_code")?.let { body["failure_code"] = it }
-    intent.getStringExtra("failure_message")?.let { body["failure_message"] = it }
-    intent.getStringExtra("test_run_id")?.let { body["test_run_id"] = it }
-    intent.getStringExtra("scenario_name")?.let { body["scenario_name"] = it }
-    intent.getStringExtra("source")?.let { body["source"] = it }
-
-    intent.extras?.keySet()?.forEach { key ->
-      if (body.containsKey(key)) {
-        return@forEach
-      }
-      val value = intent.extras?.get(key) ?: return@forEach
-      when (value) {
-        is String, is Int, is Long, is Boolean, is Double, is Float -> body[key] = value
-        else -> body[key] = value.toString()
-      }
-    }
-
-    CrustModule.emitCaptionsTesterIncident(body)
-  }
-}