@passlock/client 0.9.19 → 0.9.21

package/src/email/email.test.ts

@@ -1,4 +1,4 @@
-import { RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.js'
+import { UserClient } from '@passlock/shared/dist/rpc/user.js'
 import { Effect as E, Layer as L, LogLevel, Logger, pipe } from 'effect'
 import { NoSuchElementException } from 'effect/Cause'
 import { describe, expect, test } from 'vitest'
@@ -116,14 +116,14 @@ describe('verifyEmailCode should', () => {
       const service = yield* _(EmailService)
       yield* _(service.verifyEmailCode({ code: Fixture.code }))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(UserClient)
       expect(rpcClient.verifyEmail).toHaveBeenCalledWith(Fixture.rpcVerifyEmailReq)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      UserClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<UserClient['Type']>()
 
         rpcMock.verifyEmail.mockReturnValue(E.succeed(Fixture.rpcVerifyEmailRes))
 
@@ -154,14 +154,14 @@ describe('verifyEmailLink should', () => {
 
       // LocationSearch return ?code=code
       // and we expect rpcClient to be called with code
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(UserClient)
       expect(rpcClient.verifyEmail).toBeCalledWith(Fixture.rpcVerifyEmailReq)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      UserClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<UserClient['Type']>()
 
         rpcMock.verifyEmail.mockReturnValue(E.succeed(Fixture.rpcVerifyEmailRes))
 

package/src/email/email.ts

@@ -2,10 +2,9 @@
  * Email verification effects
  */
 import { BadRequest } from '@passlock/shared/dist/error/error.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
 import type { VerifyEmailErrors as RpcErrors } from '@passlock/shared/dist/rpc/user.js'
-import { VerifyEmailReq } from '@passlock/shared/dist/rpc/user.js'
-import type { Principal } from '@passlock/shared/dist/schema/schema.js'
+import { UserClient, VerifyEmailReq } from '@passlock/shared/dist/rpc/user.js'
+import type { Principal } from '@passlock/shared/dist/schema/principal.js'
 import { Context, Effect as E, Layer, Option as O, flow, identity, pipe } from 'effect'
 import { AuthenticationService, type AuthenticationErrors } from '../authentication/authenticate.js'
 import { StorageService } from '../storage/storage.js'
@@ -38,7 +37,7 @@ export const EmailService = Context.GenericTag<EmailService>('@services/EmailSer
 
 /* Utils */
 
-export type Dependencies = StorageService | AuthenticationService | RpcClient
+export type Dependencies = StorageService | AuthenticationService | UserClient
 
 /**
  * Check for existing token in sessionStorage,
@@ -101,7 +100,7 @@ export const verifyEmail = (
     const { token } = yield* _(getToken())
 
     yield* _(E.logDebug('Making request'))
-    const client = yield* _(RpcClient)
+    const client = yield* _(UserClient)
     const { principal } = yield* _(
       client.verifyEmail(new VerifyEmailReq({ token, code: request.code })),
     )
@@ -128,7 +127,7 @@ export const EmailServiceLive = Layer.effect(
   EmailService,
   E.gen(function* (_) {
     const context = yield* _(
-      E.context<RpcClient | AuthenticationService | StorageService | URLQueryString>(),
+      E.context<UserClient | AuthenticationService | StorageService | URLQueryString>(),
     )
     return EmailService.of({
       verifyEmailCode: flow(verifyEmail, E.provide(context)),

package/src/index.ts

@@ -10,7 +10,7 @@ import type {
 
 import { ErrorCode } from '@passlock/shared/dist/error/error.js'
 import { RpcConfig } from '@passlock/shared/dist/rpc/config.js'
-import type { Principal } from '@passlock/shared/dist/schema/schema.js'
+import type { Principal } from '@passlock/shared/dist/schema/principal.js'
 import { Effect as E, Layer as L, Layer, Option, Runtime, Scope, pipe } from 'effect'
 import { AuthenticationService, type AuthenticationRequest } from './authentication/authenticate.js'
 import { Capabilities } from './capabilities/capabilities.js'
@@ -25,7 +25,10 @@ import { UserService, type Email, type ResendEmail } from './user/user.js'
 /* Exports */
 
 export type Options = { signal?: AbortSignal }
-export type { Principal, UserVerification, VerifyEmail } from '@passlock/shared/dist/schema/schema.js'
+export type { VerifyEmail } from '@passlock/shared/dist/schema/email.js'
+export type { UserVerification } from '@passlock/shared/dist/schema/passkey.js'
+export type { Principal } from '@passlock/shared/dist/schema/principal.js'
+
 export type { AuthenticationRequest } from './authentication/authenticate.js'
 export type { VerifyRequest } from './email/email.js'
 export type { RegistrationRequest } from './registration/register.js'

package/src/logging/eventLogger.test.ts

@@ -79,6 +79,7 @@ describe('log', () => {
     const withLogLevel = logStatement.pipe(Logger.withMinimumLogLevel(LogLevel.Warning))
 
     const effect = E.provide(withLogLevel, eventLoggerLive)
+    
     E.runSync(effect)
 
     const expectedEvent = new CustomEvent('PasslogDebugMessage', {

package/src/logging/eventLogger.ts

@@ -21,15 +21,21 @@ export const logRaw = <T>(message: T) => {
 
 export const DebugMessage = 'PasslogDebugMessage'
 
+const dispatch = (message: string) => {
+  try {
+    const evt = new CustomEvent(DebugMessage, { detail: message })
+    globalThis.dispatchEvent(evt)
+  } catch (e) {
+    globalThis.console.log('Unable to fire custom event')
+  }
+}
+
 export const eventLoggerLive = Logger.add(
-  Logger.make(options => {
-    if (typeof options.message === 'string' && options.logLevel !== LogLevel.Debug) {
-      try {
-        const evt = new CustomEvent(DebugMessage, { detail: options.message })
-        globalThis.dispatchEvent(evt)
-      } catch (e) {
-        globalThis.console.log('Unable to fire custom event')
-      }
-    }
-  }),
+  Logger.make(({ logLevel, message }) => {
+    if (typeof message === 'string' && logLevel !== LogLevel.Debug) {
+      dispatch(message)
+    } else if (Array.isArray(message) && logLevel !== LogLevel.Debug) {
+      message.forEach(dispatch)
+    } 
+  })
 )

package/src/registration/register.fixture.ts

@@ -1,12 +1,11 @@
-import { PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
 import {
-    OptionsReq,
-    OptionsRes,
-    VerificationReq,
-    VerificationRes,
+  OptionsReq,
+  OptionsRes,
+  RegistrationClient,
+  VerificationReq,
+  VerificationRes,
 } from '@passlock/shared/dist/rpc/registration.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import type { RegistrationCredential } from '@passlock/shared/dist/schema/schema.js'
+import type { RegistrationCredential } from '@passlock/shared/dist/schema/passkey.js'
 import { Effect as E, Layer as L } from 'effect'
 import * as Fixtures from '../test/fixtures.js'
 import { UserService } from '../user/user.js'
@@ -75,19 +74,11 @@ export const userServiceTest = L.succeed(
 )
 
 export const rpcClientTest = L.succeed(
-  RpcClient,
-  RpcClient.of({
-    preConnect: () => E.succeed(new PreConnectRes({ warmed: true })),
-    isExistingUser: () => E.fail(Fixtures.notImplemented),
-    verifyEmail: () => E.fail(Fixtures.notImplemented),
+  RegistrationClient,
+  RegistrationClient.of({
     getRegistrationOptions: () => E.succeed(rpcOptionsRes),
     verifyRegistrationCredential: () => E.succeed(rpcVerificationRes),
-    getAuthenticationOptions: () => E.fail(Fixtures.notImplemented),
-    verifyAuthenticationCredential: () => E.fail(Fixtures.notImplemented),
-    registerOidc: () => E.fail(Fixtures.notImplemented),
-    authenticateOidc: () => E.fail(Fixtures.notImplemented),
-    resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
-  }),
+  })
 )
 
 export const principal = Fixtures.principal

package/src/registration/register.test.ts

@@ -1,5 +1,5 @@
 import { Duplicate, InternalBrowserError } from '@passlock/shared/dist/error/error.js'
-import { RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.js'
+import { RegistrationClient } from '@passlock/shared/dist/rpc/registration.js'
 import { Effect as E, Layer as L, Layer, LogLevel, Logger, pipe } from 'effect'
 import { describe, expect, test, vi } from 'vitest'
 import { mock } from 'vitest-mock-extended'
@@ -33,14 +33,14 @@ describe('register should', () => {
       const service = yield* _(RegistrationService)
       yield* _(service.registerPasskey(Fixture.registrationRequest))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(RegistrationClient)
       expect(rpcClient.getRegistrationOptions).toHaveBeenCalledWith(Fixture.rpcOptionsReq)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      RegistrationClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<RegistrationClient['Type']>()
 
         rpcMock.getRegistrationOptions.mockReturnValue(E.succeed(Fixture.rpcOptionsRes))
         rpcMock.verifyRegistrationCredential.mockReturnValue(E.succeed(Fixture.rpcVerificationRes))
@@ -69,14 +69,14 @@ describe('register should', () => {
       const service = yield* _(RegistrationService)
       yield* _(service.registerPasskey(Fixture.registrationRequest))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(RegistrationClient)
       expect(rpcClient.verifyRegistrationCredential).toHaveBeenCalledWith(Fixture.rpcVerificationReq)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      RegistrationClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<RegistrationClient['Type']>()
 
         rpcMock.getRegistrationOptions.mockReturnValue(E.succeed(Fixture.rpcOptionsRes))
         rpcMock.verifyRegistrationCredential.mockReturnValue(E.succeed(Fixture.rpcVerificationRes))
@@ -110,9 +110,9 @@ describe('register should', () => {
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      RegistrationClient,
       E.sync(() => {
-        const rpcMock = mock<RpcClient['Type']>()
+        const rpcMock = mock<RegistrationClient['Type']>()
 
         rpcMock.getRegistrationOptions.mockReturnValue(E.fail(new Duplicate({ message: 'User already exists' })))
 

package/src/registration/register.ts

@@ -2,20 +2,19 @@
  * User & passkey registration effects
  */
 import {
-    parseCreationOptionsFromJSON,
-    type CredentialCreationOptionsJSON,
+  parseCreationOptionsFromJSON,
+  type CredentialCreationOptionsJSON,
 } from '@github/webauthn-json/browser-ponyfill'
 import type { NotSupported } from '@passlock/shared/dist/error/error.js'
 import { Duplicate, InternalBrowserError } from '@passlock/shared/dist/error/error.js'
 import type { OptionsErrors, VerificationErrors } from '@passlock/shared/dist/rpc/registration.js'
-import { OptionsReq, VerificationReq } from '@passlock/shared/dist/rpc/registration.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
+import { OptionsReq, RegistrationClient, VerificationReq } from '@passlock/shared/dist/rpc/registration.js'
+import { VerifyEmail } from '@passlock/shared/dist/schema/email.js'
 import type {
-    Principal,
-    RegistrationCredential,
-    UserVerification,
-    VerifyEmail,
-} from '@passlock/shared/dist/schema/schema.js'
+  RegistrationCredential,
+  UserVerification,
+} from '@passlock/shared/dist/schema/passkey.js'
+import { Principal } from '@passlock/shared/dist/schema/principal.js'
 import { Context, Effect as E, Layer, flow, pipe } from 'effect'
 import { Capabilities } from '../capabilities/capabilities.js'
 import { StorageService } from '../storage/storage.js'
@@ -59,7 +58,7 @@ const fetchOptions = (request: OptionsReq) => {
   return E.gen(function* (_) {
     yield* _(E.logDebug('Making request'))
 
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(RegistrationClient)
     const { publicKey, session } = yield* _(rpcClient.getRegistrationOptions(request))
 
     yield* _(E.logDebug('Converting Passlock options to CredentialCreationOptions'))
@@ -86,7 +85,7 @@ const verifyCredential = (request: VerificationReq) => {
   return E.gen(function* (_) {
     yield* _(E.logDebug('Making request'))
 
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(RegistrationClient)
     const { principal } = yield* _(rpcClient.verifyRegistrationCredential(request))
 
     return principal
@@ -95,7 +94,7 @@ const verifyCredential = (request: VerificationReq) => {
 
 /* Effects */
 
-type Dependencies = Capabilities | CreateCredential | StorageService | UserService | RpcClient
+type Dependencies = Capabilities | CreateCredential | StorageService | UserService | RegistrationClient
 
 export const registerPasskey = (
   request: RegistrationRequest,
@@ -146,7 +145,7 @@ export const RegistrationServiceLive = Layer.effect(
   RegistrationService,
   E.gen(function* (_) {
     const context = yield* _(
-      E.context<CreateCredential | RpcClient | Capabilities | StorageService | UserService>(),
+      E.context<CreateCredential | RegistrationClient | Capabilities | StorageService | UserService>(),
     )
 
     return RegistrationService.of({

package/src/social/social.fixture.ts

@@ -1,7 +1,6 @@
-import { PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
 import * as Shared from '@passlock/shared/dist/rpc/social.js'
-import { Effect as E, Layer as L, Option as O } from 'effect'
+import { SocialClient } from '@passlock/shared/dist/rpc/social.js'
+import { Effect as E, Layer as L } from 'effect'
 import * as Fixtures from '../test/fixtures.js'
 import type { AuthenticateOidcReq, RegisterOidcReq } from './social.js'
 
@@ -27,8 +26,8 @@ export const authOidcReq: AuthenticateOidcReq = {
 
 export const rpcRegisterReq = new Shared.RegisterOidcReq({ 
   ...registerOidcReq, 
-  givenName: O.fromNullable(registerOidcReq.givenName), 
-  familyName: O.fromNullable(registerOidcReq.familyName) 
+  ...(registerOidcReq.givenName ? { givenName: registerOidcReq.givenName } : {}),
+  ...(registerOidcReq.familyName ? { familyName: registerOidcReq.familyName } : {})
 })
 
 export const rpcRegisterRes = new Shared.PrincipalRes({ principal: Fixtures.principal })
@@ -38,19 +37,11 @@ export const rpcAuthenticateReq = new Shared.AuthOidcReq({ ...authOidcReq })
 export const rpcAuthenticateRes = new Shared.PrincipalRes({ principal: Fixtures.principal })
 
 export const rpcClientTest = L.succeed(
-  RpcClient,
-  RpcClient.of({
-    preConnect: () => E.succeed(new PreConnectRes({ warmed: true })),
-    isExistingUser: () => E.fail(Fixtures.notImplemented),
-    verifyEmail: () => E.fail(Fixtures.notImplemented),
-    getRegistrationOptions: () => E.fail(Fixtures.notImplemented),
-    verifyRegistrationCredential: () => E.fail(Fixtures.notImplemented),
-    getAuthenticationOptions: () => E.fail(Fixtures.notImplemented),
-    verifyAuthenticationCredential: () => E.fail(Fixtures.notImplemented),
+  SocialClient,
+  SocialClient.of({
     registerOidc: () => E.fail(Fixtures.notImplemented),
     authenticateOidc: () => E.fail(Fixtures.notImplemented),
-    resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
-  }),
+  })
 )
 
 export const principal = Fixtures.principal

package/src/social/social.test.ts

@@ -1,5 +1,5 @@
 import { Duplicate, NotFound } from '@passlock/shared/dist/error/error.js'
-import { RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.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'
@@ -15,9 +15,9 @@ describe('registerOidc should', () => {
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.registerOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
@@ -41,14 +41,14 @@ describe('registerOidc should', () => {
       const service = yield* _(SocialService)
       yield* _(service.registerOidc(Fixture.registerOidcReq))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(SocialClient)
       expect(rpcClient.registerOidc).toHaveBeenCalledWith(Fixture.rpcRegisterReq)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.registerOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
@@ -77,9 +77,9 @@ describe('registerOidc should', () => {
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.registerOidc.mockReturnValue(E.fail(new Duplicate({ message: "Duplicate user" })))
 
@@ -108,9 +108,9 @@ describe('authenticateIodc should', () => {
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.authenticateOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
@@ -134,14 +134,14 @@ describe('authenticateIodc should', () => {
       const service = yield* _(SocialService)
       yield* _(service.authenticateOidc(Fixture.authOidcReq))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(SocialClient)
       expect(rpcClient.authenticateOidc).toHaveBeenCalledWith(Fixture.rpcAuthenticateReq)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.authenticateOidc.mockReturnValue(E.succeed(Fixture.rpcAuthenticateRes))
 
@@ -170,9 +170,9 @@ describe('authenticateIodc should', () => {
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.authenticateOidc.mockReturnValue(E.fail(new NotFound({ message: "User not found" })))
 

package/src/social/social.ts

@@ -5,12 +5,12 @@ import {
   type BadRequest,
   type NotSupported
 } from '@passlock/shared/dist/error/error.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.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/schema.js'
-import { Context, Effect as E, Layer, Option as O, flow } from 'effect'
+} from '@passlock/shared/dist/schema/principal.js'
+import { Context, Effect as E, Layer, flow } from 'effect'
 
 /* Requests */
 
@@ -49,7 +49,7 @@ export const SocialService = Context.GenericTag<SocialService>(
 
 /* Effects */
 
-type Dependencies = RpcClient
+type Dependencies = SocialClient
 
 export const registerOidc = (
   request: RegisterOidcReq,
@@ -57,12 +57,12 @@ export const registerOidc = (
   return E.gen(function* (_) {
     yield* _(E.logInfo('Registering social account'))
 
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(SocialClient)
 
     const rpcRequest = new Shared.RegisterOidcReq({
       ...request,
-      givenName: O.fromNullable(request.givenName),
-      familyName: O.fromNullable(request.familyName),
+      ...(request.givenName ? { givenName: request.givenName } : {}),
+      ...(request.familyName ? { familyName: request.familyName } : {})
     })
 
     const { principal } = yield* _(
@@ -79,7 +79,7 @@ export const authenticateOidc = (
   return E.gen(function* (_) {
     yield* _(E.logInfo('Authenticating with social account'))
 
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(SocialClient)
     const rpcRequest = new Shared.AuthOidcReq(request)
 
     const { principal } = yield* _(
@@ -96,7 +96,7 @@ export const authenticateOidc = (
 export const SocialServiceLive = Layer.effect(
   SocialService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<RpcClient>())
+    const context = yield* _(E.context<SocialClient>())
 
     return SocialService.of({
       registerOidc: flow(registerOidc, E.provide(context)),

package/src/storage/storage.ts

@@ -2,7 +2,7 @@
  * 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/schema.js'
+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'
 

package/src/test/fixtures.ts

@@ -1,6 +1,5 @@
 import { BadRequest } from '@passlock/shared/dist/error/error.js'
-import { PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
-import type { Principal } from '@passlock/shared/dist/schema/schema.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'
@@ -51,5 +50,4 @@ export const storageServiceTest = L.succeed(
   }),
 )
 
-export const preConnectRes = new PreConnectRes({ warmed: true })
 export const notImplemented = new BadRequest({ message: 'Not implemented' })

package/src/user/user.fixture.ts

@@ -1,5 +1,4 @@
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import { IsExistingUserReq, IsExistingUserRes, ResendEmailReq, ResendEmailRes, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
+import { IsExistingUserReq, IsExistingUserRes, ResendEmailReq, ResendEmailRes, UserClient, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
 import { Effect as E, Layer as L } from 'effect'
 import * as Fixtures from '../test/fixtures.js'
 import type { ResendEmail } from './user.js'
@@ -13,17 +12,10 @@ export const rpcResendEmailReq = new ResendEmailReq({ userId: '123', verifyEmail
 export const rpcResendEmailRes = new ResendEmailRes({ })
 
 export const rpcClientTest = L.succeed(
-  RpcClient,
-  RpcClient.of({
-    preConnect: () => E.succeed({ warmed: true }),
+  UserClient,
+  UserClient.of({
     isExistingUser: () => E.succeed({ existingUser: true }),
     verifyEmail: () => E.succeed(verifyEmailRes),
-    getRegistrationOptions: () => E.fail(Fixtures.notImplemented),
-    verifyRegistrationCredential: () => E.fail(Fixtures.notImplemented),
-    getAuthenticationOptions: () => E.fail(Fixtures.notImplemented),
-    verifyAuthenticationCredential: () => E.fail(Fixtures.notImplemented),
-    registerOidc: () => E.fail(Fixtures.notImplemented),
-    authenticateOidc: () => E.fail(Fixtures.notImplemented),
     resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
   }),
 )

package/src/user/user.test.ts

@@ -1,4 +1,4 @@
-import { RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.js'
+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'
@@ -27,14 +27,14 @@ describe('isExistingUser should', () => {
       const result = yield* _(service.isExistingUser({ email: Fixture.email }))
 
       expect(result).toBe(false)
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(UserClient)
       expect(rpcClient.isExistingUser).toBeCalledWith(Fixture.isRegisteredReq)
     })
 
     const rpcClientTest = Layer.effect(
-      RpcClient,
+      UserClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<UserClient['Type']>()
 
         rpcMock.isExistingUser.mockReturnValue(E.succeed(Fixture.isRegisteredRes))
 
@@ -57,14 +57,14 @@ describe('resendVerificationEmail should', () => {
       const service = yield* _(UserService)
       yield* _(service.resendVerificationEmail(Fixture.resendEmailReq))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(UserClient)
       expect(rpcClient.resendVerificationEmail).toBeCalledWith(Fixture.rpcResendEmailReq)
     })
 
     const rpcClientTest = Layer.effect(
-      RpcClient,
+      UserClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<UserClient['Type']>()
 
         rpcMock.resendVerificationEmail.mockReturnValue(E.succeed(Fixture.rpcResendEmailRes))
 

package/src/user/user.ts

@@ -2,9 +2,8 @@
  * Check for an existing user
  */
 import type { BadRequest, Disabled, NotFound } from '@passlock/shared/dist/error/error.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import { IsExistingUserReq, ResendEmailReq } from '@passlock/shared/dist/rpc/user.js'
-import type { VerifyEmail } from '@passlock/shared/dist/schema/schema.js'
+import { IsExistingUserReq, ResendEmailReq, UserClient } from '@passlock/shared/dist/rpc/user.js'
+import type { VerifyEmail } from '@passlock/shared/dist/schema/email.js'
 import { Context, Effect as E, Layer, flow } from 'effect'
 
 /* Requests */
@@ -27,12 +26,12 @@ export const UserService = Context.GenericTag<UserService>('@services/UserServic
 
 /* Effects */
 
-type Dependencies = RpcClient
+type Dependencies = UserClient
 
 export const isExistingUser = (request: Email): E.Effect<boolean, BadRequest, Dependencies> => {
   return E.gen(function* (_) {
     yield* _(E.logInfo('Checking registration status'))
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(UserClient)
 
     yield* _(E.logDebug('Making RPC request'))
     const { existingUser } = yield* _(rpcClient.isExistingUser(new IsExistingUserReq(request)))
@@ -44,7 +43,7 @@ export const isExistingUser = (request: Email): E.Effect<boolean, BadRequest, De
 export const resendVerificationEmail = (request: ResendEmail): E.Effect<void, ResendEmailErrors, Dependencies> => {
   return E.gen(function* (_) {
     yield* _(E.logInfo('Resending verification email'))
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(UserClient)
 
     yield* _(E.logDebug('Making RPC request'))
     const { userId, ...verifyEmail } = request
@@ -58,7 +57,7 @@ export const resendVerificationEmail = (request: ResendEmail): E.Effect<void, Re
 export const UserServiceLive = Layer.effect(
   UserService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<RpcClient>())
+    const context = yield* _(E.context<UserClient>())
     return UserService.of({
       isExistingUser: flow(isExistingUser, E.provide(context)),
       resendVerificationEmail: flow(resendVerificationEmail, E.provide(context))