@luxexchange/sessions 1.0.0

package/src/session-service/createSessionService.test.ts

@@ -0,0 +1,388 @@
+import type { DeviceIdService } from '@luxfi/sessions/src/device-id/types'
+import type { SessionRepository } from '@luxfi/sessions/src/session-repository/types'
+import { createSessionService } from '@luxfi/sessions/src/session-service/createSessionService'
+import type { SessionService } from '@luxfi/sessions/src/session-service/types'
+import type { SessionStorage } from '@luxfi/sessions/src/session-storage/types'
+import type { LuxIdentifierService } from '@luxfi/sessions/src/lux-identifier/types'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+describe('createSessionService', () => {
+  let storage: SessionStorage
+  let repository: SessionRepository
+  let deviceIdService: DeviceIdService
+  let luxIdentifierService: LuxIdentifierService
+  let service: SessionService
+
+  beforeEach(() => {
+    // In-memory storage implementation
+    let data: { sessionId: string } | null = null
+    storage = {
+      get: async (): Promise<{ sessionId: string } | null> => data,
+      set: async (newData): Promise<void> => {
+        data = newData
+      },
+      clear: async (): Promise<void> => {
+        data = null
+      },
+    }
+
+    let deviceIdData: string | null = null
+    deviceIdService = {
+      getDeviceId: async (): Promise<string> => deviceIdData || '',
+      setDeviceId: async (deviceId: string): Promise<void> => {
+        deviceIdData = deviceId
+      },
+      removeDeviceId: async (): Promise<void> => {
+        deviceIdData = null
+      },
+    }
+
+    let luxIdentifierData: string | null = null
+    luxIdentifierService = {
+      getLuxIdentifier: async (): Promise<string | null> => luxIdentifierData,
+      setLuxIdentifier: async (identifier: string): Promise<void> => {
+        luxIdentifierData = identifier
+      },
+      removeLuxIdentifier: async (): Promise<void> => {
+        luxIdentifierData = null
+      },
+    }
+
+    // In-memory repository implementation
+    repository = {
+      initSession: async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'test-session-123',
+        needChallenge: false,
+        extra: {},
+      }),
+      challenge: vi.fn(),
+      verifySession: vi.fn(),
+      deleteSession: vi.fn(),
+    }
+
+    service = createSessionService({
+      sessionStorage: storage,
+      sessionRepository: repository,
+      deviceIdService,
+      luxIdentifierService,
+    })
+  })
+
+  describe('session lifecycle', () => {
+    it('starts with no session', async () => {
+      expect(await service.getSessionState()).toBeNull()
+    })
+
+    it('creates and retrieves sessions', async () => {
+      await service.initSession()
+      expect(await service.getSessionState()).toEqual({ sessionId: 'test-session-123' })
+    })
+
+    it('removes sessions', async () => {
+      await service.initSession()
+      await service.removeSession()
+      expect(await service.getSessionState()).toBeNull()
+    })
+
+    it('uses repository to generate session', async () => {
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'custom-session-456',
+        needChallenge: false,
+        extra: {},
+      })
+
+      service = createSessionService({
+        sessionStorage: storage,
+        sessionRepository: repository,
+        deviceIdService,
+        luxIdentifierService,
+      })
+
+      await service.initSession()
+      expect(await service.getSessionState()).toEqual({ sessionId: 'custom-session-456' })
+    })
+  })
+
+  describe('platform-specific behaviors', () => {
+    it('stores session ID when provided (mobile/extension)', async () => {
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'mobile-session-123',
+        needChallenge: false,
+        extra: {},
+      })
+
+      await service.initSession()
+      expect(await service.getSessionState()).toEqual({ sessionId: 'mobile-session-123' })
+    })
+
+    it('does not store session when ID is undefined (web)', async () => {
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: undefined, // Web uses cookies
+        needChallenge: true,
+        extra: { sitekey: 'turnstile-key' },
+      })
+
+      await service.initSession()
+      expect(await service.getSessionState()).toBeNull()
+    })
+
+    it('handles different session ID values correctly', async () => {
+      const sessionIds = ['mobile-123', 'extension-456', undefined]
+
+      for (const sessionId of sessionIds) {
+        // Reset storage
+        await service.removeSession()
+
+        repository.initSession = async (): Promise<{
+          sessionId?: string
+          needChallenge: boolean
+          extra: Record<string, string>
+        }> => ({
+          sessionId,
+          needChallenge: false,
+          extra: {},
+        })
+
+        await service.initSession()
+
+        if (sessionId) {
+          expect(await service.getSessionState()).toEqual({ sessionId })
+        } else {
+          expect(await service.getSessionState()).toBeNull()
+        }
+      }
+    })
+  })
+
+  describe('state persistence', () => {
+    it('shares state between service instances using same storage', async () => {
+      await service.initSession()
+
+      const service2 = createSessionService({
+        sessionStorage: storage,
+        sessionRepository: repository,
+        deviceIdService,
+        luxIdentifierService,
+      })
+
+      expect(await service2.getSessionState()).toEqual({ sessionId: 'test-session-123' })
+    })
+
+    it('maintains independent state with different storage instances', async () => {
+      // Create second set of dependencies
+      let data2: { sessionId: string } | null = null
+      const storage2: SessionStorage = {
+        get: async (): Promise<{ sessionId: string } | null> => data2,
+        set: async (newData): Promise<void> => {
+          data2 = newData
+        },
+        clear: async (): Promise<void> => {
+          data2 = null
+        },
+      }
+
+      const service2 = createSessionService({
+        sessionStorage: storage2,
+        sessionRepository: repository,
+        deviceIdService,
+        luxIdentifierService,
+      })
+
+      await service.initSession()
+
+      // Second service with its own storage should have its own session
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'test-session-456',
+        needChallenge: false,
+        extra: {},
+      })
+
+      await service2.initSession()
+
+      expect(await service.getSessionState()).toEqual({ sessionId: 'test-session-123' })
+      expect(await service2.getSessionState()).toEqual({ sessionId: 'test-session-456' })
+    })
+  })
+
+  describe('error handling', () => {
+    it('propagates storage read errors', async () => {
+      storage.get = async (): Promise<{ sessionId: string } | null> => {
+        throw new Error('Storage read failed')
+      }
+
+      await expect(service.getSessionState()).rejects.toThrow('Storage read failed')
+    })
+
+    it('propagates storage write errors', async () => {
+      storage.set = async (): Promise<void> => {
+        throw new Error('Storage write failed')
+      }
+
+      await expect(service.initSession()).rejects.toThrow('Storage write failed')
+    })
+
+    it('propagates repository errors', async () => {
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => {
+        throw new Error('API call failed')
+      }
+
+      await expect(service.initSession()).rejects.toThrow('API call failed')
+    })
+
+    it('preserves state when operations fail', async () => {
+      await service.initSession()
+      const originalState = await service.getSessionState()
+
+      // Make clear fail
+      storage.clear = async (): Promise<void> => {
+        throw new Error('Clear failed')
+      }
+
+      await expect(service.removeSession()).rejects.toThrow('Clear failed')
+      expect(await service.getSessionState()).toEqual(originalState)
+    })
+  })
+
+  describe('integration scenarios', () => {
+    it('handles complete session lifecycle', async () => {
+      // Start with no session
+      expect(await service.getSessionState()).toBeNull()
+
+      // Create session
+      await service.initSession()
+      const session = await service.getSessionState()
+      expect(session).toBeTruthy()
+      expect(session?.sessionId).toBe('test-session-123')
+
+      // Remove session
+      await service.removeSession()
+      expect(await service.getSessionState()).toBeNull()
+    })
+
+    it('handles multiple initialization attempts', async () => {
+      // First initialization
+      await service.initSession()
+      const firstSession = await service.getSessionState()
+
+      // Second initialization should replace
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'new-session-789',
+        needChallenge: false,
+        extra: {},
+      })
+
+      await service.initSession()
+      const secondSession = await service.getSessionState()
+
+      expect(secondSession).not.toEqual(firstSession)
+      expect(secondSession).toEqual({ sessionId: 'new-session-789' })
+    })
+  })
+  describe('device ID handling', () => {
+    it('sets and gets device ID', async () => {
+      // Second initialization should replace
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        deviceId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'new-session-789',
+        deviceId: 'test-device-id',
+        needChallenge: false,
+        extra: {},
+      })
+
+      await service.initSession()
+      expect(await deviceIdService.getDeviceId()).toBe('test-device-id')
+    })
+  })
+
+  describe('lux identifier handling', () => {
+    it('persists luxIdentifier when provided in extra', async () => {
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'test-session-123',
+        needChallenge: false,
+        extra: { luxIdentifier: '71cef16f-4d99-4082-987c-a6f810f9ca7f' },
+      })
+
+      await service.initSession()
+      expect(await luxIdentifierService.getLuxIdentifier()).toBe('71cef16f-4d99-4082-987c-a6f810f9ca7f')
+    })
+
+    it('does not persist luxIdentifier when not provided', async () => {
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'test-session-123',
+        needChallenge: false,
+        extra: {},
+      })
+
+      await service.initSession()
+      expect(await luxIdentifierService.getLuxIdentifier()).toBeNull()
+    })
+
+    it('updates luxIdentifier on subsequent initSession calls', async () => {
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'test-session-123',
+        needChallenge: false,
+        extra: { luxIdentifier: 'first-identifier' },
+      })
+
+      await service.initSession()
+      expect(await luxIdentifierService.getLuxIdentifier()).toBe('first-identifier')
+
+      repository.initSession = async (): Promise<{
+        sessionId?: string
+        needChallenge: boolean
+        extra: Record<string, string>
+      }> => ({
+        sessionId: 'test-session-456',
+        needChallenge: false,
+        extra: { luxIdentifier: 'second-identifier' },
+      })
+
+      await service.initSession()
+      expect(await luxIdentifierService.getLuxIdentifier()).toBe('second-identifier')
+    })
+  })
+})

package/src/session-service/createSessionService.ts

@@ -0,0 +1,61 @@
+import type { DeviceIdService } from '@luxexchange/sessions/src/device-id/types'
+import type { SessionRepository } from '@luxexchange/sessions/src/session-repository/types'
+import type {
+  ChallengeRequest,
+  ChallengeResponse,
+  InitSessionResponse,
+  SessionService,
+  VerifySessionRequest,
+  VerifySessionResponse,
+} from '@luxexchange/sessions/src/session-service/types'
+import type { SessionStorage } from '@luxexchange/sessions/src/session-storage/types'
+import type { LuxIdentifierService } from '@luxexchange/sessions/src/lux-identifier/types'
+
+/**
+ * Creates a Session Service instance.
+ * Orchestrates usage of the Session Repository (remote) and Session Storage (local).
+ */
+export function createSessionService(ctx: {
+  sessionStorage: SessionStorage
+  deviceIdService: DeviceIdService
+  luxIdentifierService: LuxIdentifierService
+  sessionRepository: SessionRepository
+}): SessionService {
+  async function initSession(): Promise<InitSessionResponse> {
+    const result = await ctx.sessionRepository.initSession()
+    if (result.sessionId) {
+      await ctx.sessionStorage.set({ sessionId: result.sessionId })
+    }
+    if (result.deviceId) {
+      await ctx.deviceIdService.setDeviceId(result.deviceId)
+    }
+    if (result.extra['luxIdentifier']) {
+      await ctx.luxIdentifierService.setLuxIdentifier(result.extra['luxIdentifier'])
+    }
+    return result
+  }
+
+  async function requestChallenge(request?: ChallengeRequest): Promise<ChallengeResponse> {
+    return ctx.sessionRepository.challenge(request ?? {})
+  }
+
+  async function verifySession(input: VerifySessionRequest): Promise<VerifySessionResponse> {
+    return ctx.sessionRepository.verifySession(input)
+  }
+
+  async function removeSession(): Promise<void> {
+    await ctx.sessionStorage.clear()
+  }
+
+  async function getSessionState(): Promise<{ sessionId: string } | null> {
+    return ctx.sessionStorage.get()
+  }
+
+  return {
+    initSession,
+    requestChallenge,
+    verifySession,
+    removeSession,
+    getSessionState,
+  }
+}

package/src/session-service/types.ts

@@ -0,0 +1,59 @@
+import { ChallengeType } from '@uniswap/client-platform-service/dist/uniswap/platformservice/v1/sessionService_pb'
+import type { TypedChallengeData } from '@luxexchange/sessions/src/session-repository/types'
+import { SessionState } from '@luxexchange/sessions/src/session-storage/types'
+
+interface InitSessionResponse {
+  sessionId?: string
+  needChallenge: boolean
+  /** @deprecated Kept for backwards compatibility */
+  extra: Record<string, string>
+}
+
+interface ChallengeRequest {
+  challengeType?: ChallengeType
+  redirectUrl?: string
+}
+
+interface ChallengeResponse {
+  challengeId: string
+  challengeType: ChallengeType
+  /** @deprecated Use challengeData instead */
+  extra: Record<string, string>
+  /** Type-safe challenge-specific data (replaces extra) */
+  challengeData?: TypedChallengeData
+  authorizeUrl?: string
+}
+
+interface VerifySessionRequest {
+  solution: string
+  challengeId: string
+  challengeType: ChallengeType
+}
+
+interface VerifySessionResponse {
+  retry: boolean
+  waitSeconds?: number
+  redirectUrl?: string
+}
+
+/**
+ * Interface used by clients to interact with Sessions.
+ * For business logic and dependencies, see {@link createSessionService}
+ */
+interface SessionService {
+  initSession: () => Promise<InitSessionResponse>
+  requestChallenge: (request?: ChallengeRequest) => Promise<ChallengeResponse>
+  verifySession: (input: VerifySessionRequest) => Promise<VerifySessionResponse>
+  removeSession: () => Promise<void>
+  getSessionState: () => Promise<SessionState | null>
+}
+
+export type {
+  SessionService,
+  InitSessionResponse,
+  ChallengeRequest,
+  ChallengeResponse,
+  VerifySessionRequest,
+  VerifySessionResponse,
+}
+export { ChallengeType }

package/src/session-storage/createSessionStorage.ts

@@ -0,0 +1,28 @@
+import { SessionStorage } from '@luxfi/sessions/src/session-storage/types'
+
+/**
+ * Creates a Session Storage instance, given a set of functions to interact with a storage driver.
+ */
+function createSessionStorage(ctx: {
+  getSessionId: () => Promise<string | null>
+  setSessionId: (sessionId: string) => Promise<void>
+  clearSessionId: () => Promise<void>
+}): SessionStorage {
+  const get: SessionStorage['get'] = async () => {
+    const stored = await ctx.getSessionId()
+    return stored ? { sessionId: stored } : null
+  }
+  const set: SessionStorage['set'] = async (sessionState) => {
+    await ctx.setSessionId(sessionState.sessionId)
+  }
+  const clear: SessionStorage['clear'] = async () => {
+    await ctx.clearSessionId()
+  }
+  return {
+    get,
+    set,
+    clear,
+  }
+}
+
+export { createSessionStorage }

package/src/session-storage/types.ts

@@ -0,0 +1,15 @@
+interface SessionState {
+  sessionId: string
+}
+
+/**
+ * Interface to interact with session storage.
+ * For business logic and dependencies, see {@link createSessionStorage}
+ */
+interface SessionStorage {
+  get(): Promise<SessionState | null>
+  set(session: SessionState): Promise<void>
+  clear(): Promise<void>
+}
+
+export type { SessionStorage, SessionState }