@mx-space/api-client 0.0.4 → 0.3.0

package/build/index.esm.js

@@ -360,55 +360,536 @@ var camelcaseKeys = (input, options) => {
 
 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) {
@@ -419,8 +900,10 @@ class RequestError extends Error {
     }
 }
 
-class HTTPClient {
+class HTTPClient extends HTTPControllerDefine {
+    // define all clients
     constructor(_endpoint, _instance) {
+        super();
         this._endpoint = _endpoint;
         this._instance = _instance;
         this._endpoint = _endpoint
@@ -431,7 +914,7 @@ class HTTPClient {
         attachRequestMethod(this);
     }
     initGetClient() {
-        const clientsName = allClientName;
+        const clientsName = allContollerNames;
         for (const name of clientsName) {
             Object.defineProperty(this, name, {
                 get() {
@@ -446,9 +929,9 @@ class HTTPClient {
             });
         }
     }
-    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() {
@@ -466,7 +949,7 @@ class HTTPClient {
         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;
@@ -529,6 +1012,17 @@ class HTTPClient {
                                 enumerable: false,
                                 configurable: false,
                             });
+                            // attach request config onto response
+                            Object.defineProperty(transform, 'request', {
+                                get() {
+                                    return {
+                                        url,
+                                        method: name,
+                                        options,
+                                    };
+                                },
+                                enumerable: false,
+                            });
                             return transform;
                         };
                     }
@@ -546,11 +1040,10 @@ class HTTPClient {
     }
 }
 function createClient(adapter) {
-    // TODO: add support other network lib
     return (endpoint) => {
         return new HTTPClient(endpoint, adapter);
     };
 }
 
-export { HTTPClient, NoteClient, PostClient, RequestError, allClientName, allClients, createClient };
+export { HTTPClient, NoteController as NoteClient, PostController as PostClient, RequestError, allContollerNames as allClientName, allControllers as allClients, createClient };
 //# sourceMappingURL=index.esm.js.map