skapi-js 0.2.5 → 1.0.0-alpha.11

package/js/methods/database.js

@@ -2,7 +2,6 @@ import SkapiError from '../main/error';
 import { extractFormMeta, generateRandom } from '../utils/utils';
 import validator from '../utils/validator';
 import { request } from './request';
-import { checkAdmin } from './user';
 const __index_number_range = 4503599627370496;
 function normalizeRecord(record) {
     function base_decode(chars) {
@@ -149,28 +148,34 @@ function normalizeTypedString(v) {
     }
 }
 export async function deleteFiles(params) {
-    let isAdmin = await checkAdmin.bind(this)();
-    let { service = this.service, endpoints, storage = 'records' } = params;
-    if (storage === 'host' && !isAdmin) {
-        throw new SkapiError("No access", { code: 'INVALID_REQUEST' });
-    }
+    let { endpoints } = params;
     if (typeof endpoints === 'string') {
         endpoints = [endpoints];
     }
     if (!Array.isArray(endpoints)) {
         throw new SkapiError('"endpoints" should be type: array | string.', { code: 'INVALID_PARAMETER' });
     }
-    if (storage !== 'host' && storage !== 'records') {
-        throw new SkapiError('"storage" should be type: "records" | "host".', { code: 'INVALID_PARAMETER' });
-    }
     return request.bind(this)('del-files', {
-        service,
         endpoints,
-        storage
+        storage: 'records'
     }, { auth: true, method: 'post' });
 }
 export async function uploadFiles(fileList, params) {
-    let isAdmin = await checkAdmin.bind(this)();
+    await this.__connection;
+    let { service = this.service, request = 'post' } = params || {};
+    if (request === 'post') {
+        if (!params?.record_id) {
+            throw new SkapiError('"record_id" is required.', { code: 'INVALID_PARAMETER' });
+        }
+    }
+    else {
+        if (service === this.service) {
+            throw new SkapiError('invalid service.', { code: 'INVALID_PARAMETER' });
+        }
+        if (request !== 'host') {
+            throw new SkapiError('invalid request.', { code: 'INVALID_PARAMETER' });
+        }
+    }
     if (fileList instanceof SubmitEvent) {
         fileList = fileList.target;
     }
@@ -193,21 +198,12 @@ export async function uploadFiles(fileList, params) {
     let reserved_key = generateRandom();
     let getSignedParams = {
         reserved_key,
-        service: params?.service || this.service,
-        request: params?.request || 'post'
+        service,
+        request
     };
-    if (getSignedParams.request === 'host') {
-        if (!isAdmin) {
-            throw new SkapiError('The user has no access.', { code: 'INVALID_REQUEST' });
-        }
-        getSignedParams.request === 'post-host';
-    }
     if (params?.record_id) {
         getSignedParams.id = params.record_id;
     }
-    else if (!isAdmin) {
-        throw new SkapiError('Record ID is required.', { code: 'INVALID_PARAMETER' });
-    }
     let xhr;
     let fetchProgress = (url, body, progressCallback) => {
         return new Promise((res, rej) => {
@@ -851,7 +847,7 @@ export async function deleteRecords(params) {
     }
     return await request.bind(this)('del-records', params, { auth: true });
 }
-export async function grantPrivateRecordAccess(params) {
+export function grantPrivateRecordAccess(params) {
     if (!params.record_id) {
         throw new SkapiError(`Record ID is required.`, { code: 'INVALID_PARAMETER' });
     }
@@ -864,7 +860,7 @@ export async function grantPrivateRecordAccess(params) {
         execute: 'add'
     });
 }
-export async function removePrivateRecordAccess(params) {
+export function removePrivateRecordAccess(params) {
     if (!params.record_id) {
         throw new SkapiError(`Record ID is required.`, { code: 'INVALID_PARAMETER' });
     }
@@ -877,17 +873,17 @@ export async function removePrivateRecordAccess(params) {
         execute: 'remove'
     });
 }
-export async function listPrivateRecordAccess(params) {
+export function listPrivateRecordAccess(params) {
     return recordAccess({
         record_id: params.record_id,
         user_id: params.user_id || null,
         execute: 'list'
     });
 }
-export async function requestPrivateRecordAccessKey(record_id) {
-    await request.bind(this)('request-private-access-key', { record_id }, { auth: true });
+export function requestPrivateRecordAccessKey(record_id) {
+    return request.bind(this)('request-private-access-key', { record_id }, { auth: true });
 }
-async function recordAccess(params) {
+function recordAccess(params) {
     let execute = params.execute;
     let req = validator.Params(params, {
         record_id: 'string',
@@ -916,5 +912,5 @@ async function recordAccess(params) {
     if (!req.user_id) {
         req.user_id = null;
     }
-    await request.bind(this)('grant-private-access', req, { auth: true });
+    return request.bind(this)('grant-private-access', req, { auth: true });
 }

package/js/methods/request.d.ts

@@ -1,9 +1,5 @@
 import { Form, FormSubmitCallback, FetchOptions, Connection } from '../Types';
-export declare function getConnection(): Promise<Connection | null>;
-export declare function listHostDirectory(params: {
-    service: string;
-    dir: string;
-}, fetchOptions: FetchOptions): Promise<any>;
+export declare function getConnection(): Promise<Connection>;
 export declare function request(url: string, data?: Form<any> | null, options?: {
     fetchOptions?: FetchOptions & FormSubmitCallback;
     auth?: boolean;
@@ -20,14 +16,14 @@ export declare function secureRequest<RequestParams = {
 }>(params: RequestParams | RequestParams[]): Promise<any>;
 export declare function mock(data: Form<any | {
     raise?: 'ERR_INVALID_REQUEST' | 'ERR_INVALID_PARAMETER' | 'SOMETHING_WENT_WRONG' | 'ERR_EXISTS' | 'ERR_NOT_EXISTS';
-}>, formCallback?: FormSubmitCallback, options?: {
+}>, options?: {
     auth?: boolean;
     method?: string;
     meta?: Record<string, any>;
     bypassAwaitConnection?: boolean;
     responseType?: string;
     contentType?: string;
-}): Promise<{
+} & FormSubmitCallback): Promise<{
     mockResponse: Record<string, any>;
 }>;
 export declare function getFormResponse(): Promise<any>;

package/js/methods/request.js

@@ -5,20 +5,6 @@ const __pendingRequest = {};
 export function getConnection() {
     return this.__connection;
 }
-export async function listHostDirectory(params, fetchOptions) {
-    let is_admin = await this.checkAdmin();
-    if (is_admin) {
-        if (!params?.dir) {
-            params.dir = '/';
-        }
-        return request.bind(this)('list-host-directory', params, {
-            fetchOptions,
-            auth: true,
-            method: 'post'
-        });
-    }
-    return [];
-}
 export async function request(url, data = null, options) {
     options = options || {};
     let { auth = false, method = 'post', meta = null, bypassAwaitConnection = false, } = options;
@@ -225,43 +211,44 @@ export async function request(url, data = null, options) {
     if (requestKey && typeof requestKey === 'object') {
         return requestKey;
     }
-    if (typeof requestKey === 'string') {
-        if (!(__pendingRequest[requestKey] instanceof Promise)) {
-            let headers = {
-                'Accept': '*/*'
-            };
-            if (token) {
-                headers.Authorization = token;
-            }
-            if (meta) {
-                headers["Content-Meta"] = window.btoa(encodeURIComponent(typeof meta === 'string' ? meta : JSON.stringify(meta)));
-            }
-            if (options.hasOwnProperty('contentType')) {
-                if (options?.contentType) {
-                    headers["Content-Type"] = options.contentType;
-                }
-            }
-            else if (!(data instanceof FormData)) {
-                headers["Content-Type"] = 'application/json';
-            }
-            let opt = { headers };
-            if (options?.responseType) {
-                opt.responseType = options.responseType;
-            }
-            if (method === 'post') {
-                __pendingRequest[requestKey] = _post.bind(this)(endpoint, data, opt, progress);
-            }
-            else if (method === 'get') {
-                __pendingRequest[requestKey] = _get.bind(this)(endpoint, data, opt, progress);
+    if (!requestKey || typeof requestKey !== 'string') {
+        return null;
+    }
+    if (!(__pendingRequest[requestKey] instanceof Promise)) {
+        let headers = {
+            'Accept': '*/*'
+        };
+        if (token) {
+            headers.Authorization = token;
+        }
+        if (meta) {
+            headers["Content-Meta"] = window.btoa(encodeURIComponent(typeof meta === 'string' ? meta : JSON.stringify(meta)));
+        }
+        if (options.hasOwnProperty('contentType')) {
+            if (options?.contentType) {
+                headers["Content-Type"] = options.contentType;
             }
         }
+        else if (!(data instanceof FormData)) {
+            headers["Content-Type"] = 'application/json';
+        }
+        let opt = { headers };
+        if (options?.responseType) {
+            opt.responseType = options.responseType;
+        }
+        if (method === 'post') {
+            __pendingRequest[requestKey] = _post.bind(this)(endpoint, data, opt, progress);
+        }
+        else if (method === 'get') {
+            __pendingRequest[requestKey] = _get.bind(this)(endpoint, data, opt, progress);
+        }
         try {
             let response = await __pendingRequest[requestKey];
             if (isForm) {
                 return response;
             }
             else {
-                return await update_startKey_keys.bind(this)({
+                return update_startKey_keys.bind(this)({
                     hashedParam: requestKey,
                     url,
                     response
@@ -536,13 +523,13 @@ export async function secureRequest(params) {
     return await request.bind(this)('post-secure', params, { auth: true });
 }
 ;
-export async function mock(data, formCallback, options) {
-    options = options || {};
-    if (formCallback && formCallback?.formData && typeof formCallback.formData === 'function') {
-        let fetchOptions = {
-            formData: formCallback.formData
-        };
-        Object.assign(options, fetchOptions);
+export async function mock(data, options) {
+    let { auth = true, method = 'POST', meta, bypassAwaitConnection = false, responseType, contentType } = options || {};
+    let { response, onerror, formData, progress } = options || {};
+    if (options) {
+        Object.assign({ auth, method, meta, bypassAwaitConnection, responseType, contentType }, {
+            fetchOptions: { response, onerror, formData, progress }
+        });
     }
     return request.bind(this)('mock', data, options);
 }

package/js/methods/subscription.d.ts

@@ -1,4 +1,4 @@
-import { DatabaseResponse, FetchOptions, FormSubmitCallback, Form, Newsletters, SubscriptionGroup } from '../Types';
+import { DatabaseResponse, FetchOptions, Form, Newsletters, SubscriptionGroup } from '../Types';
 export declare function getSubscriptions(params: {
     subscriber?: string;
     subscription?: string;
@@ -33,7 +33,7 @@ export declare function subscribeNewsletter(form: Form<{
     email?: string;
     group: number | 'public' | 'authorized';
     redirect?: string;
-}>, callbacks: FormSubmitCallback): Promise<string>;
+}>): Promise<string>;
 export declare function unsubscribeNewsletter(params: {
     group: number | 'public' | 'authorized' | null;
 }): Promise<string>;

package/js/methods/subscription.js

@@ -135,14 +135,14 @@ export async function getNewsletterSubscription(params) {
     }
     return result;
 }
-export async function subscribeNewsletter(form, callbacks) {
+export async function subscribeNewsletter(form) {
     await this.__connection;
     let params = validator.Params(form || {}, {
         email: (v) => validator.Email(v),
         group: ['number', 'public', 'authorized'],
         redirect: (v) => validator.Url(v)
     }, this.__user ? ['group'] : ['email', 'group']);
-    return request.bind(this)(`subscribe-${this.__user ? '' : 'public-'}newsletter`, params, { fetchOptions: callbacks, auth: !!this.__user });
+    return request.bind(this)(`subscribe-${this.__user ? '' : 'public-'}newsletter`, params, { auth: !!this.__user });
 }
 export async function unsubscribeNewsletter(params) {
     await this.__connection;

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 } from '../Types';
+import { Form, FormSubmitCallback, UserProfile, FetchOptions, DatabaseResponse, QueryParams, 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,15 +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(e: SubmitEvent): Promise<'SUCCESS: The user has been logged out.'>;
+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;
     email: string;
     password: string;
-}>, option?: FormSubmitCallback): Promise<User>;
+}>): Promise<UserProfile>;
 export declare function signup(form: Form<UserAttributes & {
     email: String;
     password: String;
@@ -34,32 +35,32 @@ 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;
     code: string | number;
     new_password: string;
-}>, option?: FormSubmitCallback): Promise<"SUCCESS: New password has been set.">;
-export declare function verifyPhoneNumber(form: Form<{
+}>): Promise<"SUCCESS: New password has been set.">;
+export declare function verifyPhoneNumber(form?: Form<{
     code: string;
 }>): Promise<'SUCCESS: Verification code has been sent.' | 'SUCCESS: "phone_number" is verified.'>;
-export declare function verifyEmail(form: Form<{
+export declare function verifyEmail(form?: Form<{
     code: string;
 }>): Promise<'SUCCESS: Verification code has been sent.' | 'SUCCESS: "email" is verified.'>;
 export declare function forgotPassword(form: Form<{
     email: string;
-}>, option?: FormSubmitCallback): Promise<"SUCCESS: Verification code has been sent.">;
+}>): Promise<"SUCCESS: Verification code has been sent.">;
 export declare function changePassword(params: {
     new_password: string;
     current_password: string;
-}): Promise<unknown>;
-export declare function updateProfile(form: Form<UserAttributes>, option?: FormSubmitCallback): Promise<any>;
-export declare function getUsers(params?: QueryParams | null, fetchOptions?: FetchOptions): Promise<DatabaseResponse<UserAttributes>>;
+}): Promise<'SUCCESS: Password has been changed.'>;
+export declare function updateProfile(form: Form<UserAttributes>): Promise<UserProfile>;
+export declare function getUsers(params?: QueryParams | null, fetchOptions?: FetchOptions): Promise<DatabaseResponse<PublicUser>>;
 export declare function lastVerifiedEmail(params?: {
     revert: boolean;
 }): Promise<string | UserProfile>;
 export declare function requestUsernameChange(params: {
     redirect?: string;
     username: string;
-}): Promise<'SUCCESS: ...'>;
+}): Promise<'SUCCESS: confirmation e-mail has been sent.'>;

package/js/methods/user.js

@@ -215,7 +215,19 @@ export function authentication() {
                 cognitoUser.authenticateUser(authenticationDetails, {
                     newPasswordRequired: (userAttributes, requiredAttributes) => {
                         this.__request_signup_confirmation = username;
-                        rej(new SkapiError("User's signup confirmation is required.", { code: 'SIGNUP_CONFIRMATION_NEEDED' }));
+                        if (userAttributes['custom:signup_ticket'] === 'PASS' || userAttributes['custom:signup_ticket'] === 'MEMBER') {
+                            cognitoUser.completeNewPasswordChallenge(password, {}, {
+                                onSuccess: (result) => {
+                                    getSession().then(session => res(this.user));
+                                },
+                                onFailure: (err) => {
+                                    rej(new SkapiError(err.message || 'Failed to authenticate user.', { code: err.code }));
+                                }
+                            });
+                        }
+                        else {
+                            rej(new SkapiError("User's signup confirmation is required.", { code: 'SIGNUP_CONFIRMATION_NEEDED' }));
+                        }
                     },
                     onSuccess: (logged) => getSession().then(session => res(this.user)),
                     onFailure: (err) => {
@@ -243,7 +255,12 @@ export function authentication() {
             });
         });
     };
-    return { getSession, authenticateUser, createCognitoUser, getUser };
+    return {
+        getSession,
+        authenticateUser,
+        createCognitoUser,
+        getUser,
+    };
 }
 export async function getProfile(options) {
     await this.__connection;
@@ -265,7 +282,7 @@ export async function checkAdmin() {
     }
     return false;
 }
-export async function logout(e) {
+export async function logout() {
     await this.__connection;
     if (cognitoUser) {
         cognitoUser.signOut();
@@ -311,17 +328,18 @@ export async function recoverAccount(redirect = false) {
     this.__disabledAccount = null;
     return 'SUCCESS: Recovery e-mail has been sent.';
 }
-export async function login(form, option) {
+export async function login(form) {
     await logout.bind(this)();
     let params = validator.Params(form, {
+        username: 'string',
         email: (v) => validator.Email(v),
         password: (v) => validator.Password(v)
     }, ['email', 'password']);
-    return authentication.bind(this)().authenticateUser(params.email, params.password);
+    return authentication.bind(this)().authenticateUser(params.username || params.email, params.password);
 }
 export async function signup(form, option) {
-    await this.logout();
     let params = validator.Params(form || {}, {
+        username: 'string',
         email: (v) => validator.Email(v),
         password: (v) => validator.Password(v),
         name: 'string',
@@ -334,8 +352,20 @@ export async function signup(form, option) {
         gender_public: ['boolean', () => false],
         birthdate_public: ['boolean', () => false],
         phone_number_public: ['boolean', () => false],
+        access_group: 'number',
         misc: 'string'
     }, ['email', 'password']);
+    let is_admin = await checkAdmin.bind(this)();
+    let admin_creating_account = is_admin && params.service && this.service !== params.service;
+    if (admin_creating_account) {
+        params.owner = this.__user.user_id;
+    }
+    else {
+        if (params.access_group) {
+            throw new SkapiError('Only admins can set "access_group" parameter.', { code: 'INVALID_PARAMETER' });
+        }
+        await this.logout();
+    }
     option = validator.Params(option || {}, {
         email_subscription: (v) => {
             if (typeof v !== 'boolean') {
@@ -369,20 +399,25 @@ export async function signup(form, option) {
     });
     let logUser = option?.login || false;
     let signup_confirmation = option?.signup_confirmation || false;
+    if (admin_creating_account && signup_confirmation) {
+        throw new SkapiError('Admins cannot create an account with "option.signup_confirmation" option.', { code: 'INVALID_PARAMETER' });
+    }
     if (params.email_public && !signup_confirmation) {
         throw new SkapiError('"option.signup_confirmation" should be true if "email_public" is set to true.', { code: 'INVALID_PARAMETER' });
     }
     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 (signup_confirmation) {
-        let u = await authentication.bind(this)().createCognitoUser(params.email);
+        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) {
-        return login.bind(this)({ email: params.email, password: params.password });
+        return login.bind(this)({ email: params.username || params.email, password: params.password });
     }
     return 'SUCCESS: The account has been created.';
 }
@@ -392,7 +427,7 @@ export async function disableAccount() {
     await logout.bind(this)();
     return result;
 }
-export async function resetPassword(form, option) {
+export async function resetPassword(form) {
     await this.__connection;
     let params = validator.Params(form, {
         email: (v) => validator.Email(v),
@@ -473,7 +508,7 @@ export function verifyPhoneNumber(form) {
 export function verifyEmail(form) {
     return verifyAttribute.bind(this)('email', form);
 }
-export async function forgotPassword(form, option) {
+export async function forgotPassword(form) {
     await this.__connection;
     let params = validator.Params(form, {
         email: (v) => validator.Email(v)
@@ -524,7 +559,7 @@ export async function changePassword(params) {
         });
     });
 }
-export async function updateProfile(form, option) {
+export async function updateProfile(form) {
     await this.__connection;
     if (!this.session) {
         throw new SkapiError('User login is required.', { code: 'INVALID_REQUEST' });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skapi-js",
-  "version": "0.2.5",
+  "version": "1.0.0-alpha.11",
   "description": "Javascript library for Skapi: Complete JAM Stack, front-end driven serverless backend API service.",
   "main": "./dist/skapi.module.js",
   "types": "./js/Main.d.ts",
@@ -9,8 +9,8 @@
     "dist/"
   ],
   "scripts": {
-    "build": "npx tsc --project tsconfig.json; npx webpack --config webpack.config.js",
-    "server": "(cd server; node server.js)"
+    "build": "npx tsc --project tsconfig.json; npx webpack --config webpack.config.js; cp -r dist playground;",
+    "dev": "(cd playground; node server.js)"
   },
   "repository": {
     "type": "git",
@@ -24,6 +24,7 @@
   },
   "homepage": "https://www.skapi.com",
   "devDependencies": {
+    "amazon-cognito-identity-js": "^5.2.14",
     "typescript": "^4.9.4",
     "webpack": "^5.74.0",
     "webpack-cli": "^4.10.0"
@@ -33,8 +34,5 @@
     "skapi",
     "api",
     "jamstack"
-  ],
-  "dependencies": {
-    "amazon-cognito-identity-js": "^5.2.14"
-  }
+  ]
 }