@passlock/client 0.9.32 → 2.0.0-beta.1

package/src/connection/connection.test.ts

@@ -1,60 +0,0 @@
-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 './connection.fixture.js'
-import { Dispatcher } from '../rpc/client.js'
-import { RpcConfig } from '../rpc/config.js'
-import { ConnectionClient } from '../rpc/connection.js'
-import { ConnectionService, ConnectionServiceLive } from './connection.js'
-
-describe('preConnect should', () => {
-  test('hit the rpc endpoint', async () => {
-    const assertions = E.gen(function* (_) {
-      const service = yield* _(ConnectionService)
-      yield* _(service.preConnect())
-
-      const rpcClient = yield* _(ConnectionClient)
-      expect(rpcClient.preConnect).toBeCalled()
-
-      const dispatcher = yield* _(Dispatcher)
-      expect(dispatcher.get).toBeCalledWith(`/token/token?warm=true`)
-    })
-
-    const rpcClientTest = Layer.effect(
-      ConnectionClient,
-      E.sync(() => {
-        const rpcMock = mock<ConnectionClient['Type']>()
-
-        rpcMock.preConnect.mockReturnValue(E.succeed(Fixture.preConnectRes))
-
-        return rpcMock
-      }),
-    )
-
-    const rpcConfigTest = Layer.succeed(RpcConfig, RpcConfig.of(Fixture.rpcConfig))
-
-    const dispatcherTest = Layer.effect(
-      Dispatcher,
-      E.sync(() => {
-        const dispatcherMock = mock<Dispatcher['Type']>()
-
-        dispatcherMock.get.mockReturnValue(E.succeed({ status: 200, body: {} }))
-
-        return dispatcherMock
-      }),
-    )
-
-    const service = pipe(
-      ConnectionServiceLive,
-      L.provide(rpcClientTest),
-      L.provide(dispatcherTest),
-      L.provide(rpcConfigTest),
-    )
-
-    const layers = L.mergeAll(service, rpcClientTest, dispatcherTest)
-    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
-
-    return E.runPromise(effect)
-  })
-})

package/src/connection/connection.ts

@@ -1,51 +0,0 @@
-/**
- * Hits the rpc endpoint to warm up a lambda
- */
-import { Context, Effect as E, Layer, flow, pipe } from 'effect'
-
-import { Dispatcher } from '../rpc/client.js'
-import type { RpcConfig } from '../rpc/config.js'
-import * as RPC from '../rpc/connection.js'
-
-/* Service */
-
-export class ConnectionService extends Context.Tag('@services/ConnectionService')<
-  ConnectionService,
-  {
-    preConnect: () => E.Effect<void>
-  }
->() {}
-
-/* Effects */
-
-const hitPrincipal = pipe(
-  E.logInfo('Pre-connecting to Principal endpoint'),
-  E.zipRight(Dispatcher),
-  E.flatMap(dispatcher => dispatcher.get('/token/token?warm=true')),
-  E.asVoid,
-  E.catchAll(() => E.void),
-)
-
-const hitRpc = pipe(
-  E.logInfo('Pre-connecting to RPC endpoint'),
-  E.zipRight(RPC.ConnectionClient),
-  E.flatMap(rpcClient => rpcClient.preConnect()),
-  E.asVoid,
-)
-
-export const preConnect = () => pipe(E.all([hitPrincipal, hitRpc], { concurrency: 2 }), E.asVoid)
-
-/* Live */
-
-/* v8 ignore start */
-export const ConnectionServiceLive = Layer.effect(
-  ConnectionService,
-  E.gen(function* (_) {
-    const context = yield* _(E.context<RPC.ConnectionClient | Dispatcher | RpcConfig>())
-
-    return ConnectionService.of({
-      preConnect: flow(preConnect, E.provide(context)),
-    })
-  }),
-)
-/* v8 ignore stop */

package/src/effect.ts

@@ -1,280 +0,0 @@
-import { create, get as getCredential } from '@github/webauthn-json/browser-ponyfill'
-import { Effect as E, Layer as L, Layer, Schedule, pipe } from 'effect'
-import type { NoSuchElementException } from 'effect/Cause'
-
-import {
-  type BadRequest,
-  Duplicate,
-  InternalBrowserError,
-} from '@passlock/shared/dist/error/error.js'
-import type { Principal } from '@passlock/shared/dist/schema/principal.js'
-
-import {
-  AuthenticateServiceLive,
-  type AuthenticationErrors,
-  type AuthenticationRequest,
-  AuthenticationService,
-  GetCredential,
-} from './authentication/authenticate.js'
-import { Capabilities, capabilitiesLive } from './capabilities/capabilities.js'
-import { ConnectionService, ConnectionServiceLive } from './connection/connection.js'
-import {
-  EmailService,
-  EmailServiceLive,
-  URLQueryString,
-  type VerifyEmailErrors,
-  type VerifyRequest,
-} from './email/email.js'
-import {
-  CreateCredential,
-  type RegistrationErrors,
-  type RegistrationRequest,
-  RegistrationService,
-  RegistrationServiceLive,
-} from './registration/register.js'
-import { AuthenticationClientLive } from './rpc/passkey/authentication.js'
-import { DispatcherLive } from './rpc/client.js'
-import type { RpcConfig } from './rpc/config.js'
-import { RetrySchedule } from './rpc/config.js'
-import { ConnectionClientLive } from './rpc/connection.js'
-import { RegistrationClientLive } from './rpc/passkey/registration.js'
-import { SocialClientLive } from './rpc/social.js'
-import { UserClientLive } from './rpc/user.js'
-import {
-  type AuthenticateOidcReq,
-  type AuthenticationErrors as OidcAuthenticationErrors,
-  type RegistrationErrors as OidcRegistrationErrors,
-  type RegisterOidcReq,
-  SocialService,
-  SocialServiceLive,
-} from './social/social.js'
-import {
-  type AuthType,
-  BrowserStorage,
-  StorageService,
-  StorageServiceLive,
-  type StoredToken,
-} from './storage/storage.js'
-import {
-  type Email,
-  type ResendEmail,
-  type ResendEmailErrors,
-  UserService,
-  UserServiceLive,
-} from './user/user.js'
-
-/* Layers */
-
-const createCredentialLive = L.succeed(
-  CreateCredential,
-  CreateCredential.of({
-    createCredential: options =>
-      pipe(
-        E.tryPromise({
-          try: () => create(options),
-          catch: e => {
-            if (e instanceof Error && e.message.includes('excludeCredentials')) {
-              return new Duplicate({
-                message: 'Passkey already registered to this device or cloud account',
-              })
-            } else {
-              return new InternalBrowserError({
-                message: 'Unable to create credential',
-                detail: String(e),
-              })
-            }
-          },
-        }),
-        E.map(credential => credential.toJSON()),
-      ),
-  }),
-)
-
-const getCredentialLive = L.succeed(
-  GetCredential,
-  GetCredential.of({
-    getCredential: (options: CredentialRequestOptions) =>
-      pipe(
-        E.tryPromise({
-          try: () => getCredential(options),
-          catch: e =>
-            new InternalBrowserError({
-              message: 'Unable to get authentication credential',
-              detail: String(e),
-            }),
-        }),
-        E.map(credential => credential.toJSON()),
-      ),
-  }),
-)
-
-const schedule = Schedule.intersect(Schedule.recurs(3), Schedule.exponential('100 millis'))
-
-const retryScheduleLive = L.succeed(RetrySchedule, RetrySchedule.of({ schedule }))
-
-/* Services */
-const dispatcherLive = pipe(DispatcherLive, L.provide(retryScheduleLive))
-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(userClientLive))
-
-const registrationServiceLive = pipe(
-  RegistrationServiceLive,
-  L.provide(registerClientLive),
-  L.provide(userServiceLive),
-  L.provide(capabilitiesLive),
-  L.provide(createCredentialLive),
-  L.provide(storageServiceLive),
-)
-
-const authenticationServiceLive = pipe(
-  AuthenticateServiceLive,
-  L.provide(authenticateClientLive),
-  L.provide(capabilitiesLive),
-  L.provide(getCredentialLive),
-  L.provide(storageServiceLive),
-)
-
-const connectionServiceLive = pipe(
-  ConnectionServiceLive,
-  L.provide(connectClientLive),
-  L.provide(dispatcherLive),
-)
-
-const urlQueryStringLive = Layer.succeed(
-  URLQueryString,
-  URLQueryString.of(E.sync(() => globalThis.window.location.search)),
-)
-
-const emailServiceLive = pipe(
-  EmailServiceLive,
-  L.provide(urlQueryStringLive),
-  L.provide(userClientLive),
-  L.provide(capabilitiesLive),
-  L.provide(authenticationServiceLive),
-  L.provide(storageServiceLive),
-)
-
-const socialServiceLive = pipe(SocialServiceLive, L.provide(socialClientLive))
-
-export const allRequirements = Layer.mergeAll(
-  capabilitiesLive,
-  userServiceLive,
-  registrationServiceLive,
-  authenticationServiceLive,
-  connectionServiceLive,
-  emailServiceLive,
-  storageServiceLive,
-  socialServiceLive,
-)
-
-const browserStorageLive = Layer.effect(
-  BrowserStorage,
-  E.sync(() => BrowserStorage.of(globalThis.localStorage)),
-)
-
-export const preConnect = (): E.Effect<void, never, RpcConfig> =>
-  pipe(
-    ConnectionService,
-    E.flatMap(service => service.preConnect()),
-    E.provide(connectionServiceLive),
-  )
-
-export const isPasskeySupport: E.Effect<boolean> = pipe(
-  Capabilities,
-  E.flatMap(service => service.isPasskeySupport),
-  E.provide(capabilitiesLive),
-)
-
-export const isExistingUser = (request: Email): E.Effect<boolean, BadRequest, RpcConfig> =>
-  pipe(
-    UserService,
-    E.flatMap(service => service.isExistingUser(request)),
-    E.provide(userServiceLive),
-  )
-
-export const registerPasskey = (
-  request: RegistrationRequest,
-): E.Effect<Principal, RegistrationErrors, RpcConfig> =>
-  pipe(
-    RegistrationService,
-    E.flatMap(service => service.registerPasskey(request)),
-    E.provide(registrationServiceLive),
-    E.provide(browserStorageLive),
-  )
-
-export const authenticatePasskey = (
-  request: AuthenticationRequest,
-): E.Effect<Principal, AuthenticationErrors, RpcConfig> =>
-  pipe(
-    AuthenticationService,
-    E.flatMap(service => service.authenticatePasskey(request)),
-    E.provide(authenticationServiceLive),
-    E.provide(browserStorageLive),
-  )
-
-export const verifyEmailCode = (
-  request: VerifyRequest,
-): E.Effect<Principal, VerifyEmailErrors, RpcConfig> =>
-  pipe(
-    EmailService,
-    E.flatMap(service => service.verifyEmailCode(request)),
-    E.provide(emailServiceLive),
-    E.provide(browserStorageLive),
-  )
-
-export const verifyEmailLink: E.Effect<Principal, VerifyEmailErrors, RpcConfig> = pipe(
-  EmailService,
-  E.flatMap(service => service.verifyEmailLink()),
-  E.provide(emailServiceLive),
-  E.provide(browserStorageLive),
-)
-
-export const resendVerificationEmail = (
-  request: ResendEmail,
-): E.Effect<void, ResendEmailErrors, RpcConfig> =>
-  pipe(
-    UserService,
-    E.flatMap(service => service.resendVerificationEmail(request)),
-    E.provide(userServiceLive),
-    E.provide(browserStorageLive),
-  )
-
-export const getSessionToken = (
-  authType: AuthType,
-): E.Effect<StoredToken, NoSuchElementException> =>
-  pipe(
-    StorageService,
-    E.flatMap(service => service.getToken(authType)),
-    E.provide(storageServiceLive),
-    E.provide(browserStorageLive),
-  )
-
-export const clearExpiredTokens: E.Effect<void> = pipe(
-  StorageService,
-  E.flatMap(service => service.clearExpiredTokens),
-  E.provide(storageServiceLive),
-  E.provide(browserStorageLive),
-)
-
-export const registerOidc = (
-  request: RegisterOidcReq,
-): E.Effect<Principal, OidcRegistrationErrors, RpcConfig> =>
-  pipe(
-    SocialService,
-    E.flatMap(service => service.registerOidc(request)),
-    E.provide(socialServiceLive),
-  )
-
-export const authenticateOidc = (
-  request: AuthenticateOidcReq,
-): E.Effect<Principal, OidcAuthenticationErrors, RpcConfig> =>
-  pipe(
-    SocialService,
-    E.flatMap(service => service.authenticateOidc(request)),
-    E.provide(socialServiceLive),
-  )

package/src/email/email.fixture.ts

@@ -1,44 +0,0 @@
-import { Effect as E, Layer as L, Option as O } from 'effect'
-
-import { VerifyEmailRequest, VerifyEmailResponse } from '@passlock/shared/dist/rpc/user.js'
-
-import * as Fixtures from '../test/fixtures.js'
-import { AuthenticationService } from '../authentication/authenticate.js'
-import { UserClient } from '../rpc/user.js'
-import { URLQueryString } from './email.js'
-
-export const token = 'token'
-export const code = 'code'
-export const authType = 'passkey'
-export const expireAt = Date.now() + 10000
-
-export const locationSearchTest = L.succeed(
-  URLQueryString,
-  URLQueryString.of(E.succeed(`?code=${code}`)),
-)
-
-export const authenticationServiceTest = L.succeed(
-  AuthenticationService,
-  AuthenticationService.of({
-    authenticatePasskey: () => E.succeed(Fixtures.principal),
-  }),
-)
-
-export const rpcVerifyEmailReq = new VerifyEmailRequest({ token, code })
-
-export const rpcVerifyEmailRes = new VerifyEmailResponse({ principal: Fixtures.principal })
-
-export const rpcClientTest = L.succeed(
-  UserClient,
-  UserClient.of({
-    isExistingUser: () => E.succeed({ existingUser: true, detail: O.none() }),
-    verifyEmail: () => E.succeed(rpcVerifyEmailRes),
-    resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
-  }),
-)
-
-export const principal = Fixtures.principal
-
-export const storedToken = Fixtures.storedToken
-
-export const storageServiceTest = Fixtures.storageServiceTest

package/src/email/email.test.ts

@@ -1,186 +0,0 @@
-import { Effect as E, Layer as L, LogLevel, Logger, pipe } from 'effect'
-import { NoSuchElementException } from 'effect/Cause'
-import { describe, expect, test } from 'vitest'
-import { mock } from 'vitest-mock-extended'
-
-import * as Fixture from './email.fixture.js'
-import { AuthenticationService } from '../authentication/authenticate.js'
-import { UserClient } from '../rpc/user.js'
-import { StorageService } from '../storage/storage.js'
-import { EmailService, EmailServiceLive } from './email.js'
-
-describe('verifyEmailCode should', () => {
-  test('return a principal when the verification is successful', async () => {
-    const assertions = E.gen(function* (_) {
-      const service = yield* _(EmailService)
-      const result = yield* _(service.verifyEmailCode({ code: '123' }))
-
-      expect(result).toEqual(Fixture.principal)
-    })
-
-    const service = pipe(
-      EmailServiceLive,
-      L.provide(Fixture.locationSearchTest),
-      L.provide(Fixture.authenticationServiceTest),
-      L.provide(Fixture.storageServiceTest),
-      L.provide(Fixture.rpcClientTest),
-    )
-
-    const effect = pipe(E.provide(assertions, service), Logger.withMinimumLogLevel(LogLevel.None))
-
-    return E.runPromise(effect)
-  })
-
-  test('check for a token in local storage', async () => {
-    const assertions = E.gen(function* (_) {
-      const service = yield* _(EmailService)
-      yield* _(service.verifyEmailCode({ code: '123' }))
-
-      const storageService = yield* _(StorageService)
-      expect(storageService.getToken).toHaveBeenCalledWith('passkey')
-    })
-
-    const storageServiceTest = L.effect(
-      StorageService,
-      E.sync(() => {
-        const storageServiceMock = mock<StorageService['Type']>()
-
-        storageServiceMock.getToken.mockReturnValue(E.succeed(Fixture.storedToken))
-        storageServiceMock.clearToken.mockReturnValue(E.void)
-
-        return storageServiceMock
-      }),
-    )
-
-    const service = pipe(
-      EmailServiceLive,
-      L.provide(Fixture.locationSearchTest),
-      L.provide(Fixture.authenticationServiceTest),
-      L.provide(storageServiceTest),
-      L.provide(Fixture.rpcClientTest),
-    )
-
-    const layers = L.merge(service, storageServiceTest)
-    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
-
-    return E.runPromise(effect)
-  })
-
-  test('re-authenticate the user if no local token', async () => {
-    const assertions = E.gen(function* (_) {
-      const service = yield* _(EmailService)
-      yield* _(service.verifyEmailCode({ code: '123' }))
-
-      const authService = yield* _(AuthenticationService)
-      expect(authService.authenticatePasskey).toHaveBeenCalled()
-    })
-
-    const storageServiceTest = L.effect(
-      StorageService,
-      E.sync(() => {
-        const storageServiceMock = mock<StorageService['Type']>()
-
-        storageServiceMock.getToken.mockReturnValue(E.fail(new NoSuchElementException()))
-        storageServiceMock.clearToken.mockReturnValue(E.void)
-
-        return storageServiceMock
-      }),
-    )
-
-    const authServiceTest = L.effect(
-      AuthenticationService,
-      E.sync(() => {
-        const authServiceMock = mock<AuthenticationService['Type']>()
-
-        authServiceMock.authenticatePasskey.mockReturnValue(E.succeed(Fixture.principal))
-
-        return authServiceMock
-      }),
-    )
-
-    const service = pipe(
-      EmailServiceLive,
-      L.provide(Fixture.locationSearchTest),
-      L.provide(authServiceTest),
-      L.provide(storageServiceTest),
-      L.provide(Fixture.rpcClientTest),
-    )
-
-    const layers = L.mergeAll(service, storageServiceTest, authServiceTest)
-    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
-
-    return E.runPromise(effect)
-  })
-
-  test('call the backend', async () => {
-    const assertions = E.gen(function* (_) {
-      const service = yield* _(EmailService)
-      yield* _(service.verifyEmailCode({ code: Fixture.code }))
-
-      const rpcClient = yield* _(UserClient)
-      expect(rpcClient.verifyEmail).toHaveBeenCalledWith(Fixture.rpcVerifyEmailReq)
-    })
-
-    const rpcClientTest = L.effect(
-      UserClient,
-      E.sync(() => {
-        const rpcMock = mock<UserClient['Type']>()
-
-        rpcMock.verifyEmail.mockReturnValue(E.succeed(Fixture.rpcVerifyEmailRes))
-
-        return rpcMock
-      }),
-    )
-
-    const service = pipe(
-      EmailServiceLive,
-      L.provide(Fixture.locationSearchTest),
-      L.provide(Fixture.authenticationServiceTest),
-      L.provide(Fixture.storageServiceTest),
-      L.provide(rpcClientTest),
-    )
-
-    const layers = L.merge(service, rpcClientTest)
-    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
-
-    return E.runPromise(effect)
-  })
-})
-
-describe('verifyEmailLink should', () => {
-  test('extract the code from the current url', async () => {
-    const assertions = E.gen(function* (_) {
-      const service = yield* _(EmailService)
-      yield* _(service.verifyEmailLink())
-
-      // LocationSearch return ?code=code
-      // and we expect rpcClient to be called with code
-      const rpcClient = yield* _(UserClient)
-      expect(rpcClient.verifyEmail).toBeCalledWith(Fixture.rpcVerifyEmailReq)
-    })
-
-    const rpcClientTest = L.effect(
-      UserClient,
-      E.sync(() => {
-        const rpcMock = mock<UserClient['Type']>()
-
-        rpcMock.verifyEmail.mockReturnValue(E.succeed(Fixture.rpcVerifyEmailRes))
-
-        return rpcMock
-      }),
-    )
-
-    const service = pipe(
-      EmailServiceLive,
-      L.provide(Fixture.locationSearchTest),
-      L.provide(Fixture.storageServiceTest),
-      L.provide(Fixture.authenticationServiceTest),
-      L.provide(rpcClientTest),
-    )
-
-    const layers = L.merge(service, rpcClientTest)
-    const effect = pipe(E.provide(assertions, layers), Logger.withMinimumLogLevel(LogLevel.None))
-
-    return E.runPromise(effect)
-  })
-})