@redocly/openapi-core 1.23.1 → 1.25.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @redocly/openapi-core
 
+## 1.25.0
+
+### Minor Changes
+
+- Added a mechanism that resolves plugin properties specific to the Reunite-hosted product family.
+- Added a cache for resolved plugins to ensure that plugins are only instantiated once during a single execution.
+
+## 1.24.0
+
+### Minor Changes
+
+- Added Spot and Arazzo rules: `no-criteria-xpath`, `no-actions-type-end`, `criteria-unique`.
+
+### Patch Changes
+
+- Updated @redocly/ajv to v8.11.2.
+- Fixed an issue where custom rules were not applied to Arazzo descriptions.
+
 ## 1.23.1
 
 ## 1.23.0

package/lib/config/all.js

@@ -139,6 +139,9 @@ const all = {
         'step-onSuccess-unique': 'error',
         'step-onFailure-unique': 'error',
         'requestBody-replacements-unique': 'error',
+        'no-criteria-xpath': 'error',
+        'no-actions-type-end': 'error',
+        'criteria-unique': 'error',
     },
 };
 exports.default = all;

package/lib/config/config-resolvers.d.ts

@@ -14,7 +14,7 @@ export declare function resolveConfig({ rawConfig, configPath, externalRefResolv
     configPath?: string;
     externalRefResolver?: BaseResolver;
 }): Promise<Config>;
-export declare function resolvePlugins(plugins: (string | Plugin)[] | null, configPath?: string): Promise<Plugin[]>;
+export declare function resolvePlugins(plugins: (string | Plugin)[] | null, configDir?: string): Promise<Plugin[]>;
 export declare function resolveApis({ rawConfig, configPath, resolver, }: {
     rawConfig: RawConfig;
     configPath?: string;

package/lib/config/config-resolvers.js

@@ -23,6 +23,8 @@ const redocly_yaml_1 = require("../types/redocly-yaml");
 const DEFAULT_PROJECT_PLUGIN_PATHS = ['@theme/plugin.js', '@theme/plugin.cjs', '@theme/plugin.mjs'];
 // Workaround for dynamic imports being transpiled to require by Typescript: https://github.com/microsoft/TypeScript/issues/43329#issuecomment-811606238
 const _importDynamic = new Function('modulePath', 'return import(modulePath)');
+// Cache instantiated plugins during a single execution
+const pluginsCache = new Map();
 async function resolveConfigFileAndRefs({ configPath, externalRefResolver = new resolve_1.BaseResolver(), base = null, }) {
     if (!configPath) {
         throw new Error('Reference to a config is required.\n');
@@ -60,39 +62,59 @@ async function resolveConfig({ rawConfig, configPath, externalRefResolver, }) {
         styleguide,
     }, configPath);
 }
-function getDefaultPluginPath(configPath) {
+function getDefaultPluginPath(configDir) {
     for (const pluginPath of DEFAULT_PROJECT_PLUGIN_PATHS) {
-        const absolutePluginPath = path.resolve(path.dirname(configPath), pluginPath);
+        const absolutePluginPath = path.resolve(configDir, pluginPath);
         if ((0, fs_1.existsSync)(absolutePluginPath)) {
             return pluginPath;
         }
     }
     return;
 }
-async function resolvePlugins(plugins, configPath = '') {
+async function resolvePlugins(plugins, configDir = '') {
     if (!plugins)
         return [];
     // TODO: implement or reuse Resolver approach so it will work in node and browser envs
     const requireFunc = async (plugin) => {
         if ((0, utils_1.isString)(plugin)) {
             try {
-                const maybeAbsolutePluginPath = path.resolve(path.dirname(configPath), plugin);
+                const maybeAbsolutePluginPath = path.resolve(configDir, plugin);
                 const absolutePluginPath = (0, fs_1.existsSync)(maybeAbsolutePluginPath)
                     ? maybeAbsolutePluginPath
                     : // For plugins imported from packages specifically
                         require.resolve(plugin);
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore
-                if (typeof __webpack_require__ === 'function') {
+                if (!pluginsCache.has(absolutePluginPath)) {
+                    let requiredPlugin;
                     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
                     // @ts-ignore
-                    return __non_webpack_require__(absolutePluginPath);
-                }
-                else {
-                    // you can import both cjs and mjs
-                    const mod = await _importDynamic((0, url_1.pathToFileURL)(absolutePluginPath).href);
-                    return mod.default || mod;
+                    if (typeof __webpack_require__ === 'function') {
+                        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                        // @ts-ignore
+                        requiredPlugin = __non_webpack_require__(absolutePluginPath);
+                    }
+                    else {
+                        // you can import both cjs and mjs
+                        const mod = await _importDynamic((0, url_1.pathToFileURL)(absolutePluginPath).href);
+                        requiredPlugin = mod.default || mod;
+                    }
+                    const pluginCreatorOptions = { contentDir: configDir };
+                    const pluginModule = (0, utils_2.isDeprecatedPluginFormat)(requiredPlugin)
+                        ? requiredPlugin
+                        : (0, utils_2.isCommonJsPlugin)(requiredPlugin)
+                            ? await requiredPlugin(pluginCreatorOptions)
+                            : await requiredPlugin?.default?.(pluginCreatorOptions);
+                    if (pluginModule?.id && (0, utils_2.isDeprecatedPluginFormat)(requiredPlugin)) {
+                        logger_1.logger.info(`Deprecated plugin format detected: ${pluginModule.id}\n`);
+                    }
+                    if (pluginModule) {
+                        pluginsCache.set(absolutePluginPath, {
+                            ...pluginModule,
+                            path: plugin,
+                            absolutePath: absolutePluginPath,
+                        });
+                    }
                 }
+                return pluginsCache.get(absolutePluginPath);
             }
             catch (e) {
                 throw new Error(`Failed to load plugin "${plugin}": ${e.message}\n\n${e.stack}`);
@@ -104,7 +126,7 @@ async function resolvePlugins(plugins, configPath = '') {
     /**
      * Include the default plugin automatically if it's not in configuration
      */
-    const defaultPluginPath = getDefaultPluginPath(configPath);
+    const defaultPluginPath = getDefaultPluginPath(configDir);
     if (defaultPluginPath) {
         plugins.push(defaultPluginPath);
     }
@@ -119,19 +141,10 @@ async function resolvePlugins(plugins, configPath = '') {
             }
             resolvedPlugins.add(p);
         }
-        const requiredPlugin = await requireFunc(p);
-        const pluginCreatorOptions = { contentDir: path.dirname(configPath) };
-        const pluginModule = (0, utils_2.isDeprecatedPluginFormat)(requiredPlugin)
-            ? requiredPlugin
-            : (0, utils_2.isCommonJsPlugin)(requiredPlugin)
-                ? await requiredPlugin(pluginCreatorOptions)
-                : await requiredPlugin?.default?.(pluginCreatorOptions);
+        const pluginModule = await requireFunc(p);
         if (!pluginModule) {
             return;
         }
-        if ((0, utils_1.isString)(p) && pluginModule.id && (0, utils_2.isDeprecatedPluginFormat)(requiredPlugin)) {
-            logger_1.logger.info(`Deprecated plugin format detected: ${pluginModule.id}\n`);
-        }
         const id = pluginModule.id;
         if (typeof id !== 'string') {
             throw new Error(logger_1.colorize.red(`Plugin must define \`id\` property in ${logger_1.colorize.blue(p.toString())}.`));
@@ -220,7 +233,10 @@ async function resolvePlugins(plugins, configPath = '') {
         if (pluginModule.assertions) {
             plugin.assertions = pluginModule.assertions;
         }
-        return plugin;
+        return {
+            ...pluginModule,
+            ...plugin,
+        };
     }));
     return instances.filter(utils_1.isDefined);
 }
@@ -248,7 +264,7 @@ async function resolveAndMergeNestedStyleguideConfig({ styleguideConfig, configP
     const plugins = env_1.isBrowser
         ? // In browser, we don't support plugins from config file yet
             [builtIn_1.defaultPlugin]
-        : (0, utils_2.getUniquePlugins)(await resolvePlugins([...(styleguideConfig?.plugins || []), builtIn_1.defaultPlugin], configPath));
+        : (0, utils_2.getUniquePlugins)(await resolvePlugins([...(styleguideConfig?.plugins || []), builtIn_1.defaultPlugin], path.dirname(configPath)));
     const pluginPaths = styleguideConfig?.plugins
         ?.filter(utils_1.isString)
         .map((p) => path.resolve(path.dirname(configPath), p));

package/lib/config/config.js

@@ -38,7 +38,10 @@ class StyleguideConfig {
             [oas_types_1.SpecVersion.OAS3_1]: { ...rawConfig.rules, ...rawConfig.oas3_1Rules },
             [oas_types_1.SpecVersion.Async2]: { ...rawConfig.rules, ...rawConfig.async2Rules },
             [oas_types_1.SpecVersion.Async3]: { ...rawConfig.rules, ...rawConfig.async3Rules },
-            [oas_types_1.SpecVersion.Arazzo]: { ...rawConfig.arazzoRules },
+            [oas_types_1.SpecVersion.Arazzo]: {
+                ...rawConfig.arazzoRules,
+                ...(rawConfig.rules?.assertions ? { assertions: rawConfig.rules.assertions } : {}),
+            },
         };
         this.preprocessors = {
             [oas_types_1.SpecVersion.OAS2]: { ...rawConfig.preprocessors, ...rawConfig.oas2Preprocessors },

package/lib/config/minimal.js

@@ -121,6 +121,9 @@ const minimal = {
         'step-onSuccess-unique': 'off',
         'step-onFailure-unique': 'off',
         'requestBody-replacements-unique': 'off',
+        'no-criteria-xpath': 'off',
+        'no-actions-type-end': 'off',
+        'criteria-unique': 'off',
     },
 };
 exports.default = minimal;

package/lib/config/recommended-strict.js

@@ -121,6 +121,9 @@ const recommendedStrict = {
         'step-onSuccess-unique': 'error',
         'step-onFailure-unique': 'error',
         'requestBody-replacements-unique': 'error',
+        'no-criteria-xpath': 'error',
+        'no-actions-type-end': 'error',
+        'criteria-unique': 'error',
     },
 };
 exports.default = recommendedStrict;

package/lib/config/recommended.js

@@ -121,6 +121,9 @@ const recommended = {
         'step-onSuccess-unique': 'warn',
         'step-onFailure-unique': 'warn',
         'requestBody-replacements-unique': 'warn',
+        'no-criteria-xpath': 'warn',
+        'no-actions-type-end': 'warn',
+        'criteria-unique': 'warn',
     },
 };
 exports.default = recommended;

package/lib/config/types.d.ts

@@ -4,6 +4,7 @@ import type { Oas3PreprocessorsSet, SpecMajorVersion, Oas3DecoratorsSet, Oas2Rul
 import type { NodeType } from '../types';
 import type { SkipFunctionContext } from '../visitors';
 import type { BuiltInAsync2RuleId, BuiltInAsync3RuleId, BuiltInCommonOASRuleId, BuiltInOAS2RuleId, BuiltInOAS3RuleId, BuiltInArazzoRuleId } from '../types/redocly-yaml';
+import type { JSONSchema } from 'json-schema-to-ts';
 export type RuleSeverity = ProblemSeverity | 'off';
 export type RuleSettings = {
     severity: RuleSeverity;
@@ -91,6 +92,15 @@ export type Plugin = {
     decorators?: DecoratorsConfig;
     typeExtension?: TypeExtensionsConfig;
     assertions?: AssertionsConfig;
+    path?: string;
+    absolutePath?: string;
+    processContent?: (actions: any, content: any) => Promise<void> | void;
+    afterRoutesCreated?: (actions: any, content: any) => Promise<void> | void;
+    loaders?: Record<string, (path: string, context: any, reportError: (error: Error) => void) => Promise<unknown>>;
+    requiredEntitlements?: string[];
+    ssoConfigSchema?: JSONSchema;
+    redoclyConfigSchema?: JSONSchema;
+    ejectIgnore?: string[];
 };
 type PluginCreatorOptions = {
     contentDir: string;

package/lib/rules/arazzo/criteria-unique.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const CriteriaUnique: ArazzoRule;

package/lib/rules/arazzo/criteria-unique.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CriteriaUnique = void 0;
+const CriteriaUnique = () => {
+    return {
+        FailureActionObject: {
+            enter(action, { report, location }) {
+                const criterias = action.criteria;
+                const seen = new Set();
+                for (const criteria of criterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The FailureAction criteria items must be unique.',
+                            location: location.child(['criteria', criterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+        SuccessActionObject: {
+            enter(action, { report, location }) {
+                const criterias = action.criteria;
+                const seen = new Set();
+                for (const criteria of criterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The SuccessAction criteria items must be unique.',
+                            location: location.child(['criteria', criterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+        Step: {
+            enter(step, { report, location }) {
+                if (!step.successCriteria) {
+                    return;
+                }
+                const successCriterias = step.successCriteria;
+                const seen = new Set();
+                for (const criteria of successCriterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The Step SuccessCriteria items must be unique.',
+                            location: location.child(['successCriteria', successCriterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+    };
+};
+exports.CriteriaUnique = CriteriaUnique;

package/lib/rules/arazzo/index.js

@@ -14,6 +14,9 @@ const parameters_unique_1 = require("./parameters-unique");
 const step_onSuccess_unique_1 = require("./step-onSuccess-unique");
 const step_onFailure_unique_1 = require("./step-onFailure-unique");
 const requestBody_replacements_unique_1 = require("./requestBody-replacements-unique");
+const no_criteria_xpath_1 = require("../spot/no-criteria-xpath");
+const no_actions_type_end_1 = require("../spot/no-actions-type-end");
+const criteria_unique_1 = require("./criteria-unique");
 exports.rules = {
     spec: spec_1.Spec,
     assertions: assertions_1.Assertions,
@@ -28,5 +31,8 @@ exports.rules = {
     'step-onSuccess-unique': step_onSuccess_unique_1.StepOnSuccessUnique,
     'step-onFailure-unique': step_onFailure_unique_1.StepOnFailureUnique,
     'requestBody-replacements-unique': requestBody_replacements_unique_1.RequestBodyReplacementsUnique,
+    'no-criteria-xpath': no_criteria_xpath_1.NoCriteriaXpath,
+    'no-actions-type-end': no_actions_type_end_1.NoActionsTypeEnd,
+    'criteria-unique': criteria_unique_1.CriteriaUnique,
 };
 exports.preprocessors = {};

package/lib/rules/spot/no-actions-type-end.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const NoActionsTypeEnd: ArazzoRule;

package/lib/rules/spot/no-actions-type-end.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoActionsTypeEnd = void 0;
+const NoActionsTypeEnd = () => {
+    return {
+        FailureActionObject: {
+            enter(action, { report, location }) {
+                if (action.type === 'end') {
+                    report({
+                        message: 'The `end` type action is not supported by Spot.',
+                        location: location.child(['type']),
+                    });
+                }
+            },
+        },
+        SuccessActionObject: {
+            enter(action, { report, location }) {
+                if (action.type === 'end') {
+                    report({
+                        message: 'The `end` type action is not supported by Spot.',
+                        location: location.child(['type']),
+                    });
+                }
+            },
+        },
+    };
+};
+exports.NoActionsTypeEnd = NoActionsTypeEnd;

package/lib/rules/spot/no-criteria-xpath.d.ts

@@ -0,0 +1,2 @@
+import type { ArazzoRule } from '../../visitors';
+export declare const NoCriteriaXpath: ArazzoRule;

package/lib/rules/spot/no-criteria-xpath.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoCriteriaXpath = void 0;
+const NoCriteriaXpath = () => {
+    return {
+        CriterionObject: {
+            enter(criteria, { report, location }) {
+                if (!criteria.type) {
+                    return;
+                }
+                if (criteria?.type?.type === 'xpath' || criteria?.type === 'xpath') {
+                    report({
+                        message: 'The `xpath` type criteria is not supported by Spot.',
+                        location: location.child(['type']),
+                    });
+                }
+            },
+        },
+    };
+};
+exports.NoCriteriaXpath = NoCriteriaXpath;

package/lib/types/arazzo.js

@@ -212,7 +212,7 @@ const CriterionObject = {
             else if (typeof value === 'string') {
                 return { enum: ['regex', 'jsonpath', 'simple', 'xpath'] };
             }
-            else if (value.type === 'jsonpath') {
+            else if (value?.type === 'jsonpath') {
                 return 'JSONPathCriterion';
             }
             else {

package/lib/types/redocly-yaml.d.ts

@@ -11,7 +11,7 @@ declare const builtInAsync2Rules: readonly ["spec", "info-contact", "info-licens
 declare const builtInAsync3Rules: readonly ["spec", "info-contact", "info-license-strict", "operation-operationId", "tag-description", "tags-alphabetical", "channels-kebab-case", "no-channel-trailing-slash"];
 export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
 export type BuiltInAsync3RuleId = typeof builtInAsync3Rules[number];
-declare const builtInArazzoRules: readonly ["spec", "parameters-not-in-body", "sourceDescription-type", "version-enum", "workflowId-unique", "stepId-unique", "sourceDescription-name-unique", "workflow-dependsOn", "parameters-unique", "step-onSuccess-unique", "step-onFailure-unique", "requestBody-replacements-unique"];
+declare const builtInArazzoRules: readonly ["spec", "parameters-not-in-body", "sourceDescription-type", "version-enum", "workflowId-unique", "stepId-unique", "sourceDescription-name-unique", "workflow-dependsOn", "parameters-unique", "step-onSuccess-unique", "step-onFailure-unique", "requestBody-replacements-unique", "no-criteria-xpath", "no-actions-type-end", "criteria-unique"];
 export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];
 declare const oas2NodeTypesList: readonly ["Root", "Tag", "TagList", "ExternalDocs", "SecurityRequirement", "SecurityRequirementList", "Info", "Contact", "License", "Paths", "PathItem", "Parameter", "ParameterList", "ParameterItems", "Operation", "Example", "ExamplesMap", "Examples", "Header", "Responses", "Response", "Schema", "Xml", "SchemaProperties", "NamedSchemas", "NamedResponses", "NamedParameters", "NamedSecuritySchemes", "SecurityScheme", "TagGroup", "TagGroups", "EnumDescriptions", "Logo", "XCodeSample", "XCodeSampleList", "XServer", "XServerList"];
 export type Oas2NodeType = typeof oas2NodeTypesList[number];

package/lib/types/redocly-yaml.js

@@ -106,6 +106,9 @@ const builtInArazzoRules = [
     'step-onSuccess-unique',
     'step-onFailure-unique',
     'requestBody-replacements-unique',
+    'no-criteria-xpath',
+    'no-actions-type-end',
+    'criteria-unique',
 ];
 const builtInRules = [
     ...builtInCommonOASRules,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.23.1",
+  "version": "1.25.0",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -35,7 +35,7 @@
     "Roman Hotsiy <roman@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
-    "@redocly/ajv": "^8.11.0",
+    "@redocly/ajv": "^8.11.2",
     "@redocly/config": "^0.10.1",
     "colorette": "^1.2.0",
     "https-proxy-agent": "^7.0.4",

package/src/config/__tests__/__snapshots__/config-resolvers.test.ts.snap

@@ -5,6 +5,9 @@ exports[`resolveConfig should ignore minimal from the root and read local file 1
   "arazzoDecorators": {},
   "arazzoPreprocessors": {},
   "arazzoRules": {
+    "criteria-unique": "warn",
+    "no-actions-type-end": "warn",
+    "no-criteria-xpath": "warn",
     "parameters-not-in-body": "warn",
     "parameters-unique": "error",
     "requestBody-replacements-unique": "warn",
@@ -147,6 +150,9 @@ exports[`resolveStyleguideConfig should resolve extends with local file config w
   "arazzoDecorators": {},
   "arazzoPreprocessors": {},
   "arazzoRules": {
+    "criteria-unique": "warn",
+    "no-actions-type-end": "warn",
+    "no-criteria-xpath": "warn",
     "parameters-not-in-body": "warn",
     "parameters-unique": "error",
     "requestBody-replacements-unique": "warn",

package/src/config/__tests__/config-resolvers.test.ts

@@ -1,3 +1,4 @@
+import * as util from 'util';
 import { colorize } from '../../logger';
 import { Asserts, asserts } from '../../rules/common/assertions/asserts';
 import { resolveStyleguideConfig, resolveApis, resolveConfig } from '../config-resolvers';
@@ -91,6 +92,59 @@ describe('resolveStyleguideConfig', () => {
     });
   });
 
+  it('should instantiate the plugin once', async () => {
+    // Called by plugin during init
+    const deprecateSpy = jest.spyOn(util, 'deprecate');
+
+    const config = {
+      ...baseStyleguideConfig,
+      extends: ['local-config-with-plugin-init.yaml'],
+    };
+
+    await resolveStyleguideConfig({
+      styleguideConfig: config,
+      configPath,
+    });
+
+    expect(deprecateSpy).toHaveBeenCalledTimes(1);
+
+    await resolveStyleguideConfig({
+      styleguideConfig: config,
+      configPath,
+    });
+
+    // Should not execute the init logic again
+    expect(deprecateSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should resolve realm plugin properties', async () => {
+    const config = {
+      ...baseStyleguideConfig,
+      extends: ['local-config-with-realm-plugin.yaml'],
+    };
+
+    const { plugins } = await resolveStyleguideConfig({
+      styleguideConfig: config,
+      configPath,
+    });
+
+    const localPlugin = plugins?.find((p) => p.id === 'realm-plugin');
+    expect(localPlugin).toBeDefined();
+
+    expect(localPlugin).toMatchObject({
+      id: 'realm-plugin',
+      processContent: expect.any(Function),
+      afterRoutesCreated: expect.any(Function),
+      loaders: {
+        'test-loader': expect.any(Function),
+      },
+      requiredEntitlements: ['test-entitlement'],
+      ssoConfigSchema: { type: 'object', additionalProperties: true },
+      redoclyConfigSchema: { type: 'object', additionalProperties: false },
+      ejectIgnore: ['Navbar.tsx', 'Footer.tsx'],
+    });
+  });
+
   it('should resolve local file config with esm plugin', async () => {
     const config = {
       ...baseStyleguideConfig,

package/src/config/__tests__/fixtures/resolve-config/local-config-with-plugin-init.yaml

@@ -0,0 +1,2 @@
+plugins:
+  - plugin-with-init-logic.js

package/src/config/__tests__/fixtures/resolve-config/local-config-with-realm-plugin.yaml

@@ -0,0 +1,2 @@
+plugins:
+  - realm-plugin.js

package/src/config/__tests__/fixtures/resolve-config/plugin-with-init-logic.js

@@ -0,0 +1,9 @@
+var util = require('util');
+
+module.exports = function pluginWithInitLogic() {
+  util.deprecate(() => null);
+
+  return {
+    id: 'test-plugin',
+  };
+};

package/src/config/__tests__/fixtures/resolve-config/realm-plugin.js

@@ -0,0 +1,12 @@
+module.exports = function realmPlugin() {
+  return {
+    id: 'realm-plugin',
+    processContent: () => {},
+    afterRoutesCreated: () => {},
+    loaders: { 'test-loader': () => {} },
+    requiredEntitlements: ['test-entitlement'],
+    ssoConfigSchema: { type: 'object', additionalProperties: true },
+    redoclyConfigSchema: { type: 'object', additionalProperties: false },
+    ejectIgnore: ['Navbar.tsx', 'Footer.tsx'],
+  };
+};

package/src/config/all.ts

@@ -139,6 +139,9 @@ const all: PluginStyleguideConfig<'built-in'> = {
     'step-onSuccess-unique': 'error',
     'step-onFailure-unique': 'error',
     'requestBody-replacements-unique': 'error',
+    'no-criteria-xpath': 'error',
+    'no-actions-type-end': 'error',
+    'criteria-unique': 'error',
   },
 };