@passlock/client 0.9.17 → 0.9.21

package/src/authentication/authenticate.ts

@@ -2,21 +2,20 @@
  * Passkey authentication effects
  */
 import {
-    parseRequestOptionsFromJSON,
-    type CredentialRequestOptionsJSON,
+  parseRequestOptionsFromJSON,
+  type CredentialRequestOptionsJSON,
 } from '@github/webauthn-json/browser-ponyfill'
 import {
-    InternalBrowserError,
-    type NotSupported,
+  InternalBrowserError,
+  type NotSupported,
 } from '@passlock/shared/dist/error/error.js'
 import type { OptionsErrors, VerificationErrors } from '@passlock/shared/dist/rpc/authentication.js'
-import { OptionsReq, VerificationReq } from '@passlock/shared/dist/rpc/authentication.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
+import { AuthenticationClient, OptionsReq, VerificationReq } from '@passlock/shared/dist/rpc/authentication.js'
 import type {
-    AuthenticationCredential,
-    Principal,
-    UserVerification,
-} from '@passlock/shared/dist/schema/schema.js'
+  AuthenticationCredential,
+  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'
@@ -56,7 +55,7 @@ const fetchOptions = (request: OptionsReq) => {
   return E.gen(function* (_) {
     yield* _(E.logDebug('Making request'))
 
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(AuthenticationClient)
     const { publicKey, session } = yield* _(rpcClient.getAuthenticationOptions(request))
 
     yield* _(E.logDebug('Converting Passlock options to CredentialRequestOptions'))
@@ -83,7 +82,7 @@ const verifyCredential = (request: VerificationReq) => {
   return E.gen(function* (_) {
     yield* _(E.logDebug('Making request'))
 
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(AuthenticationClient)
     const { principal } = yield* _(rpcClient.verifyAuthenticationCredential(request))
 
     return principal
@@ -92,7 +91,7 @@ const verifyCredential = (request: VerificationReq) => {
 
 /* Effects */
 
-type Dependencies = GetCredential | Capabilities | StorageService | RpcClient
+type Dependencies = GetCredential | Capabilities | StorageService | AuthenticationClient
 
 export const authenticatePasskey = (
   request: AuthenticationRequest,
@@ -136,7 +135,7 @@ export const authenticatePasskey = (
 export const AuthenticateServiceLive = Layer.effect(
   AuthenticationService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<GetCredential | RpcClient | Capabilities | StorageService>())
+    const context = yield* _(E.context<GetCredential | AuthenticationClient | Capabilities | StorageService>())
 
     return AuthenticationService.of({
       authenticatePasskey: flow(authenticatePasskey, E.provide(context)),

package/src/connection/connection.fixture.ts

@@ -1,24 +1,12 @@
-import { PreConnectReq, PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
+import { ConnectionClient, ConnectRes } from '@passlock/shared/dist/rpc/connection.js'
 import { Effect as E, Layer as L } from 'effect'
-import * as Fixtures from '../test/fixtures.js'
 
-export const preConnectReq = new PreConnectReq({})
-export const preConnectRes = new PreConnectRes({ warmed: true })
+export const preConnectRes = new ConnectRes({ warmed: true })
 
 export const rpcClientTest = L.succeed(
-  RpcClient,
-  RpcClient.of({
+  ConnectionClient,
+  ConnectionClient.of({
     preConnect: () => E.succeed(preConnectRes),
-    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),
-    registerOidc: () => E.fail(Fixtures.notImplemented),
-    authenticateOidc: () => E.fail(Fixtures.notImplemented),
-    resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
   }),
 )
 

package/src/connection/connection.test.ts

@@ -1,5 +1,6 @@
 import { RpcConfig } from '@passlock/shared/dist/rpc/config.js'
-import { Dispatcher, RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.js'
+import { ConnectionClient } from '@passlock/shared/dist/rpc/connection.js'
+import { Dispatcher } from '@passlock/shared/dist/rpc/dispatcher.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'
@@ -12,17 +13,17 @@ describe('preConnect should', () => {
       const service = yield* _(ConnectionService)
       yield* _(service.preConnect())
 
-      const rpcClient = yield* _(RpcClient)
-      expect(rpcClient.preConnect).toBeCalledWith(Fixture.preConnectReq)
+      const rpcClient = yield* _(ConnectionClient)
+      expect(rpcClient.preConnect).toBeCalled()
 
       const dispatcher = yield* _(Dispatcher)
       expect(dispatcher.get).toBeCalledWith(`/token/token?warm=true`)
     })
 
     const rpcClientTest = Layer.effect(
-      RpcClient,
+      ConnectionClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<ConnectionClient['Type']>()
 
         rpcMock.preConnect.mockReturnValue(E.succeed(Fixture.preConnectRes))
 
@@ -37,7 +38,7 @@ describe('preConnect should', () => {
       E.sync(() => {
         const dispatcherMock = mock<Dispatcher['Type']>()
 
-        dispatcherMock.get.mockReturnValue(E.succeed({}))
+        dispatcherMock.get.mockReturnValue(E.succeed({ status: 200, body: {} }))
 
         return dispatcherMock
       }),

package/src/connection/connection.ts

@@ -2,8 +2,8 @@
  * Hits the rpc endpoint to warm up a lambda
  */
 import type { RpcConfig } from '@passlock/shared/dist/rpc/config.js'
-import { PreConnectReq } from '@passlock/shared/dist/rpc/connection.js'
-import { Dispatcher, RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
+import { ConnectionClient } from '@passlock/shared/dist/rpc/connection.js'
+import { Dispatcher } from '@passlock/shared/dist/rpc/dispatcher.js'
 import { Context, Effect as E, Layer, flow, pipe } from 'effect'
 
 /* Service */
@@ -26,8 +26,8 @@ const hitPrincipal = pipe(
 
 const hitRpc = pipe(
   E.logInfo('Pre-connecting to RPC endpoint'),
-  E.zipRight(RpcClient),
-  E.flatMap(rpcClient => rpcClient.preConnect(new PreConnectReq({}))),
+  E.zipRight(ConnectionClient),
+  E.flatMap(rpcClient => rpcClient.preConnect()),
   E.asVoid,
 )
 
@@ -39,7 +39,7 @@ export const preConnect = () => pipe(E.all([hitPrincipal, hitRpc], { concurrency
 export const ConnectionServiceLive = Layer.effect(
   ConnectionService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<RpcClient | Dispatcher | RpcConfig>())
+    const context = yield* _(E.context<ConnectionClient | Dispatcher | RpcConfig>())
 
     return ConnectionService.of({
       preConnect: flow(preConnect, E.provide(context)),

package/src/effect.ts

@@ -1,5 +1,11 @@
 import { create, get as getCredential } from '@github/webauthn-json/browser-ponyfill'
 
+import { AuthenticationClientLive } from '@passlock/shared/dist/rpc/authentication.js'
+import { ConnectionClientLive } from '@passlock/shared/dist/rpc/connection.js'
+import { RegistrationClientLive } from '@passlock/shared/dist/rpc/registration.js'
+import { SocialClientLive } from '@passlock/shared/dist/rpc/social.js'
+import { UserClientLive } from '@passlock/shared/dist/rpc/user.js'
+
 import {
   Duplicate,
   InternalBrowserError,
@@ -11,12 +17,7 @@ import {
   type Unauthorized,
 } from '@passlock/shared/dist/error/error.js'
 
-import {
-  DispatcherLive,
-  RpcClientLive,
-} from '@passlock/shared/dist/rpc/rpc.js'
-
-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 as L, Layer, Schedule, pipe } from 'effect'
 import type { NoSuchElementException } from 'effect/Cause'
@@ -48,7 +49,8 @@ import {
 } from './storage/storage.js'
 
 import { RetrySchedule, RpcConfig } from '@passlock/shared/dist/rpc/config.js'
-import { SocialService, SocialServiceLive, type OidcRequest } from './social/social.js'
+import { DispatcherLive } from '@passlock/shared/dist/rpc/dispatcher.js'
+import { SocialService, SocialServiceLive, type RegisterOidcReq } from './social/social.js'
 import { UserService, UserServiceLive, type Email } from './user/user.js'
 
 /* Layers */
@@ -98,17 +100,21 @@ const schedule = Schedule.intersect(Schedule.recurs(3), Schedule.exponential('10
 
 const retryScheduleLive = L.succeed(RetrySchedule, RetrySchedule.of({ schedule }))
 
+/* RPC Clients */
 const dispatcherLive = pipe(DispatcherLive, L.provide(retryScheduleLive))
-
-const rpcClientLive = pipe(RpcClientLive, L.provide(dispatcherLive))
+const connectClientLive = pipe(ConnectionClientLive, L.provide(dispatcherLive))
+const registerClientLive = pipe(RegistrationClientLive, L.provide(dispatcherLive))
+const authenticateClientLive = pipe(AuthenticationClientLive, L.provide(dispatcherLive))
+const socialClientLive = pipe(SocialClientLive, L.provide(dispatcherLive))
+const userClientLive = pipe(UserClientLive, L.provide(dispatcherLive))
 
 const storageServiceLive = StorageServiceLive
 
-const userServiceLive = pipe(UserServiceLive, L.provide(rpcClientLive))
+const userServiceLive = pipe(UserServiceLive, L.provide(userClientLive))
 
 const registrationServiceLive = pipe(
   RegistrationServiceLive,
-  L.provide(rpcClientLive),
+  L.provide(registerClientLive),
   L.provide(userServiceLive),
   L.provide(capabilitiesLive),
   L.provide(createCredentialLive),
@@ -117,7 +123,7 @@ const registrationServiceLive = pipe(
 
 const authenticationServiceLive = pipe(
   AuthenticateServiceLive,
-  L.provide(rpcClientLive),
+  L.provide(authenticateClientLive),
   L.provide(capabilitiesLive),
   L.provide(getCredentialLive),
   L.provide(storageServiceLive),
@@ -125,7 +131,7 @@ const authenticationServiceLive = pipe(
 
 const connectionServiceLive = pipe(
   ConnectionServiceLive,
-  L.provide(rpcClientLive),
+  L.provide(connectClientLive),
   L.provide(dispatcherLive),
 )
 
@@ -137,7 +143,7 @@ const urlQueryStringLive = Layer.succeed(
 const emailServiceLive = pipe(
   EmailServiceLive,
   L.provide(urlQueryStringLive),
-  L.provide(rpcClientLive),
+  L.provide(userClientLive),
   L.provide(capabilitiesLive),
   L.provide(authenticationServiceLive),
   L.provide(storageServiceLive),
@@ -145,7 +151,7 @@ const emailServiceLive = pipe(
 
 const socialServiceLive = pipe(
   SocialServiceLive,
-  L.provide(rpcClientLive),
+  L.provide(socialClientLive),
 )
 
 export const allRequirements = Layer.mergeAll(
@@ -271,7 +277,7 @@ export const clearExpiredTokens = (): E.Effect<void> =>
     E.provide(storageLive),
   )
 
-export const authenticateOIDC = (request: OidcRequest) => 
+export const authenticateOIDC = (request: RegisterOidcReq) => 
   pipe(
     SocialService,
     E.flatMap(service => service.registerOidc(request)),

package/src/email/email.fixture.ts

@@ -1,5 +1,4 @@
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import { VerifyEmailReq, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
+import { UserClient, VerifyEmailReq, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
 import { Effect as E, Layer as L } from 'effect'
 import { AuthenticationService } from '../authentication/authenticate.js'
 import * as Fixtures from '../test/fixtures.js'
@@ -27,17 +26,10 @@ export const rpcVerifyEmailReq = new VerifyEmailReq({ token, code })
 export const rpcVerifyEmailRes = new VerifyEmailRes({ principal: Fixtures.principal })
 
 export const rpcClientTest = L.succeed(
-  RpcClient,
-  RpcClient.of({
-    preConnect: () => E.succeed({ warmed: true }),
+  UserClient,
+  UserClient.of({
     isExistingUser: () => E.succeed({ existingUser: true }),
     verifyEmail: () => E.succeed(rpcVerifyEmailRes),
-    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/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'
@@ -18,14 +18,17 @@ import { ConnectionService } from './connection/connection.js'
 import { allRequirements } from './effect.js'
 import { EmailService, type VerifyRequest } from './email/email.js'
 import { RegistrationService, type RegistrationRequest } from './registration/register.js'
-import { SocialService, type OidcRequest } from './social/social.js'
+import { SocialService, type AuthenticateOidcReq, type RegisterOidcReq } from './social/social.js'
 import { Storage, StorageService, type AuthType, type StoredToken } from './storage/storage.js'
 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'
@@ -190,14 +193,14 @@ export class PasslockUnsafe {
       effect => this.runPromise(effect, options),
     )
 
-  registerOidc = (request: OidcRequest, options?: Options) => 
+  registerOidc = (request: RegisterOidcReq, options?: Options) => 
     pipe(
       SocialService,
       E.flatMap(service => service.registerOidc(request)),
       effect => this.runPromise(effect, options),
     )   
     
-  authenticateOidc = (request: OidcRequest, options?: Options) => 
+  authenticateOidc = (request: AuthenticateOidcReq, options?: Options) => 
     pipe(
       SocialService,
       E.flatMap(service => service.authenticateOidc(request)),
@@ -297,14 +300,14 @@ export class Passlock {
       effect => this.runPromise(effect, options),
     )
 
-  registerOidc = (request: OidcRequest, options?: Options) => 
+  registerOidc = (request: RegisterOidcReq, options?: Options) => 
     pipe(
       SocialService,
       E.flatMap(service => service.registerOidc(request)),
       effect => this.runPromise(effect, options),
     )     
 
-  authenticateOidc = (request: OidcRequest, options?: Options) => 
+  authenticateOidc = (request: AuthenticateOidcReq, options?: Options) => 
     pipe(
       SocialService,
       E.flatMap(service => service.authenticateOidc(request)),

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({