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

package/dist/server/src/@types-v5/controllers.d.ts

@@ -0,0 +1,17 @@
+import { Context } from 'koa';
+export type AdminUser = {
+    id: string | number;
+    email: string;
+    username: string;
+};
+export type RequestContext<Body = object, PathParams = object, QueryParams = object> = Omit<Context, 'body' | 'query' | 'request'> & {
+    body: Body;
+    query: QueryParams;
+    params: PathParams;
+    request: Omit<Context['request'], 'body'> & {
+        body: Body;
+    };
+    state: {
+        user?: AdminUser;
+    };
+};

package/dist/server/src/@types-v5/index.d.ts

@@ -0,0 +1,5 @@
+export * from './controllers';
+export * from './routes';
+export * from './utils';
+export { DBQuery } from './repositories';
+export { Where } from './repositories';

package/dist/server/src/@types-v5/repositories.d.ts

@@ -0,0 +1,28 @@
+import { Modules } from '@strapi/strapi';
+type DynamicValue = Modules.Documents.Params.Filters.Operator.DynamicValue;
+type Group = Modules.Documents.Params.Filters.Operator.Group;
+type BooleanValue = Modules.Documents.Params.Filters.Operator.BooleanValue;
+type Condition = {
+    [key in DynamicValue]?: boolean | string | null | Record<string, {
+        [key in DynamicValue]?: Condition;
+    }>;
+};
+type Groups = {
+    [group in Group]?: Array<Record<string, Condition>>;
+};
+type Boolean = {
+    [value: string]: {
+        [key in BooleanValue]?: boolean;
+    };
+};
+export type Where = Groups & Boolean;
+export type DBQuery = {
+    _q?: string;
+    where: Where;
+    orderBy?: Record<string, string> | string;
+    offset: number;
+    limit: number;
+    pageSize: number;
+    page: number;
+};
+export {};

package/dist/server/src/@types-v5/routes.d.ts

@@ -0,0 +1,18 @@
+import { Core } from '@strapi/strapi';
+import { PluginControllers } from '../controllers';
+type PathToFunction<T> = {
+    [K in keyof T]: T[K] extends (...args: any[]) => any ? K & string : T[K] extends object ? `${K & string}.${PathToFunction<T[K]>}` : never;
+}[keyof T];
+export type Handler<Prefix extends string, Controller extends object> = `${Prefix}.${PathToFunction<Controller>}`;
+export type StrapiRoute<ControllerName extends keyof PluginControllers> = Omit<Core.Route, 'handler' | 'info' | 'config'> & {
+    handler: Handler<ControllerName, PluginControllers[ControllerName]>;
+    config?: Core.RouteConfig & {
+        description?: string;
+        tag?: {
+            plugin: string;
+            name: string;
+            actionType: string;
+        };
+    };
+};
+export {};

package/{types/contentTypes.d.ts → dist/server/src/@types-v5/utils.d.ts}

@@ -1,5 +1,24 @@
-import { OnlyStrings, StrapiUser, StringMap } from "strapi-typed";
+import { Database } from '@strapi/database';
+import { FindOneParams, Params } from '@strapi/database/dist/entity-manager/types';
+import type { Core } from '@strapi/strapi';
+import { ContentTypesUUIDs } from '../content-types';
+type DatabaseRepository = ReturnType<Database['query']> & {
+    findOne: <T>(params: FindOneParams) => Promise<T | null>;
+    create: <T>(params: Params) => Promise<T>;
+};
+export type CoreStrapi = Omit<Core.Strapi, 'query' | 'plugin'> & {
+    query: <T extends ContentTypesUUIDs>(query: T) => DatabaseRepository;
+    plugin: (pluginName: string) => Omit<Core.Plugin, 'contentTypes'> & {
+        contentTypes: Record<string, Core.Plugin['contentTypes'][string] & {
+            uid: string;
+        }>;
+    };
+};
+export type StrapiContext = {
+    readonly strapi: CoreStrapi;
+};
 export type Id = number | string;
+type CommentApprovalStatus = 'PENDING' | 'APPROVED' | 'REJECTED';
 export type Comment<TAuthor = CommentAuthor> = {
     id: Id;
     content: string;
@@ -17,8 +36,6 @@ export type Comment<TAuthor = CommentAuthor> = {
     threadFirstItemId?: Id;
     isAdminComment?: boolean;
 } & CommentAuthorPartial;
-export type CommentModelKeys = OnlyStrings<keyof Comment>;
-type CommentApprovalStatus = "PENDING" | "APPROVED" | "REJECTED";
 export type CommentAuthor = {
     id: Id;
     name?: string;
@@ -30,9 +47,9 @@ export type CommentAuthorPartial = {
     authorName?: string;
     authorEmail?: string;
     authorAvatar?: string;
-    authorUser?: StrapiUser;
+    authorUser?: unknown;
 };
-export type CommentAuthorResolved<TExtension = StringMap<unknown>> = CommentAuthor & TExtension;
+export type CommentAuthorResolved<TExtension = Record<string, unknown>> = CommentAuthor & TExtension;
 export type CommentReport = {
     id: Id;
     related: Comment | Id;
@@ -45,5 +62,5 @@ export type RelatedEntity = {
     uid: string;
     requireCommentsApproval?: boolean;
 };
+export type ToBeFixed = any;
 export {};
-//# sourceMappingURL=contentTypes.d.ts.map

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,3 @@
+import { StrapiContext } from './@types-v5';
+declare const _default: ({ strapi }: StrapiContext) => Promise<void>;
+export default _default;

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,101 @@
+import { z } from 'zod';
+import { REPORT_REASON } from '../const';
+export declare const schemaConfig: z.ZodObject<{
+    isValidationEnabled: z.ZodOptional<z.ZodBoolean>;
+    reportReasons: z.ZodOptional<z.ZodObject<{
+        BAD_LANGUAGE: z.ZodLiteral<REPORT_REASON.BAD_LANGUAGE>;
+        OTHER: z.ZodLiteral<REPORT_REASON.OTHER>;
+        DISCRIMINATION: z.ZodLiteral<REPORT_REASON.DISCRIMINATION>;
+    }, "strip", z.ZodTypeAny, {
+        BAD_LANGUAGE?: REPORT_REASON.BAD_LANGUAGE;
+        DISCRIMINATION?: REPORT_REASON.DISCRIMINATION;
+        OTHER?: REPORT_REASON.OTHER;
+    }, {
+        BAD_LANGUAGE?: REPORT_REASON.BAD_LANGUAGE;
+        DISCRIMINATION?: REPORT_REASON.DISCRIMINATION;
+        OTHER?: REPORT_REASON.OTHER;
+    }>>;
+    isGQLPluginEnabled: z.ZodOptional<z.ZodBoolean>;
+    enabledCollections: z.ZodArray<z.ZodString, "many">;
+    moderatorRoles: z.ZodArray<z.ZodString, "many">;
+    approvalFlow: z.ZodArray<z.ZodString, "many">;
+    entryLabel: z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString, "many">>;
+    badWords: z.ZodOptional<z.ZodBoolean>;
+    blockedAuthorProps: z.ZodArray<z.ZodString, "many">;
+}, "strip", z.ZodTypeAny, {
+    enabledCollections?: string[];
+    approvalFlow?: string[];
+    entryLabel?: Record<string, string[]>;
+    moderatorRoles?: string[];
+    badWords?: boolean;
+    blockedAuthorProps?: string[];
+    isValidationEnabled?: boolean;
+    reportReasons?: {
+        BAD_LANGUAGE?: REPORT_REASON.BAD_LANGUAGE;
+        DISCRIMINATION?: REPORT_REASON.DISCRIMINATION;
+        OTHER?: REPORT_REASON.OTHER;
+    };
+    isGQLPluginEnabled?: boolean;
+}, {
+    enabledCollections?: string[];
+    approvalFlow?: string[];
+    entryLabel?: Record<string, string[]>;
+    moderatorRoles?: string[];
+    badWords?: boolean;
+    blockedAuthorProps?: string[];
+    isValidationEnabled?: boolean;
+    reportReasons?: {
+        BAD_LANGUAGE?: REPORT_REASON.BAD_LANGUAGE;
+        DISCRIMINATION?: REPORT_REASON.DISCRIMINATION;
+        OTHER?: REPORT_REASON.OTHER;
+    };
+    isGQLPluginEnabled?: boolean;
+}>;
+export type CommentsPluginConfig = z.infer<typeof schemaConfig>;
+declare const config: {
+    readonly default: {
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: REPORT_REASON.DISCRIMINATION;
+            OTHER?: REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    };
+    readonly validate: (config: unknown) => z.SafeParseReturnType<{
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: REPORT_REASON.DISCRIMINATION;
+            OTHER?: REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    }, {
+        enabledCollections?: string[];
+        approvalFlow?: string[];
+        entryLabel?: Record<string, string[]>;
+        moderatorRoles?: string[];
+        badWords?: boolean;
+        blockedAuthorProps?: string[];
+        isValidationEnabled?: boolean;
+        reportReasons?: {
+            BAD_LANGUAGE?: REPORT_REASON.BAD_LANGUAGE;
+            DISCRIMINATION?: REPORT_REASON.DISCRIMINATION;
+            OTHER?: REPORT_REASON.OTHER;
+        };
+        isGQLPluginEnabled?: boolean;
+    }>;
+};
+export default config;

package/dist/server/src/const/REGEX.d.ts

@@ -0,0 +1,19 @@
+export declare const REGEX: {
+    readonly uid: RegExp;
+    readonly relatedUid: RegExp;
+    readonly email: RegExp;
+    readonly sorting: RegExp;
+};
+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 enum APPROVAL_STATUS {
+    PENDING = "PENDING",
+    APPROVED = "APPROVED",
+    REJECTED = "REJECTED"
+}

package/dist/server/src/const/REPORT_REASON.d.ts

@@ -0,0 +1,5 @@
+export declare enum REPORT_REASON {
+    BAD_LANGUAGE = "BAD_LANGUAGE",
+    DISCRIMINATION = "DISCRIMINATION",
+    OTHER = "OTHER"
+}

package/dist/server/src/const/index.d.ts

@@ -0,0 +1,3 @@
+export * from './REGEX';
+export * from './REPORT_REASON';
+export declare const PLUGIN_SELECTOR = "plugin::comments";

package/dist/server/src/content-types/comments/index.d.ts

@@ -0,0 +1,98 @@
+declare const _default: {
+    schema: {
+        collectionName: string;
+        info: {
+            tableName: string;
+            singularName: string;
+            pluralName: string;
+            displayName: string;
+            description: string;
+            kind: string;
+        };
+        options: {
+            draftAndPublish: boolean;
+        };
+        pluginOptions: {
+            "content-manager": {
+                visible: boolean;
+            };
+            "content-type-builder": {
+                visible: boolean;
+            };
+        };
+        attributes: {
+            content: {
+                type: string;
+                configurable: boolean;
+                required: boolean;
+            };
+            blocked: {
+                type: string;
+                default: boolean;
+                configurable: boolean;
+            };
+            blockedThread: {
+                type: string;
+                default: boolean;
+                configurable: boolean;
+            };
+            blockReason: {
+                type: string;
+                configurable: boolean;
+            };
+            authorUser: {
+                type: string;
+                relation: string;
+                target: string;
+                configurable: boolean;
+            };
+            authorId: {
+                type: string;
+                configurable: boolean;
+            };
+            authorName: {
+                type: string;
+                configurable: boolean;
+            };
+            authorEmail: {
+                type: string;
+                configurable: boolean;
+            };
+            authorAvatar: {
+                type: string;
+                configurable: boolean;
+            };
+            isAdminComment: {
+                type: string;
+                configurable: boolean;
+            };
+            removed: {
+                type: string;
+                configurable: boolean;
+            };
+            approvalStatus: {
+                type: string;
+                enum: import("../../const").APPROVAL_STATUS[];
+                configurable: boolean;
+            };
+            related: {
+                type: string;
+                configurable: boolean;
+            };
+            reports: {
+                type: string;
+                relation: string;
+                target: string;
+                mappedBy: string;
+                configurable: boolean;
+            };
+            threadOf: {
+                type: string;
+                relation: string;
+                target: string;
+                configurable: boolean;
+            };
+        };
+    };
+};
+export default _default;

package/{content-types/comment.d.ts → dist/server/src/content-types/comments/schema.d.ts}

@@ -1,4 +1,6 @@
+import { APPROVAL_STATUS } from '../../const';
 declare const _default: {
+    collectionName: string;
     info: {
         tableName: string;
         singularName: string;
@@ -70,6 +72,7 @@ declare const _default: {
         };
         approvalStatus: {
             type: string;
+            enum: APPROVAL_STATUS[];
             configurable: boolean;
         };
         related: {
@@ -92,4 +95,3 @@ declare const _default: {
     };
 };
 export default _default;
-//# sourceMappingURL=comment.d.ts.map

package/{content-types → dist/server/src/content-types}/index.d.ts

@@ -1,6 +1,7 @@
-declare const _default: {
+declare const contentTypes: {
     comment: {
         schema: {
+            collectionName: string;
             info: {
                 tableName: string;
                 singularName: string;
@@ -72,6 +73,7 @@ declare const _default: {
                 };
                 approvalStatus: {
                     type: string;
+                    enum: import("../const").APPROVAL_STATUS[];
                     configurable: boolean;
                 };
                 related: {
@@ -93,10 +95,10 @@ declare const _default: {
                 };
             };
         };
-        lifecycles: Record<import("../server/utils/types").LifeCycleHookName, import("../types/utils").Effect<import("../server/utils/types").LifeCycleEvent<import("../server/utils/types").LifeCycleHookName, unknown, Record<string, unknown>>>>;
     };
-    "comment-report": {
+    'comment-report': {
         schema: {
+            collectionName: string;
             info: {
                 tableName: string;
                 singularName: string;
@@ -123,8 +125,8 @@ declare const _default: {
                 };
                 reason: {
                     type: string;
-                    enum: string[];
-                    default: string;
+                    enum: import("../const").REPORT_REASON[];
+                    default: import("../const").REPORT_REASON;
                     configurable: boolean;
                     required: boolean;
                 };
@@ -142,8 +144,12 @@ declare const _default: {
                 };
             };
         };
-        lifecycles: Record<import("../server/utils/types").LifeCycleHookName, import("../types/utils").Effect<import("../server/utils/types").LifeCycleEvent<import("../server/utils/types").LifeCycleHookName, unknown, Record<string, unknown>>>>;
     };
 };
-export default _default;
-//# sourceMappingURL=index.d.ts.map
+export type ContentTypes = typeof contentTypes;
+export type KeysContentTypes = keyof ContentTypes;
+export type CommentsContentTypes = {
+    [K in KeysContentTypes]: `plugin::comments.${K}`;
+};
+export type ContentTypesUUIDs = CommentsContentTypes[keyof CommentsContentTypes];
+export default contentTypes;

package/dist/server/src/content-types/report/index.d.ts

@@ -0,0 +1,50 @@
+declare const _default: {
+    schema: {
+        collectionName: string;
+        info: {
+            tableName: string;
+            singularName: string;
+            pluralName: string;
+            displayName: string;
+            description: string;
+            kind: string;
+        };
+        options: {
+            draftAndPublish: boolean;
+        };
+        pluginOptions: {
+            "content-manager": {
+                visible: boolean;
+            };
+            "content-type-builder": {
+                visible: boolean;
+            };
+        };
+        attributes: {
+            content: {
+                type: string;
+                configurable: boolean;
+            };
+            reason: {
+                type: string;
+                enum: import("../../const").REPORT_REASON[];
+                default: import("../../const").REPORT_REASON;
+                configurable: boolean;
+                required: boolean;
+            };
+            resolved: {
+                type: string;
+                default: boolean;
+                configurable: boolean;
+            };
+            related: {
+                type: string;
+                relation: string;
+                target: string;
+                inversedBy: string;
+                configurable: boolean;
+            };
+        };
+    };
+};
+export default _default;

package/{content-types/report.d.ts → dist/server/src/content-types/report/schema.d.ts}

@@ -1,4 +1,6 @@
+import { REPORT_REASON } from '../../const';
 declare const _default: {
+    collectionName: string;
     info: {
         tableName: string;
         singularName: string;
@@ -25,8 +27,8 @@ declare const _default: {
         };
         reason: {
             type: string;
-            enum: string[];
-            default: string;
+            enum: REPORT_REASON[];
+            default: REPORT_REASON;
             configurable: boolean;
             required: boolean;
         };
@@ -45,4 +47,3 @@ declare const _default: {
     };
 };
 export default _default;
-//# sourceMappingURL=report.d.ts.map