import { ManagedRelay } from "@t3tools/client-runtime/relay";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as SecureStore from "expo-secure-store";
const MANAGED_RELAY_TOKEN_CACHE_KEY = "t3code.cloud.relay-access-tokens";
const MANAGED_RELAY_TOKEN_CACHE_VERSION = 1;
const ManagedRelayAccessTokenCacheEntrySchema = Schema.Struct({
accountId: Schema.String,
clientId: Schema.Literals(["t3-mobile", "t3-web"]),
relayUrl: Schema.String,
thumbprint: Schema.String,
scopes: Schema.Array(
Schema.Literals(["environment:connect", "environment:status", "mobile:registration"]),
),
accessToken: Schema.String,
expiresAtMillis: Schema.Number,
});
const ManagedRelayAccessTokenCacheSchema = Schema.fromJsonString(
Schema.Struct({
version: Schema.Literal(MANAGED_RELAY_TOKEN_CACHE_VERSION),
entries: Schema.Array(ManagedRelayAccessTokenCacheEntrySchema),
}),
);
const decodeManagedRelayAccessTokenCache = Schema.decodeUnknownEffect(
ManagedRelayAccessTokenCacheSchema,
);
const encodeManagedRelayAccessTokenCache = Schema.encodeEffect(ManagedRelayAccessTokenCacheSchema);
export class ManagedRelayTokenStoreError extends Schema.TaggedError<ManagedRelayTokenStoreError>()(
"ManagedRelayTokenStoreError",
{
operation: Schema.Literals(["read", "decode", "encode", "write", "clear"]),
storageKey: Schema.String,
cause: Schema.Defect(),
},
) {
override get message(): string {
return `Managed relay token store operation "${this.operation}" failed for key "${this.storageKey}".`;
}
}
function logStoreFailure(error: ManagedRelayTokenStoreError) {
return Effect.logWarning("Managed relay token store operation failed.", {
errorTag: error._tag,
operation: error.operation,
storageKey: error.storageKey,
cause: error,
});
}
const loadManagedRelayAccessTokens = Effect.tryPromise({
try: () => SecureStore.getItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY),
catch: (cause) =>
new ManagedRelayTokenStoreError({
operation: "read",
storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
cause,
}),
}).pipe(
Effect.flatMap((encoded) =>
encoded === null
? Effect.succeed<ReadonlyArray<ManagedRelay.ManagedRelayAccessTokenCacheEntry>>([])
: decodeManagedRelayAccessTokenCache(encoded).pipe(
Effect.map((cache) => cache.entries),
Effect.mapError(
(cause) =>
new ManagedRelayTokenStoreError({
operation: "decode",
storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
cause,
}),
),
),
),
);
const saveManagedRelayAccessTokens = (
entries: ReadonlyArray<ManagedRelay.ManagedRelayAccessTokenCacheEntry>,
) =>
encodeManagedRelayAccessTokenCache({
version: MANAGED_RELAY_TOKEN_CACHE_VERSION,
entries,
}).pipe(
Effect.mapError(
(cause) =>
new ManagedRelayTokenStoreError({
operation: "encode",
storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
cause,
}),
),
Effect.flatMap((encoded) =>
Effect.tryPromise({
try: () => SecureStore.setItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY, encoded),
catch: (cause) =>
new ManagedRelayTokenStoreError({
operation: "write",
storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
cause,
}),
}),
),
);
const clearManagedRelayAccessTokens = Effect.tryPromise({
try: () => SecureStore.deleteItemAsync(MANAGED_RELAY_TOKEN_CACHE_KEY),
catch: (cause) =>
new ManagedRelayTokenStoreError({
operation: "clear",
storageKey: MANAGED_RELAY_TOKEN_CACHE_KEY,
cause,
}),
});
export const managedRelayAccessTokenStore: ManagedRelay.ManagedRelayAccessTokenStore = {
load: loadManagedRelayAccessTokens.pipe(
Effect.tapError(logStoreFailure),
Effect.orElseSucceed(() => []),
Effect.withSpan("mobile.managedRelayTokenStore.load"),
),
save: Effect.fn("mobile.managedRelayTokenStore.save")((entries) =>
saveManagedRelayAccessTokens(entries).pipe(Effect.tapError(logStoreFailure), Effect.ignore),
),
clear: clearManagedRelayAccessTokens.pipe(
Effect.tapError(logStoreFailure),
Effect.ignore,
Effect.withSpan("mobile.managedRelayTokenStore.clear"),
),
};