@rushdb/javascript-sdk 0.1.0

package/esm/network/NodeHttpClient.js

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

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

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

package/esm/package.json

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

package/esm/sdk/constants.js

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

package/esm/sdk/errors.js

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

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

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

@@ -0,0 +1,70 @@
+import { RestApiProxy } from '../api/rest-api-proxy.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, 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);
+        }
+    }
+}
+export class DBRecordsArrayInstance extends RestApiProxy {
+    constructor(data, total, searchParams) {
+        super();
+        this.data = data;
+        this.total = total;
+        this.searchParams = searchParams;
+    }
+}

package/esm/sdk/sdk.js

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

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

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

package/esm/sdk/utils.js

@@ -0,0 +1,93 @@
+import { isObject } from '../common/utils.js';
+import { ALLOWED_CONFIG_PROPERTIES } from './constants.js';
+import { UniquenessError } from './errors.js';
+export const mergeDefaultsWithPayload = async (schema, payload) => {
+    const defaultPromises = Object.entries(schema).map(async ([key, prop]) => {
+        if (prop.default &&
+            typeof prop.default !== 'undefined' &&
+            typeof payload[key] === 'undefined') {
+            return {
+                key,
+                value: typeof prop.default === 'function' ? await prop.default() : prop.default
+            };
+        }
+        else {
+            return { key, value: undefined };
+        }
+    });
+    const resolvedDefaults = await Promise.all(defaultPromises);
+    const defaults = resolvedDefaults.reduce((acc, { key, value }) => {
+        if (value !== undefined) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+    return Object.assign(Object.assign({}, defaults), payload);
+};
+export const pickUniqFieldsFromRecord = (schema, data) => {
+    return Object.entries(data)
+        .filter(([key]) => { var _a; return (_a = schema[key]) === null || _a === void 0 ? void 0 : _a.uniq; })
+        .reduce((acc, [key, value]) => {
+        if (key in schema) {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+};
+export const pickUniqFieldsFromRecords = (data, schema, label) => {
+    const properties = {};
+    const uniqFields = Object.entries(schema)
+        .filter(([_, config]) => config.uniq)
+        .reduce((acc, [key]) => {
+        acc[key] = true;
+        return acc;
+    }, {});
+    data.forEach((record) => {
+        Object.entries(record).forEach(([key, value]) => {
+            if (key in uniqFields) {
+                if (properties[key]) {
+                    if (properties[key].includes(value)) {
+                        throw new UniquenessError(label, { [key]: value });
+                    }
+                    properties[key] = [...properties[key], value];
+                }
+                else {
+                    properties[key] = [value];
+                }
+            }
+        });
+    });
+    return properties;
+};
+export const parseConfig = (config) => {
+    if (!config) {
+        return {};
+    }
+    if (!isObject(config)) {
+        throw new Error('Config must be an object');
+    }
+    const values = Object.keys(config).filter((value) => !ALLOWED_CONFIG_PROPERTIES.includes(value));
+    if (values.length > 0) {
+        throw new Error(`Config object may only contain the following: ${ALLOWED_CONFIG_PROPERTIES.join(', ')}`);
+    }
+    return config;
+};
+export function validateInteger(name, n, defaultVal) {
+    if (!Number.isInteger(n)) {
+        if (defaultVal !== undefined) {
+            return defaultVal;
+        }
+        else {
+            throw new Error(`${name} must be an integer`);
+        }
+    }
+    return n;
+}
+export function idToTimestamp(id) {
+    const parts = id.split('-');
+    const highBitsHex = parts[0] + parts[1].slice(0, 4);
+    return parseInt(highBitsHex, 16);
+}
+export function idToDate(id) {
+    return new Date(idToTimestamp(id));
+}

package/esm/types/expressions.js

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

package/esm/types/index.js

@@ -0,0 +1,5 @@
+export * from './value.js';
+export * from './query.js';
+export * from './utils.js';
+export * from './schema.js';
+export * from './expressions.js';

package/esm/types/query.js

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

package/esm/types/schema.js

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

package/esm/types/utils.js

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

package/esm/types/value.js

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

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@rushdb/javascript-sdk",
+  "description": "RushDB Javascript SDK",
+  "license": "MIT",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "cjs/index.cjs.node.js",
+  "types": "types/index.d.ts",
+  "devDependencies": {},
+  "peerDependencies": {},
+  "sideEffects": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": "https://github.com/rush-db/rushdb/issues",
+  "repository": {
+    "type": "https",
+    "url": "https://github.com/rush-db/rushdb"
+  },
+  "exports": {
+    "types": "./types/index.d.ts",
+    "browser": {
+      "import": "./esm/index.esm.worker.js",
+      "require": "./cjs/index.cjs.worker.js"
+    },
+    "bun": {
+      "import": "./esm/index.esm.worker.js",
+      "require": "./cjs/index.cjs.worker.js"
+    },
+    "deno": {
+      "import": "./esm/index.esm.worker.js",
+      "require": "./cjs/index.cjs.worker.js"
+    },
+    "worker": {
+      "import": "./esm/index.esm.worker.js",
+      "require": "./cjs/index.cjs.worker.js"
+    },
+    "workerd": {
+      "import": "./esm/index.esm.worker.js",
+      "require": "./cjs/index.cjs.worker.js"
+    },
+    "default": {
+      "import": "./esm/index.esm.node.js",
+      "require": "./cjs/index.cjs.node.js"
+    }
+  },
+  "scripts": {
+    "build": "pnpm clean && pnpm build-esm && pnpm build-cjs && pnpm postbuild",
+    "build-esm": "mkdir -p esm && tsc -p tsconfig.esm.json",
+    "build-cjs": "mkdir -p cjs && tsc -p tsconfig.cjs.json",
+    "postbuild": "node scripts/post-build.js",
+    "dev": "tsup --watch",
+    "types:check": "tsc --noEmit",
+    "clean": "rm -rf ./dist ./node_modules/.cache ./coverage ./esm ./cjs ./types",
+    "flush": "rm -rf node_modules",
+    "lint:circularDeps": "madge --circular ./src/*",
+    "lint:circularDepsWithImage": "madge --image graph.svg --circular ./src/*"
+  }
+}

package/types/api/api.d.ts

@@ -0,0 +1,43 @@
+import type { HttpClient } from '../network/HttpClient.js';
+import type { UserProvidedConfig } from '../sdk/types.js';
+import type { SearchQuery, Schema } from '../types/index.js';
+import type { ApiResponse, RecordsApi } from './types.js';
+import { createFetcher } from '../network/index.js';
+import { Transaction } from '../sdk/transaction.js';
+import { createApi } from './create-api.js';
+export declare class RestAPI {
+    api: ReturnType<typeof createApi>;
+    fetcher: ReturnType<typeof createFetcher>;
+    records: RecordsApi;
+    constructor(token?: string, config?: UserProvidedConfig & {
+        httpClient: HttpClient;
+    });
+    relations: {
+        find: <S extends Schema = any>({ pagination, search, transaction }: {
+            pagination?: Pick<SearchQuery, "limit" | "skip">;
+            search?: SearchQuery<S>;
+            transaction?: Transaction | string;
+        }) => Promise<ApiResponse<import("../sdk/record.js").Relation[]>>;
+    };
+    properties: {
+        delete: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<import("../types/value.js").Property>>;
+        find: <S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<import("../types/value.js").Property[]>>;
+        findById: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<import("../types/value.js").Property>>;
+        values: (id: string, transaction?: Transaction | string) => Promise<ApiResponse<import("../types/value.js").Property & import("../types/value.js").PropertyValuesData>>;
+    };
+    labels: {
+        find: <S extends Schema = any>(searchParams: SearchQuery<S>, transaction?: Transaction | string) => Promise<ApiResponse<Record<string, number>>>;
+    };
+    tx: {
+        begin: (config?: Partial<{
+            ttl: number;
+        }>) => Promise<Transaction>;
+        commit: (id: string) => Promise<ApiResponse<{
+            message: string;
+        }>>;
+        get: (id: string) => Promise<Transaction>;
+        rollback: (id: string) => Promise<ApiResponse<{
+            message: string;
+        }>>;
+    };
+}

package/types/api/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const DEFAULT_HOST = "api.rushdb.com";
+export declare const DEFAULT_PORT = 443;
+export declare const DEFAULT_PROTOCOL = "https";
+export declare const DEFAULT_BASE_PATH = "/api/v1";