@passlock/client 0.9.29 → 0.9.32

package/src/registration/register.fixture.ts

@@ -1,15 +1,15 @@
 import { Effect as E, Layer as L, Option as O } from 'effect'
 
 import {
-  OptionsReq,
-  OptionsRes,
-  VerificationReq,
-  VerificationRes,
-} from '@passlock/shared/dist/rpc/registration.js'
+  OptionsRequest,
+  OptionsResponse,
+  VerificationRequest,
+  VerificationResponse,
+} from '@passlock/shared/dist/rpc/passkey/registration.js'
 import type { RegistrationCredential } from '@passlock/shared/dist/schema/passkey.js'
 
 import * as Fixtures from '../test/fixtures.js'
-import { RegistrationClient } from '../rpc/registration.js'
+import { RegistrationClient } from '../rpc/passkey/registration.js'
 import { UserService } from '../user/user.js'
 import { CreateCredential, type RegistrationRequest } from './register.js'
 
@@ -27,9 +27,9 @@ export const registrationRequest: RegistrationRequest = {
   verifyEmail: O.none(),
 }
 
-export const rpcOptionsReq = new OptionsReq(registrationRequest)
+export const rpcOptionsReq = new OptionsRequest(registrationRequest)
 
-export const registrationOptions: OptionsRes = {
+export const registrationOptions: OptionsResponse = {
   session,
   publicKey: {
     rp: {
@@ -46,7 +46,7 @@ export const registrationOptions: OptionsRes = {
   },
 }
 
-export const rpcOptionsRes = new OptionsRes(registrationOptions)
+export const rpcOptionsRes = new OptionsResponse(registrationOptions)
 
 export const credential: RegistrationCredential = {
   type: 'public-key',
@@ -60,13 +60,13 @@ export const credential: RegistrationCredential = {
   clientExtensionResults: {},
 }
 
-export const rpcVerificationReq = new VerificationReq({
+export const rpcVerificationReq = new VerificationRequest({
   session,
   credential,
   verifyEmail: O.none(),
 })
 
-export const rpcVerificationRes = new VerificationRes({ principal: Fixtures.principal })
+export const rpcVerificationRes = new VerificationResponse({ principal: Fixtures.principal })
 
 export const createCredentialTest = L.succeed(
   CreateCredential,

package/src/registration/register.test.ts

@@ -5,7 +5,7 @@ import { mock } from 'vitest-mock-extended'
 import { Duplicate, InternalBrowserError } from '@passlock/shared/dist/error/error.js'
 
 import * as Fixture from './register.fixture.js'
-import { RegistrationClient } from '../rpc/registration.js'
+import { RegistrationClient } from '../rpc/passkey/registration.js'
 import { CreateCredential, RegistrationService, RegistrationServiceLive } from './register.js'
 
 describe('register should', () => {

package/src/registration/register.ts

@@ -9,19 +9,17 @@ import { Context, Effect as E, Layer, flow, pipe } from 'effect'
 
 import type { Duplicate, NotSupported } from '@passlock/shared/dist/error/error.js'
 import { 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 * as RPC from '../rpc/passkey/registration.js'
 import type { RegistrationCredential } from '@passlock/shared/dist/schema/passkey.js'
 import type { Principal } from '@passlock/shared/dist/schema/principal.js'
 
 import { Capabilities } from '../capabilities/capabilities.js'
-import { RegistrationClient } from '../rpc/registration.js'
 import { StorageService } from '../storage/storage.js'
 import type { UserService } from '../user/user.js'
 
 /* Requests */
 
-export type RegistrationRequest = OptionsReq
+export type RegistrationRequest = RPC.OptionsRequest
 
 /* Dependencies */
 
@@ -36,7 +34,7 @@ export class CreateCredential extends Context.Tag('@services/CreateCredential')<
 
 /* Errors */
 
-export type RegistrationErrors = NotSupported | OptionsErrors | VerificationErrors
+export type RegistrationErrors = NotSupported | RPC.OptionsErrors | RPC.VerificationErrors
 
 /* Service */
 
@@ -49,11 +47,11 @@ export class RegistrationService extends Context.Tag('@services/RegistrationServ
 
 /* Utilities */
 
-const fetchOptions = (request: OptionsReq) => {
+const fetchOptions = (request: RPC.OptionsRequest) => {
   return E.gen(function* (_) {
     yield* _(E.logDebug('Making request'))
 
-    const rpcClient = yield* _(RegistrationClient)
+    const rpcClient = yield* _(RPC.RegistrationClient)
     const { publicKey, session } = yield* _(rpcClient.getRegistrationOptions(request))
 
     yield* _(E.logDebug('Converting Passlock options to CredentialCreationOptions'))
@@ -76,11 +74,11 @@ const toCreationOptions = (jsonOptions: CredentialCreationOptionsJSON) => {
   )
 }
 
-const verifyCredential = (request: VerificationReq) => {
+const verifyCredential = (request: RPC.VerificationRequest) => {
   return E.gen(function* (_) {
     yield* _(E.logDebug('Making request'))
 
-    const rpcClient = yield* _(RegistrationClient)
+    const rpcClient = yield* _(RPC.RegistrationClient)
     const { principal } = yield* _(rpcClient.verifyRegistrationCredential(request))
 
     return principal
@@ -94,7 +92,7 @@ type Dependencies =
   | CreateCredential
   | StorageService
   | UserService
-  | RegistrationClient
+  | RPC.RegistrationClient
 
 export const registerPasskey = (
   request: RegistrationRequest,
@@ -105,14 +103,14 @@ export const registerPasskey = (
     yield* _(capabilities.passkeySupport)
 
     yield* _(E.logInfo('Fetching registration options from Passlock'))
-    const { options, session } = yield* fetchOptions(new OptionsReq(request))
+    const { options, session } = yield* fetchOptions(new RPC.OptionsRequest(request))
 
     yield* _(E.logInfo('Building new credential'))
     const { createCredential } = yield* _(CreateCredential)
     const credential = yield* _(createCredential(options))
 
     yield* _(E.logInfo('Storing credential public key in Passlock'))
-    const verificationRequest = new VerificationReq({
+    const verificationRequest = new RPC.VerificationRequest({
       ...request,
       credential,
       session,
@@ -146,7 +144,7 @@ export const RegistrationServiceLive = Layer.effect(
   E.gen(function* (_) {
     const context = yield* _(
       E.context<
-        CreateCredential | RegistrationClient | Capabilities | StorageService | UserService
+        CreateCredential | RPC.RegistrationClient | Capabilities | StorageService | UserService
       >(),
     )
 

package/src/rpc/client.ts

@@ -62,7 +62,7 @@ export const DispatcherLive = Layer.effect(
     }
 
     const buildUrl = (_path: string) => {
-      const endpoint = maybeEndpoint || 'https://api.passlock.dev'
+      const endpoint = maybeEndpoint || 'https://api.v1.passlock.dev'
       // drop leading /
       const path = _path.replace(/^\//, '')
       return `${endpoint}/${tenancyId}/${path}`

package/src/rpc/connection.ts

@@ -3,7 +3,7 @@ import { Context, Effect as E, Layer } from 'effect'
 
 import {
   CONNECT_ENDPOINT,
-  ConnectRes,
+  ConnectResponse,
   type ConnectionService,
 } from '@passlock/shared/dist/rpc/connection.js'
 
@@ -21,10 +21,12 @@ export const ConnectionClientLive = Layer.effect(
   E.gen(function* (_) {
     const dispatcher = yield* _(Dispatcher)
 
-    const preConnectResolver = makeGetRequest(ConnectRes, S.Never, dispatcher)
+    const preConnectResolver = makeGetRequest(ConnectResponse, S.Never, dispatcher)
 
     return {
       preConnect: () => preConnectResolver(CONNECT_ENDPOINT),
     }
   }),
 )
+
+export { ConnectResponse } from '@passlock/shared/dist/rpc/connection.js'

package/src/rpc/{authentication.ts → passkey/authentication.ts}

@@ -4,40 +4,49 @@ import {
   type AuthenticationService,
   OPTIONS_ENDPOINT,
   OptionsErrors,
-  OptionsReq,
-  OptionsRes,
-  VERIFY_ENDPOINT,
+  OptionsRequest,
+  OptionsResponse,
+  VERIFICATION_ENDPOINT,
   VerificationErrors,
-  VerificationReq,
-  VerificationRes,
-} from '@passlock/shared/dist/rpc/authentication.js'
+  VerificationRequest,
+  VerificationResponse,
+} from '@passlock/shared/dist/rpc/passkey/authentication.js'
 
-import { Dispatcher, makePostRequest } from './client.js'
+import { Dispatcher, makePostRequest } from '../client.js'
 
 /* Client */
 
-export class AuthenticationClient extends Context.Tag('@passkey/auth/client')<
+export class AuthenticationClient extends Context.Tag('@passkey/authentication/client')<
   AuthenticationClient,
   AuthenticationService
->() {}
+>() { }
 
 export const AuthenticationClientLive = Layer.effect(
   AuthenticationClient,
   E.gen(function* (_) {
     const dispatcher = yield* _(Dispatcher)
 
-    const optionsResolver = makePostRequest(OptionsReq, OptionsRes, OptionsErrors, dispatcher)
+    const optionsResolver = makePostRequest(OptionsRequest, OptionsResponse, OptionsErrors, dispatcher)
 
     const verifyResolver = makePostRequest(
-      VerificationReq,
-      VerificationRes,
+      VerificationRequest,
+      VerificationResponse,
       VerificationErrors,
       dispatcher,
     )
 
     return {
       getAuthenticationOptions: req => optionsResolver(OPTIONS_ENDPOINT, req),
-      verifyAuthenticationCredential: req => verifyResolver(VERIFY_ENDPOINT, req),
+      verifyAuthenticationCredential: req => verifyResolver(VERIFICATION_ENDPOINT, req),
     }
   }),
 )
+
+export {
+  OptionsErrors,
+  OptionsRequest,
+  OptionsResponse,
+  VerificationErrors,
+  VerificationRequest,
+  VerificationResponse,
+} from '@passlock/shared/dist/rpc/passkey/authentication.js'

package/src/rpc/passkey/registration.ts

@@ -0,0 +1,52 @@
+import { Context, Effect as E, Layer } from 'effect'
+
+import {
+  OptionsErrors,
+  OptionsRequest,
+  OptionsResponse,
+  type RegistrationService,
+  VerificationErrors,
+  VerificationRequest,
+  VerificationResponse,
+  OPTIONS_ENDPOINT,
+  VERIFICATION_ENDPOINT
+} from '@passlock/shared/dist/rpc/passkey/registration.js'
+
+import { Dispatcher, makePostRequest } from '../client.js'
+
+/* Client */
+
+export class RegistrationClient extends Context.Tag('@passkey/register/client')<
+  RegistrationClient,
+  RegistrationService
+>() {}
+
+export const RegistrationClientLive = Layer.effect(
+  RegistrationClient,
+  E.gen(function* (_) {
+    const dispatcher = yield* _(Dispatcher)
+
+    const optionsResolver = makePostRequest(OptionsRequest, OptionsResponse, OptionsErrors, dispatcher)
+
+    const verifyResolver = makePostRequest(
+      VerificationRequest,
+      VerificationResponse,
+      VerificationErrors,
+      dispatcher,
+    )
+
+    return {
+      getRegistrationOptions: req => optionsResolver(OPTIONS_ENDPOINT, req),
+      verifyRegistrationCredential: req => verifyResolver(VERIFICATION_ENDPOINT, req),
+    }
+  }),
+)
+
+export {
+  OptionsErrors,
+  OptionsRequest,
+  OptionsResponse,
+  VerificationErrors,
+  VerificationRequest,
+  VerificationResponse,
+} from '@passlock/shared/dist/rpc/passkey/registration.js'

package/src/rpc/social.ts

@@ -1,12 +1,14 @@
 import { Context, Effect as E, Layer } from 'effect'
 
 import {
-  AuthOidcErrors,
-  AuthOidcReq,
-  PrincipalRes,
-  RegisterOidcErrors,
-  RegisterOidcReq,
-  type SocialService,
+  OIDCRegistrationRequest,
+  OIDCRegistrationErrors,
+  OIDCAuthenticationRequest,
+  OIDCAuthenticationErrors,
+  OIDC_REGISTRATION_ENDPOINT,
+  OIDC_AUTHENTICATION_ENDPOINT,
+  PrincipalResponse,
+  type SocialService
 } from '@passlock/shared/dist/rpc/social.js'
 
 import { Dispatcher, makePostRequest } from './client.js'
@@ -24,22 +26,30 @@ export const SocialClientLive = Layer.effect(
     const dispatcher = yield* _(Dispatcher)
 
     const registerResolver = makePostRequest(
-      RegisterOidcReq,
-      PrincipalRes,
-      RegisterOidcErrors,
+      OIDCRegistrationRequest,
+      PrincipalResponse,
+      OIDCRegistrationErrors,
       dispatcher,
     )
 
     const authenticateResolver = makePostRequest(
-      AuthOidcReq,
-      PrincipalRes,
-      AuthOidcErrors,
+      OIDCAuthenticationRequest,
+      PrincipalResponse,
+      OIDCAuthenticationErrors,
       dispatcher,
     )
 
     return {
-      registerOidc: req => registerResolver(OIDC_REGISTER_ENDPOINT, req),
-      authenticateOidc: req => authenticateResolver(OIDC_AUTH_ENDPOINT, req),
+      oidcRegistration: req => registerResolver(OIDC_REGISTRATION_ENDPOINT, req),
+      oidcAuthentication: req => authenticateResolver(OIDC_AUTHENTICATION_ENDPOINT, req),
     }
   }),
 )
+
+export {
+  OIDCRegistrationRequest,
+  OIDCRegistrationErrors,
+  OIDCAuthenticationRequest,
+  OIDCAuthenticationErrors,
+  PrincipalResponse,
+} from '@passlock/shared/dist/rpc/social.js'

package/src/rpc/user.ts

@@ -2,18 +2,18 @@ import * as S from '@effect/schema/Schema'
 import { Context, Effect as E, Layer } from 'effect'
 
 import {
-  IsExistingUserReq,
-  IsExistingUserRes,
+  IsExistingUserRequest,
+  IsExistingUserResponse,
   RESEND_EMAIL_ENDPOINT,
   ResendEmailErrors,
-  ResendEmailReq,
-  ResendEmailRes,
+  ResendEmailRequest,
+  ResendEmailResponse,
   USER_STATUS_ENDPOINT,
   type UserService,
   VERIFY_EMAIL_ENDPOINT,
   VerifyEmailErrors,
-  VerifyEmailReq,
-  VerifyEmailRes,
+  VerifyEmailRequest,
+  VerifyEmailResponse,
 } from '@passlock/shared/dist/rpc/user.js'
 
 import { Dispatcher, makePostRequest } from './client.js'
@@ -28,22 +28,22 @@ export const UserClientLive = Layer.effect(
     const dispatcher = yield* _(Dispatcher)
 
     const isExistingUserResolver = makePostRequest(
-      IsExistingUserReq,
-      IsExistingUserRes,
+      IsExistingUserRequest,
+      IsExistingUserResponse,
       S.Never,
       dispatcher,
     )
 
     const verifyEmailResolver = makePostRequest(
-      VerifyEmailReq,
-      VerifyEmailRes,
+      VerifyEmailRequest,
+      VerifyEmailResponse,
       VerifyEmailErrors,
       dispatcher,
     )
 
     const resendEmailResolver = makePostRequest(
-      ResendEmailReq,
-      ResendEmailRes,
+      ResendEmailRequest,
+      ResendEmailResponse,
       ResendEmailErrors,
       dispatcher,
     )
@@ -55,3 +55,14 @@ export const UserClientLive = Layer.effect(
     }
   }),
 )
+
+export {
+  IsExistingUserRequest,
+  IsExistingUserResponse,
+  ResendEmailErrors,
+  ResendEmailRequest,
+  ResendEmailResponse,
+  VerifyEmailErrors,
+  VerifyEmailRequest,
+  VerifyEmailResponse,
+} from '@passlock/shared/dist/rpc/user.js'

package/src/social/social.fixture.ts

@@ -1,10 +1,9 @@
 import { Effect as E, Layer as L, Option as O } from 'effect'
 
-import * as Shared from '@passlock/shared/dist/rpc/social.js'
-
 import * as Fixtures from '../test/fixtures.js'
 import { SocialClient } from '../rpc/social.js'
 import type { AuthenticateOidcReq } from './social.js'
+import { OIDCAuthenticationRequest, OIDCRegistrationRequest, PrincipalResponse } from '@passlock/shared/dist/rpc/social.js'
 
 export const session = 'session'
 export const token = 'token'
@@ -12,7 +11,7 @@ export const code = 'code'
 export const authType = 'passkey'
 export const expireAt = Date.now() + 10000
 
-export const registerOidcReq = new Shared.RegisterOidcReq({
+export const registerOidcReq = new OIDCRegistrationRequest({
   provider: 'google',
   idToken: 'google-token',
   nonce: 'nonce',
@@ -20,21 +19,21 @@ export const registerOidcReq = new Shared.RegisterOidcReq({
   familyName: O.some('doe'),
 })
 
-export const authOidcReq: AuthenticateOidcReq = new Shared.AuthOidcReq({
+export const authOidcReq: AuthenticateOidcReq = new OIDCAuthenticationRequest({
   provider: 'google',
   idToken: 'google-token',
   nonce: 'nonce',
 })
 
-export const rpcRegisterRes = new Shared.PrincipalRes({ principal: Fixtures.principal })
+export const rpcRegisterRes = new PrincipalResponse({ principal: Fixtures.principal })
 
-export const rpcAuthenticateRes = new Shared.PrincipalRes({ principal: Fixtures.principal })
+export const rpcAuthenticateRes = new PrincipalResponse({ principal: Fixtures.principal })
 
 export const rpcClientTest = L.succeed(
   SocialClient,
   SocialClient.of({
-    registerOidc: () => E.fail(Fixtures.notImplemented),
-    authenticateOidc: () => E.fail(Fixtures.notImplemented),
+    oidcRegistration: () => E.fail(Fixtures.notImplemented),
+    oidcAuthentication: () => E.fail(Fixtures.notImplemented),
   }),
 )
 

package/src/social/social.test.ts

@@ -21,7 +21,7 @@ describe('registerOidc should', () => {
       E.sync(() => {
         const rpcMock = mock<SocialClient['Type']>()
 
-        rpcMock.registerOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
+        rpcMock.oidcRegistration.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
         return rpcMock
       }),
@@ -41,7 +41,7 @@ describe('registerOidc should', () => {
       yield* _(service.registerOidc(Fixture.registerOidcReq))
 
       const rpcClient = yield* _(SocialClient)
-      expect(rpcClient.registerOidc).toHaveBeenCalledWith(Fixture.registerOidcReq)
+      expect(rpcClient.oidcRegistration).toHaveBeenCalledWith(Fixture.registerOidcReq)
     })
 
     const rpcClientTest = L.effect(
@@ -49,7 +49,7 @@ describe('registerOidc should', () => {
       E.sync(() => {
         const rpcMock = mock<SocialClient['Type']>()
 
-        rpcMock.registerOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
+        rpcMock.oidcRegistration.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
         return rpcMock
       }),
@@ -77,7 +77,7 @@ describe('registerOidc should', () => {
       E.sync(() => {
         const rpcMock = mock<SocialClient['Type']>()
 
-        rpcMock.registerOidc.mockReturnValue(E.fail(new Duplicate({ message: 'Duplicate user' })))
+        rpcMock.oidcRegistration.mockReturnValue(E.fail(new Duplicate({ message: 'Duplicate user' })))
 
         return rpcMock
       }),
@@ -105,7 +105,7 @@ describe('authenticateIodc should', () => {
       E.sync(() => {
         const rpcMock = mock<SocialClient['Type']>()
 
-        rpcMock.authenticateOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
+        rpcMock.oidcAuthentication.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
         return rpcMock
       }),
@@ -125,7 +125,7 @@ describe('authenticateIodc should', () => {
       yield* _(service.authenticateOidc(Fixture.authOidcReq))
 
       const rpcClient = yield* _(SocialClient)
-      expect(rpcClient.authenticateOidc).toHaveBeenCalledWith(Fixture.authOidcReq)
+      expect(rpcClient.oidcAuthentication).toHaveBeenCalledWith(Fixture.authOidcReq)
     })
 
     const rpcClientTest = L.effect(
@@ -133,7 +133,7 @@ describe('authenticateIodc should', () => {
       E.sync(() => {
         const rpcMock = mock<SocialClient['Type']>()
 
-        rpcMock.authenticateOidc.mockReturnValue(E.succeed(Fixture.rpcAuthenticateRes))
+        rpcMock.oidcAuthentication.mockReturnValue(E.succeed(Fixture.rpcAuthenticateRes))
 
         return rpcMock
       }),
@@ -161,7 +161,7 @@ describe('authenticateIodc should', () => {
       E.sync(() => {
         const rpcMock = mock<SocialClient['Type']>()
 
-        rpcMock.authenticateOidc.mockReturnValue(
+        rpcMock.oidcAuthentication.mockReturnValue(
           E.fail(new NotFound({ message: 'User not found' })),
         )
 

package/src/social/social.ts

@@ -2,26 +2,23 @@
  * Passkey authentication effects
  */
 import { Context, Effect as E, Layer, flow } from 'effect'
-
-import * as RPC from '@passlock/shared/dist/rpc/social.js'
+import * as RPC from '../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 = RPC.RegisterOidcReq
+export type RegisterOidcReq = RPC.OIDCRegistrationRequest
 
-export type AuthenticateOidcReq = RPC.AuthOidcReq
+export type AuthenticateOidcReq = RPC.OIDCAuthenticationRequest
 
 /* Errors */
 
-export type RegistrationErrors = NotSupported | BadRequest | RPC.RegisterOidcErrors
+export type RegistrationErrors = NotSupported | BadRequest | RPC.OIDCRegistrationErrors
 
-export type AuthenticationErrors = NotSupported | BadRequest | RPC.AuthOidcErrors
+export type AuthenticationErrors = NotSupported | BadRequest | RPC.OIDCAuthenticationErrors
 
 /* Service */
 
@@ -35,7 +32,7 @@ export class SocialService extends Context.Tag('@services/SocialService')<
 
 /* Effects */
 
-type Dependencies = SocialClient
+type Dependencies = RPC.SocialClient
 
 export const registerOidc = (
   request: RegisterOidcReq,
@@ -43,9 +40,9 @@ export const registerOidc = (
   return E.gen(function* (_) {
     yield* _(E.logInfo('Registering social account'))
 
-    const rpcClient = yield* _(SocialClient)
-    const rpcRequest = new RPC.RegisterOidcReq(request)
-    const { principal } = yield* _(rpcClient.registerOidc(rpcRequest))
+    const rpcClient = yield* _(RPC.SocialClient)
+    const rpcRequest = new RPC.OIDCRegistrationRequest(request)
+    const { principal } = yield* _(rpcClient.oidcRegistration(rpcRequest))
 
     return principal
   })
@@ -57,9 +54,9 @@ export const authenticateOidc = (
   return E.gen(function* (_) {
     yield* _(E.logInfo('Authenticating with social account'))
 
-    const rpcClient = yield* _(SocialClient)
-    const rpcRequest = new RPC.AuthOidcReq(request)
-    const { principal } = yield* _(rpcClient.authenticateOidc(rpcRequest))
+    const rpcClient = yield* _(RPC.SocialClient)
+    const rpcRequest = new RPC.OIDCAuthenticationRequest(request)
+    const { principal } = yield* _(rpcClient.oidcAuthentication(rpcRequest))
 
     return principal
   })
@@ -71,7 +68,7 @@ export const authenticateOidc = (
 export const SocialServiceLive = Layer.effect(
   SocialService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<SocialClient>())
+    const context = yield* _(E.context<RPC.SocialClient>())
 
     return SocialService.of({
       registerOidc: flow(registerOidc, E.provide(context)),

package/src/user/user.fixture.ts

@@ -1,11 +1,11 @@
 import { Effect as E, Layer as L, Option as O } from 'effect'
 
 import {
-  IsExistingUserReq,
-  IsExistingUserRes,
-  ResendEmailReq,
-  ResendEmailRes,
-  VerifyEmailRes,
+  IsExistingUserRequest,
+  IsExistingUserResponse,
+  ResendEmailRequest,
+  ResendEmailResponse,
+  VerifyEmailResponse,
 } from '@passlock/shared/dist/rpc/user.js'
 
 import * as Fixtures from '../test/fixtures.js'
@@ -13,15 +13,15 @@ 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, detail: O.none() })
-export const verifyEmailRes = new VerifyEmailRes({ principal: Fixtures.principal })
+export const isRegisteredReq = new IsExistingUserRequest({ email })
+export const isRegisteredRes = new IsExistingUserResponse({ existingUser: false, detail: O.none() })
+export const verifyEmailRes = new VerifyEmailResponse({ principal: Fixtures.principal })
 export const resendEmailReq: ResendEmail = { userId: '123', method: 'code' }
-export const rpcResendEmailReq = new ResendEmailReq({
+export const rpcResendEmailReq = new ResendEmailRequest({
   userId: '123',
   verifyEmail: { method: 'code' },
 })
-export const rpcResendEmailRes = new ResendEmailRes({})
+export const rpcResendEmailRes = new ResendEmailResponse({})
 
 export const rpcClientTest = L.succeed(
   UserClient,