feat: parse, transform and validate response from sellers endpoint

package.json

@@ -29,8 +29,9 @@
   "dependencies": {
     "@scaleleap/amazon-marketplaces": "^4.0.2",
     "@sinclair/typebox": "^0.9.13",
+    "ajv": "^6.12.2",
     "axios": "^0.19.2",
-    "xml2js": "^0.4.23"
+    "fast-xml-parser": "^3.16.0"
   },
   "devDependencies": {
     "@scaleleap/config": "1.6.1",

src/http.ts

@@ -1,7 +1,7 @@
 import { AmazonMarketplace } from '@scaleleap/amazon-marketplaces'
 import axios from 'axios'
+import parser from 'fast-xml-parser'
 import { URLSearchParams } from 'url'
-import { parseString } from 'xml2js'
 
 import { sign } from './sign'
 
@@ -47,18 +47,8 @@ const canonicalizeParameters = (parameters: Parameters): string => {
   return sp.toString().replace(/\+/g, '%20')
 }
 
-const defaultFetch = <T>({ url, method, headers, data }: Request) =>
-  axios({ method, url, headers, data }).then(
-    (response) =>
-      new Promise<T>((resolve, reject) =>
-        parseString(response.data, (error, result) => {
-          if (error) {
-            reject(error)
-          }
-          resolve(result)
-        }),
-      ),
-  )
+const defaultFetch = <T>({ url, method, headers, data }: Request): Promise<T> =>
+  axios({ method, url, headers, data }).then((response) => parser.parse(response.data))
 
 export class HttpClient {
   constructor(

src/parsing.ts

@@ -0,0 +1,14 @@
+/** A collection of parsing utils */
+
+export const ensureArray = <T>(x: T | T[]): T[] => (Array.isArray(x) ? x : [x])
+
+export const parseBoolean = (x: 'Yes' | 'No'): boolean => {
+  switch (x) {
+    case 'Yes':
+      return true
+    case 'No':
+      return false
+    default:
+      throw new Error('TODO, but should be library-specific error')
+  }
+}

src/sections/sellers.ts

@@ -1,47 +1,106 @@
+import { Type } from '@sinclair/typebox'
+import Ajv from 'ajv'
+
 import { HttpClient, Resource } from '../http'
+import { ensureArray, parseBoolean } from '../parsing'
 
-interface MarketplaceParticipations {
+interface MarketplaceParticipationsResponse {
   ListMarketplaceParticipationsResponse: {
-    ListMarketplaceParticipationsResult: [
-      {
-        NextToken: [string]
-        ListParticipations: Array<{
-          Participation: [
-            {
-              MarketplaceId: [string]
-              SellerId: [string]
-              HasSellerSuspendedListings: [string]
-            },
-          ]
+    ListMarketplaceParticipationsResult: {
+      NextToken: string
+      ListParticipations: {
+        Participation: Array<{
+          MarketplaceId: string
+          SellerId: string
+          HasSellerSuspendedListings: 'Yes' | 'No'
         }>
-        ListMarketplaces: Array<{
-          Marketplace: [
-            {
-              MarketplaceId: [string]
-              Name: [string]
-              DefaultCountryCode: [string]
-              DefaultCurrencyCode: [string]
-              DefaultLanguageCode: [string]
-              DomainName: [string]
-            },
-          ]
+      }
+      ListMarketplaces: {
+        Marketplace: Array<{
+          MarketplaceId: string
+          Name: string
+          DefaultCountryCode: string
+          DefaultCurrencyCode: string
+          DefaultLanguageCode: string
+          DomainName: string
         }>
-      },
-    ]
-    ResponseMetadata: [{ RequestId: [string] }]
+      }
+    }
+    ResponseMetadata: { RequestId: string }
   }
 }
 
+const MarketplaceParticipations = Type.Object({
+  participations: Type.Array(
+    Type.Object({
+      marketplaceId: Type.String(),
+      sellerId: Type.String(),
+      hasSellerSuspendedListings: Type.Boolean(),
+    }),
+  ),
+  marketplaces: Type.Array(
+    Type.Object({
+      marketplaceId: Type.String(),
+      name: Type.String(),
+      defaultCountryCode: Type.String(),
+      defaultCurrencyCode: Type.String(),
+      defaultLanguageCode: Type.String(),
+      domainName: Type.String(),
+    }),
+  ),
+})
+
+// Unfortunately typebox creates an ugly type from Static<typeof X> (not a regular object with keys),
+// it's not something that we can expose from this library, so I've added a manually created interface
+interface MarketplaceParticipations {
+  participations: Array<{
+    marketplaceId: string
+    sellerId: string
+    hasSellerSuspendedListings: boolean
+  }>
+  marketplaces: Array<{
+    marketplaceId: string
+    name: string
+    defaultCountryCode: string
+    defaultCurrencyCode: string
+    defaultLanguageCode: string
+    domainName: string
+  }>
+}
+
 export class Sellers {
   constructor(private httpClient: HttpClient) {}
 
-  // TODO: transform response
-  async listMarketplaceParticipations() {
-    return this.httpClient.request('POST', {
+  async listMarketplaceParticipations(): Promise<MarketplaceParticipations> {
+    const response: MarketplaceParticipationsResponse = await this.httpClient.request('POST', {
       resource: Resource.Sellers,
       version: '2011-07-01',
       action: 'ListMarketplaceParticipations',
       parameters: {},
     })
+
+    const data = response.ListMarketplaceParticipationsResponse.ListMarketplaceParticipationsResult
+
+    const result: MarketplaceParticipations = {
+      participations: ensureArray(data.ListParticipations.Participation).map((x) => ({
+        marketplaceId: x.MarketplaceId,
+        sellerId: x.SellerId,
+        hasSellerSuspendedListings: parseBoolean(x.HasSellerSuspendedListings),
+      })),
+      marketplaces: ensureArray(data.ListMarketplaces.Marketplace).map((x) => ({
+        marketplaceId: x.MarketplaceId,
+        name: x.Name,
+        defaultCountryCode: x.DefaultCountryCode,
+        defaultCurrencyCode: x.DefaultCurrencyCode,
+        defaultLanguageCode: x.DefaultLanguageCode,
+        domainName: x.DomainName,
+      })),
+    }
+
+    if (new Ajv().validate(MarketplaceParticipations, result)) {
+      return result
+    }
+
+    throw new Error('TODO for now')
   }
 }