commit 255d430fcee6350e8fd3a849cab181a04036d1fd · edouard.paris/did-method-plc

+5

packages/lib/src/data.ts

···

       7
       7
        
       import { didForCreateOp, normalizeOp } from './operations'

     

       8
       8
        
       import {

     

       9
       9
        
         GenesisHashError,

     

       10
       10
       +
         ImproperlyFormattedDidError,

     

       10
       11
        
         ImproperOperationError,

     

       11
       12
        
         InvalidSignatureError,

     

       12
       13
        
         LateRecoveryError,

     
···

       129
       130
        
         const normalized = normalizeOp(op)

     

       130
       131
        
         await assureValidSig(normalized.rotationKeys, op)

     

       131
       132
        
         const expectedDid = await didForCreateOp(op, 64)

     

       133
       133
       +
         // id must be >=24 chars & prefix is 8chars

     

       134
       134
       +
         if (did.length < 32) {

     

       135
       135
       +
           throw new ImproperlyFormattedDidError('too short')

     

       136
       136
       +
         }

     

       132
       137
        
         if (!expectedDid.startsWith(did)) {

     

       133
       138
        
           throw new GenesisHashError(expectedDid)

     

       134
       139
        
         }

+25 -6

packages/lib/src/error.ts

···

       1
       1
       -
       export class ImproperOperationError extends Error {

     

       1
       1
       +
       export class PlcError extends Error {

     

       2
       2
       +
         plcError = true

     

       3
       3
       +
         constructor(msg: string) {

     

       4
       4
       +
           super(msg)

     

       5
       5
       +
         }

     

       6
       6
       +
       

     

       7
       7
       +
         static is(obj: unknown): obj is PlcError {

     

       8
       8
       +
           if (obj && typeof obj === 'object' && obj['plcError'] === true) {

     

       9
       9
       +
             return true

     

       10
       10
       +
           }

     

       11
       11
       +
           return false

     

       12
       12
       +
         }

     

       13
       13
       +
       }

     

       14
       14
       +
       export class ImproperOperationError extends PlcError {

     

       2
       15
        
         constructor(public reason: string, public op: unknown) {

     

       3
       16
        
           super(`Improperly formatted operation, ${reason}: ${op}`)

     

       4
       17
        
         }

     

       5
       18
        
       }

     

       6
       19
        
       

     

       7
       7
       -
       export class MisorderedOperationError extends Error {

     

       20
       20
       +
       export class MisorderedOperationError extends PlcError {

     

       8
       21
        
         constructor() {

     

       9
       22
        
           super('Operations not correctly ordered')

     

       10
       23
        
         }

     

       11
       24
        
       }

     

       12
       25
        
       

     

       13
       13
       -
       export class LateRecoveryError extends Error {

     

       26
       26
       +
       export class LateRecoveryError extends PlcError {

     

       14
       27
        
         constructor(public timeLapsed: number) {

     

       15
       28
        
           super(

     

       16
       29
        
             `Recovery operation occured outside of the allowed 72 hr recovery window. Time lapsed: ${timeLapsed}`,

     
···

       18
       31
        
         }

     

       19
       32
        
       }

     

       20
       33
        
       

     

       21
       21
       -
       export class GenesisHashError extends Error {

     

       34
       34
       +
       export class GenesisHashError extends PlcError {

     

       22
       35
        
         constructor(public expected: string) {

     

       23
       36
        
           super(

     

       24
       37
        
             `Hash of genesis operation does not match DID identifier: ${expected}`,

     
···

       26
       39
        
         }

     

       27
       40
        
       }

     

       28
       41
        
       

     

       29
       29
       -
       export class InvalidSignatureError extends Error {

     

       42
       42
       +
       export class InvalidSignatureError extends PlcError {

     

       30
       43
        
         constructor(public op: unknown) {

     

       31
       44
        
           super(`Invalid signature on op: ${JSON.stringify(op)}`)

     

       32
       45
        
         }

     

       33
       46
        
       }

     

       34
       47
        
       

     

       35
       35
       -
       export class UnsupportedKeyError extends Error {

     

       48
       48
       +
       export class UnsupportedKeyError extends PlcError {

     

       36
       49
        
         constructor(public key: string, public err: unknown) {

     

       37
       50
        
           super(`Unsupported key type ${key}: ${err}`)

     

       38
       51
        
         }

     

       39
       52
        
       }

     

       53
       53
       +
       

     

       54
       54
       +
       export class ImproperlyFormattedDidError extends PlcError {

     

       55
       55
       +
         constructor(public reason: string) {

     

       56
       56
       +
           super(`Improperly formatted did: ${reason}`)

     

       57
       57
       +
         }

     

       58
       58
       +
       }

+10

packages/server/src/error.ts

···

       1
       1
       +
       import { PlcError } from '@did-plc/lib'

     

       1
       2
        
       import { ErrorRequestHandler } from 'express'

     

       2
       3
        
       

     

       3
       4
        
       export const handler: ErrorRequestHandler = (err, req, res, next) => {

     

       5
       5
       +
         // normalize our PLC errors to server errors

     

       6
       6
       +
         if (PlcError.is(err)) {

     

       7
       7
       +
           err = ServerError.fromPlcError(err)

     

       8
       8
       +
         }

     

       9
       9
       +
       

     

       4
       10
        
         req.log.info(

     

       5
       11
        
           err,

     

       6
       12
        
           ServerError.is(err)

     
···

       31
       37
        
             typeof (obj as Record<string, unknown>).message === 'string' &&

     

       32
       38
        
             typeof (obj as Record<string, unknown>).status === 'number'

     

       33
       39
        
           )

     

       40
       40
       +
         }

     

       41
       41
       +
       

     

       42
       42
       +
         static fromPlcError(err: PlcError): ServerError {

     

       43
       43
       +
           return new ServerError(400, err.message)

     

       34
       44
        
         }

     

       35
       45
        
       }

+2 -1

packages/server/src/routes.ts

···

       19
       19
        
           res.send({ version })

     

       20
       20
        
         })

     

       21
       21
        
       

     

       22
       22
       +
         // @TODO paginate & test this

     

       22
       23
        
         router.get('/export', async function (req, res) {

     

       23
       24
        
           const fullExport = await ctx.db.fullExport()

     

       24
       25
        
           res.setHeader('content-type', 'application/jsonlines')

     
···

       65
       66
        
           res.json({ log })

     

       66
       67
        
         })

     

       67
       68
        
       

     

       68
       68
       -
         // Get operation log for a DID

     

       69
       69
       +
         // Get the most recent operation in the log for a DID

     

       69
       70
        
         router.get('/last/:did', async function (req, res) {

     

       70
       71
        
           const { did } = req.params

     

       71
       72
        
           const log = await ctx.db.opsForDid(did)