strapi-plugin-comments 2.0.10 → 2.0.11

package/build/server/services/common.js

@@ -0,0 +1,266 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const bad_words_1 = __importDefault(require("bad-words"));
+const lodash_1 = require("lodash");
+const constants_1 = require("../utils/constants");
+const error_1 = __importDefault(require("./../utils/error"));
+const functions_1 = require("./utils/functions");
+const PAGE_SIZE = 10;
+module.exports = ({ strapi }) => ({
+    async getConfig(prop, defaultValue, useLocal = false) {
+        const queryProp = (0, functions_1.buildConfigQueryProp)(prop);
+        const pluginStore = await this.getPluginStore();
+        const config = await pluginStore.get({
+            key: "config",
+        });
+        let result;
+        if (config && !useLocal) {
+            result = queryProp ? (0, lodash_1.get)(config, queryProp, defaultValue) : config;
+        }
+        else {
+            result = this.getLocalConfig(queryProp, defaultValue);
+        }
+        return (0, lodash_1.isNil)(result) ? defaultValue : result;
+    },
+    async getPluginStore() {
+        return strapi.store({ type: "plugin", name: "comments" });
+    },
+    getLocalConfig(prop, defaultValue) {
+        const queryProp = (0, functions_1.buildConfigQueryProp)(prop);
+        const result = strapi.config.get(`plugin.comments${queryProp ? "." + queryProp : ""}`);
+        return (0, lodash_1.isNil)(result) ? defaultValue : result;
+    },
+    async findAllFlat({ query = {}, populate = {}, sort, pagination }, relatedEntity = null) {
+        const defaultPopulate = {
+            authorUser: true,
+        };
+        let queryExtension = {};
+        if (sort && ((0, lodash_1.isString)(sort) || (0, lodash_1.isArray)(sort))) {
+            queryExtension = {
+                ...queryExtension,
+                orderBy: ((0, lodash_1.isString)(sort) ? [sort] : sort)
+                    .map((_) => (constants_1.REGEX.sorting.test(_) ? _ : `${_}:asc`))
+                    .reduce((prev, curr) => {
+                    const [type = "asc", ...parts] = curr.split(":").reverse();
+                    return { ...(0, lodash_1.set)(prev, parts.reverse().join("."), type) };
+                }, {}),
+            };
+        }
+        let meta = {};
+        if (pagination && (0, lodash_1.isObject)(pagination)) {
+            const parsedpagination = Object.keys(pagination).reduce((prev, curr) => ({
+                ...prev,
+                [curr]: (0, lodash_1.parseInt)((0, lodash_1.get)(pagination, curr)),
+            }), {});
+            const { page = 1, pageSize = PAGE_SIZE, start = 0, limit = PAGE_SIZE, } = parsedpagination;
+            const paginationByPage = !(0, lodash_1.isNil)(parsedpagination?.page) || !(0, lodash_1.isNil)(parsedpagination?.pageSize);
+            queryExtension = {
+                ...queryExtension,
+                offset: paginationByPage ? (page - 1) * pageSize : start,
+                limit: paginationByPage ? pageSize : limit,
+            };
+            const metapagination = paginationByPage
+                ? {
+                    pagination: {
+                        page,
+                        pageSize,
+                    },
+                }
+                : {
+                    pagination: {
+                        start,
+                        limit,
+                    },
+                };
+            meta = {
+                ...metapagination,
+            };
+        }
+        const entries = await strapi.db
+            .query((0, functions_1.getModelUid)("comment"))
+            .findMany({
+            where: {
+                ...query,
+            },
+            populate: {
+                ...defaultPopulate,
+                ...populate,
+            },
+            ...queryExtension,
+        });
+        if (pagination?.withCount &&
+            (pagination.withCount === "true" || pagination.withCount === true)) {
+            const total = await strapi.db
+                .query((0, functions_1.getModelUid)("comment"))
+                .count({
+                where: {
+                    ...query,
+                },
+            });
+            const pageSize = meta.pagination.pageSize || PAGE_SIZE;
+            const pageCount = Math.floor(total / pageSize);
+            meta = {
+                ...meta,
+                pagination: {
+                    ...meta.pagination,
+                    pageCount: !(0, lodash_1.isNil)(meta.pagination.page)
+                        ? total % pageSize === 0
+                            ? pageCount
+                            : pageCount + 1
+                        : undefined,
+                    total,
+                },
+            };
+        }
+        const entriesWithThreads = await Promise.all(entries.map(async (_) => {
+            const [nestedEntries, count] = await strapi.db
+                .query((0, functions_1.getModelUid)("comment"))
+                .findWithCount({
+                where: {
+                    threadOf: _.id,
+                },
+            });
+            return {
+                id: _.id,
+                itemsInTread: count,
+                firstThreadItemId: (0, lodash_1.first)(nestedEntries)?.id,
+            };
+        }));
+        const relatedEntities = relatedEntity !== null
+            ? [relatedEntity]
+            : await this.findRelatedEntitiesFor([...entries]);
+        const hasRelatedEntitiesToMap = relatedEntities.filter((_) => _).length > 0;
+        const result = entries.map((_) => {
+            const threadedItem = entriesWithThreads.find((item) => item.id === _.id);
+            const parsedThreadOf = (0, lodash_1.isString)(query.threadOf)
+                ? (0, lodash_1.parseInt)(query.threadOf)
+                : query.threadOf;
+            return this.sanitizeCommentEntity({
+                ..._,
+                threadOf: parsedThreadOf || _.threadOf || null,
+                gotThread: (threadedItem?.itemsInTread || 0) > 0,
+                threadFirstItemId: threadedItem?.firstThreadItemId,
+            });
+        });
+        return {
+            data: hasRelatedEntitiesToMap
+                ? result.map((_) => this.mergeRelatedEntityTo(_, relatedEntities))
+                : result,
+            ...((0, lodash_1.isEmpty)(meta) ? {} : { meta }),
+        };
+    },
+    async findAllInHierarchy({ query, populate = {}, sort, startingFromId = null, dropBlockedThreads = false, }, relatedEntity) {
+        const entities = await this.findAllFlat({ query, populate, sort }, relatedEntity);
+        return (0, functions_1.buildNestedStructure)(entities?.data, startingFromId, "threadOf", dropBlockedThreads, false);
+    },
+    async findOne(criteria) {
+        const entity = await strapi.db
+            .query((0, functions_1.getModelUid)("comment"))
+            .findOne({
+            where: criteria,
+            populate: {
+                reports: true,
+                authorUser: true,
+            },
+        });
+        if (!entity) {
+            throw new error_1.default(404, "Comment does not exist. Check your payload please.");
+        }
+        return (0, functions_1.filterOurResolvedReports)(this.sanitizeCommentEntity(entity));
+    },
+    async findRelatedEntitiesFor(entities = []) {
+        const data = entities.reduce((acc, curr) => {
+            const [relatedUid, relatedStringId] = (0, functions_1.getRelatedGroups)(curr.related);
+            const parsedRelatedId = (0, lodash_1.parseInt)(relatedStringId);
+            const relatedId = (0, lodash_1.isNumber)(parsedRelatedId)
+                ? parsedRelatedId
+                : relatedStringId;
+            return {
+                ...acc,
+                [relatedUid]: [...(acc[relatedUid] || []), relatedId],
+            };
+        }, {});
+        return Promise.all(Object.entries(data).map(async ([relatedUid, relatedStringIds]) => strapi.db
+            .query(relatedUid)
+            .findMany({
+            where: { id: Array.from(new Set(relatedStringIds)) },
+        })
+            .then((relatedEntities) => relatedEntities.map((_) => ({
+            ..._,
+            uid: relatedUid,
+        }))))).then((result) => result.flat(2));
+    },
+    mergeRelatedEntityTo(entity, relatedEntities = []) {
+        return {
+            ...entity,
+            related: relatedEntities.find((relatedEntity) => entity.related === `${relatedEntity.uid}:${relatedEntity.id}`),
+        };
+    },
+    async modifiedNestedNestedComments(id, fieldName, value) {
+        try {
+            const entitiesToChange = await strapi.db
+                .query((0, functions_1.getModelUid)("comment"))
+                .findMany({
+                where: { threadOf: id },
+            });
+            const changedEntities = await strapi.db
+                .query((0, functions_1.getModelUid)("comment"))
+                .updateMany({
+                where: { id: entitiesToChange.map((_) => _.id) },
+                data: { [fieldName]: value },
+            });
+            if (entitiesToChange.length === changedEntities.length &&
+                changedEntities.length > 0) {
+                const nestedTransactions = await Promise.all(changedEntities.map((item) => this.modifiedNestedNestedComments(item.id, fieldName, value)));
+                return nestedTransactions.length === changedEntities.length;
+            }
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    },
+    sanitizeCommentEntity(entity) {
+        return {
+            ...(0, functions_1.buildAuthorModel)({
+                ...entity,
+                threadOf: (0, lodash_1.isObject)(entity.threadOf)
+                    ? (0, functions_1.buildAuthorModel)(entity.threadOf)
+                    : entity.threadOf,
+            }),
+        };
+    },
+    isValidUserContext(user) {
+        return user ? !(0, lodash_1.isNil)(user?.id) : true;
+    },
+    async parseRelationString(relation) {
+        const [uid, relatedStringId] = (0, functions_1.getRelatedGroups)(relation);
+        const parsedRelatedId = (0, lodash_1.parseInt)(relatedStringId);
+        const relatedId = (0, lodash_1.isNumber)(parsedRelatedId)
+            ? parsedRelatedId
+            : relatedStringId;
+        const enabledCollections = await this.getConfig(constants_1.CONFIG_PARAMS.ENABLED_COLLECTIONS, []);
+        if (!enabledCollections.includes(uid)) {
+            throw new error_1.default(403, `Action not allowed for collection '${uid}'. Use one of: ${enabledCollections.join(", ")}`);
+        }
+        return [uid, relatedId];
+    },
+    async checkBadWords(content) {
+        const config = await this.getConfig(constants_1.CONFIG_PARAMS.BAD_WORDS, true);
+        if (config) {
+            const filter = new bad_words_1.default((0, lodash_1.isObject)(config) ? config : undefined);
+            if (content && filter.isProfane(content)) {
+                throw new error_1.default(400, "Bad language used! Please polite your comment...", {
+                    content: {
+                        original: content,
+                        filtered: content && filter.clean(content),
+                    },
+                });
+            }
+        }
+        return content;
+    },
+});
+//# sourceMappingURL=common.js.map

package/build/server/services/graphql.d.ts

@@ -0,0 +1,5 @@
+import { StrapiContext } from "strapi-typed";
+import { IServiceGraphQL } from "../../types";
+declare const _default: ({ strapi }: StrapiContext) => IServiceGraphQL;
+export = _default;
+//# sourceMappingURL=graphql.d.ts.map

package/build/server/services/graphql.js

@@ -0,0 +1,136 @@
+"use strict";
+const fp_1 = require("lodash/fp");
+const nexus_1 = require("nexus");
+const virtualScalarAttributes = ["id"];
+module.exports = ({ strapi }) => {
+  const { service: getService } = strapi.plugin("graphql");
+  const rootLevelOperators = () => {
+    const { operators } = strapi.plugin("graphql").service("builders").filters;
+    return [operators.and, operators.or, operators.not];
+  };
+  const buildContentTypeFilters = (contentType) => {
+    const utils = strapi.plugin("graphql").service("utils");
+    const extension = strapi.plugin("graphql").service("extension");
+    const { getFiltersInputTypeName, getScalarFilterInputTypeName } =
+      utils.naming;
+    const { isStrapiScalar, isRelation } = utils.attributes;
+    const { attributes } = contentType;
+    const filtersTypeName = getFiltersInputTypeName(contentType);
+    return (0, nexus_1.inputObjectType)({
+      name: filtersTypeName,
+      definition(t) {
+        const validAttributes = Object.entries(attributes).filter(
+          ([attributeName]) =>
+            extension
+              .shadowCRUD(contentType.uid)
+              .field(attributeName)
+              .hasFiltersEnabeld()
+        );
+        const isIDFilterEnabled = extension
+          .shadowCRUD(contentType.uid)
+          .field("id")
+          .hasFiltersEnabeld();
+        if (contentType.kind === "collectionType" && isIDFilterEnabled) {
+          t.field("id", { type: getScalarFilterInputTypeName("ID") });
+        }
+        for (const [attributeName, attribute] of validAttributes) {
+          if (isStrapiScalar(attribute)) {
+            addScalarAttribute(t, attributeName, attribute);
+          } else if (isRelation(attribute)) {
+            addRelationalAttribute(t, attributeName, attribute);
+          }
+        }
+        for (const operator of rootLevelOperators()) {
+          operator.add(t, filtersTypeName);
+        }
+      },
+    });
+  };
+  const addScalarAttribute = (builder, attributeName, attribute) => {
+    const { naming, mappers } = strapi.plugin("graphql").service("utils");
+    const gqlType = mappers.strapiScalarToGraphQLScalar(attribute.type);
+    builder.field(attributeName, {
+      type: naming.getScalarFilterInputTypeName(gqlType),
+    });
+  };
+  const addRelationalAttribute = (builder, attributeName, attribute) => {
+    const utils = strapi.plugin("graphql").service("utils");
+    const extension = strapi.plugin("graphql").service("extension");
+    const { getFiltersInputTypeName } = utils.naming;
+    const { isMorphRelation } = utils.attributes;
+    const model = strapi.getModel(attribute.target);
+    if (!model || isMorphRelation(attribute)) return;
+    if (extension.shadowCRUD(model.uid).isDisabled()) return;
+    builder.field(attributeName, { type: getFiltersInputTypeName(model) });
+  };
+  const recursivelyReplaceScalarOperators = (data) => {
+    const { operators } = getService("builders").filters;
+    if (Array.isArray(data)) {
+      return data.map(recursivelyReplaceScalarOperators);
+    }
+    if ((0, fp_1.isDate)(data) || !(0, fp_1.isObject)(data)) {
+      return data;
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(data)) {
+      const isOperator = !!operators[key];
+      const newKey = isOperator ? operators[key].strapiOperator : key;
+      result[newKey] = recursivelyReplaceScalarOperators(value);
+    }
+    return result;
+  };
+  const graphQLFiltersToStrapiQuery = (filters, contentType = {}) => {
+    const { isStrapiScalar, isMedia, isRelation } =
+      getService("utils").attributes;
+    const { operators } = getService("builders").filters;
+    const ROOT_LEVEL_OPERATORS = [operators.and, operators.or, operators.not];
+    if ((0, fp_1.isNil)(filters)) {
+      return {};
+    }
+    if (Array.isArray(filters)) {
+      return filters.map((filtersItem) =>
+        graphQLFiltersToStrapiQuery(filtersItem, contentType)
+      );
+    }
+    const resultMap = {};
+    const { attributes } = contentType;
+    const isAttribute = (attributeName) => {
+      return (
+        virtualScalarAttributes.includes(attributeName) ||
+        (0, fp_1.has)(attributeName, attributes)
+      );
+    };
+    for (const [key, value] of Object.entries(filters)) {
+      if (isAttribute(key)) {
+        const attribute = attributes[key];
+        if (
+          virtualScalarAttributes.includes(key) ||
+          isStrapiScalar(attribute)
+        ) {
+          resultMap[key] = recursivelyReplaceScalarOperators(value);
+        } else if (isRelation(attribute) || isMedia(attribute)) {
+          const relModel = strapi.getModel(attribute.target);
+          resultMap[key] = graphQLFiltersToStrapiQuery(value, relModel);
+        }
+      } else {
+        const rootLevelOperator = ROOT_LEVEL_OPERATORS.find(
+          (0, fp_1.propEq)("fieldName", key)
+        );
+        if (rootLevelOperator) {
+          const { strapiOperator } = rootLevelOperator;
+          resultMap[strapiOperator] = graphQLFiltersToStrapiQuery(
+            value,
+            contentType
+          );
+        }
+      }
+    }
+    return resultMap;
+  };
+  const serviceMethods = {
+    buildContentTypeFilters,
+    graphQLFiltersToStrapiQuery,
+  };
+  return serviceMethods;
+};
+//# sourceMappingURL=graphql.js.map

package/build/server/services/index.d.ts

@@ -0,0 +1,8 @@
+declare const _default: {
+    admin: ({ strapi }: import("strapi-typed").StrapiContext) => import("../../types").IServiceAdmin;
+    client: ({ strapi }: import("strapi-typed").StrapiContext) => import("../../types").IServiceClient;
+    common: ({ strapi }: import("strapi-typed").StrapiContext) => import("../../types").IServiceCommon;
+    gql: ({ strapi }: import("strapi-typed").StrapiContext) => import("../../types").IServiceGraphQL;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/build/server/services/index.js

@@ -0,0 +1,16 @@
+"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 common_1 = __importDefault(require("./common"));
+const graphql_1 = __importDefault(require("./graphql"));
+exports.default = {
+    admin: admin_1.default,
+    client: client_1.default,
+    common: common_1.default,
+    gql: graphql_1.default,
+};
+//# sourceMappingURL=index.js.map

package/build/server/services/utils/functions.d.ts

@@ -0,0 +1,13 @@
+import { Id, StrapiUser } from "strapi-typed";
+import { Comment, ToBeFixed } from "../../../types";
+import PluginError from "./../../utils/error";
+export declare const buildNestedStructure: (entities: Array<Comment>, id?: Id | null, field?: string, dropBlockedThreads?: boolean, blockNestedThreads?: boolean) => Array<Comment>;
+export declare const isEqualEntity: (existing: Comment, data: ToBeFixed, user: StrapiUser) => boolean;
+export declare const getRelatedGroups: (related: string) => Array<string>;
+export declare const getModelUid: (name: string) => string;
+export declare const filterOurResolvedReports: (item: Comment) => Comment;
+export declare const convertContentTypeNameToSlug: (str: string) => string;
+export declare const buildAuthorModel: (item: Comment) => Comment;
+export declare const buildConfigQueryProp: (prop?: undefined | string | Array<string>) => string;
+export declare const resolveUserContextError: (user: StrapiUser) => PluginError;
+//# sourceMappingURL=functions.d.ts.map

package/build/server/services/utils/functions.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault =
+  (this && this.__importDefault) ||
+  function (mod) {
+    return mod && mod.__esModule ? mod : { default: mod };
+  };
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveUserContextError =
+  exports.buildConfigQueryProp =
+  exports.buildAuthorModel =
+  exports.convertContentTypeNameToSlug =
+  exports.filterOurResolvedReports =
+  exports.getModelUid =
+  exports.getRelatedGroups =
+  exports.isEqualEntity =
+  exports.buildNestedStructure =
+    void 0;
+const error_1 = __importDefault(require("./../../utils/error"));
+const constants_1 = require("./../../utils/constants");
+const lodash_1 = require("lodash");
+const buildNestedStructure = (
+  entities,
+  id = null,
+  field = "threadOf",
+  dropBlockedThreads = false,
+  blockNestedThreads = false
+) =>
+  entities
+    .filter((entity) => {
+      const entityField = (0, lodash_1.get)(entity, field);
+      if (entityField === null && id === null) {
+        return true;
+      }
+      let data = entityField;
+      if (data && typeof id === "string") {
+        data = data.toString();
+      }
+      return (
+        (data && data === id) ||
+        ((0, lodash_1.isObject)(entityField) && entityField.id === id)
+      );
+    })
+    .map((entity) => ({
+      ...entity,
+      [field]: undefined,
+      related: undefined,
+      blockedThread: blockNestedThreads || entity.blockedThread,
+      children:
+        entity.blockedThread && dropBlockedThreads
+          ? []
+          : (0, exports.buildNestedStructure)(
+              entities,
+              entity.id,
+              field,
+              dropBlockedThreads,
+              entity.blockedThread
+            ),
+    }));
+exports.buildNestedStructure = buildNestedStructure;
+const isEqualEntity = (existing, data, user) => {
+  const { author: existingAuthor = {} } = existing;
+  const { author } = data;
+  if (data.approvalStatus && existing.approvalStatus !== data.approvalStatus) {
+    return false;
+  }
+  if (user) {
+    const existingUserId = existingAuthor?.id || existingAuthor;
+    const receivedUserId = user?.id || author?.id;
+    return receivedUserId && existingUserId === receivedUserId;
+  }
+  return existingAuthor.id === author?.id;
+};
+exports.isEqualEntity = isEqualEntity;
+const getRelatedGroups = (related) =>
+  related.split(constants_1.REGEX.relatedUid).filter((s) => s && s.length > 0);
+exports.getRelatedGroups = getRelatedGroups;
+const getModelUid = (name) => {
+  return strapi.plugin("comments").contentTypes[name]?.uid;
+};
+exports.getModelUid = getModelUid;
+const filterOurResolvedReports = (item) =>
+  item
+    ? {
+        ...item,
+        reports: (item.reports || []).filter((report) => !report.resolved),
+      }
+    : item;
+exports.filterOurResolvedReports = filterOurResolvedReports;
+const convertContentTypeNameToSlug = (str) => {
+  const plainConversion = str.replace(
+    /[A-Z]/g,
+    (letter) => `-${letter.toLowerCase()}`
+  );
+  return (0, lodash_1.first)(plainConversion) === "-"
+    ? plainConversion.slice(1, plainConversion.length)
+    : plainConversion;
+};
+exports.convertContentTypeNameToSlug = convertContentTypeNameToSlug;
+const buildAuthorModel = (item) => {
+  const {
+    authorUser,
+    authorId,
+    authorName,
+    authorEmail,
+    authorAvatar,
+    ...rest
+  } = item;
+  let author = {};
+  if (authorUser) {
+    author = {
+      id: authorUser.id,
+      name: authorUser.username,
+      email: authorUser.email,
+      avatar: authorUser.avatar,
+    };
+  } else if (authorId) {
+    author = {
+      id: authorId,
+      name: authorName,
+      email: authorEmail,
+      avatar: authorAvatar,
+    };
+  }
+  return {
+    ...rest,
+    author: (0, lodash_1.isEmpty)(author) ? undefined : author,
+  };
+};
+exports.buildAuthorModel = buildAuthorModel;
+const buildConfigQueryProp = (prop = "") =>
+  (0, lodash_1.isArray)(prop) ? prop.join(".") : prop ?? "";
+exports.buildConfigQueryProp = buildConfigQueryProp;
+const resolveUserContextError = (user) => {
+  if (user) {
+    throw new error_1.default(401, "Not authenticated");
+  } else {
+    throw new error_1.default(403, "Not authorized");
+  }
+};
+exports.resolveUserContextError = resolveUserContextError;
+//# sourceMappingURL=functions.js.map

package/build/server/utils/constants.d.ts

@@ -0,0 +1,9 @@
+import { ConfigParamKeys, RegExpCollection } from "../../types";
+export declare const CONFIG_PARAMS: ConfigParamKeys;
+export declare const APPROVAL_STATUS: {
+    PENDING: string;
+    APPROVED: string;
+    REJECTED: string;
+};
+export declare const REGEX: RegExpCollection;
+//# sourceMappingURL=constants.d.ts.map

package/build/server/utils/constants.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.REGEX = exports.APPROVAL_STATUS = exports.CONFIG_PARAMS = void 0;
+exports.CONFIG_PARAMS = {
+  ENABLED_COLLECTIONS: "enabledCollections",
+  APPROVAL_FLOW: "approvalFlow",
+  ENTRY_LABEL: "entryLabel",
+  MODERATOR_ROLES: "moderatorRoles",
+  BAD_WORDS: "badWords",
+};
+exports.APPROVAL_STATUS = {
+  PENDING: "PENDING",
+  APPROVED: "APPROVED",
+  REJECTED: "REJECTED",
+};
+exports.REGEX = {
+  uid: /^(?<type>[a-z0-9-]+)\:{2}(?<api>[a-z0-9-]+)\.{1}(?<contentType>[a-z0-9-]+)$/i,
+  relatedUid:
+    /^(?<uid>[a-z0-9-]+\:{2}[a-z0-9-]+\.[a-z0-9-]+)\:{1}(?<id>[a-z0-9-]+)$/i,
+  email: /\S+@\S+\.\S+/,
+  sorting: /^(?<path>[a-z0-9-_\:\.]+)\:+(asc|desc)$/i,
+};
+//# sourceMappingURL=constants.js.map

package/build/server/utils/error.d.ts

@@ -0,0 +1,23 @@
+declare type ErrorPayload =
+  | {
+      [key: string]: any;
+    }
+  | undefined;
+interface IPluginError extends Error {
+  status: number;
+  payload: ErrorPayload;
+}
+export default class PluginError extends Error implements IPluginError {
+  status: number;
+  payload: ErrorPayload;
+  constructor(status: number, message: string, payload?: ErrorPayload);
+  toString(e?: PluginError): string;
+  toJSON():
+    | this
+    | {
+        name: string;
+        message: string;
+      };
+}
+export {};
+//# sourceMappingURL=error.d.ts.map

package/build/server/utils/error.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class PluginError extends Error {
+  status;
+  payload;
+  constructor(status, message, payload = undefined) {
+    super();
+    this.name = "Strapi:Plugin:Comments";
+    this.status = status || 500;
+    this.message = message || "Internal error";
+    this.payload = payload;
+    Object.setPrototypeOf(this, PluginError.prototype);
+  }
+  toString(e = this) {
+    return `${e.name} - ${e.message}`;
+  }
+  toJSON() {
+    if (this.payload) {
+      return {
+        name: this.name,
+        message: this.message,
+        ...(this.payload || {}),
+      };
+    }
+    return this;
+  }
+}
+exports.default = PluginError;
+//# sourceMappingURL=error.js.map