skapi-js 0.2.0 → 0.2.2

package/js/Main.d.ts

@@ -0,0 +1,3 @@
+import Skapi from "./main/skapi";
+import SkapiError from "./main/error";
+export { Skapi, SkapiError };

package/js/Main.js

@@ -0,0 +1,3 @@
+import Skapi from "./main/skapi";
+import SkapiError from "./main/error";
+export { Skapi, SkapiError };

package/js/Types.d.ts

@@ -0,0 +1,194 @@
+export type Condition = 'gt' | 'gte' | 'lt' | 'lte' | 'eq' | 'ne' | '>' | '>=' | '<' | '<=' | '=' | '!=';
+export type SubscriptionGroup<T> = {
+    user_id: string;
+    group?: T;
+};
+export type Database<Tbl, Ref, Idx> = {
+    service?: string;
+    record_id?: string;
+    table?: Tbl;
+    reference?: Ref;
+    index?: Idx;
+    private_access_key?: string;
+};
+export type GetRecordQuery = Database<{
+    name: string;
+    access_group?: number | 'private' | 'public' | 'authorized';
+    subscription?: {
+        user_id: string;
+        group: number;
+    };
+}, string, {
+    name: string | '$updated' | '$uploaded' | '$referenced_count' | '$user_id';
+    value: string | number | boolean;
+    condition?: Condition;
+    range?: string | number | boolean;
+}> & {
+    tag?: string;
+};
+export type PostRecordConfig = Database<{
+    name?: string;
+    access_group?: number | 'private' | 'public' | 'authorized';
+    subscription_group?: number;
+}, {
+    record_id: string;
+    reference_limit: number | null;
+    allow_multiple_reference: boolean;
+}, {
+    name: string;
+    value: string | number | boolean;
+} | null> & {
+    tags?: string[];
+};
+export type RecordData = {
+    service: string;
+    record_id: string;
+    user_id: string;
+    updated: number;
+    uploaded: number;
+    table: {
+        name: string;
+        access_group?: number | 'private' | 'public' | 'authorized';
+        subscription?: {
+            user_id: string;
+            group: number;
+        };
+    };
+    reference: {
+        record_id?: string;
+        reference_limit: number;
+        allow_multiple_reference: boolean;
+        referenced_count: number;
+    };
+    index?: {
+        name: string;
+        value: string | number | boolean;
+    };
+    data?: Record<string, any>;
+    tags?: string[];
+    ip: string;
+};
+export type Connection = {
+    locale: string;
+    owner: string;
+    email: string;
+    service: string;
+    region: string;
+    timestamp: number;
+    ip: string;
+};
+export type FormSubmitCallback = {
+    response?(response: any): any;
+    onerror?(error: Error): any;
+    formData?(formData: FormData): Promise<FormData> | FormData;
+    progress: ProgressCallback;
+};
+export type Form<T> = HTMLFormElement | FormData | SubmitEvent | T;
+export type Newsletters = {
+    message_id: string;
+    timestamp: number;
+    complaint: number;
+    read: number;
+    subject: string;
+    bounced: string;
+    url: string;
+};
+export type UserAttributes = {
+    name?: string;
+    email?: string;
+    phone_number?: string;
+    address?: string | {
+        formatted: string;
+        locality: string;
+        region: string;
+        postal_code: string;
+        country: string;
+    };
+    gender?: string;
+    birthdate?: string;
+    email_public?: boolean;
+    phone_number_public?: boolean;
+    address_public?: boolean;
+    gender_public?: boolean;
+    birthdate_public?: boolean;
+    misc?: string;
+};
+export type UserProfile = {
+    service: string;
+    owner?: string;
+    access_group?: number;
+    user_id: string;
+    locale: string;
+    email_verified?: boolean;
+    phone_number_verified?: boolean;
+    signup_ticket?: string;
+} & UserAttributes;
+export interface User extends UserProfile {
+    subscribers: number;
+    timestamp: number;
+}
+export type QueryParams = {
+    searchFor: string;
+    value: string | number | boolean;
+    condition?: '>' | '>=' | '=' | '<' | '<=' | '!=' | 'gt' | 'gte' | 'eq' | 'lt' | 'lte' | 'ne';
+    range?: string | number | boolean;
+};
+export type ProgressCallback = (e: {
+    status: 'upload' | 'download';
+    progress: number;
+    loaded: number;
+    total: number;
+    currentFile?: File;
+    completed?: File[];
+    failed?: File[];
+    abort: () => void;
+}) => void;
+export type FetchOptions = {
+    limit?: number;
+    fetchMore?: boolean;
+    ascending?: boolean;
+    startKey?: {
+        [key: string]: any;
+    };
+    progress?: ProgressCallback;
+};
+export type DatabaseResponse<T> = {
+    list: T[];
+    startKey: string;
+    endOfList: boolean;
+    startKeyHistory: string[];
+};
+export type Service = {
+    active: number;
+    api_key: string;
+    cors: string[];
+    email: string;
+    email_subscribers: number;
+    group: number;
+    region: string;
+    name: string;
+    newsletter_subscribers: number;
+    service: string;
+    template_activation: {
+        html: string;
+        subject: string;
+    };
+    template_verification: {
+        html: string;
+        sms: string;
+        subject: string;
+    };
+    template_welcome: {
+        html: string;
+        subject: string;
+    };
+    timestamp: number;
+    triggers: {
+        newsletter_signed: string;
+        newsletter_subscribers: string;
+        template_activation: string;
+        template_verification: string;
+        template_welcome: string;
+    };
+    users: number;
+};

package/js/Types.js

@@ -0,0 +1 @@
+export {};

package/js/main/error.d.ts

@@ -0,0 +1,8 @@
+export default class SkapiError extends Error {
+    code: string | number;
+    cause: Error;
+    constructor(error: any, options?: {
+        code?: string;
+        cause?: Error;
+    });
+}

package/js/main/error.js

@@ -0,0 +1,38 @@
+export default class SkapiError extends Error {
+    constructor(error, options) {
+        if (Array.isArray(error) && error.length <= 2) {
+            super(error[1] || 'Something went wrong.');
+            this.name = "SKAPI";
+            this.code = error[0] || "ERROR";
+            if (options) {
+                if (options.code) {
+                    this.code = options.code;
+                }
+                if (options.cause) {
+                    this.cause = options.cause;
+                }
+            }
+        }
+        else if (typeof error === 'string') {
+            super(error || 'Something went wrong.');
+            this.name = "SKAPI";
+            this.code = 'ERROR';
+            if (options) {
+                if (options.code) {
+                    this.code = options.code;
+                }
+                if (options.cause) {
+                    this.cause = options.cause;
+                }
+            }
+        }
+        else if (error instanceof Error) {
+            super(error.message || 'Something went wrong.');
+            this.cause = error;
+            this.name = error.name;
+            if (error.hasOwnProperty('code')) {
+                this.code = error.code;
+            }
+        }
+    }
+}

package/js/main/skapi.d.ts

@@ -0,0 +1,79 @@
+import { User, Connection } from '../Types';
+export default class Skapi {
+    version: string;
+    private __disabledAccount;
+    private __cached_requests;
+    private __startKeyHistory;
+    private __request_signup_confirmation;
+    service: string;
+    owner: string;
+    private __class_properties_has_been_cached;
+    session: Record<string, any> | null;
+    __user: User | null;
+    get user(): User | null;
+    set user(value: User | null);
+    connection: Connection | null;
+    host: string;
+    hostDomain: string;
+    admin_endpoint: Promise<Record<string, any>>;
+    record_endpoint: Promise<Record<string, any>>;
+    validate: {
+        userId(val: string): boolean;
+        url(val: string | string[]): boolean;
+        phoneNumber(val: string): boolean;
+        birthdate(val: string): boolean;
+        email(val: string): boolean;
+    };
+    __connection: Promise<Connection | null>;
+    constructor(service_id: string, owner: string, options?: {
+        autoLogin: boolean;
+    });
+    updateConnection(): Promise<Connection>;
+    getConnection: any;
+    getProfile: any;
+    checkAdmin: any;
+    getFile: any;
+    request: any;
+    secureRequest: any;
+    getFormResponse: any;
+    getRecords: any;
+    getTables: any;
+    getIndexes: any;
+    getTags: any;
+    deleteRecords: any;
+    resendSignupConfirmation: any;
+    recoverAccount: any;
+    getUsers: any;
+    disableAccount: any;
+    lastVerifiedEmail: any;
+    getSubscribedTo: any;
+    getSubscribers: any;
+    getSubscriptions: any;
+    unsubscribeNewsletter: any;
+    getNewsletters: any;
+    getNewsletterSubscription: any;
+    requestUsernameChange: any;
+    grantPrivateRecordAccess: any;
+    removePrivateRecordAccess: any;
+    listPrivateRecordAccess: any;
+    requestPrivateRecordAccessKey: any;
+    listHostDirectory: any;
+    deleteFiles: any;
+    uploadFiles(...args: any[]): any;
+    mock(...args: any[]): any;
+    login(...args: any[]): any;
+    logout(...args: any[]): any;
+    signup(...args: any[]): any;
+    resetPassword(...args: any[]): any;
+    verifyEmail(...args: any[]): any;
+    verifyPhoneNumber(...args: any[]): any;
+    forgotPassword(...args: any[]): any;
+    changePassword(...args: any[]): any;
+    updateProfile(...args: any[]): any;
+    postRecord(...args: any[]): any;
+    subscribe(...args: any[]): any;
+    unsubscribe(...args: any[]): any;
+    blockSubscriber(...args: any[]): any;
+    unblockSubscriber(...args: any[]): any;
+    subscribeNewsletter(...args: any[]): any;
+}

package/js/main/skapi.js

@@ -0,0 +1,285 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import SkapiError from './error';
+import validator from '../utils/validator';
+import { getRecords, postRecord, deleteRecords, getTables, getIndexes, getTags, uploadFiles, getFile, grantPrivateRecordAccess, removePrivateRecordAccess, listPrivateRecordAccess, requestPrivateRecordAccessKey, deleteFiles } from '../methods/database';
+import { request, secureRequest, mock, getFormResponse, formHandler, getConnection, listHostDirectory } from '../methods/request';
+import { subscribe, unsubscribe, blockSubscriber, unblockSubscriber, getSubscribers, getSubscribedTo, 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() {
+        if (this.__user && Object.keys(this.__user).length) {
+            return JSON.parse(JSON.stringify(this.__user));
+        }
+        else {
+            return null;
+        }
+    }
+    set user(value) {
+    }
+    constructor(service_id, owner, options) {
+        this.version = '0.2.2';
+        this.__disabledAccount = null;
+        this.__cached_requests = {};
+        this.__startKeyHistory = {};
+        this.__request_signup_confirmation = null;
+        this.__class_properties_has_been_cached = false;
+        this.session = null;
+        this.__user = null;
+        this.connection = null;
+        this.host = 'skapi';
+        this.hostDomain = 'skapi.com';
+        this.validate = {
+            userId(val) {
+                try {
+                    validator.UserId(val);
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            },
+            url(val) {
+                try {
+                    validator.Url(val);
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            },
+            phoneNumber(val) {
+                try {
+                    validator.PhoneNumber(val);
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            },
+            birthdate(val) {
+                try {
+                    validator.Birthdate(val);
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            },
+            email(val) {
+                try {
+                    validator.Email(val);
+                    return true;
+                }
+                catch (err) {
+                    return false;
+                }
+            }
+        };
+        this.getConnection = getConnection.bind(this);
+        this.getProfile = getProfile.bind(this);
+        this.checkAdmin = checkAdmin.bind(this);
+        this.getFile = getFile.bind(this);
+        this.request = request.bind(this);
+        this.secureRequest = secureRequest.bind(this);
+        this.getFormResponse = getFormResponse.bind(this);
+        this.getRecords = getRecords.bind(this);
+        this.getTables = getTables.bind(this);
+        this.getIndexes = getIndexes.bind(this);
+        this.getTags = getTags.bind(this);
+        this.deleteRecords = deleteRecords.bind(this);
+        this.resendSignupConfirmation = resendSignupConfirmation.bind(this);
+        this.recoverAccount = recoverAccount.bind(this);
+        this.getUsers = getUsers.bind(this);
+        this.disableAccount = disableAccount.bind(this);
+        this.lastVerifiedEmail = lastVerifiedEmail.bind(this);
+        this.getSubscribedTo = getSubscribedTo.bind(this);
+        this.getSubscribers = getSubscribers.bind(this);
+        this.getSubscriptions = getSubscriptions.bind(this);
+        this.unsubscribeNewsletter = unsubscribeNewsletter.bind(this);
+        this.getNewsletters = getNewsletters.bind(this);
+        this.getNewsletterSubscription = getNewsletterSubscription.bind(this);
+        this.requestUsernameChange = requestUsernameChange.bind(this);
+        this.grantPrivateRecordAccess = grantPrivateRecordAccess.bind(this);
+        this.removePrivateRecordAccess = removePrivateRecordAccess.bind(this);
+        this.listPrivateRecordAccess = listPrivateRecordAccess.bind(this);
+        this.requestPrivateRecordAccessKey = requestPrivateRecordAccessKey.bind(this);
+        this.listHostDirectory = listHostDirectory.bind(this);
+        this.deleteFiles = deleteFiles.bind(this);
+        if (typeof service_id !== 'string' || typeof owner !== 'string') {
+            throw new SkapiError('"service_id" and "owner" should be type <string>.', { code: 'INVALID_PARAMETER' });
+        }
+        if (!service_id || !owner) {
+            throw new SkapiError('"service_id" and "owner" is required', { code: 'INVALID_PARAMETER' });
+        }
+        if (owner !== this.host) {
+            validator.UserId(owner, '"owner"');
+        }
+        this.service = service_id;
+        this.owner = owner;
+        let autoLogin = typeof options?.autoLogin === 'boolean' ? options.autoLogin : true;
+        const target_cdn = 'd1h765tqb4s5ov';
+        const cdn_domain = `https://${target_cdn}.cloudfront.net`;
+        let sreg = service_id.substring(0, 4);
+        this.admin_endpoint = fetch(`${cdn_domain}/${sreg}/admin.json`)
+            .then(response => response.blob())
+            .then(blob => new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onloadend = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
+        }))
+            .then(data => typeof data === 'string' ? JSON.parse(window.atob(data.split(',')[1])) : null);
+        this.record_endpoint = fetch(`${cdn_domain}/${sreg}/record.json`)
+            .then(response => response.blob())
+            .then(blob => new Promise((resolve, reject) => {
+            const reader = new FileReader();
+            reader.onloadend = () => resolve(reader.result);
+            reader.onerror = reject;
+            reader.readAsDataURL(blob);
+        }))
+            .then(data => typeof data === 'string' ? JSON.parse(window.atob(data.split(',')[1])) : null);
+        this.__connection = (async () => {
+            if (!window.sessionStorage) {
+                throw new Error(`This browser does not support skapi.`);
+            }
+            const restore = JSON.parse(window.sessionStorage.getItem(`${service_id}#${owner}`) || 'null');
+            if (restore?.connection) {
+                for (let k in restore) {
+                    this[k] = restore[k];
+                }
+            }
+            const admin_endpoint = await this.admin_endpoint;
+            setUserPool({
+                UserPoolId: admin_endpoint.userpool_id,
+                ClientId: admin_endpoint.userpool_client
+            });
+            const process = [];
+            if (!restore?.connection) {
+                process.push(this.updateConnection());
+            }
+            if (!restore?.connection && !autoLogin) {
+                let currentUser = userPool.getCurrentUser();
+                if (currentUser) {
+                    currentUser.signOut();
+                }
+            }
+            if (restore?.connection || autoLogin) {
+                process.push(authentication.bind(this)().getSession({ refreshToken: !restore?.connection }).catch(err => {
+                    this.__user = null;
+                }));
+                this.updateConnection();
+            }
+            let awaitProcess;
+            if (process.length) {
+                awaitProcess = await Promise.all(process);
+            }
+            const storeClassProperties = () => {
+                if (this.__class_properties_has_been_cached) {
+                    return;
+                }
+                let exec = () => {
+                    let data = {};
+                    const to_be_cached = [
+                        '__startKeyHistory',
+                        '__cached_requests',
+                        '__request_signup_confirmation',
+                        'connection',
+                    ];
+                    if (this.connection) {
+                        for (let k of to_be_cached) {
+                            data[k] = this[k];
+                        }
+                        window.sessionStorage.setItem(`${service_id}#${owner}`, JSON.stringify(data));
+                        this.__class_properties_has_been_cached = true;
+                    }
+                };
+                return (awaitProcess instanceof Promise) ? awaitProcess.then(() => exec()) : exec();
+            };
+            window.addEventListener('beforeunload', storeClassProperties);
+            window.addEventListener("visibilitychange", storeClassProperties);
+            return this.connection;
+        })();
+    }
+    async updateConnection() {
+        let skapi = `%c\r\n          $$\\                          $$\\ \r\n          $$ |                         \\__|\r\n $$$$$$$\\ $$ |  $$\\ $$$$$$\\   $$$$$$\\  $$\\ \r\n$$  _____|$$ | $$  |\\____$$\\ $$  __$$\\ $$ |\r\n\\$$$$$$\\  $$$$$$  \/ $$$$$$$ |$$ \/  $$ |$$ |\r\n \\____$$\\ $$  _$$< $$  __$$ |$$ |  $$ |$$ |\r\n$$$$$$$  |$$ | \\$$\\\\$$$$$$$ |$$$$$$$  |$$ |\r\n\\_______\/ \\__|  \\__|\\_______|$$  ____\/ \\__|\r\n                             $$ |          \r\n                             $$ |          \r\n                             \\__|          \r\n`;
+        this.connection = await request.bind(this)('service', {
+            service: this.service,
+            owner: this.owner
+        }, { bypassAwaitConnection: true, method: 'get' });
+        console.log(`Built with:\n${skapi}Version: ${this.version}\n\nDocumentation: https://docs.skapi.com`, `font-family: monospace; color:blue;`);
+        return this.connection;
+    }
+    uploadFiles(...args) { return uploadFiles.bind(this)(...args); }
+    mock(...args) { return mock.bind(this)(...args); }
+    login(...args) { return login.bind(this)(...args); }
+    logout(...args) { return logout.bind(this)(...args); }
+    signup(...args) { return signup.bind(this)(...args); }
+    resetPassword(...args) { return resetPassword.bind(this)(...args); }
+    verifyEmail(...args) { return verifyEmail.bind(this)(...args); }
+    verifyPhoneNumber(...args) { return verifyPhoneNumber.bind(this)(...args); }
+    forgotPassword(...args) { return forgotPassword.bind(this)(...args); }
+    changePassword(...args) { return changePassword.bind(this)(...args); }
+    updateProfile(...args) { return updateProfile.bind(this)(...args); }
+    postRecord(...args) { return postRecord.bind(this)(...args); }
+    subscribe(...args) { return subscribe.bind(this)(...args); }
+    unsubscribe(...args) { return unsubscribe.bind(this)(...args); }
+    blockSubscriber(...args) { return blockSubscriber.bind(this)(...args); }
+    unblockSubscriber(...args) { return unblockSubscriber.bind(this)(...args); }
+    subscribeNewsletter(...args) { return subscribeNewsletter.bind(this)(...args); }
+}
+__decorate([
+    formHandler()
+], Skapi.prototype, "uploadFiles", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "mock", null);
+__decorate([
+    formHandler({ preventMultipleCalls: true })
+], Skapi.prototype, "login", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "logout", null);
+__decorate([
+    formHandler({ preventMultipleCalls: true })
+], Skapi.prototype, "signup", null);
+__decorate([
+    formHandler({ preventMultipleCalls: true })
+], Skapi.prototype, "resetPassword", null);
+__decorate([
+    formHandler({ preventMultipleCalls: true })
+], Skapi.prototype, "verifyEmail", null);
+__decorate([
+    formHandler({ preventMultipleCalls: true })
+], Skapi.prototype, "verifyPhoneNumber", null);
+__decorate([
+    formHandler({ preventMultipleCalls: true })
+], Skapi.prototype, "forgotPassword", null);
+__decorate([
+    formHandler({ preventMultipleCalls: true })
+], Skapi.prototype, "changePassword", null);
+__decorate([
+    formHandler({ preventMultipleCalls: true })
+], Skapi.prototype, "updateProfile", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "postRecord", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "subscribe", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "unsubscribe", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "blockSubscriber", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "unblockSubscriber", null);
+__decorate([
+    formHandler()
+], Skapi.prototype, "subscribeNewsletter", null);