@passlock/client 0.9.32 → 2.0.0-beta.2

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.v1.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,32 +0,0 @@
-import * as S from '@effect/schema/Schema'
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  CONNECT_ENDPOINT,
-  ConnectResponse,
-  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(ConnectResponse, S.Never, dispatcher)
-
-    return {
-      preConnect: () => preConnectResolver(CONNECT_ENDPOINT),
-    }
-  }),
-)
-
-export { ConnectResponse } from '@passlock/shared/dist/rpc/connection.js'

package/src/rpc/passkey/authentication.ts

@@ -1,52 +0,0 @@
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  type AuthenticationService,
-  OPTIONS_ENDPOINT,
-  OptionsErrors,
-  OptionsRequest,
-  OptionsResponse,
-  VERIFICATION_ENDPOINT,
-  VerificationErrors,
-  VerificationRequest,
-  VerificationResponse,
-} from '@passlock/shared/dist/rpc/passkey/authentication.js'
-
-import { Dispatcher, makePostRequest } from '../client.js'
-
-/* Client */
-
-export class AuthenticationClient extends Context.Tag('@passkey/authentication/client')<
-  AuthenticationClient,
-  AuthenticationService
->() { }
-
-export const AuthenticationClientLive = Layer.effect(
-  AuthenticationClient,
-  E.gen(function* (_) {
-    const dispatcher = yield* _(Dispatcher)
-
-    const optionsResolver = makePostRequest(OptionsRequest, OptionsResponse, OptionsErrors, dispatcher)
-
-    const verifyResolver = makePostRequest(
-      VerificationRequest,
-      VerificationResponse,
-      VerificationErrors,
-      dispatcher,
-    )
-
-    return {
-      getAuthenticationOptions: req => optionsResolver(OPTIONS_ENDPOINT, req),
-      verifyAuthenticationCredential: req => verifyResolver(VERIFICATION_ENDPOINT, req),
-    }
-  }),
-)
-
-export {
-  OptionsErrors,
-  OptionsRequest,
-  OptionsResponse,
-  VerificationErrors,
-  VerificationRequest,
-  VerificationResponse,
-} from '@passlock/shared/dist/rpc/passkey/authentication.js'

package/src/rpc/passkey/registration.ts

@@ -1,52 +0,0 @@
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  OptionsErrors,
-  OptionsRequest,
-  OptionsResponse,
-  type RegistrationService,
-  VerificationErrors,
-  VerificationRequest,
-  VerificationResponse,
-  OPTIONS_ENDPOINT,
-  VERIFICATION_ENDPOINT
-} from '@passlock/shared/dist/rpc/passkey/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(OptionsRequest, OptionsResponse, OptionsErrors, dispatcher)
-
-    const verifyResolver = makePostRequest(
-      VerificationRequest,
-      VerificationResponse,
-      VerificationErrors,
-      dispatcher,
-    )
-
-    return {
-      getRegistrationOptions: req => optionsResolver(OPTIONS_ENDPOINT, req),
-      verifyRegistrationCredential: req => verifyResolver(VERIFICATION_ENDPOINT, req),
-    }
-  }),
-)
-
-export {
-  OptionsErrors,
-  OptionsRequest,
-  OptionsResponse,
-  VerificationErrors,
-  VerificationRequest,
-  VerificationResponse,
-} from '@passlock/shared/dist/rpc/passkey/registration.js'

package/src/rpc/social.ts

@@ -1,55 +0,0 @@
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  OIDCRegistrationRequest,
-  OIDCRegistrationErrors,
-  OIDCAuthenticationRequest,
-  OIDCAuthenticationErrors,
-  OIDC_REGISTRATION_ENDPOINT,
-  OIDC_AUTHENTICATION_ENDPOINT,
-  PrincipalResponse,
-  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(
-      OIDCRegistrationRequest,
-      PrincipalResponse,
-      OIDCRegistrationErrors,
-      dispatcher,
-    )
-
-    const authenticateResolver = makePostRequest(
-      OIDCAuthenticationRequest,
-      PrincipalResponse,
-      OIDCAuthenticationErrors,
-      dispatcher,
-    )
-
-    return {
-      oidcRegistration: req => registerResolver(OIDC_REGISTRATION_ENDPOINT, req),
-      oidcAuthentication: req => authenticateResolver(OIDC_AUTHENTICATION_ENDPOINT, req),
-    }
-  }),
-)
-
-export {
-  OIDCRegistrationRequest,
-  OIDCRegistrationErrors,
-  OIDCAuthenticationRequest,
-  OIDCAuthenticationErrors,
-  PrincipalResponse,
-} from '@passlock/shared/dist/rpc/social.js'

package/src/rpc/user.ts

@@ -1,68 +0,0 @@
-import * as S from '@effect/schema/Schema'
-import { Context, Effect as E, Layer } from 'effect'
-
-import {
-  IsExistingUserRequest,
-  IsExistingUserResponse,
-  RESEND_EMAIL_ENDPOINT,
-  ResendEmailErrors,
-  ResendEmailRequest,
-  ResendEmailResponse,
-  USER_STATUS_ENDPOINT,
-  type UserService,
-  VERIFY_EMAIL_ENDPOINT,
-  VerifyEmailErrors,
-  VerifyEmailRequest,
-  VerifyEmailResponse,
-} 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(
-      IsExistingUserRequest,
-      IsExistingUserResponse,
-      S.Never,
-      dispatcher,
-    )
-
-    const verifyEmailResolver = makePostRequest(
-      VerifyEmailRequest,
-      VerifyEmailResponse,
-      VerifyEmailErrors,
-      dispatcher,
-    )
-
-    const resendEmailResolver = makePostRequest(
-      ResendEmailRequest,
-      ResendEmailResponse,
-      ResendEmailErrors,
-      dispatcher,
-    )
-
-    return {
-      isExistingUser: req => isExistingUserResolver(USER_STATUS_ENDPOINT, req),
-      verifyEmail: req => verifyEmailResolver(VERIFY_EMAIL_ENDPOINT, req),
-      resendVerificationEmail: req => resendEmailResolver(RESEND_EMAIL_ENDPOINT, req),
-    }
-  }),
-)
-
-export {
-  IsExistingUserRequest,
-  IsExistingUserResponse,
-  ResendEmailErrors,
-  ResendEmailRequest,
-  ResendEmailResponse,
-  VerifyEmailErrors,
-  VerifyEmailRequest,
-  VerifyEmailResponse,
-} from '@passlock/shared/dist/rpc/user.js'

package/src/social/social.fixture.ts

@@ -1,44 +0,0 @@
-import { Effect as E, Layer as L, Option as O } from 'effect'
-
-import * as Fixtures from '../test/fixtures.js'
-import { SocialClient } from '../rpc/social.js'
-import type { AuthenticateOidcReq } from './social.js'
-import { OIDCAuthenticationRequest, OIDCRegistrationRequest, PrincipalResponse } from '@passlock/shared/dist/rpc/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 OIDCRegistrationRequest({
-  provider: 'google',
-  idToken: 'google-token',
-  nonce: 'nonce',
-  givenName: O.some('john'),
-  familyName: O.some('doe'),
-})
-
-export const authOidcReq: AuthenticateOidcReq = new OIDCAuthenticationRequest({
-  provider: 'google',
-  idToken: 'google-token',
-  nonce: 'nonce',
-})
-
-export const rpcRegisterRes = new PrincipalResponse({ principal: Fixtures.principal })
-
-export const rpcAuthenticateRes = new PrincipalResponse({ principal: Fixtures.principal })
-
-export const rpcClientTest = L.succeed(
-  SocialClient,
-  SocialClient.of({
-    oidcRegistration: () => E.fail(Fixtures.notImplemented),
-    oidcAuthentication: () => 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.oidcRegistration.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.oidcRegistration).toHaveBeenCalledWith(Fixture.registerOidcReq)
-    })
-
-    const rpcClientTest = L.effect(
-      SocialClient,
-      E.sync(() => {
-        const rpcMock = mock<SocialClient['Type']>()
-
-        rpcMock.oidcRegistration.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.oidcRegistration.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.oidcAuthentication.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.oidcAuthentication).toHaveBeenCalledWith(Fixture.authOidcReq)
-    })
-
-    const rpcClientTest = L.effect(
-      SocialClient,
-      E.sync(() => {
-        const rpcMock = mock<SocialClient['Type']>()
-
-        rpcMock.oidcAuthentication.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.oidcAuthentication.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)
-  })
-})