skapi-js 1.0.0-alpha.9 → 1.0.1

package/js/methods/database.js

@@ -3,7 +3,15 @@ import { extractFormMeta, generateRandom } from '../utils/utils';
 import validator from '../utils/validator';
 import { request } from './request';
 const __index_number_range = 4503599627370496;
-function normalizeRecord(record) {
+function fromBase62(str) {
+    const base62Chars = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+    let result = 0;
+    for (let i = 0; i < str.length; i++) {
+        result = result * 62 + base62Chars.indexOf(str[i]);
+    }
+    return result;
+}
+export 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);
@@ -23,10 +31,17 @@ function normalizeRecord(record) {
             referenced_count: 0
         },
         ip: '',
-        bin: []
+        bin: {}
     };
     const keys = {
         'ip': (r) => {
+            if (r.slice(-1) === 'R') {
+                output.readonly = true;
+                r = r.slice(0, -1);
+            }
+            else {
+                output.readonly = false;
+            }
             output.ip = r;
         },
         'rec': (r) => {
@@ -47,10 +62,10 @@ function normalizeRecord(record) {
             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])
-                };
+                output.table.subscription = true;
+            }
+            else {
+                output.table.subscription = false;
             }
         },
         'usr_tbl': (r) => {
@@ -59,10 +74,10 @@ function normalizeRecord(record) {
             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])
-                };
+                output.table.subscription = true;
+            }
+            else {
+                output.table.subscription = false;
             }
         },
         'idx': (r) => {
@@ -97,7 +112,40 @@ function normalizeRecord(record) {
             output.reference.referenced_count = r;
         },
         'bin': (r) => {
-            output.bin = r;
+            let binObj = {};
+            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 = splitPath[6] == '**' ? 'private' : parseInt(splitPath[6]);
+                    access_group = access_group == 0 ? 'public' : access_group == 1 ? 'authorized' : access_group;
+                    let obj = {
+                        access_group,
+                        filename,
+                        url,
+                        path,
+                        size: fromBase62(size),
+                        uploaded: fromBase62(uploaded),
+                        getFile: (dataType, progress) => {
+                            let config = {
+                                dataType: dataType || 'download',
+                                progress
+                            };
+                            return getFile.bind(this)(url, config);
+                        }
+                    };
+                    if (binObj[pathKey]) {
+                        binObj[pathKey].push(obj);
+                        continue;
+                    }
+                    binObj[pathKey] = [obj];
+                }
+            }
+            output.bin = binObj;
         },
         'data': (r) => {
             let data = r;
@@ -118,6 +166,9 @@ function normalizeRecord(record) {
             keys[k](record[k]);
         }
     }
+    if (record.private_key) {
+        this.__private_access_key[output.record_id] = record.private_key;
+    }
     return output;
 }
 function normalizeTypedString(v) {
@@ -155,15 +206,18 @@ export async function deleteFiles(params) {
     if (!Array.isArray(endpoints)) {
         throw new SkapiError('"endpoints" should be type: array | string.', { code: 'INVALID_PARAMETER' });
     }
-    return request.bind(this)('del-files', {
+    let updatedRec = request.bind(this)('del-files', {
         endpoints,
         storage: 'records'
     }, { auth: true, method: 'post' });
+    return updatedRec.map(r => normalizeRecord.bind(this)(r));
 }
 export async function uploadFiles(fileList, params) {
     await this.__connection;
-    let { service = this.service, request = 'post' } = params || {};
-    if (request === 'post') {
+    let params_request = params?.request || 'post';
+    let nestKey = params?.nestKey || '';
+    let service = params?.service || this.service;
+    if (params_request === 'post') {
         if (!params?.record_id) {
             throw new SkapiError('"record_id" is required.', { code: 'INVALID_PARAMETER' });
         }
@@ -172,7 +226,7 @@ export async function uploadFiles(fileList, params) {
         if (service === this.service) {
             throw new SkapiError('invalid service.', { code: 'INVALID_PARAMETER' });
         }
-        if (request !== 'host') {
+        if (params_request !== 'host') {
             throw new SkapiError('invalid request.', { code: 'INVALID_PARAMETER' });
         }
     }
@@ -182,11 +236,14 @@ export async function uploadFiles(fileList, params) {
     if (fileList instanceof HTMLFormElement) {
         fileList = new FormData(fileList);
     }
+    let formDataKeys = [];
     if (fileList instanceof FormData) {
         let fileEntries = [];
         for (let entry of fileList.entries()) {
             let value = entry[1];
             if (value instanceof File) {
+                let key = entry[0];
+                formDataKeys.push(key);
                 fileEntries.push(value);
             }
         }
@@ -199,7 +256,7 @@ export async function uploadFiles(fileList, params) {
     let getSignedParams = {
         reserved_key,
         service,
-        request
+        request: params_request
     };
     if (params?.record_id) {
         getSignedParams.id = params.record_id;
@@ -249,13 +306,17 @@ export async function uploadFiles(fileList, params) {
         }
         return result;
     }
-    for (let f of fileList) {
+    let bin_endpoints = [];
+    for (let i = 0; i < fileList.length; i++) {
+        let f = fileList[i];
+        let key = formDataKeys?.[i] || '';
         let signedParams = Object.assign({
-            key: f.name,
+            key: params_request === 'host' ? (nestKey ? nestKey + '/' : '') + f.name : key ? key + '/' + f.name : 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 { fields = null, url, cdn } = await request.bind(this)('get-signed-url', signedParams, { auth: true });
+        bin_endpoints.push(cdn);
         let form = new FormData();
         for (let name in fields) {
             form.append(name, fields[name]);
@@ -263,6 +324,8 @@ export async function uploadFiles(fileList, params) {
         form.append('file', f);
         try {
             await fetchProgress(url, form, (p) => {
+                if (typeof params.progress !== 'function')
+                    return;
                 params.progress({
                     status: 'upload',
                     progress: p.loaded / p.total * 100,
@@ -280,15 +343,13 @@ export async function uploadFiles(fileList, params) {
             failed.push(f);
         }
     }
-    return { completed, failed };
+    return { completed, failed, bin_endpoints };
 }
 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);
-    }
+    validator.Url(url);
     let isValidEndpoint = false;
     let splitUrl = url.split('/');
     let host = splitUrl[2];
@@ -312,24 +373,61 @@ export async function getFile(url, config) {
         }
     }
     let service = subdomain ? null : target_key[1];
-    validator.Params(config, {
-        expiration: ['number', () => 60],
-        noCdn: ['boolean', () => false],
-        dataType: ['base64', 'blob', 'endpoint', 'download', () => 'download']
-    }, [], ['progress']);
+    config = validator.Params(config, {
+        expires: 'number',
+        dataType: ['base64', 'blob', 'endpoint', 'download', () => 'download'],
+        progress: p => p
+    });
     let needAuth = target_key[0] == 'auth';
     let filename = url.split('/').slice(-1)[0];
-    if (config?.noCdn || needAuth && (config?.dataType === 'download' || config?.dataType === 'endpoint')) {
+    let expires = config?.expires || 0;
+    if (expires) {
+        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
+            key: url,
+            expires
         };
         if (service) {
             params.service = service;
         }
         url = (await request.bind(this)('get-signed-url', params, { auth: true })).url;
     }
+    else if (needAuth) {
+        let token = this.session?.idToken?.jwtToken;
+        let access_group = target_key[6] === '**' ? '**' : parseInt(target_key[6]);
+        if (!token) {
+            throw new SkapiError('User login is required.', { code: 'INVALID_REQUEST' });
+        }
+        else {
+            let currTime = Date.now() / 1000;
+            if (this.session.idToken.payload.exp < currTime) {
+                try {
+                    await this.authentication().getSession({ refreshToken: true });
+                    token = this.session?.idToken?.jwtToken;
+                }
+                catch (err) {
+                    this.logout();
+                    throw new SkapiError('User login is required.', { code: 'INVALID_REQUEST' });
+                }
+            }
+        }
+        if (access_group === '**') {
+            if (this.__user.user_id !== target_key[3]) {
+                throw new SkapiError('User has no access.', { code: 'INVALID_REQUEST' });
+            }
+        }
+        else if (this.__user.access_group < access_group) {
+            throw new SkapiError('User has no access.', { code: 'INVALID_REQUEST' });
+        }
+        url += `?t=${token}`;
+    }
+    if (config?.dataType === 'endpoint') {
+        return url;
+    }
     if (config?.dataType === 'download') {
         let a = document.createElement('a');
         a.href = url;
@@ -340,20 +438,19 @@ export async function getFile(url, config) {
         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, _) => {
+    let blob = new Promise(async (res, rej) => {
+        try {
+            let b = await request.bind(this)(url, { service: service || this.service }, { method: 'get', noParams: true, contentType: null, responseType: 'blob', fetchOptions: { progress: config?.progress } });
+            if (config?.dataType === 'base64') {
                 const reader = new FileReader();
-                reader.onloadend = () => resolve(reader.result);
-                reader.readAsDataURL(blob);
-            });
+                reader.onloadend = () => res(reader.result);
+                reader.readAsDataURL(b);
+            }
         }
-        return blobToBase64(blob);
-    }
+        catch (err) {
+            rej(err);
+        }
+    });
     return blob;
 }
 export async function getRecords(query, fetchOptions) {
@@ -373,18 +470,7 @@ export async function getRecords(query, fetchOptions) {
         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;
-                }
-            }
+            subscription: (v) => validator.UserId(v, 'User ID in "subscription"')
         },
         reference: 'string',
         index: {
@@ -438,14 +524,17 @@ export async function getRecords(query, fetchOptions) {
                     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 validator.specialChars(v, 'index.range', false, true);
                 }
                 return v;
             }
         },
         tag: 'string',
-        private_access_key: 'string'
+        private_key: 'string'
     };
+    if (query?.tag) {
+        validator.specialChars(query.tag, 'tag', false, true);
+    }
     if (query?.table) {
         if (query.table.access_group === 'public') {
             query.table.access_group = 0;
@@ -453,6 +542,9 @@ export async function getRecords(query, fetchOptions) {
         else if (query.table.access_group === 'authorized') {
             query.table.access_group = 1;
         }
+        if (query.table?.name) {
+            validator.specialChars(query.table.name, 'table name', true, true);
+        }
         if (typeof query.table.access_group === 'number') {
             if (!this.__user) {
                 if (0 < query.table.access_group) {
@@ -467,6 +559,7 @@ export async function getRecords(query, fetchOptions) {
     if (query?.index && !query.index?.name) {
         throw new SkapiError('"index.name" is required when using "index" parameter.', { code: 'INVALID_REQUEST' });
     }
+    let is_reference_fetch = '';
     if (query?.record_id) {
         validator.specialChars(query.record_id, 'record_id', false, false);
         let outputObj = { record_id: query.record_id };
@@ -474,6 +567,9 @@ export async function getRecords(query, fetchOptions) {
             outputObj.service = query.service;
         }
         query = outputObj;
+        if (this.__private_access_key[query.record_id]) {
+            query.private_key = this.__private_access_key[query.record_id];
+        }
     }
     else {
         let ref_user;
@@ -482,26 +578,44 @@ export async function getRecords(query, fetchOptions) {
         }
         if (query.reference) {
             try {
-                ref_user = validator.UserId(query?.reference);
+                ref_user = validator.UserId(query.reference);
             }
             catch (err) {
+                validator.specialChars(query.reference, 'reference', false, false);
+                is_reference_fetch = query.reference;
+                if (this.__private_access_key[is_reference_fetch]) {
+                    query.private_key = this.__private_access_key[is_reference_fetch];
+                }
             }
         }
-        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 isAdmin = await this.checkAdmin();
+        let q = validator.Params(query || {}, struct, ref_user || isAdmin ? [] : ['table']);
+        if (typeof q.table !== 'string') {
+            if (q.table?.subscription) {
+                if (!this.session) {
+                    throw new SkapiError('Unsigned users have no access to subscription records.', { code: 'INVALID_REQUEST' });
+                }
+                q.table.subscription = {
+                    user_id: q.table.subscription,
+                    group: 1
+                };
+            }
         }
+        query = q;
     }
-    let auth = query.hasOwnProperty('access_group') && query.table.access_group ? true : !!this.__user;
+    let auth = query.hasOwnProperty('access_group') && typeof query.table !== 'string' && 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]);
+        result.list[i] = normalizeRecord.bind(this)(result.list[i]);
     }
     ;
+    if (is_reference_fetch && result?.reference_private_key) {
+        this.__private_access_key[is_reference_fetch] = result.reference_private_key;
+    }
     return result;
 }
 export async function postRecord(form, config) {
@@ -525,16 +639,29 @@ export async function postRecord(form, config) {
             config.table.access_group = 0;
         }
     }
+    if (typeof config.reference === 'string') {
+        config.reference = {
+            record_id: config.reference
+        };
+    }
     let progress = config.progress || null;
-    config = validator.Params(config || {}, {
+    let reference_private_key = null;
+    let config_chkd = validator.Params(config || {}, {
         record_id: 'string',
+        readonly: 'boolean',
         table: {
             name: 'string',
-            subscription_group: ['number', null],
+            subscription: 'boolean',
             access_group: ['number', 'private', 'public', 'authorized']
         },
         reference: {
-            record_id: ['string', null],
+            record_id: (v) => {
+                validator.specialChars(v, '"reference.record_id"', false, false);
+                if (this.__private_access_key[v]) {
+                    reference_private_key = this.__private_access_key[v];
+                }
+                return v;
+            },
             reference_limit: (v) => {
                 if (v === null) {
                     return null;
@@ -573,41 +700,64 @@ export async function postRecord(form, config) {
                 return v;
             }
             throw new SkapiError(`"tags" should be type: <string | string[]>`, { code: 'INVALID_PARAMETER' });
+        },
+        remove_bin: (v) => {
+            if (!v) {
+                return null;
+            }
+            let arr = [];
+            if (Array.isArray(v)) {
+                for (let i of v) {
+                    if (typeof i === 'string') {
+                        arr.push(i);
+                    }
+                    else if (i.url && i.size && i.filename && typeof i.getFile === 'function') {
+                        arr.push(i.url);
+                    }
+                    else {
+                        throw new SkapiError(`"remove_bin" should be type: <string | BinaryFile[]>`, { code: 'INVALID_PARAMETER' });
+                    }
+                }
+            }
+            return arr;
         }
     }, [], ['response', 'onerror', 'progress'], null);
-    if (!config?.table && !config?.record_id) {
+    if (!config_chkd?.table && !config_chkd?.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;
+    if (typeof config_chkd.table !== 'string' && config_chkd.table) {
+        if (config_chkd.table.access_group === 'public') {
+            config_chkd.table.access_group = 0;
         }
-        else if (config.table.access_group === 'authorized') {
-            config.table.access_group = 1;
+        else if (config_chkd.table.access_group === 'authorized') {
+            config_chkd.table.access_group = 1;
         }
-        if (typeof config.table.access_group === 'number') {
-            if (!isAdmin && this.user.access_group < config.table.access_group) {
+        if (typeof config_chkd.table.access_group === 'number') {
+            if (!isAdmin && this.user.access_group < config_chkd.table.access_group) {
                 throw new SkapiError("User has no access", { code: 'INVALID_REQUEST' });
             }
         }
-        if (!config.table.name) {
+        if (!config_chkd.table.name) {
             throw new SkapiError('"table.name" cannot be empty string.', { code: 'INVALID_PARAMETER' });
         }
+        validator.specialChars(config_chkd.table.name, 'table name', true, true);
         if (isAdmin) {
-            if (config.table.access_group === 'private') {
+            if (config_chkd.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' });
+        if (config_chkd.table?.subscription) {
+            config_chkd.table.subscription_group = 1;
+            delete config_chkd.table.subscription;
         }
     }
+    config = config_chkd;
     delete config.response;
     delete config.onerror;
     delete config.progress;
+    if (reference_private_key) {
+        config.reference_private_key = reference_private_key;
+    }
     if (config.index) {
         if (!config.index.name || typeof config.index.name !== 'string') {
             throw new SkapiError('"index.name" is required. type: string.', { code: 'INVALID_PARAMETER' });
@@ -629,43 +779,27 @@ export async function postRecord(form, config) {
     }
     let options = { auth: true };
     let postData = null;
+    let to_bin = 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;
+        form = (form instanceof SubmitEvent) ? form.target : 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 (formMeta.to_bin.length) {
+            to_bin = formMeta.to_bin;
         }
-        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);
-                }
+        if (formMeta.files.length) {
+            let formData = new FormData();
+            for (let f of formMeta.files) {
+                formData.append(f.name, f.file, f.file.name);
+            }
+            options.meta = config;
+            if (Object.keys(formMeta.meta).length) {
+                options.meta.data = formMeta.meta;
             }
+            postData = formData;
+        }
+        else {
+            postData = Object.assign({ data: formMeta.meta }, config);
         }
-        postData = formData;
     }
     else {
         postData = Object.assign({ data: form }, config);
@@ -676,7 +810,28 @@ export async function postRecord(form, config) {
     if (Object.keys(fetchOptions).length) {
         Object.assign(options, { fetchOptions });
     }
-    return normalizeRecord(await request.bind(this)('post-record', postData, options));
+    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);
+        }
+    }
+    return normalizeRecord.bind(this)(rec);
 }
 export async function getTables(query, fetchOptions) {
     let res = await request.bind(this)('get-table', validator.Params(query || {}, {
@@ -688,7 +843,7 @@ export async function getTables(query, fetchOptions) {
         'tbl': 'table',
         'srvc': 'service'
     };
-    if (Array.isArray(res.list)) {
+    if (Array.isArray(res?.list)) {
         for (let t of res.list) {
             for (let k in convert) {
                 if (t.hasOwnProperty(k)) {
@@ -701,6 +856,9 @@ export async function getTables(query, fetchOptions) {
     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),
@@ -743,7 +901,7 @@ export async function getIndexes(query, fetchOptions) {
         'avrg_bool': 'average_bool',
         'cnt_str': 'string_count'
     };
-    if (Array.isArray(res.list)) {
+    if (Array.isArray(res?.list)) {
         res.list = res.list.map((i) => {
             let iSplit = i.idx.split('/');
             let resolved = {
@@ -767,7 +925,7 @@ export async function getTags(query, fetchOptions) {
         tag: 'string',
         condition: ['gt', 'gte', 'lt', 'lte', '>', '>=', '<', '<=', '=', 'eq', '!=', 'ne']
     }), Object.assign({ auth: true }, { fetchOptions }));
-    if (Array.isArray(res.list)) {
+    if (Array.isArray(res?.list)) {
         for (let i in res.list) {
             let item = res.list[i];
             let tSplit = item.tag.split('/');
@@ -788,15 +946,17 @@ export async function deleteRecords(params) {
     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);
+            record_id: (id => {
                 if (typeof id === 'string') {
                     return [id];
                 }
+                if (!Array.isArray(id)) {
+                    throw new SkapiError('"record_id" should be type: <string | string[]>', { code: 'INVALID_PARAMETER' });
+                }
                 if (id.length > 100) {
                     throw new SkapiError('"record_id" should not exceed 100 items.', { code: 'INVALID_PARAMETER' });
                 }
-                return id;
+                return validator.specialChars(id, 'record_id', false, false);
             })(params.record_id)
         }, { auth: true });
     }
@@ -826,24 +986,28 @@ export async function deleteRecords(params) {
             },
             name: 'string',
             subscription: (v) => {
-                if (isAdmin) {
+                if (isAdmin && typeof params?.table?.subscription === 'string') {
                     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;
+                if (typeof v === 'boolean') {
+                    if (v) {
+                        return this.__user.user_id;
+                    }
+                    else {
+                        return null;
                     }
                 }
-                throw new SkapiError('Subscription group should be between 0 ~ 99.', { code: 'INVALID_PARAMETER' });
-            }
+                throw new SkapiError('"table.subscription" is an invalid parameter key.', { code: 'INVALID_PARAMETER' });
+            },
         };
-        params.table = validator.Params(params.table || {}, struct, isAdmin ? [] : ['name']);
+        let table_p = validator.Params(params.table || {}, struct, isAdmin ? [] : ['name']);
+        if (table_p.subscription === null) {
+            delete table_p.subscription;
+        }
+        else {
+            table_p.subscription_group = 1;
+        }
+        params.table = table_p;
     }
     return await request.bind(this)('del-records', params, { auth: true });
 }
@@ -854,7 +1018,7 @@ export function grantPrivateRecordAccess(params) {
     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({
+    return recordAccess.bind(this)({
         record_id: params.record_id,
         user_id: params.user_id || null,
         execute: 'add'
@@ -867,18 +1031,23 @@ export function removePrivateRecordAccess(params) {
     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({
+    return recordAccess.bind(this)({
         record_id: params.record_id,
         user_id: params.user_id || null,
         execute: 'remove'
     });
 }
 export function listPrivateRecordAccess(params) {
-    return recordAccess({
+    let list = recordAccess.bind(this)({
         record_id: params.record_id,
         user_id: params.user_id || null,
         execute: 'list'
     });
+    list.list = list.list.map((i) => {
+        i.record_id = i.rec_usr.split('/')[0];
+        i.user_id = i.rec_usr.split('/')[1];
+        return i;
+    });
 }
 export function requestPrivateRecordAccessKey(record_id) {
     return request.bind(this)('request-private-access-key', { record_id }, { auth: true });
@@ -894,13 +1063,16 @@ function recordAccess(params) {
                 }
                 throw new SkapiError(`User ID is required.`, { code: 'INVALID_PARAMETER' });
             }
-            let id = validator.specialChars(v, 'user id', false, false);
+            let id = v;
             if (typeof id === 'string') {
-                return [id];
+                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', 'list']