strapi-plugin-comments 2.0.10 → 2.1.0-beta.1

package/server/controllers/admin.js

@@ -1,168 +1,135 @@
-'use strict';
-
-const { getPluginService } = require('./../utils/functions');
-const { parseParams, throwError } = require('./utils/functions');
-const _ = require('lodash');
-
-module.exports = {
-
-  getService(name = 'admin') {
-    return getPluginService(name);
-  },
-
-  async config(ctx) {
-    try {
-      return await this.getService().config();
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async settingsConfig(ctx) {
-    try {
-      return this.getService().config(true);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async settingsUpdateConfig(ctx) {
-    try {
-      const { request: { body } } = ctx;
-      return this.getService().updateConfig(body);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async settingsRestoreConfig(ctx) {
-    try {
-      return this.getService().restoreConfig();
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async settingsRestart(ctx) {
-    try {
-      await this.getService().restart();
-      return ctx.send({ status: 200 });
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async findAll(ctx) {
-    return this.getService()
-      .findAll(ctx.query);
-  },
-
-  async findOne(ctx) {
-    const { params = {}, query } = ctx;
-    const { id } = parseParams(params);
-    try {
-      return await this.getService()
-        .findOneAndThread(id, query);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async blockComment(ctx) {
-    const { params = {} } = ctx;
-    const { id } = parseParams(params);
-    try {
-      return await this.getService()
-        .blockComment(id, true);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async unblockComment(ctx) {
-    const { params = {} } = ctx;
-    const { id } = parseParams(params);
-    try {
-      return await this.getService()
-        .blockComment(id, false);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async blockCommentThread(ctx) {
-    const { params = {} } = ctx;
-    const { id } = parseParams(params);
-    try {
-      return await this.getService()
-        .blockCommentThread(id, true);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async unblockCommentThread(ctx) {
-    const { params = {} } = ctx;
-    const { id } = parseParams(params);
-    try {
-      return await this.getService()
-        .blockCommentThread(id, false);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async resolveAbuseReport(ctx) {
-    const { params = {} } = ctx;
-    const { id: commentId, reportId } = parseParams(params);
-    try {
-      return await this.getService()
-        .resolveAbuseReport(reportId, commentId);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async approveComment(ctx) {
-    const { id } = parseParams(ctx.params || {});
-    try {
-      return await this.getService()
-        .approveComment(id);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async rejectComment(ctx) {
-    const { id } = parseParams(ctx.params || {});
-    try {
-      return await this.getService()
-        .rejectComment(id);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  getContentsTypes() {
-    return Object.entries(strapi.contentTypes)
-      .filter(([, contentType]) => (
-        contentType.associations || []).some(_ => _.plugin === 'comments' && _.collection === 'comment'),
-      )
-      .reduce((acc, [, contentType]) => [
-          ...acc,
-          { key: contentType.globalName, value: contentType.collectionName }],
-        [],
-      );
-  },
-
-  async contentTypeName(ctx) {
-    const { params: { contentTypeName } } = ctx;
-    try {
-      const result = await this.getService()
-        .contentTypeName(contentTypeName);
-      return { list: result };
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const functions_1 = require("./../utils/functions");
+const functions_2 = require("./utils/functions");
+const controllers = {
+    getService(name = "admin") {
+        return (0, functions_1.getPluginService)(name);
+    },
+    async config(ctx) {
+        try {
+            return await this.getService().config();
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async settingsConfig(ctx) {
+        try {
+            return this.getService().config(true);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async settingsUpdateConfig(ctx) {
+        try {
+            const { request: { body }, } = ctx;
+            (0, functions_1.assertNotEmpty)(body);
+            return this.getService().updateConfig(body);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async settingsRestoreConfig(ctx) {
+        try {
+            return this.getService().restoreConfig();
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async settingsRestart(ctx) {
+        try {
+            await this.getService().restart();
+            return ctx.send({ status: 200 });
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async findAll(ctx) {
+        return this.getService().findAll(ctx.query);
+    },
+    async findOne(ctx) {
+        const { params = {}, query } = ctx;
+        const { id } = (0, functions_2.parseParams)(params);
+        try {
+            return await this.getService().findOneAndThread(id, query);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async blockComment(ctx) {
+        const { params = {} } = ctx;
+        const { id } = (0, functions_2.parseParams)(params);
+        try {
+            return await this.getService().blockComment(id, true);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async unblockComment(ctx) {
+        const { params = {} } = ctx;
+        const { id } = (0, functions_2.parseParams)(params);
+        try {
+            return await this.getService().blockComment(id, false);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async blockCommentThread(ctx) {
+        const { params = {} } = ctx;
+        const { id } = (0, functions_2.parseParams)(params);
+        try {
+            return await this.getService().blockCommentThread(id, true);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async unblockCommentThread(ctx) {
+        const { params = {} } = ctx;
+        const { id } = (0, functions_2.parseParams)(params);
+        try {
+            return await this.getService().blockCommentThread(id, false);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async resolveAbuseReport(ctx) {
+        const { params = {} } = ctx;
+        const { id: commentId, reportId } = (0, functions_2.parseParams)(params);
+        try {
+            return await this.getService().resolveAbuseReport(reportId, commentId);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async approveComment(ctx) {
+        const { id } = (0, functions_2.parseParams)(ctx.params || {});
+        try {
+            return await this.getService().approveComment(id);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async rejectComment(ctx) {
+        const { id } = (0, functions_2.parseParams)(ctx.params || {});
+        try {
+            return await this.getService().rejectComment(id);
+        }
+        catch (e) {
+            throw (0, functions_2.throwError)(ctx, e);
+        }
+    },
 };
+exports.default = controllers;
+//# sourceMappingURL=admin.js.map

package/server/controllers/client.d.ts

@@ -0,0 +1,4 @@
+import { ToBeFixed } from "../../types";
+declare const controllers: ToBeFixed;
+export default controllers;
+//# sourceMappingURL=client.d.ts.map

package/server/controllers/client.js

@@ -1,114 +1,106 @@
-'use strict';
-
-const { getPluginService } = require('./../utils/functions');
-const { parseParams, throwError } = require('./utils/functions');
-const { flatInput } = require('./utils/parsers');
-
-module.exports = {
-
-  getService(name = 'client') {
-    return getPluginService(name);
-  },
-
-  async findAllFlat(ctx) {
-    const { params = {}, query, sort, pagination } = ctx;
-    const { relation } = parseParams(params);
-
-    const { sort: querySort, pagination: queryPagination, ...filterQuery } = query || {};
-
-    try {
-      return this.getService('common')
-        .findAllFlat(flatInput(relation, filterQuery, sort || querySort, pagination || queryPagination));
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async findAllInHierarchy(ctx) {
-    const { params = {}, query, sort } = ctx;
-    const { relation } = parseParams(params);
-
-    const { sort: querySort, ...filterQuery } = query || {};
-
-    try {
-      return await this.getService('common')
-        .findAllInHierarchy({
-          ...flatInput(relation, filterQuery, sort || querySort),
-          dropBlockedThreads: true,
-        });
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async post(ctx) {
-    const { request, params = {}, state = {} } = ctx;
-    const { relation } = parseParams(params);
-    const { user } = state;
-    const { body = {} } = request;
-    try {
-      const entity = await this.getService()
-        .create(relation, body, user);
-
-      if (entity) {
-        return entity;
-      }
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async put(ctx) {
-    const { request, state, params = {} } = ctx;
-    const { body = {} } = request;
-    const { user } = state;
-    const { commentId, relation } = parseParams(params);
-    try {
-      return await this.getService()
-        .update(commentId, relation, body, user);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async reportAbuse(ctx) {
-    const { request, state, params = {} } = ctx;
-    const { body = {} } = request;
-    if (!body.content) {
-      return ctx.badRequest(null, 'Content field is required');
-    }
-    const { user } = state;
-    const { relation, commentId } = parseParams(params);
-    try {
-      return await this.getService()
-        .reportAbuse(commentId, relation, body, user);
-    } catch (e) {
-      throwError(ctx, e);
-    }
-  },
-
-  async removeComment(ctx) {
-    const { 
-      params: { relationId, commentId }, 
-      query: { authorId },
-      state: { user },
-    } = ctx;
-    if (authorId || user?.id) {
-      try {
-        return await this.getService()
-          .markAsRemoved(
-            commentId,
-            relationId,
-            authorId,
-            user
-          );
-      } catch (e) {
-        if (!e.isBoom) {
-          throwError(ctx, e);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const functions_1 = require("./../utils/functions");
+const functions_2 = require("./utils/functions");
+const parsers_1 = require("./utils/parsers");
+const controllers = {
+    getService(name = "client") {
+        return (0, functions_1.getPluginService)(name);
+    },
+    async findAllFlat(ctx) {
+        const { params = {}, query, sort, pagination } = ctx;
+        const { relation } = (0, functions_2.parseParams)(params);
+        const { sort: querySort, pagination: queryPagination, ...filterQuery } = query || {};
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["relation"]);
+            return this.getService("common").findAllFlat((0, parsers_1.flatInput)(relation, filterQuery, sort || querySort, pagination || queryPagination));
         }
-        throw e;
-      }
-    }
-    return ctx.badRequest('Not provided authorId');
-  },
+        catch (e) {
+            (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async findAllInHierarchy(ctx) {
+        const { params = {}, query, sort } = ctx;
+        const { relation } = (0, functions_2.parseParams)(params);
+        const { sort: querySort, ...filterQuery } = query || {};
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["relation"]);
+            return await this.getService("common").findAllInHierarchy({
+                ...(0, parsers_1.flatInput)(relation, filterQuery, sort || querySort),
+                dropBlockedThreads: true,
+            });
+        }
+        catch (e) {
+            (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async post(ctx) {
+        const { request, params = {}, state = {} } = ctx;
+        const { relation } = (0, functions_2.parseParams)(params);
+        const { user } = state;
+        const { body = {} } = request;
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["relation"]);
+            (0, functions_1.assertNotEmpty)(body);
+            const entity = await this.getService().create(relation, body, user);
+            if (entity) {
+                return entity;
+            }
+        }
+        catch (e) {
+            (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async put(ctx) {
+        const { request, state, params = {} } = ctx;
+        const { body = {} } = request;
+        const { user } = state;
+        const { commentId, relation } = (0, functions_2.parseParams)(params);
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["commentId", "relation"]);
+            (0, functions_1.assertNotEmpty)(body);
+            return await this.getService().update(commentId, relation, body, user);
+        }
+        catch (e) {
+            (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async reportAbuse(ctx) {
+        const { request, state, params = {} } = ctx;
+        const { body = {} } = request;
+        (0, functions_1.assertNotEmpty)(body);
+        if (!body.content) {
+            return ctx.badRequest(null, "Content field is required");
+        }
+        const { user } = state;
+        const { relation, commentId } = (0, functions_2.parseParams)(params);
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["commentId", "relation"]);
+            return await this.getService().reportAbuse(commentId, relation, body, user);
+        }
+        catch (e) {
+            (0, functions_2.throwError)(ctx, e);
+        }
+    },
+    async removeComment(ctx) {
+        const { params, query, state: { user }, } = ctx;
+        const { relationId, commentId } = (0, functions_2.parseParams)(params);
+        const { authorId } = (0, functions_2.parseParams)(query);
+        try {
+            (0, functions_1.assertParamsPresent)(params, ["commentId", "relationId"]);
+            (0, functions_1.assertParamsPresent)(query, ["authorId"]);
+            if (authorId || user?.id) {
+                return await this.getService().markAsRemoved(commentId, relationId, authorId, user);
+            }
+            return ctx.badRequest("Not provided authorId");
+        }
+        catch (e) {
+            if (!e.isBoom) {
+                (0, functions_2.throwError)(ctx, e);
+            }
+            throw e;
+        }
+    },
 };
+exports.default = controllers;
+//# sourceMappingURL=client.js.map

package/server/controllers/index.d.ts

@@ -0,0 +1,6 @@
+declare type PluginControllers = {
+    [key: string]: Function | Object;
+};
+declare const controllers: PluginControllers;
+export default controllers;
+//# sourceMappingURL=index.d.ts.map

package/server/controllers/index.js

@@ -1,9 +1,13 @@
-'use strict';
-
-const adminController = require('./admin');
-const clientController = require('./client');
-
-module.exports = {
-  admin: adminController,
-  client: clientController,
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
+Object.defineProperty(exports, "__esModule", { value: true });
+const admin_1 = __importDefault(require("./admin"));
+const client_1 = __importDefault(require("./client"));
+const controllers = {
+    admin: admin_1.default,
+    client: client_1.default,
+};
+exports.default = controllers;
+//# sourceMappingURL=index.js.map

package/server/controllers/utils/functions.d.ts

@@ -0,0 +1,7 @@
+import { Id, StringMap, StrapiRequestContext } from "strapi-typed";
+import PluginError from "../../utils/error";
+declare type ParseResponse = StringMap<string | number | Id>;
+export declare const parseParams: (params: StringMap<string | number>) => ParseResponse;
+export declare const throwError: <T extends {} = never>(ctx: StrapiRequestContext<T, {}>, e: PluginError | Error | unknown) => PluginError | Error | unknown | never;
+export {};
+//# sourceMappingURL=functions.d.ts.map

package/server/controllers/utils/functions.js

@@ -1,19 +1,24 @@
-const PluginError = require('./../../utils/error');
-
-module.exports = {
-    parseParams: params => Object.keys(params).reduce((prev, curr) => {
-        const value = params[curr];
-        const parsedValue = Number(value);
-        return {
-         ...prev,
-         [curr]: isNaN(parsedValue) ? value : parsedValue
-       };
-      }, {}),
-
-  throwError: (ctx, e) => {
-    if (e instanceof PluginError){
-      return ctx.throw(e.status, JSON.stringify(e));
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwError = exports.parseParams = void 0;
+const error_1 = __importDefault(require("../../utils/error"));
+const parseParams = (params) => Object.keys(params).reduce((prev, curr) => {
+    const value = params[curr];
+    const parsedValue = Number(value);
+    return {
+        ...prev,
+        [curr]: isNaN(parsedValue) ? value : parsedValue,
+    };
+}, {});
+exports.parseParams = parseParams;
+const throwError = (ctx, e) => {
+    if (e instanceof error_1.default) {
+        return ctx.throw(e.status, JSON.stringify(e));
     }
-    throw e;
-  },
+    return e;
 };
+exports.throwError = throwError;
+//# sourceMappingURL=functions.js.map

package/server/controllers/utils/parsers.d.ts

@@ -0,0 +1,15 @@
+import { Id } from "strapi-typed";
+import { ToBeFixed } from "../../../types";
+export declare const flatInput: (relation: Id, query: ToBeFixed, sort: ToBeFixed, pagination?: ToBeFixed) => {
+    query: any;
+    populate: {
+        threadOf: {
+            populate: {
+                authorUser: boolean;
+            };
+        };
+    };
+    pagination: any;
+    sort: any;
+};
+//# sourceMappingURL=parsers.d.ts.map

package/server/controllers/utils/parsers.js

@@ -1,23 +1,23 @@
-'use strict'
-
-module.exports = {
-    flatInput(relation, query, sort, pagination) {
-      const filters = query?.filters || query;
-      const orOperator = (filters?.$or || []).filter(_ => !Object.keys(_).includes('removed'));
-      return {
-          query: {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatInput = void 0;
+const flatInput = (relation, query, sort, pagination) => {
+    const filters = query?.filters || query;
+    const orOperator = (filters?.$or || []).filter((_) => !Object.keys(_).includes("removed"));
+    return {
+        query: {
             ...filters,
             $or: [...orOperator, { removed: { $null: true } }, { removed: false }],
             related: relation,
-          },
-          populate: {
+        },
+        populate: {
             threadOf: {
-              populate: { authorUser: true },
+                populate: { authorUser: true },
             },
-          },
-          pagination,
-          sort,
-        };
-    },
-  
+        },
+        pagination,
+        sort,
+    };
 };
+exports.flatInput = flatInput;
+//# sourceMappingURL=parsers.js.map