skapi-js 0.0.3 → 0.0.41

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "skapi-js",
-  "version": "0.0.3",
-  "description": "skapi javascript library",
-  "main": "./dist/skapi.js",
+  "version": "0.0.41",
+  "description": "skapi serverless cloud javascript library",
+  "main": "./dist/skapi.module.js",
   "scripts": {
     "build": "npx tsc ; npx webpack --config webpack.config.js ; npx typedoc"
   },
@@ -27,7 +27,8 @@
     "backend",
     "serverless",
     "skapi",
-    "api"
+    "api",
+    "cloud"
   ],
   "dependencies": {
     "amazon-cognito-identity-js": "^5.2.12"

package/src/decorators.ts

@@ -29,7 +29,8 @@ function formResponse() {
 
                 // form element action
                 let href = new URL(form.action);
-                let response_key = sha256(form.action);
+                // let response_key = sha256(form.action);
+                let response_key = form.action;
                 let timestamp = Date.now().toString();
 
                 window.sessionStorage.setItem(response_key, JSON.stringify({ [timestamp]: response }));

package/src/skapi.ts

@@ -110,7 +110,21 @@ export default class Skapi {
     // public
 
     /** Current logged in user object. null if not logged. */
-    user: User | null = null;
+    __user: User | null = null;
+
+    get user() {
+        if (this.__user && Object.keys(this.__user).length) {
+            return JSON.parse(JSON.stringify(this.__user));
+        }
+        else {
+            return null;
+        }
+    }
+
+    set user(value) {
+        // setting user is bypassed
+    }
+
     /** Connected service object. null if connection failed. */
     connection: Connection | null = null;
     host: string = 'skapi';
@@ -411,7 +425,7 @@ export default class Skapi {
                                     user.access_group = Number(this.session.idToken.payload.access_group);
                                     user.user_id = user.sub;
                                     delete user.sub;
-                                    this.user = user;
+                                    this.__user = user;
                                     res(user);
                                 }
                             });
@@ -577,6 +591,10 @@ export default class Skapi {
         return await this.request(p.url, option || null, { method: 'get', auth: p.url.includes('/auth/'), contentType: null, responseType: 'blob' });
     }
 
+    async mock(data, options) {
+        return this.request('test-api', data, options);
+    }
+
     /**
      * Sends post request to your custom server using Skapi's secure API layer.</br>
      * You must set your secret API key from the Skapi's admin page.</br>
@@ -735,7 +753,7 @@ export default class Skapi {
      * Retrives respond data from form request.
      * 
      * ```
-     * let respond = skapi.getResponse();
+     * let respond = skapi.getFormResponse();
      * ```
      * @category Connection
      */
@@ -835,6 +853,7 @@ export default class Skapi {
                     case 'signup':
                     case 'confirm-signup':
                     case 'recover-account':
+                    case 'test-api':
                     case 'service':
                         return {
                             public: admin.admin_public,
@@ -1008,11 +1027,11 @@ export default class Skapi {
         }
 
         let requestKey = this.load_startKey_keys({
-            params: Object.assign(isForm || (data || {}), required || {}),
+            params: data,
             url: isExternalUrl || url,
             refresh: isForm ? true : refresh // should not use startKey when post is a form
         }); // returns requrestKey | cached data
-
+        
         if (requestKey && typeof requestKey === 'object') {
             return requestKey;
         }
@@ -1093,7 +1112,7 @@ export default class Skapi {
     }): string | FetchResponse {
 
         let { params = {}, url, refresh = false } = option || {};
-
+        
         if (params.hasOwnProperty('startKey')) {
             if (
                 typeof params.startKey !== 'object' && !Object.keys(params.startKey).length ||
@@ -1118,41 +1137,10 @@ export default class Skapi {
             }
         }
 
-        let toHash = (() => {
-            if (params && typeof params === 'object' && Object.keys(params).length) {
-                // hash request parameters
-                let paramsHash = JSON.parse(JSON.stringify(params));
-
-                function orderObjectKeys(obj: Record<string, any>) {
-                    function sortObject(obj: Record<string, any>): Record<string, any> {
-                        if (typeof obj === 'object' && obj) {
-                            return Object.keys(obj).sort().reduce((res, key) => ((res as any)[key] = obj[key], res), {});
-                        }
-                        return obj;
-                    };
-
-                    let _obj = sortObject(obj);
-                    for (let k in _obj) {
-                        if (_obj[k] && typeof _obj[k] === 'object') {
-                            _obj[k] = sortObject(obj[k]);
-                        }
-                    }
-
-                    return _obj;
-                }
-
-                return JSON.stringify(orderObjectKeys(paramsHash)) + url + this.service;
-            }
-
-            return url + this.service;
-        })();
-
         // let hashedParams = createHash('sha256').update(toHash).digest('hex');
-        let hashedParams = sha256((() => {
+        let hashedParams = (() => {
             if (params && typeof params === 'object' && Object.keys(params).length) {
                 // hash request parameters
-                let paramsHash = JSON.parse(JSON.stringify(params));
-
                 function orderObjectKeys(obj: Record<string, any>) {
                     function sortObject(obj: Record<string, any>): Record<string, any> {
                         if (typeof obj === 'object' && obj) {
@@ -1171,11 +1159,12 @@ export default class Skapi {
                     return _obj;
                 }
 
-                return JSON.stringify(orderObjectKeys(paramsHash)) + url + this.service;
+                return url + '/' + JSON.stringify(orderObjectKeys(params));
             }
 
-            return url + this.service;
-        })());
+            return url + '/' + this.service;
+
+        })();
 
         if (refresh && this.__startKey_keys?.[url]?.[hashedParams]) {
             // init cache, init startKey
@@ -1188,7 +1177,8 @@ export default class Skapi {
             if (Array.isArray(this.__startKey_keys[url][hashedParams]) && this.__startKey_keys[url][hashedParams].length) {
                 // delete cache of all startkeys
                 for (let p of this.__startKey_keys[url][hashedParams]) {
-                    let hashedParams_cached = hashedParams + sha256(JSON.stringify(p));
+                    // let hashedParams_cached = hashedParams + '/' + sha256(JSON.stringify(p));
+                    let hashedParams_cached = hashedParams + '/' + JSON.stringify(p);
                     // let hashedParams_cached = hashedParams + createHash('sha256').update(JSON.stringify(p)).digest('hex');
 
                     if (this.__cached_requests?.[url] && this.__cached_requests?.[url]?.[hashedParams_cached]) {
@@ -1216,7 +1206,7 @@ export default class Skapi {
         if (last_startKey_key) {
             // use last start key
 
-            if (last_startKey_key === 'end') {
+            if (last_startKey_key === '"end"') { // cached startKeys are stringified
                 return {
                     list: [],
                     startKey: 'end',
@@ -1226,7 +1216,8 @@ export default class Skapi {
 
             else {
                 // cache_hashedParams += createHash('sha256').update(last_startKey_key).digest('hex');
-                cache_hashedParams += sha256(last_startKey_key);
+                // cache_hashedParams += sha256(last_startKey_key);
+                cache_hashedParams += ('/' + last_startKey_key);
                 params.startKey = JSON.parse(last_startKey_key);
             }
         }
@@ -1456,13 +1447,9 @@ export default class Skapi {
         option = checkParams(option || {}, {
             record_id: 'string',
             access_group: ['number', 'private'],
-            table: ['string', () => {
-                if (!option?.record_id) {
-                    throw new SkapiError('Either "record_id" or "table" should have a value.', { code: 'INVALID_PARAMETER' });
-                }
-            }],
+            table: 'string',
             subscription_group: 'number',
-            reference: 'string',
+            reference: ['string', null],
             index: {
                 name: 'string',
                 value: ['string', 'number', 'boolean']
@@ -1488,11 +1475,33 @@ export default class Skapi {
                 throw new SkapiError(`"tags" should be type: <string | string[]>`, { code: 'INVALID_PARAMETER' });
             },
             config: {
-                reference_limit: ['number', null],
+                reference_limit: (v: number) => {
+                    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',
                 private_access: (v: string | string[]) => {
                     let param = 'config.private_access';
 
+                    if (v === null) {
+                        return null;
+                    }
+
                     if (v && typeof v === 'string') {
                         v = [v];
                     }
@@ -1501,7 +1510,7 @@ export default class Skapi {
                         for (let u of v) {
                             validateUserId(u, `User ID in "${param}"`);
 
-                            if (this.user && u === this.user.user_id) {
+                            if (this.__user && u === this.__user.user_id) {
                                 throw new SkapiError(`"${param}" should not be the uploader's user ID.`, { code: 'INVALID_PARAMETER' });
                             }
                         }
@@ -1521,6 +1530,10 @@ export default class Skapi {
         delete option.formData;
         delete option.onerror;
 
+        if (!option?.table && !option?.record_id) {
+            throw new SkapiError('Either "record_id" or "table" should have a value.', { code: 'INVALID_PARAMETER' });
+        }
+
         if (option?.index) {
             // index name allows periods. white space is invalid.
             if (!option.index?.name || typeof option.index?.name !== 'string') {
@@ -1545,7 +1558,6 @@ export default class Skapi {
             }
         }
 
-
         if (is_admin) {
             if (option?.access_group === 'private') {
                 throw new SkapiError('Service owner cannot write private records.', { code: 'INVALID_REQUEST' });
@@ -1656,22 +1668,7 @@ export default class Skapi {
                     return v;
                 }
             },
-            tags: (v: string | string[]) => {
-                if (typeof v === 'string') {
-                    return [v];
-                }
-                else if (Array.isArray(v)) {
-                    if (v.length > 10) {
-                        throw new SkapiError('Cannot query more than 10 tags at once.', { code: 'INVALID_REQUEST' });
-                    }
-                    for (let s of v) {
-                        if (typeof s !== 'string') {
-                            throw new SkapiError('Tags should be type: <string | string[]>', { code: 'INVALID_PARAMETER' });
-                        }
-                    }
-                    return v;
-                }
-            }
+            tags: 'string'
         };
 
         params = checkParams(params || {}, struct, ['table']);
@@ -1680,73 +1677,11 @@ export default class Skapi {
             throw new SkapiError('Requires login.', { code: 'INVALID_REQUEST' });
         }
 
-        if (params?.tags) {
-            let tagFetch = [];
-            let getStartKey = fetchOptions?.startKey || null;
-
-            for (let t of params.tags) {
-                let params_copy = JSON.parse(JSON.stringify(params));
-                params_copy.tag = t;
-                delete params_copy.tags;
-
-                let fetchOpt = fetchOptions ? JSON.parse(JSON.stringify(fetchOptions)) : null;
-                if (fetchOpt) {
-                    delete fetchOpt.startKey;
-
-                    if (getStartKey && getStartKey?.[t]) {
-                        fetchOpt.startKey = getStartKey[t];
-                    }
-                }
-
-                tagFetch.push(this.request(
-                    'get-records',
-                    params_copy,
-                    Object.assign(
-                        { auth: params.hasOwnProperty('access_group') && (params.access_group === 'private' || params.access_group > 0) ? true : !!this.session },
-                        { fetchOptions: fetchOpt }
-                    )));
-            }
-
-            let list = [];
-            let startKey = {};
-            let res_all = await Promise.all(tagFetch);
-
-            for (let res of res_all) {
-                for (let i in res.list) {
-                    if (tagFetch.includes(res.list[i].rec)) {
-                        continue;
-                    }
-                    tagFetch.push(res.list[i]);
-                    list.push(normalize_record_data(res.list[i]));
-                };
-                if (res.startKey) {
-                    if (Array.isArray(params.tags)) {
-                        let tag = params.tags.splice(0, 1);
-                        startKey[tag[0]] = res.startKey;
-                    }
-                }
-            }
-
-            let endOfList = true;
-            for (let k in startKey) {
-                if (startKey[k] && startKey[k] !== 'end') {
-                    endOfList = false;
-                    break;
-                }
-            }
-
-            return {
-                list,
-                endOfList,
-                startKey
-            };
-        }
-
         let result = await this.request(
             'get-records',
             params,
             Object.assign(
-                { auth: params.hasOwnProperty('access_group') && (params.access_group === 'private' || params.access_group > 0) ? true : !!this.user },
+                { auth: params.hasOwnProperty('access_group') && (params.access_group === 'private' || params.access_group > 0) ? true : !!this.__user },
                 { fetchOptions }
             )
         );
@@ -2205,7 +2140,7 @@ export default class Skapi {
             }
         }, ['user_id', 'group']);
 
-        if (this.user && option.user_id === this.user.user_id) {
+        if (this.__user && option.user_id === this.__user.user_id) {
             throw new SkapiError(`"user_id" cannot be the user's own ID.`, { code: 'INVALID_PARAMETER' });
         }
 
@@ -2330,7 +2265,7 @@ export default class Skapi {
         }) || {};
 
         return this.getSubscriptions({
-            subscriber: option.user_id || this.user?.user_id,
+            subscriber: option.user_id || this.__user?.user_id,
             group: option.group
         });
     }
@@ -2348,7 +2283,7 @@ export default class Skapi {
         }) || {};
 
         let subParams = {
-            subscription: option.user_id || this.user?.user_id,
+            subscription: option.user_id || this.__user?.user_id,
             group: option.group
         };
 
@@ -2722,18 +2657,14 @@ export default class Skapi {
      */
     async resendSignupConfirmation(
         /** Redirect url on confirmation success. */
-        redirect: boolean | string = false
+        redirect: string
     ): Promise<string> {
-        if (redirect && typeof redirect === 'string') {
-            redirect = (validateUrl(redirect) as string);
-        }
-
-        else if (typeof redirect !== 'boolean') {
-            throw new SkapiError('Argument should be type: <boolean | string>.', { code: 'INVALID_REQUEST' });
+        if (!this.__request_signup_confirmation) {
+            throw new SkapiError('Least one login attempt is required.', { code: 'INVALID_REQUEST' });
         }
 
-        if (!this.__request_signup_confirmation) {
-            throw new SkapiError('Least one signin attempt is required.', { code: 'INVALID_REQUEST' });
+        if (redirect) {
+            validateUrl(redirect);
         }
 
         let resend = await this.request("confirm-signup", {
@@ -2742,7 +2673,7 @@ export default class Skapi {
         });
 
         this.__request_signup_confirmation = null;
-        return resend;
+        return resend; // 'SUCCESS: Signup confirmation E-Mail has been sent.'
     }
 
     /**
@@ -2834,8 +2765,8 @@ export default class Skapi {
                     if (code) {
                         this.authentication().updateSession({ refreshToken: true }).then(
                             () => {
-                                if (this.user) {
-                                    this.user[attribute + '_verified'] = true;
+                                if (this.__user) {
+                                    this.__user[attribute + '_verified'] = true;
                                 }
                                 res(`SUCCESS: "${attribute}" is verified.`);
                             }
@@ -3049,8 +2980,8 @@ export default class Skapi {
     async disableAccount(): Promise<string> {
         await this.__connection;
 
-        if (this.user && Array.isArray(this.user.services)) {
-            for (let s of this.user.services) {
+        if (this.__user && Array.isArray(this.__user.services)) {
+            for (let s of this.__user.services) {
                 if (s.active) {
                     throw new SkapiError('All services needs to be disabled.', { code: 'INVALID_REQUEST' });
                 }
@@ -3115,7 +3046,7 @@ export default class Skapi {
         });
 
         if (params && typeof params === 'object' && !Object.keys(params).length) {
-            return this.user;
+            return this.__user;
         }
 
         if (params.new_password || params.current_password) {
@@ -3158,10 +3089,10 @@ export default class Skapi {
             ['phone_number_public', 'phone_number_verified', "User's phone number should be verified to set"]
         ];
 
-        if (this.user) {
+        if (this.__user) {
             for (let c of collision) {
-                if (params[c[0]] && !this.user[c[1]]) {
-                    throw new SkapiError(`${c[2]} "${c[0]}" to true.`, { code: 'INVALID_PARAMETER' });
+                if (params[c[0]] && !this.__user[c[1]]) {
+                    throw new SkapiError(`${c[2]} "${c[0]}" to true.`, { code: 'INVALID_REQUEST' });
                 }
             }
         }
@@ -3220,7 +3151,7 @@ export default class Skapi {
             await this.authentication().updateSession({ refreshToken: true });
         }
 
-        return this.user;
+        return this.__user;
     }
 
 
@@ -3265,13 +3196,13 @@ export default class Skapi {
             auth: true
         };
 
-        if (option.private) {
+        if (option?.private) {
             Object.assign(opt, { meta: { '__private__': option.private } });
         }
 
         await this.request('post-userdata', form, opt);
         await this.authentication().updateSession();
-        return this.user;
+        return this.__user;
     }
 
     /**
@@ -3507,7 +3438,7 @@ export default class Skapi {
 
         let user = result.list[0];
         // append user session data
-        Object.assign(user, this.user);
+        Object.assign(user, this.__user);
 
         user._what_public_see = JSON.parse(JSON.stringify(user));
 

package/src/utils.ts

@@ -1,36 +1,34 @@
 import SkapiError from "./skapi_error";
 import { RecordData, Form } from "./Types";
 
-const sha256: any = function (ascii) {
-    // author: https://geraintluff.github.io/sha256/
-
+const sha256: any = function sha256(ascii) {
     function rightRotate(value, amount) {
         return (value >>> amount) | (value << (32 - amount));
     };
 
-    var mathPow = Math.pow;
-    var maxWord = mathPow(2, 32);
-    var lengthProperty = 'length';
-    var i, j; // Used as a counter across the whole file
-    var result = '';
+    let mathPow = Math.pow;
+    let maxWord = mathPow(2, 32);
+    let lengthProperty = 'length';
+    let i, j; // Used as a counter across the whole file
+    let result = '';
 
-    var words = [];
-    var asciiBitLength = ascii[lengthProperty] * 8;
+    let words = [];
+    let asciiBitLength = ascii[lengthProperty] * 8;
 
     //* caching results is optional - remove/add slash from front of this line to toggle
     // Initial hash value: first 32 bits of the fractional parts of the square roots of the first 8 primes
     // (we actually calculate the first 64, but extra values are just ignored)
-    var hash = sha256.h = sha256.h || [];
+    let hash = (sha256 as any).h = (sha256 as any).h || [];
     // Round constants: first 32 bits of the fractional parts of the cube roots of the first 64 primes
-    var k = sha256.k = sha256.k || [];
-    var primeCounter = k[lengthProperty];
+    let k = (sha256 as any).k = (sha256 as any).k || [];
+    let primeCounter = k[lengthProperty];
     /*/
-    var hash = [], k = [];
-    var primeCounter = 0;
+    let hash = [], k = [];
+    let primeCounter = 0;
     //*/
 
-    var isComposite = {};
-    for (var candidate = 2; primeCounter < 64; candidate++) {
+    let isComposite = {};
+    for (let candidate = 2; primeCounter < 64; candidate++) {
         if (!isComposite[candidate]) {
             for (i = 0; i < 313; i += candidate) {
                 isComposite[i] = candidate;
@@ -44,7 +42,9 @@ const sha256: any = function (ascii) {
     while (ascii[lengthProperty] % 64 - 56) ascii += '\x00'; // More zero padding
     for (i = 0; i < ascii[lengthProperty]; i++) {
         j = ascii.charCodeAt(i);
-        if (j >> 8) return; // ASCII check: only accept characters in range 0-255
+        if (j >> 8) {
+            return; // ASCII check: only accept characters in range 0-255
+        }
         words[i >> 2] |= j << ((3 - i) % 4) * 8;
     }
     words[words[lengthProperty]] = ((asciiBitLength / maxWord) | 0);
@@ -52,21 +52,21 @@ const sha256: any = function (ascii) {
 
     // process each chunk
     for (j = 0; j < words[lengthProperty];) {
-        var w = words.slice(j, j += 16); // The message is expanded into 64 words as part of the iteration
-        var oldHash = hash;
+        let w = words.slice(j, j += 16); // The message is expanded into 64 words as part of the iteration
+        let oldHash = hash;
         // This is now the undefinedworking hash", often labelled as variables a...g
         // (we have to truncate as well, otherwise extra entries at the end accumulate
         hash = hash.slice(0, 8);
 
         for (i = 0; i < 64; i++) {
-            var i2 = i + j;
+            let i2 = i + j;
             // Expand the message into 64 words
             // Used below if 
-            var w15 = w[i - 15], w2 = w[i - 2];
+            let w15 = w[i - 15], w2 = w[i - 2];
 
             // Iterate
-            var a = hash[0], e = hash[4];
-            var temp1 = hash[7]
+            let a = hash[0], e = hash[4];
+            let temp1 = hash[7]
                 + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) // S1
                 + ((e & hash[5]) ^ ((~e) & hash[6])) // ch
                 + k[i]
@@ -79,7 +79,7 @@ const sha256: any = function (ascii) {
                 ) | 0
                 );
             // This is only used once, so *could* be moved below, but it only saves 4 bytes and makes things unreadble
-            var temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) // S0
+            let temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) // S0
                 + ((a & hash[1]) ^ (a & hash[2]) ^ (hash[1] & hash[2])); // maj
 
             hash = [(temp1 + temp2) | 0].concat(hash); // We don't bother trimming off the extra ones, they're harmless as long as we're truncating when we do the slice()
@@ -93,10 +93,11 @@ const sha256: any = function (ascii) {
 
     for (i = 0; i < 8; i++) {
         for (j = 3; j + 1; j--) {
-            var b = (hash[i] >> (j * 8)) & 255;
+            let b = (hash[i] >> (j * 8)) & 255;
             result += ((b < 16) ? 0 : '') + b.toString(16);
         }
     }
+
     return result;
 };
 
@@ -236,7 +237,7 @@ function checkParams(
             } catch (err) {
                 if (typeof err === 'string' && err.substring(0, 6) === 'BREAK:') {
                     // break on BREAK message
-                    err = err.substring(5);
+                    err = err.substring(6);
                     let errMsg = (err as string).split(':');
                     errToThrow = new SkapiError(errMsg[1], { code: errMsg[0] });
                     break;
@@ -291,6 +292,9 @@ function checkParams(
 
             val = _params;
         }
+        else {
+            throw new SkapiError(`Value: ${_params}${isInvalid}`, { code: 'INVALID_PARAMETER' });
+        }
     }
 
     else if (struct === null) {

package/tsconfig.json

@@ -23,7 +23,7 @@
     // "disableSolutionSearching": true,                 /* Opt a project out of multi-project reference checking when editing. */
     // "disableReferencedProjectLoad": true,             /* Reduce the number of projects loaded automatically by TypeScript. */
     /* Language and Environment */
-    "target": "es2016", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
+    "target": "ES2020", /* Set the JavaScript language version for emitted JavaScript and include compatible library declarations. */
     // "lib": [],                                        /* Specify a set of bundled library declaration files that describe the target runtime environment. */
     // "jsx": "preserve",                                /* Specify what JSX code is generated. */
     // "experimentalDecorators": true,                   /* Enable experimental support for TC39 stage 2 draft decorators. */
@@ -37,7 +37,7 @@
     // "useDefineForClassFields": true,                  /* Emit ECMAScript-standard-compliant class fields. */
     // "moduleDetection": "auto",                        /* Control what method is used to detect module-format JS files. */
     /* Modules */
-    "module": "commonjs", /* Specify what module code is generated. */
+    "module": "ES2020", /* Specify what module code is generated. */
     // "rootDir": "./",                                  /* Specify the root folder within your source files. */
     // "moduleResolution": "node",                       /* Specify how TypeScript looks up a file from a given module specifier. */
     "moduleResolution": "node",