skapi-js 0.2.0 → 0.2.2

package/js/methods/database.js

@@ -0,0 +1,915 @@
+import SkapiError from '../main/error';
+import { extractFormMeta, generateRandom } from '../utils/utils';
+import validator from '../utils/validator';
+import { request } from './request';
+import { checkAdmin } from './user';
+const __index_number_range = 4503599627370496;
+function normalizeRecord(record) {
+    function base_decode(chars) {
+        let charset = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+        return chars.split('').reverse().reduce((prev, curr, i) => prev + (charset.indexOf(curr) * (62 ** i)), 0);
+    }
+    const output = {
+        user_id: '',
+        record_id: '',
+        updated: 0,
+        uploaded: 0,
+        table: {
+            name: '',
+            access_group: 0
+        },
+        reference: {
+            reference_limit: null,
+            allow_multiple_reference: true,
+            referenced_count: 0
+        },
+        ip: '',
+        bin: []
+    };
+    const keys = {
+        'ip': (r) => {
+            output.ip = r;
+        },
+        'rec': (r) => {
+            if (!r)
+                return;
+            output.record_id = r;
+            let base62timestamp = r.substring(0, r.length - 9);
+            let uploaded = base_decode(base62timestamp);
+            output.uploaded = uploaded;
+        },
+        'usr': (r) => {
+            output.user_id = r;
+        },
+        'tbl': (r) => {
+            if (!r)
+                return;
+            let rSplit = r.split('/');
+            output.table.name = rSplit[0];
+            output.table.access_group = rSplit[2] == '**' ? 'private' : parseInt(rSplit[2]);
+            if (rSplit?.[3]) {
+                output.table.subscription = {
+                    user_id: rSplit[3],
+                    group: parseInt(rSplit[4])
+                };
+            }
+        },
+        'usr_tbl': (r) => {
+            let rSplit = r.split('/');
+            output.user_id = rSplit[0];
+            output.table.name = rSplit[1];
+            output.table.access_group = rSplit[3] == '**' ? 'private' : parseInt(rSplit[3]);
+            if (rSplit?.[4]) {
+                output.table.subscription = {
+                    user_id: rSplit[4],
+                    group: parseInt(rSplit[5])
+                };
+            }
+        },
+        '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.record_id = r.split('/')[0];
+        },
+        'tags': (r) => {
+            output.tags = r;
+        },
+        'upd': (r) => {
+            output.updated = r;
+        },
+        'acpt_mrf': (r) => {
+            output.reference.allow_multiple_reference = r;
+        },
+        'ref_limt': (r) => {
+            output.reference.reference_limit = r;
+        },
+        'rfd': (r) => {
+            output.reference.referenced_count = r;
+        },
+        'bin': (r) => {
+            output.bin = r;
+        },
+        '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)) {
+            keys[k](record[k]);
+        }
+    }
+    return output;
+}
+function normalizeTypedString(v) {
+    let value = v.substring(3);
+    let type = v.substring(0, 3);
+    switch (type) {
+        case "!S%":
+            return value;
+        case "!N%":
+            return Number(value) - 4503599627370496;
+        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 isAdmin = await checkAdmin.bind(this)();
+    let { service = this.service, endpoints, storage = 'records' } = params;
+    if (storage === 'host' && !isAdmin) {
+        throw new SkapiError("No access", { code: 'INVALID_REQUEST' });
+    }
+    if (typeof endpoints === 'string') {
+        endpoints = [endpoints];
+    }
+    if (!Array.isArray(endpoints)) {
+        throw new SkapiError('"endpoints" should be type: array | string.', { code: 'INVALID_PARAMETER' });
+    }
+    if (storage !== 'host' && storage !== 'records') {
+        throw new SkapiError('"storage" should be type: "records" | "host".', { code: 'INVALID_PARAMETER' });
+    }
+    return request.bind(this)('del-files', {
+        service,
+        endpoints,
+        storage
+    }, { auth: true, method: 'post' });
+}
+export async function uploadFiles(fileList, params) {
+    let isAdmin = await checkAdmin.bind(this)();
+    if (fileList instanceof SubmitEvent) {
+        fileList = fileList.target;
+    }
+    if (fileList instanceof HTMLFormElement) {
+        fileList = new FormData(fileList);
+    }
+    if (fileList instanceof FormData) {
+        let fileEntries = [];
+        for (let entry of fileList.entries()) {
+            let value = entry[1];
+            if (value instanceof File) {
+                fileEntries.push(value);
+            }
+        }
+        fileList = fileEntries;
+    }
+    if (!(fileList[0] instanceof File)) {
+        throw new SkapiError('"fileList" should be a FileList or array of File object.', { code: 'INVALID_PARAMETER' });
+    }
+    let reserved_key = generateRandom();
+    let getSignedParams = {
+        reserved_key,
+        service: params?.service || this.service,
+        request: params?.request || 'post'
+    };
+    if (getSignedParams.request === 'host') {
+        if (!isAdmin) {
+            throw new SkapiError('The user has no access.', { code: 'INVALID_REQUEST' });
+        }
+        getSignedParams.request === 'post-host';
+    }
+    if (params?.record_id) {
+        getSignedParams.id = params.record_id;
+    }
+    else if (!isAdmin) {
+        throw new SkapiError('Record ID is required.', { code: 'INVALID_PARAMETER' });
+    }
+    let xhr;
+    let fetchProgress = (url, body, progressCallback) => {
+        return new Promise((res, rej) => {
+            xhr = new XMLHttpRequest();
+            xhr.open('POST', url);
+            xhr.onload = (e) => {
+                let result = xhr.responseText;
+                try {
+                    result = JSON.parse(result);
+                }
+                catch (err) { }
+                if (xhr.status >= 200 && xhr.status < 300) {
+                    let result = xhr.responseText;
+                    try {
+                        result = JSON.parse(result);
+                    }
+                    catch (err) { }
+                    res(result);
+                }
+                else {
+                    rej(result);
+                }
+            };
+            xhr.onerror = () => rej('Network error');
+            xhr.onabort = () => rej('Aborted');
+            xhr.ontimeout = () => rej('Timeout');
+            if (xhr.upload && typeof params.progress === 'function') {
+                xhr.upload.onprogress = progressCallback;
+            }
+            xhr.send(body);
+        });
+    };
+    let completed = [];
+    let failed = [];
+    function toBase62(num) {
+        const base62Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+        if (num === 0)
+            return base62Chars[0];
+        let result = '';
+        while (num > 0) {
+            result = base62Chars[num % 62] + result;
+            num = Math.floor(num / 62);
+        }
+        return result;
+    }
+    for (let f of fileList) {
+        let signedParams = Object.assign({
+            key: f.name,
+            sizeKey: toBase62(f.size),
+            contentType: f.type || null
+        }, getSignedParams);
+        let { fields = null, url } = await request.bind(this)('get-signed-url', signedParams, { auth: true });
+        let form = new FormData();
+        for (let name in fields) {
+            form.append(name, fields[name]);
+        }
+        form.append('file', f);
+        try {
+            await fetchProgress(url, form, (p) => {
+                params.progress({
+                    status: 'upload',
+                    progress: p.loaded / p.total * 100,
+                    currentFile: f,
+                    completed,
+                    failed,
+                    loaded: p.loaded,
+                    total: p.total,
+                    abort: () => xhr.abort()
+                });
+            });
+            completed.push(f);
+        }
+        catch (err) {
+            failed.push(f);
+        }
+    }
+    return { completed, failed };
+}
+export async function getFile(url, config) {
+    if (typeof url !== 'string') {
+        throw new SkapiError('"url" should be type: string.', { code: 'INVALID_PARAMETER' });
+    }
+    if (!config?.noCdn) {
+        validator.Url(url);
+    }
+    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);
+    if (!isValidEndpoint) {
+        if (target_key[0] !== 'auth' && target_key[0] !== 'publ') {
+            throw new SkapiError('Invalid file url.', { code: 'INVALID_PARAMETER' });
+        }
+        try {
+            validator.UserId(target_key[2]);
+            validator.UserId(target_key[3]);
+        }
+        catch {
+            throw new SkapiError('Invalid file url.', { code: 'INVALID_PARAMETER' });
+        }
+    }
+    let service = subdomain ? null : target_key[1];
+    validator.Params(config, {
+        expiration: ['number', () => 60],
+        noCdn: ['boolean', () => false],
+        dataType: ['base64', 'blob', 'endpoint', 'download', () => 'download']
+    }, [], ['progress']);
+    let needAuth = target_key[0] == 'auth';
+    let filename = url.split('/').slice(-1)[0];
+    if (config?.noCdn || needAuth && (config?.dataType === 'download' || config?.dataType === 'endpoint')) {
+        let params = {
+            request: subdomain ? 'get-host' : 'get',
+            id: subdomain || target_key[5],
+            key: url
+        };
+        if (service) {
+            params.service = service;
+        }
+        url = (await request.bind(this)('get-signed-url', params, { auth: true })).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;
+    }
+    if (config?.dataType === 'endpoint') {
+        return url;
+    }
+    let blob = await request.bind(this)(url, { service: service || this.service }, { method: 'get', auth: needAuth, contentType: null, responseType: 'blob', fetchOptions: { progress: config?.progress } });
+    if (config?.dataType === 'base64') {
+        function blobToBase64(blob) {
+            return new Promise((resolve, _) => {
+                const reader = new FileReader();
+                reader.onloadend = () => resolve(reader.result);
+                reader.readAsDataURL(blob);
+            });
+        }
+        return blobToBase64(blob);
+    }
+    return blob;
+}
+export async function getRecords(query, fetchOptions) {
+    await this.__connection;
+    const indexTypes = {
+        '$updated': 'number',
+        '$uploaded': 'number',
+        '$referenced_count': 'number'
+    };
+    if (typeof query?.table === 'string') {
+        query.table = {
+            name: query.table,
+            access_group: 0
+        };
+    }
+    const struct = {
+        table: {
+            name: 'string',
+            access_group: ['number', 'private', 'public', 'authorized'],
+            subscription: {
+                user_id: (v) => validator.UserId(v, 'User ID in "subscription.user_id"'),
+                group: (v) => {
+                    if (typeof v !== 'number') {
+                        throw new SkapiError('"subscription.group" should be type: number.', { code: 'INVALID_PARAMETER' });
+                    }
+                    if (v > 99 || v < 0) {
+                        throw new SkapiError('"subscription.group" should be within range: 0 ~ 99.', { code: 'INVALID_PARAMETER' });
+                    }
+                    return v;
+                }
+            }
+        },
+        reference: 'string',
+        index: {
+            name: (v) => {
+                if (typeof v !== 'string') {
+                    throw new SkapiError('"index.name" should be type: string.', { code: 'INVALID_PARAMETER' });
+                }
+                if (indexTypes.hasOwnProperty(v)) {
+                    return v;
+                }
+                if (['$uploaded', '$updated', '$referenced_count', '$user_id'].includes(v)) {
+                    return v;
+                }
+                return validator.specialChars(v, 'index.name', true, false);
+            },
+            value: (v) => {
+                if (query.index?.name && indexTypes.hasOwnProperty(query.index.name)) {
+                    let tp = indexTypes[query.index.name];
+                    if (typeof v === tp) {
+                        return v;
+                    }
+                    else {
+                        throw new SkapiError(`"index.value" should be type: ${tp}.`, { code: 'INVALID_PARAMETER' });
+                    }
+                }
+                if (typeof v === 'number') {
+                    if (v > __index_number_range || v < -__index_number_range) {
+                        throw new SkapiError(`Number value should be within range -${__index_number_range} ~ +${__index_number_range}`, { code: 'INVALID_PARAMETER' });
+                    }
+                    return v;
+                }
+                else if (typeof v === 'boolean') {
+                    return v;
+                }
+                else {
+                    if ('$user_id' == query.index?.name) {
+                        return validator.UserId(v);
+                    }
+                    return validator.specialChars(v, 'index.value', false, true);
+                }
+            },
+            condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne'],
+            range: (v) => {
+                if (!query.index || !('value' in query.index)) {
+                    throw new SkapiError('"index.value" is required.', { code: 'INVALID_PARAMETER' });
+                }
+                if (query.index.name === '$record_id') {
+                    throw new SkapiError(`Cannot do "index.range" on ${query.index.name}`, { code: 'INVALID_PARAMETER' });
+                }
+                if (typeof query.index.value !== typeof v) {
+                    throw new SkapiError('"index.range" type should match the type of "index.value".', { code: 'INVALID_PARAMETER' });
+                }
+                if (typeof v === 'string') {
+                    return validator.specialChars(v, 'index.value');
+                }
+                return v;
+            }
+        },
+        tag: 'string',
+        private_access_key: 'string'
+    };
+    if (query?.table) {
+        if (query.table.access_group === 'public') {
+            query.table.access_group = 0;
+        }
+        else if (query.table.access_group === 'authorized') {
+            query.table.access_group = 1;
+        }
+        if (typeof query.table.access_group === 'number') {
+            if (!this.__user) {
+                if (0 < query.table.access_group) {
+                    throw new SkapiError("User has no access", { code: 'INVALID_REQUEST' });
+                }
+            }
+            else if (this.user.access_group < query.table.access_group) {
+                throw new SkapiError("User has no access", { code: 'INVALID_REQUEST' });
+            }
+        }
+    }
+    if (query?.index && !query.index?.name) {
+        throw new SkapiError('"index.name" is required when using "index" parameter.', { code: 'INVALID_REQUEST' });
+    }
+    if (query?.record_id) {
+        validator.specialChars(query.record_id, 'record_id', false, false);
+        let outputObj = { record_id: query.record_id };
+        if (query?.service) {
+            outputObj.service = query.service;
+        }
+        query = outputObj;
+    }
+    else {
+        let ref_user;
+        if (!this.session && query.table?.access_group === 'private') {
+            throw new SkapiError('Unsigned users have no access to private records.', { code: 'INVALID_REQUEST' });
+        }
+        if (query.reference) {
+            try {
+                ref_user = validator.UserId(query?.reference);
+            }
+            catch (err) {
+            }
+        }
+        query = validator.Params(query || {}, struct, ref_user ? [] : ['table']);
+        if (query.table?.subscription && !this.session) {
+            throw new SkapiError('Unsigned users have no access to subscription records.', { code: 'INVALID_REQUEST' });
+        }
+    }
+    let auth = query.hasOwnProperty('access_group') && query.table.access_group ? true : !!this.__user;
+    let result = await request.bind(this)('get-records', query, {
+        fetchOptions,
+        auth,
+        method: auth ? 'post' : 'get'
+    });
+    for (let i in result.list) {
+        result.list[i] = normalizeRecord(result.list[i]);
+    }
+    ;
+    return result;
+}
+export async function postRecord(form, config) {
+    let isAdmin = await this.checkAdmin();
+    if (!config) {
+        throw new SkapiError('"config" argument is required.', { code: 'INVALID_PARAMETER' });
+    }
+    if (!this.user) {
+        throw new SkapiError('Login is required.', { code: 'INVALID_REQUEST' });
+    }
+    let fetchOptions = {};
+    if (typeof config?.formData === 'function') {
+        fetchOptions.formData = config.formData;
+        delete config.formData;
+    }
+    if (typeof config.table === 'string') {
+        config.table = {
+            name: config.table
+        };
+        if (!config.record_id) {
+            config.table.access_group = 0;
+        }
+    }
+    let progress = config.progress || null;
+    config = validator.Params(config || {}, {
+        record_id: 'string',
+        table: {
+            name: 'string',
+            subscription_group: ['number', null],
+            access_group: ['number', 'private', 'public', 'authorized']
+        },
+        reference: {
+            record_id: ['string', null],
+            reference_limit: (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' });
+            },
+            allow_multiple_reference: 'boolean',
+        },
+        index: {
+            name: 'string',
+            value: ['string', 'number', 'boolean']
+        },
+        tags: (v) => {
+            if (v === null) {
+                return v;
+            }
+            if (typeof v === 'string') {
+                return [v];
+            }
+            if (Array.isArray(v)) {
+                for (let i of v) {
+                    if (typeof i !== 'string') {
+                        throw new SkapiError(`"tags" should be type: <string | string[]>`, { code: 'INVALID_PARAMETER' });
+                    }
+                    validator.specialChars(v, 'tag', false, true);
+                }
+                return v;
+            }
+            throw new SkapiError(`"tags" should be type: <string | string[]>`, { code: 'INVALID_PARAMETER' });
+        }
+    }, [], ['response', 'onerror', 'progress'], null);
+    if (!config?.table && !config?.record_id) {
+        throw new SkapiError('Either "record_id" or "table" should have a value.', { code: 'INVALID_PARAMETER' });
+    }
+    if (config.table) {
+        if (config.table.access_group === 'public') {
+            config.table.access_group = 0;
+        }
+        else if (config.table.access_group === 'authorized') {
+            config.table.access_group = 1;
+        }
+        if (typeof config.table.access_group === 'number') {
+            if (!isAdmin && this.user.access_group < config.table.access_group) {
+                throw new SkapiError("User has no access", { code: 'INVALID_REQUEST' });
+            }
+        }
+        if (!config.table.name) {
+            throw new SkapiError('"table.name" cannot be empty string.', { code: 'INVALID_PARAMETER' });
+        }
+        if (isAdmin) {
+            if (config.table.access_group === 'private') {
+                throw new SkapiError('Service owner cannot write private records.', { code: 'INVALID_REQUEST' });
+            }
+            if (config.table.hasOwnProperty('subscription_group')) {
+                throw new SkapiError('Service owner cannot write to subscription table.', { code: 'INVALID_REQUEST' });
+            }
+        }
+        if (typeof config.table?.subscription_group === 'number' && config.table.subscription_group < 0 || config.table.subscription_group > 99) {
+            throw new SkapiError("Subscription group should be within range: 0 ~ 99", { code: 'INVALID_PARAMETER' });
+        }
+    }
+    delete config.response;
+    delete config.onerror;
+    delete config.progress;
+    if (config.index) {
+        if (!config.index.name || typeof config.index.name !== 'string') {
+            throw new SkapiError('"index.name" is required. type: string.', { code: 'INVALID_PARAMETER' });
+        }
+        if (!['$uploaded', '$updated', '$referenced_count', '$user_id'].includes(config.index.name)) {
+            validator.specialChars(config.index.name, 'index name', true);
+        }
+        if (!config.index.hasOwnProperty('value')) {
+            throw new SkapiError('"index.value" is required.', { code: 'INVALID_PARAMETER' });
+        }
+        if (typeof config.index.value === 'string') {
+            validator.specialChars(config.index.value, 'index value', false, true);
+        }
+        else if (typeof config.index.value === 'number') {
+            if (config.index.value > __index_number_range || config.index.value < -__index_number_range) {
+                throw new SkapiError(`Number value should be within range -${__index_number_range} ~ +${__index_number_range}`, { code: 'INVALID_PARAMETER' });
+            }
+        }
+    }
+    let options = { auth: true };
+    let postData = null;
+    if ((form instanceof HTMLFormElement) || (form instanceof FormData) || (form instanceof SubmitEvent)) {
+        let toConvert = (form instanceof SubmitEvent) ? form.target : form;
+        let formData = !(form instanceof FormData) ? new FormData(toConvert) : form;
+        let formMeta = extractFormMeta(form);
+        options.meta = config;
+        if (Object.keys(formMeta.meta).length) {
+            options.meta.data = formMeta.meta;
+        }
+        let formToRemove = {};
+        for (let [key, value] of formData.entries()) {
+            if (formMeta.meta.hasOwnProperty(key) && !(value instanceof Blob)) {
+                let f = formData.getAll(key);
+                let f_idx = f.indexOf(value);
+                if (formToRemove.hasOwnProperty(key)) {
+                    formToRemove[key].push(f_idx);
+                }
+                else {
+                    formToRemove[key] = [f_idx];
+                }
+            }
+        }
+        if (Object.keys(formToRemove).length) {
+            for (let key in formToRemove) {
+                let values = formData.getAll(key);
+                let val_len = values.length;
+                while (val_len--) {
+                    if (formToRemove[key].includes(val_len)) {
+                        values.splice(val_len, 1);
+                    }
+                }
+                formData.delete(key);
+                for (let dat of values) {
+                    formData.append(key, dat, dat instanceof File ? dat.name : null);
+                }
+            }
+        }
+        postData = formData;
+    }
+    else {
+        postData = Object.assign({ data: form }, config);
+    }
+    if (typeof progress === 'function') {
+        fetchOptions.progress = progress;
+    }
+    if (Object.keys(fetchOptions).length) {
+        Object.assign(options, { fetchOptions });
+    }
+    return normalizeRecord(await request.bind(this)('post-record', postData, options));
+}
+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: true }, { 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) {
+    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: true }, { 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: true }, { fetchOptions }));
+    if (Array.isArray(res.list)) {
+        for (let i in res.list) {
+            let item = res.list[i];
+            let tSplit = item.tag.split('/');
+            res.list[i] = {
+                table: tSplit[1],
+                tag: tSplit[0],
+                number_of_records: item.cnt_rec
+            };
+        }
+    }
+    return res;
+}
+export async function deleteRecords(params) {
+    let isAdmin = await this.checkAdmin();
+    if (isAdmin && !params?.service) {
+        throw new SkapiError('Service ID is required.', { code: 'INVALID_PARAMETER' });
+    }
+    if (params?.record_id) {
+        return await request.bind(this)('del-records', {
+            service: params.service || this.service,
+            record_id: (v => {
+                let id = validator.specialChars(v, 'record_id', false, false);
+                if (typeof id === 'string') {
+                    return [id];
+                }
+                if (id.length > 100) {
+                    throw new SkapiError('"record_id" should not exceed 100 items.', { code: 'INVALID_PARAMETER' });
+                }
+                return id;
+            })(params.record_id)
+        }, { auth: true });
+    }
+    else {
+        if (!params?.table) {
+            if (isAdmin) {
+                return null;
+            }
+            throw new SkapiError('Either "table" or "record_id" is required.', { code: 'INVALID_PARAMETER' });
+        }
+        let struct = {
+            access_group: (v) => {
+                if (typeof v === 'string' && ['private', 'public', 'authorized'].includes(v)) {
+                    switch (v) {
+                        case 'private':
+                            return v;
+                        case 'public':
+                            return 0;
+                        case 'authorized':
+                            return 1;
+                    }
+                }
+                else if (typeof v === 'number' && v >= 0 && v < 100) {
+                    return v;
+                }
+                throw new SkapiError('Invalid "table.access_group". Access group should be type <number (0~99) | "private" | "public" | "authorized">.', { code: 'INVALID_PARAMETER' });
+            },
+            name: 'string',
+            subscription: (v) => {
+                if (isAdmin) {
+                    return validator.UserId(v, 'User ID in "table.subscription"');
+                }
+                throw new SkapiError('"table.subscription" is an invalid parameter key.', { code: 'INVALID_PARAMETER' });
+            },
+            subscription_group: (v) => {
+                if (isAdmin && typeof params?.table?.subscription !== 'string') {
+                    throw new SkapiError('"table.subscription" is required.', { code: 'INVALID_PARAMETER' });
+                }
+                if (typeof v === 'number') {
+                    if (v >= 0 && v < 99) {
+                        return v;
+                    }
+                }
+                throw new SkapiError('Subscription group should be between 0 ~ 99.', { code: 'INVALID_PARAMETER' });
+            }
+        };
+        params.table = validator.Params(params.table || {}, struct, isAdmin ? [] : ['name']);
+    }
+    return await request.bind(this)('del-records', params, { auth: true });
+}
+export async function grantPrivateRecordAccess(params) {
+    if (!params.record_id) {
+        throw new SkapiError(`Record ID is required.`, { code: 'INVALID_PARAMETER' });
+    }
+    if (!params.user_id || Array.isArray(params.user_id) && !params.user_id.length) {
+        throw new SkapiError(`User ID is required.`, { code: 'INVALID_PARAMETER' });
+    }
+    return recordAccess({
+        record_id: params.record_id,
+        user_id: params.user_id || null,
+        execute: 'add'
+    });
+}
+export async function removePrivateRecordAccess(params) {
+    if (!params.record_id) {
+        throw new SkapiError(`Record ID is required.`, { code: 'INVALID_PARAMETER' });
+    }
+    if (!params.user_id || Array.isArray(params.user_id) && !params.user_id.length) {
+        throw new SkapiError(`User ID is required.`, { code: 'INVALID_PARAMETER' });
+    }
+    return recordAccess({
+        record_id: params.record_id,
+        user_id: params.user_id || null,
+        execute: 'remove'
+    });
+}
+export async function listPrivateRecordAccess(params) {
+    return recordAccess({
+        record_id: params.record_id,
+        user_id: params.user_id || null,
+        execute: 'list'
+    });
+}
+export async function requestPrivateRecordAccessKey(record_id) {
+    await request.bind(this)('request-private-access-key', { record_id }, { auth: true });
+}
+async function recordAccess(params) {
+    let execute = params.execute;
+    let req = validator.Params(params, {
+        record_id: 'string',
+        user_id: (v) => {
+            if (!v) {
+                if (execute == 'list') {
+                    return null;
+                }
+                throw new SkapiError(`User ID is required.`, { code: 'INVALID_PARAMETER' });
+            }
+            let id = validator.specialChars(v, 'user id', false, false);
+            if (typeof id === 'string') {
+                return [id];
+            }
+            if (id.length > 100) {
+                throw new SkapiError(`Cannot process more than 100 users at once.`, { code: 'INVALID_REQUEST' });
+            }
+            return id;
+        },
+        execute: ['add', 'remove', 'list']
+    }, [
+        'execute',
+        'record_id',
+        'user_id'
+    ]);
+    if (!req.user_id) {
+        req.user_id = null;
+    }
+    await request.bind(this)('grant-private-access', req, { auth: true });
+}