@rushdb/javascript-sdk 0.9.3 → 0.9.5

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,77 +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, searchParams) {
-        super();
-        this.data = data;
-        this.searchParams = searchParams;
-    }
-    __date() {
-        return idToDate(this.data.__id);
-    }
-    __timestamp() {
-        return idToTimestamp(this.data.__id);
-    }
-    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

@@ -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 {};

package/esm/sdk/utils.js

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

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

package/esm/types/index.js

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

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

package/esm/types/schema.js

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

package/esm/types/utils.js

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

package/esm/types/value.js

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

package/types/index.d.ts

@@ -1,60 +0,0 @@
-import type { InferType, DBRecord, UserProvidedConfig, Relation } from './sdk'
-
-import { DBRecordsBatchDraft, DBRecordDraft, RestAPI, ApiResponse } from './api'
-import { HttpClient, HttpClientResponse } from './network/HttpClient'
-import {
-  Model,
-  DBRecordInstance,
-  DBRecordsArrayInstance,
-  Transaction,
-  idToDate,
-  idToTimestamp,
-  EmptyTargetError,
-  UniquenessError,
-  NonUniqueResultError
-} from './sdk'
-import { Models, Schema } from './types'
-
-declare module '@rushdb/javascript-sdk' {
-  export namespace RushDB {}
-
-  export class RushDB extends RestAPI {
-    static RushDB: typeof RushDB
-
-    constructor(token?: string, config?: UserProvidedConfig)
-    public api: RestAPI
-
-    public registerModel<Model extends Model = Model>(model: Model): Model //Model<T['schema']>
-    public getModel(label: string): Model
-    public getModels(): Map<string, Model>
-    public getInstance(token: string, config?: UserProvidedConfig): RushDB
-    public toInstance<Schema extends Schema = Schema>(record: DBRecord<Schema>): DBRecordInstance
-  }
-
-  export {
-    DBRecordsBatchDraft,
-    Relation,
-    ApiResponse,
-    InferType,
-    Model,
-    Models,
-    DBRecord,
-    DBRecordDraft,
-    DBRecordInstance,
-    DBRecordsArrayInstance,
-    RestAPI,
-    Schema,
-    Transaction,
-    HttpClient,
-    HttpClientResponse,
-    EmptyTargetError,
-    NonUniqueResultError,
-    UniquenessError,
-    idToDate,
-    idToTimestamp
-  }
-
-  export * from './types'
-
-  export default RushDB
-}