skapi-js 0.2.0 → 0.2.2

package/js/methods/subscription.d.ts

@@ -0,0 +1,46 @@
+import { DatabaseResponse, FetchOptions, FormSubmitCallback, Form, Newsletters, SubscriptionGroup } from '../Types';
+export declare function getSubscriptions(params: {
+    subscriber?: string;
+    subscription?: string;
+    group?: number;
+    blocked?: boolean;
+}, fetchOptions?: FetchOptions, _mapper?: Function): Promise<DatabaseResponse<{
+    subscriber: string;
+    subscription: string;
+    group: number;
+    timestamp: number;
+    blocked: boolean;
+}>>;
+export declare function subscribe(option: SubscriptionGroup<number>): Promise<'SUCCESS: the user has subscribed.'>;
+export declare function unsubscribe(option: SubscriptionGroup<number | '*'>): Promise<'SUCCESS: the user has unsubscribed.'>;
+export declare function blockSubscriber(option: SubscriptionGroup<number | '*'>): Promise<'SUCCESS: blocked user id "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".'>;
+export declare function unblockSubscriber(option: SubscriptionGroup<number | '*'>): Promise<'SUCCESS: unblocked user id "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx".'>;
+export declare function getSubscribedTo(option: SubscriptionGroup<number | undefined> & {
+    blocked?: boolean;
+}, fetchOptions: FetchOptions): Promise<DatabaseResponse<any>>;
+export declare function getSubscribers(option: SubscriptionGroup<number | undefined> & {
+    blocked?: boolean;
+}, fetchOptions: FetchOptions): Promise<DatabaseResponse<any>>;
+export declare function getNewsletterSubscription(params: {
+    group?: number;
+}): Promise<{
+    active: boolean;
+    timestamp: number;
+    group: number;
+    subscribed_email: string;
+}[]>;
+export declare function subscribeNewsletter(form: Form<{
+    email?: string;
+    group: number | 'public' | 'authorized';
+    redirect?: string;
+}>, callbacks: FormSubmitCallback): Promise<string>;
+export declare function unsubscribeNewsletter(params: {
+    group: number | 'public' | 'authorized' | null;
+}): Promise<string>;
+export declare function getNewsletters(params?: {
+    searchFor: 'message_id' | 'timestamp' | 'read' | 'complaint' | 'subject';
+    value: string | number;
+    range: string | number;
+    condition?: '>' | '>=' | '=' | '<' | '<=' | 'gt' | 'gte' | 'eq' | 'lt' | 'lte';
+    group: 'public' | 'authorized' | number;
+}, fetchOptions?: FetchOptions): Promise<Newsletters>;

package/js/methods/subscription.js

@@ -0,0 +1,240 @@
+import SkapiError from '../main/error';
+import validator from '../utils/validator';
+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']);
+    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' });
+    }
+    return 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' });
+    }
+    let response = await request.bind(this)('get-subscription', params, Object.assign({ auth: true }, { fetchOptions }));
+    response.list = response.list.map(_mapper || ((s) => {
+        let subscription = {};
+        let subSplit = s.sub.split('#');
+        subscription.subscriber = subSplit[2];
+        subscription.subscription = subSplit[0];
+        subscription.group = parseInt(subSplit[1]);
+        subscription.timestamp = s.stmp;
+        subscription.blocked = s.grp.substring(0, 1) === 'N';
+        return subscription;
+    }));
+    return response;
+}
+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' });
+    }
+    return await request.bind(this)('subscription', {
+        subscribe: user_id,
+        group
+    }, { auth: true });
+}
+export async function unsubscribe(option) {
+    await this.__connection;
+    let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
+    return await request.bind(this)('subscription', {
+        unsubscribe: user_id,
+        group
+    }, { 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 });
+}
+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 });
+}
+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,
+        blocked: option.blocked
+    }, fetchOptions);
+}
+;
+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,
+        blocked: option.blocked
+    };
+    return getSubscriptions.bind(this)(subParams, fetchOptions);
+}
+;
+export async function getNewsletterSubscription(params) {
+    await this.__connection;
+    let isAdmin = await this.checkAdmin();
+    params = validator.Params(params, {
+        user_id: v => {
+            if (v !== this.__user.user_id && !isAdmin) {
+                throw new SkapiError(`No access.`, { code: 'INVALID_REQUEST' });
+            }
+            return v;
+        },
+        group: 'number'
+    });
+    let list = await request.bind(this)('get-newsletter-subscription', params, { auth: true });
+    let result = [];
+    for (let sub of list) {
+        let subt = sub['subt'].split('#');
+        let active = true;
+        if (subt[0].charAt(0) === '@') {
+            active = false;
+            subt[0] = subt[0].substring(1);
+        }
+        let group = parseInt(subt[0]);
+        result.push({
+            timestamp: sub['stmp'],
+            group,
+            subscribed_email: subt[1],
+            active
+        });
+    }
+    return result;
+}
+export async function subscribeNewsletter(form, callbacks) {
+    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 });
+}
+export async function unsubscribeNewsletter(params) {
+    await this.__connection;
+    params = validator.Params(params, {
+        group: ['number', 'public', 'authorized']
+    }, ['group']);
+    let param_send = Object.assign({
+        action: 'unsubscribe'
+    }, params);
+    return request.bind(this)('subscribe-newsletter', param_send, { auth: true });
+}
+export async function getNewsletters(params, fetchOptions) {
+    let isAdmin = await this.checkAdmin();
+    let searchType = {
+        'message_id': 'string',
+        'timestamp': 'number',
+        'read': 'number',
+        'complaint': 'number',
+        'subject': 'string'
+    };
+    if (!params) {
+        if (!fetchOptions) {
+            fetchOptions = {};
+        }
+        fetchOptions.ascending = false;
+    }
+    let _params = params || {
+        searchFor: 'timestamp',
+        value: 0,
+        condition: '>'
+    };
+    params = validator.Params(_params, {
+        searchFor: ['message_id', 'timestamp', 'read', 'complaint', 'group', 'subject'],
+        value: (v) => {
+            if (typeof v !== searchType[_params.searchFor]) {
+                throw new SkapiError(`"value" type does not match the type of "${_params.searchFor}" index.`, { code: 'INVALID_PARAMETER' });
+            }
+            else if (typeof v === 'string' && !v) {
+                throw new SkapiError('"value" should not be empty string.', { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        },
+        range: (v) => {
+            if (!_params.hasOwnProperty('value') || typeof v !== typeof _params.value) {
+                throw new SkapiError('"range" should match type of "value".', { code: 'INVALID_PARAMETER' });
+            }
+            return v;
+        },
+        condition: ['>', '>=', '=', '<', '<=', 'gt', 'gte', 'eq', 'lt', 'lte', () => '='],
+        group: (x) => {
+            if (!this.session) {
+                throw new SkapiError('User should be logged in.', { code: 'INVALID_REQUEST' });
+            }
+            if (x === 'public') {
+                return 0;
+            }
+            else if (x === 'authorized') {
+                return 1;
+            }
+            else if (typeof x === 'number') {
+                if (!isAdmin && x > parseInt(this.session.idToken.payload.access_group)) {
+                    throw new SkapiError('User has no access.', { code: 'INVALID_REQUEST' });
+                }
+            }
+            return x;
+        }
+    }, ['searchFor', 'value', 'group']);
+    let mails = await request.bind(this)(params.group === 0 ? 'get-public-newsletters' : 'get-newsletters', params, Object.assign({ method: 'get', auth: params.group !== 0 }, { fetchOptions }));
+    let remap = {
+        'message_id': 'mid',
+        'timestamp': 'stmp',
+        'complaint': 'cmpl',
+        'read': 'read',
+        'subject': 'subj',
+        'bounced': 'bnce',
+        'url': 'url'
+    };
+    let defaults = {
+        'message_id': '',
+        'timestamp': 0,
+        'complaint': 0,
+        'read': 0,
+        'subject': '',
+        'bounced': 0,
+        'url': ''
+    };
+    mails.list = mails.list.map(m => {
+        let remapped = {};
+        for (let k in remap) {
+            remapped[k] = m[remap[k]] || defaults[remap[k]];
+        }
+        return remapped;
+    });
+    return mails;
+}

package/js/methods/user.d.ts

@@ -0,0 +1,67 @@
+import { CognitoUser, CognitoUserSession, CognitoUserPool } from 'amazon-cognito-identity-js';
+import { User, Form, FormSubmitCallback, UserProfile, FetchOptions, DatabaseResponse, QueryParams, UserAttributes } from '../Types';
+export declare let userPool: CognitoUserPool | null;
+export declare function setUserPool(params: {
+    UserPoolId: string;
+    ClientId: string;
+}): void;
+export declare function authentication(): {
+    getSession: (option?: {
+        refreshToken?: boolean;
+    }) => Promise<CognitoUserSession>;
+    authenticateUser: (email: string, password: string) => Promise<User>;
+    createCognitoUser: (email: string) => Promise<{
+        cognitoUser: CognitoUser;
+        cognitoUsername: string;
+    }>;
+    getUser: () => Promise<UserProfile | null>;
+};
+export declare function getProfile(options?: {
+    refreshToken: boolean;
+}): Promise<User | null>;
+export declare function checkAdmin(): Promise<boolean>;
+export declare function logout(e: SubmitEvent): 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<{
+    email: string;
+    password: string;
+}>, option?: FormSubmitCallback & {
+    logout: boolean;
+}): Promise<User>;
+export declare function signup(form: Form<UserAttributes & {
+    email: String;
+    password: String;
+}>, option?: {
+    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.'>;
+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<{
+    code: string;
+}>): Promise<'SUCCESS: Verification code has been sent.' | 'SUCCESS: "phone_number" is verified.'>;
+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.">;
+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>>;
+export declare function lastVerifiedEmail(params?: {
+    revert: boolean;
+}): Promise<string | UserProfile>;
+export declare function requestUsernameChange(params: {
+    redirect?: string;
+    username: string;
+}): Promise<'SUCCESS: ...'>;