@passlock/client 0.9.22 → 0.9.24

package/src/social/social.test.ts

@@ -1,9 +1,11 @@
-import { Duplicate, NotFound } from '@passlock/shared/dist/error/error.js'
-import { SocialClient } from '@passlock/shared/dist/rpc/social.js'
 import { Effect as E, Layer as L, Layer, LogLevel, Logger, pipe } from 'effect'
 import { describe, expect, test } from 'vitest'
 import { mock } from 'vitest-mock-extended'
+
+import { Duplicate, NotFound } from '@passlock/shared/dist/error/error.js'
+
 import * as Fixture from './social.fixture.js'
+import { SocialClient } from '../rpc/social.js'
 import { SocialService, SocialServiceLive } from './social.js'
 
 describe('registerOidc should', () => {
@@ -25,10 +27,7 @@ describe('registerOidc should', () => {
       }),
     )
 
-    const service = pipe(
-      SocialServiceLive,
-      L.provide(rpcClientTest),
-    )
+    const service = pipe(SocialServiceLive, L.provide(rpcClientTest))
 
     const layers = Layer.merge(service, rpcClientTest)
     const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
@@ -42,7 +41,7 @@ describe('registerOidc should', () => {
       yield* _(service.registerOidc(Fixture.registerOidcReq))
 
       const rpcClient = yield* _(SocialClient)
-      expect(rpcClient.registerOidc).toHaveBeenCalledWith(Fixture.rpcRegisterReq)
+      expect(rpcClient.registerOidc).toHaveBeenCalledWith(Fixture.registerOidcReq)
     })
 
     const rpcClientTest = L.effect(
@@ -56,10 +55,7 @@ describe('registerOidc should', () => {
       }),
     )
 
-    const service = pipe(
-      SocialServiceLive,
-      L.provide(rpcClientTest),
-    )
+    const service = pipe(SocialServiceLive, L.provide(rpcClientTest))
 
     const layers = Layer.merge(service, rpcClientTest)
     const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
@@ -81,16 +77,13 @@ describe('registerOidc should', () => {
       E.sync(() => {
         const rpcMock = mock<SocialClient['Type']>()
 
-        rpcMock.registerOidc.mockReturnValue(E.fail(new Duplicate({ message: "Duplicate user" })))
+        rpcMock.registerOidc.mockReturnValue(E.fail(new Duplicate({ message: 'Duplicate user' })))
 
         return rpcMock
       }),
     )
 
-    const service = pipe(
-      SocialServiceLive,
-      L.provide(rpcClientTest),
-    )
+    const service = pipe(SocialServiceLive, L.provide(rpcClientTest))
 
     const layers = Layer.merge(service, rpcClientTest)
     const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
@@ -118,10 +111,7 @@ describe('authenticateIodc should', () => {
       }),
     )
 
-    const service = pipe(
-      SocialServiceLive,
-      L.provide(rpcClientTest),
-    )
+    const service = pipe(SocialServiceLive, L.provide(rpcClientTest))
 
     const layers = Layer.merge(service, rpcClientTest)
     const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
@@ -135,7 +125,7 @@ describe('authenticateIodc should', () => {
       yield* _(service.authenticateOidc(Fixture.authOidcReq))
 
       const rpcClient = yield* _(SocialClient)
-      expect(rpcClient.authenticateOidc).toHaveBeenCalledWith(Fixture.rpcAuthenticateReq)
+      expect(rpcClient.authenticateOidc).toHaveBeenCalledWith(Fixture.authOidcReq)
     })
 
     const rpcClientTest = L.effect(
@@ -149,10 +139,7 @@ describe('authenticateIodc should', () => {
       }),
     )
 
-    const service = pipe(
-      SocialServiceLive,
-      L.provide(rpcClientTest),
-    )
+    const service = pipe(SocialServiceLive, L.provide(rpcClientTest))
 
     const layers = Layer.merge(service, rpcClientTest)
     const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
@@ -174,16 +161,15 @@ describe('authenticateIodc should', () => {
       E.sync(() => {
         const rpcMock = mock<SocialClient['Type']>()
 
-        rpcMock.authenticateOidc.mockReturnValue(E.fail(new NotFound({ message: "User not found" })))
+        rpcMock.authenticateOidc.mockReturnValue(
+          E.fail(new NotFound({ message: 'User not found' })),
+        )
 
         return rpcMock
       }),
     )
 
-    const service = pipe(
-      SocialServiceLive,
-      L.provide(rpcClientTest),
-    )
+    const service = pipe(SocialServiceLive, L.provide(rpcClientTest))
 
     const layers = Layer.merge(service, rpcClientTest)
     const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))

package/src/social/social.ts

@@ -1,51 +1,37 @@
 /**
  * Passkey authentication effects
  */
-import {
-  type BadRequest,
-  type NotSupported
-} from '@passlock/shared/dist/error/error.js'
-import * as Shared from '@passlock/shared/dist/rpc/social.js'
-import { SocialClient } from '@passlock/shared/dist/rpc/social.js'
-import type {
-  Principal
-} from '@passlock/shared/dist/schema/principal.js'
 import { Context, Effect as E, Layer, flow } from 'effect'
 
+import * as RPC from '@passlock/shared/dist/rpc/social.js'
+import { type BadRequest, type NotSupported } from '@passlock/shared/dist/error/error.js'
+import type { Principal } from '@passlock/shared/dist/schema/principal.js'
+
+import { SocialClient } from '../rpc/social.js'
+
 /* Requests */
 
 export type Provider = 'apple' | 'google'
 
-export type RegisterOidcReq = {
-  provider: Provider
-  idToken: string
-  nonce: string
-  givenName?: string
-  familyName?: string
-}
+export type RegisterOidcReq = RPC.RegisterOidcReq
 
-export type AuthenticateOidcReq = {
-  provider: Provider
-  idToken: string
-  nonce: string
-}
+export type AuthenticateOidcReq = RPC.AuthOidcReq
 
 /* Errors */
 
-export type RegistrationErrors = NotSupported | BadRequest | Shared.RegisterOidcErrors
+export type RegistrationErrors = NotSupported | BadRequest | RPC.RegisterOidcErrors
 
-export type AuthenticationErrors = NotSupported | BadRequest | Shared.AuthOidcErrors
+export type AuthenticationErrors = NotSupported | BadRequest | RPC.AuthOidcErrors
 
 /* Service */
 
-export type SocialService = {
-  registerOidc: (data: RegisterOidcReq) => E.Effect<Principal, RegistrationErrors>
-  authenticateOidc: (data: AuthenticateOidcReq) => E.Effect<Principal, AuthenticationErrors>
-}
-
-export const SocialService = Context.GenericTag<SocialService>(
-  '@services/SocialService',
-)
+export class SocialService extends Context.Tag('@services/SocialService')<
+  SocialService,
+  {
+    registerOidc: (req: RegisterOidcReq) => E.Effect<Principal, RegistrationErrors>
+    authenticateOidc: (req: AuthenticateOidcReq) => E.Effect<Principal, AuthenticationErrors>
+  }
+>() {}
 
 /* Effects */
 
@@ -58,16 +44,8 @@ export const registerOidc = (
     yield* _(E.logInfo('Registering social account'))
 
     const rpcClient = yield* _(SocialClient)
-
-    const rpcRequest = new Shared.RegisterOidcReq({
-      ...request,
-      ...(request.givenName ? { givenName: request.givenName } : {}),
-      ...(request.familyName ? { familyName: request.familyName } : {})
-    })
-
-    const { principal } = yield* _(
-      rpcClient.registerOidc(rpcRequest)
-    )
+    const rpcRequest = new RPC.RegisterOidcReq(request)
+    const { principal } = yield* _(rpcClient.registerOidc(rpcRequest))
 
     return principal
   })
@@ -80,11 +58,8 @@ export const authenticateOidc = (
     yield* _(E.logInfo('Authenticating with social account'))
 
     const rpcClient = yield* _(SocialClient)
-    const rpcRequest = new Shared.AuthOidcReq(request)
-
-    const { principal } = yield* _(
-      rpcClient.authenticateOidc(rpcRequest)
-    )
+    const rpcRequest = new RPC.AuthOidcReq(request)
+    const { principal } = yield* _(rpcClient.authenticateOidc(rpcRequest))
 
     return principal
   })
@@ -100,7 +75,7 @@ export const SocialServiceLive = Layer.effect(
 
     return SocialService.of({
       registerOidc: flow(registerOidc, E.provide(context)),
-      authenticateOidc: flow(authenticateOidc, E.provide(context))
+      authenticateOidc: flow(authenticateOidc, E.provide(context)),
     })
   }),
 )

package/src/storage/storage.fixture.ts

@@ -1,15 +1,15 @@
 import { Effect as E, Layer, pipe } from 'effect'
 import { mock } from 'vitest-mock-extended'
-import { Storage, StorageServiceLive } from './storage.js'
+
+import { BrowserStorage, StorageServiceLive } from './storage.js'
 
 const storageTest = Layer.effect(
-  Storage,
+  BrowserStorage,
   E.sync(() => mock<Storage>()),
 )
 
-export const testLayers = (storage: Layer.Layer<Storage> = storageTest) => {
+export const testLayers = (storage: Layer.Layer<BrowserStorage> = storageTest) => {
   const storageService = pipe(StorageServiceLive, Layer.provide(storage))
-
   return Layer.merge(storage, storageService)
 }
 

package/src/storage/storage.test.ts

@@ -1,8 +1,15 @@
 import { Effect as E, Layer, LogLevel, Logger, identity, pipe } from 'effect'
 import { describe, expect, test } from 'vitest'
 import { mock } from 'vitest-mock-extended'
+
 import { principal, testLayers } from './storage.fixture.js'
-import { Storage, StorageService, clearExpiredToken, clearToken, getToken } from './storage.js'
+import {
+  BrowserStorage,
+  StorageService,
+  clearExpiredToken,
+  clearToken,
+  getToken,
+} from './storage.js'
 
 // eslint chokes on expect(storage.setItem) etc
 /* eslint @typescript-eslint/unbound-method: 0 */
@@ -13,7 +20,7 @@ describe('storeToken should', () => {
       const service = yield* _(StorageService)
       yield* _(service.storeToken(principal))
 
-      const storage = yield* _(Storage)
+      const storage = yield* _(BrowserStorage)
       expect(storage.setItem).toHaveBeenCalled()
     })
 
@@ -30,7 +37,7 @@ describe('storeToken should', () => {
       const service = yield* _(StorageService)
       yield* _(service.storeToken(principal))
 
-      const storage = yield* _(Storage)
+      const storage = yield* _(BrowserStorage)
       expect(storage.setItem).toHaveBeenCalledWith('passlock:passkey:token', expect.any(String))
     })
 
@@ -47,10 +54,13 @@ describe('storeToken should', () => {
       const service = yield* _(StorageService)
       yield* _(service.storeToken(principal))
 
-      const storage = yield* _(Storage)
-      const token = principal.token
-      const expiry = principal.expireAt.getTime()
-      expect(storage.setItem).toHaveBeenCalledWith('passlock:passkey:token', `${token}:${expiry}`)
+      const storage = yield* _(BrowserStorage)
+      const token = principal.jti
+      const expiry = principal.exp.getTime()
+      expect(storage.setItem).toHaveBeenCalledWith(
+        'passlock:passkey:token',
+        `${token}:${expiry.toFixed(0)}`,
+      )
     })
 
     const effect = pipe(
@@ -68,17 +78,17 @@ describe('getToken should', () => {
       const service = yield* _(StorageService)
       yield* _(service.getToken('passkey'))
 
-      const storage = yield* _(Storage)
+      const storage = yield* _(BrowserStorage)
       expect(storage.getItem).toHaveBeenCalled()
       expect(storage.getItem).toHaveBeenCalledWith('passlock:passkey:token')
     })
 
     const storageTest = Layer.effect(
-      Storage,
+      BrowserStorage,
       E.sync(() => {
         const mockStorage = mock<Storage>()
         const expiry = Date.now() + 1000
-        mockStorage.getItem.mockReturnValue(`token:${expiry}`)
+        mockStorage.getItem.mockReturnValue(`token:${expiry.toFixed(0)}`)
         return mockStorage
       }),
     )
@@ -106,11 +116,11 @@ describe('getToken should', () => {
     )
 
     const storageTest = Layer.effect(
-      Storage,
+      BrowserStorage,
       E.sync(() => {
         const mockStorage = mock<Storage>()
         const expiry = Date.now() - 1000
-        mockStorage.getItem.mockReturnValue(`token:${expiry}`)
+        mockStorage.getItem.mockReturnValue(`token:${expiry.toFixed(0)}`)
         return mockStorage
       }),
     )
@@ -127,7 +137,7 @@ describe('getToken should', () => {
 describe('clearToken should', () => {
   test('clear the token in local storage', () => {
     const assertions = E.gen(function* (_) {
-      const storage = yield* _(Storage)
+      const storage = yield* _(BrowserStorage)
       yield* _(clearToken('passkey'))
       expect(storage.removeItem).toHaveBeenCalledWith('passlock:passkey:token')
     })
@@ -144,18 +154,18 @@ describe('clearToken should', () => {
 describe('clearExpiredToken should', () => {
   test('clear an expired token from local storage', () => {
     const assertions = E.gen(function* (_) {
-      const storage = yield* _(Storage)
+      const storage = yield* _(BrowserStorage)
       yield* _(clearExpiredToken('passkey'))
       expect(storage.getItem).toHaveBeenCalledWith('passlock:passkey:token')
       expect(storage.removeItem).toHaveBeenCalledWith('passlock:passkey:token')
     })
 
     const storageTest = Layer.effect(
-      Storage,
+      BrowserStorage,
       E.sync(() => {
         const mockStorage = mock<Storage>()
         const expiry = Date.now() - 1000
-        mockStorage.getItem.mockReturnValue(`token:${expiry}`)
+        mockStorage.getItem.mockReturnValue(`token:${expiry.toFixed(0)}`)
         return mockStorage
       }),
     )
@@ -170,18 +180,18 @@ describe('clearExpiredToken should', () => {
 
   test('leave a live token in local storage', () => {
     const assertions = E.gen(function* (_) {
-      const storage = yield* _(Storage)
+      const storage = yield* _(BrowserStorage)
       yield* _(clearExpiredToken('passkey'))
       expect(storage.getItem).toHaveBeenCalledWith('passlock:passkey:token')
       expect(storage.removeItem).not.toHaveBeenCalled()
     })
 
     const storageTest = Layer.effect(
-      Storage,
+      BrowserStorage,
       E.sync(() => {
         const mockStorage = mock<Storage>()
         const expiry = Date.now() + 1000
-        mockStorage.getItem.mockReturnValue(`token:${expiry}`)
+        mockStorage.getItem.mockReturnValue(`token:${expiry.toFixed(0)}`)
         return mockStorage
       }),
     )

package/src/storage/storage.ts

@@ -2,10 +2,11 @@
  * Wrapper around local storage that allows us to store
  * authentication tokens in local storage for a short period.
  */
-import type { Principal } from '@passlock/shared/dist/schema/principal.js'
 import { Context, Effect as E, Layer, Option as O, flow, pipe } from 'effect'
 import type { NoSuchElementException } from 'effect/Cause'
 
+import type { Principal } from '@passlock/shared/dist/schema/principal.js'
+
 /* Requests */
 
 export type AuthType = 'email' | 'passkey' | 'apple' | 'google'
@@ -13,33 +14,31 @@ export type AuthType = 'email' | 'passkey' | 'apple' | 'google'
 export type StoredToken = {
   token: string
   authType: AuthType
-  expireAt: number
+  expiry: number
 }
 
 /* Service */
 
-export type StorageService = {
-  storeToken: (principal: Principal) => E.Effect<void>
-  getToken: (authType: AuthType) => E.Effect<StoredToken, NoSuchElementException>
-  clearToken: (authType: AuthType) => E.Effect<void>
-  clearExpiredToken: (authType: AuthType) => E.Effect<void>
-  clearExpiredTokens: E.Effect<void>
-}
-
-/* Utilities */
-
-export const StorageService = Context.GenericTag<StorageService>('@services/StorageService')
+export class StorageService extends Context.Tag('@services/StorageService')<
+  StorageService,
+  {
+    storeToken: (principal: Principal) => E.Effect<void>
+    getToken: (authType: AuthType) => E.Effect<StoredToken, NoSuchElementException>
+    clearToken: (authType: AuthType) => E.Effect<void>
+    clearExpiredToken: (authType: AuthType) => E.Effect<void>
+    clearExpiredTokens: E.Effect<void>
+  }
+>() {}
 
-// inject window.localStorage to make testing easier
-export const Storage = Context.GenericTag<Storage>('@services/Storage')
+export class BrowserStorage extends Context.Tag('@services/Storage')<BrowserStorage, Storage>() {}
 
 export const buildKey = (authType: AuthType) => `passlock:${authType}:token`
 
 // principal => token:expireAt
 export const compressToken = (principal: Principal): string => {
-  const expireAt = principal.expireAt.getTime()
-  const token = principal.token
-  return `${token}:${expireAt}`
+  const expireAt = principal.exp.getTime()
+  const token = principal.jti
+  return `${token}:${expireAt.toFixed(0)}`
 }
 
 // token:expireAt => { authType, token, expireAt }
@@ -50,10 +49,12 @@ export const expandToken =
     if (tokens.length !== 2) return O.none()
 
     const [token, expireAtString] = tokens
+    if (token === undefined || expireAtString === undefined) return O.none()
+
     const parse = O.liftThrowable(Number.parseInt)
     const expireAt = parse(expireAtString)
 
-    return O.map(expireAt, expireAt => ({ authType, token, expireAt }))
+    return O.map(expireAt, expiry => ({ authType, token, expiry }))
   }
 
 /* Effects */
@@ -63,13 +64,13 @@ export const expandToken =
  * @param principal
  * @returns
  */
-export const storeToken = (principal: Principal): E.Effect<void, never, Storage> => {
+export const storeToken = (principal: Principal): E.Effect<void, never, BrowserStorage> => {
   return E.gen(function* (_) {
-    const localStorage = yield* _(Storage)
+    const localStorage = yield* _(BrowserStorage)
 
     const storeEffect = E.try(() => {
       const compressed = compressToken(principal)
-      const key = buildKey(principal.authStatement.authType)
+      const key = buildKey(principal.authType)
       localStorage.setItem(key, compressed)
     }).pipe(E.orElse(() => E.void)) // We dont care if it fails
 
@@ -79,20 +80,20 @@ export const storeToken = (principal: Principal): E.Effect<void, never, Storage>
 
 /**
  * Get stored token from local storage
- * @param authType
+ * @param authenticator
  * @returns
  */
 export const getToken = (
-  authType: AuthType,
-): E.Effect<StoredToken, NoSuchElementException, Storage> => {
+  authenticator: AuthType,
+): E.Effect<StoredToken, NoSuchElementException, BrowserStorage> => {
   return E.gen(function* (_) {
-    const localStorage = yield* _(Storage)
+    const localStorage = yield* _(BrowserStorage)
 
     const getEffect = pipe(
-      O.some(buildKey(authType)),
+      O.some(buildKey(authenticator)),
       O.flatMap(key => pipe(localStorage.getItem(key), O.fromNullable)),
-      O.flatMap(expandToken(authType)),
-      O.filter(({ expireAt: expireAt }) => expireAt > Date.now()),
+      O.flatMap(expandToken(authenticator)),
+      O.filter(({ expiry }) => expiry > Date.now()),
     )
 
     return yield* _(getEffect)
@@ -104,9 +105,9 @@ export const getToken = (
  * @param authType
  * @returns
  */
-export const clearToken = (authType: AuthType): E.Effect<void, never, Storage> => {
+export const clearToken = (authType: AuthType): E.Effect<void, never, BrowserStorage> => {
   return E.gen(function* (_) {
-    const localStorage = yield* _(Storage)
+    const localStorage = yield* _(BrowserStorage)
     localStorage.removeItem(buildKey(authType))
   })
 }
@@ -117,15 +118,15 @@ export const clearToken = (authType: AuthType): E.Effect<void, never, Storage> =
  * @param defer
  * @returns
  */
-export const clearExpiredToken = (authType: AuthType): E.Effect<void, never, Storage> => {
+export const clearExpiredToken = (authType: AuthType): E.Effect<void, never, BrowserStorage> => {
   const key = buildKey(authType)
 
   const effect = E.gen(function* (_) {
-    const storage = yield* _(Storage)
+    const storage = yield* _(BrowserStorage)
     const item = yield* _(O.fromNullable(storage.getItem(key)))
     const token = yield* _(expandToken(authType)(item))
 
-    if (token.expireAt < Date.now()) {
+    if (token.expiry < Date.now()) {
       storage.removeItem(key)
     }
   })
@@ -140,7 +141,7 @@ export const clearExpiredToken = (authType: AuthType): E.Effect<void, never, Sto
   )
 }
 
-export const clearExpiredTokens: E.Effect<void, never, Storage> = E.all([
+export const clearExpiredTokens: E.Effect<void, never, BrowserStorage> = E.all([
   clearExpiredToken('passkey'),
   clearExpiredToken('email'),
   clearExpiredToken('google'),
@@ -153,7 +154,7 @@ export const clearExpiredTokens: E.Effect<void, never, Storage> = E.all([
 export const StorageServiceLive = Layer.effect(
   StorageService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<Storage>())
+    const context = yield* _(E.context<BrowserStorage>())
 
     return {
       storeToken: flow(storeToken, E.provide(context)),

package/src/test/fixtures.ts

@@ -1,6 +1,8 @@
+import { Effect as E, Layer as L } from 'effect'
+
 import { BadRequest } from '@passlock/shared/dist/error/error.js'
 import type { Principal } from '@passlock/shared/dist/schema/principal.js'
-import { Effect as E, Layer as L } from 'effect'
+
 import { Capabilities } from '../capabilities/capabilities.js'
 import { StorageService, type StoredToken } from '../storage/storage.js'
 
@@ -8,15 +10,30 @@ export const session = 'session'
 export const token = 'token'
 export const code = 'code'
 export const authType = 'passkey'
-export const expireAt = Date.now() + 10000
+export const expiry = Date.now() + 10000
 
 export const principal: Principal = {
+  jti: 'token',
   token: 'token',
+  sub: 'user-1',
+  iss: 'idp.passlock.dev',
+  aud: 'tenancy_id',
+  iat: new Date(),
+  nbf: new Date(),
+  exp: new Date(Date.now() + 5 * 60 * 1000),
+  email: 'john.doe@gmail.com',
+  givenName: 'john',
+  familyName: 'doe',
+  emailVerified: false,
+  authType: 'passkey',
+  authId: 'auth-1',
+  userVerified: true,
+  // legacy
   user: {
-    id: '1',
-    email: 'john.doe@gmail.com',
+    id: 'user-1',
     givenName: 'john',
     familyName: 'doe',
+    email: 'john.doe@gmail.com',
     emailVerified: false,
   },
   authStatement: {
@@ -37,7 +54,7 @@ export const capabilitiesTest = L.succeed(
   }),
 )
 
-export const storedToken: StoredToken = { token, authType, expireAt }
+export const storedToken: StoredToken = { token, authType, expiry }
 
 export const storageServiceTest = L.succeed(
   StorageService,
@@ -50,4 +67,4 @@ export const storageServiceTest = L.succeed(
   }),
 )
 
-export const notImplemented = new BadRequest({ message: 'Not implemented' })
+export const notImplemented = new BadRequest({ message: 'Not implemented' })

package/src/user/user.fixture.ts

@@ -1,21 +1,33 @@
-import { IsExistingUserReq, IsExistingUserRes, ResendEmailReq, ResendEmailRes, UserClient, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
-import { Effect as E, Layer as L } from 'effect'
+import { Effect as E, Layer as L, Option as O } from 'effect'
+
+import {
+  IsExistingUserReq,
+  IsExistingUserRes,
+  ResendEmailReq,
+  ResendEmailRes,
+  VerifyEmailRes,
+} from '@passlock/shared/dist/rpc/user.js'
+
 import * as Fixtures from '../test/fixtures.js'
+import { UserClient } from '../rpc/user.js'
 import type { ResendEmail } from './user.js'
 
 export const email = 'jdoe@gmail.com'
 export const isRegisteredReq = new IsExistingUserReq({ email })
-export const isRegisteredRes = new IsExistingUserRes({ existingUser: false })
+export const isRegisteredRes = new IsExistingUserRes({ existingUser: false, detail: O.none() })
 export const verifyEmailRes = new VerifyEmailRes({ principal: Fixtures.principal })
 export const resendEmailReq: ResendEmail = { userId: '123', method: 'code' }
-export const rpcResendEmailReq = new ResendEmailReq({ userId: '123', verifyEmail: { method: 'code' }})
-export const rpcResendEmailRes = new ResendEmailRes({ })
+export const rpcResendEmailReq = new ResendEmailReq({
+  userId: '123',
+  verifyEmail: { method: 'code' },
+})
+export const rpcResendEmailRes = new ResendEmailRes({})
 
 export const rpcClientTest = L.succeed(
   UserClient,
   UserClient.of({
-    isExistingUser: () => E.succeed({ existingUser: true }),
+    isExistingUser: () => E.succeed({ existingUser: true, detail: O.none() }),
     verifyEmail: () => E.succeed(verifyEmailRes),
     resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
   }),
-)
+)

package/src/user/user.test.ts

@@ -1,8 +1,9 @@
-import { UserClient } from '@passlock/shared/dist/rpc/user.js'
 import { Effect as E, Layer as L, Layer, LogLevel, Logger, pipe } from 'effect'
 import { describe, expect, test } from 'vitest'
 import { mock } from 'vitest-mock-extended'
+
 import * as Fixture from './user.fixture.js'
+import { UserClient } from '../rpc/user.js'
 import { UserService, UserServiceLive } from './user.js'
 
 describe('isExistingUser should', () => {
@@ -76,10 +77,7 @@ describe('resendVerificationEmail should', () => {
 
     const layers = L.merge(service, rpcClientTest)
 
-    const effect = pipe(
-      E.provide(assertions, layers),
-      Logger.withMinimumLogLevel(LogLevel.None)
-    )
+    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
 
     return E.runPromise(effect)
   })