@vtex/api 6.45.4

package/README.md

@@ -0,0 +1,65 @@
+# VTEX IO API Client for Node
+
+This library enables developers to quickly integrate with the VTEX IO APIs and create full fledged node services using VTEX IO.
+
+[![Build Status](https://travis-ci.org/vtex/node-vtex-api.svg?branch=master)](https://travis-ci.org/vtex/node-vtex-api)
+
+## Getting started
+
+For a complete example on using `@vtex/api`, check out this app: https://github.com/vtex-apps/service-example
+
+The most basic usage is to export a new `Service()` with your route handlers:
+
+```javascript
+// Import global types
+import './globals'
+
+import { Service } from '@vtex/api'
+
+import { clients } from './clients'
+import example from './handlers/example'
+
+// Export a service that defines route handlers and client options.
+export default new Service({
+  clients,
+  routes: {
+    example,
+  },
+})
+```
+
+This allows you to define middlewares that receive a `Context` param which contains all IO Clients in the `clients` property:
+
+```javascript
+export const example = async (ctx: Context, next: () => Promise<void>) => {
+  const {state: {code}, clients: {apps}} = ctx
+  console.log('Received code:', code)
+
+  const apps = await apps.listApps()
+  
+  ctx.status = 200
+  ctx.body = apps
+  ctx.set('Cache-Control', 'private')
+
+  await next()
+}
+```
+
+`ctx.clients.apps` is an instance of `Apps`.
+
+## Development
+
+- Install the dependencies: `yarn`
+- Watch for changes: `yarn watch`
+
+### Development with IO clients
+
+- Install the dependencies: `yarn`
+- [Link](https://classic.yarnpkg.com/en/docs/cli/link/) this package: `yarn link`
+- Watch for changes: `yarn watch`
+- Move to the app that depends on the changes made on this package: `cd ../<your-app>/node`
+- Link this package to your app's node_modules: `yarn link @vtex/api`
+
+Now, when you get a workspace up and running for your app with `vtex link`, you'll have this package linked as well.
+
+> When done developing, don't forget to unlink it from `<your-app>/node`: `yarn unlink @vtex/api`

package/gen/manifest.schema

@@ -0,0 +1,189 @@
+{
+    "$schema": "http://json-schema.org/draft-07/schema#",
+    "definitions": {
+        "BILLING_TYPE": {
+            "enum": [
+                "billable",
+                "free",
+                "sponsored"
+            ],
+            "type": "string"
+        },
+        "BillingOptions": {
+            "properties": {
+                "availableCountries": {
+                    "items": {
+                        "type": "string"
+                    },
+                    "type": "array"
+                },
+                "plans": {
+                    "items": {
+                        "$ref": "#/definitions/Plan"
+                    },
+                    "type": "array"
+                },
+                "support": {
+                    "$ref": "#/definitions/Support"
+                },
+                "type": {
+                    "$ref": "#/definitions/BILLING_TYPE"
+                }
+            },
+            "type": "object"
+        },
+        "Plan": {
+            "properties": {
+                "currency": {
+                    "type": "string"
+                },
+                "id": {
+                    "type": "string"
+                },
+                "price": {
+                    "$ref": "#/definitions/Price"
+                }
+            },
+            "type": "object"
+        },
+        "Policy": {
+            "properties": {
+                "attrs": {
+                    "additionalProperties": {
+                        "type": "string"
+                    },
+                    "type": "object"
+                },
+                "name": {
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        },
+        "Price": {
+            "properties": {
+                "metrics": {
+                    "items": {
+                        "$ref": "#/definitions/PriceMetric"
+                    },
+                    "type": "array"
+                },
+                "subscription": {
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "PriceMetric": {
+            "properties": {
+                "customUrl": {
+                    "type": "string"
+                },
+                "id": {
+                    "type": "string"
+                },
+                "ranges": {
+                    "items": {
+                        "$ref": "#/definitions/Range"
+                    },
+                    "type": "array"
+                }
+            },
+            "type": "object"
+        },
+        "Range": {
+            "properties": {
+                "exclusiveFrom": {
+                    "type": "number"
+                },
+                "inclusiveTo": {
+                    "type": "number"
+                },
+                "multiplier": {
+                    "type": "number"
+                }
+            },
+            "type": "object"
+        },
+        "Support": {
+            "properties": {
+                "email": {
+                    "type": "string"
+                },
+                "phone": {
+                    "type": "string"
+                },
+                "url": {
+                    "type": "string"
+                }
+            },
+            "type": "object"
+        }
+    },
+    "properties": {
+        "billingOptions": {
+            "$ref": "#/definitions/BillingOptions"
+        },
+        "builders": {
+            "additionalProperties": {
+                "type": "string"
+            },
+            "type": "object"
+        },
+        "categories": {
+            "items": {
+                "type": "string"
+            },
+            "type": "array"
+        },
+        "credentialType": {
+            "type": "string"
+        },
+        "dependencies": {
+            "additionalProperties": {
+                "type": "string"
+            },
+            "type": "object"
+        },
+        "description": {
+            "type": "string"
+        },
+        "mustUpdateAt": {
+            "type": "string"
+        },
+        "name": {
+            "type": "string"
+        },
+        "peerDependencies": {
+            "additionalProperties": {
+                "type": "string"
+            },
+            "type": "object"
+        },
+        "policies": {
+            "items": {
+                "$ref": "#/definitions/Policy"
+            },
+            "type": "array"
+        },
+        "registries": {
+            "items": {
+                "type": "string"
+            },
+            "type": "array"
+        },
+        "settingsSchema": {
+        },
+        "title": {
+            "type": "string"
+        },
+        "vendor": {
+            "type": "string"
+        },
+        "version": {
+            "type": "string"
+        }
+    },
+    "type": "object"
+}
+

package/lib/HttpClient/GraphQLClient.d.ts

@@ -0,0 +1,28 @@
+import { GraphQLError } from 'graphql';
+import { HttpClient } from './HttpClient';
+import { RequestConfig } from './typings';
+interface QueryOptions<Variables extends object> {
+    query: string;
+    variables: Variables;
+    inflight?: boolean;
+    throwOnError?: boolean;
+    extensions?: Record<string, any>;
+}
+interface MutateOptions<Variables extends object> {
+    mutate: string;
+    variables: Variables;
+    throwOnError?: boolean;
+}
+export declare type Serializable = object | boolean | string | number;
+export interface GraphQLResponse<T extends Serializable> {
+    data?: T;
+    errors?: GraphQLError[];
+    extensions?: Record<string, any>;
+}
+export declare class GraphQLClient {
+    private http;
+    constructor(http: HttpClient);
+    query: <Data extends Serializable, Variables extends object>({ query, variables, inflight, extensions, throwOnError }: QueryOptions<Variables>, config?: RequestConfig) => Promise<GraphQLResponse<Data>>;
+    mutate: <Data extends Serializable, Variables extends object>({ mutate, variables, throwOnError }: MutateOptions<Variables>, config?: RequestConfig) => Promise<GraphQLResponse<Data>>;
+}
+export {};

package/lib/HttpClient/GraphQLClient.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const customGraphQLError_1 = __importDefault(require("../errors/customGraphQLError"));
+const inflight_1 = require("./middlewares/inflight");
+const throwOnGraphQLErrors = (message, response) => {
+    if (response && response.errors && response.errors.length > 0) {
+        throw new customGraphQLError_1.default(message, response.errors);
+    }
+    return response;
+};
+class GraphQLClient {
+    constructor(http) {
+        this.http = http;
+        this.query = ({ query, variables, inflight, extensions, throwOnError }, config = {}) => this.http.getWithBody(config.url || '', { query, variables, extensions }, {
+            inflightKey: inflight !== false ? inflight_1.inflightUrlWithQuery : undefined,
+            ...config,
+        })
+            .then(graphqlResponse => throwOnError === false
+            ? graphqlResponse
+            : throwOnGraphQLErrors(this.http.name, graphqlResponse));
+        this.mutate = ({ mutate, variables, throwOnError }, config = {}) => this.http.post(config.url || '', { query: mutate, variables }, config)
+            .then(graphqlResponse => throwOnError === false
+            ? graphqlResponse
+            : throwOnGraphQLErrors(this.http.name, graphqlResponse));
+    }
+}
+exports.GraphQLClient = GraphQLClient;

package/lib/HttpClient/HttpClient.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { AxiosResponse } from 'axios';
+import { IncomingMessage } from 'http';
+import { IOContext } from '../service/worker/runtime/typings';
+import { InstanceOptions, IOResponse, RequestConfig } from './typings';
+declare type ClientOptions = IOContext & Partial<InstanceOptions>;
+export declare class HttpClient {
+    name: string;
+    private runMiddlewares;
+    constructor(opts: ClientOptions);
+    get: <T = any>(url: string, config?: RequestConfig) => Promise<T>;
+    getRaw: <T = any>(url: string, config?: RequestConfig) => Promise<IOResponse<T>>;
+    getWithBody: <T = any>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
+    getBuffer: (url: string, config?: RequestConfig) => Promise<{
+        data: Buffer;
+        headers: any;
+    }>;
+    getStream: (url: string, config?: RequestConfig) => Promise<IncomingMessage>;
+    put: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
+    putRaw: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<IOResponse<T>>;
+    post: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
+    postRaw: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<IOResponse<T>>;
+    patch: <T = void>(url: string, data?: any, config?: RequestConfig) => Promise<T>;
+    head: (url: string, config?: RequestConfig) => Promise<IOResponse<void>>;
+    delete: <T = void>(url: string, config?: RequestConfig | undefined) => Promise<IOResponse<T>>;
+    protected request: (config: RequestConfig) => Promise<AxiosResponse<any>>;
+    private getConfig;
+}
+export {};

package/lib/HttpClient/HttpClient.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const crypto_1 = require("crypto");
+const koa_compose_1 = __importDefault(require("koa-compose"));
+const p_limit_1 = __importDefault(require("p-limit"));
+const constants_1 = require("../constants");
+const binding_1 = require("../utils/binding");
+const tenant_1 = require("../utils/tenant");
+const cache_1 = require("./middlewares/cache");
+const cancellationToken_1 = require("./middlewares/cancellationToken");
+const inflight_1 = require("./middlewares/inflight");
+const memoization_1 = require("./middlewares/memoization");
+const metrics_1 = require("./middlewares/metrics");
+const notFound_1 = require("./middlewares/notFound");
+const recorder_1 = require("./middlewares/recorder");
+const request_1 = require("./middlewares/request");
+const tracing_1 = require("./middlewares/tracing");
+const DEFAULT_TIMEOUT_MS = 1000;
+const noTransforms = [(data) => data];
+class HttpClient {
+    constructor(opts) {
+        this.get = (url, config = {}) => {
+            const cacheableConfig = this.getConfig(url, config);
+            return this.request(cacheableConfig).then(response => response.data);
+        };
+        this.getRaw = (url, config = {}) => {
+            const cacheableConfig = this.getConfig(url, config);
+            return this.request(cacheableConfig);
+        };
+        this.getWithBody = (url, data, config = {}) => {
+            const bodyHash = crypto_1.createHash('md5').update(JSON.stringify(data)).digest('hex');
+            const cacheableConfig = this.getConfig(url, {
+                ...config,
+                data,
+                params: {
+                    ...config.params,
+                    [constants_1.BODY_HASH]: bodyHash,
+                },
+            });
+            return this.request(cacheableConfig).then(response => response.data);
+        };
+        this.getBuffer = (url, config = {}) => {
+            const bufferConfig = { cacheable: cache_1.CacheType.Disk, ...config, url, responseType: 'arraybuffer', transformResponse: noTransforms };
+            return this.request(bufferConfig);
+        };
+        this.getStream = (url, config = {}) => {
+            const streamConfig = { ...config, url, responseType: 'stream', transformResponse: noTransforms };
+            return this.request(streamConfig).then(response => response.data);
+        };
+        this.put = (url, data, config = {}) => {
+            const putConfig = { ...config, url, data, method: 'put' };
+            return this.request(putConfig).then(response => response.data);
+        };
+        this.putRaw = (url, data, config = {}) => {
+            const putConfig = { ...config, url, data, method: 'put' };
+            return this.request(putConfig);
+        };
+        this.post = (url, data, config = {}) => {
+            const postConfig = { ...config, url, data, method: 'post' };
+            return this.request(postConfig).then(response => response.data);
+        };
+        this.postRaw = (url, data, config = {}) => {
+            const postConfig = { ...config, url, data, method: 'post' };
+            return this.request(postConfig);
+        };
+        this.patch = (url, data, config = {}) => {
+            const patchConfig = { ...config, url, data, method: 'patch' };
+            return this.request(patchConfig).then(response => response.data);
+        };
+        this.head = (url, config = {}) => {
+            const headConfig = { ...config, url, method: 'head' };
+            return this.request(headConfig);
+        };
+        this.delete = (url, config) => {
+            const deleteConfig = { ...config, url, method: 'delete' };
+            return this.request(deleteConfig);
+        };
+        this.request = async (config) => {
+            const context = { config };
+            await this.runMiddlewares(context);
+            return context.response;
+        };
+        this.getConfig = (url, config = {}) => ({
+            cacheable: cache_1.CacheType.Memory,
+            memoizable: true,
+            ...config,
+            url,
+        });
+        const { baseURL, authToken, authType, memoryCache, diskCache, locale, name, metrics, product, serverTiming, recorder, userAgent, timeout = DEFAULT_TIMEOUT_MS, segmentToken, sessionToken, retries, concurrency, headers: defaultHeaders, host, params, operationId, tenant, binding, verbose, cancellation, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent, tracer, logger, } = opts;
+        this.name = name || baseURL || 'unknown';
+        const limit = concurrency && concurrency > 0 && p_limit_1.default(concurrency) || undefined;
+        const headers = {
+            ...defaultHeaders,
+            'Accept-Encoding': 'gzip',
+            'User-Agent': userAgent,
+            ...host ? { [constants_1.FORWARDED_HOST_HEADER]: host } : null,
+            ...tenant ? { [constants_1.TENANT_HEADER]: tenant_1.formatTenantHeaderValue(tenant) } : null,
+            ...binding ? { [constants_1.BINDING_HEADER]: binding_1.formatBindingHeaderValue(binding) } : null,
+            ...locale ? { [constants_1.LOCALE_HEADER]: locale } : null,
+            ...operationId ? { 'x-vtex-operation-id': operationId } : null,
+            ...product ? { [constants_1.PRODUCT_HEADER]: product } : null,
+            ...segmentToken ? { [constants_1.SEGMENT_HEADER]: segmentToken } : null,
+            ...sessionToken ? { [constants_1.SESSION_HEADER]: sessionToken } : null,
+        };
+        if (authType && authToken) {
+            headers['Authorization'] = `${authType} ${authToken}`; // tslint:disable-line
+        }
+        const memoizedCache = new Map();
+        this.runMiddlewares = koa_compose_1.default([
+            tracing_1.createHttpClientTracingMiddleware({ tracer, logger, clientName: this.name, hasDiskCacheMiddleware: !!diskCache, hasMemoryCacheMiddleware: !!memoryCache }),
+            ...(opts.middlewares || []),
+            request_1.defaultsMiddleware({ baseURL, rawHeaders: headers, params, timeout, retries, verbose, exponentialTimeoutCoefficient, initialBackoffDelay, exponentialBackoffCoefficient, httpsAgent }),
+            metrics_1.metricsMiddleware({ metrics, serverTiming, name }),
+            memoization_1.memoizationMiddleware({ memoizedCache }),
+            ...recorder ? [recorder_1.recorderMiddleware(recorder)] : [],
+            cancellationToken_1.cancellationToken(cancellation),
+            inflight_1.singleFlightMiddleware,
+            notFound_1.acceptNotFoundMiddleware,
+            ...memoryCache ? [cache_1.cacheMiddleware({ type: cache_1.CacheType.Memory, storage: memoryCache })] : [],
+            ...diskCache ? [cache_1.cacheMiddleware({ type: cache_1.CacheType.Disk, storage: diskCache })] : [],
+            notFound_1.notFoundFallbackMiddleware,
+            request_1.routerCacheMiddleware,
+            request_1.requestMiddleware(limit),
+        ]);
+    }
+}
+exports.HttpClient = HttpClient;