Use auth cache as default source of truth across providers

Author: sleepyfran

packages/infrastructure/onedrive-provider/src/onedrive-provider.ts

@@ -26,13 +26,13 @@ export const OneDriveProviderLive = Layer.effect(
 
     return MediaProviderFactory.of({
       authenticationProvider: Effect.succeed(msalAuth),
-      createMediaProvider: (authInfo) => {
+      createMediaProvider: (fallbackAuthInfo) => {
         const options: ClientOptions = {
           authProvider: {
             getAccessToken: () =>
               Effect.runPromise(
                 authCache.get(FileBasedProviderId.OneDrive).pipe(
-                  Effect.map(Option.getOrElse(() => authInfo)),
+                  Effect.map(Option.getOrElse(() => fallbackAuthInfo)),
                   Effect.map((authInfo) => authInfo.accessToken),
                 ),
               ),

packages/infrastructure/spotify-player/index.ts

@@ -1,4 +1,6 @@
 import {
+  ApiBasedProviderId,
+  AuthenticationCache,
   MediaPlayerFactory,
   MediaPlayerId,
   ProviderType,
@@ -12,6 +14,7 @@ import {
   Effect,
   Layer,
   Match,
+  Option,
   pipe,
   Queue,
   Scope,
@@ -42,6 +45,7 @@ const { PlayTrack, TogglePlayback, Stop, Dispose } =
   Data.taggedEnum<SpotifyPlayerCommand>();
 
 const make = Effect.gen(function* () {
+  const authCache = yield* AuthenticationCache;
   const playerApi = yield* SpotifyPlayerApi;
   const layerScope = yield* Scope.make();
 
@@ -73,7 +77,12 @@ const make = Effect.gen(function* () {
           window.onSpotifyWebPlaybackSDKReady = () => {
             const player = new window.Spotify.Player({
               name: "Echo",
-              getOAuthToken: (cb) => cb(authInfo.accessToken),
+              getOAuthToken: (cb) =>
+                Effect.runPromise(
+                  authCache
+                    .get(ApiBasedProviderId.Spotify)
+                    .pipe(Effect.map(Option.getOrElse(() => authInfo))),
+                ).then((authInfo) => cb(authInfo.accessToken)),
               volume: 1.0,
             });
 

packages/infrastructure/spotify-provider/src/apis/list-albums-api.ts

@@ -9,6 +9,7 @@ import {
   type Album,
   type Artist,
   type AuthenticationInfo,
+  type IAuthenticationCache,
   type Track,
 } from "@echo/core-types";
 import type { SpotifyAlbumResponse } from "./types";
@@ -22,7 +23,8 @@ const initialState = {
  * Creates an effect that retrieves all the albums in the user's library.
  */
 export const createListAlbums = (
-  authInfo: AuthenticationInfo,
+  fallbackAuthInfo: AuthenticationInfo,
+  authCache: IAuthenticationCache,
   userLibraryApi: ISpotifyLibraryApi,
 ) =>
   Effect.iterate(initialState, {
@@ -35,9 +37,13 @@ export const createListAlbums = (
           return state;
         }
 
+        const authInfoOrFallback = yield* authCache
+          .get(ApiBasedProviderId.Spotify)
+          .pipe(Effect.map(Option.getOrElse(() => fallbackAuthInfo)));
+
         const response = yield* userLibraryApi
           .savedAlbums({
-            authInfo,
+            authInfo: authInfoOrFallback,
             offset: maybeOffset.value,
             limit: 50,
           })

packages/infrastructure/spotify-provider/src/spotify-provider.ts

@@ -1,4 +1,8 @@
-import { MediaProviderFactory, ProviderType } from "@echo/core-types";
+import {
+  AuthenticationCache,
+  MediaProviderFactory,
+  ProviderType,
+} from "@echo/core-types";
 import { Effect, Layer } from "effect";
 import { SpotifyAuthentication } from "./spotify-authentication";
 import { SpotifyLibraryApi } from "./apis/user-library-api";
@@ -13,14 +17,19 @@ import { createListAlbums } from "./apis/list-albums-api";
 export const SpotifyProviderLive = Layer.effect(
   MediaProviderFactory,
   Effect.gen(function* () {
+    const authCache = yield* AuthenticationCache;
     const spotifyAuth = yield* SpotifyAuthentication;
     const userLibraryApi = yield* SpotifyLibraryApi;
 
     return MediaProviderFactory.of({
       authenticationProvider: Effect.succeed(spotifyAuth),
-      createMediaProvider: (authInfo) => ({
+      createMediaProvider: (fallbackAuthInfo) => ({
         _tag: ProviderType.ApiBased,
-        listAlbums: createListAlbums(authInfo, userLibraryApi),
+        listAlbums: createListAlbums(
+          fallbackAuthInfo,
+          authCache,
+          userLibraryApi,
+        ),
       }),
     });
   }),

packages/services/bootstrap/src/loaders/player.ts

@@ -3,6 +3,7 @@ import {
   type ProviderMetadata,
   MediaPlayerFactory,
   ProviderType,
+  AuthenticationCache,
 } from "@echo/core-types";
 import { FetchHttpClient } from "@effect/platform";
 
@@ -27,7 +28,9 @@ export class LazyLoadedMediaPlayer extends Effect.Tag(
  */
 const lazyLoadFromMetadata = (
   metadata: ProviderMetadata,
-): Effect.Effect<Layer.Layer<MediaPlayerFactory, never, never>> => {
+): Effect.Effect<
+  Layer.Layer<MediaPlayerFactory, never, AuthenticationCache>
+> => {
   switch (metadata.type) {
     case ProviderType.FileBased:
       return Effect.promise(async () => {
@@ -61,17 +64,26 @@ const createLazyLoadedMediaPlayer = (metadata: ProviderMetadata) =>
 /**
  * A layer that can lazily load a media player based on the metadata provided.
  */
-export const LazyLoadedMediaPlayerLive = Layer.succeed(
+export const LazyLoadedMediaPlayerLive = Layer.effect(
   LazyLoadedMediaPlayer,
-  LazyLoadedMediaPlayer.of({
-    load: (metadata) =>
-      Effect.gen(function* () {
-        const mediaPlayerFactory = yield* lazyLoadFromMetadata(metadata);
+  Effect.gen(function* () {
+    const authCache = yield* AuthenticationCache;
+    const authCacheLayer = Layer.succeed(AuthenticationCache, authCache);
 
-        return yield* Effect.provide(
-          createLazyLoadedMediaPlayer(metadata),
-          mediaPlayerFactory,
-        );
-      }),
+    return LazyLoadedMediaPlayer.of({
+      load: (metadata) =>
+        Effect.gen(function* () {
+          const mediaPlayerFactory = yield* lazyLoadFromMetadata(metadata);
+
+          return yield* Effect.provide(
+            createLazyLoadedMediaPlayer(metadata),
+            // The auth cache requires a single instance for the whole application
+            // since the tokens are only stored in-memory, but since providers
+            // are lazy loaded and require the dependencies in place, we need
+            // to manually provide it from the environment.
+            mediaPlayerFactory.pipe(Layer.provide(authCacheLayer)),
+          );
+        }),
+    });
   }),
 );