@passlock/client 0.9.5 → 0.9.7

package/src/authentication/authenticate.ts

@@ -6,11 +6,10 @@ import {
   parseRequestOptionsFromJSON,
 } from '@github/webauthn-json/browser-ponyfill'
 import {
-  type BadRequest,
   InternalBrowserError,
   type NotSupported,
 } from '@passlock/shared/dist/error/error.js'
-import type { VerificationErrors } from '@passlock/shared/dist/rpc/authentication.js'
+import type { OptionsErrors, VerificationErrors } from '@passlock/shared/dist/rpc/authentication.js'
 import { OptionsReq, VerificationReq } from '@passlock/shared/dist/rpc/authentication.js'
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
 import type {
@@ -24,23 +23,27 @@ import { StorageService } from '../storage/storage.js'
 
 /* Requests */
 
-export type AuthenticationRequest = { userVerification?: UserVerification }
+export type AuthenticationRequest = { 
+  email?: string, 
+  userVerification?: UserVerification 
+}
 
 /* Errors */
 
-export type AuthenticationErrors = NotSupported | BadRequest | VerificationErrors
+export type AuthenticationErrors = NotSupported | OptionsErrors | VerificationErrors
 
 /* Dependencies */
 
 export type GetCredential = (
-  options: CredentialRequestOptions,
+  request: CredentialRequestOptions,
 ) => E.Effect<AuthenticationCredential, InternalBrowserError>
+
 export const GetCredential = Context.GenericTag<GetCredential>('@services/Get')
 
 /* Service */
 
 export type AuthenticationService = {
-  authenticatePasskey: (data: AuthenticationRequest) => E.Effect<Principal, AuthenticationErrors>
+  authenticatePasskey: (request: AuthenticationRequest) => E.Effect<Principal, AuthenticationErrors>
 }
 
 export const AuthenticationService = Context.GenericTag<AuthenticationService>(
@@ -49,12 +52,12 @@ export const AuthenticationService = Context.GenericTag<AuthenticationService>(
 
 /* Utilities */
 
-const fetchOptions = (req: OptionsReq) => {
+const fetchOptions = (request: OptionsReq) => {
   return E.gen(function* (_) {
     yield* _(E.logDebug('Making request'))
 
     const rpcClient = yield* _(RpcClient)
-    const { publicKey, session } = yield* _(rpcClient.getAuthenticationOptions(req))
+    const { publicKey, session } = yield* _(rpcClient.getAuthenticationOptions(request))
 
     yield* _(E.logDebug('Converting Passlock options to CredentialRequestOptions'))
     const options = yield* _(toRequestOptions({ publicKey }))
@@ -63,9 +66,9 @@ const fetchOptions = (req: OptionsReq) => {
   })
 }
 
-const toRequestOptions = (options: CredentialRequestOptionsJSON) => {
+const toRequestOptions = (request: CredentialRequestOptionsJSON) => {
   return pipe(
-    E.try(() => parseRequestOptionsFromJSON(options)),
+    E.try(() => parseRequestOptionsFromJSON(request)),
     E.mapError(
       error =>
         new InternalBrowserError({
@@ -76,12 +79,12 @@ const toRequestOptions = (options: CredentialRequestOptionsJSON) => {
   )
 }
 
-const verifyCredential = (req: VerificationReq) => {
+const verifyCredential = (request: VerificationReq) => {
   return E.gen(function* (_) {
     yield* _(E.logDebug('Making request'))
 
     const rpcClient = yield* _(RpcClient)
-    const { principal } = yield* _(rpcClient.verifyAuthenticationCredential(req))
+    const { principal } = yield* _(rpcClient.verifyAuthenticationCredential(request))
 
     return principal
   })

package/src/capabilities/capabilities.ts

@@ -19,7 +19,7 @@ export const Capabilities = Context.GenericTag<Capabilities>('@services/Capabili
 
 const hasWebAuthn = E.suspend(() =>
   typeof window.PublicKeyCredential === 'function'
-    ? E.unit
+    ? E.void
     : new NotSupported({ message: 'WebAuthn API is not supported on this device' }),
 )
 
@@ -29,7 +29,7 @@ const hasPlatformAuth = pipe(
     identity,
     () => new NotSupported({ message: 'No platform authenticator available on this device' }),
   ),
-  E.asUnit,
+  E.asVoid,
 )
 
 const hasConditionalUi = pipe(
@@ -42,7 +42,7 @@ const hasConditionalUi = pipe(
     identity,
     () => new NotSupported({ message: 'Conditional mediation not available on this device' }),
   ),
-  E.asUnit,
+  E.asVoid,
 )
 
 export const passkeySupport = pipe(

package/src/connection/connection.fixture.ts

@@ -1,24 +1,27 @@
-import { BadRequest } from '@passlock/shared/dist/error/error.js'
 import { PreConnectReq, PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
 import { Effect as E, Layer as L } from 'effect'
+import * as Fixtures from '../test/fixtures.js'
+
+export const preConnectReq = new PreConnectReq({})
+export const preConnectRes = new PreConnectRes({ warmed: true })
 
 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' })),
+    preConnect: () => E.succeed(preConnectRes),
+    isExistingUser: () => E.fail(Fixtures.notImplemented),
+    verifyEmail: () => E.fail(Fixtures.notImplemented),
+    getRegistrationOptions: () => E.fail(Fixtures.notImplemented),
+    verifyRegistrationCredential: () => E.fail(Fixtures.notImplemented),
+    getAuthenticationOptions: () => E.fail(Fixtures.notImplemented),
+    verifyAuthenticationCredential: () => E.fail(Fixtures.notImplemented),
+    registerOidc: () => E.fail(Fixtures.notImplemented),
+    authenticateOidc: () => E.fail(Fixtures.notImplemented),
+    resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
   }),
 )
 
-export const preConnectReq = new PreConnectReq({})
-export const preConnectRes = new PreConnectRes({ warmed: true })
-
 export const rpcConfig = {
   endpoint: 'https://example.com',
   tenancyId: 'tenancyId',

package/src/connection/connection.ts

@@ -20,18 +20,18 @@ const hitPrincipal = pipe(
   E.logInfo('Pre-connecting to Principal endpoint'),
   E.zipRight(Dispatcher),
   E.flatMap(dispatcher => dispatcher.get('/token/token?warm=true')),
-  E.asUnit,
-  E.catchAll(() => E.unit),
+  E.asVoid,
+  E.catchAll(() => E.void),
 )
 
 const hitRpc = pipe(
   E.logInfo('Pre-connecting to RPC endpoint'),
   E.zipRight(RpcClient),
   E.flatMap(rpcClient => rpcClient.preConnect(new PreConnectReq({}))),
-  E.asUnit,
+  E.asVoid,
 )
 
-export const preConnect = () => pipe(E.all([hitPrincipal, hitRpc], { concurrency: 2 }), E.asUnit)
+export const preConnect = () => pipe(E.all([hitPrincipal, hitRpc], { concurrency: 2 }), E.asVoid)
 
 /* Live */
 

package/src/effect.ts

@@ -1,18 +1,5 @@
 import { create, get as getCredential } from '@github/webauthn-json/browser-ponyfill'
 
-export type {
-  BadRequest,
-  Disabled,
-  Duplicate,
-  Forbidden,
-  InternalBrowserError,
-  NotFound,
-  NotSupported,
-  Unauthorized,
-} from '@passlock/shared/dist/error/error.js'
-
-export type { Principal } from '@passlock/shared/dist/schema/schema.js'
-
 import {
   type BadRequest,
   type Disabled,
@@ -32,6 +19,7 @@ import {
 } from '@passlock/shared/dist/rpc/rpc.js'
 
 import type { Principal } from '@passlock/shared/dist/schema/schema.js'
+
 import { Context, Effect as E, Layer as L, Layer, Schedule, pipe } from 'effect'
 import type { NoSuchElementException } from 'effect/Cause'
 
@@ -44,7 +32,7 @@ import {
 
 import { capabilitiesLive } from './capabilities/capabilities.js'
 import { ConnectionService, ConnectionServiceLive } from './connection/connection.js'
-import { EmailService, EmailServiceLive, LocationSearch, type VerifyRequest } from './email/email.js'
+import { EmailService, EmailServiceLive, URLQueryString, type VerifyRequest } from './email/email.js'
 
 import {
   CreateCredential,
@@ -62,10 +50,11 @@ import {
 } from './storage/storage.js'
 
 import { type Email, UserService, UserServiceLive } from './user/user.js'
+import { SocialService, SocialServiceLive, type OidcRequest } from './social/social.js'
 
 /* Layers */
 
-const createLive = L.succeed(
+const createCredentialLive = L.succeed(
   CreateCredential,
   CreateCredential.of((options: CredentialCreationOptions) =>
     pipe(
@@ -74,7 +63,7 @@ const createLive = L.succeed(
         catch: e => {
           if (e instanceof Error && e.message.includes('excludeCredentials')) {
             return new Duplicate({
-              message: 'Passkey already registered on this device or cloud account',
+              message: 'Passkey already registered to this device or cloud account',
             })
           } else {
             return new InternalBrowserError({
@@ -84,12 +73,12 @@ const createLive = L.succeed(
           }
         },
       }),
-      E.map(credential => credential.toJSON()),
+      E.map(credential => credential.toJSON())
     ),
   ),
 )
 
-const getLive = L.succeed(
+const getCredentialLive = L.succeed(
   GetCredential,
   GetCredential.of((options: CredentialRequestOptions) =>
     pipe(
@@ -123,7 +112,7 @@ const registrationServiceLive = pipe(
   L.provide(rpcClientLive),
   L.provide(userServiceLive),
   L.provide(capabilitiesLive),
-  L.provide(createLive),
+  L.provide(createCredentialLive),
   L.provide(storageServiceLive),
 )
 
@@ -131,7 +120,7 @@ const authenticationServiceLive = pipe(
   AuthenticateServiceLive,
   L.provide(rpcClientLive),
   L.provide(capabilitiesLive),
-  L.provide(getLive),
+  L.provide(getCredentialLive),
   L.provide(storageServiceLive),
 )
 
@@ -141,20 +130,25 @@ const connectionServiceLive = pipe(
   L.provide(dispatcherLive),
 )
 
-const locationSearchLive = Layer.succeed(
-  LocationSearch,
-  LocationSearch.of(E.sync(() => globalThis.window.location.search)),
+const urlQueryStringLive = Layer.succeed(
+  URLQueryString,
+  URLQueryString.of(E.sync(() => globalThis.window.location.search)),
 )
 
 const emailServiceLive = pipe(
   EmailServiceLive,
-  L.provide(locationSearchLive),
+  L.provide(urlQueryStringLive),
   L.provide(rpcClientLive),
   L.provide(capabilitiesLive),
   L.provide(authenticationServiceLive),
   L.provide(storageServiceLive),
 )
 
+const socialServiceLive = pipe(
+  SocialServiceLive,
+  L.provide(rpcClientLive),
+)
+
 export const allRequirements = Layer.mergeAll(
   capabilitiesLive,
   userServiceLive,
@@ -163,6 +157,7 @@ export const allRequirements = Layer.mergeAll(
   connectionServiceLive,
   emailServiceLive,
   storageServiceLive,
+  socialServiceLive,
 )
 
 export class Config extends Context.Tag('Config')<
@@ -243,7 +238,7 @@ export type VerifyEmailErrors =
 
 export const verifyEmailCode = (
   request: VerifyRequest,
-): E.Effect<boolean, VerifyEmailErrors, Config> =>
+): E.Effect<Principal, VerifyEmailErrors, Config> =>
   pipe(
     EmailService,
     E.flatMap(service => service.verifyEmailCode(request)),
@@ -251,7 +246,7 @@ export const verifyEmailCode = (
     exchangeConfig,
   )
 
-export const verifyEmailLink = (): E.Effect<boolean, VerifyEmailErrors, Config> =>
+export const verifyEmailLink = (): E.Effect<Principal, VerifyEmailErrors, Config> =>
   pipe(
     EmailService,
     E.flatMap(service => service.verifyEmailLink()),
@@ -276,3 +271,10 @@ export const clearExpiredTokens = (): E.Effect<void> =>
     E.provide(storageServiceLive),
     E.provide(storageLive),
   )
+
+export const authenticateOIDC = (request: OidcRequest) => 
+  pipe(
+    SocialService,
+    E.flatMap(service => service.registerOidc(request)),
+    E.provide(socialServiceLive)
+  )

package/src/email/email.fixture.ts

@@ -1,8 +1,7 @@
-import { BadRequest } from '@passlock/shared/dist/error/error.js'
 import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
 import { VerifyEmailReq, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
 import { Effect as E, Layer as L } from 'effect'
-import { LocationSearch } from './email.js'
+import { URLQueryString } from './email.js'
 import { AuthenticationService } from '../authentication/authenticate.js'
 import * as Fixtures from '../test/fixtures.js'
 
@@ -12,8 +11,8 @@ export const authType = 'passkey'
 export const expireAt = Date.now() + 10000
 
 export const locationSearchTest = L.succeed(
-  LocationSearch,
-  LocationSearch.of(E.succeed(`?code=${code}`)),
+  URLQueryString,
+  URLQueryString.of(E.succeed(`?code=${code}`)),
 )
 
 export const authenticationServiceTest = L.succeed(
@@ -23,23 +22,26 @@ export const authenticationServiceTest = L.succeed(
   }),
 )
 
+export const verifyEmailReq = new VerifyEmailReq({ token, code })
+
+export const verifyEmailRes = new VerifyEmailRes({ principal: Fixtures.principal })
+
 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' })),
+    verifyEmail: () => E.succeed(verifyEmailRes),
+    getRegistrationOptions: () => E.fail(Fixtures.notImplemented),
+    verifyRegistrationCredential: () => E.fail(Fixtures.notImplemented),
+    getAuthenticationOptions: () => E.fail(Fixtures.notImplemented),
+    verifyAuthenticationCredential: () => E.fail(Fixtures.notImplemented),
+    registerOidc: () => E.fail(Fixtures.notImplemented),
+    authenticateOidc: () => E.fail(Fixtures.notImplemented),
+    resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
   }),
 )
 
-export const verifyEmailReq = new VerifyEmailReq({ token, code })
-
-export const verifyEmailRes = new VerifyEmailRes({ verified: true })
-
 export const principal = Fixtures.principal
 
 export const storedToken = Fixtures.storedToken

package/src/email/email.test.ts

@@ -9,12 +9,12 @@ import { AuthenticationService } from '../authentication/authenticate.js'
 import { StorageService } from '../storage/storage.js'
 
 describe('verifyEmailCode should', () => {
-  test('return true when the verification is successful', async () => {
+  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).toBe(true)
+      expect(result).toEqual(Fixture.principal)
     })
 
     const service = pipe(
@@ -45,7 +45,7 @@ describe('verifyEmailCode should', () => {
         const storageServiceMock = mock<StorageService>()
 
         storageServiceMock.getToken.mockReturnValue(E.succeed(Fixture.storedToken))
-        storageServiceMock.clearToken.mockReturnValue(E.unit)
+        storageServiceMock.clearToken.mockReturnValue(E.void)
 
         return storageServiceMock
       }),
@@ -80,7 +80,7 @@ describe('verifyEmailCode should', () => {
         const storageServiceMock = mock<StorageService>()
 
         storageServiceMock.getToken.mockReturnValue(E.fail(new NoSuchElementException()))
-        storageServiceMock.clearToken.mockReturnValue(E.unit)
+        storageServiceMock.clearToken.mockReturnValue(E.void)
 
         return storageServiceMock
       }),

package/src/email/email.ts

@@ -8,6 +8,7 @@ import { VerifyEmailReq } from '@passlock/shared/dist/rpc/user.js'
 import { Context, Effect as E, Layer, Option as O, flow, identity, pipe } from 'effect'
 import { type AuthenticationErrors, AuthenticationService } from '../authentication/authenticate.js'
 import { StorageService } from '../storage/storage.js'
+import type { Principal } from '@passlock/shared/dist/schema/schema.js'
 
 /* Requests */
 
@@ -21,16 +22,16 @@ export type VerifyEmailErrors = RpcErrors | AuthenticationErrors
 
 /* Dependencies */
 
-export class LocationSearch extends Context.Tag('LocationSearch')<
-  LocationSearch,
+export class URLQueryString extends Context.Tag('URLQueryString')<
+  URLQueryString,
   E.Effect<string>
 >() {}
 
 /* Service */
 
 export type EmailService = {
-  verifyEmailCode: (request: VerifyRequest) => E.Effect<boolean, VerifyEmailErrors>
-  verifyEmailLink: () => E.Effect<boolean, VerifyEmailErrors>
+  verifyEmailCode: (request: VerifyRequest) => E.Effect<Principal, VerifyEmailErrors>
+  verifyEmailLink: () => E.Effect<Principal, VerifyEmailErrors>
 }
 
 export const EmailService = Context.GenericTag<EmailService>('@services/EmailService')
@@ -78,7 +79,7 @@ const getToken = () => {
  */
 export const extractCodeFromHref = () => {
   return pipe(
-    LocationSearch,
+    URLQueryString,
     E.flatMap(identity),
     E.map(search => new URLSearchParams(search)),
     E.flatMap(params => O.fromNullable(params.get('code'))),
@@ -89,23 +90,23 @@ export const extractCodeFromHref = () => {
 
 /**
  * Verify the mailbox using the given code
- * @param verificationRequest
+ * @param request
  * @returns
  */
 export const verifyEmail = (
-  verificationRequest: VerifyRequest,
-): E.Effect<boolean, VerifyEmailErrors, Dependencies> => {
+  request: VerifyRequest,
+): E.Effect<Principal, VerifyEmailErrors, Dependencies> => {
   return E.gen(function* (_) {
     // Re-authenticate the user if required
     const { token } = yield* _(getToken())
 
     yield* _(E.logDebug('Making request'))
     const client = yield* _(RpcClient)
-    const { verified } = yield* _(
-      client.verifyEmail(new VerifyEmailReq({ token, code: verificationRequest.code })),
+    const { principal } = yield* _(
+      client.verifyEmail(new VerifyEmailReq({ token, code: request.code })),
     )
 
-    return verified
+    return principal
   })
 }
 
@@ -127,7 +128,7 @@ export const EmailServiceLive = Layer.effect(
   EmailService,
   E.gen(function* (_) {
     const context = yield* _(
-      E.context<RpcClient | AuthenticationService | StorageService | LocationSearch>(),
+      E.context<RpcClient | AuthenticationService | StorageService | URLQueryString>(),
     )
     return EmailService.of({
       verifyEmailCode: flow(verifyEmail, E.provide(context)),