skapi-js 1.2.14-beta.3 → 1.2.14-beta.6

package/js/methods/database.js

@@ -1,947 +0,0 @@
-import SkapiError from '../main/error';
-import { extractFormData, fromBase62 } from '../utils/utils';
-import validator from '../utils/validator';
-import { request, uploadFiles } from '../utils/network';
-import { checkAdmin } from './user';
-import { authentication } from './user';
-import { accessGroup, cannotBeEmptyString, getStruct, indexValue, recordIdOrUniqueId } from './param_restrictions';
-export async function normalizeRecord(record, _called_from) {
-    if (record?.rec) {
-        if (_called_from !== 'called from postRecord') {
-            let recPost = window.sessionStorage.getItem(`${this.service}:post:${record.rec}`);
-            if (recPost) {
-                try {
-                    record = JSON.parse(recPost);
-                }
-                catch (err) { }
-                window.sessionStorage.removeItem(`${this.service}:post:${record.rec}`);
-            }
-        }
-    }
-    const output = {
-        user_id: '',
-        record_id: '',
-        updated: 0,
-        uploaded: 0,
-        readonly: false,
-        table: {
-            name: '',
-            access_group: 0,
-            subscription: {
-                is_subscription_record: false,
-                upload_to_feed: false,
-                notify_subscribers: false,
-                feed_referencing_records: false,
-                notify_referencing_records: false
-            }
-        },
-        referenced_count: 0,
-        source: {
-            referencing_limit: null,
-            prevent_multiple_referencing: false,
-            can_remove_referencing_records: false,
-            only_granted_can_reference: false,
-        },
-        ip: '',
-        bin: {}
-    };
-    let is_anonymous = false;
-    function access_group_set(v) {
-        let access_group = v == '**' ? 'private' : parseInt(v);
-        access_group = access_group == 0 ? 'public' : access_group == 1 ? 'authorized' : access_group == 99 ? 'admin' : access_group;
-        return access_group;
-    }
-    const keys = {
-        'ip': (r) => {
-            let split_ip = r.split('#');
-            let ip = split_ip[0];
-            if (split_ip.length > 1) {
-                output.unique_id = split_ip[1];
-            }
-            if (ip.slice(-1) === 'R') {
-                output.readonly = true;
-                ip = ip.slice(0, -1);
-            }
-            else {
-                output.readonly = false;
-            }
-            if (/^\d{1,3}-\d{1,3}-\d{1,3}-\d{1,3}$/.test(ip)) {
-                ip = ip.split('-').join('.');
-                is_anonymous = true;
-            }
-            output.ip = ip;
-        },
-        'rec': (r) => {
-            if (!r)
-                return;
-            output.record_id = r;
-            let base62timestamp = r.substring(0, r.length - 9);
-            let uploaded = fromBase62(base62timestamp);
-            output.uploaded = uploaded;
-        },
-        'usr': (r) => {
-            output.user_id = r;
-        },
-        'tbl': (r) => {
-            if (!r)
-                return;
-            if (!output.table.name) {
-                let rSplit = r.split('/');
-                output.table.name = rSplit[0];
-                output.table.access_group = access_group_set(rSplit[2]);
-                if (rSplit?.[3]) {
-                    output.table.subscription.is_subscription_record = true;
-                }
-            }
-        },
-        'usr_tbl': (r) => {
-            let rSplit = r.split('/');
-            if (!output.user_id) {
-                output.user_id = rSplit[0];
-            }
-            if (!output.table.name) {
-                output.table.name = rSplit[1];
-                output.table.access_group = access_group_set(rSplit[3]);
-                if (rSplit?.[4]) {
-                    output.table.subscription.is_subscription_record = true;
-                }
-            }
-        },
-        'idx': (r) => {
-            if (!r)
-                return;
-            let rSplit = r.split('!');
-            let name = rSplit.splice(0, 1)[0];
-            let value = normalizeTypedString('!' + rSplit.join('!'));
-            output.index = {
-                name,
-                value
-            };
-        },
-        'ref': (r) => {
-            if (!r)
-                return;
-            output.reference = r.split('/')[0];
-        },
-        'tags': (r) => {
-            output.tags = r;
-        },
-        'upd': (r) => {
-            output.updated = r;
-        },
-        'acpt_mrf': (r) => {
-            output.source.prevent_multiple_referencing = !r;
-        },
-        'ref_limt': (r) => {
-            output.source.referencing_limit = r;
-        },
-        'rfd': (r) => {
-            output.referenced_count = r;
-        },
-        'bin': async (r) => {
-            let binObj = {};
-            let _ref = output?.reference || null;
-            if (Array.isArray(r)) {
-                for (let url of r) {
-                    let path = url.split('/').slice(3).join('/');
-                    let splitPath = path.split('/');
-                    let filename = decodeURIComponent(splitPath.slice(-1)[0]);
-                    let pathKey = decodeURIComponent(splitPath[10]);
-                    let size = splitPath[9];
-                    let uploaded = splitPath[8];
-                    let access_group = access_group_set(splitPath[6]);
-                    let url_endpoint = url;
-                    if (access_group !== 'public') {
-                        url_endpoint = await getFile.bind(this)(url, { dataType: 'endpoint', _ref });
-                    }
-                    let obj = {
-                        access_group,
-                        filename,
-                        url: url_endpoint,
-                        path,
-                        size: fromBase62(size),
-                        uploaded: fromBase62(uploaded),
-                        getFile: (dataType, progress) => {
-                            let config = {
-                                dataType: dataType || 'download',
-                                progress,
-                                _ref,
-                                _update: obj
-                            };
-                            return getFile.bind(this)(url_endpoint, config);
-                        }
-                    };
-                    if (binObj[pathKey]) {
-                        binObj[pathKey].push(obj);
-                        continue;
-                    }
-                    binObj[pathKey] = [obj];
-                }
-            }
-            output.bin = binObj;
-        },
-        'prv_acs': (r) => {
-            for (let k in r) {
-                let subscription_config = ['notify_subscribers', 'upload_to_feed', 'feed_referencing_records', 'notify_referencing_records'];
-                if (subscription_config.includes(k)) {
-                    output.table.subscription[k] = r[k];
-                }
-                else {
-                    output.source[k] = r[k];
-                }
-            }
-        },
-        'data': (r) => {
-            let data = r;
-            if (r === '!D%{}') {
-                data = {};
-            }
-            else if (r === '!L%[]') {
-                data = [];
-            }
-            output.data = data;
-        }
-    };
-    if (record.record_id) {
-        return record;
-    }
-    for (let k in keys) {
-        if (record.hasOwnProperty(k)) {
-            let exec = keys[k](record[k]);
-            if (exec instanceof Promise) {
-                await exec;
-            }
-        }
-    }
-    if (is_anonymous) {
-        output.user_id = 'anonymous:' + output.user_id;
-    }
-    return output;
-}
-function normalizeTypedString(v) {
-    let value = v.substring(3);
-    let type = v.substring(0, 3);
-    switch (type) {
-        case "!S%":
-            return value;
-        case "!N%":
-            let splitDec = value.split('.');
-            let calcNumb = Number(splitDec[0]) - 4503599627370496;
-            if (splitDec.length === 1) {
-                return calcNumb;
-            }
-            return parseFloat(calcNumb.toString() + '.' + splitDec[1]);
-        case "!B%":
-            return value === '1';
-        case "!L%":
-        case "!D%":
-            try {
-                return JSON.parse(value);
-            }
-            catch (err) {
-                throw new SkapiError('Value parse error.', { code: 'PARSE_ERROR' });
-            }
-        default:
-            return v;
-    }
-}
-export async function deleteFiles(params) {
-    let { endpoints } = params;
-    if (typeof endpoints === 'string') {
-        endpoints = [endpoints];
-    }
-    if (!Array.isArray(endpoints)) {
-        throw new SkapiError('"endpoints" should be type: array | string.', { code: 'INVALID_PARAMETER' });
-    }
-    let updatedRec = await request.bind(this)('del-files', {
-        endpoints,
-        storage: 'records'
-    }, { auth: true, method: 'post' });
-    let to_process = [];
-    for (let i in updatedRec) {
-        to_process.push(normalizeRecord.bind(this)(updatedRec[i]));
-    }
-    return Promise.all(to_process);
-}
-export async function getFile(url, config) {
-    if (typeof url !== 'string') {
-        throw new SkapiError('"url" should be type: string.', { code: 'INVALID_PARAMETER' });
-    }
-    url = validator.Url(url.split('?')[0]);
-    let isValidEndpoint = false;
-    let splitUrl = url.split('/');
-    let host = splitUrl[2];
-    let splitHost = host.split('.');
-    let subdomain = null;
-    if (splitHost.length === 3 && splitHost[1] === 'skapi') {
-        subdomain = splitHost[0];
-        isValidEndpoint = true;
-    }
-    let target_key = splitUrl.slice(3);
-    let needAuth = false;
-    if (!isValidEndpoint) {
-        if (target_key[0] === 'auth' || target_key[0] === 'publ') {
-            try {
-                validator.UserId(target_key[2]);
-                validator.UserId(target_key[3]);
-                needAuth = target_key[0] == 'auth';
-                isValidEndpoint = true;
-            }
-            catch {
-                throw new SkapiError('Invalid file url.', { code: 'INVALID_PARAMETER' });
-            }
-        }
-    }
-    let service = subdomain ? null : target_key[1];
-    config = validator.Params(config, {
-        expires: ['number', () => 0],
-        dataType: ['base64', 'blob', 'endpoint', 'text', 'info', () => 'download'],
-        progress: 'function',
-        _ref: 'string',
-        _update: v => v
-    });
-    if (config?.dataType === 'info') {
-        return {
-            url,
-            filename: target_key[target_key.length - 1],
-            fileKey: target_key[target_key.length - 2],
-            access_group: target_key[6] === '**' ? 'private' : target_key[6] === '01' ? 'authorized' : target_key[6] === '00' ? 'public' : parseInt(target_key[6]),
-            uploader: target_key[3],
-            record_id: target_key[4] === 'records' ? target_key[5] : 'N/A',
-            filesize: fromBase62(target_key[9]),
-            uploaded: fromBase62(target_key[8]),
-        };
-    }
-    let filename = url.split('/').slice(-1)[0];
-    let expires = config.expires;
-    if (expires) {
-        if (!isValidEndpoint) {
-            throw new SkapiError('Expires option can only be used on skapi cdn endpoints.', { code: 'INVALID_PARAMETER' });
-        }
-        if (expires < 0) {
-            throw new SkapiError('"config.expires" should be > 0. (seconds)', { code: 'INVALID_PARAMETER' });
-        }
-        let params = {
-            request: subdomain ? 'get-host' : 'get',
-            id: subdomain || target_key[5],
-            key: url,
-            expires
-        };
-        if (service) {
-            params.service = service;
-        }
-        url = (await request.bind(this)('get-signed-url', params, { auth: true })).url;
-    }
-    else if (needAuth) {
-        let currTime = Math.floor(Date.now() / 1000);
-        if (!this.bearerToken && this.session?.idToken?.payload?.exp < currTime) {
-            this.log('getFile:requesting new token', null);
-            try {
-                await authentication.bind(this)().getSession({ refreshToken: true });
-                this.log('getFile:received new tokens', {
-                    exp: this.session?.idToken?.payload?.exp,
-                    currTime,
-                    expiresIn: this.session?.idToken?.payload?.exp - currTime,
-                    token: this.session?.accessToken?.jwtToken,
-                    refreshToken: this.session?.refreshToken?.token
-                });
-            }
-            catch (err) {
-                this.log('getFile:new token error', err);
-                throw new SkapiError('User login is required.', { code: 'INVALID_REQUEST' });
-            }
-        }
-        let token = this.bearerToken || this.session?.idToken?.jwtToken;
-        url += `?t=${token}`;
-        let access_group = target_key[6] === '**' ? '**' : parseInt(target_key[6]);
-        if (this.user.user_id !== target_key[3] && (access_group === '**' || this.user?.access_group < access_group)) {
-            let record_id = target_key[5];
-            if (this.__private_access_key[record_id] && typeof this.__private_access_key[record_id] === 'string') {
-                url += '&p=' + this.__private_access_key[record_id];
-            }
-            else if (this.owner !== this.host) {
-                try {
-                    let p = await this.requestPrivateRecordAccessKey({ record_id, reference_id: config?._ref });
-                    url += '&p=' + p;
-                }
-                catch (err) { }
-            }
-        }
-    }
-    if (config?.dataType === 'endpoint') {
-        if (config._update) {
-            config._update.url = url;
-        }
-        return url;
-    }
-    if (config?.dataType === 'download') {
-        let a = document.createElement('a');
-        a.href = url;
-        document.body.appendChild(a);
-        a.setAttribute('download', filename);
-        a.target = '_blank';
-        a.click();
-        document.body.removeChild(a);
-        return null;
-    }
-    let blob = new Promise(async (res, rej) => {
-        try {
-            let b = await request.bind(this)(url, null, { method: 'get', contentType: null, responseType: config?.dataType === 'text' ? 'text' : 'blob', fetchOptions: { progress: config?.progress } }, { ignoreService: true });
-            if (config?.dataType === 'base64') {
-                const reader = new FileReader();
-                reader.onloadend = () => res(reader.result);
-                reader.readAsDataURL(b);
-            }
-            else {
-                res(b);
-            }
-        }
-        catch (err) {
-            rej(err);
-        }
-    });
-    return blob;
-}
-async function prepGetParams(query, isDel = false) {
-    query = extractFormData(query, { ignoreEmpty: true }).data;
-    if (typeof query?.table === 'string') {
-        query.table = {
-            name: query.table,
-            access_group: 0
-        };
-    }
-    let is_reference_fetch = '';
-    let rec_or_uniq = recordIdOrUniqueId(query);
-    if (rec_or_uniq) {
-        query = rec_or_uniq;
-        is_reference_fetch = query.record_id || query.unique_id;
-        if (typeof is_reference_fetch === 'string') {
-            if (typeof this.__private_access_key?.[is_reference_fetch] === 'string') {
-                query.private_key = this.__private_access_key?.[is_reference_fetch] || undefined;
-            }
-            if (this.__my_unique_ids[is_reference_fetch]) {
-                if (isDel) {
-                    delete this.__my_unique_ids[is_reference_fetch];
-                }
-                else {
-                    query.record_id = this.__my_unique_ids[is_reference_fetch];
-                }
-            }
-        }
-    }
-    else {
-        let isAdmin = await checkAdmin.bind(this)();
-        let ref = query.reference;
-        let ref_user = '';
-        if (ref?.record_id || ref?.unique_id) {
-            is_reference_fetch = ref.record_id || ref.unique_id;
-            if (is_reference_fetch && typeof this.__private_access_key?.[is_reference_fetch] === 'string') {
-                query.private_key = this.__private_access_key?.[is_reference_fetch] || undefined;
-            }
-            query.reference = is_reference_fetch;
-        }
-        else if (ref?.user_id) {
-            ref_user = ref.user_id;
-            query.reference = ref_user;
-        }
-        query = validator.Params(query || {}, getStruct.bind(this)(query), ref_user || isAdmin ? [] : ['table'], { ignoreEmpty: true });
-    }
-    return {
-        query,
-        is_reference_fetch
-    };
-}
-export async function getRecords(query, fetchOptions) {
-    await this.__connection;
-    let q = await prepGetParams.bind(this)(query);
-    let is_reference_fetch = q.is_reference_fetch;
-    let result = await request.bind(this)('get-records', q.query, {
-        fetchOptions,
-        auth: !!this.__user,
-        method: !!this.__user ? 'post' : 'get'
-    });
-    if (is_reference_fetch && result?.reference_private_key && typeof result.reference_private_key === 'string') {
-        this.__private_access_key[is_reference_fetch] = result.reference_private_key;
-    }
-    let to_process = [];
-    for (let i in result.list) {
-        to_process.push(normalizeRecord.bind(this)(result.list[i]));
-    }
-    result.list = await Promise.all(to_process);
-    return result;
-}
-export async function postRecord(form, config, files) {
-    await this.__connection;
-    let is_reference_post = "";
-    if (!config) {
-        throw new SkapiError('"config" argument is required.', { code: 'INVALID_PARAMETER' });
-    }
-    let is_public = !this.__user;
-    if (typeof config.table === 'string') {
-        config.table = {
-            name: config.table
-        };
-    }
-    if (!config.record_id && !config.table.hasOwnProperty('access_group')) {
-        config.table.access_group = 0;
-    }
-    let reference_limit_check = (v) => {
-        if (v === null) {
-            return null;
-        }
-        else if (typeof v === 'number') {
-            if (0 > v) {
-                throw new SkapiError(`"reference_limit" should be >= 0`, { code: 'INVALID_PARAMETER' });
-            }
-            if (v > 4503599627370546) {
-                throw new SkapiError(`"reference_limit" should be <= 4503599627370546`, { code: 'INVALID_PARAMETER' });
-            }
-            return v;
-        }
-        throw new SkapiError(`"reference_limit" should be type: <number | null>`, { code: 'INVALID_PARAMETER' });
-    };
-    if (config.table?.subscription) {
-        if (config.table?.subscription?.is_subscription_record) {
-            Object.assign(config.table.subscription, { group: 1 });
-        }
-        else if (config.table?.subscription?.is_subscription_record === false || !config.record_id && !config.table.subscription?.is_subscription_record) {
-            Object.assign(config.table.subscription, { group: null });
-        }
-        delete config.table.subscription?.is_subscription_record;
-    }
-    let _config = validator.Params(config || {}, {
-        record_id: ['string', () => {
-                if (!config.table || !config.table.name) {
-                    throw new SkapiError('"table.name" is required.', { code: 'INVALID_PARAMETER' });
-                }
-            }],
-        unique_id: 'string',
-        readonly: 'boolean',
-        table: {
-            name: v => cannotBeEmptyString(v, 'table name', true, true),
-            subscription: {
-                group: v => {
-                    if (v === 1) {
-                        return 1;
-                    }
-                    return null;
-                },
-                upload_to_feed: 'boolean',
-                notify_subscribers: 'boolean',
-                feed_referencing_records: 'boolean',
-                notify_referencing_records: 'boolean',
-            },
-            access_group: accessGroup.bind(this),
-        },
-        source: {
-            referencing_limit: reference_limit_check,
-            prevent_multiple_referencing: 'boolean',
-            can_remove_referencing_records: 'boolean',
-            only_granted_can_reference: 'boolean',
-            allow_granted_to_grant_others: 'boolean',
-            referencing_index_restrictions: v => {
-                if (v === undefined) {
-                    return undefined;
-                }
-                if (!v) {
-                    return null;
-                }
-                if (Array.isArray(v) && !v.length) {
-                    return null;
-                }
-                let p = {
-                    name: [v => cannotBeEmptyString(v, '"name" in "index_restrictions"', true, false)],
-                    value: v => indexValue(v),
-                    condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne', () => null],
-                    range: val => {
-                        if (val !== null && typeof v.value !== typeof val) {
-                            throw new SkapiError('Index restriction "range" type should match the type of "value".', { code: 'INVALID_PARAMETER' });
-                        }
-                        if (!v.hasOwnProperty('value')) {
-                            throw new SkapiError('Index restriction "value" is required.', { code: 'INVALID_PARAMETER' });
-                        }
-                        if (v.condition && (v.condition !== 'eq' || v.condition !== '=')) {
-                            throw new SkapiError('Index restriction "condition" cannot be used with "range".', { code: 'INVALID_PARAMETER' });
-                        }
-                        return val;
-                    }
-                };
-                if (!Array.isArray(v)) {
-                    v = [v];
-                }
-                return v.map(vv => validator.Params(vv, p));
-            },
-        },
-        reference: v => {
-            if (v === null) {
-                return { record_id: null };
-            }
-            if (!v) {
-                return undefined;
-            }
-            if (typeof v === 'string') {
-                is_reference_post = v;
-                if (this.__my_unique_ids[v]) {
-                    return this.__my_unique_ids[v];
-                }
-                return v;
-            }
-            if (typeof v !== 'object') {
-                throw new SkapiError('"reference" should be type: <string | object>.', { code: 'INVALID_PARAMETER' });
-            }
-            return validator.Params(v, {
-                unique_id: 'string',
-                record_id: v => {
-                    if (v === null || v === undefined) {
-                        return v;
-                    }
-                    is_reference_post = v;
-                    if (typeof this.__private_access_key?.[v] === 'string') {
-                        config.reference_private_key = this.__private_access_key[v] || undefined;
-                    }
-                    return validator.specialChars(v, '"reference.record_id"', false, false);
-                }
-            });
-        },
-        index: {
-            name: v => cannotBeEmptyString(v, 'index.name', true, false),
-            value: v => indexValue(v)
-        },
-        tags: (v) => {
-            if (v === null || v === undefined) {
-                return v;
-            }
-            if (typeof v === 'string') {
-                v = v.split(',').map(t => t.trim());
-            }
-            return validator.specialChars(v, 'tag', false, true);
-        },
-        remove_bin: (v) => {
-            if (!v) {
-                return null;
-            }
-            let arr = [];
-            if (Array.isArray(v)) {
-                for (let i of v) {
-                    if (typeof i === 'string') {
-                        arr.push(decodeURIComponent(i.split('?')[0]));
-                    }
-                    else if (i.url && i.size && i.filename) {
-                        let hostUrl = i.url.split('/').slice(0, 3).join('/');
-                        let url = hostUrl + '/' + i.path;
-                        arr.push(url);
-                    }
-                    else {
-                        throw new SkapiError(`"remove_bin" should be type: <string[] | BinaryFile[] | null>`, { code: 'INVALID_PARAMETER' });
-                    }
-                }
-            }
-            else {
-                throw new SkapiError(`"remove_bin" should be type: <string[] | BinaryFile[] | null>`, { code: 'INVALID_PARAMETER' });
-            }
-            return arr;
-        },
-        progress: 'function',
-    });
-    let progress = config.progress || null;
-    delete _config.progress;
-    let options = { auth: !!this.__user, method: 'post' };
-    let postData = null;
-    let to_bin = null;
-    let extractedForm = extractFormData(form);
-    if (files) {
-        to_bin = files;
-    }
-    else if (extractedForm.files.length) {
-        to_bin = extractedForm.files;
-    }
-    if (is_public) {
-        if (_config.record_id) {
-            throw new SkapiError('Public users cannot update existing records.', { code: 'INVALID_REQUEST' });
-        }
-        if (_config.table.access_group !== 'public' && _config.table.access_group !== 0) {
-            throw new SkapiError('Public users can only post records to public tables.', { code: 'INVALID_REQUEST' });
-        }
-        if (_config.table.subscription) {
-            throw new SkapiError('Public users cannot post subscription records.', { code: 'INVALID_REQUEST' });
-        }
-        if (_config.remove_bin) {
-            throw new SkapiError('Public users cannot remove files from records.', { code: 'INVALID_REQUEST' });
-        }
-        if (_config.unique_id) {
-            throw new SkapiError('Public users cannot set unique_id for records.', { code: 'INVALID_REQUEST' });
-        }
-    }
-    postData = Object.assign({ data: extractedForm.data }, _config);
-    let fetchOptions = {};
-    if (typeof progress === 'function') {
-        fetchOptions.progress = progress;
-    }
-    if (Object.keys(fetchOptions).length) {
-        Object.assign(options, { fetchOptions });
-    }
-    let rec = await request.bind(this)('post-record', postData, options);
-    if (to_bin) {
-        let bin_formData = new FormData();
-        for (let f of to_bin) {
-            bin_formData.append(f.name, f.file, f.file.name);
-        }
-        let uploadFileParams = {
-            record_id: rec.rec,
-            progress
-        };
-        if (_config.hasOwnProperty('service')) {
-            uploadFileParams['service'] = _config.service;
-        }
-        let { bin_endpoints } = await uploadFiles.bind(this)(bin_formData, uploadFileParams);
-        if (!rec.bin) {
-            rec.bin = bin_endpoints;
-        }
-        else {
-            rec.bin.push(...bin_endpoints);
-        }
-    }
-    if (is_reference_post && typeof rec?.reference_private_key === 'string') {
-        this.__private_access_key[is_reference_post] = rec.reference_private_key;
-    }
-    window.sessionStorage.setItem(`${this.service}:post:${rec.rec}`, JSON.stringify(rec));
-    let record = await normalizeRecord.bind(this)(rec, 'called from postRecord');
-    if (record.unique_id) {
-        this.__my_unique_ids[record.unique_id] = record.record_id;
-        window.sessionStorage.setItem(`${this.service}:uniqueids`, JSON.stringify(this.__my_unique_ids));
-    }
-    return record;
-}
-export async function getTables(query, fetchOptions) {
-    let res = await request.bind(this)('get-table', validator.Params(query || {}, {
-        table: 'string',
-        condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne']
-    }), Object.assign({ auth: !!this.__user }, { fetchOptions }));
-    let convert = {
-        'cnt_rec': 'number_of_records',
-        'tbl': 'table',
-        'srvc': 'service'
-    };
-    if (Array.isArray(res?.list)) {
-        for (let t of res.list) {
-            for (let k in convert) {
-                if (t.hasOwnProperty(k)) {
-                    t[convert[k]] = t[k];
-                    delete t[k];
-                }
-            }
-        }
-    }
-    return res;
-}
-export async function getIndexes(query, fetchOptions) {
-    if (!query?.table) {
-        throw new SkapiError('"table" is required.', { code: 'INVALID_PARAMETER' });
-    }
-    let p = validator.Params(query || {}, {
-        table: 'string',
-        index: (v) => validator.specialChars(v, 'index name', true, false),
-        order: {
-            by: [
-                'average_number',
-                'total_number',
-                'number_count',
-                'average_bool',
-                'total_bool',
-                'bool_count',
-                'string_count',
-                'index_name',
-                'number_of_records'
-            ],
-            value: ['string', 'number', 'boolean'],
-            condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne']
-        }
-    }, ['table']);
-    if (p.hasOwnProperty('order')) {
-        if (!p.order?.by) {
-            throw new SkapiError('"order.by" is required.', { code: 'INVALID_PARAMETER' });
-        }
-        if (p.order.hasOwnProperty('condition') && !p.order.hasOwnProperty('value')) {
-            throw new SkapiError('"value" is required for "condition".', { code: 'INVALID_PARAMETER' });
-        }
-        if (p.hasOwnProperty('index')) {
-            if (p.index.substring(p.index.length - 1) !== '.') {
-                throw new SkapiError('"index" should be a parent index name of the compound index when using "order.by"', { code: 'INVALID_PARAMETER' });
-            }
-        }
-    }
-    let res = await request.bind(this)('get-index', p, Object.assign({ auth: !!this.__user }, { fetchOptions }));
-    let convert = {
-        'cnt_bool': 'boolean_count',
-        'cnt_numb': 'number_count',
-        'totl_numb': 'total_number',
-        'totl_bool': 'total_bool',
-        'avrg_numb': 'average_number',
-        'avrg_bool': 'average_bool',
-        'cnt_str': 'string_count'
-    };
-    if (Array.isArray(res?.list)) {
-        res.list = res.list.map((i) => {
-            let iSplit = i.idx.split('/');
-            let resolved = {
-                table: iSplit[1],
-                index: iSplit[2],
-                number_of_records: i.cnt_rec
-            };
-            for (let k in convert) {
-                if (i?.[k]) {
-                    resolved[convert[k]] = i[k];
-                }
-            }
-            return resolved;
-        });
-    }
-    return res;
-}
-export async function getTags(query, fetchOptions) {
-    let res = await request.bind(this)('get-tag', validator.Params(query || {}, {
-        table: 'string',
-        tag: 'string',
-        condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne']
-    }), Object.assign({ auth: !!this.__user }, { fetchOptions }));
-    if (Array.isArray(res?.list)) {
-        res.list = res.list.map(item => {
-            let tSplit = item.tag.split('/');
-            return {
-                table: tSplit[1],
-                tag: tSplit[0],
-                number_of_records: item.cnt_rec
-            };
-        });
-    }
-    return res;
-}
-export async function getUniqueId(query, fetchOptions) {
-    let res = await request.bind(this)('get-uniqueid', validator.Params(query || {}, {
-        unique_id: 'string',
-        condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne']
-    }), Object.assign({ auth: !!this.__user }, { fetchOptions }));
-    if (Array.isArray(res?.list)) {
-        for (let i in res.list) {
-            let item = res.list[i];
-            res.list[i] = {
-                unique_id: item.unq,
-                record_id: item.rec
-            };
-        }
-    }
-    return res;
-}
-export async function deleteRecords(query, fetchOptions) {
-    await this.__connection;
-    let q = await prepGetParams.bind(this)(query, true);
-    let is_reference_fetch = q.is_reference_fetch;
-    let result = await request.bind(this)('del-records', q.query, { auth: true, fetchOptions });
-    if (is_reference_fetch && typeof result?.reference_private_key === 'string') {
-        this.__private_access_key[is_reference_fetch] = result.reference_private_key;
-    }
-    return result?.message || result;
-}
-export function grantPrivateRecordAccess(params) {
-    return recordAccess.bind(this)({
-        record_id: params.record_id,
-        user_id: params.user_id,
-        execute: 'add'
-    });
-}
-export function removePrivateRecordAccess(params) {
-    return recordAccess.bind(this)({
-        record_id: params.record_id,
-        user_id: params.user_id || null,
-        execute: 'remove'
-    });
-}
-export async function listPrivateRecordAccess(p, fetchOptions) {
-    let params = {
-        record_id: p.record_id || undefined,
-        user_id: p.user_id || undefined,
-        execute: 'list'
-    };
-    if (!params.record_id && !params.user_id) {
-        throw new SkapiError(`Either record_id or user_id must be provided.`, { code: 'INVALID_PARAMETER' });
-    }
-    if (params.user_id) {
-        if (typeof params.user_id === 'string') {
-            validator.UserId(params.user_id);
-            params.user_id = [params.user_id];
-        }
-        else if (Array.isArray(params.user_id)) {
-            for (let u of params.user_id) {
-                validator.UserId(u);
-            }
-        }
-        else {
-            throw new SkapiError(`user_id should be type: <string | string[]>`, { code: 'INVALID_PARAMETER' });
-        }
-    }
-    let mapper = (i) => {
-        if (i.rec_usr) {
-            i.record_id = i.rec_usr.split('/')[0];
-            i.user_id = i.rec_usr.split('/')[1];
-        }
-        else if (i.usr_rec) {
-            i.user_id = i.usr_rec.split('/')[0];
-            i.record_id = i.usr_rec.split('/')[1];
-        }
-        return i;
-    };
-    let list = await request.bind(this)('grant-private-access', params, { auth: true, fetchOptions });
-    list.list = list.list.map(mapper);
-    return list;
-}
-export function requestPrivateRecordAccessKey(params) {
-    let record_id = params.record_id;
-    let reference_id = params.reference_id || undefined;
-    if (!record_id) {
-        throw new SkapiError(`Record ID is required.`, { code: 'INVALID_PARAMETER' });
-    }
-    if (typeof record_id !== 'string') {
-        throw new SkapiError(`Record ID should be type: <string | string[]>`, { code: 'INVALID_PARAMETER' });
-    }
-    if (reference_id && typeof reference_id !== 'string') {
-        throw new SkapiError(`Reference ID should be type: <string>`, { code: 'INVALID_PARAMETER' });
-    }
-    if (this.__private_access_key[record_id]) {
-        return this.__private_access_key[record_id];
-    }
-    let res = request.bind(this)('request-private-access-key', { record_id, reference_id }, { auth: true });
-    this.__private_access_key[record_id] = res;
-    return res;
-}
-function recordAccess(params) {
-    let execute = params.execute;
-    let req = validator.Params(params, {
-        record_id: 'string',
-        user_id: (v) => {
-            if (!v) {
-                throw new SkapiError(`User ID is required.`, { code: 'INVALID_PARAMETER' });
-            }
-            let id = v;
-            if (typeof id === 'string') {
-                id = [id];
-            }
-            if (id.length > 100) {
-                throw new SkapiError(`Cannot process more than 100 users at once.`, { code: 'INVALID_REQUEST' });
-            }
-            for (let i of id) {
-                validator.UserId(i, 'User ID in "user_id"');
-            }
-            return id;
-        },
-        execute: ['add', 'remove']
-    }, [
-        'execute',
-        'record_id',
-        'user_id'
-    ]);
-    if (!req.user_id) {
-        req.user_id = null;
-    }
-    return request.bind(this)('grant-private-access', req, { auth: true });
-}
-//# sourceMappingURL=database.js.map