strapi-plugin-comments 2.0.11 → 2.1.1

package/content-types/comment.js

@@ -1,93 +0,0 @@
-/**
- * Comments Collection Type
- */
-
-module.exports = {
-  info: {
-    tableName: 'plugin-comments-comments',
-    singularName: 'comment',
-    pluralName: 'comments',
-    displayName: 'Comment',
-    description: 'Comment content type',
-    kind: 'collectionType',
-  },
-  options: {
-    draftAndPublish: false,
-  },
-  pluginOptions: {
-    'content-manager': {
-      visible: false
-    },
-    'content-type-builder': {
-      visible: false
-    }
-  },
-  attributes: {
-    content: {
-      type: 'text',
-      configurable: false,
-      required: true
-    },
-    blocked: {
-      type: 'boolean',
-      default: false,
-      configurable: false
-    },
-    blockedThread: {
-      type: 'boolean',
-      default: false,
-      configurable: false
-    },
-    blockReason: {
-      type: 'string',
-      configurable: false
-    },
-    authorUser: {
-      type: 'relation',
-      relation: 'oneToOne',
-      target: 'plugin::users-permissions.user',
-      configurable: false,
-    },
-    authorId: {
-      type: 'string',
-      configurable: false
-    },
-    authorName: {
-      type: 'string',
-      configurable: false
-    },
-    authorEmail: {
-      type: 'email',
-      configurable: false
-    },
-    authorAvatar: {
-      type: 'string',
-      configurable: false
-    },
-    removed: {
-      type: 'boolean',
-      configurable: false
-    },
-    approvalStatus: {
-      type: 'string',
-      configurable: false
-    },
-    related: {
-      type: 'string',
-      configurable: false
-    },
-    reports: {
-      type: 'relation',
-      relation: 'oneToMany',
-      target: 'plugin::comments.comment-report',
-      mappedBy: 'related',
-      configurable: false,
-    },
-    threadOf: {
-      type: 'relation',
-      relation: 'oneToOne',
-      target: 'plugin::comments.comment',
-      configurable: false,
-    },
-  },
-};

package/content-types/index.js

@@ -1,11 +0,0 @@
-const CommentCT = require('./comment');
-const ReportCT = require('./report');
-
-module.exports = {
-  'comment': {
-    schema: CommentCT,
-  },
-  'comment-report': {
-    schema: ReportCT,
-  }, 
-};

package/content-types/report.js

@@ -1,54 +0,0 @@
-/**
- * Comments Collection Type
- */
-
- module.exports = {
-  info: {
-    tableName: 'plugin-comments-reports',
-    singularName: 'comment-report',
-    pluralName: 'comment-reports',
-    displayName: 'Reports',
-    description: 'Reports content type',
-    kind: 'collectionType',
-  },
-  options: {
-    draftAndPublish: false,
-  },
-  pluginOptions: {
-    'content-manager': {
-      visible: false
-    },
-    'content-type-builder': {
-      visible: false
-    }
-  },
-  attributes: {
-    content: {
-      type: 'text',
-      configurable: false
-    },
-    reason: {
-      type: 'enumeration',
-      enum: [
-        'BAD_LANGUAGE',
-        'DISCRIMINATION',
-        'OTHER'
-      ],
-      default: 'OTHER',
-      configurable: false,
-      required: true
-    },
-    resolved: {
-      type: 'boolean',
-      default: false,
-      configurable: false
-    },
-    related: {
-      type: 'relation',
-      relation: 'manyToOne',
-      target: 'plugin::comments.comment',
-      inversedBy: 'reports',
-      configurable: false,
-    },
-  },
-};

package/jest.config.js

@@ -1,7 +0,0 @@
-module.exports = {
-  name: 'Unit test',
-  testMatch: ['**/__tests__/?(*.)+(spec|test).js'],
-  transform: {},
-  coverageDirectory: "./coverage/",
-  collectCoverage: true,
-};

package/permissions.js

@@ -1,19 +0,0 @@
-'use strict';
-
-module.exports = {
-    render: function(uid) {
-        return `plugin::comments.${uid}`;
-    },
-    comments: {
-        read: 'read',
-        moderate: 'moderate',
-    },
-    reports: {
-        read: 'reports.read',
-        action: 'reports.action',
-    },
-    settings: {
-        read: 'settings.read',
-        change: 'settings.change',
-    },
-};

package/server/config/index.js

@@ -1,17 +0,0 @@
-'use strict';
-
-module.exports = {
-  default: {
-    enabledCollections: [],
-    moderatorRoles: [],
-    approvalFlow: [],
-    entryLabel: {
-      '*': ['Title', 'title', 'Name', 'name', 'Subject', 'subject']
-    },
-    reportReasons: {
-      'BAD_LANGUAGE': 'BAD_LANGUAGE',
-      'DISCRIMINATION': 'DISCRIMINATION',
-      'OTHER': 'OTHER',
-    },
-  }
-};

package/server/controllers/admin.js

@@ -1,168 +0,0 @@
-'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);
-    }
-  },
-};

package/server/controllers/client.js

@@ -1,114 +0,0 @@
-'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);
-        }
-        throw e;
-      }
-    }
-    return ctx.badRequest('Not provided authorId');
-  },
-};

package/server/controllers/index.js

@@ -1,9 +0,0 @@
-'use strict';
-
-const adminController = require('./admin');
-const clientController = require('./client');
-
-module.exports = {
-  admin: adminController,
-  client: clientController,
-};

package/server/controllers/utils/__tests__/functions.test.js

@@ -1,43 +0,0 @@
-const PluginError = require('../../../utils/error');
-const ctx = require('koa/lib/context');
-const { throwError } = require('../functions');
-
-jest.mock
-
-describe('Test Comments controller functions utils', () => {
-  
-  describe('Errors serialization', () => {
-    test('Should throw error PluginError', () => {
-      try {
-        throw new PluginError(400, 'Error message', {
-          content: {
-            param: 'Parameter value'
-          }
-        });
-      } catch (e) {
-        expect(e).toBeInstanceOf(PluginError);
-        expect(e).toHaveProperty('status', 400);
-        expect(e).toHaveProperty('name', 'Strapi:Plugin:Comments');
-        expect(e).toHaveProperty('message', 'Error message');
-        expect(e).toHaveProperty('payload');
-        expect(e.payload).toEqual(expect.objectContaining({
-          content: {
-            param: 'Parameter value'
-          }
-        }));
-
-        try {
-          throwError(ctx, e);
-        } catch (eFinal) {
-          const stringifiedError = eFinal.toString();
-          expect(stringifiedError.includes('BadRequestError')).toEqual(true);
-          expect(stringifiedError.includes('Strapi:Plugin:Comments')).toEqual(true);
-          expect(stringifiedError.includes('Error message')).toEqual(true);
-          expect(stringifiedError.includes('Strapi:Plugin:Comments')).toEqual(true);
-          expect(stringifiedError.includes('content')).toEqual(true);
-          expect(stringifiedError.includes('Parameter value')).toEqual(true);
-        }
-      }
-    });
-  });
-});

package/server/controllers/utils/__tests__/parsers.test.js

@@ -1,94 +0,0 @@
-const { flatInput } = require('../parsers');
-
-jest.mock
-
-describe('Test Comments controller parsers utils', () => {
-  
-  describe('Flat Input properties', () => {
-    const relation = 'api::test.relation';
-    const filters = {
-      content: {
-        '$eq': 'Test'
-      }
-    };
-    const sort = {
-      createdAt: 'desc'
-    };
-    const pagination = {
-      page: 3,
-      pageSize: 5,
-    };
-
-    test('Should contain default property \'populate\'', () => {
-      expect(flatInput()).toHaveProperty(['populate', 'threadOf', 'populate', 'authorUser'], true);
-    });
-
-    test('Should assign relation to \'query\'', () => {
-      expect(flatInput(relation)).toHaveProperty(['query', 'related'], relation);
-    });
-
-    test('Should assign filters to \'query\'', () => {
-      const result = flatInput(relation, filters);
-      expect(result).toHaveProperty(['query', 'content', '$eq'], filters.content['$eq']);
-    });
-
-    test('Should assign not allow to overwrite \'removed\' in $or operator', () => {
-      const overwrittenOrOperator = {
-        $or: [{ removed: true }, { removed: false }, { removed: null }]
-      };
-      const result = flatInput(relation, overwrittenOrOperator);
-      expect(result).toHaveProperty(['query', '$or', 0, 'removed', '$null'], true);
-      expect(result).toHaveProperty(['query', '$or', 1, 'removed'], false);
-    });
-
-    test('Should assign sort', () => {
-      const result = flatInput(relation, filters, sort);
-      expect(result).toHaveProperty(['sort', 'createdAt'], sort.createdAt);
-    });
-
-    test('Should assign pagination', () => {
-      const result = flatInput(relation, filters, sort, pagination);
-      expect(result).toHaveProperty(['pagination', 'page'], pagination.page);
-      expect(result).toHaveProperty(['pagination', 'pageSize'], pagination.pageSize);
-    });
-
-    test('Should build complex output', () => {
-      const day = 24 * 60 * 60 * 1000;
-      const now = Date.now().toString();
-      const oneDayBefore = new Date(Date.now().valueOf() - day).toString();
-      const complexFilters = {
-        '$or': [{
-          createdAt: {
-            '$lte':  oneDayBefore
-          }
-        }, {
-          createdAt: {
-            '$eq':  now
-          }
-        }],
-        content: {
-          '$contains': 'Test'
-        }
-      };
-
-      const complexSort = [{
-        createdAt: 'desc'
-      }, {
-        title: 'asc'
-      }];
-
-      const result = flatInput(relation, complexFilters, complexSort, pagination);
-
-      expect(result).toHaveProperty(['query', 'related'], relation);
-      expect(result).toHaveProperty(['query', '$or', 0, 'createdAt', '$lte'], oneDayBefore);
-      expect(result).toHaveProperty(['query', '$or', 1, 'createdAt', '$eq'], now);
-      expect(result).toHaveProperty(['query', '$or', 2, 'removed', '$null'], true);
-      expect(result).toHaveProperty(['query', '$or', 3, 'removed'], false);
-      expect(result).toHaveProperty(['query', 'content', '$contains'], complexFilters.content['$contains']);
-      expect(result).toHaveProperty(['sort', 0, 'createdAt'], complexSort[0].createdAt);
-      expect(result).toHaveProperty(['sort', 1, 'title'], complexSort[1].title);
-      expect(result).toHaveProperty(['pagination', 'page'], pagination.page);
-      expect(result).toHaveProperty(['pagination', 'pageSize'], pagination.pageSize);
-    });
-  });
-});

package/server/controllers/utils/functions.js

@@ -1,19 +0,0 @@
-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));
-    }
-    throw e;
-  },
-};

package/server/controllers/utils/parsers.js

@@ -1,23 +0,0 @@
-'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: {
-            ...filters,
-            $or: [...orOperator, { removed: { $null: true } }, { removed: false }],
-            related: relation,
-          },
-          populate: {
-            threadOf: {
-              populate: { authorUser: true },
-            },
-          },
-          pagination,
-          sort,
-        };
-    },
-  
-};

package/server/destroy.js

@@ -1,5 +0,0 @@
-'use strict';
-
-module.exports = ({ strapi }) => {
-  // destroy phase
-};