@vtex/api 1.9.1-beta → 1.9.3

package/lib/HttpClient/index.js

@@ -1,122 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const compose = require("koa-compose");
-const cache_1 = require("./middlewares/cache");
-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 DEFAULT_TIMEOUT_MS = 10000;
-const noTransforms = [(data) => data];
-const rootURL = (service, { region }, { endpoint }) => {
-    if (endpoint) {
-        return 'http://' + endpoint;
-    }
-    if (region) {
-        return `http://${service}.${region}.vtex.io`;
-    }
-    throw new Error('Missing required: should specify either {region} or {endpoint}');
-};
-const workspaceURL = (service, context, opts) => {
-    const { account, workspace } = context;
-    if (!account || !workspace) {
-        throw new Error('Missing required arguments: {account, workspace}');
-    }
-    return rootURL(service, context, opts) + `/${account}/${workspace}`;
-};
-class HttpClient {
-    constructor(opts) {
-        this.get = (url, config = {}) => {
-            const cacheableConfig = Object.assign({}, config, { url, cacheable: true });
-            return this.request(cacheableConfig).then(response => response.data);
-        };
-        this.getRaw = (url, config = {}) => {
-            const cacheableConfig = Object.assign({}, config, { url, cacheable: true });
-            return this.request(cacheableConfig);
-        };
-        this.getBuffer = (url, config = {}) => {
-            const bufferConfig = Object.assign({}, config, { url, responseType: 'arraybuffer', transformResponse: noTransforms });
-            return this.request(bufferConfig);
-        };
-        this.getStream = (url, config = {}) => {
-            const streamConfig = Object.assign({}, config, { url, responseType: 'stream', transformResponse: noTransforms });
-            return this.request(streamConfig).then(response => response.data);
-        };
-        this.put = (url, data, config = {}) => {
-            const putConfig = Object.assign({}, config, { url, data, method: 'put' });
-            return this.request(putConfig).then(response => response.data);
-        };
-        this.post = (url, data, config = {}) => {
-            const postConfig = Object.assign({}, config, { url, data, method: 'post' });
-            return this.request(postConfig).then(response => response.data);
-        };
-        this.postRaw = (url, data, config = {}) => {
-            const postConfig = Object.assign({}, config, { url, data, method: 'post' });
-            return this.request(postConfig);
-        };
-        this.patch = (url, data, config = {}) => {
-            const patchConfig = Object.assign({}, config, { url, data, method: 'patch' });
-            return this.request(patchConfig).then(response => response.data);
-        };
-        this.delete = (url, config) => {
-            const deleteConfig = Object.assign({}, config, { url, method: 'delete' });
-            return this.request(deleteConfig);
-        };
-        this.request = (config) => __awaiter(this, void 0, void 0, function* () {
-            const context = { config };
-            yield this.runMiddlewares(context);
-            console.error('finished middlewares, returning response =', context.response);
-            return context.response;
-        });
-        const { baseURL, authToken, authType, cacheStorage, metrics, recorder, userAgent, timeout = DEFAULT_TIMEOUT_MS, segmentToken } = opts;
-        const headers = {
-            'Accept-Encoding': 'gzip',
-            'User-Agent': userAgent,
-        };
-        if (authType && authToken) {
-            headers['Authorization'] = `${authType} ${authToken}`; // tslint:disable-line
-        }
-        this.runMiddlewares = compose([
-            request_1.defaultsMiddleware(baseURL, headers, timeout),
-            ...recorder ? [recorder_1.recorderMiddleware(recorder)] : [],
-            notFound_1.acceptNotFoundMiddleware,
-            ...cacheStorage ? [cache_1.cacheMiddleware({ cacheStorage, segmentToken: segmentToken || '' })] : [],
-            notFound_1.notFoundFallbackMiddleware,
-            ...metrics ? [metrics_1.metricsMiddleware(metrics)] : [],
-            request_1.requestMiddleware,
-        ]);
-    }
-    static forWorkspace(service, context, opts) {
-        const { authToken, userAgent, recorder, segmentToken, sessionToken } = context;
-        const { timeout, cacheStorage } = opts;
-        const baseURL = workspaceURL(service, context, opts);
-        return new HttpClient({ baseURL, authType: AuthType.bearer, authToken, userAgent, timeout, recorder, cacheStorage, segmentToken, sessionToken });
-    }
-    static forRoot(service, context, opts) {
-        const { authToken, userAgent, recorder, segmentToken, sessionToken } = context;
-        const { timeout, cacheStorage } = opts;
-        const baseURL = rootURL(service, context, opts);
-        return new HttpClient({ baseURL, authType: AuthType.bearer, authToken, userAgent, timeout, recorder, cacheStorage, segmentToken, sessionToken });
-    }
-    static forLegacy(endpoint, opts) {
-        const { authToken, userAgent, timeout, cacheStorage } = opts;
-        return new HttpClient({ baseURL: endpoint, authType: AuthType.token, authToken, userAgent, timeout, cacheStorage });
-    }
-}
-exports.HttpClient = HttpClient;
-exports.withoutRecorder = (ioContext) => {
-    return Object.assign({}, ioContext, { recorder: undefined });
-};
-var AuthType;
-(function (AuthType) {
-    AuthType["bearer"] = "bearer";
-    AuthType["token"] = "token";
-})(AuthType || (AuthType = {}));

package/lib/HttpClient/middlewares/cache.d.ts

@@ -1,16 +0,0 @@
-import { AxiosRequestConfig, AxiosResponse } from 'axios';
-import { CacheLayer } from '../../caches/CacheLayer';
-import { MiddlewareContext } from '../context';
-export declare const cacheMiddleware: ({ cacheStorage, segmentToken }: {
-    cacheStorage: CacheLayer<string, Cached>;
-    segmentToken: string;
-}) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
-export interface Cached {
-    etag: string;
-    expiration: number;
-    response: Partial<AxiosResponse>;
-}
-export declare type CacheableRequestConfig = AxiosRequestConfig & {
-    url: string;
-    cacheable: boolean;
-};

package/lib/HttpClient/middlewares/cache.js

@@ -1,86 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const url_1 = require("url");
-const cacheKey = (config) => {
-    const { baseURL = '', url = '', params } = config;
-    const fullURL = [baseURL, url].filter(str => str).join('/');
-    const urlObject = new url_1.URL(fullURL);
-    const searchParams = new url_1.URLSearchParams(params);
-    urlObject.search = searchParams.toString();
-    return urlObject.toString();
-};
-const parseCacheHeaders = (headers) => {
-    const { 'cache-control': cacheControl = '', etag, age: ageStr } = headers;
-    const cacheDirectives = cacheControl.split(',').map(d => d.trim());
-    const maxAgeDirective = cacheDirectives.find(d => d.startsWith('max-age'));
-    const [, maxAgeStr] = maxAgeDirective ? maxAgeDirective.split('=') : [null, null];
-    const maxAge = maxAgeStr ? parseInt(maxAgeStr, 10) : 0;
-    const age = ageStr ? parseInt(ageStr, 10) : 0;
-    return {
-        age,
-        etag,
-        maxAge,
-        noCache: cacheDirectives.indexOf('no-cache') !== -1,
-        noStore: cacheDirectives.indexOf('no-store') !== -1,
-    };
-};
-function isCacheable(arg) {
-    return arg && arg.cacheable;
-}
-const addNotModified = (validateStatus) => (status) => validateStatus(status) || status === 304;
-exports.cacheMiddleware = ({ cacheStorage, segmentToken }) => {
-    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-        console.error('cacheMiddleware');
-        if (!isCacheable(ctx.config)) {
-            return yield next();
-        }
-        const key = cacheKey(ctx.config);
-        const keyWithSegment = key + segmentToken;
-        const cacheHasWithSegment = yield cacheStorage.has(keyWithSegment);
-        const cached = cacheHasWithSegment ? yield cacheStorage.get(keyWithSegment) : yield cacheStorage.get(key);
-        if (cached) {
-            const { etag: cachedEtag, response, expiration } = cached;
-            if (expiration > Date.now() && response) {
-                ctx.response = response;
-                return;
-            }
-            const validateStatus = addNotModified(ctx.config.validateStatus);
-            if (cachedEtag && validateStatus(response.status)) {
-                ctx.config.headers['if-none-match'] = cachedEtag;
-                ctx.config.validateStatus = validateStatus;
-            }
-        }
-        yield next();
-        if (!ctx.response) {
-            return;
-        }
-        const revalidated = ctx.response.status === 304;
-        if (revalidated && cached) {
-            ctx.response = cached.response;
-        }
-        const { data, headers, status } = ctx.response;
-        const { age, etag, maxAge, noStore } = parseCacheHeaders(headers);
-        if (noStore && !etag) {
-            return;
-        }
-        if (maxAge || etag) {
-            const currentAge = revalidated ? 0 : age;
-            const varySegment = ctx.response.headers.vary.includes('x-vtex-segment');
-            const setKey = varySegment ? keyWithSegment : key;
-            yield cacheStorage.set(setKey, {
-                etag,
-                expiration: Date.now() + (maxAge - currentAge) * 1000,
-                response: { data, headers, status },
-            });
-            return;
-        }
-    });
-};

package/lib/HttpClient/middlewares/metrics.d.ts

@@ -1,3 +0,0 @@
-import { MetricsAccumulator } from '../../metrics/metricsAccumulator';
-import { MiddlewareContext } from '../context';
-export declare const metricsMiddleware: (metrics: MetricsAccumulator) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;

package/lib/HttpClient/middlewares/metrics.js

@@ -1,42 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const statusLabel = (status) => `${Math.floor(status / 100)}xx`;
-exports.metricsMiddleware = (metrics) => {
-    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-        console.error('metricsMiddleware');
-        const start = ctx.config.metric && process.hrtime();
-        const production = ctx.config.production || false;
-        let status;
-        try {
-            yield next();
-            if (ctx.response && ctx.response.status && ctx.config.metric) {
-                status = statusLabel(ctx.response.status);
-            }
-        }
-        catch (err) {
-            if (err.response && err.response.status && ctx.config.metric) {
-                status = statusLabel(err.response.status);
-            }
-            else if (err.code === 'ECONNABORTED') {
-                status = 'timeout';
-            }
-            else {
-                status = 'error';
-            }
-            throw err;
-        }
-        finally {
-            if (ctx.config.metric) {
-                metrics.batchHrTimeMetric(`http-client-${ctx.config.metric}-${status}`, start, production);
-            }
-        }
-    });
-};

package/lib/HttpClient/middlewares/notFound.d.ts

@@ -1,7 +0,0 @@
-import { AxiosRequestConfig } from 'axios';
-import { MiddlewareContext } from '../context';
-export declare const acceptNotFoundMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
-export declare const notFoundFallbackMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
-export declare type IgnoreNotFoundRequestConfig = AxiosRequestConfig & {
-    nullIfNotFound?: boolean;
-};

package/lib/HttpClient/middlewares/notFound.js

@@ -1,30 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const addNotFound = (validateStatus) => (status) => validateStatus(status) || status === 404;
-function nullIfNotFound(config) {
-    return config && config.nullIfNotFound;
-}
-exports.acceptNotFoundMiddleware = (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-    console.error('acceptNotFoundMiddleware');
-    const { config } = ctx;
-    if (nullIfNotFound(config)) {
-        ctx.config.validateStatus = addNotFound(config.validateStatus);
-    }
-    yield next();
-});
-exports.notFoundFallbackMiddleware = (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-    console.error('notFoundFallbackMiddleware');
-    yield next();
-    const { config } = ctx;
-    if (nullIfNotFound(config) && ctx.response && ctx.response.status === 404) {
-        ctx.response.data = null;
-    }
-});

package/lib/HttpClient/middlewares/recorder.d.ts

@@ -1,3 +0,0 @@
-import { MiddlewareContext } from '../context';
-export declare const recorderMiddleware: (recorder: Recorder) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
-export declare type Recorder = (headers: any) => void;

package/lib/HttpClient/middlewares/recorder.js

@@ -1,27 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.recorderMiddleware = (recorder) => {
-    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-        console.error('recorderMiddleware');
-        try {
-            yield next();
-            if (ctx.response) {
-                recorder(ctx.response.headers);
-            }
-        }
-        catch (err) {
-            if (err.response && err.response.headers && err.response.status === 404) {
-                recorder(err.response.headers);
-            }
-            throw err;
-        }
-    });
-};

package/lib/HttpClient/middlewares/request.d.ts

@@ -1,3 +0,0 @@
-import { MiddlewareContext } from '../context';
-export declare const defaultsMiddleware: (baseURL: string | undefined, headers: Record<string, string>, timeout: number) => (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;
-export declare const requestMiddleware: (ctx: MiddlewareContext, next: () => Promise<void>) => Promise<void>;

package/lib/HttpClient/middlewares/request.js

@@ -1,41 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const axios_1 = require("axios");
-const retry = require("axios-retry");
-const http_1 = require("http");
-const http = axios_1.default.create({
-    httpAgent: new http_1.Agent({
-        keepAlive: true,
-        maxFreeSockets: 50,
-    }),
-});
-retry(http);
-http.interceptors.response.use(response => response, (err) => {
-    try {
-        delete err.response.request;
-        delete err.response.config;
-        delete err.config.res;
-        delete err.config.data;
-    }
-    catch (e) { } // tslint:disable-line
-    return Promise.reject(err);
-});
-exports.defaultsMiddleware = (baseURL, headers, timeout) => {
-    return (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-        console.error('defaultsMiddleware');
-        ctx.config = Object.assign({ baseURL, maxRedirects: 0, timeout, validateStatus: status => (status >= 200 && status < 300) }, ctx.config, { headers: Object.assign({}, headers, ctx.config.headers) });
-        yield next();
-    });
-};
-exports.requestMiddleware = (ctx, next) => __awaiter(this, void 0, void 0, function* () {
-    console.error('requestMiddleware');
-    ctx.response = yield http.request(ctx.config);
-});

package/lib/ID.d.ts

@@ -1,23 +0,0 @@
-import { LegacyInstanceOptions } from './HttpClient';
-export declare class ID {
-    private http;
-    private defaultHeaders;
-    constructor(endpointUrl: string | undefined, opts: LegacyInstanceOptions);
-    getTemporaryToken: () => Promise<string>;
-    sendCodeToEmail: (token: string, email: string) => Promise<any>;
-    getEmailCodeAuthenticationToken: (token: string, email: string, code: string) => Promise<AuthenticationResponse>;
-    getPasswordAuthenticationToken: (token: string, email: string, password: string) => Promise<AuthenticationResponse>;
-}
-export interface AuthenticationResponse {
-    promptMFA: boolean;
-    clientToken: any;
-    authCookie: {
-        Name: string;
-        Value: string;
-    };
-    accountAuthCookie: any;
-    expiresIn: number;
-    userId: string;
-    phoneNumber: string;
-    scope: any;
-}

package/lib/ID.js

@@ -1,46 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const HttpClient_1 = require("./HttpClient");
-const routes = {
-    SEND: '/accesskey/send',
-    START: '/start',
-    VALIDATE: '/accesskey/validate',
-    VALIDATE_CLASSIC: '/classic/validate',
-};
-const VTEXID_ENDPOINTS = {
-    BETA: 'https://vtexid.vtex.com.br/api/vtexid/pub/authentication',
-    STABLE: 'https://vtexid.vtex.com.br/api/vtexid/pub/authentication',
-};
-const endpoint = (env) => {
-    return VTEXID_ENDPOINTS[env] || env;
-};
-class ID {
-    constructor(endpointUrl = 'STABLE', opts) {
-        this.getTemporaryToken = () => {
-            return this.http.get(routes.START).then(({ authenticationToken }) => authenticationToken);
-        };
-        this.sendCodeToEmail = (token, email) => {
-            const params = { authenticationToken: token, email };
-            return this.http.get(routes.SEND, { params, headers: this.defaultHeaders });
-        };
-        this.getEmailCodeAuthenticationToken = (token, email, code) => {
-            const params = {
-                accesskey: code,
-                authenticationToken: token,
-                login: email,
-            };
-            return this.http.get(routes.VALIDATE, { params, headers: this.defaultHeaders });
-        };
-        this.getPasswordAuthenticationToken = (token, email, password) => {
-            const params = {
-                authenticationToken: token,
-                login: email,
-                password,
-            };
-            return this.http.get(routes.VALIDATE_CLASSIC, { params, headers: this.defaultHeaders });
-        };
-        this.http = HttpClient_1.HttpClient.forLegacy(endpoint(endpointUrl), opts);
-        this.defaultHeaders = opts.accept ? { accept: opts.accept } : {};
-    }
-}
-exports.ID = ID;

package/lib/IODataSource.d.ts

@@ -1,23 +0,0 @@
-import { DataSource, DataSourceConfig } from 'apollo-datasource';
-import { HttpClient, InstanceOptions, IOContext, LegacyInstanceOptions, ServiceContext } from './HttpClient';
-interface HttpClientFactoryOptions {
-    service: string | void;
-    context: IOContext | void;
-    options: InstanceOptions | LegacyInstanceOptions | void;
-}
-export declare type HttpClientFactory = (opts: HttpClientFactoryOptions) => HttpClient | void;
-export declare abstract class IODataSource extends DataSource<ServiceContext> {
-    protected context?: IOContext | undefined;
-    private options;
-    protected abstract httpClientFactory: HttpClientFactory;
-    protected service: string | void;
-    private httpClient;
-    private initialized;
-    constructor(context?: IOContext | undefined, options?: InstanceOptions);
-    initialize(config: DataSourceConfig<ServiceContext>): void;
-    readonly http: HttpClient;
-}
-export declare const forWorkspace: HttpClientFactory;
-export declare const forRoot: HttpClientFactory;
-export declare const forLegacy: HttpClientFactory;
-export {};

package/lib/IODataSource.js

@@ -1,43 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const apollo_datasource_1 = require("apollo-datasource");
-const HttpClient_1 = require("./HttpClient");
-class IODataSource extends apollo_datasource_1.DataSource {
-    constructor(context, options = {}) {
-        super();
-        this.context = context;
-        this.options = options;
-        this.service = undefined;
-        this.httpClient = undefined;
-        this.initialized = false;
-    }
-    initialize(config) {
-        const { context: { vtex: context }, cache: cacheStorage } = config;
-        this.context = context;
-        this.httpClient = this.httpClientFactory({
-            context,
-            options: Object.assign({ cacheStorage }, this.options),
-            service: this.service,
-        });
-        this.initialized = true;
-    }
-    get http() {
-        if (!this.initialized) {
-            this.initialize({ context: { vtex: this.context } });
-        }
-        if (this.httpClient) {
-            return this.httpClient;
-        }
-        throw new Error('IO Datasource was not initialized nor constructed with a context');
-    }
-}
-exports.IODataSource = IODataSource;
-exports.forWorkspace = ({ context, service, options }) => (context && service)
-    ? HttpClient_1.HttpClient.forWorkspace(service, context, options || {})
-    : undefined;
-exports.forRoot = ({ context, service, options }) => (context && service)
-    ? HttpClient_1.HttpClient.forRoot(service, context, options || {})
-    : undefined;
-exports.forLegacy = ({ service, options }) => service
-    ? HttpClient_1.HttpClient.forLegacy(service, options || {})
-    : undefined;

package/lib/Logger.d.ts

@@ -1,20 +0,0 @@
-import { HttpClientFactory, IODataSource } from './IODataSource';
-export declare class Logger extends IODataSource {
-    protected service: string;
-    protected httpClientFactory: HttpClientFactory;
-    debug: (message: any, subject?: string) => Promise<void>;
-    info: (message: any, subject?: string) => Promise<void>;
-    warn: (message: any, subject?: string) => Promise<void>;
-    error: (error: any, details?: Record<string, any> | undefined, subject?: string) => Promise<void>;
-    sendLog: (subject: string, message: any, level: string) => Promise<void>;
-}
-export interface ErrorLog {
-    code: string;
-    message: string;
-    response?: {
-        status: number;
-        data: string;
-        headers: Record<string, string>;
-    };
-    [key: string]: any;
-}

package/lib/Logger.js

@@ -1,60 +0,0 @@
-"use strict";
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
-            t[p[i]] = s[p[i]];
-    return t;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const stringify = require("json-stringify-safe");
-const PQueue = require("p-queue");
-const ramda_1 = require("ramda");
-const HttpClient_1 = require("./HttpClient");
-const IODataSource_1 = require("./IODataSource");
-const DEFAULT_SUBJECT = '-';
-const PICKED_AXIOS_PROPS = ['baseURL', 'cacheable', 'data', 'finished', 'headers', 'method', 'timeout', 'status', 'path', 'url'];
-const queue = new PQueue({ concurrency: 1 });
-const routes = {
-    Log: (level) => `/logs/${level}`,
-};
-const errorReplacer = (key, value) => {
-    if (key.startsWith('_')) {
-        return undefined;
-    }
-    if (value && typeof value === 'string' && value.length > 1024) {
-        return value.substr(0, 256) + '[...TRUNCATED]';
-    }
-    return value;
-};
-const forWorkspaceWithoutRecorder = ({ service, context, options }) => (service && context)
-    ? HttpClient_1.HttpClient.forWorkspace(service, HttpClient_1.withoutRecorder(context), options || {})
-    : undefined;
-class Logger extends IODataSource_1.IODataSource {
-    constructor() {
-        super(...arguments);
-        this.service = 'colossus';
-        this.httpClientFactory = forWorkspaceWithoutRecorder;
-        this.debug = (message, subject = DEFAULT_SUBJECT) => this.sendLog(subject, message, 'debug');
-        this.info = (message, subject = DEFAULT_SUBJECT) => this.sendLog(subject, message, 'info');
-        this.warn = (message, subject = DEFAULT_SUBJECT) => this.sendLog(subject, message, 'warn');
-        this.error = (error, details, subject = DEFAULT_SUBJECT) => {
-            if (!error) {
-                error = new Error('Colossus.error was called with null or undefined error');
-                error.code = 'ERR_NIL_ERR';
-                console.error(error);
-            }
-            const { code: errorCode, message, stack, config, request, response } = error, rest = __rest(error, ["code", "message", "stack", "config", "request", "response"]);
-            const code = errorCode || response && `http-${response.status}`;
-            const pickedDetails = Object.assign({}, config ? { config: ramda_1.pick(PICKED_AXIOS_PROPS, config) } : undefined, request ? { request: ramda_1.pick(PICKED_AXIOS_PROPS, request) } : undefined, response ? { response: ramda_1.pick(PICKED_AXIOS_PROPS, response) } : undefined, JSON.parse(stringify(rest, errorReplacer)), details);
-            const hasDetails = Object.keys(pickedDetails).length > 0;
-            return this.sendLog(subject, { code, message, stack, details: hasDetails ? pickedDetails : undefined }, 'error');
-        };
-        this.sendLog = (subject, message, level) => {
-            return queue.add(() => this.http.put(routes.Log(level), message, { params: { subject } }));
-        };
-    }
-}
-exports.Logger = Logger;

package/lib/Metadata.d.ts

@@ -1,27 +0,0 @@
-import { InstanceOptions, IOContext } from './HttpClient';
-import { IODataSource } from './IODataSource';
-import { BucketMetadata } from './responses';
-export interface MetadataEntry {
-    Key: string;
-    Hash: string;
-    Value: any;
-}
-export interface MetadataEntryList {
-    Data: MetadataEntry[];
-    Next: string;
-}
-export declare class Metadata extends IODataSource {
-    protected service: string;
-    protected httpClientFactory: import("./IODataSource").HttpClientFactory;
-    constructor(context?: IOContext, options?: InstanceOptions);
-    getBuckets: (bucket: string) => Promise<BucketMetadata>;
-    list: (bucket: string, includeValue: boolean, limit?: number | undefined, nextMarker?: string | undefined) => Promise<MetadataEntryList>;
-    listAll: (bucket: string, includeValue: boolean) => Promise<MetadataEntryList>;
-    get: (bucket: string, key: string) => Promise<any>;
-    save: (bucket: string, key: string, data: any) => Promise<void>;
-    saveAll: (bucket: string, data: {
-        [key: string]: any;
-    }) => Promise<void>;
-    delete: (bucket: string, key: string) => Promise<import("./HttpClient").IOResponse<void>>;
-    deleteAll: (bucket: string) => Promise<import("./HttpClient").IOResponse<void>>;
-}