@rushdb/javascript-sdk 0.1.0

package/cjs/network/FetchHttpClient.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FetchHttpClientResponse = exports.FetchHttpClient = void 0;
+const constants_js_1 = require("../common/constants.js");
+const HttpClient_js_1 = require("./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).
+ */
+class FetchHttpClient extends HttpClient_js_1.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_js_1.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_js_1.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_js_1.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 : constants_js_1.DEFAULT_TIMEOUT);
+        return new FetchHttpClientResponse(res);
+    }
+}
+exports.FetchHttpClient = FetchHttpClient;
+class FetchHttpClientResponse extends HttpClient_js_1.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;
+    }
+}
+exports.FetchHttpClientResponse = FetchHttpClientResponse;

package/cjs/network/HttpClient.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpClientResponse = exports.HttpClientGenericResponse = exports.HttpClient = void 0;
+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;
+    }
+}
+exports.HttpClient = HttpClient;
+HttpClient.CONNECTION_CLOSED_ERROR_CODES = ['ECONNRESET', 'EPIPE'];
+HttpClient.TIMEOUT_ERROR_CODE = 'ETIMEDOUT';
+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.');
+    }
+}
+exports.HttpClientGenericResponse = HttpClientGenericResponse;
+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.');
+    }
+}
+exports.HttpClientResponse = HttpClientResponse;

package/cjs/network/NodeHttpClient.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeHttpClientResponse = exports.NodeHttpClient = void 0;
+const http_ = require("http");
+const https_ = require("https");
+const constants_js_1 = require("../common/constants.js");
+const HttpClient_js_1 = require("./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 });
+class NodeHttpClient extends HttpClient_js_1.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.host,
+                method,
+                path: url.pathname + url.search,
+                port: url.port
+            });
+            req.setTimeout(timeout !== null && timeout !== void 0 ? timeout : constants_js_1.DEFAULT_TIMEOUT, () => {
+                req.destroy(HttpClient_js_1.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();
+                }
+            });
+        });
+    }
+}
+exports.NodeHttpClient = NodeHttpClient;
+class NodeHttpClientResponse extends HttpClient_js_1.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);
+                }
+            });
+        });
+    }
+}
+exports.NodeHttpClientResponse = NodeHttpClientResponse;

package/cjs/network/index.js

@@ -0,0 +1,28 @@
+"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 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFetcher = void 0;
+const defaultHeaders = {
+    'Content-Type': 'application/json'
+};
+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()}`);
+};
+exports.createFetcher = createFetcher;

package/cjs/network/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/package.json

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

package/cjs/sdk/constants.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ALLOWED_CONFIG_PROPERTIES = void 0;
+exports.ALLOWED_CONFIG_PROPERTIES = [
+    'httpClient',
+    'timeout',
+    'host',
+    'port',
+    'protocol',
+    'url',
+    'validator'
+];

package/cjs/sdk/errors.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NonUniqueResultError = exports.EmptyTargetError = exports.UniquenessError = void 0;
+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);
+    }
+}
+exports.UniquenessError = UniquenessError;
+class EmptyTargetError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'EmptyTarget';
+        Object.setPrototypeOf(this, EmptyTargetError.prototype);
+    }
+}
+exports.EmptyTargetError = EmptyTargetError;
+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);
+    }
+}
+exports.NonUniqueResultError = NonUniqueResultError;

package/cjs/sdk/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./sdk.js"), exports);
+__exportStar(require("./types.js"), exports);
+__exportStar(require("./errors.js"), exports);
+__exportStar(require("./transaction.js"), exports);
+__exportStar(require("./utils.js"), exports);
+__exportStar(require("./record.js"), exports);
+__exportStar(require("./model.js"), exports);

package/cjs/sdk/model.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Model = void 0;
+const rest_api_proxy_js_1 = require("../api/rest-api-proxy.js");
+const utils_js_1 = require("../common/utils.js");
+const errors_js_1 = require("./errors.js");
+const utils_js_2 = require("./utils.js");
+class Model extends rest_api_proxy_js_1.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 (0, utils_js_2.mergeDefaultsWithPayload)(this.schema, record);
+        const uniqFields = (0, utils_js_2.pickUniqFieldsFromRecord)(this.schema, data);
+        if (!(0, utils_js_1.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 errors_js_1.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 (0, utils_js_2.mergeDefaultsWithPayload)(this.schema, record);
+        const uniqFields = (0, utils_js_2.pickUniqFieldsFromRecord)(this.schema, data);
+        if (!(0, utils_js_1.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 errors_js_1.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 (0, utils_js_2.mergeDefaultsWithPayload)(this.schema, record);
+            }));
+            // Check uniqueness
+            const uniqProperties = (0, utils_js_2.pickUniqFieldsFromRecords)(recordsToStore, this.schema, this.label);
+            if (!(0, utils_js_1.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 errors_js_1.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 ((0, utils_js_1.isEmptyObject)(searchParams.where)) {
+            throw new errors_js_1.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);
+    }
+}
+exports.Model = Model;

package/cjs/sdk/record.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBRecordsArrayInstance = exports.DBRecordInstance = exports.DBRecordDraft = exports.DBRecordsBatchDraft = void 0;
+const rest_api_proxy_js_1 = require("../api/rest-api-proxy.js");
+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
+        };
+    }
+}
+exports.DBRecordsBatchDraft = DBRecordsBatchDraft;
+class DBRecordDraft {
+    constructor({ label, properties = [] }) {
+        this.label = label;
+        this.properties = properties;
+    }
+    toJson() {
+        return {
+            label: this.label,
+            properties: this.properties
+        };
+    }
+}
+exports.DBRecordDraft = DBRecordDraft;
+class DBRecordInstance extends rest_api_proxy_js_1.RestApiProxy {
+    constructor(data, searchParams) {
+        super();
+        this.data = data;
+        this.searchParams = searchParams;
+    }
+    async delete(transaction) {
+        if (this.data) {
+            return await this.apiProxy.records.deleteById(this.data.__id, transaction);
+        }
+    }
+    async update(partialData, transaction) {
+        if (this.data) {
+            return this.apiProxy.records.update(this.data.__id, partialData, transaction);
+        }
+    }
+    async set(data, transaction) {
+        if (this.data) {
+            return this.apiProxy.records.set(this.data.__id, data, transaction);
+        }
+    }
+    async attach(target, options, transaction) {
+        if (this.data) {
+            return this.apiProxy.records.attach(this.data.__id, target, options, transaction);
+        }
+    }
+    async detach(target, options, transaction) {
+        if (this.data) {
+            return this.apiProxy.records.detach(this.data.__id, target, options, transaction);
+        }
+    }
+}
+exports.DBRecordInstance = DBRecordInstance;
+class DBRecordsArrayInstance extends rest_api_proxy_js_1.RestApiProxy {
+    constructor(data, total, searchParams) {
+        super();
+        this.data = data;
+        this.total = total;
+        this.searchParams = searchParams;
+    }
+}
+exports.DBRecordsArrayInstance = DBRecordsArrayInstance;

package/cjs/sdk/sdk.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initSDK = void 0;
+const api_js_1 = require("../api/api.js");
+const constants_js_1 = require("../common/constants.js");
+const record_js_1 = require("./record.js");
+const utils_js_1 = require("./utils.js");
+const initSDK = (httpClient) => {
+    class RushDB extends api_js_1.RestAPI {
+        constructor(token, config) {
+            var _a;
+            const props = (0, utils_js_1.parseConfig)(config);
+            super(token, Object.assign(Object.assign({}, props), { httpClient: (_a = props.httpClient) !== null && _a !== void 0 ? _a : httpClient }));
+            this.state = {
+                debug: false,
+                timeout: (0, utils_js_1.validateInteger)('timeout', props.timeout, constants_js_1.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 record_js_1.DBRecordInstance(record);
+            result.init(this);
+            return result;
+        }
+    }
+    return RushDB;
+};
+exports.initSDK = initSDK;