Rename and fix lint errors

Author: adrianhopebailie

README.md

@@ -1,12 +1,11 @@
-# ilp-protocol-btp3
-ilp-x module provides an asynchronous request-response framework for communicating BTPv3 packets between clients and server over an
-underlying gRPC bidirectional stream.
+# ilp-transport-grpc
+ilp-transport-grpc module provides an asynchronous request-response framework for communicating ILP packets between clients and a server over an underlying gRPC bidirectional stream.
 
 
 #Server
 ```javascript
-const server = new BtpServer({}, {
-  log: createLogger('btp-server'),
+const server = new GrpcTransportServer({}, {
+  log: createLogger('grpc-server'),
   authenticate: () => Promise.resolve({ id: 'test' })
 })
 
@@ -32,7 +31,7 @@ client.on('request', (data) =>  {
 
 const response = await client.request({
     protocol: 'ilp',
-    contentType: BtpMessageContentType.ApplicationOctetStream,
+    contentType: FrameContentType.ApplicationOctetStream,
     payload: Buffer.from('Hello?')
   })
 ```

dist/example/client.js

@@ -1,11 +1,8 @@
-import {createConnection, BtpMessageContentType, BtpPacketType, BtpErrorCode, BtpErrorMessagePacket} from '../lib'
+import { createConnection, FrameType, TransportErrorCode, ErrorFrame, FrameContentType } from '../lib'
 import UUID from '../lib/uuid'
 
 (async () => {
   const client = await createConnection('127.0.0.1:5001', {
-    headers: {
-      authorization: 'Bearer TOKEN'
-    },
     accountId: 'matt',
     accountInfo: {
       relation: 'child',
@@ -14,21 +11,25 @@ import UUID from '../lib/uuid'
     }
   })
 
-  client.on('error', (data: any) =>  {
+  client.on('error', (data: any) => {
     console.log(data)
   })
 
-  client.on('request', (data: any) =>  {
+  client.on('request', (data: any) => {
     console.log(data)
   })
 
   const errorPacket = {
     id: new UUID().toString(),
     correlationId: new UUID().toString(),
-    type: BtpPacketType.ERROR,
-    code: BtpErrorCode.UnknownCorrelationId,
+    type: FrameType.ERROR,
+    code: TransportErrorCode.UnknownCorrelationId,
     message: `No request found with id: ${new UUID().toString()}`
-  } as BtpErrorMessagePacket
+  } as ErrorFrame
 
-  // const resp = await client._send(errorPacket, () => null)
+  const resp = await client.message({
+    protocol: 'test',
+    contentType: FrameContentType.TextPlain,
+    payload: Buffer.from('TEST')
+  })
 })()

dist/example/client.js.map

@@ -1,31 +1,31 @@
-import { BtpError, BtpStream, BtpServer, BtpMessage, BtpMessageContentType } from '../lib'
+import { TransportError, GrpcTransport, GrpcTransportServer, MessagePayload, FrameContentType } from '../lib'
 import { default as createLogger } from 'ilp-logger'
 
-const server = new BtpServer({}, {
-  log: createLogger('btp-server'),
+const server = new GrpcTransportServer({}, {
+  log: createLogger('grpc-server'),
   authenticate: () => Promise.resolve({ id: 'test' })
 })
 server.on('listening', () => {
   console.log('Listening...')
 })
 
-server.on('connection', (stream: BtpStream) => {
+server.on('connection', (stream: GrpcTransport) => {
 
   const { accountId, accountInfo } = stream
 
   console.log(`CONNECTION: state=${stream.state}`)
 
-  stream.on('message', (message: BtpMessage) => {
+  stream.on('message', (message: MessagePayload) => {
     console.log(`MESSAGE (protocol=${message.protocol}): ${message.payload.toString()}`)
   })
 
-  stream.on('request', (message: BtpMessage, replyCallback: (reply: BtpMessage | BtpError | Promise<BtpMessage | BtpError>) => void) => {
+  stream.on('request', (message: MessagePayload, replyCallback: (reply: MessagePayload | TransportError | Promise<MessagePayload | TransportError>) => void) => {
     console.log(`REQUEST (protocol=${message.protocol}): ${message.payload.toString()}`)
     replyCallback(new Promise((respond) => {
       setTimeout(() => {
         respond({
           protocol: 'ilp',
-          contentType: BtpMessageContentType.ApplicationOctetStream,
+          contentType: FrameContentType.ApplicationOctetStream,
           payload: Buffer.from('Goodbye!')
         })
       }, 100)

dist/example/server.js

@@ -0,0 +1,13 @@
+export interface AccountInfo {
+  relation: 'parent' | 'peer' | 'child',
+  assetCode: string,
+  assetScale: number,
+}
+
+/**
+ * An asset/currency including the code used to identify it (e.g. ISO4017 currency code) and scale
+ */
+export interface AssetInfo {
+  scale: number
+  code: string
+}

dist/example/server.js.map

@@ -1,47 +1,47 @@
-import { BtpErrorMessage } from './packet'
+import { ErrorPayload } from './packet'
 
-export enum BtpErrorCode {
+export enum TransportErrorCode {
   UnreachableError = 'T00', // Message can't be processed at this time
   NotAcceptedError = 'F00', // Generic error at remote
   Unauthorized = 'F01', // Connection has not been authorized, use a sub-protocol to auth
   DuplicateIdError = 'F02', // Same ID used for different messages
   UnknownProtocolError = 'F03', // Unrecognized sub-protocol
   UnknownCorrelationId = 'F04' // Got a response/error/ack with a correlation id that doesn't match any prev sent messages
 }
-export namespace BtpErrorCode {
-  export function getName (code: BtpErrorCode): string {
+export namespace TransportErrorCode {
+  export function getName (code: TransportErrorCode): string {
     switch (code) {
-      case BtpErrorCode.UnreachableError:
+      case TransportErrorCode.UnreachableError:
         return 'UnreachableError'
-      case BtpErrorCode.NotAcceptedError:
+      case TransportErrorCode.NotAcceptedError:
         return 'NotAcceptedError'
-      case BtpErrorCode.Unauthorized:
+      case TransportErrorCode.Unauthorized:
         return 'Unauthorized'
-      case BtpErrorCode.DuplicateIdError:
+      case TransportErrorCode.DuplicateIdError:
         return 'DuplicateIdError'
-      case BtpErrorCode.UnknownProtocolError:
+      case TransportErrorCode.UnknownProtocolError:
         return 'UnknownProtocolError'
-      case BtpErrorCode.UnknownCorrelationId:
+      case TransportErrorCode.UnknownCorrelationId:
         return 'UnknownCorrelationId'
     }
-    throw new Error('Unknown BtpErrorCode')
+    throw new Error('Unknown Error Code')
   }
 }
 
-export class BtpError extends Error {
-  constructor (code: BtpErrorCode, message?: string) {
+export class TransportError extends Error {
+  constructor (code: TransportErrorCode, message?: string) {
     super(`${code}: ${message}`)
-    Error.captureStackTrace(this, BtpError)
-    this.name = BtpErrorCode.getName(code)
+    Error.captureStackTrace(this, TransportError)
+    this.name = TransportErrorCode.getName(code)
   }
 }
 
-export function btpErrorFromMessage (message: BtpErrorMessage): BtpError {
-  return new BtpError(message.code, message.message)
+export function transportErrorFromMessage (message: ErrorPayload): TransportError {
+  return new TransportError(message.code, message.message)
 }
-export function btpErrorToString (error: BtpError) {
+export function transportErrorToString (error: TransportError) {
   return JSON.stringify({
-    code: `${BtpErrorCode[error.name]} ${error.name}`,
+    code: `${TransportErrorCode[error.name]} ${error.name}`,
     message: error.message,
     stack: error.stack || '-'
   })

src/example/client.ts

@@ -0,0 +1,44 @@
+import {
+  ClientDuplexStream,
+  loadPackageDefinition,
+  ServerDuplexStream,
+  ChannelCredentials,
+  ServiceError,
+  Metadata,
+  ServiceDefinition
+} from 'grpc'
+
+import { Frame } from './packet'
+
+const PROTO_PATH = __dirname + '/../../src/lib/transport.proto'
+const protoLoader = require('@grpc/proto-loader')
+const packageDefinition = protoLoader.loadSync(
+    PROTO_PATH,
+  {keepCase: true,
+    longs: String,
+    enums: String,
+    defaults: true,
+    oneofs: true
+  })
+const protoDescriptor = loadPackageDefinition(packageDefinition)
+export const TransportService = protoDescriptor.transport.TransportService as TransportService
+
+interface TransportService {
+  new (address: string, credentials: ChannelCredentials): TransportServiceInstance
+  service: ServiceDefinition<TransportServiceInstance>
+}
+
+export interface TransportServiceInstance {
+  Authenticate: (message: AuthMessage, callback: (error: ServiceError | null, responseMessage: AuthResponse | null) => void) => void
+  MessageStream: (meta: Metadata) => DuplexStream
+}
+
+export interface AuthMessage {
+  id: string
+}
+
+export interface AuthResponse {
+  id: string
+}
+
+export type DuplexStream = ClientDuplexStream< Frame, Frame> & ServerDuplexStream< Frame, Frame>