skapi-js 0.1.124 → 0.2.0-alpha.0

package/esm/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/esm/methods/subscription.js

@@ -0,0 +1,273 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+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 function getSubscriptions(params, fetchOptions, _mapper) {
+    return __awaiter(this, void 0, void 0, function* () {
+        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 = yield 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 function subscribe(option) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield 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 yield request.bind(this)('subscription', {
+            subscribe: user_id,
+            group
+        }, { auth: true });
+    });
+}
+export function unsubscribe(option) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield this.__connection;
+        let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
+        return yield request.bind(this)('subscription', {
+            unsubscribe: user_id,
+            group
+        }, { auth: true });
+    });
+}
+export function blockSubscriber(option) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield this.__connection;
+        let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
+        return yield request.bind(this)('subscription', { block: user_id, group }, { auth: true });
+    });
+}
+export function unblockSubscriber(option) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield this.__connection;
+        let { user_id, group } = subscriptionGroupCheck.bind(this)(option);
+        return yield request.bind(this)('subscription', { unblock: user_id, group }, { auth: true });
+    });
+}
+export function getSubscribedTo(option, fetchOptions) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        yield 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 || ((_a = this.__user) === null || _a === void 0 ? void 0 : _a.user_id),
+            group: option.group,
+            blocked: option.blocked
+        }, fetchOptions);
+    });
+}
+;
+export function getSubscribers(option, fetchOptions) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+        yield this.__connection;
+        option = validator.Params(option, {
+            user_id: (v) => validator.UserId(v, '"user_id"'),
+            group: 'number',
+            blocked: 'boolean'
+        }) || {};
+        let subParams = {
+            subscription: option.user_id || ((_a = this.__user) === null || _a === void 0 ? void 0 : _a.user_id),
+            group: option.group,
+            blocked: option.blocked
+        };
+        return getSubscriptions.bind(this)(subParams, fetchOptions);
+    });
+}
+;
+export function getNewsletterSubscription(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield this.__connection;
+        let isAdmin = yield 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 = yield 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 function subscribeNewsletter(form, callbacks) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield 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 function unsubscribeNewsletter(params) {
+    return __awaiter(this, void 0, void 0, function* () {
+        yield 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 function getNewsletters(params, fetchOptions) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let isAdmin = yield 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 = yield 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/esm/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: ...'>;