commit 8a8b6188c0c3068f927ee34bc415f67507f967db · edouard.paris/did-method-plc

+15 -6

packages/lib/src/client.ts

···

       1
       1
       -
       import { cidForCbor } from '@atproto/common'

     

       1
       1
       +
       import { check, cidForCbor } from '@atproto/common'

     

       2
       2
        
       import { Keypair } from '@atproto/crypto'

     

       3
       3
        
       import axios from 'axios'

     

       4
       4
       -
       import { didForCreateOp, signOperation } from './operations'

     

       4
       4
       +
       import { didForCreateOp, normalizeOp, signOperation } from './operations'

     

       5
       5
        
       import * as t from './types'

     

       6
       6
        
       

     

       7
       7
        
       export class Client {

     
···

       20
       20
        
         async getOperationLog(

     

       21
       21
        
           did: string,

     

       22
       22
        
           includeNull = false,

     

       23
       23
       -
         ): Promise<t.Operation[]> {

     

       23
       23
       +
         ): Promise<t.CompatibleOpOrTombstone[]> {

     

       24
       24
        
           let url = `${this.url}/${encodeURIComponent(did)}/log`

     

       25
       25
        
           if (includeNull) {

     

       26
       26
        
             url += '?includeNull=true'

     
···

       33
       33
        
           return `${this.url}/${encodeURIComponent(did)}`

     

       34
       34
        
         }

     

       35
       35
        
       

     

       36
       36
       -
         async getLastOp(did: string): Promise<t.Operation> {

     

       36
       36
       +
         async getLastOp(did: string): Promise<t.CompatibleOpOrTombstone> {

     

       37
       37
        
           const res = await axios.get(`${this.url}/${encodeURIComponent(did)}/last`)

     

       38
       38
        
           return res.data

     

       39
       39
        
         }

     
···

       44
       44
        
           key: Keypair,

     

       45
       45
        
         ) {

     

       46
       46
        
           const lastOp = await this.getLastOp(did)

     

       47
       47
       +
           if (check.is(lastOp, t.def.tombstone)) {

     

       48
       48
       +
             throw new Error('Cannot apply op to tombstone')

     

       49
       49
       +
           }

     

       47
       50
        
           const prev = await cidForCbor(lastOp)

     

       48
       48
       -
           const { signingKey, rotationKeys, handles, services } = lastOp

     

       51
       51
       +
           const { signingKey, rotationKeys, handles, services } = normalizeOp(lastOp)

     

       49
       52
        
           const op = await signOperation(

     

       50
       53
        
             {

     

       51
       54
        
               signingKey,

     
···

       76
       79
        
           return did

     

       77
       80
        
         }

     

       78
       81
        
       

     

       79
       79
       -
         async sendOperation(did: string, op: t.Operation) {

     

       82
       82
       +
         async sendOperation(did: string, op: t.OpOrTombstone) {

     

       80
       83
        
           await axios.post(this.postOpUrl(did), op)

     

       84
       84
       +
         }

     

       85
       85
       +
       

     

       86
       86
       +
         async export(): Promise<t.ExportedOp[]> {

     

       87
       87
       +
           const res = await axios.get(`${this.url}/export`)

     

       88
       88
       +
           const lines = res.data.split('\n')

     

       89
       89
       +
           return lines.map((l) => JSON.parse(l))

     

       81
       90
        
         }

     

       82
       91
        
       

     

       83
       92
        
         async health() {

+8

packages/lib/src/types.ts

···

       68
       68
        
       })

     

       69
       69
        
       export type IndexedOperation = z.infer<typeof indexedOperation>

     

       70
       70
        
       

     

       71
       71
       +
       export type ExportedOp = {

     

       72
       72
       +
         did: string

     

       73
       73
       +
         operation: CompatibleOpOrTombstone

     

       74
       74
       +
         cid: string

     

       75
       75
       +
         nullified: boolean

     

       76
       76
       +
         createdAt: Date

     

       77
       77
       +
       }

     

       78
       78
       +
       

     

       71
       79
        
       export const didDocVerificationMethod = z.object({

     

       72
       80
        
         id: z.string(),

     

       73
       81
        
         type: z.string(),

+3 -6

packages/server/src/db/index.ts

···

       1
       1
       -
       import { Kysely, Migrator, PostgresDialect, Selectable, sql } from 'kysely'

     

       1
       1
       +
       import { Kysely, Migrator, PostgresDialect, sql } from 'kysely'

     

       2
       2
        
       import { Pool as PgPool, types as pgTypes } from 'pg'

     

       3
       3
        
       import { CID } from 'multiformats/cid'

     

       4
       4
        
       import { cidForCbor } from '@atproto/common'

     

       5
       5
        
       import * as plc from '@did-plc/lib'

     

       6
       6
        
       import { ServerError } from '../error'

     

       7
       7
        
       import * as migrations from '../migrations'

     

       8
       8
       -
       import { DatabaseSchema, OperationsTable, PlcDatabase } from './types'

     

       8
       8
       +
       import { DatabaseSchema, PlcDatabase } from './types'

     

       9
       9
        
       import MockDatabase from './mock'

     

       10
       10
        
       

     

       11
       11
        
       export * from './mock'

     
···

       197
       197
        
           return res?.operation ?? null

     

       198
       198
        
         }

     

       199
       199
        
       

     

       200
       200
       -
         async exportOps(

     

       201
       201
       -
           count: number,

     

       202
       202
       -
           after?: Date,

     

       203
       203
       -
         ): Promise<Selectable<OperationsTable>[]> {

     

       200
       200
       +
         async exportOps(count: number, after?: Date): Promise<plc.ExportedOp[]> {

     

       204
       201
        
           let builder = this.db

     

       205
       202
        
             .selectFrom('operations')

     

       206
       203
        
             .selectAll()

+2 -6

packages/server/src/db/mock.ts

···

       1
       1
        
       import { cidForCbor, check } from '@atproto/common'

     

       2
       2
        
       import * as plc from '@did-plc/lib'

     

       3
       3
       -
       import { Selectable } from 'kysely'

     

       4
       3
        
       import { ServerError } from '../error'

     

       5
       5
       -
       import { OperationsTable, PlcDatabase } from './types'

     

       4
       4
       +
       import { PlcDatabase } from './types'

     

       6
       5
        
       

     

       7
       6
        
       type Contents = Record<string, plc.IndexedOperation[]>

     

       8
       7
        
       

     
···

       73
       72
        
         }

     

       74
       73
        
       

     

       75
       74
        
         // disabled in mocks

     

       76
       76
       -
         async exportOps(

     

       77
       77
       -
           _count: number,

     

       78
       78
       -
           _after?: Date,

     

       79
       79
       -
         ): Promise<Selectable<OperationsTable>[]> {

     

       75
       75
       +
         async exportOps(_count: number, _after?: Date): Promise<plc.ExportedOp[]> {

     

       80
       76
        
           return []

     

       81
       77
        
         }

     

       82
       78
        
       }

+2 -2

packages/server/src/db/types.ts

···

       1
       1
        
       import * as plc from '@did-plc/lib'

     

       2
       2
       -
       import { Generated, Selectable } from 'kysely'

     

       2
       2
       +
       import { Generated } from 'kysely'

     

       3
       3
        
       

     

       4
       4
        
       export interface PlcDatabase {

     

       5
       5
        
         close(): Promise<void>

     
···

       11
       11
        
           includeNull?: boolean,

     

       12
       12
        
         ): Promise<plc.IndexedOperation[]>

     

       13
       13
        
         lastOpForDid(did: string): Promise<plc.CompatibleOpOrTombstone | null>

     

       14
       14
       -
         exportOps(count: number, after?: Date): Promise<Selectable<OperationsTable>[]>

     

       14
       14
       +
         exportOps(count: number, after?: Date): Promise<plc.ExportedOp[]>

     

       15
       15
        
       }

     

       16
       16
        
       

     

       17
       17
        
       export interface OperationsTable {

+5 -3

packages/server/src/routes.ts

···

       26
       26
        
           const ops = await ctx.db.exportOps(count, after)

     

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

     

       28
       28
        
           res.status(200)

     

       29
       29
       -
           for (const op of ops) {

     

       30
       30
       -
             const line = JSON.stringify(op)

     

       29
       29
       +
           for (let i = 0; i < ops.length; i++) {

     

       30
       30
       +
             if (i > 0) {

     

       31
       31
       +
               res.write('\n')

     

       32
       32
       +
             }

     

       33
       33
       +
             const line = JSON.stringify(ops[i])

     

       31
       34
        
             res.write(line)

     

       32
       32
       -
             res.write('\n')

     

       33
       35
        
           }

     

       34
       36
        
           res.end()

     

       35
       37
        
         })

+6 -2

packages/server/tests/server.test.ts

···

       1
       1
        
       import { EcdsaKeypair } from '@atproto/crypto'

     

       2
       2
        
       import * as plc from '@did-plc/lib'

     

       3
       3
        
       import { CloseFn, runTestServer } from './_util'

     

       4
       4
       -
       import { cidForCbor } from '@atproto/common'

     

       4
       4
       +
       import { check, cidForCbor } from '@atproto/common'

     

       5
       5
        
       import { AxiosError } from 'axios'

     

       6
       6
        
       import { Database } from '../src'

     

       7
       7
        
       import { signOperation } from '@did-plc/lib'

     
···

       133
       133
        
           const newKey = await EcdsaKeypair.create()

     

       134
       134
        
           const ops = await client.getOperationLog(did)

     

       135
       135
        
           const forkPoint = ops.at(-2)

     

       136
       136
       -
           if (!forkPoint) {

     

       136
       136
       +
           if (!check.is(forkPoint, plc.def.operation)) {

     

       137
       137
        
             throw new Error('Could not find fork point')

     

       138
       138
        
           }

     

       139
       139
        
           const forkCid = await cidForCbor(forkPoint)

     
···

       217
       217
        
       

     

       218
       218
        
           const ops = await client.getOperationLog(did)

     

       219
       219
        
           await plc.validateOperationLog(did, ops)

     

       220
       220
       +
         })

     

       221
       221
       +
       

     

       222
       222
       +
         it('exports the data set', async () => {

     

       223
       223
       +
           await client.export()

     

       220
       224
        
         })

     

       221
       225
        
       

     

       222
       226
        
         it('healthcheck succeeds when database is available.', async () => {