strapi-plugin-comments 2.0.10 → 2.1.0

package/server/services/graphql.js

@@ -1,190 +1,125 @@
-'use strict';
-
-const { has, propEq, isNil, isDate, isObject } = require('lodash/fp');
-const { inputObjectType } = require('nexus');
-
-const virtualScalarAttributes = ['id'];
-
+"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 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();
-        // Add an ID filter to the collection types
-        if (contentType.kind === 'collectionType' && isIDFilterEnabled) {
-          t.field('id', { type: getScalarFilterInputTypeName('ID') });
+    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);
         }
-
-        // Add every defined attribute
-        for (const [attributeName, attribute] of validAttributes) {
-          // Handle scalars
-          if (isStrapiScalar(attribute)) {
-            addScalarAttribute(t, attributeName, attribute);
-          }
-
-          // Handle relations
-          else if (isRelation(attribute)) {
-            addRelationalAttribute(t, attributeName, attribute);
-          }
+        if ((0, fp_1.isDate)(data) || !(0, fp_1.isObject)(data)) {
+            return data;
         }
-
-        // Conditional clauses
-        for (const operator of rootLevelOperators()) {
-          operator.add(t, filtersTypeName);
+        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);
         }
-      },
-    });
-  };
-
-  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 there is no model corresponding to the attribute configuration
-    // or if the attribute is a polymorphic relation, then ignore it
-    if (!model || isMorphRelation(attribute)) return;
-
-    // If the target model is disabled, then ignore it too
-    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);
-    }
-
-    // Note: We need to make an exception for date since GraphQL
-    // automatically cast date strings to date instances in args
-    if (isDate(data) || !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];
-
-    // Handle unwanted scenario where there is no filters defined
-    if (isNil(filters)) {
-      return {};
-    }
-
-    // If filters is a collection, then apply the transformation to every item of the list
-    if (Array.isArray(filters)) {
-      return filters.map(filtersItem =>
-        graphQLFiltersToStrapiQuery(filtersItem, contentType)
-      );
-    }
-
-    const resultMap = {};
-    const { attributes } = contentType;
-
-    const isAttribute = attributeName => {
-      return virtualScalarAttributes.includes(attributeName) || has(attributeName, attributes);
+        return result;
     };
-
-    for (const [key, value] of Object.entries(filters)) {
-      // If the key is an attribute, update the value
-      if (isAttribute(key)) {
-        const attribute = attributes[key];
-
-        // If it's a scalar attribute
-        if (virtualScalarAttributes.includes(key) || isStrapiScalar(attribute)) {
-          // Replace (recursively) every GraphQL scalar operator with the associated Strapi operator
-          resultMap[key] = recursivelyReplaceScalarOperators(value);
+    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 it's a deep filter on a relation
-        else if (isRelation(attribute) || isMedia(attribute)) {
-          // Fetch the model from the relation
-          const relModel = strapi.getModel(attribute.target);
-
-          // Recursively apply the mapping to the value using the fetched model,
-          // and update the value within `resultMap`
-          resultMap[key] = graphQLFiltersToStrapiQuery(value, relModel);
+        if (Array.isArray(filters)) {
+            return filters.map((filtersItem) => graphQLFiltersToStrapiQuery(filtersItem, contentType));
         }
-      }
-
-      // Handle the case where the key is not an attribute (operator, ...)
-      else {
-        const rootLevelOperator = ROOT_LEVEL_OPERATORS.find(propEq('fieldName', key));
-
-        // If it's a root level operator (AND, NOT, OR, ...)
-        if (rootLevelOperator) {
-          const { strapiOperator } = rootLevelOperator;
-
-          // Transform the current value recursively and add it to the resultMap
-          // object using the strapiOperator equivalent of the GraphQL key
-          resultMap[strapiOperator] = graphQLFiltersToStrapiQuery(value, 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;
-  };
-
-  return {
-    buildContentTypeFilters,
-    graphQLFiltersToStrapiQuery,
-  };
-};
+        return resultMap;
+    };
+    const serviceMethods = {
+        buildContentTypeFilters,
+        graphQLFiltersToStrapiQuery,
+    };
+    return serviceMethods;
+};
+//# sourceMappingURL=graphql.js.map

package/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/server/services/index.js

@@ -1,13 +1,16 @@
-'use strict';
-
-const adminServices = require('./admin');
-const clientServices = require('./client');
-const commonServices = require('./common');
-const graphQLService = require('./graphql');
-
-module.exports = {
-  admin: adminServices,
-  client: clientServices,
-  common: commonServices,
-  gql: graphQLService,
+"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/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, fieldsToPopulate?: Array<string>) => Comment;
+export declare const buildConfigQueryProp: (prop?: undefined | string | Array<string>) => string;
+export declare const resolveUserContextError: (user: StrapiUser) => PluginError;
+//# sourceMappingURL=functions.d.ts.map

package/server/services/utils/functions.js

@@ -1,112 +1,108 @@
-const PluginError = require('./../../utils/error');
-const { REGEX } = require('./../../utils/constants')
-const { first, isObject, isArray, isEmpty } = require('lodash');
-
-const buildNestedStructure = (
-  entities,
-  id = null,
-  field = 'threadOf',
-  dropBlockedThreads = false,
-  blockNestedThreads = false,
-) =>
-  entities
-    .filter(entity => {
-        // mongo by default not return `null` for empty data
-        if (entity[field] === null && id === null) {
-            return true;
-        }
-        let data = entity[field];
-        if (data && typeof id === 'string') {
-            data = data.toString();
-        }
-        return (data && data === id) || (isObject(entity[field]) && (entity[field].id === id));
-    })
-    .map(entity => ({
-        ...entity,
-        [field]: undefined,
-        related: undefined,
-        blockedThread: blockNestedThreads || entity.blockedThread,
-        children: entity.blockedThread && dropBlockedThreads ? [] : buildNestedStructure(entities, entity.id, field,
-        dropBlockedThreads, entity.blockedThread),
-    }));
-
-module.exports = {
-    isEqualEntity: (existing, data, user) => {
-        const { author: existingAuthor } = existing;
-        const { author } = data;
-
-        // Disallow approval status change by Client
-        if (data.approvalStatus && (existing.approvalStatus !== data.approvalStatus)) {
-            return false;
-        }
-
-        // Make sure that author is exact the same
-        if (user) {
-            const existingUserId = existingAuthor?.id || existingAuthor;
-            const receivedUserId = user?.id || author?.id;
-            return receivedUserId && (existingUserId === receivedUserId);
-        }
-        return existingAuthor.id === author?.id;
-    },
-
-    getRelatedGroups: related => related.split(REGEX.relatedUid).filter(s => s && s.length > 0),
-
-    getModelUid: name => {
-        return strapi
-            .plugin('comments')
-            .contentTypes[name]?.uid;
-    },
-
-    filterOurResolvedReports: item => (item ? {
+"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),
-
-    convertContentTypeNameToSlug: str => {
-        const plainConversion = str.replace(/[A-Z]/g, letter => `-${letter.toLowerCase()}`);
-        return first(plainConversion) === '-' ? plainConversion.slice(1, plainConversion.length) : plainConversion;
-    },
-
-    buildNestedStructure,
-
-    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: isEmpty(author) ? undefined : author,
+        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, fieldsToPopulate = []) => {
+    const { authorUser, authorId, authorName, authorEmail, authorAvatar, ...rest } = item;
+    let author = {};
+    if (authorUser) {
+        author = fieldsToPopulate.reduce((prev, curr) => ({
+            ...prev,
+            [curr]: authorUser[curr],
+        }), {
+            id: authorUser.id,
+            name: authorUser.username,
+            email: authorUser.email,
+            avatar: (0, lodash_1.isString)(authorUser.avatar) || (0, lodash_1.isObject)(authorUser.avatar)
+                ? authorUser.avatar
+                : undefined,
+        });
+    }
+    else if (authorId) {
+        author = {
+            id: authorId,
+            name: authorName,
+            email: authorEmail,
+            avatar: authorAvatar,
         };
-    },
-
-    buildConfigQueryProp(prop) {
-        let queryProp = prop;
-        if (prop && isArray(prop)) {
-            queryProp = prop.join('.');
-        }
-        return queryProp;
-    },
-
-    resolveUserContextError: user => {
-        if (user) {
-            throw new PluginError(401, 'Not authenticated');
-        } else {
-            throw new PluginError(403, 'Not authorized');
-        }
-    },
+    }
+    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/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/server/utils/constants.js

@@ -1,26 +1,22 @@
-const CONFIG_PARAMS = {
-  ENABLED_COLLECTIONS: 'enabledCollections',
-  APPROVAL_FLOW: 'approvalFlow',
-  ENTRY_LABEL: 'entryLabel',
-  MODERATOR_ROLES: 'moderatorRoles',
-  BAD_WORDS: 'badWords',
+"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",
 };
-
-const APPROVAL_STATUS = {
-  PENDING: "PENDING",
-  APPROVED: "APPROVED",
-  REJECTED: "REJECTED",
+exports.APPROVAL_STATUS = {
+    PENDING: "PENDING",
+    APPROVED: "APPROVED",
+    REJECTED: "REJECTED",
 };
-
-const 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
-};
-
-module.exports = {
-  CONFIG_PARAMS,
-  APPROVAL_STATUS,
-  REGEX,
+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