@rushdb/javascript-sdk 0.9.4 → 0.9.5

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';

package/esm/sdk/model.js

@@ -1,143 +0,0 @@
-import { RestApiProxy } from '../api/rest-api-proxy.js';
-import { isEmptyObject } from '../common/utils.js';
-import { EmptyTargetError, UniquenessError } from './errors.js';
-import { mergeDefaultsWithPayload, pickUniqFieldsFromRecord, pickUniqFieldsFromRecords } from './utils.js';
-export class Model extends RestApiProxy {
-    constructor(modelName, schema, RushDBInstance) {
-        super();
-        this.label = modelName;
-        this.schema = schema;
-        RushDBInstance === null || RushDBInstance === void 0 ? void 0 : RushDBInstance.registerModel(this);
-    }
-    getLabel() {
-        return this.label;
-    }
-    async find(params = {}, transaction) {
-        var _a;
-        return (_a = this.apiProxy) === null || _a === void 0 ? void 0 : _a.records.find(this.label, params, transaction);
-    }
-    async findOne(params = {}, transaction) {
-        var _a;
-        return (_a = this.apiProxy) === null || _a === void 0 ? void 0 : _a.records.findOne(this.label, Object.assign({}, params), transaction);
-    }
-    async findById(id, transaction) {
-        return this.findOne({ where: { $id: id } }, transaction);
-    }
-    async findUniq(params = {}, transaction) {
-        var _a;
-        return (_a = this.apiProxy) === null || _a === void 0 ? void 0 : _a.records.findUniq(this.label, Object.assign({}, params), transaction);
-    }
-    async create(record, transaction) {
-        var _a;
-        const data = await mergeDefaultsWithPayload(this.schema, record);
-        const uniqFields = pickUniqFieldsFromRecord(this.schema, data);
-        if (!isEmptyObject(uniqFields)) {
-            const tx = transaction !== null && transaction !== void 0 ? transaction : (await this.apiProxy.tx.begin());
-            const matchingRecords = await this.find({ where: uniqFields }, tx);
-            const hasOwnTransaction = typeof transaction !== 'undefined';
-            const canCreate = !((_a = matchingRecords === null || matchingRecords === void 0 ? void 0 : matchingRecords.data) === null || _a === void 0 ? void 0 : _a.length);
-            if (canCreate) {
-                const result = await this.apiProxy.records.create(this.label, data, tx);
-                if (!hasOwnTransaction) {
-                    await tx.commit();
-                }
-                return result;
-            }
-            else {
-                if (!hasOwnTransaction) {
-                    await tx.commit();
-                }
-                // @TODO: Make it optional
-                throw new UniquenessError(this.label, uniqFields);
-            }
-        }
-        return await this.apiProxy.records.create(this.label, data, transaction);
-    }
-    attach(sourceId, target, options, transaction) {
-        return this.apiProxy.records.attach(sourceId, target, options, transaction);
-    }
-    detach(sourceId, target, options, transaction) {
-        return this.apiProxy.records.detach(sourceId, target, options, transaction);
-    }
-    async handleSetOrUpdate(id, record, method, transaction) {
-        var _a;
-        const data = await mergeDefaultsWithPayload(this.schema, record);
-        const uniqFields = pickUniqFieldsFromRecord(this.schema, data);
-        if (!isEmptyObject(uniqFields)) {
-            const tx = transaction !== null && transaction !== void 0 ? transaction : (await this.apiProxy.tx.begin());
-            const matchingRecords = await this.find({ where: uniqFields }, tx);
-            const hasOwnTransaction = typeof transaction !== 'undefined';
-            const canUpdate = !((_a = matchingRecords === null || matchingRecords === void 0 ? void 0 : matchingRecords.data) === null || _a === void 0 ? void 0 : _a.length) ||
-                (matchingRecords.data.length === 1 && matchingRecords.data[0].__id === id);
-            if (canUpdate) {
-                const result = await this.apiProxy.records[method](id, data, tx);
-                if (!hasOwnTransaction) {
-                    await tx.commit();
-                }
-                return result;
-            }
-            else {
-                if (!hasOwnTransaction) {
-                    await tx.commit();
-                }
-                throw new UniquenessError(this.label, uniqFields);
-            }
-        }
-        return await this.apiProxy.records[method](id, data, transaction);
-    }
-    async set(id, record, transaction) {
-        return await this.handleSetOrUpdate(id, record, 'set', transaction);
-    }
-    async update(id, record, transaction) {
-        return await this.handleSetOrUpdate(id, record, 'update', transaction);
-    }
-    async createMany(records, transaction) {
-        var _a;
-        // Begin a transaction if one isn't provided.
-        const hasOwnTransaction = typeof transaction !== 'undefined';
-        const tx = transaction !== null && transaction !== void 0 ? transaction : (await this.apiProxy.tx.begin());
-        try {
-            // Apply defaults in parallel
-            const recordsToStore = await Promise.all(records.map(async (record) => {
-                return await mergeDefaultsWithPayload(this.schema, record);
-            }));
-            // Check uniqueness
-            const uniqProperties = pickUniqFieldsFromRecords(recordsToStore, this.schema, this.label);
-            if (!isEmptyObject(uniqProperties)) {
-                const criteria = Object.entries(uniqProperties).map(([key, values]) => ({
-                    [key]: { $in: values }
-                }));
-                const matchingRecords = await this.find({
-                    where: {
-                        $or: criteria
-                    }
-                }, tx);
-                if ((_a = matchingRecords === null || matchingRecords === void 0 ? void 0 : matchingRecords.data) === null || _a === void 0 ? void 0 : _a.length) {
-                    throw new UniquenessError(this.label, Object.keys(uniqProperties));
-                }
-            }
-            // Create records in the database
-            const createdRecords = await this.apiProxy.records.createMany(this.label, recordsToStore, tx);
-            // Commit the transaction if it was created internally
-            if (!hasOwnTransaction) {
-                await tx.commit();
-            }
-            return createdRecords;
-        }
-        catch (error) {
-            if (!hasOwnTransaction) {
-                await tx.rollback();
-            }
-            throw error;
-        }
-    }
-    async delete(searchParams, transaction) {
-        if (isEmptyObject(searchParams.where)) {
-            throw new EmptyTargetError(`You must specify criteria to delete records of type '${this.label}'. Empty criteria are not allowed. If this was intentional, use the Dashboard instead.`);
-        }
-        return await this.apiProxy.records.delete(Object.assign(Object.assign({}, searchParams), { labels: [this.label] }), transaction);
-    }
-    async deleteById(idOrIds, transaction) {
-        return await this.apiProxy.records.deleteById(idOrIds, transaction);
-    }
-}

package/esm/sdk/record.js

@@ -1,115 +0,0 @@
-import { RestApiProxy } from '../api/rest-api-proxy.js';
-import { idToDate, idToTimestamp } from './utils.js';
-export class DBRecordsBatchDraft {
-    constructor({ label, options = {
-        returnResult: true,
-        suggestTypes: true
-    }, payload }) {
-        this.label = label;
-        this.options = options;
-        this.payload = payload;
-    }
-    toJson() {
-        return {
-            label: this.label,
-            options: this.options,
-            payload: this.payload
-        };
-    }
-}
-export class DBRecordDraft {
-    constructor({ label, properties = [] }) {
-        this.label = label;
-        this.properties = properties;
-    }
-    toJson() {
-        return {
-            label: this.label,
-            properties: this.properties
-        };
-    }
-}
-export class DBRecordInstance extends RestApiProxy {
-    constructor(data) {
-        super();
-        this.data = data;
-    }
-    get id() {
-        try {
-            return this.data.__id;
-        }
-        catch (_a) {
-            throw new Error(`DBRecordInstance: Unable to access 'id'. The Record data is undefined.`);
-        }
-    }
-    get label() {
-        try {
-            return this.data.__label;
-        }
-        catch (_a) {
-            throw new Error(`DBRecordInstance: Unable to access 'label'. The Record data is undefined.`);
-        }
-    }
-    get proptypes() {
-        try {
-            return this.data.__proptypes;
-        }
-        catch (_a) {
-            throw new Error(`DBRecordInstance: Unable to access 'proptypes'. The Record data' is undefined.`);
-        }
-    }
-    get date() {
-        try {
-            return idToDate(this.data.__id);
-        }
-        catch (_a) {
-            throw new Error(`DBRecordInstance: Unable to access 'date'. The Record data is undefined.`);
-        }
-    }
-    get timestamp() {
-        try {
-            return idToTimestamp(this.data.__id);
-        }
-        catch (_a) {
-            throw new Error(`DBRecordInstance: Unable to access 'timestamp'. The Record data is undefined.`);
-        }
-    }
-    async delete(transaction) {
-        if (!this.data) {
-            throw new Error('DBRecordInstance: Unable to delete Record. The Record data is undefined.');
-        }
-        return await this.apiProxy.records.deleteById(this.data.__id, transaction);
-    }
-    async update(partialData, transaction) {
-        if (!this.data) {
-            throw new Error('DBRecordInstance: Unable to update Record. The Record data is undefined.');
-        }
-        return this.apiProxy.records.update(this.data.__id, partialData, transaction);
-    }
-    async set(data, transaction) {
-        if (!this.data) {
-            throw new Error('DBRecordInstance: Unable to set. The Record data is undefined.');
-        }
-        return this.apiProxy.records.set(this.data.__id, data, transaction);
-    }
-    async attach(target, options, transaction) {
-        if (!this.data) {
-            throw new Error('DBRecordInstance: Unable to attach Record. The Record data is undefined.');
-        }
-        return this.apiProxy.records.attach(this.data.__id, target, options, transaction);
-    }
-    async detach(target, options, transaction) {
-        if (!this.data) {
-            throw new Error('DBRecordInstance: Unable to detach Record. The Record data is undefined.');
-        }
-        return this.apiProxy.records.detach(this.data.__id, target, options, transaction);
-    }
-}
-export class DBRecordsArrayInstance extends RestApiProxy {
-    constructor(data, total, searchParams) {
-        super();
-        this.data = data;
-        this.total = total;
-        this.searchParams = searchParams;
-    }
-}

package/esm/sdk/sdk.js

@@ -1,42 +0,0 @@
-import { RestAPI } from '../api/api.js';
-import { DEFAULT_TIMEOUT } from '../common/constants.js';
-import { DBRecordInstance } from './record.js';
-import { parseConfig, validateInteger } from './utils.js';
-export const initSDK = (httpClient) => {
-    class RushDB extends RestAPI {
-        constructor(token, config) {
-            var _a;
-            const props = parseConfig(config);
-            super(token, Object.assign(Object.assign({}, props), { httpClient: (_a = props.httpClient) !== null && _a !== void 0 ? _a : httpClient }));
-            this.state = {
-                debug: false,
-                timeout: validateInteger('timeout', props.timeout, DEFAULT_TIMEOUT),
-                token
-            };
-            this.models = new Map();
-            RushDB.instance = this;
-        }
-        static getInstance() {
-            return RushDB.instance;
-        }
-        registerModel(model) {
-            const label = model.getLabel();
-            // Inject the API into the model
-            model.init(this);
-            this.models.set(label, model);
-            return model; //as unknown as Model<T['schema']> & Omit<RestAPI, 'find'>
-        }
-        getModels() {
-            return this.models;
-        }
-        getModel(label) {
-            return this.models.get(label);
-        }
-        toInstance(record) {
-            const result = new DBRecordInstance(record);
-            result.init(this);
-            return result;
-        }
-    }
-    return RushDB;
-};

package/esm/sdk/transaction.js

@@ -1,13 +0,0 @@
-import { RestApiProxy } from '../api/rest-api-proxy.js';
-export class Transaction extends RestApiProxy {
-    constructor(id) {
-        super();
-        this.id = id;
-    }
-    async rollback() {
-        return await this.apiProxy.tx.rollback(this.id);
-    }
-    async commit() {
-        return await this.apiProxy.tx.commit(this.id);
-    }
-}

package/esm/sdk/types.js

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