@toa.io/extensions.exposition 0.22.0 → 0.22.1

package/components/identity.basic/source/authenticate.ts

@@ -1,27 +1,29 @@
 import { atob } from 'buffer'
 import { compare } from 'bcryptjs'
-import { type Query } from '@toa.io/types'
-import { Nope, type Nopeable } from 'nopeable'
+import { type Query, type Maybe } from '@toa.io/types'
 import { type Context } from './types'
 
-export async function computation (input: string, context: Context): Promise<Nopeable<Output>> {
+export async function computation (input: string, context: Context): Promise<Maybe<Output>> {
   const [username, password] = atob(input).split(':')
   const query: Query = { criteria: `username==${username}` }
   const credentials = await context.local.observe({ query })
 
-  if (credentials instanceof Nope)
+  if (credentials instanceof Error)
     return credentials
 
   if (credentials === null)
-    return new Nope('NOT_FOUND')
+    return ERR_NOT_FOUND
 
   const spicy = password + context.configuration.pepper
   const match = await compare(spicy, credentials.password)
 
   if (match) return { identity: { id: credentials.id } }
-  else return new Nope('PASSWORD_MISMATCH')
+  else return ERR_PASSWORD_MISMATCH
 }
 
+const ERR_NOT_FOUND = new Error('NOT_FOUND')
+const ERR_PASSWORD_MISMATCH = new Error('PASSWORD_MISMATCH')
+
 interface Output {
   identity: {
     id: string

package/components/identity.basic/source/create.ts

@@ -1,8 +1,7 @@
-import { type Nopeable } from 'nopeable'
 import { type Context } from './types'
 
 export async function effect
-(input: CreateInput, context: Context): Promise<Nopeable<CreateOutput>> {
+(input: CreateInput, context: Context): Promise<CreateOutput> {
   const [username, password] = atob(input.credentials).split(':')
   const request = { input: { username, password }, query: { id: input.id } }
 

package/components/identity.basic/source/transit.ts

@@ -1,6 +1,5 @@
 import { genSalt, hash } from 'bcryptjs'
-import { type Operation } from '@toa.io/types'
-import { Nope, type Nopeable } from 'nopeable'
+import { type Maybe, type Operation } from '@toa.io/types'
 import { type Context, type Entity, type TransitInput, type TransitOutput } from './types'
 
 export class Transition implements Operation {
@@ -21,7 +20,7 @@ export class Transition implements Operation {
     this.passwrodRx = toRx(context.configuration.password)
   }
 
-  public async execute (input: TransitInput, object: Entity): Promise<Nopeable<TransitOutput>> {
+  public async execute (input: TransitInput, object: Entity): Promise<Maybe<TransitOutput>> {
     const existent = object._version !== 0
 
     if (existent)
@@ -29,17 +28,17 @@ export class Transition implements Operation {
 
     if (input.username !== undefined) {
       if (existent && object.username === this.principal)
-        return new Nope('PRINCIPAL_LOCKED', 'Principal username cannot be changed.')
+        return ERR_PRINCIPAL_LOCKED
 
       if (invalid(input.username, this.usernameRx))
-        return new Nope('INVALID_USERNAME', 'Username is not meeting the requirements.')
+        return ERR_INVALID_USERNAME
 
       object.username = input.username
     }
 
     if (input.password !== undefined) {
       if (invalid(input.password, this.passwrodRx))
-        return new Nope('INVALID_PASSWORD', 'Password is not meeting the requirements.')
+        return ERR_INVALID_PASSWORD
 
       const salt = await genSalt(this.rounds)
       const spicy = input.password + this.pepper
@@ -61,4 +60,8 @@ function invalid (value: string, expressions: RegExp[]): boolean {
   return expressions.some((expression) => !expression.test(value))
 }
 
+const ERR_PRINCIPAL_LOCKED = new Error('PRINCIPAL_LOCKED')
+const ERR_INVALID_USERNAME = new Error('INVALID_USERNAME')
+const ERR_INVALID_PASSWORD = new Error('INVALID_PASSWORD')
+
 type Tokens = Context['remote']['identity']['tokens']

package/components/identity.basic/source/types.ts

@@ -1,8 +1,8 @@
-import { type Call, type Observation, type Query } from '@toa.io/types'
+import { type Call, type Maybe, type Observation, type Query } from '@toa.io/types'
 
 export interface Context {
   local: {
-    observe: Observation<Entity>
+    observe: Observation<Maybe<Entity>>
     transit: Call<TransitOutput, TransitInput>
   }
   remote: {

package/components/identity.tokens/source/authenticate.ts

@@ -1,5 +1,4 @@
-import { Nope, type Nopeable } from 'nopeable'
-import { type Operation } from '@toa.io/types'
+import { type Maybe, type Operation } from '@toa.io/types'
 import { type AuthenticateOutput, type Context } from './types'
 
 export class Computation implements Operation {
@@ -13,10 +12,10 @@ export class Computation implements Operation {
     this.observe = context.local.observe
   }
 
-  public async execute (token: string): Promise<Nopeable<AuthenticateOutput>> {
+  public async execute (token: string): Promise<Maybe<AuthenticateOutput>> {
     const claim = await this.decrypt({ input: token })
 
-    if (claim instanceof Nope)
+    if (claim instanceof Error)
       return claim
 
     const identity = claim.identity
@@ -28,7 +27,7 @@ export class Computation implements Operation {
       const revocation = await this.observe({ query: { id: identity.id } })
 
       if (revocation !== null && iat < revocation.revokedAt)
-        return new Nope('REVOKED')
+        return ERR_TOKEN_REVOKED
     }
 
     const refresh = stale || claim.refresh
@@ -36,3 +35,5 @@ export class Computation implements Operation {
     return { identity, refresh }
   }
 }
+
+const ERR_TOKEN_REVOKED = new Error('TOKEN_REVOKED')

package/components/identity.tokens/source/decrypt.ts

@@ -1,9 +1,9 @@
 import { V3 } from 'paseto'
-import { Nope, type Nopeable } from 'nopeable'
+import { type Maybe } from '@toa.io/types'
 import { type Context, type Claim, type DecryptOutput } from './types'
 
 export async function computation (token: string, context: Context):
-Promise<Nopeable<DecryptOutput>> {
+Promise<Maybe<DecryptOutput>> {
   let refresh = false
   let claim = await decrypt(token, context.configuration.key0)
 
@@ -12,8 +12,14 @@ Promise<Nopeable<DecryptOutput>> {
     claim = await decrypt(token, context.configuration.key1)
   }
 
-  if (claim === null) return new Nope('INVALID_TOKEN', 'Invalid token')
-  else return { identity: claim.identity, iat: claim.iat, exp: claim.exp, refresh }
+  if (claim === null)
+    return ERR_INVALID_TOKEN
+  else return {
+    identity: claim.identity,
+    iat: claim.iat,
+    exp: claim.exp,
+    refresh
+  }
 }
 
 async function decrypt (token: string, key: string): Promise<Claim | null> {
@@ -23,3 +29,5 @@ async function decrypt (token: string, key: string): Promise<Claim | null> {
     return null
   }
 }
+
+const ERR_INVALID_TOKEN = new Error('INVALID_TOKEN')

package/components/identity.tokens/source/encrypt.test.ts

@@ -31,5 +31,5 @@ it('should encrypt with given lifetime', async () => {
 
   await timeout(lifetime * 1000)
 
-  await expect(decrypt(encrypted, context)).resolves.toMatchObject({ code: 'INVALID_TOKEN' })
+  await expect(decrypt(encrypted, context)).resolves.toMatchObject({ message: 'INVALID_TOKEN' })
 })

package/components/identity.tokens/source/types.ts

@@ -1,9 +1,9 @@
-import { type Call, type Observation } from '@toa.io/types'
+import { type Call, type Maybe, type Observation } from '@toa.io/types'
 
 export interface Context {
   local: {
     observe: Observation<Entity>
-    decrypt: Call<DecryptOutput, string>
+    decrypt: Call<Maybe<DecryptOutput>, string>
   }
   configuration: Configuration
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/extensions.exposition",
-  "version": "0.22.0",
+  "version": "0.22.1",
   "description": "Toa Exposition",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -16,11 +16,8 @@
   "publishConfig": {
     "access": "public"
   },
-  "peerDependencies": {
-    "nopeable": "*"
-  },
   "dependencies": {
-    "@toa.io/core": "0.22.0",
+    "@toa.io/core": "0.22.1",
     "@toa.io/generic": "0.22.0",
     "@toa.io/http": "0.22.0",
     "@toa.io/schemas": "0.22.0",
@@ -49,5 +46,5 @@
     "@types/express": "4.17.17",
     "@types/negotiator": "0.6.1"
   },
-  "gitHead": "c463348c8eb54a43f7755ec8aeba9acafb56d53b"
+  "gitHead": "d1116e1a3c3d881d2204989851596f0715abcb0f"
 }

package/source/Gateway.ts

@@ -1,5 +1,5 @@
 import { type bindings, Connector } from '@toa.io/core'
-import { Nope, type Nopeable } from 'nopeable'
+import { type Maybe } from '@toa.io/types'
 import * as http from './HTTP'
 import { rethrow } from './exceptions'
 import { type Method, type Parameter, type Tree } from './RTD'
@@ -65,9 +65,9 @@ export class Gateway extends Connector {
 
     const reply = await method.endpoint
       .call(request.body, request.query, parameters)
-      .catch(rethrow) as Nopeable<unknown>
+      .catch(rethrow) as Maybe<unknown>
 
-    if (reply instanceof Nope)
+    if (reply instanceof Error)
       throw new http.Conflict(reply)
 
     return { body: reply }

package/source/directives/auth/Family.ts

@@ -1,5 +1,4 @@
 import { type Component } from '@toa.io/core'
-import { Nope } from 'nopeable'
 import { type Parameter } from '../../RTD'
 import { type Family, type Output } from '../../Directive'
 import { type Remotes } from '../../Remotes'
@@ -107,7 +106,7 @@ class Authorization implements Family<Directive, Extension> {
     const result = await this.schemes[scheme]
       .invoke<AuthenticationResult>('authenticate', { input: credentials })
 
-    if (result instanceof Nope)
+    if (result instanceof Error)
       return null
 
     const identity = result.identity

package/source/directives/auth/Incept.ts

@@ -1,4 +1,4 @@
-import { Nope, type Nopeable } from 'nopeable'
+import { type Maybe } from '@toa.io/types'
 import * as http from '../../HTTP'
 import { type Directive, type Discovery, type Identity, type Input, type Schemes } from './types'
 import { split } from './split'
@@ -31,9 +31,9 @@ export class Incept implements Directive {
     this.schemes[scheme] ??= await this.discovery[provider]
 
     const identity = await this.schemes[scheme]
-      .invoke<Nopeable<Identity>>('create', { input: { id, credentials } })
+      .invoke<Maybe<Identity>>('create', { input: { id, credentials } })
 
-    if (identity instanceof Nope)
+    if (identity instanceof Error)
       throw new http.Conflict(identity)
 
     request.identity = identity

package/source/directives/auth/types.ts

@@ -1,5 +1,5 @@
 import { type Component } from '@toa.io/core'
-import { type Nopeable } from 'nopeable'
+import { type Maybe } from '@toa.io/types'
 import { type Parameter } from '../../RTD'
 import type * as http from '../../HTTP'
 import type * as directive from '../../Directive'
@@ -29,7 +29,7 @@ export interface Ban {
 }
 
 export type Input = directive.Input & Extension
-export type AuthenticationResult = Nopeable<{ identity: Identity, refresh: boolean }>
+export type AuthenticationResult = Maybe<{ identity: Identity, refresh: boolean }>
 
 export type Scheme = 'basic' | 'token'
 export type Remote = 'basic' | 'tokens' | 'roles' | 'bans'