@passlock/client 0.9.17 → 0.9.21

package/src/social/social.fixture.ts

@@ -1,9 +1,8 @@
-import { PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import { AuthenticateOidcReq, OidcRes, RegisterOidcReq } from '@passlock/shared/dist/rpc/social.js'
+import * as Shared from '@passlock/shared/dist/rpc/social.js'
+import { SocialClient } from '@passlock/shared/dist/rpc/social.js'
 import { Effect as E, Layer as L } from 'effect'
 import * as Fixtures from '../test/fixtures.js'
-import { type OidcRequest } from './social.js'
+import type { AuthenticateOidcReq, RegisterOidcReq } from './social.js'
 
 export const session = 'session'
 export const token = 'token'
@@ -11,33 +10,38 @@ export const code = 'code'
 export const authType = 'passkey'
 export const expireAt = Date.now() + 10000
 
-export const oidcReq: OidcRequest = {
+export const registerOidcReq: RegisterOidcReq = {
   provider: 'google',
-  idToken: 'google-token'
+  idToken: 'google-token',
+  nonce: 'nonce',
+  givenName: 'john',
+  familyName: 'doe'
 }
 
-export const rpcRegisterReq = new RegisterOidcReq({ ...oidcReq })
+export const authOidcReq: AuthenticateOidcReq = {
+  provider: 'google',
+  idToken: 'google-token',
+  nonce: 'nonce'
+}
+
+export const rpcRegisterReq = new Shared.RegisterOidcReq({ 
+  ...registerOidcReq, 
+  ...(registerOidcReq.givenName ? { givenName: registerOidcReq.givenName } : {}),
+  ...(registerOidcReq.familyName ? { familyName: registerOidcReq.familyName } : {})
+})
 
-export const rpcRegisterRes = new OidcRes({ principal: Fixtures.principal })
+export const rpcRegisterRes = new Shared.PrincipalRes({ principal: Fixtures.principal })
 
-export const rpcAuthenticateReq = new AuthenticateOidcReq({ ...oidcReq })
+export const rpcAuthenticateReq = new Shared.AuthOidcReq({ ...authOidcReq })
 
-export const rpcAuthenticateRes = new OidcRes({ principal: Fixtures.principal })
+export const rpcAuthenticateRes = new Shared.PrincipalRes({ principal: Fixtures.principal })
 
 export const rpcClientTest = L.succeed(
-  RpcClient,
-  RpcClient.of({
-    preConnect: () => E.succeed(new PreConnectRes({ warmed: true })),
-    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),
+  SocialClient,
+  SocialClient.of({
     registerOidc: () => E.fail(Fixtures.notImplemented),
     authenticateOidc: () => E.fail(Fixtures.notImplemented),
-    resendVerificationEmail: () => E.fail(Fixtures.notImplemented),
-  }),
+  })
 )
 
 export const principal = Fixtures.principal

package/src/social/social.test.ts

@@ -1,5 +1,5 @@
 import { Duplicate, NotFound } from '@passlock/shared/dist/error/error.js'
-import { RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.js'
+import { SocialClient } from '@passlock/shared/dist/rpc/social.js'
 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'
@@ -10,14 +10,14 @@ describe('registerOidc should', () => {
   test('return a valid credential', async () => {
     const assertions = E.gen(function* (_) {
       const service = yield* _(SocialService)
-      const result = yield* _(service.registerOidc(Fixture.oidcReq))
+      const result = yield* _(service.registerOidc(Fixture.registerOidcReq))
       expect(result).toEqual(Fixture.principal)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.registerOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
@@ -39,16 +39,16 @@ describe('registerOidc should', () => {
   test('pass the request to the backend', async () => {
     const assertions = E.gen(function* (_) {
       const service = yield* _(SocialService)
-      yield* _(service.registerOidc(Fixture.oidcReq))
+      yield* _(service.registerOidc(Fixture.registerOidcReq))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(SocialClient)
       expect(rpcClient.registerOidc).toHaveBeenCalledWith(Fixture.rpcRegisterReq)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.registerOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
@@ -71,15 +71,15 @@ describe('registerOidc should', () => {
     const assertions = E.gen(function* (_) {
       const service = yield* _(SocialService)
 
-      const defect = yield* _(service.registerOidc(Fixture.oidcReq), E.flip)
+      const defect = yield* _(service.registerOidc(Fixture.registerOidcReq), E.flip)
 
       expect(defect).toBeInstanceOf(Duplicate)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.registerOidc.mockReturnValue(E.fail(new Duplicate({ message: "Duplicate user" })))
 
@@ -103,14 +103,14 @@ describe('authenticateIodc should', () => {
   test('return a valid credential', async () => {
     const assertions = E.gen(function* (_) {
       const service = yield* _(SocialService)
-      const result = yield* _(service.authenticateOidc(Fixture.oidcReq))
+      const result = yield* _(service.authenticateOidc(Fixture.authOidcReq))
       expect(result).toEqual(Fixture.principal)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.authenticateOidc.mockReturnValue(E.succeed(Fixture.rpcRegisterRes))
 
@@ -132,16 +132,16 @@ describe('authenticateIodc should', () => {
   test('pass the request to the backend', async () => {
     const assertions = E.gen(function* (_) {
       const service = yield* _(SocialService)
-      yield* _(service.authenticateOidc(Fixture.oidcReq))
+      yield* _(service.authenticateOidc(Fixture.authOidcReq))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(SocialClient)
       expect(rpcClient.authenticateOidc).toHaveBeenCalledWith(Fixture.rpcAuthenticateReq)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.authenticateOidc.mockReturnValue(E.succeed(Fixture.rpcAuthenticateRes))
 
@@ -164,15 +164,15 @@ describe('authenticateIodc should', () => {
     const assertions = E.gen(function* (_) {
       const service = yield* _(SocialService)
 
-      const defect = yield* _(service.authenticateOidc(Fixture.oidcReq), E.flip)
+      const defect = yield* _(service.authenticateOidc(Fixture.authOidcReq), E.flip)
 
       expect(defect).toBeInstanceOf(NotFound)
     })
 
     const rpcClientTest = L.effect(
-      RpcClient,
+      SocialClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<SocialClient['Type']>()
 
         rpcMock.authenticateOidc.mockReturnValue(E.fail(new NotFound({ message: "User not found" })))
 

package/src/social/social.ts

@@ -2,31 +2,45 @@
  * Passkey authentication effects
  */
 import {
-    type BadRequest,
-    type NotSupported
+  type BadRequest,
+  type NotSupported
 } from '@passlock/shared/dist/error/error.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import { AuthenticateOidcErrors, AuthenticateOidcReq, RegisterOidcErrors, RegisterOidcReq } from '@passlock/shared/dist/rpc/social.js'
+import * as Shared from '@passlock/shared/dist/rpc/social.js'
+import { SocialClient } from '@passlock/shared/dist/rpc/social.js'
 import type {
-    Principal
-} from '@passlock/shared/dist/schema/schema.js'
+  Principal
+} from '@passlock/shared/dist/schema/principal.js'
 import { Context, Effect as E, Layer, flow } from 'effect'
 
 /* Requests */
 
-export type OidcRequest = { provider: 'google', idToken: string }
+export type Provider = 'apple' | 'google'
+
+export type RegisterOidcReq = {
+  provider: Provider
+  idToken: string
+  nonce: string
+  givenName?: string
+  familyName?: string
+}
+
+export type AuthenticateOidcReq = {
+  provider: Provider
+  idToken: string
+  nonce: string
+}
 
 /* Errors */
 
-export type RegistrationErrors = NotSupported | BadRequest | RegisterOidcErrors
+export type RegistrationErrors = NotSupported | BadRequest | Shared.RegisterOidcErrors
 
-export type AuthenticationErrors = NotSupported | BadRequest | AuthenticateOidcErrors
+export type AuthenticationErrors = NotSupported | BadRequest | Shared.AuthOidcErrors
 
 /* Service */
 
 export type SocialService = {
-  registerOidc: (data: OidcRequest) => E.Effect<Principal, RegistrationErrors>
-  authenticateOidc: (data: OidcRequest) => E.Effect<Principal, AuthenticationErrors>
+  registerOidc: (data: RegisterOidcReq) => E.Effect<Principal, RegistrationErrors>
+  authenticateOidc: (data: AuthenticateOidcReq) => E.Effect<Principal, AuthenticationErrors>
 }
 
 export const SocialService = Context.GenericTag<SocialService>(
@@ -35,18 +49,24 @@ export const SocialService = Context.GenericTag<SocialService>(
 
 /* Effects */
 
-type Dependencies = RpcClient
+type Dependencies = SocialClient
 
 export const registerOidc = (
-  request: OidcRequest,
+  request: RegisterOidcReq,
 ): E.Effect<Principal, RegistrationErrors, Dependencies> => {
   return E.gen(function* (_) {
     yield* _(E.logInfo('Registering social account'))
 
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(SocialClient)
+
+    const rpcRequest = new Shared.RegisterOidcReq({
+      ...request,
+      ...(request.givenName ? { givenName: request.givenName } : {}),
+      ...(request.familyName ? { familyName: request.familyName } : {})
+    })
 
     const { principal } = yield* _(
-      rpcClient.registerOidc(new RegisterOidcReq(request))
+      rpcClient.registerOidc(rpcRequest)
     )
 
     return principal
@@ -54,15 +74,16 @@ export const registerOidc = (
 }
 
 export const authenticateOidc = (
-  request: OidcRequest,
+  request: AuthenticateOidcReq,
 ): E.Effect<Principal, AuthenticationErrors, Dependencies> => {
   return E.gen(function* (_) {
     yield* _(E.logInfo('Authenticating with social account'))
 
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(SocialClient)
+    const rpcRequest = new Shared.AuthOidcReq(request)
 
     const { principal } = yield* _(
-      rpcClient.authenticateOidc(new AuthenticateOidcReq(request))
+      rpcClient.authenticateOidc(rpcRequest)
     )
 
     return principal
@@ -75,7 +96,7 @@ export const authenticateOidc = (
 export const SocialServiceLive = Layer.effect(
   SocialService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<RpcClient>())
+    const context = yield* _(E.context<SocialClient>())
 
     return SocialService.of({
       registerOidc: flow(registerOidc, E.provide(context)),

package/src/storage/storage.ts

@@ -2,13 +2,13 @@
  * 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.js'
+import type { Principal } from '@passlock/shared/dist/schema/principal.js'
 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' | 'google'
+export type AuthType = 'email' | 'passkey' | 'apple' | 'google'
 
 export type StoredToken = {
   token: string
@@ -144,6 +144,7 @@ export const clearExpiredTokens: E.Effect<void, never, Storage> = E.all([
   clearExpiredToken('passkey'),
   clearExpiredToken('email'),
   clearExpiredToken('google'),
+  clearExpiredToken('apple'),
 ])
 
 /* Live */

package/src/test/fixtures.ts

@@ -1,6 +1,5 @@
 import { BadRequest } from '@passlock/shared/dist/error/error.js'
-import { PreConnectRes } from '@passlock/shared/dist/rpc/connection.js'
-import type { Principal } from '@passlock/shared/dist/schema/schema.js'
+import type { Principal } from '@passlock/shared/dist/schema/principal.js'
 import { Effect as E, Layer as L } from 'effect'
 import { Capabilities } from '../capabilities/capabilities.js'
 import { StorageService, type StoredToken } from '../storage/storage.js'
@@ -51,5 +50,4 @@ export const storageServiceTest = L.succeed(
   }),
 )
 
-export const preConnectRes = new PreConnectRes({ warmed: true })
 export const notImplemented = new BadRequest({ message: 'Not implemented' })

package/src/user/user.fixture.ts

@@ -1,5 +1,4 @@
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import { IsExistingUserReq, IsExistingUserRes, ResendEmailReq, ResendEmailRes, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
+import { IsExistingUserReq, IsExistingUserRes, ResendEmailReq, ResendEmailRes, UserClient, VerifyEmailRes } from '@passlock/shared/dist/rpc/user.js'
 import { Effect as E, Layer as L } from 'effect'
 import * as Fixtures from '../test/fixtures.js'
 import type { ResendEmail } from './user.js'
@@ -13,17 +12,10 @@ export const rpcResendEmailReq = new ResendEmailReq({ userId: '123', verifyEmail
 export const rpcResendEmailRes = new ResendEmailRes({ })
 
 export const rpcClientTest = L.succeed(
-  RpcClient,
-  RpcClient.of({
-    preConnect: () => E.succeed({ warmed: true }),
+  UserClient,
+  UserClient.of({
     isExistingUser: () => E.succeed({ existingUser: true }),
     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),
   }),
 )

package/src/user/user.test.ts

@@ -1,4 +1,4 @@
-import { RpcClient, type RouterOps } from '@passlock/shared/dist/rpc/rpc.js'
+import { UserClient } from '@passlock/shared/dist/rpc/user.js'
 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'
@@ -27,14 +27,14 @@ describe('isExistingUser should', () => {
       const result = yield* _(service.isExistingUser({ email: Fixture.email }))
 
       expect(result).toBe(false)
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(UserClient)
       expect(rpcClient.isExistingUser).toBeCalledWith(Fixture.isRegisteredReq)
     })
 
     const rpcClientTest = Layer.effect(
-      RpcClient,
+      UserClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<UserClient['Type']>()
 
         rpcMock.isExistingUser.mockReturnValue(E.succeed(Fixture.isRegisteredRes))
 
@@ -57,14 +57,14 @@ describe('resendVerificationEmail should', () => {
       const service = yield* _(UserService)
       yield* _(service.resendVerificationEmail(Fixture.resendEmailReq))
 
-      const rpcClient = yield* _(RpcClient)
+      const rpcClient = yield* _(UserClient)
       expect(rpcClient.resendVerificationEmail).toBeCalledWith(Fixture.rpcResendEmailReq)
     })
 
     const rpcClientTest = Layer.effect(
-      RpcClient,
+      UserClient,
       E.sync(() => {
-        const rpcMock = mock<RouterOps>()
+        const rpcMock = mock<UserClient['Type']>()
 
         rpcMock.resendVerificationEmail.mockReturnValue(E.succeed(Fixture.rpcResendEmailRes))
 

package/src/user/user.ts

@@ -2,9 +2,8 @@
  * Check for an existing user
  */
 import type { BadRequest, Disabled, NotFound } from '@passlock/shared/dist/error/error.js'
-import { RpcClient } from '@passlock/shared/dist/rpc/rpc.js'
-import { IsExistingUserReq, ResendEmailReq } from '@passlock/shared/dist/rpc/user.js'
-import type { VerifyEmail } from '@passlock/shared/dist/schema/schema.js'
+import { IsExistingUserReq, ResendEmailReq, UserClient } from '@passlock/shared/dist/rpc/user.js'
+import type { VerifyEmail } from '@passlock/shared/dist/schema/email.js'
 import { Context, Effect as E, Layer, flow } from 'effect'
 
 /* Requests */
@@ -27,12 +26,12 @@ export const UserService = Context.GenericTag<UserService>('@services/UserServic
 
 /* Effects */
 
-type Dependencies = RpcClient
+type Dependencies = UserClient
 
 export const isExistingUser = (request: Email): E.Effect<boolean, BadRequest, Dependencies> => {
   return E.gen(function* (_) {
     yield* _(E.logInfo('Checking registration status'))
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(UserClient)
 
     yield* _(E.logDebug('Making RPC request'))
     const { existingUser } = yield* _(rpcClient.isExistingUser(new IsExistingUserReq(request)))
@@ -44,7 +43,7 @@ export const isExistingUser = (request: Email): E.Effect<boolean, BadRequest, De
 export const resendVerificationEmail = (request: ResendEmail): E.Effect<void, ResendEmailErrors, Dependencies> => {
   return E.gen(function* (_) {
     yield* _(E.logInfo('Resending verification email'))
-    const rpcClient = yield* _(RpcClient)
+    const rpcClient = yield* _(UserClient)
 
     yield* _(E.logDebug('Making RPC request'))
     const { userId, ...verifyEmail } = request
@@ -58,7 +57,7 @@ export const resendVerificationEmail = (request: ResendEmail): E.Effect<void, Re
 export const UserServiceLive = Layer.effect(
   UserService,
   E.gen(function* (_) {
-    const context = yield* _(E.context<RpcClient>())
+    const context = yield* _(E.context<UserClient>())
     return UserService.of({
       isExistingUser: flow(isExistingUser, E.provide(context)),
       resendVerificationEmail: flow(resendVerificationEmail, E.provide(context))

package/README.md

@@ -1,116 +0,0 @@
-<div align="center">
-  <a href="https://github.com/passlock-dev/passkeys-frontend">
-    <img src="https://github.com/passlock-dev/passkeys-frontend/assets/208345/53ee00d3-8e6c-49ea-b43c-3f901450c73b" alt="Passlock logo" width="80" height="80">
-  </a>
-</div>
-
-<a name="readme-top"></a>
-<h1 align="center">Serverless Passkeys</h1>
-
-  <p align="center">
-    Passkey authentication for your web apps. Supports React, Angular, Vue, SvelteKit & others.
-    <br />
-    <a href="https://passlock.dev"><strong>Project website »</strong></a>
-    <br />
-    <a href="https://passlock.dev/#demo">Demo</a>
-    ·
-    <a href="https://docs.passlock.dev">Documentation</a>
-    ·
-    <a href="https://docs.passlock.dev/docs/tutorial/intro">Tutorial</a>
-  </p>
-</div>
-
-<br />
-
-## Features
-
-Passkeys and the WebAuthn API are quite complex. We've taken an opinionated approach to simplify things for you. Following the 80/20 principle we've tried to focus on the features most valuable to developers and users. We welcome feature requests so do [get in touch][contact].
-
-1. **🔐 Primary & secondary authentication** - Replace password based logins with passkeys, or use passkeys alongside passwords for secondary authentication.
-
-2. **☝🏻 Biometrics** - We've made it really easy to implement facial or fingerprint recognition in your webapps.
-
-3. **🔐 Step up authentication** - Require biometric or PIN verification for some operations, whilst allowing one-tap authentication for others.
-
-4. **🚀 Social login** - Quickly add social login to your web application.
-
-5. **🖥️ Full management console** - Manage all security related aspects of your userbase through a web based console.
-
-6. **🕵️ Audit trail** - View a full audit trail for each user: when they add a new passkey, when they login, verify their email address and much more.
-
-## Screenshot
-
-![Passlock user profile](https://github.com/passlock-dev/passkeys/assets/208345/a4a5c4b8-86cb-4076-bd26-7c29ed2151c6)
-<p align="center">Viewing a user's authentication activity on their profile page</p>
-
-## Usage
-
-Use this library to generate a secure token, representing passkey registration or authentication. Send the token to your backend for verification (see below)
-
-### Register a passkey
-
-```typescript
-import { Passlock, PasslockError } from '@passlock/client'
-
-// you can find these details in the settings area of the Passlock console
-const tenancyId = '...'
-const clientId = '...'
-
-const passlock = new Passlock({ tenancyId, clientId })
-
-// to register a new passkey, call registerPasskey(). We're using placeholders for 
-// the user data. You should grab this from an HTML form, React store, Redux etc.
-const [email, givenName, familyName] = ["jdoe@gmail.com", "John", "Doe"]
-
-// Passlock doesn't throw but instead returns a union: result | error
-const result = await passlock.registerPasskey({ email, givenName, familyName })
-
-// ensure Passlock didn't return an error
-if (!PasslockError.isError(result)) {
-  // send the token to your backend (json/fetch or hidden form field etc)
-  console.log('Token: %s', result.token)
-}
-```
-
-### Authenticate using a passkey
-
-```typescript
-import { Passlock, PasslockError } from '@passlock/client'
-
-const tenancyId = '...'
-const clientId = '...'
-
-const passlock = new Passlock({ tenancyId, clientId })
-const result = await passlock.authenticatePasskey()
-
-if (!PasslockError.isError(result)) {
-  // send the token to your backend for verification
-  console.log('Token: %s', result.token)
-}
-```
-
-### Backend verification
-
-Verify the token and obtain the passkey registration or authentication details. You can make a simple GET request to `https://api.passlock.dev/{tenancyId}/token/{token}` or use the [@passlock/node][node] library:
-
-```typescript
-import { Passlock } from '@passlock/node'
-
-// API Keys can be found in your passlock console
-const passlock = new Passlock({ tenancyId, apiKey })
-
-// token comes from your frontend
-const principal = await passlock.fetchPrincipal({ token })
-
-// get the user id
-console.log(principal.user.id)
-```
-
-## More information
-
-Please see the [tutorial][tutorial] and [documentation][docs]
-
-[contact]: https://passlock.dev/contact
-[tutorial]: https://docs.passlock.dev/docs/tutorial/intro
-[docs]: https://docs.passlock.dev
-[node]: https://www.npmjs.com/package/@passlock/node