skapi-js 1.0.0-alpha.9 → 1.0.1

package/js/methods/request.d.ts

@@ -1,6 +1,7 @@
 import { Form, FormSubmitCallback, FetchOptions, Connection } from '../Types';
 export declare function getConnection(): Promise<Connection>;
 export declare function request(url: string, data?: Form<any> | null, options?: {
+    noParams?: boolean;
     fetchOptions?: FetchOptions & FormSubmitCallback;
     auth?: boolean;
     method?: string;

package/js/methods/request.js

@@ -1,5 +1,5 @@
 import SkapiError from '../main/error';
-import { MD5 } from '../utils/utils';
+import { MD5, generateRandom } from '../utils/utils';
 import validator from '../utils/validator';
 const __pendingRequest = {};
 export function getConnection() {
@@ -74,6 +74,7 @@ export async function request(url, data = null, options) {
                 case 'refresh-cdn':
                 case 'request-newsletter-sender':
                 case 'set-404':
+                case 'subdomain-info':
                     return {
                         public: admin.admin_public,
                         private: admin.admin_private
@@ -119,14 +120,16 @@ export async function request(url, data = null, options) {
     let fetchOptions = {};
     let { fetchMore = false, progress } = options?.fetchOptions || {};
     if (options?.fetchOptions && Object.keys(options.fetchOptions).length) {
-        let fetOpt = validator.Params({
-            limit: options.fetchOptions?.limit || 50,
-            startKey: options.fetchOptions?.startKey || null,
-            ascending: typeof options.fetchOptions?.ascending === 'boolean' ? options.fetchOptions.ascending : true
-        }, {
-            limit: ['number', () => 50],
+        let fetOpt = {};
+        for (let k of ['limit', 'startKey', 'ascending']) {
+            if (options.fetchOptions.hasOwnProperty(k)) {
+                fetOpt[k] = options.fetchOptions[k];
+            }
+        }
+        fetOpt = validator.Params(fetOpt, {
+            limit: 'number',
             startKey: null,
-            ascending: ['boolean', () => true]
+            ascending: 'boolean'
         });
         if (fetOpt.hasOwnProperty('limit') && typeof fetOpt.limit === 'number') {
             if (fetOpt.limit > 1000) {
@@ -222,7 +225,16 @@ export async function request(url, data = null, options) {
             headers.Authorization = token;
         }
         if (meta) {
-            headers["Content-Meta"] = window.btoa(encodeURIComponent(typeof meta === 'string' ? meta : JSON.stringify(meta)));
+            let meta_key = '__meta__' + generateRandom(16);
+            if (data instanceof FormData) {
+                headers["Content-Meta"] = window.btoa(encodeURIComponent(JSON.stringify({
+                    meta_key: meta_key,
+                    merge: 'data'
+                })));
+                data.set(meta_key, new Blob([JSON.stringify(meta)], {
+                    type: 'application/json'
+                }));
+            }
         }
         if (options.hasOwnProperty('contentType')) {
             if (options?.contentType) {
@@ -240,7 +252,7 @@ export async function request(url, data = null, options) {
             __pendingRequest[requestKey] = _post.bind(this)(endpoint, data, opt, progress);
         }
         else if (method === 'get') {
-            __pendingRequest[requestKey] = _get.bind(this)(endpoint, data, opt, progress);
+            __pendingRequest[requestKey] = _get.bind(this)(endpoint, data, opt, progress, options?.noParams);
         }
         try {
             let response = await __pendingRequest[requestKey];
@@ -482,8 +494,8 @@ async function _post(url, params, option, progress) {
     return _fetch.bind(this)(url, opt, progress);
 }
 ;
-async function _get(url, params, option, progress) {
-    if (params && typeof params === 'object' && Object.keys(params).length) {
+async function _get(url, params, option, progress, noParams) {
+    if (params && typeof params === 'object' && !noParams && Object.keys(params).length) {
         if (url.substring(url.length - 1) !== '?') {
             url = url + '?';
         }
@@ -571,10 +583,12 @@ export function formHandler(options) {
             }
             const handleResponse = (response) => {
                 if (option?.response) {
-                    if (typeof option.response === 'function')
+                    if (typeof option.response === 'function') {
                         return option.response(response);
-                    else
+                    }
+                    else {
                         throw new SkapiError('Callback "response" should be type: function.', { code: 'INVALID_PARAMETER' });
+                    }
                 }
                 if (formEl) {
                     if (routeWithDataKey) {
@@ -589,14 +603,21 @@ export function formHandler(options) {
                 if (form instanceof SubmitEvent) {
                     form.preventDefault();
                 }
-                let is_err = err instanceof Error ? err : new SkapiError(err);
+                if (err instanceof SkapiError) {
+                    err.name = propertyKey + '()';
+                }
+                else {
+                    err = err instanceof Error ? err : new SkapiError(err, { name: propertyKey + '()' });
+                }
                 if (option?.onerror) {
-                    if (typeof option.onerror === 'function')
-                        return option.onerror(is_err);
-                    else
-                        throw new SkapiError('Callback "onerror" should be type: function.', { code: 'INVALID_PARAMETER' });
+                    if (typeof option.onerror === 'function') {
+                        return option.onerror(err);
+                    }
+                    else {
+                        return new SkapiError('Callback "onerror" should be type: function.', { code: 'INVALID_PARAMETER', name: propertyKey + '()' });
+                    }
                 }
-                throw is_err;
+                return err;
             };
             const executeMethod = () => {
                 try {
@@ -616,7 +637,11 @@ export function formHandler(options) {
                             return handleResponse(resolved);
                         }
                         catch (err) {
-                            return handleError(err);
+                            let is_err = handleError(err);
+                            if (is_err instanceof Error) {
+                                throw is_err;
+                            }
+                            return is_err;
                         }
                     })();
                 }
@@ -624,9 +649,7 @@ export function formHandler(options) {
             if (preventMultipleCalls) {
                 return (async () => {
                     if (pendPromise?.[propertyKey] instanceof Promise) {
-                        let res = await pendPromise[propertyKey];
-                        pendPromise[propertyKey] = null;
-                        return res;
+                        return pendPromise[propertyKey];
                     }
                     else {
                         pendPromise[propertyKey] = executeMethod().finally(() => {

package/js/methods/subscription.d.ts

@@ -2,7 +2,6 @@ import { DatabaseResponse, FetchOptions, Form, Newsletters, SubscriptionGroup }
 export declare function getSubscriptions(params: {
     subscriber?: string;
     subscription?: string;
-    group?: number;
     blocked?: boolean;
 }, fetchOptions?: FetchOptions, _mapper?: Function): Promise<DatabaseResponse<{
     subscriber: string;
@@ -22,7 +21,7 @@ export declare function getSubscribers(option: SubscriptionGroup<number | undefi
     blocked?: boolean;
 }, fetchOptions: FetchOptions): Promise<DatabaseResponse<any>>;
 export declare function getNewsletterSubscription(params: {
-    group?: number;
+    group?: number | 'public' | 'authorized';
 }): Promise<{
     active: boolean;
     timestamp: number;

package/js/methods/subscription.js

@@ -4,19 +4,7 @@ import { request } from './request';
 function subscriptionGroupCheck(option) {
     option = validator.Params(option, {
         user_id: (v) => validator.UserId(v, '"user_id"'),
-        group: (v) => {
-            if (v === '*') {
-                return v;
-            }
-            if (typeof v !== 'number') {
-                throw new SkapiError('"group" should be type: number.', { code: 'INVALID_PARAMETER' });
-            }
-            else if (v < 1 && v > 99) {
-                throw new SkapiError('"group" should be within range 1 ~ 99.', { code: 'INVALID_PARAMETER' });
-            }
-            return v;
-        }
-    }, ['user_id', 'group']);
+    }, ['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' });
     }
@@ -26,13 +14,13 @@ function subscriptionGroupCheck(option) {
 export async function getSubscriptions(params, fetchOptions, _mapper) {
     params = validator.Params(params, {
         subscriber: (v) => validator.UserId(v, 'User ID in "subscriber"'),
-        group: 'number',
         subscription: (v) => validator.UserId(v, 'User ID in "subscription"'),
         blocked: 'boolean'
     });
     if (!params.subscriber && !params.subscription) {
         throw new SkapiError('At least either "subscriber" or "subscription" should have a value.', { code: 'INVALID_PARAMETER' });
     }
+    Object.assign(params, { group: 1 });
     let response = await request.bind(this)('get-subscription', params, Object.assign({ auth: true }, { fetchOptions }));
     response.list = response.list.map(_mapper || ((s) => {
         let subscription = {};
@@ -48,43 +36,39 @@ export async function getSubscriptions(params, fetchOptions, _mapper) {
 }
 export async function subscribe(option) {
     await this.__connection;
-    let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
-    if (typeof group !== 'number') {
-        throw new SkapiError('"group" should be type: number.', { code: 'INVALID_PARAMETER' });
-    }
+    let { user_id } = subscriptionGroupCheck.bind(this)(option);
     return await request.bind(this)('subscription', {
         subscribe: user_id,
-        group
+        group: 1
     }, { auth: true });
 }
 export async function unsubscribe(option) {
     await this.__connection;
-    let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
+    let { user_id } = subscriptionGroupCheck.bind(this)(option);
     return await request.bind(this)('subscription', {
         unsubscribe: user_id,
-        group
+        group: 1
     }, { auth: true });
 }
 export async function blockSubscriber(option) {
     await this.__connection;
-    let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
-    return await request.bind(this)('subscription', { block: user_id, group }, { auth: true });
+    let { user_id } = subscriptionGroupCheck.bind(this)(option);
+    return await request.bind(this)('subscription', { block: user_id, group: 1 }, { auth: true });
 }
 export async function unblockSubscriber(option) {
     await this.__connection;
-    let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
-    return await request.bind(this)('subscription', { unblock: user_id, group }, { auth: true });
+    let { user_id } = subscriptionGroupCheck.bind(this)(option);
+    return await request.bind(this)('subscription', { unblock: user_id, group: 1 }, { auth: true });
 }
 export async function getSubscribedTo(option, fetchOptions) {
     await this.__connection;
     option = validator.Params(option, {
         user_id: (v) => validator.UserId(v, '"user_id"'),
-        group: 'number',
         blocked: 'boolean'
     }) || {};
     return getSubscriptions.bind(this)({
         subscriber: option.user_id || this.__user?.user_id,
-        group: option.group,
+        group: 1,
         blocked: option.blocked
     }, fetchOptions);
 }
@@ -93,12 +77,11 @@ export async function getSubscribers(option, fetchOptions) {
     await this.__connection;
     option = validator.Params(option, {
         user_id: (v) => validator.UserId(v, '"user_id"'),
-        group: 'number',
         blocked: 'boolean'
     }) || {};
     let subParams = {
         subscription: option.user_id || this.__user?.user_id,
-        group: option.group,
+        group: 1,
         blocked: option.blocked
     };
     return getSubscriptions.bind(this)(subParams, fetchOptions);
@@ -114,7 +97,18 @@ export async function getNewsletterSubscription(params) {
             }
             return v;
         },
-        group: 'number'
+        group: v => {
+            if (v === 'public') {
+                v = 0;
+            }
+            if (v === 'authorized') {
+                v = 1;
+            }
+            if (typeof v !== 'number') {
+                throw new SkapiError('"group" should be type number | "public" | "authorized".', { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        }
     });
     let list = await request.bind(this)('get-newsletter-subscription', params, { auth: true });
     let result = [];

package/js/methods/user.d.ts

@@ -1,5 +1,5 @@
 import { CognitoUser, CognitoUserSession, CognitoUserPool } from 'amazon-cognito-identity-js';
-import { User, Form, FormSubmitCallback, UserProfile, FetchOptions, DatabaseResponse, QueryParams, UserAttributes, PublicUser } from '../Types';
+import { Form, FormSubmitCallback, UserProfile, FetchOptions, DatabaseResponse, UserAttributes, PublicUser } from '../Types';
 export declare let userPool: CognitoUserPool | null;
 export declare function setUserPool(params: {
     UserPoolId: string;
@@ -9,7 +9,7 @@ export declare function authentication(): {
     getSession: (option?: {
         refreshToken?: boolean;
     }) => Promise<CognitoUserSession>;
-    authenticateUser: (email: string, password: string) => Promise<User>;
+    authenticateUser: (email: string, password: string) => Promise<UserProfile>;
     createCognitoUser: (email: string) => Promise<{
         cognitoUser: CognitoUser;
         cognitoUsername: string;
@@ -18,16 +18,16 @@ export declare function authentication(): {
 };
 export declare function getProfile(options?: {
     refreshToken: boolean;
-}): Promise<User | null>;
+}): Promise<UserProfile | null>;
 export declare function checkAdmin(): Promise<boolean>;
 export declare function logout(): Promise<'SUCCESS: The user has been logged out.'>;
 export declare function resendSignupConfirmation(redirect: string): Promise<'SUCCESS: Signup confirmation E-Mail has been sent.'>;
 export declare function recoverAccount(redirect?: boolean | string): Promise<"SUCCESS: Recovery e-mail has been sent.">;
 export declare function login(form: Form<{
-    username: string;
+    username?: string;
     email: string;
     password: string;
-}>): Promise<User>;
+}>): Promise<UserProfile>;
 export declare function signup(form: Form<UserAttributes & {
     email: String;
     password: String;
@@ -35,7 +35,7 @@ export declare function signup(form: Form<UserAttributes & {
     signup_confirmation?: boolean | string;
     email_subscription?: boolean;
     login?: boolean;
-} & FormSubmitCallback): Promise<User | "SUCCESS: The account has been created. User's signup confirmation is required." | 'SUCCESS: The account has been created.'>;
+} & FormSubmitCallback): Promise<UserProfile | "SUCCESS: The account has been created. User's signup confirmation is required." | 'SUCCESS: The account has been created.'>;
 export declare function disableAccount(): Promise<'SUCCESS: account has been disabled.'>;
 export declare function resetPassword(form: Form<{
     email: string;
@@ -55,8 +55,13 @@ export declare function changePassword(params: {
     new_password: string;
     current_password: string;
 }): Promise<'SUCCESS: Password has been changed.'>;
-export declare function updateProfile(form: Form<UserAttributes>): Promise<User>;
-export declare function getUsers(params?: QueryParams | null, fetchOptions?: FetchOptions): Promise<DatabaseResponse<PublicUser>>;
+export declare function updateProfile(form: Form<UserAttributes>): Promise<UserProfile>;
+export declare function getUsers(params?: {
+    searchFor: string;
+    value: string | number | boolean;
+    condition?: '>' | '>=' | '=' | '<' | '<=' | '!=' | 'gt' | 'gte' | 'eq' | 'lt' | 'lte' | 'ne';
+    range?: string | number | boolean;
+}, fetchOptions?: FetchOptions): Promise<DatabaseResponse<PublicUser>>;
 export declare function lastVerifiedEmail(params?: {
     revert: boolean;
 }): Promise<string | UserProfile>;

package/js/methods/user.js

@@ -125,7 +125,7 @@ export function authentication() {
             }
         });
     };
-    const getSession = (option) => {
+    const getSession = async (option) => {
         let { refreshToken = false } = option || {};
         return new Promise((res, rej) => {
             cognitoUser = userPool?.getCurrentUser() || null;
@@ -206,18 +206,18 @@ export function authentication() {
             this.__request_signup_confirmation = null;
             this.__disabledAccount = null;
             createCognitoUser(email).then(initUser => {
-                cognitoUser = initUser.cognitoUser;
                 let username = initUser.cognitoUsername;
                 let authenticationDetails = new AuthenticationDetails({
                     Username: username,
                     Password: password
                 });
-                cognitoUser.authenticateUser(authenticationDetails, {
+                initUser.cognitoUser.authenticateUser(authenticationDetails, {
                     newPasswordRequired: (userAttributes, requiredAttributes) => {
                         this.__request_signup_confirmation = username;
                         if (userAttributes['custom:signup_ticket'] === 'PASS' || userAttributes['custom:signup_ticket'] === 'MEMBER') {
-                            cognitoUser.completeNewPasswordChallenge(password, {}, {
-                                onSuccess: (result) => {
+                            initUser.cognitoUser.completeNewPasswordChallenge(password, {}, {
+                                onSuccess: _ => {
+                                    cognitoUser = initUser.cognitoUser;
                                     getSession().then(session => res(this.user));
                                 },
                                 onFailure: (err) => {
@@ -229,7 +229,9 @@ export function authentication() {
                             rej(new SkapiError("User's signup confirmation is required.", { code: 'SIGNUP_CONFIRMATION_NEEDED' }));
                         }
                     },
-                    onSuccess: (logged) => getSession().then(session => res(this.user)),
+                    onSuccess: _ => getSession().then(_ => {
+                        res(this.user);
+                    }),
                     onFailure: (err) => {
                         let error = [err.message || 'Failed to authenticate user.', err?.code || 'INVALID_REQUEST'];
                         if (err.code === "NotAuthorizedException") {
@@ -241,6 +243,12 @@ export function authentication() {
                                 error = ['Incorrect username or password.', 'INCORRECT_USERNAME_OR_PASSWORD'];
                             }
                         }
+                        else if (err.code === "UserNotFoundException") {
+                            error = ['Incorrect username or password.', 'INCORRECT_USERNAME_OR_PASSWORD'];
+                        }
+                        else if (err.code === "TooManyRequestsException" || err.code === "LimitExceededException") {
+                            error = ['Too many attempts. Please try again later.', 'REQUEST_EXCEED'];
+                        }
                         let errCode = error[1];
                         let errMsg = error[0];
                         let customErr = error[0].split('#');
@@ -263,7 +271,7 @@ export function authentication() {
     };
 }
 export async function getProfile(options) {
-    await this.__connection;
+    await this.__authConnection;
     try {
         await authentication.bind(this)().getSession(options);
         return this.user;
@@ -316,7 +324,7 @@ export async function resendSignupConfirmation(redirect) {
 }
 export async function recoverAccount(redirect = false) {
     if (typeof redirect === 'string') {
-        validator.Url(redirect);
+        redirect = validator.Url(redirect);
     }
     else if (typeof redirect !== 'boolean') {
         throw new SkapiError('Argument should be type: <boolean | string>.', { code: 'INVALID_REQUEST' });
@@ -329,7 +337,7 @@ export async function recoverAccount(redirect = false) {
     return 'SUCCESS: Recovery e-mail has been sent.';
 }
 export async function login(form) {
-    await logout.bind(this)();
+    await this.logout();
     let params = validator.Params(form, {
         username: 'string',
         email: (v) => validator.Email(v),
@@ -407,18 +415,23 @@ export async function signup(form, option) {
     }
     params.signup_confirmation = signup_confirmation;
     params.email_subscription = option?.email_subscription || false;
-    delete params.service;
-    delete params.owner;
-    await request.bind(this)("signup", params);
+    if (!admin_creating_account) {
+        delete params.service;
+        delete params.owner;
+    }
+    let resp = await request.bind(this)("signup", params, { auth: admin_creating_account });
     if (signup_confirmation) {
         let u = await authentication.bind(this)().createCognitoUser(params.username || params.email);
         cognitoUser = u.cognitoUser;
         this.__request_signup_confirmation = u.cognitoUsername;
         return "SUCCESS: The account has been created. User's signup confirmation is required.";
     }
-    if (logUser) {
+    if (logUser && !admin_creating_account) {
         return login.bind(this)({ email: params.username || params.email, password: params.password });
     }
+    if (admin_creating_account) {
+        return resp;
+    }
     return 'SUCCESS: The account has been created.';
 }
 export async function disableAccount() {
@@ -551,6 +564,9 @@ export async function changePassword(params) {
                 else if (err?.code === "NotAuthorizedException") {
                     rej(new SkapiError('Incorrect password.', { code: 'INVALID_REQUEST' }));
                 }
+                else if (err?.code === "TooManyRequestsException" || err?.code === "LimitExceededException") {
+                    rej(new SkapiError('Too many attempts. Please try again later.', { code: 'REQUEST_EXCEED' }));
+                }
                 else {
                     rej(new SkapiError(err?.message || 'Failed to change user password.', { code: err?.code || err?.name }));
                 }
@@ -673,18 +689,18 @@ export async function getUsers(params, fetchOptions) {
     }
     const searchForTypes = {
         'user_id': (v) => validator.UserId(v),
-        'name': 'string',
         'email': (v) => validator.Email(v),
         'phone_number': (v) => validator.PhoneNumber(v),
-        'address': 'string',
-        'gender': 'string',
-        'birthdate': (v) => validator.Birthdate(v),
         'locale': (v) => {
             if (typeof v !== 'string' || typeof v === 'string' && v.length > 5) {
                 throw new SkapiError('Value of "locale" should be a country code.', { code: 'INVALID_PARAMETER' });
             }
             return v;
         },
+        'name': 'string',
+        'address': 'string',
+        'gender': 'string',
+        'birthdate': (v) => validator.Birthdate(v),
         'timestamp': 'number',
         'access_group': 'number',
         'approved': (v) => {
@@ -716,7 +732,9 @@ export async function getUsers(params, fetchOptions) {
         value: (v) => {
             let checker = searchForTypes[params.searchFor];
             if (typeof checker === 'function') {
-                return checker(v);
+                if (!params?.condition || params?.condition === '=' || params?.range) {
+                    return checker(v);
+                }
             }
             else if (typeof v !== checker) {
                 throw new SkapiError(`Value does not match the type of "${params.searchFor}" index.`, { code: 'INVALID_PARAMETER' });

package/js/utils/utils.d.ts

@@ -16,5 +16,6 @@ declare function generateRandom(length?: number): string;
 declare function extractFormMeta(form: Form<any>): {
     meta: {};
     files: any[];
+    to_bin: any[];
 };
 export { extractFormMeta, MD5, generateRandom };

package/js/utils/utils.js

@@ -1,4 +1,3 @@
-import SkapiError from "../main/error";
 class MD5 {
     static hash(str) {
         if (typeof str !== 'string') {
@@ -182,6 +181,7 @@ function extractFormMeta(form) {
             meta[key] = val;
         }
     }
+    let to_bin = [];
     if (form instanceof FormData) {
         let meta = {};
         let totalFileSize = 0;
@@ -190,18 +190,22 @@ function extractFormMeta(form) {
             let name = pair[0];
             let v = pair[1];
             if (v instanceof File) {
-                if (!files.includes(name)) {
-                    files.push(name);
+                if ((totalFileSize + v.size) > 4000000) {
+                    to_bin.push({ name, file: v });
+                    continue;
                 }
                 totalFileSize += v.size;
+                files.push({ name, file: v });
             }
             else if (v instanceof FileList) {
-                if (!files.includes(name)) {
-                    files.push(name);
-                }
                 if (v && v.length > 0) {
                     for (let idx = 0; idx <= v.length - 1; idx++) {
+                        if ((totalFileSize + v.item(idx).size) > 4000000) {
+                            to_bin.push({ name, file: v.item(idx) });
+                            continue;
+                        }
                         totalFileSize += v.item(idx).size;
+                        files.push({ name, file: v.item(idx) });
                     }
                 }
             }
@@ -209,10 +213,7 @@ function extractFormMeta(form) {
                 appendData(meta, name, v);
             }
         }
-        if (totalFileSize > 4400000) {
-            throw new SkapiError('Total File size cannot exceed 4MB. Use skapi.uploadFiles() instead.', { code: 'INVALID_REQUEST' });
-        }
-        return { meta, files };
+        return { meta, files, to_bin };
     }
     if (form instanceof SubmitEvent) {
         form = form.target;
@@ -262,12 +263,14 @@ function extractFormMeta(form) {
                     }
                 }
                 else if (i.type === 'file') {
-                    if (!files.includes(i.name)) {
-                        files.push(i.name);
-                    }
                     if (i.files && i.files.length > 0) {
                         for (let idx = 0; idx <= i.files.length - 1; idx++) {
+                            if ((totalFileSize + i.files.item(idx).size) > 4000000) {
+                                to_bin.push({ name: i.name, file: i.files.item(idx) });
+                                continue;
+                            }
                             totalFileSize += i.files.item(idx).size;
+                            files.push({ name: i.name, file: i.files.item(idx) });
                         }
                     }
                 }
@@ -276,10 +279,7 @@ function extractFormMeta(form) {
                 }
             }
         }
-        if (totalFileSize > 4400000) {
-            throw new SkapiError('Total File size cannot exceed 4MB. Use skapi.uploadFiles() instead.', { code: 'INVALID_REQUEST' });
-        }
-        return { meta, files };
+        return { meta, files, to_bin };
     }
     return null;
 }

package/js/utils/validator.js

@@ -85,26 +85,32 @@ function Url(url) {
             }
             else {
                 let cu = c.trim();
-                if (!cu.includes(' ') && !cu.includes(',')) {
-                    if (cu.slice(0, 1) === '/' && baseUrl) {
-                        cu = baseUrl + cu;
+                if (cu[0] === '/' && baseUrl) {
+                    if (baseUrl.slice(0, 5) === 'file:') {
+                        throw new SkapiError(`"${c}" is an invalid url. Relative URL does not work on local file system. Use full URL string.`, { code: 'INVALID_PARAMETER' });
                     }
-                    else if (cu.slice(0, 1) === '.' && baseUrl) {
-                        cu = window.location.href.split('/').slice(0, -1).join('/') + cu;
-                    }
-                    let _url;
-                    try {
-                        _url = new URL(cu);
-                    }
-                    catch (err) {
-                        throw new SkapiError(`"${c}" is an invalid url.`, { code: 'INVALID_PARAMETER' });
+                    cu = baseUrl + cu;
+                }
+                else if (cu[0] === '.' && baseUrl) {
+                    if (baseUrl.slice(0, 5) === 'file:') {
+                        throw new SkapiError(`"${c}" is an invalid url. Relative URL does not work on local file system. Use full URL string.`, { code: 'INVALID_PARAMETER' });
                     }
-                    if (_url.protocol) {
-                        let url = _url.href;
-                        if (url.charAt(url.length - 1) === '/')
-                            url = url.substring(0, url.length - 1);
-                        return url;
+                    let curr_loc = window.location.href.split('?')[0];
+                    if (curr_loc.slice(-1) !== '/') {
+                        curr_loc += '/';
                     }
+                    cu = curr_loc + cu.slice(1);
+                }
+                let _url;
+                try {
+                    _url = new URL(cu);
+                }
+                catch (err) {
+                    throw new SkapiError(`"${c}" is an invalid url.`, { code: 'INVALID_PARAMETER' });
+                }
+                if (_url.protocol) {
+                    let url = _url.href;
+                    return url;
                 }
             }
         }
@@ -122,13 +128,13 @@ function specialChars(string, p = 'parameter', allowPeriods = false, allowWhiteS
         if (typeof s !== 'string') {
             throw new SkapiError(`${p} should be type: <string | string[]>.`, { code: 'INVALID_PARAMETER' });
         }
-        if (!allowWhiteSpace && string.includes(' ')) {
+        if (!allowWhiteSpace && s.includes(' ')) {
             throw new SkapiError(`${p} should not have whitespace.`, { code: 'INVALID_PARAMETER' });
         }
-        if (!allowPeriods && string.includes('.')) {
+        if (!allowPeriods && s.includes('.')) {
             throw new SkapiError(`${p} should not have periods.`, { code: 'INVALID_PARAMETER' });
         }
-        if (/[`!@#$%^&*()_+\-=\[\]{};':"\\|,<>\/?~]/.test(s)) {
+        if (/[!@#$%&*()+\-={};':"\|,<>\/?~]/.test(s)) {
             throw new SkapiError(`${p} should not have special characters.`, { code: 'INVALID_PARAMETER' });
         }
     };