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

package/server/services/client.js

@@ -1,321 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const functions_1 = require("./../utils/functions");
-const lodash_1 = require("lodash");
-const error_1 = __importDefault(require("./../utils/error"));
-const functions_2 = require("./utils/functions");
-const constants_1 = require("./../utils/constants");
-module.exports = ({ strapi }) => ({
-    getCommonService() {
-        return (0, functions_1.getPluginService)("common");
-    },
-    async create(relation, data, user) {
-        const { content, threadOf } = data;
-        const singleRelationFulfilled = relation && constants_1.REGEX.relatedUid.test(relation);
-        if (!singleRelationFulfilled) {
-            throw new error_1.default(400, `Field "related" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
-        }
-        const [uid, relatedId] = await this.getCommonService().parseRelationString(relation);
-        const enabledCollections = await this.getCommonService().getConfig(constants_1.CONFIG_PARAMS.ENABLED_COLLECTIONS, []);
-        const isEnabledCollection = await this.getCommonService().isEnabledCollection(uid);
-        if (enabledCollections.length > 0 && !isEnabledCollection) {
-            throw new error_1.default(400, `Field "related" refer to not enabled collection. Please amend the plugin settings and try again`);
-        }
-        const relatedEntity = await strapi.db
-            .query(uid)
-            .findOne({ where: { id: relatedId } });
-        if (!relatedEntity) {
-            throw new error_1.default(400, `Relation for field "related" does not exist. Check your payload please.`);
-        }
-        const approvalFlow = await this.getCommonService().getConfig(constants_1.CONFIG_PARAMS.APPROVAL_FLOW, []);
-        const isApprovalFlowEnabled = approvalFlow.includes(uid) || relatedEntity.requireCommentsApproval;
-        const doNotPopulateAuthor = await this.getCommonService().getConfig(constants_1.CONFIG_PARAMS.AUTHOR_BLOCKED_PROPS, []);
-        let linkToThread;
-        try {
-            linkToThread = !(0, lodash_1.isNil)(threadOf)
-                ? await this.getCommonService().findOne({
-                    id: threadOf,
-                    related: relation,
-                })
-                : null;
-        }
-        catch (e) {
-            throw new error_1.default(400, "Thread does not exist");
-        }
-        const validContext = this.getCommonService().isValidUserContext(user);
-        if (!validContext) {
-            throw (0, functions_2.resolveUserContextError)(user);
-        }
-        if ((await this.getCommonService().checkBadWords(content)) &&
-            singleRelationFulfilled) {
-            const { author, ...rest } = data;
-            let authorData = {};
-            if (validContext && user) {
-                authorData = {
-                    authorUser: user?.id,
-                };
-            }
-            else if (author) {
-                if (author.email && !constants_1.REGEX.email.test(author.email)) {
-                    throw new error_1.default(400, 'Field: "author.email". Author e-mail is not valid value. Check your payload');
-                }
-                authorData = {
-                    authorId: author.id,
-                    authorName: author.name,
-                    authorEmail: author.email,
-                    authorAvatar: (0, lodash_1.isString)(author.avatar) ? author.avatar : undefined,
-                };
-            }
-            const authorNotProperlyProvided = !(0, lodash_1.isEmpty)(authorData) && !(authorData.authorId || authorData.authorUser);
-            if ((0, lodash_1.isEmpty)(authorData) || authorNotProperlyProvided) {
-                throw new error_1.default(400, `Not able to recognise author of a comment. Make sure you've provided "author" property in a payload or authenticated your request properly.`);
-            }
-            if (isApprovalFlowEnabled &&
-                !(0, lodash_1.isNil)(data.approvalStatus) &&
-                data.approvalStatus !== constants_1.APPROVAL_STATUS.PENDING) {
-                throw new error_1.default(400, "Invalid approval status");
-            }
-            const entity = await strapi.db
-                .query((0, functions_2.getModelUid)("comment"))
-                .create({
-                data: {
-                    ...rest,
-                    ...authorData,
-                    related: relation,
-                    approvalStatus: isApprovalFlowEnabled
-                        ? constants_1.APPROVAL_STATUS.PENDING
-                        : null,
-                },
-                populate: {
-                    authorUser: true,
-                },
-            });
-            const sanitizedEntity = this.getCommonService().sanitizeCommentEntity({
-                ...entity,
-                threadOf: linkToThread,
-            }, doNotPopulateAuthor);
-            try {
-                await this.sendResponseNotification(sanitizedEntity);
-            }
-            catch (e) {
-                console.error(e);
-            }
-            return sanitizedEntity;
-        }
-        throw new error_1.default(400, "No content received");
-    },
-    async update(id, relation, data, user) {
-        const { content } = data;
-        const singleRelationFulfilled = relation && constants_1.REGEX.relatedUid.test(relation);
-        if (!singleRelationFulfilled) {
-            throw new error_1.default(400, `Request property "relation" got incorrect format, use format like "api::<collection name>.<content type name>:<entity id>"`);
-        }
-        await this.getCommonService().parseRelationString(relation);
-        const existingEntity = await this.getCommonService().findOne({
-            id,
-            related: relation,
-        });
-        const validContext = this.getCommonService().isValidUserContext(user);
-        if (!validContext) {
-            throw (0, functions_2.resolveUserContextError)(user);
-        }
-        if ((0, functions_2.isEqualEntity)(existingEntity, data, user) && content) {
-            if (await this.getCommonService().checkBadWords(content)) {
-                const blockedAuthorProps = await this.getCommonService().getConfig(constants_1.CONFIG_PARAMS.AUTHOR_BLOCKED_PROPS, []);
-                const entity = await strapi.db
-                    .query((0, functions_2.getModelUid)("comment"))
-                    .update({
-                    where: { id },
-                    data: { content },
-                    populate: { threadOf: true, authorUser: true },
-                });
-                return this.getCommonService().sanitizeCommentEntity(entity, blockedAuthorProps);
-            }
-        }
-        throw new error_1.default(403, `You're not allowed to take an action on that entity. Make sure you've provided "author" property in a payload or authenticated your request properly.`);
-    },
-    async reportAbuse(id, relation, payload, user) {
-        if (!this.getCommonService().isValidUserContext(user)) {
-            throw (0, functions_2.resolveUserContextError)(user);
-        }
-        await this.getCommonService().parseRelationString(relation);
-        try {
-            const reportAgainstEntity = await this.getCommonService().findOne({
-                id,
-                related: relation,
-            });
-            if (reportAgainstEntity.isAdminComment) {
-                throw new error_1.default(403, `You're not allowed to take an action on that entity. This in a admin comment.`);
-            }
-            if (reportAgainstEntity) {
-                const entity = await strapi.db
-                    .query((0, functions_2.getModelUid)("comment-report"))
-                    .create({
-                    data: {
-                        ...payload,
-                        resolved: false,
-                        related: id,
-                    },
-                });
-                if (entity) {
-                    const response = {
-                        ...entity,
-                        related: reportAgainstEntity,
-                    };
-                    try {
-                        await this.sendAbuseReportEmail(entity.reason, entity.content);
-                        return response;
-                    }
-                    catch (err) {
-                        return response;
-                    }
-                }
-                else {
-                    throw new error_1.default(500, "Report cannot be created");
-                }
-            }
-            throw new error_1.default(403, `You're not allowed to take an action on that entity. Make sure that comment exist or you've authenticated your request properly.`);
-        }
-        catch (e) {
-            throw e;
-        }
-    },
-    async markAsRemoved(id, relation, authorId, user) {
-        if (!this.getCommonService().isValidUserContext(user)) {
-            throw (0, functions_2.resolveUserContextError)(user);
-        }
-        const author = user?.id || authorId;
-        if (!author) {
-            throw new error_1.default(403, `You're not allowed to take an action on that entity. Make sure that you've provided proper "authorId" or authenticated your request properly.`);
-        }
-        await this.getCommonService().parseRelationString(relation);
-        try {
-            const byAuthor = user?.id
-                ? {
-                    authorUser: author,
-                }
-                : {
-                    authorId: author,
-                };
-            const entity = await this.getCommonService().findOne({
-                id,
-                related: relation,
-                ...byAuthor,
-            });
-            if (entity) {
-                const removedEntity = await strapi.db
-                    .query((0, functions_2.getModelUid)("comment"))
-                    .update({
-                    where: {
-                        id,
-                        related: relation,
-                    },
-                    data: { removed: true },
-                    populate: { threadOf: true, authorUser: true },
-                });
-                await this.markAsRemovedNested(id, true);
-                const doNotPopulateAuthor = await this.getCommonService().getConfig(constants_1.CONFIG_PARAMS.AUTHOR_BLOCKED_PROPS, []);
-                return this.getCommonService().sanitizeCommentEntity(removedEntity, doNotPopulateAuthor);
-            }
-            else {
-                throw new error_1.default(404, `Entity does not exist or you're not allowed to take an action on it`);
-            }
-        }
-        catch (e) {
-            throw new error_1.default(404, `Entity does not exist or you're not allowed to take an action on it`);
-        }
-    },
-    async sendAbuseReportEmail(reason, content) {
-        const rolesToBeNotified = (await this.getCommonService().getConfig(constants_1.CONFIG_PARAMS.MODERATOR_ROLES)) || ["strapi-super-admin"];
-        const adminUserModel = strapi.db.query("admin::user");
-        const emails = await adminUserModel
-            .findMany({
-            where: {
-                roles: { code: rolesToBeNotified },
-            },
-        })
-            .then((items) => items.map((_) => _.email));
-        const superAdmin = await strapi.db
-            .query("admin::user")
-            .findOne({
-            where: {
-                roles: { code: "strapi-super-admin" },
-            },
-        });
-        if (emails.length > 0) {
-            try {
-                await strapi
-                    .plugin("email")
-                    .service("email")
-                    .send({
-                    to: emails,
-                    from: superAdmin.email,
-                    subject: "New abuse report on comment",
-                    text: `
-                        There was a new abuse report on your app. 
-                        Reason: ${reason}
-                        Message: ${content}
-                    `,
-                });
-            }
-            catch (err) {
-                strapi.log.error(err);
-                throw err;
-            }
-        }
-    },
-    async markAsRemovedNested(id, status) {
-        return this.getCommonService().modifiedNestedNestedComments(id, "removed", status);
-    },
-    async sendResponseNotification(entity) {
-        if (entity.threadOf) {
-            const thread = (0, lodash_1.isObject)(entity.threadOf) ? entity.threadOf : await this.getCommonService().findOne({ id: entity.threadOf });
-            let emailRecipient = thread?.author?.email;
-            if (thread.authorUser && !emailRecipient) {
-                const strapiUser = (0, lodash_1.isObject)(thread.authorUser) ? thread.authorUser : await strapi.db.query("api::user").findOne({
-                    where: { id: thread.authorUser }
-                });
-                emailRecipient = strapiUser?.email;
-            }
-            if (emailRecipient) {
-                const superAdmin = await strapi.db
-                    .query("admin::user")
-                    .findOne({
-                    where: {
-                        roles: { code: "strapi-super-admin" },
-                    },
-                });
-                const emailSender = await this.getCommonService().getConfig('client.contactEmail', superAdmin.email);
-                const clientAppUrl = await this.getCommonService().getConfig('client.url', 'our site');
-                try {
-                    await strapi
-                        .plugin("email")
-                        .service("email")
-                        .send({
-                        to: [emailRecipient],
-                        from: emailSender,
-                        subject: "You've got a new response to your comment",
-                        text: `Hello ${thread?.author?.name || emailRecipient}!
-                You've got a new response to your comment by ${entity?.author?.name || entity?.author?.email}.
-                
-                ------
-
-                "${entity.content}"
-
-                ------
-                
-                Visit ${clientAppUrl} and continue the discussion.
-                `,
-                    });
-                }
-                catch (err) {
-                    strapi.log.error(err);
-                    throw err;
-                }
-            }
-        }
-    },
-});
-//# sourceMappingURL=client.js.map

package/server/services/common.d.ts

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

package/server/services/common.js

@@ -1,296 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-const no_profanity_1 = require("no-profanity");
-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 parsers_1 = require("./utils/parsers");
-const PAGE_SIZE = 10;
-const REQUIRED_FIELDS = ["id"];
-const lifecycleHookListeners = {
-    comment: {},
-    "comment-report": {}
-};
-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, fields, isAdmin = false, omit: baseOmit = [], }, relatedEntity = null) {
-        const omit = baseOmit.filter((field) => !REQUIRED_FIELDS.includes(field));
-        const defaultSelect = ["id", "related"].filter((field) => !omit.includes(field));
-        const populateClause = {
-            authorUser: true,
-            ...((0, lodash_1.isObject)(populate) ? populate : {}),
-        };
-        const doNotPopulateAuthor = isAdmin
-            ? []
-            : await this.getConfig(constants_1.CONFIG_PARAMS.AUTHOR_BLOCKED_PROPS, []);
-        const sortQuery = (0, parsers_1.parseSortQuery)(sort);
-        const fieldsQuery = (0, parsers_1.parseFieldsQuery)(fields, sortQuery, defaultSelect);
-        let [meta, queryExtension = {}] = (0, parsers_1.parsePaginationsQuery)(pagination, fieldsQuery, { PAGE_SIZE });
-        const entries = await strapi.db
-            .query((0, functions_1.getModelUid)("comment"))
-            .findMany({
-            where: {
-                ...query,
-            },
-            populate: {
-                ...populateClause,
-            },
-            ...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 = omit.includes("related")
-            ? []
-            : 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;
-            let authorUserPopulate = {};
-            if ((0, lodash_1.isObject)(populateClause?.authorUser)) {
-                authorUserPopulate =
-                    "populate" in populateClause.authorUser
-                        ? populateClause.authorUser.populate
-                        : populateClause.authorUser;
-            }
-            const primitiveThreadOf = (0, lodash_1.isString)(parsedThreadOf) || (0, lodash_1.isNumber)(parsedThreadOf) ?
-                parsedThreadOf :
-                null;
-            return this.sanitizeCommentEntity({
-                ..._,
-                threadOf: primitiveThreadOf || _.threadOf,
-                gotThread: (threadedItem?.itemsInTread || 0) > 0,
-                threadFirstItemId: threadedItem?.firstThreadItemId,
-            }, doNotPopulateAuthor, omit, authorUserPopulate);
-        });
-        return {
-            data: hasRelatedEntitiesToMap
-                ? result.map((_) => this.mergeRelatedEntityTo(_, relatedEntities))
-                : result,
-            ...((0, lodash_1.isEmpty)(meta) ? {} : { meta }),
-        };
-    },
-    async findAllInHierarchy({ query, populate = {}, sort, fields, startingFromId = null, dropBlockedThreads = false, isAdmin = false, omit = [], }, relatedEntity) {
-        const entities = await this.findAllFlat({ query, populate, sort, fields, isAdmin, omit }, 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.");
-        }
-        const doNotPopulateAuthor = await this.getConfig(constants_1.CONFIG_PARAMS.AUTHOR_BLOCKED_PROPS, []);
-        return (0, functions_1.filterOurResolvedReports)(this.sanitizeCommentEntity(entity, doNotPopulateAuthor));
-    },
-    async findAllPerAuthor({ query = {}, populate = {}, pagination, sort, fields, isAdmin = false, }, authorId, isStrapiAuthor = false) {
-        if ((0, lodash_1.isNil)(authorId)) {
-            return {
-                data: [],
-            };
-        }
-        const { related, ...restQuery } = query;
-        const authorQuery = isStrapiAuthor ? {
-            authorUser: {
-                id: authorId
-            },
-        } : {
-            authorId,
-        };
-        const response = await this.findAllFlat({
-            query: {
-                ...restQuery,
-                ...authorQuery,
-            },
-            pagination, populate, sort, fields, isAdmin
-        });
-        return {
-            ...response,
-            data: response.data.map(({ author, ...rest }) => rest),
-        };
-    },
-    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.count &&
-                changedEntities.count > 0) {
-                const nestedTransactions = await Promise.all(entitiesToChange.map((item) => this.modifiedNestedNestedComments(item.id, fieldName, value)));
-                return nestedTransactions.length === changedEntities.count;
-            }
-            return true;
-        }
-        catch (e) {
-            return false;
-        }
-    },
-    sanitizeCommentEntity(entity, blockedAuthorProps, omit = [], populate) {
-        const fieldsToPopulate = (0, lodash_1.isArray)(populate)
-            ? populate
-            : Object.keys(populate || {});
-        return (0, lodash_1.omit)({
-            ...(0, functions_1.buildAuthorModel)({
-                ...entity,
-                threadOf: (0, lodash_1.isObject)(entity.threadOf)
-                    ? (0, functions_1.buildAuthorModel)(entity.threadOf, blockedAuthorProps, fieldsToPopulate)
-                    : entity.threadOf,
-            }, blockedAuthorProps, fieldsToPopulate),
-        }, omit);
-    },
-    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 isEnabledCollection = await this.isEnabledCollection(uid);
-        const enabledCollections = await this.getConfig(constants_1.CONFIG_PARAMS.ENABLED_COLLECTIONS, []);
-        if (enabledCollections.length > 0 && !isEnabledCollection) {
-            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) {
-            if (content && (0, no_profanity_1.isProfane)({ testString: content })) {
-                throw new error_1.default(400, "Bad language used! Please polite your comment...", {
-                    content: {
-                        original: content,
-                        filtered: content && (0, no_profanity_1.replaceProfanities)({ testString: content }),
-                    },
-                });
-            }
-        }
-        return content;
-    },
-    async isEnabledCollection(uid) {
-        const enabledCollections = await this.getConfig("enabledCollections", []);
-        return enabledCollections.includes(uid);
-    },
-    registerLifecycleHook({ callback, contentTypeName, hookName }) {
-        if (!lifecycleHookListeners[contentTypeName][hookName]) {
-            lifecycleHookListeners[contentTypeName][hookName] = [];
-        }
-        lifecycleHookListeners[contentTypeName][hookName]?.push(callback);
-    },
-    async runLifecycleHook({ contentTypeName, event, hookName }) {
-        const hookListeners = lifecycleHookListeners[contentTypeName][hookName] ?? [];
-        for (const listener of hookListeners) {
-            await listener(event);
-        }
-    },
-});
-//# sourceMappingURL=common.js.map

package/server/services/graphql.d.ts

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