4165011940

Build # 4165011940

Build Type

github

Committed by GitHub

Commit Message

Merge 0a2c0d626 into cc2748e68

Pull Request Pull Request #96: SDK refactoring for dogfooding

Run Details

38 of 56 branches covered (67.86%)

Branch coverage included in aggregate %.

89 of 89 new or added lines in 7 files covered. (100.0%)

112 of 129 relevant lines covered (86.82%)

3.38 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

72.73

/src/api/order-book/api.ts

import {
  Address,
  BaseHttpRequest,
  CancelablePromise,
  DefaultService,
  OpenAPIConfig,
  OrderBookClient,
  OrderCancellation,
  OrderCreation,
  OrderPostError,
  OrderQuoteRequest,
  OrderQuoteResponse,
  Trade,
  TransactionHash,
  UID,
} from './generated'
import { CowError } from '../../common/cow-error'
import { SupportedChainId } from '../../common/chains'
import { EnvConfig, PROD_CONFIG, STAGING_CONFIG } from '../../common/configs'
import { transformOrder } from './transformOrder'
import { EnrichedOrder } from './types'
import { ApiRequestOptions } from './generated/core/ApiRequestOptions'
import { request as __request } from './generated/core/request'

class FetchHttpRequest extends BaseHttpRequest {
  constructor(config: OpenAPIConfig) {
    super(config)
  }

  /**
   * Request method
   * @param options The request options from the service
   * @returns CancelablePromise<T>
   * @throws ApiError
   */
  public override request<T>(options: ApiRequestOptions): CancelablePromise<T> {
    return __request(this.config, {
      ...options,
      headers: {
        ...options.headers,
        'Content-Type': 'application/json',
      },
    })
  }
}

export class OrderBookApi {
  private envConfig: EnvConfig
  private service: DefaultService

  constructor(chainId: SupportedChainId, env: 'prod' | 'staging' = 'prod') {
    this.envConfig = (env === 'prod' ? PROD_CONFIG : STAGING_CONFIG)[chainId]

    this.service = new OrderBookClient({ BASE: this.envConfig.apiUrl }, FetchHttpRequest).default
  }

  getTrades({ owner, orderId }: { owner?: Address; orderId?: UID }): CancelablePromise<Array<Trade>> {
    if (owner && orderId) {
      return new CancelablePromise((resolve, reject) => {
        reject(new CowError('Cannot specify both owner and orderId'))
      })
    }

    return this.service.getApiV1Trades(owner, orderId)
  }

  getOrders({
    owner,
    offset = 0,
    limit = 1000,
  }: {
    owner: Address
    offset?: number
    limit?: number
  }): Promise<Array<EnrichedOrder>> {
    return this.service.getApiV1AccountOrders(owner, offset, limit).then((orders) => {
      return orders.map(transformOrder)
    })
  }

  getTxOrders(txHash: TransactionHash): Promise<Array<EnrichedOrder>> {
    return this.service.getApiV1TransactionsOrders(txHash).then((orders) => {
      return orders.map(transformOrder)
    })
  }

  getOrder(uid: UID): Promise<EnrichedOrder> {
    return this.service.getApiV1Orders(uid).then((order) => {
      return transformOrder(order)
    })
  }

  getQuote(requestBody: OrderQuoteRequest): CancelablePromise<OrderQuoteResponse> {
    return this.service.postApiV1Quote(requestBody)
  }

  sendSignedOrderCancellation(uid: UID, requestBody: OrderCancellation): CancelablePromise<void> {
    return this.service.deleteApiV1Orders1(uid, requestBody)
  }

  sendOrder(requestBody: OrderCreation): Promise<UID> {
    return this.service.postApiV1Orders(requestBody).catch((error) => {
      const body: OrderPostError = error.body

      if (body?.errorType) {
        throw new Error(body.errorType)
      }

      throw error
    })
  }

  getOrderLink(uid: UID): string {
    return this.envConfig.apiUrl + `/api/v1/orders/${uid}`
  }
}

1	import {
2	Address,
3	BaseHttpRequest,
4	CancelablePromise,
5	DefaultService,
6	OpenAPIConfig,
7	OrderBookClient,
8	OrderCancellation,
9	OrderCreation,
10	OrderPostError,
11	OrderQuoteRequest,
12	OrderQuoteResponse,
13	Trade,
14	TransactionHash,
15	UID,
16	} from './generated'
17	import { CowError } from '../../common/cow-error'
18	import { SupportedChainId } from '../../common/chains'
19	import { EnvConfig, PROD_CONFIG, STAGING_CONFIG } from '../../common/configs'
20	import { transformOrder } from './transformOrder'
21	import { EnrichedOrder } from './types'
22	import { ApiRequestOptions } from './generated/core/ApiRequestOptions'
23	import { request as __request } from './generated/core/request'
24
25	class FetchHttpRequest extends BaseHttpRequest {
26	constructor(config: OpenAPIConfig) {
27	super(config)	1✔
28	}
29
30	/**
31	* Request method
32	* @param options The request options from the service
33	* @returns CancelablePromise<T>
34	* @throws ApiError
35	*/
36	public override request<T>(options: ApiRequestOptions): CancelablePromise<T> {
37	return __request(this.config, {	19✔
38	...options,
39	headers: {
40	...options.headers,
41	'Content-Type': 'application/json',
42	},
43	})
44	}
45	}
46
47	export class OrderBookApi {
48	private envConfig: EnvConfig
49	private service: DefaultService
50
51	constructor(chainId: SupportedChainId, env: 'prod' \| 'staging' = 'prod') {	1✔
52	this.envConfig = (env === 'prod' ? PROD_CONFIG : STAGING_CONFIG)[chainId]	1!
53
54	this.service = new OrderBookClient({ BASE: this.envConfig.apiUrl }, FetchHttpRequest).default	1✔
55	}
56
57	getTrades({ owner, orderId }: { owner?: Address; orderId?: UID }): CancelablePromise<Array<Trade>> {
58	if (owner && orderId) {	5✔
59	return new CancelablePromise((resolve, reject) => {	1✔
60	reject(new CowError('Cannot specify both owner and orderId'))	1✔
61	})
62	}
63
64	return this.service.getApiV1Trades(owner, orderId)	4✔
65	}
66
67	getOrders({
68	owner,
69	offset = 0,	×
70	limit = 1000,	×
71	}: {
72	owner: Address
73	offset?: number
74	limit?: number
75	}): Promise<Array<EnrichedOrder>> {
76	return this.service.getApiV1AccountOrders(owner, offset, limit).then((orders) => {	4✔
77	return orders.map(transformOrder)	×
78	})
79	}
80
81	getTxOrders(txHash: TransactionHash): Promise<Array<EnrichedOrder>> {
82	return this.service.getApiV1TransactionsOrders(txHash).then((orders) => {	3✔
83	return orders.map(transformOrder)	×
84	})
85	}
86
87	getOrder(uid: UID): Promise<EnrichedOrder> {
88	return this.service.getApiV1Orders(uid).then((order) => {	4✔
89	return transformOrder(order)	×
90	})
91	}
92
93	getQuote(requestBody: OrderQuoteRequest): CancelablePromise<OrderQuoteResponse> {
94	return this.service.postApiV1Quote(requestBody)	×
95	}
96
97	sendSignedOrderCancellation(uid: UID, requestBody: OrderCancellation): CancelablePromise<void> {
98	return this.service.deleteApiV1Orders1(uid, requestBody)	2✔
99	}
100
101	sendOrder(requestBody: OrderCreation): Promise<UID> {
102	return this.service.postApiV1Orders(requestBody).catch((error) => {	2✔
103	const body: OrderPostError = error.body	2✔
104
105	if (body?.errorType) {	2!
106	throw new Error(body.errorType)	×
107	}
108
109	throw error	2✔
110	})
111	}
112
113	getOrderLink(uid: UID): string {
114	return this.envConfig.apiUrl + `/api/v1/orders/${uid}`	1✔
115	}
116	}

cowprotocol / cow-sdk / 4165011940

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous