@rushdb/javascript-sdk 0.1.0

package/esm/api/create-api.js

@@ -0,0 +1,254 @@
+import { isArray } from '../common/utils.js';
+import { NonUniqueResultError } from '../sdk/errors.js';
+import { DBRecordsBatchDraft, DBRecordDraft } from '../sdk/record.js';
+import { buildTransactionHeader, pickRecordId, pickTransactionId } from './utils.js';
+// POST /api/v1/records/:id @TODO
+export const createApi = (fetcher) => ({
+    labels: {
+        async find(searchParams, transaction) {
+            const txId = pickTransactionId(transaction);
+            return fetcher(`/labels`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'POST',
+                requestData: searchParams
+            });
+        }
+    },
+    properties: {
+        delete: (id, transaction) => {
+            const txId = pickTransactionId(transaction);
+            return fetcher(`/properties/${id}`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'DELETE'
+            });
+        },
+        find: (searchParams, transaction) => {
+            const txId = pickTransactionId(transaction);
+            return fetcher(`/properties`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'POST',
+                requestData: searchParams
+            });
+        },
+        findById: (id, transaction) => {
+            const txId = pickTransactionId(transaction);
+            return fetcher(`/properties/${id}`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'GET'
+            });
+        },
+        // update: () => {
+        //   // @TODO
+        // },
+        // updateValues: (id: string, transaction?: Transaction | string) => {
+        //   // @TODO
+        // },
+        values: (id, transaction) => {
+            const txId = pickTransactionId(transaction);
+            return fetcher(`/properties/${id}/values`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'GET'
+            });
+        }
+    },
+    records: {
+        attach: async (source, idOrIds, options, transaction) => {
+            const txId = pickTransactionId(transaction);
+            const recordId = pickRecordId(source);
+            return fetcher(`/records/${recordId}/relations`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'POST',
+                requestData: Object.assign(Object.assign({ targetIds: idOrIds }, ((options === null || options === void 0 ? void 0 : options.type) && { type: options === null || options === void 0 ? void 0 : options.type })), ((options === null || options === void 0 ? void 0 : options.direction) && { direction: options === null || options === void 0 ? void 0 : options.direction }))
+            });
+        },
+        async create(data, transaction) {
+            const txId = pickTransactionId(transaction);
+            if (data instanceof DBRecordDraft) {
+                return fetcher(`/records`, {
+                    headers: Object.assign({}, buildTransactionHeader(txId)),
+                    method: 'POST',
+                    requestData: data.toJson()
+                });
+            }
+            return { data: undefined, success: false };
+        },
+        async createMany(data, transaction) {
+            const txId = pickTransactionId(transaction);
+            if (data instanceof DBRecordsBatchDraft) {
+                return fetcher(`/records/import/json`, {
+                    headers: Object.assign({}, buildTransactionHeader(txId)),
+                    method: 'POST',
+                    requestData: data.toJson()
+                });
+            }
+            return { data: [], success: false };
+        },
+        delete(searchParams, transaction) {
+            const txId = pickTransactionId(transaction);
+            return fetcher(`/records/delete`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'PUT',
+                requestData: searchParams
+            });
+        },
+        deleteById(idOrIds, transaction) {
+            const txId = pickTransactionId(transaction);
+            if (isArray(idOrIds)) {
+                return fetcher(`/records/delete`, {
+                    headers: Object.assign({}, buildTransactionHeader(txId)),
+                    method: 'PUT',
+                    requestData: { limit: 1000, where: { $id: { $in: idOrIds } } }
+                });
+            }
+            else {
+                return fetcher(`/records/${idOrIds}`, {
+                    headers: Object.assign({}, buildTransactionHeader(txId)),
+                    method: 'DELETE'
+                });
+            }
+        },
+        detach: async (source, idOrIds, options, transaction) => {
+            const txId = pickTransactionId(transaction);
+            const recordId = pickRecordId(source);
+            return fetcher(`/records/${recordId}/relations`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'PUT',
+                requestData: Object.assign(Object.assign({ targetIds: idOrIds }, ((options === null || options === void 0 ? void 0 : options.typeOrTypes) && { typeOrTypes: options === null || options === void 0 ? void 0 : options.typeOrTypes })), ((options === null || options === void 0 ? void 0 : options.direction) && { direction: options === null || options === void 0 ? void 0 : options.direction }))
+            });
+        },
+        export(searchParams, transaction) {
+            const txId = pickTransactionId(transaction);
+            return fetcher(`/records/export/csv`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'POST',
+                requestData: searchParams
+            });
+        },
+        find(params, transaction) {
+            const txId = pickTransactionId(transaction);
+            const url = (params === null || params === void 0 ? void 0 : params.id) ? `/records/${params === null || params === void 0 ? void 0 : params.id}/search` : `/records/search`;
+            return fetcher(url, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'POST',
+                requestData: params === null || params === void 0 ? void 0 : params.searchParams
+            });
+        },
+        findById(idOrIds, transaction) {
+            const txId = pickTransactionId(transaction);
+            if (isArray(idOrIds)) {
+                return fetcher(`/records`, {
+                    headers: Object.assign({}, buildTransactionHeader(txId)),
+                    method: 'POST',
+                    requestData: { ids: idOrIds }
+                });
+            }
+            return fetcher(`/records/${idOrIds}`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'GET'
+            });
+        },
+        async findOne(searchParams, transaction) {
+            const txId = pickTransactionId(transaction);
+            const response = await fetcher(`/records/search`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'POST',
+                requestData: Object.assign(Object.assign({}, searchParams), { limit: 1, skip: 0 })
+            });
+            const [record] = response.data;
+            return Object.assign(Object.assign({}, response), { data: record });
+        },
+        async findUniq(searchParams, transaction) {
+            const txId = pickTransactionId(transaction);
+            const response = await fetcher(`/records/search`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'POST',
+                requestData: Object.assign(Object.assign({}, searchParams), { limit: 1, skip: 0 })
+            });
+            if (typeof response.total !== 'undefined' && response.total > 1) {
+                throw new NonUniqueResultError(response.total, searchParams);
+            }
+            const [record] = response.data;
+            return Object.assign(Object.assign({}, response), { data: record });
+        },
+        properties(target, transaction) {
+            const txId = pickTransactionId(transaction);
+            const recordId = pickRecordId(target);
+            return fetcher(`/records/${recordId}/properties`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'GET'
+            });
+        },
+        relations: async (target, transaction) => {
+            const txId = pickTransactionId(transaction);
+            const recordId = pickRecordId(target);
+            return fetcher(`/records/${recordId}/relations`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'GET'
+            });
+        },
+        // upsert() {
+        //   // @TODO
+        // }
+        set(target, data, transaction) {
+            const txId = pickTransactionId(transaction);
+            const recordId = pickRecordId(target);
+            return fetcher(`/records/${recordId}`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'PUT',
+                requestData: data instanceof DBRecordDraft ? data.toJson() : data
+            });
+        },
+        update(target, data, transaction) {
+            const txId = pickTransactionId(transaction);
+            const recordId = pickRecordId(target);
+            return fetcher(`/records/${recordId}`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'PATCH',
+                requestData: data instanceof DBRecordDraft ? data.toJson() : data
+            });
+        }
+    },
+    relations: {
+        find: async (searchParams, pagination, transaction) => {
+            const txId = pickTransactionId(transaction);
+            const queryParams = new URLSearchParams();
+            if (typeof (pagination === null || pagination === void 0 ? void 0 : pagination.limit) !== 'undefined') {
+                queryParams.append('limit', pagination.limit.toString());
+            }
+            if (typeof (pagination === null || pagination === void 0 ? void 0 : pagination.skip) !== 'undefined') {
+                queryParams.append('skip', pagination === null || pagination === void 0 ? void 0 : pagination.skip.toString());
+            }
+            const queryString = queryParams.toString() ? '?' + queryParams.toString() : '';
+            return fetcher(`/records/relations/search${queryString}`, {
+                headers: Object.assign({}, buildTransactionHeader(txId)),
+                method: 'POST',
+                requestData: searchParams
+            });
+        }
+    },
+    tx: {
+        begin(config = {}) {
+            return fetcher(`/tx`, {
+                method: 'POST',
+                requestData: config
+            });
+        },
+        commit(id) {
+            return fetcher(`/tx/${id}/commit`, {
+                method: 'POST',
+                requestData: {}
+            });
+        },
+        get(id) {
+            return fetcher(`/tx/${id}`, {
+                method: 'GET'
+            });
+        },
+        rollback(id) {
+            return fetcher(`/tx/${id}/rollback`, {
+                method: 'POST',
+                requestData: {}
+            });
+        }
+    }
+});

package/esm/api/index.js

@@ -0,0 +1,2 @@
+export { DBRecordsBatchDraft, DBRecordDraft } from '../sdk/record.js';
+export { RestAPI } from './api.js';

package/esm/api/rest-api-proxy.js

@@ -0,0 +1,18 @@
+export class RestApiProxy {
+    constructor() {
+        this.apiProxy = {};
+        return new Proxy(this, {
+            get: (target, prop, receiver) => {
+                if (prop in target) {
+                    return Reflect.get(target, prop, receiver);
+                }
+                if (this.apiProxy && prop in this.apiProxy) {
+                    return Reflect.get(this.apiProxy, prop, receiver);
+                }
+            }
+        });
+    }
+    init(api, methodsWhiteList) {
+        this.apiProxy = api;
+    }
+}

package/esm/api/types.js

@@ -0,0 +1 @@
+export {};

package/esm/api/utils.js

@@ -0,0 +1,138 @@
+import { ISO_8601_FULL, PROPERTY_TYPE_BOOLEAN, PROPERTY_TYPE_DATETIME, PROPERTY_TYPE_NULL, PROPERTY_TYPE_NUMBER, PROPERTY_TYPE_STRING } from '../common/constants.js';
+import { isArray, isObject, isString } from '../common/utils.js';
+import { DBRecordInstance } from '../sdk';
+import { Transaction } from '../sdk/transaction.js';
+import { DEFAULT_BASE_PATH, DEFAULT_HOST, DEFAULT_PORT, DEFAULT_PROTOCOL } from './constants.js';
+export const buildTransactionHeader = (txId) => txId ?
+    {
+        ['x-transaction-id']: txId
+    }
+    : undefined;
+export const isTransaction = (input) => isString(input) || input instanceof Transaction;
+export const pickTransaction = (input) => (isTransaction(input) ? input : undefined);
+export const pickTransactionId = (input) => isTransaction(input) ?
+    input instanceof Transaction ?
+        input.id
+        : input
+    : undefined;
+export const pickRecordId = (input) => {
+    if (isString(input)) {
+        return input;
+    }
+    else if (input instanceof DBRecordInstance && input.data) {
+        return input.data.__id;
+    }
+    else if ('__id' in input) {
+        return input.__id;
+    }
+    return undefined;
+};
+export const createSearchParams = (labelOrSearchParams, searchParamsOrTransaction) => {
+    var _a, _b, _c;
+    const isFirstArgString = isString(labelOrSearchParams);
+    const isFirstArgUUID = isUUID(labelOrSearchParams);
+    const isSecondArgTransaction = isTransaction(searchParamsOrTransaction);
+    const isEmptySearchParams = isSecondArgTransaction || !isObject(searchParamsOrTransaction);
+    if (isFirstArgString) {
+        const baseParams = isFirstArgUUID ?
+            { id: labelOrSearchParams }
+            : { searchParams: { labels: [labelOrSearchParams] } };
+        return isEmptySearchParams ? Object.assign(Object.assign({}, baseParams), { searchParams: Object.assign({}, baseParams.searchParams) }) : Object.assign(Object.assign({}, baseParams), { searchParams: Object.assign(Object.assign({}, searchParamsOrTransaction), { labels: [
+                    ...((_b = (_a = baseParams.searchParams) === null || _a === void 0 ? void 0 : _a.labels) !== null && _b !== void 0 ? _b : []),
+                    ...((_c = searchParamsOrTransaction.labels) !== null && _c !== void 0 ? _c : [])
+                ] }) });
+    }
+    else {
+        return { searchParams: labelOrSearchParams !== null && labelOrSearchParams !== void 0 ? labelOrSearchParams : {} };
+    }
+};
+export const isUUID = (value) => {
+    const regex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/;
+    return regex.test(value);
+};
+export const arrayIsConsistent = (arr) => arr.every((item) => typeof item === typeof arr[0]);
+export const getValueParameters = (value) => {
+    if (Array.isArray(value)) {
+        return {
+            isEmptyArray: value.length === 0,
+            isEmptyStringsArray: value.every((v) => v === ''),
+            isInconsistentArray: !arrayIsConsistent(value)
+        };
+    }
+    else {
+        return { isEmptyString: value === '' };
+    }
+};
+export const suggestPropertyType = (value) => {
+    if (typeof value === PROPERTY_TYPE_STRING) {
+        return ISO_8601_FULL.test(value) ? PROPERTY_TYPE_DATETIME : PROPERTY_TYPE_STRING;
+    }
+    else if (typeof value === PROPERTY_TYPE_NUMBER) {
+        return PROPERTY_TYPE_NUMBER;
+    }
+    else if (typeof value === PROPERTY_TYPE_BOOLEAN) {
+        return PROPERTY_TYPE_BOOLEAN;
+    }
+    else if (value === null) {
+        return PROPERTY_TYPE_NULL;
+    }
+    else {
+        return PROPERTY_TYPE_STRING;
+    }
+};
+const processArrayValue = (value, suggestTypes) => {
+    const { isEmptyArray, isInconsistentArray } = getValueParameters(value);
+    if (isEmptyArray) {
+        return { type: PROPERTY_TYPE_STRING, value: [] };
+    }
+    if (isInconsistentArray || !suggestTypes) {
+        return { type: PROPERTY_TYPE_STRING, value: value.map(String) };
+    }
+    return { type: suggestPropertyType(value[0]), value };
+};
+const processNonArrayValue = (value, suggestTypes) => {
+    if (!suggestTypes) {
+        return { type: PROPERTY_TYPE_STRING, value: String(value) };
+    }
+    const type = suggestPropertyType(value);
+    return { type, value: type === PROPERTY_TYPE_NULL ? null : value };
+};
+export const prepareProperties = (data, options = { suggestTypes: true }) => Object.entries(data).map(([name, value]) => {
+    const { type, value: processedValue } = isArray(value) ?
+        processArrayValue(value, options.suggestTypes)
+        : processNonArrayValue(value, options.suggestTypes);
+    return { name, type, value: processedValue };
+});
+export const normalizeRecord = ({ label, options = { suggestTypes: true }, payload }) => ({
+    label,
+    properties: prepareProperties(payload, options)
+});
+export const buildUrl = (props) => {
+    let protocol = DEFAULT_PROTOCOL;
+    let host = DEFAULT_HOST;
+    let port = DEFAULT_PORT;
+    let basePath = DEFAULT_BASE_PATH;
+    if ('url' in props) {
+        const url = new URL(props.url);
+        protocol = url.protocol.replace(':', '');
+        host = url.hostname;
+        port = parseInt(url.port || protocol === 'http' ? '80'
+            : protocol === 'https' ? '443'
+                : '');
+    }
+    if ('host' in props && 'port' in props && 'protocol' in props) {
+        protocol = props.protocol.replace(':', '');
+        host = props.host;
+        port = props.port;
+    }
+    // Ensure the basePath starts with a '/'
+    if (basePath && !basePath.startsWith('/')) {
+        basePath = '/' + basePath;
+    }
+    // If the port is the default for the protocol (80 for http, 443 for https), it can be omitted
+    let portString = '';
+    if (!((protocol === 'http' && port === 80) || (protocol === 'https' && port === 443))) {
+        portString = ':' + port;
+    }
+    return `${protocol}://${host}${portString}${basePath}`;
+};

package/esm/common/constants.js

@@ -0,0 +1,7 @@
+export const ISO_8601_FULL = /^(?:\d{4}-(?:(?:0[1-9]|1[0-2])-(?:0[1-9]|1\d|2[0-8])|(?:0[13-9]|1[0-2])-(?:29|30)|(?:0[13578]|1[02])-31)|(?:\d{2}(?:[02468][048]|[13579][26])-02-29))Schema(0[0-9]|1[0-9]|2[0-3]):(0[0-9]|[1-5][0-9]):(0[0-9]|[1-5][0-9])?(?:\.([0-9]{1,9}))?([zZ]?|([\+-])(((([0][0-9])|([1][0-3])):?(([03][0])|([14][5])))|14:00)?)$/;
+export const DEFAULT_TIMEOUT = 80000;
+export const PROPERTY_TYPE_STRING = 'string';
+export const PROPERTY_TYPE_DATETIME = 'datetime';
+export const PROPERTY_TYPE_BOOLEAN = 'boolean';
+export const PROPERTY_TYPE_NUMBER = 'number';
+export const PROPERTY_TYPE_NULL = 'null';

package/esm/common/utils.js

@@ -0,0 +1,37 @@
+export const isArray = (item) => typeof item === 'object' && Array.isArray(item) && item !== null;
+export const isObject = (input) => input !== null && Object.prototype.toString.call(input) === '[object Object]';
+export const isEmptyObject = (input) => isObject(input) && Object.keys(input).length === 0;
+export const isObjectFlat = (input) => {
+    return (isObject(input) &&
+        Object.keys(input).every((key) => {
+            const value = input[key];
+            // Check if the value is an array
+            if (isArray(value)) {
+                // Check if every element in the array is of an allowed type (string, number, boolean, or null)
+                return value.every((element) => typeof element === 'string' ||
+                    typeof element === 'number' ||
+                    typeof element === 'boolean' ||
+                    element === null);
+            }
+            // Check if the value is a non-null object (excluding arrays, which are also typeof 'object')
+            return !(value && typeof value === 'object');
+        }));
+};
+export const isString = (input) => typeof input === 'string';
+export const toBoolean = (value) => {
+    if (typeof value === 'string') {
+        if (value.toLowerCase() === 'true') {
+            return true;
+        }
+        else if (value.toLowerCase() === 'false') {
+            return false;
+        }
+    }
+    if (isArray(value) && value.length === 0) {
+        return false;
+    }
+    if (isObject(value) && Object.keys(value).length === 0) {
+        return false;
+    }
+    return Boolean(value);
+};

package/esm/index.esm.node.js

@@ -0,0 +1,6 @@
+import { HttpClient, HttpClientResponse } from './network/HttpClient.js';
+import { NodeHttpClient } from './network/NodeHttpClient.js';
+import { DBRecordsBatchDraft, Model, DBRecordInstance, DBRecordsArrayInstance, Transaction, EmptyTargetError, NonUniqueResultError, UniquenessError, initSDK, idToDate, idToTimestamp } from './sdk/index.js';
+const RushDB = initSDK(new NodeHttpClient());
+export { RushDB, DBRecordsBatchDraft, Model, DBRecordInstance, DBRecordsArrayInstance, Transaction, EmptyTargetError, HttpClient, HttpClientResponse, NonUniqueResultError, UniquenessError, idToDate, idToTimestamp };
+export default RushDB;

package/esm/index.esm.worker.js

@@ -0,0 +1,6 @@
+import { FetchHttpClient } from './network/FetchHttpClient.js';
+import { HttpClient, HttpClientResponse } from './network/HttpClient.js';
+import { DBRecordsBatchDraft, Model, DBRecordInstance, DBRecordsArrayInstance, Transaction, EmptyTargetError, NonUniqueResultError, UniquenessError, initSDK, idToDate, idToTimestamp } from './sdk/index.js';
+const RushDB = initSDK(new FetchHttpClient());
+export { RushDB, DBRecordsBatchDraft, Model, DBRecordInstance, DBRecordsArrayInstance, Transaction, EmptyTargetError, HttpClient, HttpClientResponse, NonUniqueResultError, UniquenessError, idToDate, idToTimestamp };
+export default RushDB;

package/esm/network/FetchHttpClient.js

@@ -0,0 +1,133 @@
+import { DEFAULT_TIMEOUT } from '../common/constants.js';
+import { HttpClient, HttpClientGenericResponse } from './HttpClient.js';
+/**
+ * HTTP client which uses a `fetch` function to issue requests.
+ *
+ * By default, relies on the global `fetch` function, but an optional function
+ * can be passed in. If passing in a function, it is expected to match the Web
+ * Fetch API. As an example, this could be the function provided by the
+ * node-fetch package (https://github.com/node-fetch/node-fetch).
+ */
+export class FetchHttpClient extends HttpClient {
+    constructor(fetchFn) {
+        super();
+        // Default to global fetch if available
+        if (!fetchFn) {
+            if (!globalThis.fetch) {
+                throw new Error('fetch() function not provided and is not defined in the global scope. ' +
+                    'You must provide a fetch implementation.');
+            }
+            fetchFn = globalThis.fetch;
+        }
+        // Both timeout behaviors differs from Node:
+        // - Fetch uses a single timeout for the entire length of the request.
+        // - Node is more fine-grained and resets the timeout after each stage of the request.
+        if (globalThis.AbortController) {
+            // Utilise native AbortController if available
+            // AbortController was added in Node v15.0.0, v14.17.0
+            this._fetchFn = FetchHttpClient.makeFetchWithAbortTimeout(fetchFn);
+        }
+        else {
+            // Fall back to racing against a timeout promise if not available in the runtime
+            // This does not actually cancel the underlying fetch operation or resources
+            this._fetchFn = FetchHttpClient.makeFetchWithRaceTimeout(fetchFn);
+        }
+    }
+    static makeFetchWithRaceTimeout(fetchFn) {
+        return (url, init, timeout) => {
+            let pendingTimeoutId;
+            const timeoutPromise = new Promise((_, reject) => {
+                pendingTimeoutId = setTimeout(() => {
+                    pendingTimeoutId = null;
+                    reject(HttpClient.makeTimeoutError());
+                }, timeout);
+            });
+            const fetchPromise = fetchFn(url, init);
+            return Promise.race([fetchPromise, timeoutPromise]).finally(() => {
+                if (pendingTimeoutId) {
+                    clearTimeout(pendingTimeoutId);
+                }
+            });
+        };
+    }
+    static makeFetchWithAbortTimeout(fetchFn) {
+        return async (url, init, timeout) => {
+            // Use AbortController because AbortSignal.timeout() was added later in Node v17.3.0, v16.14.0
+            const abort = new AbortController();
+            let timeoutId = setTimeout(() => {
+                timeoutId = null;
+                abort.abort(HttpClient.makeTimeoutError());
+            }, timeout);
+            try {
+                return await fetchFn(url, Object.assign(Object.assign({}, init), { signal: abort.signal }));
+            }
+            catch (err) {
+                // Some implementations, like node-fetch, do not respect the reason passed to AbortController.abort()
+                // and instead it always throws an AbortError
+                // We catch this case to normalise all timeout errors
+                if (err.name === 'AbortError') {
+                    throw HttpClient.makeTimeoutError();
+                }
+                else {
+                    throw err;
+                }
+            }
+            finally {
+                if (timeoutId) {
+                    clearTimeout(timeoutId);
+                }
+            }
+        };
+    }
+    async makeRequest(url, { headers, method, protocol, requestData, timeout }) {
+        // For methods which expect payloads, we should always pass a body value
+        // even when it is empty. Without this, some JS runtimes (eg. Deno) will
+        // inject a second Content-Length header.
+        const methodHasPayload = method == 'POST' || method == 'PUT' || method == 'PATCH';
+        const body = JSON.stringify(requestData) || (methodHasPayload ? '' : undefined);
+        const res = await this._fetchFn(url, {
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            body,
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore
+            headers,
+            method
+        }, timeout !== null && timeout !== void 0 ? timeout : DEFAULT_TIMEOUT);
+        return new FetchHttpClientResponse(res);
+    }
+}
+export class FetchHttpClientResponse extends HttpClientGenericResponse {
+    constructor(res) {
+        super(res.status, FetchHttpClientResponse._transformHeadersToObject(res.headers));
+        this._res = res;
+    }
+    getRawResponse() {
+        return this._res;
+    }
+    toStream(streamCompleteCallback) {
+        // Unfortunately `fetch` does not have event handlers for when the stream is
+        // completely read. We therefore invoke the streamCompleteCallback right
+        // away. This callback emits a response event with metadata and completes
+        // metrics, so it's ok to do this without waiting for the stream to be
+        // completely read.
+        streamCompleteCallback();
+        // Fetch's `body` property is expected to be a readable stream of the body.
+        return this._res.body;
+    }
+    toJSON() {
+        return this._res.json();
+    }
+    static _transformHeadersToObject(headers) {
+        // Fetch uses a Headers instance so this must be converted to a barebones
+        // JS object to meet the HttpClient interface.
+        const headersObj = {};
+        for (const entry of headers) {
+            if (!Array.isArray(entry) || entry.length != 2) {
+                throw new Error('Response objects produced by the fetch function given to FetchHttpClient do not have an iterable headers map. Response#headers should be an iterable object.');
+            }
+            headersObj[entry[0]] = entry[1];
+        }
+        return headersObj;
+    }
+}

package/esm/network/HttpClient.js

@@ -0,0 +1,53 @@
+export class HttpClient {
+    makeRequest(url, { headers, method, protocol, requestData, timeout }) {
+        throw new Error('makeRequest not implemented.');
+    }
+    static makeTimeoutError() {
+        const timeoutErr = new TypeError(HttpClient.TIMEOUT_ERROR_CODE);
+        timeoutErr.code = HttpClient.TIMEOUT_ERROR_CODE;
+        return timeoutErr;
+    }
+}
+HttpClient.CONNECTION_CLOSED_ERROR_CODES = ['ECONNRESET', 'EPIPE'];
+HttpClient.TIMEOUT_ERROR_CODE = 'ETIMEDOUT';
+export class HttpClientGenericResponse {
+    constructor(statusCode, headers) {
+        this._statusCode = statusCode;
+        this._headers = headers;
+    }
+    getStatusCode() {
+        return this._statusCode;
+    }
+    getHeaders() {
+        return this._headers;
+    }
+    getRawResponse() {
+        throw new Error('getRawResponse not implemented.');
+    }
+    toStream(streamCompleteCallback) {
+        throw new Error('toStream not implemented.');
+    }
+    toJSON() {
+        throw new Error('toJSON not implemented.');
+    }
+}
+export class HttpClientResponse {
+    constructor(response) {
+        this._res = response;
+    }
+    getStatusCode() {
+        throw new Error('getStatusCode not implemented.');
+    }
+    getHeaders() {
+        throw new Error('getHeaders not implemented.');
+    }
+    getRawResponse() {
+        throw new Error('getRawResponse not implemented.');
+    }
+    toStream(streamCompleteCallback) {
+        throw new Error('toStream not implemented.');
+    }
+    toJSON() {
+        throw new Error('toJSON not implemented.');
+    }
+}