strapi-plugin-comments 2.3.2 → 3.0.0-beta.0

package/dist/server/src/services/settings.service.d.ts

@@ -0,0 +1,93 @@
+import { StrapiContext } from '../@types-v5';
+import { CommentsPluginConfig } from '../validators/api/controllers/settings.controller.validator';
+declare const _default: ({ strapi }: StrapiContext) => {
+    getConfig: (viaSettingsPage?: boolean) => Promise<{
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: import("../const").REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: import("../const").REPORT_REASON.DISCRIMINATION;
+            OTHER?: import("../const").REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    } | Omit<{
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: import("../const").REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: import("../const").REPORT_REASON.DISCRIMINATION;
+            OTHER?: import("../const").REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    }, "enabledCollections" | "moderatorRoles" | "isGQLPluginEnabled">>;
+    update: (config: CommentsPluginConfig) => Promise<{
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: import("../const").REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: import("../const").REPORT_REASON.DISCRIMINATION;
+            OTHER?: import("../const").REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    } | Omit<{
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: import("../const").REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: import("../const").REPORT_REASON.DISCRIMINATION;
+            OTHER?: import("../const").REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    }, "enabledCollections" | "moderatorRoles" | "isGQLPluginEnabled">>;
+    restore: () => Promise<{
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: import("../const").REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: import("../const").REPORT_REASON.DISCRIMINATION;
+            OTHER?: import("../const").REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    } | Omit<{
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: import("../const").REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: import("../const").REPORT_REASON.DISCRIMINATION;
+            OTHER?: import("../const").REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    }, "enabledCollections" | "moderatorRoles" | "isGQLPluginEnabled">>;
+    restart: () => void;
+};
+export default _default;

package/dist/server/src/services/utils/functions.d.ts

@@ -0,0 +1,12 @@
+import { StrapiAdmin, StrapiUser } from '@sensinum/strapi-utils';
+import { AdminUser, Id } from '../../@types-v5';
+import PluginError from '../../utils/error';
+import { Comment, CommentWithRelated } from '../../validators/repositories';
+export declare const buildNestedStructure: (entities: Array<Comment | CommentWithRelated>, id?: Id | null, field?: string, dropBlockedThreads?: boolean, blockNestedThreads?: boolean) => Array<Comment>;
+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 buildAuthorModel: (item: any, blockedAuthorProps: Array<string>, fieldsToPopulate?: Array<string>) => Comment;
+export declare const buildConfigQueryProp: (prop?: undefined | string | Array<string>) => string;
+export declare const resolveUserContextError: (user?: AdminUser | StrapiUser) => PluginError;
+export declare const getAuthorName: (author: StrapiAdmin) => string;

package/dist/server/src/utils/Either.d.ts

@@ -0,0 +1,16 @@
+export type Left<T> = {
+    left: T;
+    right?: never;
+};
+export type Right<U> = {
+    left?: never;
+    right: U;
+};
+export type ExtractRightEither<T> = T extends Right<any> ? T['right'] : never;
+export type Either<T, U> = NonNullable<Left<T> | Right<U>>;
+export type UnwrapEither = <T, U>(e: Either<T, U>) => NonNullable<T | U>;
+export declare const unwrapEither: UnwrapEither;
+export declare const isLeft: <T, U>(e: Either<T, U>) => e is Left<T>;
+export declare const isRight: <T, U>(e: Either<T, U>) => e is Right<U>;
+export declare const makeLeft: <T>(value: T) => Left<T>;
+export declare const makeRight: <U>(value: U) => Right<U>;

package/dist/server/src/utils/PluginError.d.ts

@@ -0,0 +1,11 @@
+export type ErrorPayload = Record<string, any> | undefined;
+export default class PluginError extends Error {
+    status: number;
+    payload: ErrorPayload;
+    constructor(status: number, message: string, payload?: ErrorPayload);
+    toString(e?: PluginError): string;
+    toJSON(): this | {
+        name: string;
+        message: string;
+    };
+}

package/dist/server/src/utils/constants.d.ts

@@ -0,0 +1,25 @@
+import { LifeCycleHookName } from "./types";
+export declare const CONFIG_PARAMS: {
+    readonly ENABLED_COLLECTIONS: "enabledCollections";
+    readonly APPROVAL_FLOW: "approvalFlow";
+    readonly ENTRY_LABEL: "entryLabel";
+    readonly MODERATOR_ROLES: "moderatorRoles";
+    readonly BAD_WORDS: "badWords";
+    readonly AUTHOR_BLOCKED_PROPS: "blockedAuthorProps";
+};
+export declare const APPROVAL_STATUS: {
+    PENDING: string;
+    APPROVED: string;
+    REJECTED: string;
+};
+export declare const AUTHOR_TYPE: {
+    GENERIC: string;
+    STRAPI: string;
+};
+export declare const REGEX: {
+    readonly uid: RegExp;
+    readonly relatedUid: RegExp;
+    readonly email: RegExp;
+    readonly sorting: RegExp;
+};
+export declare const LIFECYCLE_HOOKS: ReadonlyArray<LifeCycleHookName>;

package/{server → dist/server/src}/utils/error.d.ts

@@ -16,4 +16,3 @@ export default class PluginError extends Error implements IPluginError {
     };
 }
 export {};
-//# sourceMappingURL=error.d.ts.map

package/dist/server/src/utils/getConfig.d.ts

@@ -0,0 +1,3 @@
+import { StrapiContext } from '../@types-v5';
+import { CommentsPluginConfig } from '../config';
+export declare const getConfig: <T extends "enabledCollections" | "approvalFlow" | "entryLabel" | "moderatorRoles" | "badWords" | "blockedAuthorProps" | "isValidationEnabled" | "reportReasons" | "isGQLPluginEnabled">(strapi: StrapiContext['strapi'], path: T, defaultValue: CommentsPluginConfig[T]) => Promise<CommentsPluginConfig[T]>;

package/dist/server/src/utils/getPluginService.d.ts

@@ -0,0 +1,3 @@
+import { CoreStrapi } from '../@types-v5';
+import { PluginServices } from '../services';
+export declare const getPluginService: <T extends "admin" | "client" | "common" | "settings">(strapi: CoreStrapi, serviceName: T) => PluginServices[T];

package/dist/server/src/utils/throwError.d.ts

@@ -0,0 +1,3 @@
+import { RequestContext } from '../@types-v5';
+import PluginError from './PluginError';
+export declare const throwError: (ctx: RequestContext, e: PluginError | Error | unknown) => PluginError | Error | unknown | never;

package/dist/server/src/utils/tryCatch.d.ts

@@ -0,0 +1 @@
+export declare const tryCatch: <T, E>(callback: () => T, throwError: E) => Promise<import("./Either").Right<Awaited<T>> | import("./Either").Left<E>>;

package/{server → dist/server/src}/utils/types.d.ts

@@ -1,6 +1,5 @@
-import { Effect } from "../../types/utils";
-export type ContentType = "comment" | "comment-report";
-export type LifeCycleHookName = "beforeCreate" | "beforeCreateMany" | "afterCreate" | "afterCreateMany" | "beforeUpdate" | "beforeUpdateMany" | "afterUpdate" | "afterUpdateMany" | "beforeDelete" | "beforeDeleteMany" | "afterDelete" | "afterDeleteMany" | "beforeCount" | "afterCount" | "beforeFindOne" | "afterFindOne" | "beforeFindMany" | "afterFindMany";
+export type ContentType = 'comment' | 'comment-report';
+export type LifeCycleHookName = 'beforeCreate' | 'beforeCreateMany' | 'afterCreate' | 'afterCreateMany' | 'beforeUpdate' | 'beforeUpdateMany' | 'afterUpdate' | 'afterUpdateMany' | 'beforeDelete' | 'beforeDeleteMany' | 'afterDelete' | 'afterDeleteMany' | 'beforeCount' | 'afterCount' | 'beforeFindOne' | 'afterFindOne' | 'beforeFindMany' | 'afterFindMany';
 export interface LifeCycleEvent<THookName extends LifeCycleHookName = LifeCycleHookName, TResult = unknown, TParams = Record<string, unknown>> {
     action: THookName;
     model: {
@@ -8,7 +7,7 @@ export interface LifeCycleEvent<THookName extends LifeCycleHookName = LifeCycleH
         uid: string;
         tableName: string;
         attributes: Record<string, unknown>;
-        lifecycles: Partial<Record<LifeCycleHookName, Effect<LifeCycleEvent>>>;
+        lifecycles: Partial<Record<LifeCycleHookName, any>>;
         indexes: Array<{
             type?: string;
             name: string;
@@ -20,4 +19,3 @@ export interface LifeCycleEvent<THookName extends LifeCycleHookName = LifeCycleH
     params: TParams;
     result?: TResult | TResult[];
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/server/src/validators/api/controllers/admin.controller.validator.d.ts

@@ -0,0 +1,119 @@
+import { z } from 'zod';
+import { ExtractRightEither } from '../../../utils/Either';
+export declare const baseAdminPanelQuery: z.ZodObject<z.objectUtil.extendShape<z.objectUtil.extendShape<z.objectUtil.extendShape<{
+    pageSize: z.ZodDefault<z.ZodPipeline<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>, z.ZodNumber>>;
+    page: z.ZodDefault<z.ZodPipeline<z.ZodEffects<z.ZodUnion<[z.ZodString, z.ZodNumber]>, number, string | number>, z.ZodNumber>>;
+}, {
+    _q: z.ZodOptional<z.ZodString>;
+}>, {
+    orderBy: z.ZodNullable<z.ZodOptional<z.ZodString>>;
+}>, {
+    _q: z.ZodOptional<z.ZodString>;
+}>, "strip", z.ZodTypeAny, {
+    page?: number;
+    pageSize?: number;
+    _q?: string;
+    orderBy?: string;
+}, {
+    page?: string | number;
+    pageSize?: string | number;
+    _q?: string;
+    orderBy?: string;
+}>;
+export declare const getIdValidator: (params: unknown) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    id?: number;
+}>;
+export type IdValidatorSchema = ExtractRightEither<ReturnType<typeof getIdValidator>>;
+export declare const getCommentFindAllValidator: (query: unknown) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    page?: number;
+    pageSize?: number;
+    _q?: string;
+    orderBy?: string;
+}>;
+export type CommentFindAllSchema = ExtractRightEither<ReturnType<typeof getCommentFindAllValidator>>;
+export declare const getReportFindReportsValidator: (query: unknown) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    page?: number;
+    pageSize?: number;
+    _q?: string;
+    orderBy?: string;
+}>;
+export type ReportFindReportsValidator = ExtractRightEither<ReturnType<typeof getReportFindReportsValidator>>;
+export declare const getCommentFindOneValidator: (id: string | number, params: object) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    id?: number;
+    removed?: boolean;
+}>;
+export type FindOneValidatorSchema = ExtractRightEither<ReturnType<typeof getCommentFindOneValidator>>;
+export declare const getCommentResolveAbuseReportValidator: (params: unknown) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    id?: number;
+    reportId?: number;
+}>;
+export type CommentResolveAbuseReportValidatorSchema = ExtractRightEither<ReturnType<typeof getCommentResolveAbuseReportValidator>>;
+export declare const getCommentResolveMultipleAbuseReportsValidator: (params: unknown) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    id?: number;
+    reportIds?: number[];
+}>;
+export type CommentResolveMultipleAbuseReportsValidatorSchema = ExtractRightEither<ReturnType<typeof getCommentResolveMultipleAbuseReportsValidator>>;
+export declare const getReportsMultipleAbuseValidator: (params: unknown) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    reportIds?: number[];
+}>;
+export type ReportsMultipleAbuseValidator = ExtractRightEither<ReturnType<typeof getReportsMultipleAbuseValidator>>;
+export declare const postCommentValidator: z.ZodObject<{
+    id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+    content: z.ZodString;
+    author: z.ZodObject<{
+        id: z.ZodUnion<[z.ZodString, z.ZodNumber]>;
+        email: z.ZodString;
+        lastname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        username: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        firstname: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        id?: string | number;
+        email?: string;
+        lastname?: string;
+        username?: string;
+        firstname?: string;
+    }, {
+        id?: string | number;
+        email?: string;
+        lastname?: string;
+        username?: string;
+        firstname?: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    id?: string | number;
+    content?: string;
+    author?: {
+        id?: string | number;
+        email?: string;
+        lastname?: string;
+        username?: string;
+        firstname?: string;
+    };
+}, {
+    id?: string | number;
+    content?: string;
+    author?: {
+        id?: string | number;
+        email?: string;
+        lastname?: string;
+        username?: string;
+        firstname?: string;
+    };
+}>;
+export declare const getCommentPostValidator: (params: unknown) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    id?: string | number;
+    content?: string;
+    author?: {
+        id?: string | number;
+        email?: string;
+        lastname?: string;
+        username?: string;
+        firstname?: string;
+    };
+}>;
+export type CommentPostValidatorSchema = z.infer<typeof postCommentValidator>;
+export declare const getUpdateCommentValidator: (params: unknown) => import("../../../utils/Either").Left<import("../../../utils/PluginError").default> | import("../../../utils/Either").Right<{
+    id?: string | number;
+    content?: string;
+}>;
+export type UpdateCommentValidatorSchema = ExtractRightEither<ReturnType<typeof getUpdateCommentValidator>>;