@passlock/client 0.9.30 → 2.0.0-beta.1

package/src/rpc/client.ts

@@ -1,174 +0,0 @@
-import * as S from '@effect/schema/Schema'
-import { Context, Effect as E, Layer, pipe } from 'effect'
-
-import { NetworkError } from '@passlock/shared/dist/error/error.js'
-
-import { PASSLOCK_CLIENT_VERSION } from '../version.js'
-import { RetrySchedule, RpcConfig } from './config.js'
-
-export type DispatcherResponse = {
-  status: number
-  body: object
-}
-
-/** To send the JSON to the backend */
-export class Dispatcher extends Context.Tag('@rpc/Dispatcher')<
-  Dispatcher,
-  {
-    get: (path: string) => E.Effect<DispatcherResponse, NetworkError>
-    post: (path: string, body: string) => E.Effect<DispatcherResponse, NetworkError>
-  }
->() {}
-
-/** Fires off client requests using fetch */
-/** TODO: Write tests */
-/** TODO: Evaluate platform/http client (if now stable) */
-export const DispatcherLive = Layer.effect(
-  Dispatcher,
-  E.gen(function* (_) {
-    const { schedule } = yield* _(RetrySchedule)
-    const { tenancyId, clientId, endpoint: maybeEndpoint } = yield* _(RpcConfig)
-
-    const parseJson = (res: Response, url: string) =>
-      E.tryPromise({
-        try: () => res.json() as Promise<unknown>,
-        catch: e =>
-          new NetworkError({
-            message: 'Unable to extract json response from ' + url,
-            detail: String(e),
-          }),
-      })
-
-    // 400 errors are reflected in the RPC response error channel
-    // so in network terms they're still "ok"
-    const assertNo500s = (res: Response, url: string) => {
-      if (res.status >= 500) {
-        return E.fail(
-          new NetworkError({
-            message: 'Received 500 response code from ' + url,
-          }),
-        )
-      } else return E.void
-    }
-
-    const parseJsonObject = (json: unknown) => {
-      return typeof json === 'object' && json !== null
-        ? E.succeed(json)
-        : E.fail(
-            new NetworkError({
-              message: `Expected JSON object to be returned from RPC endpoint, actual ${typeof json}`,
-            }),
-          )
-    }
-
-    const buildUrl = (_path: string) => {
-      const endpoint = maybeEndpoint || 'https://api.passlock.dev'
-      // drop leading /
-      const path = _path.replace(/^\//, '')
-      return `${endpoint}/${tenancyId}/${path}`
-    }
-
-    return {
-      get: (path: string) => {
-        const effect = E.gen(function* (_) {
-          const headers = {
-            'Accept': 'application/json',
-            'X-CLIENT-ID': clientId,
-            'X-PASSLOCK-CLIENT-VERSION': PASSLOCK_CLIENT_VERSION,
-          }
-
-          const url = buildUrl(path)
-
-          const res = yield* _(
-            E.tryPromise({
-              try: () => fetch(url, { method: 'GET', headers }),
-              catch: e =>
-                new NetworkError({ message: 'Unable to fetch from ' + url, detail: String(e) }),
-            }),
-          )
-
-          const json = yield* _(parseJson(res, url))
-          yield* _(assertNo500s(res, url))
-          const jsonObject = yield* _(parseJsonObject(json))
-
-          return { status: res.status, body: jsonObject }
-        })
-
-        return E.retry(effect, { schedule })
-      },
-
-      post: (_path: string, body: string) => {
-        const effect = E.gen(function* (_) {
-          const headers = {
-            'Content-Type': 'application/json',
-            'Accept': 'application/json',
-            'X-CLIENT-ID': clientId,
-            'X-PASSLOCK-CLIENT-VERSION': PASSLOCK_CLIENT_VERSION,
-          }
-
-          // drop leading /
-          const url = buildUrl(_path)
-
-          const res = yield* _(
-            E.tryPromise({
-              try: () => fetch(url, { method: 'POST', headers, body }),
-              catch: e =>
-                new NetworkError({ message: 'Unable to fetch from ' + url, detail: String(e) }),
-            }),
-          )
-
-          const json = yield* _(parseJson(res, url))
-          yield* _(assertNo500s(res, url))
-          const jsonObject = yield* _(parseJsonObject(json))
-
-          return { status: res.status, body: jsonObject }
-        })
-
-        return E.retry(effect, { schedule })
-      },
-    }
-  }),
-)
-
-export const makeGetRequest =
-  <Res, ResEnc, Err, ErrEnc>(
-    responseSchema: S.Schema<Res, ResEnc, never>,
-    errorSchema: S.Schema<Err, ErrEnc, never>,
-    dispatcher: Dispatcher['Type'],
-  ) =>
-  (path: string) =>
-    pipe(
-      dispatcher.get(path),
-      E.flatMap(res => {
-        if (res.status === 200) return S.decodeUnknown(responseSchema)(res.body)
-        return pipe(
-          S.decodeUnknown(errorSchema)(res.body),
-          E.flatMap(err => E.fail(err)),
-        )
-      }),
-      E.catchTag('ParseError', e => E.die(e)),
-      E.catchTag('NetworkError', e => E.die(e)),
-    )
-
-export const makePostRequest =
-  <Req, ReqEnc, Res, ResEnc, Err, ErrEnc>(
-    requestSchema: S.Schema<Req, ReqEnc, never>,
-    responseSchema: S.Schema<Res, ResEnc, never>,
-    errorSchema: S.Schema<Err, ErrEnc, never>,
-    dispatcher: Dispatcher['Type'],
-  ) =>
-  (path: string, request: Req) => {
-    return pipe(
-      S.encode(requestSchema)(request),
-      E.flatMap(request => dispatcher.post(path, JSON.stringify(request))),
-      E.flatMap(res => {
-        if (res.status === 200) return S.decodeUnknown(responseSchema)(res.body)
-        return pipe(
-          S.decodeUnknown(errorSchema)(res.body),
-          E.flatMap(err => E.fail(err)),
-        )
-      }),
-      E.catchTag('ParseError', e => E.die(e)),
-      E.catchTag('NetworkError', e => E.die(e)),
-    )
-  }

package/src/rpc/config.ts

@@ -1,18 +0,0 @@
-import type { Schedule } from 'effect'
-import { Context } from 'effect'
-
-export class RpcConfig extends Context.Tag('@rpc/RpcConfig')<
-  RpcConfig,
-  {
-    endpoint?: string
-    tenancyId: string
-    clientId: string
-  }
->() {}
-
-export class RetrySchedule extends Context.Tag('@rpc/RetrySchedule')<
-  RetrySchedule,
-  {
-    schedule: Schedule.Schedule<unknown>
-  }
->() {}

package/src/rpc/connection.ts

@@ -1,30 +0,0 @@
-import * as S from '@effect/schema/Schema'
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  CONNECT_ENDPOINT,
-  ConnectRes,
-  type ConnectionService,
-} from '@passlock/shared/dist/rpc/connection.js'
-
-import { Dispatcher, makeGetRequest } from './client.js'
-
-/* Client */
-
-export class ConnectionClient extends Context.Tag('@connection/client')<
-  ConnectionClient,
-  ConnectionService
->() {}
-
-export const ConnectionClientLive = Layer.effect(
-  ConnectionClient,
-  E.gen(function* (_) {
-    const dispatcher = yield* _(Dispatcher)
-
-    const preConnectResolver = makeGetRequest(ConnectRes, S.Never, dispatcher)
-
-    return {
-      preConnect: () => preConnectResolver(CONNECT_ENDPOINT),
-    }
-  }),
-)

package/src/rpc/registration.ts

@@ -1,41 +0,0 @@
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  OptionsErrors,
-  OptionsReq,
-  OptionsRes,
-  type RegistrationService,
-  VerificationErrors,
-  VerificationReq,
-  VerificationRes,
-} from '@passlock/shared/dist/rpc/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(OptionsReq, OptionsRes, OptionsErrors, dispatcher)
-
-    const verifyResolver = makePostRequest(
-      VerificationReq,
-      VerificationRes,
-      VerificationErrors,
-      dispatcher,
-    )
-
-    return {
-      getRegistrationOptions: req => optionsResolver('/passkey/register/options', req),
-      verifyRegistrationCredential: req => verifyResolver('/passkey/register/verify', req),
-    }
-  }),
-)

package/src/rpc/social.ts

@@ -1,45 +0,0 @@
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  AuthOidcErrors,
-  AuthOidcReq,
-  PrincipalRes,
-  RegisterOidcErrors,
-  RegisterOidcReq,
-  type SocialService,
-} from '@passlock/shared/dist/rpc/social.js'
-
-import { Dispatcher, makePostRequest } from './client.js'
-
-/* Client */
-
-export const OIDC_REGISTER_ENDPOINT = '/social/oidc/register'
-export const OIDC_AUTH_ENDPOINT = '/social/oidc/auth'
-
-export class SocialClient extends Context.Tag('@social/client')<SocialClient, SocialService>() {}
-
-export const SocialClientLive = Layer.effect(
-  SocialClient,
-  E.gen(function* (_) {
-    const dispatcher = yield* _(Dispatcher)
-
-    const registerResolver = makePostRequest(
-      RegisterOidcReq,
-      PrincipalRes,
-      RegisterOidcErrors,
-      dispatcher,
-    )
-
-    const authenticateResolver = makePostRequest(
-      AuthOidcReq,
-      PrincipalRes,
-      AuthOidcErrors,
-      dispatcher,
-    )
-
-    return {
-      registerOidc: req => registerResolver(OIDC_REGISTER_ENDPOINT, req),
-      authenticateOidc: req => authenticateResolver(OIDC_AUTH_ENDPOINT, req),
-    }
-  }),
-)

package/src/rpc/user.ts

@@ -1,57 +0,0 @@
-import * as S from '@effect/schema/Schema'
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  IsExistingUserReq,
-  IsExistingUserRes,
-  RESEND_EMAIL_ENDPOINT,
-  ResendEmailErrors,
-  ResendEmailReq,
-  ResendEmailRes,
-  USER_STATUS_ENDPOINT,
-  type UserService,
-  VERIFY_EMAIL_ENDPOINT,
-  VerifyEmailErrors,
-  VerifyEmailReq,
-  VerifyEmailRes,
-} from '@passlock/shared/dist/rpc/user.js'
-
-import { Dispatcher, makePostRequest } from './client.js'
-
-/* Client */
-
-export class UserClient extends Context.Tag('@user/client')<UserClient, UserService>() {}
-
-export const UserClientLive = Layer.effect(
-  UserClient,
-  E.gen(function* (_) {
-    const dispatcher = yield* _(Dispatcher)
-
-    const isExistingUserResolver = makePostRequest(
-      IsExistingUserReq,
-      IsExistingUserRes,
-      S.Never,
-      dispatcher,
-    )
-
-    const verifyEmailResolver = makePostRequest(
-      VerifyEmailReq,
-      VerifyEmailRes,
-      VerifyEmailErrors,
-      dispatcher,
-    )
-
-    const resendEmailResolver = makePostRequest(
-      ResendEmailReq,
-      ResendEmailRes,
-      ResendEmailErrors,
-      dispatcher,
-    )
-
-    return {
-      isExistingUser: req => isExistingUserResolver(USER_STATUS_ENDPOINT, req),
-      verifyEmail: req => verifyEmailResolver(VERIFY_EMAIL_ENDPOINT, req),
-      resendVerificationEmail: req => resendEmailResolver(RESEND_EMAIL_ENDPOINT, req),
-    }
-  }),
-)

package/src/social/social.fixture.ts

@@ -1,45 +0,0 @@
-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'
-
-export const session = 'session'
-export const token = 'token'
-export const code = 'code'
-export const authType = 'passkey'
-export const expireAt = Date.now() + 10000
-
-export const registerOidcReq = new Shared.RegisterOidcReq({
-  provider: 'google',
-  idToken: 'google-token',
-  nonce: 'nonce',
-  givenName: O.some('john'),
-  familyName: O.some('doe'),
-})
-
-export const authOidcReq: AuthenticateOidcReq = new Shared.AuthOidcReq({
-  provider: 'google',
-  idToken: 'google-token',
-  nonce: 'nonce',
-})
-
-export const rpcRegisterRes = new Shared.PrincipalRes({ principal: Fixtures.principal })
-
-export const rpcAuthenticateRes = new Shared.PrincipalRes({ principal: Fixtures.principal })
-
-export const rpcClientTest = L.succeed(
-  SocialClient,
-  SocialClient.of({
-    registerOidc: () => E.fail(Fixtures.notImplemented),
-    authenticateOidc: () => 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

@@ -1,179 +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 { Duplicate, NotFound } from '@passlock/shared/dist/error/error.js'
-
-import * as Fixture from './social.fixture.js'
-import { SocialClient } from '../rpc/social.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.registerOidcReq))
-      expect(result).toEqual(Fixture.principal)
-    })
-
-    const rpcClientTest = L.effect(
-      SocialClient,
-      E.sync(() => {
-        const rpcMock = mock<SocialClient['Type']>()
-
-        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.registerOidcReq))
-
-      const rpcClient = yield* _(SocialClient)
-      expect(rpcClient.registerOidc).toHaveBeenCalledWith(Fixture.registerOidcReq)
-    })
-
-    const rpcClientTest = L.effect(
-      SocialClient,
-      E.sync(() => {
-        const rpcMock = mock<SocialClient['Type']>()
-
-        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.registerOidcReq), E.flip)
-
-      expect(defect).toBeInstanceOf(Duplicate)
-    })
-
-    const rpcClientTest = L.effect(
-      SocialClient,
-      E.sync(() => {
-        const rpcMock = mock<SocialClient['Type']>()
-
-        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.authOidcReq))
-      expect(result).toEqual(Fixture.principal)
-    })
-
-    const rpcClientTest = L.effect(
-      SocialClient,
-      E.sync(() => {
-        const rpcMock = mock<SocialClient['Type']>()
-
-        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.authOidcReq))
-
-      const rpcClient = yield* _(SocialClient)
-      expect(rpcClient.authenticateOidc).toHaveBeenCalledWith(Fixture.authOidcReq)
-    })
-
-    const rpcClientTest = L.effect(
-      SocialClient,
-      E.sync(() => {
-        const rpcMock = mock<SocialClient['Type']>()
-
-        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.authOidcReq), E.flip)
-
-      expect(defect).toBeInstanceOf(NotFound)
-    })
-
-    const rpcClientTest = L.effect(
-      SocialClient,
-      E.sync(() => {
-        const rpcMock = mock<SocialClient['Type']>()
-
-        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

@@ -1,82 +0,0 @@
-/**
- * Passkey authentication effects
- */
-import { Context, Effect as E, Layer, flow } from 'effect'
-
-import * as RPC from '@passlock/shared/dist/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 AuthenticateOidcReq = RPC.AuthOidcReq
-
-/* Errors */
-
-export type RegistrationErrors = NotSupported | BadRequest | RPC.RegisterOidcErrors
-
-export type AuthenticationErrors = NotSupported | BadRequest | RPC.AuthOidcErrors
-
-/* Service */
-
-export class SocialService extends Context.Tag('@services/SocialService')<
-  SocialService,
-  {
-    registerOidc: (req: RegisterOidcReq) => E.Effect<Principal, RegistrationErrors>
-    authenticateOidc: (req: AuthenticateOidcReq) => E.Effect<Principal, AuthenticationErrors>
-  }
->() {}
-
-/* Effects */
-
-type Dependencies = SocialClient
-
-export const registerOidc = (
-  request: RegisterOidcReq,
-): E.Effect<Principal, RegistrationErrors, Dependencies> => {
-  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))
-
-    return principal
-  })
-}
-
-export const authenticateOidc = (
-  request: AuthenticateOidcReq,
-): E.Effect<Principal, AuthenticationErrors, Dependencies> => {
-  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))
-
-    return principal
-  })
-}
-
-/* Live */
-
-/* v8 ignore start */
-export const SocialServiceLive = Layer.effect(
-  SocialService,
-  E.gen(function* (_) {
-    const context = yield* _(E.context<SocialClient>())
-
-    return SocialService.of({
-      registerOidc: flow(registerOidc, E.provide(context)),
-      authenticateOidc: flow(authenticateOidc, E.provide(context)),
-    })
-  }),
-)
-/* v8 ignore stop */

package/src/storage/storage.fixture.ts

@@ -1,16 +0,0 @@
-import { Effect as E, Layer, pipe } from 'effect'
-import { mock } from 'vitest-mock-extended'
-
-import { BrowserStorage, StorageServiceLive } from './storage.js'
-
-const storageTest = Layer.effect(
-  BrowserStorage,
-  E.sync(() => mock<Storage>()),
-)
-
-export const testLayers = (storage: Layer.Layer<BrowserStorage> = storageTest) => {
-  const storageService = pipe(StorageServiceLive, Layer.provide(storage))
-  return Layer.merge(storage, storageService)
-}
-
-export { principal } from '../test/fixtures.js'