@mx-space/api-client 0.0.4 → 0.3.0

package/build/index.umd.js

@@ -366,55 +366,536 @@
 
 	const isPlainObject = (obj) => typeof obj === 'object' &&
 	    Object.prototype.toString.call(obj) === '[object Object]';
+	const sortOrderToNumber = (order) => {
+	    return ({
+	        asc: 1,
+	        desc: -1,
+	    }[order] || 1);
+	};
+	const destructureData = (payload) => {
+	    if (typeof payload !== 'object') {
+	        return payload;
+	    }
+	    if (payload === null) {
+	        return payload;
+	    }
+	    const data = payload.data;
+	    const dataIsPlainObject = Object.prototype.toString.call(data) === '[object Object]';
+	    if (dataIsPlainObject && Object.keys(payload).length === 1) {
+	        const d = Object.assign({}, data);
+	        // attach raw onto new data
+	        attachRawFromOneToAnthor(payload, d);
+	        return d;
+	    }
+	    return payload;
+	};
+	const attachRawFromOneToAnthor = (from, to) => {
+	    if (!from) {
+	        return;
+	    }
+	    from.raw &&
+	        Object.defineProperty(to, 'raw', {
+	            value: Object.assign({}, from.raw),
+	            enumerable: false,
+	        });
+	    from.request &&
+	        Object.defineProperty(to, 'request', {
+	            value: Object.assign({}, from.request),
+	            enumerable: false,
+	        });
+	};
 
 	function attachRequestMethod(target) {
-	    const resolveFullPath = target.resolveFullPath;
-	    Object.defineProperty(target, 'get', {
-	        value: function (path, params) {
-	            return target.instance.get(resolveFullPath(path), {
-	                params,
-	            });
+	    Object.defineProperty(target, '$$get', {
+	        value: function (url, options) {
+	            // HINT: method get only accept search params;
+	            const { params = {} } = options;
+	            const qs = handleSearchParams(params);
+	            return target.instance.get(url + `${qs ? `${'?' + qs}` : ''}`);
 	        },
 	    });
+	    Object.defineProperty(target, '$$post', {
+	        value: function (path, options) {
+	            return target.instance.post(path, options);
+	        },
+	    });
+	}
+	// FIXME: only support string value
+	function handleSearchParams(obj) {
+	    if (!obj && typeof obj !== 'object') {
+	        throw new TypeError('params must be object.');
+	    }
+	    if (obj instanceof URLSearchParams) {
+	        return obj.toString();
+	    }
+	    const search = new URLSearchParams();
+	    Object.entries(obj).forEach(([k, v]) => {
+	        if (typeof v === 'undefined' ||
+	            Object.prototype.toString.call(v) === '[object Null]') {
+	            return;
+	        }
+	        search.set(k, v);
+	    });
+	    return search.toString();
+	}
+
+	class AggregateController {
+	    constructor(client) {
+	        this.client = client;
+	        this.base = 'aggregate';
+	        this.name = 'aggregate';
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    /**
+	     * 获取聚合数据
+	     */
+	    getAggregateData() {
+	        return this.proxy.get();
+	    }
+	    /**
+	     * 获取最新发布的内容
+	     */
+	    getTop(size = 5) {
+	        return this.proxy.top.get({ params: { size } });
+	    }
+	    getTimeline(options) {
+	        const { sort, type, year } = options || {};
+	        return this.proxy.timeline.get({
+	            params: {
+	                sort: sort && sortOrderToNumber(sort),
+	                type,
+	                year,
+	            },
+	        });
+	    }
+	    /**
+	     * 获取聚合数据统计
+	     */
+	    getStat() {
+	        return this.proxy.stat.get();
+	    }
+	}
+
+	var CategoryType;
+	(function (CategoryType) {
+	    CategoryType[CategoryType["Category"] = 0] = "Category";
+	    CategoryType[CategoryType["Tag"] = 1] = "Tag";
+	})(CategoryType || (CategoryType = {}));
+
+	class CategoryController {
+	    constructor(client) {
+	        this.client = client;
+	        this.name = 'category';
+	        this.base = 'categories';
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    getAllCategories() {
+	        return this.proxy.get({
+	            params: {
+	                type: CategoryType.Category,
+	            },
+	        });
+	    }
+	    getAllTags() {
+	        return this.proxy.get({
+	            params: {
+	                type: CategoryType.Tag,
+	            },
+	        });
+	    }
+	    async getCategoryDetail(ids) {
+	        if (typeof ids === 'string') {
+	            const data = await this.proxy.get({
+	                params: {
+	                    ids: ids,
+	                },
+	            });
+	            const result = Object.values(data.entries)[0];
+	            attachRawFromOneToAnthor(data, result);
+	            return result;
+	        }
+	        else if (Array.isArray(ids)) {
+	            const data = await this.proxy.get({
+	                params: {
+	                    ids: ids.join(','),
+	                },
+	            });
+	            const entries = data === null || data === void 0 ? void 0 : data.entries;
+	            if (!entries) {
+	                throw new RequestError('data structure error', 500, data.request.path, data);
+	            }
+	            const map = new Map(Object.entries(entries).map(([id, value]) => [id.toLowerCase(), value]));
+	            attachRawFromOneToAnthor(data, map);
+	            return map;
+	        }
+	    }
+	    async getCategoryByIdOrSlug(idOrSlug) {
+	        const res = await this.proxy(idOrSlug).get();
+	        return destructureData(res);
+	    }
+	    async getTagByName(name) {
+	        const res = await this.proxy(name).get({
+	            params: {
+	                tag: 1,
+	            },
+	        });
+	        return res;
+	    }
+	}
+
+	class CommentController {
+	    constructor(client) {
+	        this.client = client;
+	        this.base = 'comments';
+	        this.name = 'comment';
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    /**
+	     * 根据 comment id 获取评论, 包括子评论
+	     */
+	    getById(id) {
+	        return this.proxy(id).get();
+	    }
+	    /**
+	     * 获取文章的评论列表
+	     * @param refId 文章 Id
+	     */
+	    getByRefId(refId, pagination = {}) {
+	        const { page, size } = pagination;
+	        return this.proxy.ref(refId).get({
+	            params: { page: page || 1, size: size || 10 },
+	        });
+	    }
+	    /**
+	     * 评论
+	     */
+	    comment(refId, data) {
+	        return this.proxy(refId).post({
+	            data,
+	        });
+	    }
+	    /**
+	     * 回复评论
+	     */
+	    reply(commentId, data) {
+	        return this.proxy.reply(commentId).post({
+	            data,
+	        });
+	    }
+	}
+
+	class BaseCrudController {
+	    constructor(client) {
+	        this.client = client;
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    getById(id) {
+	        return this.proxy(id).get();
+	    }
+	    getAll() {
+	        return this.proxy.all.get();
+	    }
+	    /**
+	     * 带分页的查询
+	     * @param page
+	     * @param perPage
+	     */
+	    getAllPaginated(page, perPage) {
+	        return this.proxy.get({
+	            params: { page, size: perPage },
+	        });
+	    }
+	}
+
+	class LinkController extends BaseCrudController {
+	    constructor(client) {
+	        super(client);
+	        this.client = client;
+	        this.name = 'link';
+	        this.base = 'links';
+	    }
 	}
 
-	class NoteClient {
-	    constructor() {
+	class NoteController {
+	    constructor(client) {
+	        this.client = client;
 	        this.base = 'notes';
 	        this.name = 'note';
 	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    /**
+	     * 最新日记
+	     */
+	    getLatest() {
+	        return this.proxy.latest.get();
+	    }
+	    /**
+	     * 获取一篇日记
+	     * @param id id | nid
+	     * @param password 访问密码
+	     */
+	    getNoteById(id, password) {
+	        if (typeof id === 'number') {
+	            return this.proxy.nid(id.toString()).get({
+	                params: { password },
+	            });
+	        }
+	        else {
+	            return this.proxy(id).get({ params: { password } });
+	        }
+	    }
+	    /**
+	     * 日记列表分页
+	     */
+	    getList(page = 1, perPage = 10) {
+	        return this.proxy.get({
+	            params: { page, size: perPage },
+	        });
+	    }
+	    /**
+	     * 获取当前日记的上下各 n / 2 篇日记
+	     */
+	    getMiddleList(id, size = 5) {
+	        return this.proxy.list(id).get({
+	            params: { size },
+	        });
+	    }
+	    /**
+	     * 喜欢这篇日记
+	     */
+	    likeIt(id) {
+	        return this.proxy.like(id).get();
+	    }
 	}
 
-	class PostClient {
+	class PageController {
+	    constructor(client) {
+	        this.client = client;
+	        this.base = 'pages';
+	        this.name = 'page';
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    /**
+	     * 页面列表
+	     */
+	    getList(page = 1, perPage = 10) {
+	        return this.proxy.get({
+	            params: { page, size: perPage },
+	        });
+	    }
+	    /**
+	     * 页面详情
+	     */
+	    getById(id) {
+	        return this.proxy(id).get();
+	    }
+	    /**
+	     * 根据路径获取页面
+	     * @param slug 路径
+	     * @returns
+	     */
+	    getBySlug(slug) {
+	        return this.proxy.slug(slug).get({});
+	    }
+	}
+
+	class PostController {
 	    constructor(client) {
 	        this.client = client;
 	        this.base = 'posts';
 	        this.name = 'post';
 	    }
-	    getPosts(page = 1, perPage = 10) {
-	        return this.client.proxy(this.base).get({
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    /**
+	     * 获取文章列表分页
+	     * @param page
+	     * @param perPage
+	     * @returns
+	     */
+	    getList(page = 1, perPage = 10) {
+	        return this.proxy.get({
 	            params: { page, size: perPage },
 	        });
 	    }
 	    getPost(idOrCategoryName, slug) {
 	        if (arguments.length == 1) {
-	            return this.client.proxy(this.base)(idOrCategoryName).get();
+	            return this.proxy(idOrCategoryName).get();
 	        }
 	        else {
-	            return this.client
-	                .proxy(this.base)(idOrCategoryName)(slug)
-	                .get();
+	            return this.proxy(idOrCategoryName)(slug).get();
+	        }
+	    }
+	    /**
+	     * 获取最新的文章
+	     */
+	    getLatest() {
+	        return this.proxy.latest.get();
+	    }
+	    /**
+	     * 点赞
+	     */
+	    thumbsUp(id) {
+	        return this.proxy('_thumbs-up').get({ params: { id } });
+	    }
+	}
+
+	class RecentlyController {
+	    constructor(client) {
+	        this.client = client;
+	        this.base = 'recently';
+	        this.name = 'recently';
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    /**
+	     * 获取最新一条
+	     */
+	    getLatestOne() {
+	        return this.proxy.latest.get();
+	    }
+	    getAll() {
+	        return this.proxy.all.get();
+	    }
+	    getList(before, after, size) {
+	        if (!before && !after) {
+	            throw new Error('you can only choose `before` or `after`');
 	        }
+	        return this.proxy.get({
+	            params: {
+	                before,
+	                after,
+	                size,
+	            },
+	        });
 	    }
 	}
 
-	const allClients = [NoteClient, PostClient];
-	// export const allClientName = allClients.map((c) =>
-	//   c.name.replace('Client', '').toLowerCase(),
-	// )
-	// Why not code like before
-	// In order to tree shake unnecessary client
-	const allClientName = ['note', 'post'];
+	class SayController extends BaseCrudController {
+	    constructor(client) {
+	        super(client);
+	        this.client = client;
+	        this.base = 'says';
+	        this.name = 'say';
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    /**
+	     * 获取随机一条
+	     */
+	    getRandom() {
+	        return this.proxy.random.get();
+	    }
+	}
+
+	class SearchController {
+	    constructor(client) {
+	        this.client = client;
+	        this.base = 'search';
+	        this.name = 'search';
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    search(type, keyword, options = {}) {
+	        return this.proxy(type).get({
+	            params: Object.assign({ keyword }, options),
+	        });
+	    }
+	    /**
+	     * 从 algolya 搜索
+	     * https://www.algolia.com/doc/api-reference/api-methods/search/
+	     * @param keyword
+	     * @param options
+	     * @returns
+	     */
+	    searchByAlgolia(keyword, options) {
+	        return this.proxy('algolia').get({ params: Object.assign({ keyword }, options) });
+	    }
+	}
+
+	class UserController {
+	    constructor(client) {
+	        this.client = client;
+	        this.base = 'master';
+	        this.name = 'user';
+	    }
+	    get proxy() {
+	        return this.client.proxy(this.base);
+	    }
+	    getMasterInfo() {
+	        return this.proxy.get();
+	    }
+	    login(username, password) {
+	        return this.proxy.login.post({
+	            data: {
+	                username,
+	                password,
+	            },
+	        });
+	    }
+	    checkTokenValid(token) {
+	        return this.proxy.check_logged.get({
+	            params: {
+	                token,
+	            },
+	        });
+	    }
+	}
+
+	const allControllers = [
+	    AggregateController,
+	    CategoryController,
+	    CommentController,
+	    LinkController,
+	    NoteController,
+	    PageController,
+	    PostController,
+	    RecentlyController,
+	    SayController,
+	    SearchController,
+	    UserController,
+	];
+	const allContollerNames = [
+	    'aggregate',
+	    'category',
+	    'comment',
+	    'link',
+	    'note',
+	    'page',
+	    'post',
+	    'recently',
+	    'say',
+	    'search',
+	    'user',
+	];
+
+	class HTTPControllerDefine {
+	    get master() {
+	        return this.user;
+	    }
+	    get friend() {
+	        return this.link;
+	    }
+	    get shorthand() {
+	        return this.recently;
+	    }
+	}
 
 	class RequestError extends Error {
 	    constructor(message, status, path, raw) {
@@ -425,8 +906,10 @@
 	    }
 	}
 
-	class HTTPClient {
+	class HTTPClient extends HTTPControllerDefine {
+	    // define all clients
 	    constructor(_endpoint, _instance) {
+	        super();
 	        this._endpoint = _endpoint;
 	        this._instance = _instance;
 	        this._endpoint = _endpoint
@@ -437,7 +920,7 @@
 	        attachRequestMethod(this);
 	    }
 	    initGetClient() {
-	        const clientsName = allClientName;
+	        const clientsName = allContollerNames;
 	        for (const name of clientsName) {
 	            Object.defineProperty(this, name, {
 	                get() {
@@ -452,9 +935,9 @@
 	            });
 	        }
 	    }
-	    injectClients(Clients, ...rest) {
-	        Clients = Array.isArray(Clients) ? Clients : [Clients, ...rest];
-	        for (const Client of Clients) {
+	    injectControllers(Controller, ...rest) {
+	        Controller = Array.isArray(Controller) ? Controller : [Controller, ...rest];
+	        for (const Client of Controller) {
 	            const cl = new Client(this);
 	            Object.defineProperty(this, `_${cl.name.toLowerCase()}`, {
 	                get() {
@@ -472,7 +955,7 @@
 	        return this._instance;
 	    }
 	    request(options) {
-	        return this._instance[String(options.method || 'get').toLowerCase()](options.url, options);
+	        return this['$$' + String(options.method || 'get').toLowerCase()](options.url, options);
 	    }
 	    get proxy() {
 	        return this._proxy;
@@ -535,6 +1018,17 @@
 	                                enumerable: false,
 	                                configurable: false,
 	                            });
+	                            // attach request config onto response
+	                            Object.defineProperty(transform, 'request', {
+	                                get() {
+	                                    return {
+	                                        url,
+	                                        method: name,
+	                                        options,
+	                                    };
+	                                },
+	                                enumerable: false,
+	                            });
 	                            return transform;
 	                        };
 	                    }
@@ -552,18 +1046,17 @@
 	    }
 	}
 	function createClient(adapter) {
-	    // TODO: add support other network lib
 	    return (endpoint) => {
 	        return new HTTPClient(endpoint, adapter);
 	    };
 	}
 
 	exports.HTTPClient = HTTPClient;
-	exports.NoteClient = NoteClient;
-	exports.PostClient = PostClient;
+	exports.NoteClient = NoteController;
+	exports.PostClient = PostController;
 	exports.RequestError = RequestError;
-	exports.allClientName = allClientName;
-	exports.allClients = allClients;
+	exports.allClientName = allContollerNames;
+	exports.allClients = allControllers;
 	exports.createClient = createClient;
 
 	Object.defineProperty(exports, '__esModule', { value: true });