@passlock/client 0.9.10 → 0.9.12

package/src/registration/register.ts

@@ -2,8 +2,8 @@
  * User & passkey registration effects
  */
 import {
-  type CredentialCreationOptionsJSON,
-  parseCreationOptionsFromJSON,
+    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'
@@ -11,10 +11,10 @@ import type { OptionsErrors, VerificationErrors } from '@passlock/shared/dist/rp
 import { OptionsReq, VerificationReq } from '@passlock/shared/dist/rpc/registration.js'
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
 import type {
-  Principal,
-  RegistrationCredential,
-  UserVerification,
-  VerifyEmail,
+    Principal,
+    RegistrationCredential,
+    UserVerification,
+    VerifyEmail,
 } from '@passlock/shared/dist/schema/schema.js'
 import { Context, Effect as E, Layer, flow, pipe } from 'effect'
 import { Capabilities } from '../capabilities/capabilities.js'

package/src/social/social.fixture.ts

@@ -0,0 +1,47 @@
+import { PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
+import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
+import { AuthenticateOidcReq, OidcRes, RegisterOidcReq } 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 OidcRequest } from './social.js'
+
+export const session = 'session'
+export const token = 'token'
+export const code = 'code'
+export const authType = 'passkey'
+export const expireAt = Date.now() + 10000
+
+export const oidcReq: OidcRequest = {
+  provider: 'google',
+  idToken: 'google-token'
+}
+
+export const rpcRegisterReq = new RegisterOidcReq({ ...oidcReq })
+
+export const rpcRegisterRes = new OidcRes({ principal: Fixtures.principal })
+
+export const rpcAuthenticateReq = new AuthenticateOidcReq({ ...oidcReq })
+
+export const rpcAuthenticateRes = new OidcRes({ 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),
+    registerOidc: () => E.fail(Fixtures.notImplemented),
+    authenticateOidc: () => E.fail(Fixtures.notImplemented),
+    resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
+  }),
+)
+
+export const principal = Fixtures.principal
+
+export const capabilitiesTest = Fixtures.capabilitiesTest
+
+export const storageServiceTest = Fixtures.storageServiceTest

package/src/social/social.test.ts

@@ -0,0 +1,193 @@
+import { Duplicate, NotFound } from '@passlock/shared/dist/error/error.js'
+import { RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.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 './social.fixture.js'
+import { SocialService, SocialServiceLive } from './social.js'
+
+describe('registerOidc should', () => {
+  test('return a valid credential', async () => {
+    const assertions = E.gen(function* (_) {
+      const service = yield* _(SocialService)
+      const result = yield* _(service.registerOidc(Fixture.oidcReq))
+      expect(result).toEqual(Fixture.principal)
+    })
+
+    const rpcClientTest = L.effect(
+      RpcClient,
+      E.sync(() => {
+        const rpcMock = mock<RouterOps>()
+
+        rpcMock.registerOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
+
+        return rpcMock
+      }),
+    )
+
+    const service = pipe(
+      SocialServiceLive,
+      L.provide(rpcClientTest),
+    )
+
+    const layers = Layer.merge(service, rpcClientTest)
+    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
+
+    return E.runPromise(effect)
+  })
+
+  test('pass the request to the backend', async () => {
+    const assertions = E.gen(function* (_) {
+      const service = yield* _(SocialService)
+      yield* _(service.registerOidc(Fixture.oidcReq))
+
+      const rpcClient = yield* _(RpcClient)
+      expect(rpcClient.registerOidc).toHaveBeenCalledWith(Fixture.rpcRegisterReq)
+    })
+
+    const rpcClientTest = L.effect(
+      RpcClient,
+      E.sync(() => {
+        const rpcMock = mock<RouterOps>()
+
+        rpcMock.registerOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
+
+        return rpcMock
+      }),
+    )
+
+    const service = pipe(
+      SocialServiceLive,
+      L.provide(rpcClientTest),
+    )
+
+    const layers = Layer.merge(service, rpcClientTest)
+    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
+
+    return E.runPromise(effect)
+  })
+
+  test('return an error if we try to register an existing user', async () => {
+    const assertions = E.gen(function* (_) {
+      const service = yield* _(SocialService)
+
+      const defect = yield* _(service.registerOidc(Fixture.oidcReq), E.flip)
+
+      expect(defect).toBeInstanceOf(Duplicate)
+    })
+
+    const rpcClientTest = L.effect(
+      RpcClient,
+      E.sync(() => {
+        const rpcMock = mock<RouterOps>()
+
+        rpcMock.registerOidc.mockReturnValue(E.fail(new Duplicate({ message: "Duplicate user" })))
+
+        return rpcMock
+      }),
+    )
+
+    const service = pipe(
+      SocialServiceLive,
+      L.provide(rpcClientTest),
+    )
+
+    const layers = Layer.merge(service, rpcClientTest)
+    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
+
+    return E.runPromise(effect)
+  })
+})
+
+describe('authenticateIodc should', () => {
+  test('return a valid credential', async () => {
+    const assertions = E.gen(function* (_) {
+      const service = yield* _(SocialService)
+      const result = yield* _(service.authenticateOidc(Fixture.oidcReq))
+      expect(result).toEqual(Fixture.principal)
+    })
+
+    const rpcClientTest = L.effect(
+      RpcClient,
+      E.sync(() => {
+        const rpcMock = mock<RouterOps>()
+
+        rpcMock.authenticateOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
+
+        return rpcMock
+      }),
+    )
+
+    const service = pipe(
+      SocialServiceLive,
+      L.provide(rpcClientTest),
+    )
+
+    const layers = Layer.merge(service, rpcClientTest)
+    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
+
+    return E.runPromise(effect)
+  })
+
+  test('pass the request to the backend', async () => {
+    const assertions = E.gen(function* (_) {
+      const service = yield* _(SocialService)
+      yield* _(service.authenticateOidc(Fixture.oidcReq))
+
+      const rpcClient = yield* _(RpcClient)
+      expect(rpcClient.authenticateOidc).toHaveBeenCalledWith(Fixture.rpcAuthenticateReq)
+    })
+
+    const rpcClientTest = L.effect(
+      RpcClient,
+      E.sync(() => {
+        const rpcMock = mock<RouterOps>()
+
+        rpcMock.authenticateOidc.mockReturnValue(E.succeed(Fixture.rpcAuthenticateRes))
+
+        return rpcMock
+      }),
+    )
+
+    const service = pipe(
+      SocialServiceLive,
+      L.provide(rpcClientTest),
+    )
+
+    const layers = Layer.merge(service, rpcClientTest)
+    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
+
+    return E.runPromise(effect)
+  })
+
+  test('return an error if we try to authenticate a non-existing user', async () => {
+    const assertions = E.gen(function* (_) {
+      const service = yield* _(SocialService)
+
+      const defect = yield* _(service.authenticateOidc(Fixture.oidcReq), E.flip)
+
+      expect(defect).toBeInstanceOf(NotFound)
+    })
+
+    const rpcClientTest = L.effect(
+      RpcClient,
+      E.sync(() => {
+        const rpcMock = mock<RouterOps>()
+
+        rpcMock.authenticateOidc.mockReturnValue(E.fail(new NotFound({ message: "User not found" })))
+
+        return rpcMock
+      }),
+    )
+
+    const service = pipe(
+      SocialServiceLive,
+      L.provide(rpcClientTest),
+    )
+
+    const layers = Layer.merge(service, rpcClientTest)
+    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
+
+    return E.runPromise(effect)
+  })
+})

package/src/social/social.ts

@@ -2,13 +2,13 @@
  * Passkey authentication effects
  */
 import {
-  type BadRequest,
-  type NotSupported
+    type BadRequest,
+    type NotSupported
 } from '@passlock/shared/dist/error/error.js'
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
 import { AuthenticateOidcErrors, AuthenticateOidcReq, RegisterOidcErrors, RegisterOidcReq } from '@passlock/shared/dist/rpc/social.js'
 import type {
-  Principal
+    Principal
 } from '@passlock/shared/dist/schema/schema.js'
 import { Context, Effect as E, Layer, flow } from 'effect'
 

package/src/storage/storage.test.ts

@@ -1,8 +1,8 @@
 import { Effect as E, Layer, LogLevel, Logger, identity, pipe } from 'effect'
 import { describe, expect, test } from 'vitest'
 import { mock } from 'vitest-mock-extended'
-import { Storage, StorageService, clearExpiredToken, clearToken, getToken } from './storage.js'
 import { principal, testLayers } from './storage.fixture.js'
+import { Storage, StorageService, clearExpiredToken, clearToken, getToken } from './storage.js'
 
 // eslint chokes on expect(storage.setItem) etc
 /* eslint @typescript-eslint/unbound-method: 0 */

package/src/test/fixtures.ts

@@ -1,9 +1,9 @@
+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 { Effect as E, Layer as L } from 'effect'
 import { Capabilities } from '../capabilities/capabilities.js'
 import { StorageService, type StoredToken } from '../storage/storage.js'
-import { BadRequest } from '@passlock/shared/dist/error/error.js'
-import { PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
 
 export const session = 'session'
 export const token = 'token'

package/src/user/user.fixture.ts

@@ -1,12 +1,16 @@
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import { IsExistingUserReq, IsExistingUserRes, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
+import { IsExistingUserReq, IsExistingUserRes, ResendEmailReq, ResendEmailRes, 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'
 
 export const email = 'jdoe@gmail.com'
 export const isRegisteredReq = new IsExistingUserReq({ email })
 export const isRegisteredRes = new IsExistingUserRes({ existingUser: false })
 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 rpcClientTest = L.succeed(
   RpcClient,

package/src/user/user.test.ts

@@ -1,9 +1,9 @@
-import { type RouterOps, RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
+import { RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.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 { UserService, UserServiceLive } from './user.js'
 import * as Fixture from './user.fixture.js'
+import { UserService, UserServiceLive } from './user.js'
 
 describe('isExistingUser should', () => {
   test('return true when the user already has a passkey', async () => {
@@ -50,3 +50,37 @@ describe('isExistingUser should', () => {
     return E.runPromise(effect)
   })
 })
+
+describe('resendVerificationEmail should', () => {
+  test('forward the request to the backend', async () => {
+    const assertions = E.gen(function* (_) {
+      const service = yield* _(UserService)
+      yield* _(service.resendVerificationEmail(Fixture.resendEmailReq))
+
+      const rpcClient = yield* _(RpcClient)
+      expect(rpcClient.resendVerificationEmail).toBeCalledWith(Fixture.rpcResendEmailReq)
+    })
+
+    const rpcClientTest = Layer.effect(
+      RpcClient,
+      E.sync(() => {
+        const rpcMock = mock<RouterOps>()
+
+        rpcMock.resendVerificationEmail.mockReturnValue(E.succeed(Fixture.rpcResendEmailRes))
+
+        return rpcMock
+      }),
+    )
+
+    const service = pipe(UserServiceLive, L.provide(rpcClientTest))
+
+    const layers = L.merge(service, rpcClientTest)
+
+    const effect = pipe(
+      E.provide(assertions, layers),
+      Logger.withMinimumLogLevel(LogLevel.None)
+    )
+
+    return E.runPromise(effect)
+  })
+})