@passlock/client 0.9.0

package/src/storage/storage.ts

@@ -0,0 +1,165 @@
+/**
+ * Wrapper around local storage that allows us to store
+ * authentication tokens in local storage for a short period.
+ */
+import type { Principal } from '@passlock/shared/dist/schema/schema'
+import { Context, Effect as E, Layer, Option as O, flow, pipe } from 'effect'
+import type { NoSuchElementException } from 'effect/Cause'
+
+/* Requests */
+
+export type AuthType = 'email' | 'passkey'
+
+export type StoredToken = {
+  token: string
+  authType: AuthType
+  expireAt: number
+}
+
+/* Service */
+
+export type StorageService = {
+  storeToken: (principal: Principal) => E.Effect<void>
+  getToken: (authType: AuthType) => E.Effect<StoredToken, NoSuchElementException>
+  clearToken: (authType: AuthType) => E.Effect<void>
+  clearExpiredToken: (authType: AuthType) => E.Effect<void>
+  clearExpiredTokens: E.Effect<void>
+}
+
+/* Utilities */
+
+export const StorageService = Context.GenericTag<StorageService>('@services/StorageService')
+
+// inject window.localStorage to make testing easier
+export const Storage = Context.GenericTag<Storage>('@services/Storage')
+
+export const buildKey = (authType: AuthType) => `passlock:${authType}:token`
+
+// principal => token:expireAt
+export const compressToken = (principal: Principal): string => {
+  const expireAt = principal.expireAt.getTime()
+  const token = principal.token
+  return `${token}:${expireAt}`
+}
+
+// token:expireAt => { authType, token, expireAt }
+export const expandToken =
+  (authType: AuthType) =>
+  (s: string): O.Option<StoredToken> => {
+    const tokens = s.split(':')
+    if (tokens.length !== 2) return O.none()
+
+    const [token, expireAtString] = tokens
+    const parse = O.liftThrowable(Number.parseInt)
+    const expireAt = parse(expireAtString)
+
+    return O.map(expireAt, expireAt => ({ authType, token, expireAt }))
+  }
+
+/* Effects */
+
+/**
+ * Store compressed token in local storage
+ * @param principal
+ * @returns
+ */
+export const storeToken = (principal: Principal): E.Effect<void, never, Storage> => {
+  return E.gen(function* (_) {
+    const localStorage = yield* _(Storage)
+
+    const storeEffect = E.try(() => {
+      const compressed = compressToken(principal)
+      const key = buildKey(principal.authStatement.authType)
+      localStorage.setItem(key, compressed)
+    }).pipe(E.orElse(() => E.unit)) // We dont care if it fails
+
+    return yield* _(storeEffect)
+  })
+}
+
+/**
+ * Get stored token from local storage
+ * @param authType
+ * @returns
+ */
+export const getToken = (
+  authType: AuthType,
+): E.Effect<StoredToken, NoSuchElementException, Storage> => {
+  return E.gen(function* (_) {
+    const localStorage = yield* _(Storage)
+
+    const getEffect = pipe(
+      O.some(buildKey(authType)),
+      O.flatMap(key => pipe(localStorage.getItem(key), O.fromNullable)),
+      O.flatMap(expandToken(authType)),
+      O.filter(({ expireAt: expireAt }) => expireAt > Date.now()),
+    )
+
+    return yield* _(getEffect)
+  })
+}
+
+/**
+ * Remove token from local storage
+ * @param authType
+ * @returns
+ */
+export const clearToken = (authType: AuthType): E.Effect<void, never, Storage> => {
+  return E.gen(function* (_) {
+    const localStorage = yield* _(Storage)
+    localStorage.removeItem(buildKey(authType))
+  })
+}
+
+/**
+ * Only clear if now > token.expireAt
+ * @param authType
+ * @param defer
+ * @returns
+ */
+export const clearExpiredToken = (authType: AuthType): E.Effect<void, never, Storage> => {
+  const key = buildKey(authType)
+
+  const effect = E.gen(function* (_) {
+    const storage = yield* _(Storage)
+    const item = yield* _(O.fromNullable(storage.getItem(key)))
+    const token = yield* _(expandToken(authType)(item))
+
+    if (token.expireAt < Date.now()) {
+      storage.removeItem(key)
+    }
+  })
+
+  // we don't care if it fails
+  return pipe(
+    effect,
+    E.match({
+      onSuccess: () => E.unit,
+      onFailure: () => E.unit,
+    }),
+  )
+}
+
+export const clearExpiredTokens: E.Effect<void, never, Storage> = E.all([
+  clearExpiredToken('passkey'),
+  clearExpiredToken('email'),
+])
+
+/* Live */
+
+/* v8 ignore start */
+export const StorageServiceLive = Layer.effect(
+  StorageService,
+  E.gen(function* (_) {
+    const context = yield* _(E.context<Storage>())
+
+    return {
+      storeToken: flow(storeToken, E.provide(context)),
+      getToken: flow(getToken, E.provide(context)),
+      clearToken: flow(clearToken, E.provide(context)),
+      clearExpiredToken: flow(clearExpiredToken, E.provide(context)),
+      clearExpiredTokens: pipe(clearExpiredTokens, E.provide(context)),
+    }
+  }),
+)
+/* v8 ignore stop */

package/src/test/fixtures.ts

@@ -0,0 +1,51 @@
+import type { Principal } from '@passlock/shared/dist/schema/schema'
+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'
+export const authType = 'passkey'
+export const expireAt = Date.now() + 10000
+
+export const principal: Principal = {
+  token: 'token',
+  subject: {
+    id: '1',
+    email: 'john.doe@gmail.com',
+    firstName: 'john',
+    lastName: 'doe',
+    emailVerified: false,
+  },
+  authStatement: {
+    authType: 'email',
+    userVerified: false,
+    authTimestamp: new Date(0),
+  },
+  expireAt: new Date(0),
+}
+
+export const capabilitiesTest = L.succeed(
+  Capabilities,
+  Capabilities.of({
+    passkeySupport: E.unit,
+    isPasskeySupport: E.succeed(true),
+    autofillSupport: E.unit,
+    isAutofillSupport: E.succeed(true),
+  }),
+)
+
+export const storedToken: StoredToken = { token, authType, expireAt }
+
+export const storageServiceTest = L.succeed(
+  StorageService,
+  StorageService.of({
+    storeToken: () => E.unit,
+    getToken: () => E.succeed(storedToken),
+    clearToken: () => E.unit,
+    clearExpiredToken: () => E.unit,
+    clearExpiredTokens: E.unit,
+  }),
+)

package/src/user/user.fixture.ts

@@ -0,0 +1,23 @@
+import { BadRequest } from '@passlock/shared/dist/error/error'
+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(
+  RpcClient,
+  RpcClient.of({
+    preConnect: () => E.succeed({ warmed: true }),
+    isExistingUser: () => E.succeed({ existingUser: true }),
+    verifyEmail: () => E.succeed({ verified: true }),
+    getRegistrationOptions: () => E.fail(new BadRequest({ message: 'Not implemeneted' })),
+    verifyRegistrationCredential: () => E.fail(new BadRequest({ message: 'Not implemeneted' })),
+    getAuthenticationOptions: () => E.fail(new BadRequest({ message: 'Not implemeneted' })),
+    verifyAuthenticationCredential: () => E.fail(new BadRequest({ message: 'Not implemeneted' })),
+  }),
+)
+
+export const isRegisteredReq = new IsExistingUserReq({ email })
+export const isRegisteredRes = new IsExistingUserRes({ existingUser: false })

package/src/user/user.test.ts

@@ -0,0 +1,53 @@
+import { type RouterOps, RpcClient } from '@passlock/shared/dist/rpc/rpc'
+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'
+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* (_) {
+      const service = yield* _(UserService)
+      const result = yield* _(service.isExistingUser({ email: Fixture.email }))
+
+      expect(result).toBe(true)
+    })
+
+    const service = pipe(UserServiceLive, L.provide(Fixture.rpcClientTest))
+
+    const effect = pipe(E.provide(assertions, service), Logger.withMinimumLogLevel(LogLevel.None))
+
+    return E.runPromise(effect)
+  })
+
+  test('send the email to the backend', async () => {
+    const assertions = E.gen(function* (_) {
+      const service = yield* _(UserService)
+      const result = yield* _(service.isExistingUser({ email: Fixture.email }))
+
+      expect(result).toBe(false)
+      const rpcClient = yield* _(RpcClient)
+      expect(rpcClient.isExistingUser).toBeCalledWith(Fixture.isRegisteredReq)
+    })
+
+    const rpcClientTest = Layer.effect(
+      RpcClient,
+      E.sync(() => {
+        const rpcMock = mock<RouterOps>()
+
+        rpcMock.isExistingUser.mockReturnValue(E.succeed(Fixture.isRegisteredRes))
+
+        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)
+  })
+})

package/src/user/user.ts

@@ -0,0 +1,50 @@
+/**
+ * Check for an existing user
+ */
+import type { BadRequest } from '@passlock/shared/dist/error/error'
+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 }
+
+/* Service */
+
+export type UserService = {
+  isExistingUser: (email: Email) => E.Effect<boolean, BadRequest>
+}
+
+export const UserService = Context.GenericTag<UserService>('@services/UserService')
+
+/* Effects */
+
+type Dependencies = RpcClient
+
+export const isExistingUser = (request: Email): E.Effect<boolean, BadRequest, Dependencies> => {
+  return E.gen(function* (_) {
+    yield* _(E.logInfo('Checking registration status'))
+    const rpcClient = yield* _(RpcClient)
+
+    yield* _(E.logDebug('Making RPC request'))
+    const { existingUser } = yield* _(rpcClient.isExistingUser(new IsExistingUserReq(request)))
+
+    return existingUser
+  })
+}
+
+/* Live */
+
+/* v8 ignore start */
+export const UserServiceLive = Layer.effect(
+  UserService,
+  E.gen(function* (_) {
+    const context = yield* _(E.context<RpcClient>())
+    return UserService.of({
+      isExistingUser: flow(isExistingUser, E.provide(context)),
+    })
+  }),
+)
+/* v8 ignore stop */