skapi-js 1.0.17-alpha → 1.0.18-alpha

package/js/main/skapi.d.ts

@@ -28,15 +28,37 @@ export default class Skapi {
     };
     private __connection;
     private __authConnection;
+    private __socket;
+    private __socket_group;
     constructor(service: string, owner: string, options?: {
         autoLogin: boolean;
     });
     updateConnection(): Promise<Connection>;
     private checkAdmin;
     private request;
-    private getSubscribedTo;
-    private getSubscribers;
     normalizeRecord: any;
+    connectRealtime(cb: (rt: {
+        status: 'message' | 'error' | 'success' | 'close' | 'notice';
+        message: any;
+    }) => Promise<void>): any;
+    closeRealtime(): Promise<void>;
+    getRealtimeUsers(params: {
+        group: string;
+        user_id?: string;
+    }, fetchOptions?: FetchOptions): Promise<DatabaseResponse<string[]>>;
+    postRealtime(message: any, recipient: string): Promise<{
+        status: 'success';
+        message: 'Message sent.';
+    } | {
+        status: 'error';
+        message: 'Realtime connection is not open.';
+    }>;
+    joinRealtime(params: {
+        group: string | null;
+    }): Promise<{
+        status: 'success';
+        message: string;
+    }>;
     getConnection(): Promise<Connection>;
     getProfile(options?: {
         refreshToken: boolean;

package/js/main/skapi.js

@@ -7,8 +7,9 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 import SkapiError from './error';
 import validator from '../utils/validator';
 import { getRecords, postRecord, deleteRecords, getTables, getIndexes, getTags, uploadFiles, getFile, grantPrivateRecordAccess, removePrivateRecordAccess, listPrivateRecordAccess, requestPrivateRecordAccessKey, deleteFiles, normalizeRecord } from '../methods/database';
+import { connectRealtime, joinRealtime, postRealtime, closeRealtime, getRealtimeUsers } from '../methods/realtime';
 import { request, secureRequest, mock, getFormResponse, formHandler, getConnection } from '../methods/request';
-import { subscribe, unsubscribe, blockSubscriber, unblockSubscriber, getSubscribers, getSubscribedTo, getSubscriptions, subscribeNewsletter, getNewsletters, unsubscribeNewsletter, getNewsletterSubscription } from '../methods/subscription';
+import { subscribe, unsubscribe, blockSubscriber, unblockSubscriber, getSubscriptions, subscribeNewsletter, getNewsletters, unsubscribeNewsletter, getNewsletterSubscription } from '../methods/subscription';
 import { checkAdmin, getProfile, logout, recoverAccount, resendSignupConfirmation, authentication, login, signup, disableAccount, resetPassword, verifyEmail, verifyPhoneNumber, forgotPassword, changePassword, updateProfile, getUsers, setUserPool, userPool, lastVerifiedEmail, requestUsernameChange } from '../methods/user';
 export default class Skapi {
     get user() {
@@ -22,7 +23,7 @@ export default class Skapi {
     set user(value) {
     }
     constructor(service, owner, options) {
-        this.version = '1.0.17-alpha';
+        this.version = '1.0.18-alpha';
         this.session = null;
         this.connection = null;
         this.host = 'skapi';
@@ -84,8 +85,6 @@ export default class Skapi {
         };
         this.checkAdmin = checkAdmin.bind(this);
         this.request = request.bind(this);
-        this.getSubscribedTo = getSubscribedTo.bind(this);
-        this.getSubscribers = getSubscribers.bind(this);
         this.normalizeRecord = normalizeRecord.bind(this);
         if (typeof service !== 'string' || typeof owner !== 'string') {
             throw new SkapiError('"service" and "owner" should be type <string>.', { code: 'INVALID_PARAMETER' });
@@ -192,6 +191,21 @@ export default class Skapi {
         }, { bypassAwaitConnection: true, method: 'get' });
         return this.connection;
     }
+    connectRealtime(cb) {
+        return connectRealtime.bind(this)(cb);
+    }
+    closeRealtime() {
+        return closeRealtime.bind(this)();
+    }
+    getRealtimeUsers(params, fetchOptions) {
+        return getRealtimeUsers.bind(this)(params, fetchOptions);
+    }
+    postRealtime(message, recipient) {
+        return postRealtime.bind(this)(message, recipient);
+    }
+    joinRealtime(params) {
+        return joinRealtime.bind(this)(params);
+    }
     getConnection() {
         return getConnection.bind(this)();
     }
@@ -291,6 +305,15 @@ export default class Skapi {
         return subscribeNewsletter.bind(this)(form);
     }
 }
+__decorate([
+    formHandler()
+], Skapi.prototype, "getRealtimeUsers", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "postRealtime", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "joinRealtime", null);
 __decorate([
     formHandler()
 ], Skapi.prototype, "getConnection", null);

package/js/methods/database.js

@@ -555,6 +555,9 @@ export async function getRecords(query, fetchOptions) {
                 throw new SkapiError("User has no access", { code: 'INVALID_REQUEST' });
             }
         }
+        if (!query.table.hasOwnProperty('access_group')) {
+            query.table.access_group = query.table?.subscription ? 1 : 0;
+        }
     }
     if (query?.index && !query.index?.name) {
         throw new SkapiError('"index.name" is required when using "index" parameter.', { code: 'INVALID_REQUEST' });
@@ -725,7 +728,7 @@ export async function postRecord(form, config) {
     if (!config_chkd?.table && !config_chkd?.record_id) {
         throw new SkapiError('Either "record_id" or "table" should have a value.', { code: 'INVALID_PARAMETER' });
     }
-    if (typeof config_chkd.table !== 'string' && config_chkd.table) {
+    if (config_chkd.table) {
         if (config_chkd.table.access_group === 'public') {
             config_chkd.table.access_group = 0;
         }
@@ -747,8 +750,8 @@ export async function postRecord(form, config) {
             }
         }
         if (config_chkd.table?.subscription) {
-            if (!config_chkd?.record_id && !config_chkd.table?.access_group) {
-                throw new SkapiError('Public records cannot require subscription.', { code: 'INVALID_REQUEST' });
+            if (!config_chkd?.record_id && !config_chkd.table.hasOwnProperty('access_group')) {
+                config_chkd.table.access_group = 1;
             }
             if (config_chkd.table.access_group === 0) {
                 throw new SkapiError('Public records cannot require subscription.', { code: 'INVALID_REQUEST' });

package/js/methods/realtime.d.ts

@@ -0,0 +1,27 @@
+import { DatabaseResponse, FetchOptions } from '../Types';
+type RealTimeCallback = (rt: {
+    status: 'message' | 'error' | 'success' | 'close' | 'notice';
+    message: string | {
+        [key: string]: any;
+    };
+}) => void;
+export declare function closeRealtime(): Promise<void>;
+export declare function connectRealtime(cb: RealTimeCallback, delay?: number): Promise<void>;
+export declare function postRealtime(message: any, recipient: string): Promise<{
+    status: 'success';
+    message: 'Message sent.';
+} | {
+    status: 'error';
+    message: 'Realtime connection is not open.';
+}>;
+export declare function joinRealtime(params: {
+    group?: string | null;
+}): Promise<{
+    status: 'success';
+    message: string;
+}>;
+export declare function getRealtimeUsers(params: {
+    group: string;
+    user_id?: string;
+}, fetchOptions?: FetchOptions): Promise<DatabaseResponse<string[]>>;
+export {};

package/js/methods/realtime.js

@@ -0,0 +1,159 @@
+import SkapiError from '../main/error';
+import validator from '../utils/validator';
+import { extractFormMeta } from '../utils/utils';
+import { request } from './request';
+async function prepareWebsocket() {
+    await this.getProfile();
+    if (!this.session) {
+        throw new SkapiError(`No access.`, { code: 'INVALID_REQUEST' });
+    }
+    let r = await this.record_endpoint;
+    return new WebSocket(r.websocket_private + '?token=' + this.session.accessToken.jwtToken);
+}
+let reconnectAttempts = 0;
+export async function closeRealtime() {
+    let socket = this.__socket ? await this.__socket : this.__socket;
+    if (socket) {
+        socket.close();
+    }
+    this.__socket = null;
+    this.__socket_group = null;
+    return null;
+}
+export function connectRealtime(cb, delay = 0) {
+    if (typeof cb !== 'function') {
+        throw new SkapiError(`Callback must be a function.`, { code: 'INVALID_REQUEST' });
+    }
+    if (reconnectAttempts || !(this.__socket instanceof Promise)) {
+        this.__socket = new Promise(resolve => {
+            setTimeout(async () => {
+                await this.__connection;
+                let socket = await prepareWebsocket.bind(this)();
+                socket.onopen = () => {
+                    reconnectAttempts = 0;
+                    cb({ status: 'success', message: 'Connected to WebSocket server.' });
+                    if (this.__socket_group) {
+                        socket.send(JSON.stringify({
+                            action: 'joinGroup',
+                            rid: this.__socket_group,
+                            token: this.session.accessToken.jwtToken
+                        }));
+                    }
+                    resolve(socket);
+                };
+                socket.onmessage = event => {
+                    let data = JSON.parse(decodeURI(event.data));
+                    if (data?.['#notice']) {
+                        cb({ status: 'notice', message: data['#notice'] });
+                    }
+                    else {
+                        cb({ status: 'message', message: data });
+                    }
+                };
+                socket.onclose = event => {
+                    if (event.wasClean) {
+                        cb({ status: 'close', message: 'WebSocket connection closed.' });
+                        this.__socket = null;
+                        this.__socket_group = null;
+                    }
+                    else {
+                        const maxAttempts = 10;
+                        reconnectAttempts++;
+                        if (reconnectAttempts < maxAttempts) {
+                            let delay = Math.min(1000 * (2 ** reconnectAttempts), 30000);
+                            cb({ status: 'error', message: `Skapi: WebSocket connection error. Reconnecting in ${delay / 1000} seconds...` });
+                            connectRealtime.bind(this)(cb, delay);
+                        }
+                        else {
+                            cb({ status: 'error', message: 'Skapi: WebSocket connection error. Max reconnection attempts reached.' });
+                            this.__socket = null;
+                        }
+                    }
+                };
+                socket.onerror = () => {
+                    cb({ status: 'error', message: 'Skapi: WebSocket connection error.' });
+                    throw new SkapiError(`Skapi: WebSocket connection error.`, { code: 'ERROR' });
+                };
+            }, delay);
+        });
+    }
+    return this.__socket;
+}
+export async function postRealtime(message, recipient) {
+    let socket = this.__socket ? await this.__socket : this.__socket;
+    if (!socket) {
+        throw new SkapiError(`No realtime connection. Execute connectRealtime() before this method.`, { code: 'INVALID_REQUEST' });
+    }
+    if (!recipient) {
+        throw new SkapiError(`No recipient.`, { code: 'INVALID_REQUEST' });
+    }
+    if (message instanceof FormData || message instanceof SubmitEvent || message instanceof HTMLFormElement) {
+        message = extractFormMeta(message).meta;
+    }
+    if (socket.readyState === 1) {
+        try {
+            validator.UserId(recipient);
+            socket.send(JSON.stringify({
+                action: 'sendMessage',
+                uid: recipient,
+                content: message,
+                token: this.session.accessToken.jwtToken
+            }));
+        }
+        catch (err) {
+            if (this.__socket_group !== recipient) {
+                throw new SkapiError(`User has not joined to the recipient group. Run joinRealtime("${recipient}")`, { code: 'INVALID_REQUEST' });
+            }
+            socket.send(JSON.stringify({
+                action: 'broadcast',
+                rid: recipient,
+                content: message,
+                token: this.session.accessToken.jwtToken
+            }));
+        }
+        return { status: 'success', message: 'Message sent.' };
+    }
+    return { status: 'error', message: 'Realtime connection is not open.' };
+}
+export async function joinRealtime(params) {
+    let socket = this.__socket ? await this.__socket : this.__socket;
+    if (!socket) {
+        throw new SkapiError(`No realtime connection. Execute connectRealtime() before this method.`, { code: 'INVALID_REQUEST' });
+    }
+    if (params instanceof FormData || params instanceof SubmitEvent || params instanceof HTMLFormElement) {
+        params = extractFormMeta(params).meta;
+    }
+    let { group = null } = params;
+    if (!group && !this.__socket_group) {
+        return { status: 'success', message: 'Left realtime message group.' };
+    }
+    if (group !== null && typeof group !== 'string') {
+        throw new SkapiError(`"group" must be a string | null.`, { code: 'INVALID_PARAMETER' });
+    }
+    socket.send(JSON.stringify({
+        action: 'joinGroup',
+        rid: group,
+        token: this.session.accessToken.jwtToken
+    }));
+    this.__socket_group = group;
+    return { status: 'success', message: group ? `Joined realtime message group: "${group}".` : 'Left realtime message group.' };
+}
+export async function getRealtimeUsers(params, fetchOptions) {
+    await this.__connection;
+    params = validator.Params(params, {
+        user_id: (v) => validator.UserId(v, 'User ID in "user_id"'),
+        group: 'string'
+    }, ['group']);
+    if (!params.group) {
+        throw new SkapiError(`"group" is required.`, { code: 'INVALID_PARAMETER' });
+    }
+    let res = request.bind(this)('get-ws-group', params, {
+        fetchOptions,
+        auth: true,
+        method: 'post'
+    });
+    for (let i = 0; i < res.list.length; i++) {
+        res[i] = res[i].uid.split('#')[1];
+    }
+    return res;
+}

package/js/methods/request.js

@@ -91,6 +91,7 @@ export async function request(url, data = null, options) {
                 case 'get-signed-url':
                 case 'grant-private-access':
                 case 'request-private-access-key':
+                case 'get-ws-group':
                 case 'del-files':
                     return {
                         private: record.record_private,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skapi-js",
-  "version": "1.0.17-alpha",
+  "version": "1.0.18-alpha",
   "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",