import {
ClientCapabilities,
PlatformConnectionSource,
Persistence,
} from "@t3tools/client-runtime/platform";
import {
ConnectionBlockedError,
ConnectionTransientError,
Connectivity,
Wakeups,
} from "@t3tools/client-runtime/connection";
import { managedRelayAccountChanges, managedRelaySessionAtom } from "@t3tools/client-runtime/relay";
import * as Clock from "effect/Clock";
import * as Context from "effect/Context";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Option from "effect/Option";
import * as Queue from "effect/Queue";
import * as Stream from "effect/Stream";
import Constants from "expo-constants";
import * as Network from "expo-network";
import { AppState } from "react-native";
import { authClientMetadata } from "../lib/authClientMetadata";
import * as Runtime from "../lib/runtime";
import * as MobileStorage from "../persistence/mobile-storage";
import { appAtomRegistry } from "../state/atom-registry";
import { clearThreadOutboxEnvironment } from "../state/thread-outbox-removal";
import { clearComposerDraftsEnvironment } from "../state/use-composer-drafts";
import { clearThreadComposerErrorsForEnvironment } from "../state/thread-composer-error";
import { mobileApplicationActiveWakeup } from "./app-state-wakeups";
import * as ConnectionStorage from "./storage";
function networkStatus(state: Network.NetworkState): "unknown" | "offline" | "online" {
if (state.isConnected === false) {
return "offline";
}
if (state.isConnected === true) {
return "online";
}
return "unknown";
}
const layerConnectivity = Connectivity.layer({
status: Effect.tryPromise({
try: () => Network.getNetworkStateAsync(),
catch: () => undefined,
}).pipe(
Effect.match({
onFailure: () => "unknown" as const,
onSuccess: networkStatus,
}),
),
changes: Stream.callback((queue) =>
Effect.acquireRelease(
Effect.sync(() => {
let active = true;
const networkSubscription = Network.addNetworkStateListener((state) => {
Queue.offerUnsafe(queue, networkStatus(state));
});
const appStateSubscription = AppState.addEventListener("change", (state) => {
if (state !== "active") {
return;
}
void Network.getNetworkStateAsync()
.then((current) => {
if (active) {
Queue.offerUnsafe(queue, networkStatus(current));
}
})
.catch(() => undefined);
});
return {
close: () => {
active = false;
networkSubscription.remove();
appStateSubscription.remove();
},
};
}),
({ close }) => Effect.sync(close),
).pipe(Effect.asVoid),
),
});
/** Wake connections on network path changes; online/offline misses Wi-Fi-to-cellular moves. */
const networkPathChanges = Stream.callback<"network-changed">((queue) =>
Effect.acquireRelease(
Effect.sync(() => {
let active = true;
let previous: Network.NetworkStateType | undefined;
const record = (state: Network.NetworkState) => {
const type = state.isConnected === true ? state.type : undefined;
if (previous !== undefined && type !== undefined && type !== previous) {
Queue.offerUnsafe(queue, "network-changed");
}
previous = type ?? previous;
};
// Seed the current type: the listener reports only changes and would miss the first move.
void Network.getNetworkStateAsync()
.then((state) => {
if (active && previous === undefined && state.isConnected === true) {
previous = state.type;
}
})
.catch(() => undefined);
const subscription = Network.addNetworkStateListener(record);
return {
remove: () => {
active = false;
subscription.remove();
},
};
}),
(subscription) => Effect.sync(() => subscription.remove()),
).pipe(Effect.asVoid),
);
const layerWakeups = Wakeups.layer({
changes: Stream.mergeAll(
[
Stream.callback<"application-active-probe" | "application-active-long">((queue) =>
Effect.acquireRelease(
Effect.gen(function* () {
const nowMs = yield* Clock.currentTimeMillis;
let backgroundedAtMs = AppState.currentState === "background" ? nowMs : null;
return AppState.addEventListener("change", (state) => {
if (state === "background") {
backgroundedAtMs = Date.now();
return;
}
if (state === "active") {
Queue.offerUnsafe(
queue,
mobileApplicationActiveWakeup(backgroundedAtMs, Date.now()),
);
backgroundedAtMs = null;
}
});
}),
(subscription) => Effect.sync(() => subscription.remove()),
).pipe(Effect.asVoid),
),
managedRelayAccountChanges(appAtomRegistry).pipe(
Stream.map(() => "credentials-changed" as const),
),
networkPathChanges,
],
{ concurrency: "unbounded" },
),
});
const layerCapabilities = Layer.effectContext(
Effect.gen(function* () {
const storage = yield* MobileStorage.MobileStorage;
return Context.make(
ClientCapabilities.CloudSession,
ClientCapabilities.CloudSession.of({
identity: Effect.sync(() =>
Option.fromNullishOr(appAtomRegistry.get(managedRelaySessionAtom)),
),
clerkToken: Effect.gen(function* () {
const session = appAtomRegistry.get(managedRelaySessionAtom);
if (session === null) {
return yield* new ConnectionBlockedError({
reason: "authentication",
detail: "Sign in to T3 Connect to connect this environment.",
});
}
const token = yield* session.readClerkToken().pipe(
Effect.mapError(
(error) =>
new ConnectionTransientError({
reason: "network",
detail: error.message,
}),
),
);
if (token === null) {
return yield* new ConnectionBlockedError({
reason: "authentication",
detail: "The T3 Connect session is unavailable.",
});
}
return token;
}),
}),
).pipe(
Context.add(
ClientCapabilities.PrimaryEnvironmentAuth,
ClientCapabilities.PrimaryEnvironmentAuth.of({
bearerToken: Effect.succeedNone,
}),
),
// The relay device id already persists in secure storage; analytics only sends its hash.
Context.add(ClientCapabilities.AnalyticsDevice, {
id: storage.loadOrCreateAgentAwarenessDeviceId.pipe(Effect.option),
}),
Context.add(
ClientCapabilities.RelayDeviceIdentity,
ClientCapabilities.RelayDeviceIdentity.of({
deviceId: storage.loadOrCreateAgentAwarenessDeviceId.pipe(
Effect.mapError(
(cause) =>
new ConnectionTransientError({
reason: "remote-unavailable",
detail: `Could not load the mobile device identity: ${String(cause)}`,
}),
),
Effect.asSome,
),
}),
),
Context.add(
ClientCapabilities.ClientPresentation,
ClientCapabilities.ClientPresentation.of({
metadata: authClientMetadata(Constants.expoConfig?.version),
}),
),
Context.add(
ClientCapabilities.SshEnvironmentGateway,
ClientCapabilities.SshEnvironmentGateway.of({
provision: Effect.fn("ClientCapabilities.SshEnvironmentGateway.provision")(() =>
Effect.fail(
new ConnectionBlockedError({
reason: "unsupported",
detail: "SSH environments are only available in the desktop app.",
}),
),
),
prepare: Effect.fn("ClientCapabilities.SshEnvironmentGateway.prepare")(() =>
Effect.fail(
new ConnectionBlockedError({
reason: "unsupported",
detail: "SSH environments are only available in the desktop app.",
}),
),
),
disconnect: Effect.fn("ClientCapabilities.SshEnvironmentGateway.disconnect")(
() => Effect.void,
),
}),
),
);
}),
);
const layerPlatformConnectionSource = Layer.succeed(
PlatformConnectionSource.PlatformConnectionSource,
PlatformConnectionSource.PlatformConnectionSource.of({
registrations: Stream.empty,
}),
);
const layerProvidedConnectionStorage = ConnectionStorage.layer.pipe(Layer.provide(Runtime.layer));
const layerProvidedCapabilities = layerCapabilities.pipe(Layer.provide(Runtime.layer));
const layerEnvironmentOwnedDataCleanup = Layer.succeed(
Persistence.EnvironmentOwnedDataCleanup,
Persistence.EnvironmentOwnedDataCleanup.of({
clear: Effect.fn("Persistence.EnvironmentOwnedDataCleanup.clear")((environmentId) =>
Effect.all(
[
Effect.promise(() => clearThreadOutboxEnvironment(environmentId)),
Effect.promise(() => clearComposerDraftsEnvironment(environmentId)),
Effect.sync(() => clearThreadComposerErrorsForEnvironment(environmentId)),
],
{ concurrency: "unbounded", discard: true },
),
),
}),
);
type ConnectionPlatformLayerSource =
| typeof layerProvidedConnectionStorage
| typeof Runtime.layer
| typeof layerConnectivity
| typeof layerWakeups
| typeof layerProvidedCapabilities
| typeof layerPlatformConnectionSource
| typeof layerEnvironmentOwnedDataCleanup;
export const layer: Layer.Layer<
Layer.Success<ConnectionPlatformLayerSource>,
Layer.Error<ConnectionPlatformLayerSource>,
Layer.Services<ConnectionPlatformLayerSource>
> = Layer.mergeAll(
layerProvidedConnectionStorage,
Runtime.layer,
layerConnectivity,
layerWakeups,
layerProvidedCapabilities,
layerPlatformConnectionSource,
layerEnvironmentOwnedDataCleanup,
);