@passlock/client 0.9.0 → 0.9.2

package/src/connection/connection.ts

@@ -2,7 +2,8 @@
  * Hits the rpc endpoint to warm up a lambda
  */
 import { PreConnectReq } from '@passlock/shared/dist/rpc/connection'
-import { NetworkService, RpcClient, RpcConfig } from '@passlock/shared/dist/rpc/rpc'
+import type { RpcConfig } from '@passlock/shared/dist/rpc/rpc';
+import { Dispatcher, RpcClient } from '@passlock/shared/dist/rpc/rpc'
 import { Context, Effect as E, Layer, flow, pipe } from 'effect'
 
 /* Service */
@@ -17,23 +18,20 @@ export const ConnectionService = Context.GenericTag<ConnectionService>('@service
 
 const hitPrincipal = pipe(
   E.logInfo('Pre-connecting to Principal endpoint'),
-  E.zipRight(NetworkService),
-  E.flatMap(networkService => networkService.get('/token/token?warm=true')),
+  E.zipRight(Dispatcher),
+  E.flatMap(dispatcher => dispatcher.get('/token/token?warm=true')),
   E.asUnit,
-  E.catchAll(() => E.unit)
+  E.catchAll(() => E.unit),
 )
 
 const hitRpc = pipe(
   E.logInfo('Pre-connecting to RPC endpoint'),
   E.zipRight(RpcClient),
   E.flatMap(rpcClient => rpcClient.preConnect(new PreConnectReq({}))),
-  E.asUnit
+  E.asUnit,
 )
 
-export const preConnect = () => pipe(
-  E.all([hitPrincipal, hitRpc], { concurrency: 2 }),
-  E.asUnit
-)
+export const preConnect = () => pipe(E.all([hitPrincipal, hitRpc], { concurrency: 2 }), E.asUnit)
 
 /* Live */
 
@@ -41,7 +39,7 @@ export const preConnect = () => pipe(
 export const ConnectionServiceLive = Layer.effect(
   ConnectionService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<RpcClient | NetworkService | RpcConfig>())
+    const context = yield* _(E.context<RpcClient | Dispatcher | RpcConfig>())
 
     return ConnectionService.of({
       preConnect: flow(preConnect, E.provide(context)),

package/src/effect.ts

@@ -25,7 +25,7 @@ import {
 } from '@passlock/shared/dist/error/error'
 
 import {
-  NetworkServiceLive,
+  DispatcherLive,
   RetrySchedule,
   RpcClientLive,
   RpcConfig,
@@ -110,9 +110,9 @@ const schedule = Schedule.intersect(Schedule.recurs(3), Schedule.exponential('10
 
 const retryScheduleLive = L.succeed(RetrySchedule, RetrySchedule.of({ schedule }))
 
-const networkServiceLive = pipe(NetworkServiceLive, L.provide(retryScheduleLive))
+const dispatcherLive = pipe(DispatcherLive, L.provide(retryScheduleLive))
 
-const rpcClientLive = pipe(RpcClientLive, L.provide(networkServiceLive))
+const rpcClientLive = pipe(RpcClientLive, L.provide(dispatcherLive))
 
 const storageServiceLive = StorageServiceLive
 
@@ -136,9 +136,9 @@ const authenticationServiceLive = pipe(
 )
 
 const connectionServiceLive = pipe(
-  ConnectionServiceLive, 
-  L.provide(rpcClientLive), 
-  L.provide(networkServiceLive)
+  ConnectionServiceLive,
+  L.provide(rpcClientLive),
+  L.provide(dispatcherLive),
 )
 
 const locationSearchLive = Layer.succeed(

package/src/email/email.fixture.ts

@@ -1,4 +1,3 @@
-
 import { BadRequest } from '@passlock/shared/dist/error/error'
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc'
 import { VerifyEmailReq, VerifyEmailRes } from '@passlock/shared/dist/rpc/user'
@@ -7,7 +6,6 @@ import { LocationSearch } from './email'
 import { AuthenticationService } from '../authentication/authenticate'
 import * as Fixtures from '../test/fixtures'
 
-
 export const token = 'token'
 export const code = 'code'
 export const authType = 'passkey'

package/src/email/email.test.ts

@@ -8,7 +8,6 @@ import * as Fixture from './email.fixture'
 import { AuthenticationService } from '../authentication/authenticate'
 import { StorageService } from '../storage/storage'
 
-
 describe('verifyEmailCode should', () => {
   test('return true when the verification is successful', async () => {
     const assertions = E.gen(function* (_) {

package/src/email/email.ts

@@ -3,13 +3,12 @@
  */
 import { BadRequest } from '@passlock/shared/dist/error/error'
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc'
-import type { VerifyEmailErrors as RpcErrors} from '@passlock/shared/dist/rpc/user';
+import type { VerifyEmailErrors as RpcErrors } from '@passlock/shared/dist/rpc/user'
 import { VerifyEmailReq } from '@passlock/shared/dist/rpc/user'
 import { Context, Effect as E, Layer, Option as O, flow, identity, pipe } from 'effect'
 import { type AuthenticationErrors, AuthenticationService } from '../authentication/authenticate'
 import { StorageService } from '../storage/storage'
 
-
 /* Requests */
 
 export type VerifyRequest = {

package/src/event/event.test.ts

@@ -2,7 +2,6 @@ import { Effect } from 'effect'
 import { afterEach, describe, expect, test, vi } from 'vitest'
 import { DebugMessage, fireEvent, isPasslockEvent } from './event'
 
-
 describe('fireEvent', () => {
   afterEach(() => {
     vi.restoreAllMocks()

package/src/event/event.ts

@@ -4,7 +4,6 @@
 import { InternalBrowserError } from '@passlock/shared/dist/error/error'
 import { Effect } from 'effect'
 
-
 export const DebugMessage = 'PasslogDebugMessage'
 
 export const fireEvent = (message: string) => {

package/src/index.ts

@@ -7,6 +7,7 @@ import type {
   NotSupported,
   Unauthorized,
 } from '@passlock/shared/dist/error/error'
+import { ErrorCode } from '@passlock/shared/dist/error/error'
 import { RpcConfig } from '@passlock/shared/dist/rpc/rpc'
 import { Effect as E, Layer as L, Layer, Option, Runtime, Scope, pipe } from 'effect'
 import { type AuthenticationRequest, AuthenticationService } from './authentication/authenticate'
@@ -17,7 +18,7 @@ import { EmailService, type VerifyRequest } from './email/email'
 import { type RegistrationRequest, RegistrationService } from './registration/register'
 import { type AuthType, Storage, StorageService } from './storage/storage'
 import { type Email, UserService } from './user/user'
-import { ErrorCode } from '@passlock/shared/dist/error/error'
+
 export { ErrorCode } from '@passlock/shared/dist/error/error'
 
 export class PasslockError extends Error {
@@ -85,12 +86,16 @@ const transformErrors = <A, R>(
 
     Sequential: errors => {
       console.error(errors)
-      return E.succeed(new PasslockError('Sorry, something went wrong', ErrorCode.InternalServerError))
+      return E.succeed(
+        new PasslockError('Sorry, something went wrong', ErrorCode.InternalServerError),
+      )
     },
 
     Parallel: errors => {
       console.error(errors)
-      return E.succeed(new PasslockError('Sorry, something went wrong', ErrorCode.InternalServerError))
+      return E.succeed(
+        new PasslockError('Sorry, something went wrong', ErrorCode.InternalServerError),
+      )
     },
   })
 
@@ -106,10 +111,12 @@ type Requirements =
   | StorageService
   | Capabilities
 
-export class Passlock {
+export type Options = { signal?: AbortSignal }
+
+export class PasslockUnsafe {
   private readonly runtime: Runtime.Runtime<Requirements>
 
-  constructor(config: { tenancyId: string; clientId: string; endpoint: string }) {
+  constructor(config: { tenancyId: string; clientId: string; endpoint?: string }) {
     const rpcConfig = Layer.succeed(RpcConfig, RpcConfig.of(config))
     const storage = Layer.succeed(Storage, Storage.of(globalThis.localStorage))
     const allLayers = pipe(allRequirements, L.provide(rpcConfig), L.provide(storage))
@@ -119,19 +126,20 @@ export class Passlock {
 
   private readonly runPromise = <A, R extends Requirements>(
     effect: E.Effect<A, PasslockErrors, R>,
+    options: Options | undefined = undefined
   ) => {
     return pipe(
       transformErrors(effect),
       E.flatMap(result => (PasslockError.isError(result) ? E.fail(result) : E.succeed(result))),
-      effect => Runtime.runPromise(this.runtime)(effect),
+      effect => Runtime.runPromise(this.runtime)(effect, options),
     )
   }
 
-  preConnect = () =>
+  preConnect = (options?: Options) =>
     pipe(
       ConnectionService,
       E.flatMap(service => service.preConnect()),
-      effect => Runtime.runPromise(this.runtime)(effect),
+      effect => Runtime.runPromise(this.runtime)(effect, options),
     )
 
   isPasskeySupport = () =>
@@ -141,39 +149,39 @@ export class Passlock {
       effect => Runtime.runPromise(this.runtime)(effect),
     )
 
-  isExistingPasskey = (email: Email) =>
+  isExistingPasskey = (email: Email, options?: Options) =>
     pipe(
       UserService,
       E.flatMap(service => service.isExistingUser(email)),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
-  registerPasskey = (request: RegistrationRequest) =>
+  registerPasskey = (request: RegistrationRequest, options?: Options) =>
     pipe(
       RegistrationService,
       E.flatMap(service => service.registerPasskey(request)),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
-  authenticatePasskey = (request: AuthenticationRequest) =>
+  authenticatePasskey = (request: AuthenticationRequest, options?: Options) =>
     pipe(
       AuthenticationService,
       E.flatMap(service => service.authenticatePasskey(request)),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
-  verifyEmailCode = (request: VerifyRequest) =>
+  verifyEmailCode = (request: VerifyRequest, options?: Options) =>
     pipe(
       EmailService,
       E.flatMap(service => service.verifyEmailCode(request)),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
-  verifyEmailLink = () =>
+  verifyEmailLink = (options?: Options) =>
     pipe(
       EmailService,
       E.flatMap(service => service.verifyEmailLink()),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
   getSessionToken = (authType: AuthType) =>
@@ -181,21 +189,21 @@ export class Passlock {
       StorageService,
       E.flatMap(service => service.getToken(authType).pipe(effect => E.option(effect))),
       E.map(Option.getOrUndefined),
-      effect => Runtime.runSync(this.runtime)(effect)
+      effect => Runtime.runSync(this.runtime)(effect),
     )
 
   clearExpiredTokens = () =>
     pipe(
       StorageService,
       E.flatMap(service => service.clearExpiredTokens),
-      effect => Runtime.runPromise(this.runtime)(effect)
+      effect => Runtime.runPromise(this.runtime)(effect),
     )
 }
 
-export class PasslockSafe {
+export class Passlock {
   private readonly runtime: Runtime.Runtime<Requirements>
 
-  constructor(config: { tenancyId: string; clientId: string; endpoint: string }) {
+  constructor(config: { tenancyId: string; clientId: string; endpoint?: string }) {
     const rpcConfig = Layer.succeed(RpcConfig, RpcConfig.of(config))
     const storage = Layer.succeed(Storage, Storage.of(globalThis.localStorage))
     const allLayers = pipe(allRequirements, L.provide(rpcConfig), L.provide(storage))
@@ -205,10 +213,21 @@ export class PasslockSafe {
 
   private readonly runPromise = <A, R extends Requirements>(
     effect: E.Effect<A, PasslockErrors, R>,
+    options: Options | undefined = undefined
   ) => {
-    return pipe(transformErrors(effect), effect => Runtime.runPromise(this.runtime)(effect))
+    return pipe(
+      transformErrors(effect), 
+      effect => Runtime.runPromise(this.runtime)(effect, options)
+    )
   }
 
+  preConnect = (options?: Options) =>
+    pipe(
+      ConnectionService,
+      E.flatMap(service => service.preConnect()),
+      effect => this.runPromise(effect, options),
+    )
+
   isPasskeySupport = () =>
     pipe(
       Capabilities,
@@ -216,46 +235,39 @@ export class PasslockSafe {
       effect => Runtime.runPromise(this.runtime)(effect),
     )
 
-  preConnect = () =>
-    pipe(
-      ConnectionService,
-      E.flatMap(service => service.preConnect()),
-      effect => this.runPromise(effect),
-    )
-
-  isExistingPasskey = (email: Email) =>
+  isExistingPasskey = (email: Email, options?: Options) =>
     pipe(
       UserService,
       E.flatMap(service => service.isExistingUser(email)),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
-  registerPasskey = (request: RegistrationRequest) =>
+  registerPasskey = (request: RegistrationRequest, options?: Options) =>
     pipe(
       RegistrationService,
       E.flatMap(service => service.registerPasskey(request)),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
-  authenticatePasskey = (request: AuthenticationRequest = {}) =>
+  authenticatePasskey = (request: AuthenticationRequest = {}, options?: Options) =>
     pipe(
       AuthenticationService,
       E.flatMap(service => service.authenticatePasskey(request)),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
-  verifyEmailCode = (request: VerifyRequest) =>
+  verifyEmailCode = (request: VerifyRequest, options?: Options) =>
     pipe(
       EmailService,
       E.flatMap(service => service.verifyEmailCode(request)),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
-  verifyEmailLink = () =>
+  verifyEmailLink = (options?: Options) =>
     pipe(
       EmailService,
       E.flatMap(service => service.verifyEmailLink()),
-      effect => this.runPromise(effect),
+      effect => this.runPromise(effect, options),
     )
 
   getSessionToken = (authType: AuthType) =>
@@ -263,13 +275,13 @@ export class PasslockSafe {
       StorageService,
       E.flatMap(service => service.getToken(authType).pipe(effect => E.option(effect))),
       E.map(maybeToken => Option.getOrUndefined(maybeToken)),
-      effect => Runtime.runSync(this.runtime)(effect)
+      effect => Runtime.runSync(this.runtime)(effect),
     )
 
   clearExpiredTokens = () =>
     pipe(
       StorageService,
       E.flatMap(service => service.clearExpiredTokens),
-      effect => Runtime.runPromise(this.runtime)(effect)
+      effect => Runtime.runPromise(this.runtime)(effect),
     )
 }

package/src/registration/register.fixture.ts

@@ -12,7 +12,6 @@ import { CreateCredential, type RegistrationRequest } from './register'
 import * as Fixtures from '../test/fixtures'
 import { UserService } from '../user/user'
 
-
 export const session = 'session'
 export const token = 'token'
 export const code = 'code'

package/src/registration/register.test.ts

@@ -7,7 +7,6 @@ import { CreateCredential, RegistrationService, RegistrationServiceLive } from '
 import * as Fixture from './register.fixture'
 import { UserService } from '../user/user'
 
-
 describe('register should', () => {
   test('return a valid credential', async () => {
     const assertions = E.gen(function* (_) {

package/src/registration/register.ts

@@ -5,15 +5,10 @@ import {
   type CredentialCreationOptionsJSON,
   parseCreationOptionsFromJSON,
 } from '@github/webauthn-json/browser-ponyfill'
-import type { NotSupported } from '@passlock/shared/dist/error/error';
+import type { NotSupported } from '@passlock/shared/dist/error/error'
 import { Duplicate, InternalBrowserError } from '@passlock/shared/dist/error/error'
-import type {
-  OptionsErrors,
-  VerificationErrors} from '@passlock/shared/dist/rpc/registration';
-import {
-  OptionsReq,
-  VerificationReq,
-} from '@passlock/shared/dist/rpc/registration'
+import type { OptionsErrors, VerificationErrors } from '@passlock/shared/dist/rpc/registration'
+import { OptionsReq, VerificationReq } from '@passlock/shared/dist/rpc/registration'
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc'
 import type {
   Principal,

package/src/test/fixtures.ts

@@ -3,7 +3,6 @@ import { Effect as E, Layer as L } from 'effect'
 import { Capabilities } from '../capabilities/capabilities'
 import { StorageService, type StoredToken } from '../storage/storage'
 
-
 export const session = 'session'
 export const token = 'token'
 export const code = 'code'

package/src/user/user.fixture.ts

@@ -3,7 +3,6 @@ import { RpcClient } from '@passlock/shared/dist/rpc/rpc'
 import { IsExistingUserReq, IsExistingUserRes } from '@passlock/shared/dist/rpc/user'
 import { Effect as E, Layer as L } from 'effect'
 
-
 export const email = 'jdoe@gmail.com'
 
 export const rpcClientTest = L.succeed(

package/src/user/user.test.ts

@@ -5,7 +5,6 @@ import { mock } from 'vitest-mock-extended'
 import { UserService, UserServiceLive } from './user'
 import * as Fixture from './user.fixture'
 
-
 describe('isExistingUser should', () => {
   test('return true when the user already has a passkey', async () => {
     const assertions = E.gen(function* (_) {

package/src/user/user.ts

@@ -6,7 +6,6 @@ import { RpcClient } from '@passlock/shared/dist/rpc/rpc'
 import { IsExistingUserReq } from '@passlock/shared/dist/rpc/user'
 import { Context, Effect as E, Layer, flow } from 'effect'
 
-
 /* Requests */
 
 export type Email = { email: string }