@rushdb/javascript-sdk 0.9.4 → 0.10.0

package/esm/api/utils.js

@@ -1,139 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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.');
-    }
-}

package/esm/network/NodeHttpClient.js

@@ -1,98 +0,0 @@
-import * as http_ from 'http';
-import * as https_ from 'https';
-import { DEFAULT_TIMEOUT } from '../common/constants.js';
-import { HttpClient, HttpClientGenericResponse } from './HttpClient.js';
-// `import * as http_ from 'http'` creates a "Module Namespace Exotic Object"
-// which is immune to monkey-patching, whereas http_.default (in an ES Module context)
-// will resolve to the same thing as require('http'), which is
-// monkey-patchable. We care about this because users in their test
-// suites might be using a library like "nock" which relies on the ability
-// to monkey-patch and intercept calls to http.request.
-const http = http_.default || http_;
-const https = https_.default || https_;
-const defaultHttpAgent = new http.Agent({ keepAlive: true });
-const defaultHttpsAgent = new https.Agent({ keepAlive: true });
-export class NodeHttpClient extends HttpClient {
-    constructor(agent) {
-        super();
-        this._agent = agent;
-    }
-    makeRequest(urlString, { headers, method, protocol, requestData, timeout }) {
-        const url = new URL(urlString);
-        const isInsecureConnection = protocol === 'http' || url.protocol === 'http:';
-        let agent = this._agent;
-        if (!agent) {
-            agent = isInsecureConnection ? defaultHttpAgent : defaultHttpsAgent;
-        }
-        return new Promise((resolve, reject) => {
-            const req = (isInsecureConnection ? http : https).request({
-                agent,
-                ciphers: 'DEFAULT:!aNULL:!eNULL:!LOW:!EXPORT:!SSLv2:!MD5',
-                headers,
-                host: url.hostname,
-                method,
-                path: url.pathname + url.search,
-                port: url.port
-            });
-            req.setTimeout(timeout !== null && timeout !== void 0 ? timeout : DEFAULT_TIMEOUT, () => {
-                req.destroy(HttpClient.makeTimeoutError());
-            });
-            req.on('response', (res) => {
-                resolve(new NodeHttpClientResponse(res));
-            });
-            req.on('error', (error) => {
-                reject(error);
-            });
-            req.once('socket', (socket) => {
-                const payload = requestData ? JSON.stringify(requestData) : '';
-                if (socket.connecting) {
-                    socket.once(isInsecureConnection ? 'connect' : 'secureConnect', () => {
-                        // Send payload; we're safe:
-                        req.write(payload);
-                        req.end();
-                    });
-                }
-                else {
-                    // we're already connected
-                    req.write(payload);
-                    req.end();
-                }
-            });
-        });
-    }
-}
-export class NodeHttpClientResponse extends HttpClientGenericResponse {
-    constructor(res) {
-        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-        // @ts-ignore
-        super(res.statusCode, res.headers || {});
-        this._res = res;
-    }
-    getRawResponse() {
-        return this._res;
-    }
-    toStream(streamCompleteCallback) {
-        // The raw response is itself the stream, so we just return that. To be
-        // backwards compatible, we should invoke the streamCompleteCallback only
-        // once the stream has been fully consumed.
-        this._res.once('end', () => streamCompleteCallback());
-        return this._res;
-    }
-    toJSON() {
-        return new Promise((resolve, reject) => {
-            let response = '';
-            this._res.setEncoding('utf8');
-            this._res.on('data', (chunk) => {
-                response += chunk;
-            });
-            this._res.once('end', () => {
-                try {
-                    resolve(JSON.parse(response));
-                }
-                catch (e) {
-                    reject(e);
-                }
-            });
-        });
-    }
-}

package/esm/network/index.js

@@ -1,24 +0,0 @@
-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 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-const defaultHeaders = {
-    'Content-Type': 'application/json'
-};
-export const createFetcher = ({ httpClient, token, url }) => async (input, _a) => {
-    var { headers: initHeaders } = _a, init = __rest(_a, ["headers"]);
-    const response = await httpClient.makeRequest(`${url}${input}`, Object.assign({ credentials: 'omit', headers: Object.assign(Object.assign(Object.assign({}, defaultHeaders), initHeaders), typeof token !== 'undefined' ? { token } : {}) }, init));
-    if (response.getStatusCode() >= 200 && response.getStatusCode() < 300) {
-        const data = await response.toJSON();
-        return data;
-    }
-    // @TODO: Make it more useful
-    throw new Error(`${response.getStatusCode()}`);
-};

package/esm/network/types.js

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

package/esm/package.json

@@ -1,4 +0,0 @@
-{
-  "type": "module",
-  "name": "@rushdb/javascript-sdk"
-}

package/esm/sdk/constants.js

@@ -1,10 +0,0 @@
-export const ALLOWED_CONFIG_PROPERTIES = [
-    'httpClient',
-    'timeout',
-    'host',
-    'port',
-    'protocol',
-    'url',
-    'validator',
-    'logger'
-];

package/esm/sdk/errors.js

@@ -1,21 +0,0 @@
-export class UniquenessError extends Error {
-    constructor(label, properties) {
-        super(`Record with label "${label}" and properties ${JSON.stringify(properties)} already exists`);
-        this.name = 'UniquenessError';
-        Object.setPrototypeOf(this, UniquenessError.prototype);
-    }
-}
-export class EmptyTargetError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'EmptyTarget';
-        Object.setPrototypeOf(this, EmptyTargetError.prototype);
-    }
-}
-export class NonUniqueResultError extends Error {
-    constructor(duplicateCount, searchParams) {
-        super(`Expected a unique result but found ${duplicateCount} matches for the provided search parameters: ${JSON.stringify(searchParams)}. Ensure your search parameters uniquely identify a single result.`);
-        this.name = 'NonUniqueResultError';
-        Object.setPrototypeOf(this, NonUniqueResultError.prototype);
-    }
-}

package/esm/sdk/index.js

@@ -1,7 +0,0 @@
-export * from './sdk.js';
-export * from './types.js';
-export * from './errors.js';
-export * from './transaction.js';
-export * from './utils.js';
-export * from './record.js';
-export * from './model.js';