@cap-js/ord 1.8.0 → 1.9.1

package/lib/templates/api-resource.js

@@ -0,0 +1,283 @@
+const _ = require("lodash");
+
+const Logger = require("../logger");
+const defaults = require("../defaults");
+const { createPackages } = require("./package");
+const placeholders = require("../common/placeholders");
+const { resolveApiResourceProtocol } = require("../protocol-resolver");
+const { resolveVisibility, resolveServiceName, flattenEntityGraph } = require("../common/utils");
+const {
+    isValidService,
+    readORDExtensions,
+    isEventsOnlyService,
+    isPrimaryDataProductService,
+} = require("../common/utils");
+const {
+    DESCRIPTION_PREFIX,
+    ORD_RESOURCE_TYPE,
+    RESOURCE_VISIBILITY,
+    SHORT_DESCRIPTION_PREFIX,
+    ORD_API_PROTOCOL,
+    MCP_RESOURCE_DEFINITION_TYPE,
+    ORD_EXTENSIONS_PREFIX,
+    ORD_ODM_ENTITY_NAME_ANNOTATION,
+    ENTITY_RELATIONSHIP_ANNOTATION,
+} = require("../constants");
+
+const RESOURCE_DEFINITION_PROVIDERS = Object.freeze({
+    [ORD_API_PROTOCOL.SAP_INA]: () => [],
+    [ORD_API_PROTOCOL.MCP]: (service, ordId, accessStrategies) => {
+        return [
+            {
+                mediaType: `application/json`,
+                type: MCP_RESOURCE_DEFINITION_TYPE,
+                accessStrategies: accessStrategies,
+                url: `/ord/v1/${ordId}/${service.name}.mcp.json`,
+            },
+        ];
+    },
+    [ORD_API_PROTOCOL.REST]: (service, ordId, accessStrategies) => {
+        // REST only has OpenAPI, no EDMX
+        return [
+            {
+                type: "openapi-v3",
+                mediaType: `application/json`,
+                accessStrategies: accessStrategies,
+                url: `/ord/v1/${ordId}/${service.name}.oas3.json`,
+            },
+        ];
+    },
+    [ORD_API_PROTOCOL.GRAPHQL]: (service, ordId, accessStrategies) => {
+        // GraphQL only has GraphQL SDL
+        return [
+            {
+                type: "graphql-sdl",
+                mediaType: "text/plain",
+                accessStrategies: accessStrategies,
+                url: `/ord/v1/${ordId}/${service.name}.graphql`,
+            },
+        ];
+    },
+    [ORD_API_PROTOCOL.ODATA_V2]: (service, ordId, accessStrategies) => {
+        // openapi-v3 is not supported for OData V2, only EDMX
+        return [
+            {
+                type: "edmx",
+                mediaType: "application/xml",
+                accessStrategies: accessStrategies,
+                url: `/ord/v1/${ordId}/${service.name}.edmx`,
+            },
+        ];
+    },
+    [ORD_API_PROTOCOL.ODATA_V4]: (service, ordId, accessStrategies) => {
+        // OData V4 supports both openapi-v3 and EDMX
+        return [
+            {
+                type: "openapi-v3",
+                mediaType: "application/json",
+                accessStrategies: accessStrategies,
+                url: `/ord/v1/${ordId}/${service.name}.oas3.json`,
+            },
+            {
+                type: "edmx",
+                mediaType: "application/xml",
+                accessStrategies: accessStrategies,
+                url: `/ord/v1/${ordId}/${service.name}.edmx`,
+            },
+        ];
+    },
+    [ORD_API_PROTOCOL.SAP_DATA_SUBSCRIPTION]: (service, ordId, accessStrategies) => {
+        // Data product services use CSN
+        return [
+            {
+                mediaType: `application/json`,
+                accessStrategies: accessStrategies,
+                type: "sap-csn-interop-effective-v1",
+                url: `/ord/v1/${ordId}/${service.name}.csn.json`,
+            },
+        ];
+    },
+});
+
+function _getGroupID(appConfig, srvDefinition) {
+    return `${defaults.groupTypeId}:${appConfig.ordNamespace}:${resolveServiceName(appConfig, srvDefinition)}`;
+}
+
+function _getExposedEntityTypes(service) {
+    const ordIds = new Set(
+        Object.values(service.entities ?? {})
+            .flatMap((entity) => flattenEntityGraph(entity))
+            .flatMap((entity) => {
+                const [namespace, name, version = "v1"] = entity[ENTITY_RELATIONSHIP_ANNOTATION]?.split(":") || [];
+                const major = (entity[`${ORD_EXTENSIONS_PREFIX}version`] ?? version.substring(1)).split(".")[0];
+
+                return [
+                    ...(!entity[ORD_ODM_ENTITY_NAME_ANNOTATION]
+                        ? []
+                        : [`sap.odm:entityType:${entity[ORD_ODM_ENTITY_NAME_ANNOTATION]}:v1`]),
+                    ...(!entity[ENTITY_RELATIONSHIP_ANNOTATION]
+                        ? []
+                        : [entity["@ORD.Extensions.ordId"] ?? `${namespace}:entityType:${name}:v${major}`]),
+                ];
+            }),
+    );
+
+    return [...ordIds].map((ordId) => ({ ordId: ordId }));
+}
+
+/**
+ * Extracts version suffix from service name for data product services.
+ * Only accepts pattern: .v<number> (e.g., .v0, .v1, .v2, .v10)
+ * Rejects patterns like: .v1.1, .v1.0, .version1, .beta
+ *
+ * @param {string} serviceName The full service name
+ * @returns {Object|null} Object with cleanName, version, and semanticVersion, or null if invalid pattern
+ */
+function _extractVersionFromServiceName(serviceName) {
+    // Only match pattern: .v<number> (where number is 1 or more digits)
+    const versionPattern = /\.v(\d+)$/;
+    const match = serviceName.match(versionPattern);
+
+    if (!match) {
+        return null; // No valid version suffix found
+    }
+
+    const versionNumber = parseInt(match[1], 10);
+
+    return {
+        cleanName: serviceName.replace(versionPattern, ""),
+        semanticVersion: `${versionNumber}.0.0`,
+    };
+}
+
+function _getPackageID(namespace, packageIds, resourceType, visibility = RESOURCE_VISIBILITY.public) {
+    return (
+        packageIds.find((id) => {
+            if (visibility === RESOURCE_VISIBILITY.public) {
+                return id.includes(resourceType) && !id.includes("-internal") && !id.includes("-private");
+            } else {
+                return id.includes(`${resourceType}-${visibility}`);
+            }
+        }) || packageIds.find((id) => id.includes(namespace))
+    );
+}
+
+/**
+ * This is a template function to create API Resource object for API Resource Array.
+ * Properties of an API resource can be overwritten by the ORD extensions. Example: visibility.
+ * Ensures proper visibility compliance by checking associated EntityTypes.
+ * @param {object} srvDefinition The definition of the service
+ * @param {object} appConfig - The application configuration.
+ * @returns {Array} An array of objects for the API Resources.
+ */
+const createAPIResourceTemplate = (srvDefinition, appConfig) => {
+    const apiResources = [];
+    const namespace = appConfig.ordNamespace;
+    const accessStrategies = appConfig.accessStrategies;
+    const ordExtensions = readORDExtensions(srvDefinition);
+    const visibility = resolveVisibility(appConfig, srvDefinition);
+    const packageIds = createPackages(appConfig)?.map((pkg) => pkg.ordId) || [];
+    const packageId = _getPackageID(namespace, packageIds, ORD_RESOURCE_TYPE.api, visibility);
+    const protocolResults = resolveApiResourceProtocol(srvDefinition);
+
+    // If no protocols were generated, skip this service
+    if (protocolResults.length === 0) {
+        Logger.info(`No supported protocols for service '${srvDefinition.name}', skipping API resource generation.`);
+        return apiResources;
+    }
+
+    // Handle version suffix extraction for primary data product services
+    let cleanServiceName,
+        version,
+        semanticVersion,
+        extracted = null;
+    if (isPrimaryDataProductService(srvDefinition)) {
+        extracted = _extractVersionFromServiceName(srvDefinition.name);
+
+        cleanServiceName = resolveServiceName(appConfig, { name: extracted?.cleanName || srvDefinition.name });
+        semanticVersion = ordExtensions.version || extracted?.semanticVersion || "1.0.0";
+        version = `v${semanticVersion.split(".")[0]}`;
+    } else {
+        // Non-data product - use current behavior
+        cleanServiceName = resolveServiceName(appConfig, srvDefinition);
+        semanticVersion = ordExtensions.version || "1.0.0";
+        version = `v${semanticVersion.split(".")[0]}`;
+    }
+
+    protocolResults.forEach((protocolResult, index) => {
+        const { apiProtocol, entryPoints, hasResourceDefinitions } = protocolResult;
+        const protocolExtensions = readORDExtensions(srvDefinition, `@protocol('${apiProtocol}').ORD.Extensions.`);
+        const ordId =
+            placeholders.replace(protocolExtensions.ordId, { type: "apiResource", namespace: namespace }) ??
+            placeholders.replace(ordExtensions.ordId, { type: "apiResource", namespace: namespace }) ??
+            `${namespace}:apiResource:${cleanServiceName}${index === 0 ? "" : `-${apiProtocol}`}:${version}`;
+
+        // Build resource definitions based on protocol
+        const resourceDefinitions = !hasResourceDefinitions
+            ? []
+            : RESOURCE_DEFINITION_PROVIDERS[apiProtocol](srvDefinition, ordId, accessStrategies);
+
+        const exposedEntityTypes = _getExposedEntityTypes(srvDefinition);
+
+        let obj = {
+            ordId,
+            title:
+                srvDefinition["@title"] ??
+                srvDefinition["@Common.Label"] ??
+                srvDefinition["@EndUserText.label"] ??
+                srvDefinition.name,
+            shortDescription: SHORT_DESCRIPTION_PREFIX + srvDefinition.name,
+            description: srvDefinition["@Core.Description"] ?? DESCRIPTION_PREFIX + srvDefinition.name,
+            version: semanticVersion,
+            lastUpdate: appConfig.lastUpdate,
+            visibility,
+            partOfPackage: packageId,
+            partOfGroups: [_getGroupID(appConfig, srvDefinition)],
+            releaseStatus: "active",
+            apiProtocol,
+            resourceDefinitions,
+            entryPoints,
+            extensible: {
+                supported: "no",
+            },
+            ...(exposedEntityTypes.length ? { exposedEntityTypes } : []),
+            ..._.omit(ordExtensions, ["ordId"]),
+            ..._.omit(protocolExtensions, ["ordId"]),
+        };
+
+        // Special handling for data product services
+        if (isPrimaryDataProductService(srvDefinition)) {
+            obj.direction = "outbound";
+            if (extracted) {
+                // Overwrite partOfGroups
+                obj.partOfGroups = [`${defaults.groupTypeId}:${namespace}:${cleanServiceName}`];
+            }
+        }
+
+        apiResources.push(obj);
+    });
+
+    return apiResources;
+};
+
+function createAPIResources(appConfig) {
+    return Object.values(appConfig.csn.definitions)
+        .filter((definition) => isValidService(definition) && !isEventsOnlyService(definition))
+        .flatMap((service) => createAPIResourceTemplate(service, appConfig))
+        .filter((ar) => ar.visibility !== RESOURCE_VISIBILITY.private)
+        .map((ar) => ({
+            ...ar,
+            ordId: placeholders.replace(ar.ordId, { type: "apiResource", namespace: appConfig.ordNamespace }),
+            partOfPackage: placeholders.replace(ar.partOfPackage, {
+                type: "package",
+                namespace: appConfig.ordNamespace,
+            }),
+        }));
+}
+
+module.exports = {
+    createAPIResources,
+    createAPIResourceTemplate,
+    _getPackageID,
+    _getExposedEntityTypes,
+};

package/lib/templates/entity-type.js

@@ -0,0 +1,121 @@
+const _ = require("lodash");
+
+const Logger = require("../logger");
+const { createPackages } = require("./package");
+const placeholders = require("../common/placeholders");
+const { readORDExtensions, isExposedEntityType } = require("../common/utils");
+const {
+    LEVEL,
+    SEM_VERSION_REGEX,
+    RESOURCE_VISIBILITY,
+    ENTITY_RELATIONSHIP_ANNOTATION,
+    CONTENT_MERGE_KEY,
+} = require("../constants");
+
+const RESOLVERS = Object.freeze({
+    ordId: (entity, appConfig) => {
+        const [namespace, name, version = "v1"] = entity[ENTITY_RELATIONSHIP_ANNOTATION].split(":");
+
+        return (
+            placeholders.replace(entity["@ORD.Extensions.ordId"], {
+                type: "entityType",
+                namespace: appConfig.ordNamespace,
+            }) ??
+            `${namespace}:entityType:${name}:v${(entity["@ORD.Extensions.version"] ?? version.substring(1)).split(".")[0]}`
+        );
+    },
+    title: (entity) => {
+        return (
+            entity["@ORD.Extensions.title"] ??
+            entity["@title"] ??
+            entity["@Common.Label"] ??
+            entity["@EndUserText.label"] ??
+            RESOLVERS.localId(entity)
+        );
+    },
+    level: (entity) => {
+        return (
+            entity["@ORD.Extensions.level"] ??
+            (entity["@ObjectModel.compositionRoot"] || entity["@ODM.root"] ? LEVEL.rootEntity : LEVEL.subEntity)
+        );
+    },
+    localId: (entity) => {
+        return entity["@ORD.Extensions.localId"] ?? entity[ENTITY_RELATIONSHIP_ANNOTATION].split(":")[1];
+    },
+    version: (entity, appConfig) => {
+        const ordId = RESOLVERS.ordId(entity, appConfig);
+        const version = entity["@ORD.Extensions.version"] ?? ordId.split(":").pop().replace("v", "") + ".0.0";
+
+        if (!SEM_VERSION_REGEX.test(version)) {
+            Logger.warn("Entity version", version, "is not a valid semantic version.");
+        }
+
+        return version;
+    },
+    visibility: (entity, appConfig) => {
+        return entity["@ORD.Extensions.visibility"] ?? appConfig.env?.defaultVisibility ?? RESOURCE_VISIBILITY.public;
+    },
+    partOfPackage: (entity, appConfig) => {
+        const namespace = appConfig.ordNamespace;
+        const visibility = RESOLVERS.visibility(entity, appConfig);
+        const name = appConfig.appName?.replace(/[^a-zA-Z0-9]/g, "");
+        const packages = createPackages(appConfig).map((pkg) => pkg.ordId);
+        const suffix = visibility === RESOURCE_VISIBILITY.public ? "" : `-${visibility}`;
+
+        return (
+            placeholders.replace(entity["@ORD.Extensions.partOfPackage"], {
+                type: "package",
+                namespace: namespace,
+            }) ??
+            [`${namespace}:package:${name}-entityType${suffix}:v1`, `${namespace}:package:${name}:v1`].find(
+                (candidate) => packages.includes(candidate),
+            )
+        );
+    },
+});
+
+/**
+ * This is a template function to create EntityType object for EntityTypes Array.
+ * Ensures correct visibility assignment based on referenced resources.
+ *
+ * @param { object } appConfig  The configuration object.
+ * @param { object } entity The entity definition.
+ * @returns { object } An object for the EntityType (see: https://pages.github.tools.sap/CentralEngineering/open-resource-discovery-specification/spec-v1/interfaces/Document#entity-type).
+ */
+function createEntityTypeTemplate(appConfig, entity) {
+    return {
+        releaseStatus: "active",
+        extensible: { supported: "no" },
+        lastUpdate: appConfig.lastUpdate,
+        description: `Description for ${RESOLVERS.localId(entity)}`,
+        shortDescription: `Short description of ${RESOLVERS.localId(entity)}`,
+
+        title: RESOLVERS.title(entity),
+        level: RESOLVERS.level(entity),
+        localId: RESOLVERS.localId(entity),
+        ordId: RESOLVERS.ordId(entity, appConfig),
+        version: RESOLVERS.version(entity, appConfig),
+        visibility: RESOLVERS.visibility(entity, appConfig),
+        partOfPackage: RESOLVERS.partOfPackage(entity, appConfig),
+
+        ..._.omit(readORDExtensions(entity), Object.keys(RESOLVERS)),
+    };
+}
+
+function createEntityTypes(appConfig) {
+    return appConfig.hasSAPPolicyLevel
+        ? [] // If SAP policy level is present, don't create entity type, they must be in the central repository
+        : _.uniqBy(
+              Object.values(appConfig.csn.definitions)
+                  .filter((definition) => isExposedEntityType(definition))
+                  .map((entity) => createEntityTypeTemplate(appConfig, entity))
+                  .filter((entity) => entity.visibility !== RESOURCE_VISIBILITY.private),
+              CONTENT_MERGE_KEY,
+          );
+}
+
+module.exports = {
+    createEntityTypes,
+    createEntityTypeTemplate,
+    RESOLVERS,
+};

package/lib/templates/event-resource.js

@@ -0,0 +1,161 @@
+const _ = require("lodash");
+
+const defaults = require("../defaults");
+const { prune } = require("../common/utils");
+const { createPackages } = require("./package");
+const entityTypeTemplate = require("./entity-type");
+const placeholders = require("../common/placeholders");
+const {
+    RESOURCE_VISIBILITY,
+    ENTITY_RELATIONSHIP_ANNOTATION,
+    ORD_ODM_ENTITY_NAME_ANNOTATION,
+    CDS_ELEMENT_KIND,
+} = require("../constants");
+const {
+    readORDExtensions,
+    resolveVisibility,
+    flattenEntityGraph,
+    resolveServiceName,
+    isValidService,
+} = require("../common/utils");
+
+const RESOLVERS = Object.freeze({
+    version: (service) => {
+        return service["@ORD.Extensions.version"] ?? "1.0.0";
+    },
+    description: (service) => {
+        return (
+            service["@ORD.Extensions.description"] ??
+            service["@description"] ??
+            service["@Core.Description"] ??
+            "CAP Event resource describing events / messages."
+        );
+    },
+    ordId: (service, appConfig) => {
+        const name = resolveServiceName(appConfig, service);
+        const version = `v${RESOLVERS.version(service).split(".")[0]}`;
+
+        return (
+            placeholders.replace(service["@ORD.Extensions.ordId"], {
+                type: "eventResource",
+                namespace: appConfig.ordNamespace,
+            }) ?? `${appConfig.ordNamespace}:eventResource:${name}:${version}`
+        );
+    },
+    title: (service, appConfig) => {
+        return (
+            service["@ORD.Extensions.title"] ??
+            service["@title"] ??
+            service["@Common.Label"] ??
+            service["@EndUserText.label"] ??
+            `ODM ${appConfig.appName.replace(/[^a-zA-Z0-9]/g, "")} Events`
+        );
+    },
+    exposedEntityTypes: (service, appConfig) => {
+        const ordIds = new Set(
+            Object.values(service.entities ?? {})
+                .flatMap((entity) => flattenEntityGraph(entity))
+                .flatMap((entity) => {
+                    return [
+                        ...(!entity[ORD_ODM_ENTITY_NAME_ANNOTATION]
+                            ? []
+                            : [`sap.odm:entityType:${entity[ORD_ODM_ENTITY_NAME_ANNOTATION]}:v1`]),
+                        ...(!entity[ENTITY_RELATIONSHIP_ANNOTATION]
+                            ? []
+                            : [entityTypeTemplate.RESOLVERS.ordId(entity, appConfig)]),
+                    ];
+                }),
+        );
+
+        return service["@ORD.Extensions.exposedEntityTypes"] ?? [...ordIds].map((ordId) => ({ ordId: ordId }));
+    },
+    visibility: (service, appConfig) => {
+        return resolveVisibility(appConfig, service);
+    },
+    partOfGroups: (service, appConfig) => {
+        const namespace = appConfig.ordNamespace;
+        const name = resolveServiceName(appConfig, service);
+
+        return service["@ORD.Extensions.partOfGroups"] ?? [`${defaults.groupTypeId}:${namespace}:${name}`];
+    },
+    partOfPackage: (service, appConfig) => {
+        const namespace = appConfig.ordNamespace;
+        const visibility = RESOLVERS.visibility(service, appConfig);
+        const name = appConfig.appName?.replace(/[^a-zA-Z0-9]/g, "");
+        const packages = createPackages(appConfig).map((pkg) => pkg.ordId);
+        const suffix = visibility === RESOURCE_VISIBILITY.public ? "" : `-${visibility}`;
+
+        return (
+            placeholders.replace(service["@ORD.Extensions.partOfPackage"], { type: "package", namespace: namespace }) ??
+            [`${namespace}:package:${name}-event${suffix}:v1`, `${namespace}:package:${name}:v1`] //
+                .find((candidate) => packages.includes(candidate))
+        );
+    },
+    resourceDefinitions: (service, appConfig) => {
+        const name = service.name;
+        const ordId = RESOLVERS.ordId(service, appConfig);
+        const accessStrategies = appConfig.accessStrategies;
+
+        return (
+            service["@ORD.Extensions.resourceDefinitions"] ?? [
+                {
+                    type: "asyncapi-v2",
+                    mediaType: `application/json`,
+                    url: `/ord/v1/${ordId}/${name}.asyncapi2.json`,
+                    accessStrategies: accessStrategies,
+                },
+            ]
+        );
+    },
+});
+
+/**
+ * This is a template function to create Event Resource object.
+ * There can be only one event resource per service because all events are using the same protocol, they are always Cloud Events.
+ * Properties of an event resource can be overwritten by the ORD extensions. Example: visibility.
+ * Ensures proper visibility compliance by checking associated EntityTypes.
+ *
+ * @param {object} service The definition of the service
+ * @param {object} appConfig - The application configuration.
+ * @returns {object} An object representing the Event Resource.
+ */
+function createEventResourceTemplate(service, appConfig) {
+    return prune({
+        releaseStatus: "active",
+        extensible: { supported: "no" },
+        lastUpdate: appConfig.lastUpdate,
+        shortDescription: `${service.name} event resource`,
+
+        version: RESOLVERS.version(service),
+        ordId: RESOLVERS.ordId(service, appConfig),
+        title: RESOLVERS.title(service, appConfig),
+        description: RESOLVERS.description(service),
+        visibility: RESOLVERS.visibility(service, appConfig),
+        partOfGroups: RESOLVERS.partOfGroups(service, appConfig),
+        partOfPackage: RESOLVERS.partOfPackage(service, appConfig),
+        exposedEntityTypes: RESOLVERS.exposedEntityTypes(service, appConfig),
+        resourceDefinitions: RESOLVERS.resourceDefinitions(service, appConfig),
+
+        ..._.omit(readORDExtensions(service), Object.keys(RESOLVERS)),
+    });
+}
+
+function createEventResources(appConfig) {
+    const services = _.uniqBy(
+        Object.values(appConfig.csn.definitions)
+            .filter((definition) => definition.kind === CDS_ELEMENT_KIND.event)
+            .filter((definition) => isValidService(definition["_service"]))
+            .map((definition) => definition["_service"]),
+        "name",
+    );
+
+    return services
+        .map((service) => createEventResourceTemplate(service, appConfig))
+        .filter((resource) => resource.visibility !== RESOURCE_VISIBILITY.private);
+}
+
+module.exports = {
+    createEventResources,
+    createEventResourceTemplate,
+    RESOLVERS,
+};

package/lib/templates/group.js

@@ -0,0 +1,50 @@
+const defaults = require("../defaults");
+const { RESOURCE_VISIBILITY } = require("../constants");
+const { resolveServiceName, isValidService, resolveVisibility } = require("../common/utils");
+
+const RESOLVERS = Object.freeze({
+    title: (service) => {
+        return (
+            service["@ORD.Extensions.title"] ??
+            `${service.name
+                .split(".")
+                .pop()
+                .replace(/Service(.*)$/, "")} Service`
+        );
+    },
+    groupId: (service, appConfig) => {
+        const namespace = appConfig.ordNamespace;
+        const name = resolveServiceName(appConfig, service);
+
+        return `${defaults.groupTypeId}:${namespace}:${name}`;
+    },
+});
+
+/**
+ * This is a template function to create group object of a service for groups array in ORD doc.
+ *
+ * @param {object} service The definition of the service
+ * @param {object} appConfig - The application configuration.
+ * @returns {Object} A group object.
+ */
+function createGroupsTemplateForService(service, appConfig) {
+    return {
+        groupTypeId: defaults.groupTypeId,
+
+        title: RESOLVERS.title(service),
+        groupId: RESOLVERS.groupId(service, appConfig),
+    };
+}
+
+function createGroups(appConfig) {
+    return Object.values(appConfig.csn.definitions)
+        .filter((definition) => isValidService(definition))
+        .filter((service) => resolveVisibility(appConfig, service) !== RESOURCE_VISIBILITY.private)
+        .flatMap((service) => createGroupsTemplateForService(service, appConfig));
+}
+
+module.exports = {
+    createGroups,
+    createGroupsTemplateForService,
+    RESOLVERS,
+};