@redocly/openapi-core 1.0.0-beta.49 → 1.0.0-beta.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.49",
+  "version": "1.0.0-beta.53",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -30,22 +30,22 @@
     "Andriy Leliv <andriy@redoc.ly> (https://redoc.ly/)"
   ],
   "dependencies": {
+    "@redocly/ajv": "^8.6.2",
     "@types/node": "^14.11.8",
     "colorette": "^1.2.0",
+    "js-levenshtein": "^1.1.6",
     "js-yaml": "^3.14.1",
-    "yaml-ast-parser": "0.0.43",
+    "lodash.isequal": "^4.5.0",
     "minimatch": "^3.0.4",
     "node-fetch": "^2.6.1",
-    "js-levenshtein": "^1.1.6",
-    "@redocly/ajv": "^6.12.3",
-    "lodash.isequal": "^4.5.0"
+    "yaml-ast-parser": "0.0.43"
   },
   "devDependencies": {
+    "@types/js-levenshtein": "^1.1.0",
     "@types/js-yaml": "^3.12.4",
+    "@types/lodash.isequal": "^4.5.5",
     "@types/minimatch": "^3.0.3",
     "@types/node-fetch": "^2.5.7",
-    "@types/js-levenshtein": "^1.1.0",
-    "@types/lodash.isequal": "^4.5.5",
     "typescript": "^4.0.5"
   }
 }

package/src/__tests__/lint.test.ts

@@ -0,0 +1,44 @@
+import { outdent } from 'outdent';
+
+import { lintFromString } from '../lint';
+import { loadConfig } from '../config/load';
+import { replaceSourceWithRef } from '../../__tests__/utils';
+
+describe('lint', () => {
+  it('lintFromString should work', async () => {
+    const results = await lintFromString({
+      absoluteRef: '/test/spec.yaml',
+      source: outdent`
+      openapi: 3.0.0
+      info:
+        title: Test API
+        version: "1.0"
+        description: Test
+        license: Fail
+
+      servers:
+        - url: http://example.com
+      paths: {}
+    `,
+      config: await loadConfig(),
+    });
+
+    expect(replaceSourceWithRef(results)).toMatchInlineSnapshot(`
+      Array [
+        Object {
+          "location": Array [
+            Object {
+              "pointer": "#/info/license",
+              "reportOnKey": false,
+              "source": "/test/spec.yaml",
+            },
+          ],
+          "message": "Expected type \`License\` (object) but got \`string\`",
+          "ruleId": "spec",
+          "severity": "error",
+          "suggest": Array [],
+        },
+      ]
+    `);
+  });
+});

package/src/benchmark/benches/recommended-oas3.bench.ts

@@ -4,6 +4,7 @@ import { lintDocument } from '../../lint';
 import { LintConfig } from '../../config/config';
 import { BaseResolver } from '../../resolve';
 import { parseYamlToDocument } from '../utils';
+import { defaultPlugin } from '../../config/builtIn';
 
 export const name = 'Validate with recommended rules';
 export const count = 10;
@@ -17,6 +18,6 @@ export function measureAsync() {
   return lintDocument({
     externalRefResolver: new BaseResolver(),
     document: rebillyDocument,
-    config: new LintConfig({}),
+    config: new LintConfig({ plugins: [defaultPlugin] }),
   });
 }

package/src/benchmark/benchmark.js

@@ -30,7 +30,9 @@ function prepareRevision(revision) {
   // Returns the complete git hash for a given git revision reference.
   const hash = exec(`git rev-parse "${revision}"`);
   const dir = path.join(os.tmpdir(), 'openapi-cli-benchmark', hash);
-  fs.rmdirSync(dir, { recursive: true });
+  if (fs.existsSync(dir)) {
+    fs.rmdirSync(dir, { recursive: true});
+  }
   fs.mkdirSync(dir, { recursive: true });
 
   exec(`git archive "${hash}" | tar -xC "${dir}"`);

package/src/benchmark/utils.ts

@@ -1,6 +1,6 @@
 import * as yaml from 'js-yaml';
 import { Document, Source } from '../resolve';
-import { Oas3RuleSet } from '../lint';
+import { Oas3RuleSet } from '../oas-types';
 import { RuleConfig, LintConfig, Plugin } from '../config/config';
 
 export function parseYamlToDocument(body: string, absoluteRef: string = ''): Document {

package/src/bundle.ts

@@ -6,9 +6,9 @@ import { Oas2Types } from './types/oas2';
 import { Oas3_1Types } from './types/oas3_1';
 import { NormalizedNodeType, normalizeTypes, NodeType } from './types';
 import { WalkContext, walkDocument, UserContext, ResolveResult } from './walk';
-import { detectOpenAPI, openAPIMajor, OasMajorVersion } from './lint';
+import { detectOpenAPI, openAPIMajor, OasMajorVersion } from './oas-types';
 import { Location, refBaseName } from './ref-utils';
-import { Config, LintConfig } from './config/config';
+import type { Config, LintConfig } from './config/config';
 import { initRules } from './config/rules';
 import { reportUnresolvedRef } from './rules/no-unresolved-refs';
 import { isPlainObject } from './utils';

package/src/config/__tests__/resolve-plugins.test.ts

@@ -1,5 +1,5 @@
 import * as path from 'path';
-import { loadConfig } from '../config';
+import { loadConfig } from '../load';
 
 describe('resolving a plugin', () => {
   const configPath = path.join(__dirname, 'fixtures/plugin-config.yaml');

package/src/config/builtIn.ts

@@ -1,7 +1,9 @@
 import recommended from './recommended';
 import all from './all';
 import minimal from './minimal';
-import { LintRawConfig } from './config';
+import { LintRawConfig, Plugin } from './config';
+
+import * as builtinRules from '../rules/builtin';
 
 export const builtInConfigs: Record<string, LintRawConfig> = {
   recommended,
@@ -11,3 +13,11 @@ export const builtInConfigs: Record<string, LintRawConfig> = {
     decorators: { 'registry-dependencies': 'on' }
   }
 };
+
+export const defaultPlugin: Plugin = {
+  id: '', // default plugin doesn't have id
+  rules: builtinRules.rules,
+  preprocessors: builtinRules.preprocessors,
+  decorators: builtinRules.decorators,
+  configs: builtInConfigs,
+}

package/src/config/config.ts

@@ -3,9 +3,8 @@ import * as path from 'path';
 import * as yaml from 'js-yaml';
 import { dirname } from 'path';
 import { red, blue } from 'colorette';
-import { builtInConfigs } from './builtIn';
-import * as builtinRules from '../rules/builtin';
-import { loadYaml, notUndefined } from '../utils';
+
+import { notUndefined } from '../utils';
 
 import {
   OasVersion,
@@ -15,14 +14,13 @@ import {
   Oas2RuleSet,
   Oas2PreprocessorsSet,
   Oas2DecoratorsSet,
-} from '../lint';
+  Oas3RuleSet
+} from '../oas-types';
 
 import { ProblemSeverity, NormalizedProblem } from '../walk';
-import { Oas3RuleSet } from '../lint';
 
 import recommended from './recommended';
 import { NodeType } from '../types';
-import { RedoclyClient } from '../redocly';
 
 export const IGNORE_FILE = '.redocly.lint-ignore.yaml';
 const IGNORE_BANNER =
@@ -149,13 +147,6 @@ export class LintConfig {
     this.plugins = rawConfig.plugins ? resolvePlugins(rawConfig.plugins, configFile) : [];
     this.doNotResolveExamples = !!rawConfig.doNotResolveExamples;
 
-    this.plugins.push({
-      id: '', // default plugin doesn't have id
-      rules: builtinRules.rules,
-      preprocessors: builtinRules.preprocessors,
-      decorators: builtinRules.decorators,
-    });
-
     if (!rawConfig.extends) {
       this.recommendedFallback = true;
     }
@@ -192,7 +183,7 @@ export class LintConfig {
       [OasVersion.Version3_1]: { ...merged.decorators, ...merged.oas3_1Decorators },
     };
 
-    const dir = this.configFile ? path.dirname(this.configFile) : process.cwd();
+    const dir = this.configFile ? path.dirname(this.configFile) : (typeof process !== 'undefined' && process.cwd() || '');
     const ignoreFile = path.join(dir, IGNORE_FILE);
 
     /* no crash when using it on the client */
@@ -260,6 +251,7 @@ export class LintConfig {
       if (plugin.typeExtension !== undefined) {
         switch (version) {
           case OasVersion.Version3_0:
+          case OasVersion.Version3_1:
             if (!plugin.typeExtension.oas3) continue;
             extendedTypes = plugin.typeExtension.oas3(extendedTypes, version);
           case OasVersion.Version2:
@@ -405,80 +397,38 @@ export class Config {
   }
 }
 
-export async function loadConfig(configPath?: string, customExtends?: string[]): Promise<Config> {
-  if (configPath === undefined) {
-    configPath = findConfig();
-  }
-  let rawConfig: RawConfig = {};
-  // let resolvedPlugins: Plugin[] = [];
-
-  if (configPath !== undefined) {
-    try {
-      rawConfig = (await loadYaml(configPath)) as RawConfig;
-    } catch (e) {
-      throw new Error(`Error parsing config file at \`${configPath}\`: ${e.message}`);
-    }
-  }
-  if (customExtends !== undefined) {
-    rawConfig.lint = rawConfig.lint || {};
-    rawConfig.lint.extends = customExtends;
-  }
-
-  const redoclyClient = new RedoclyClient();
-  if (redoclyClient.hasToken()) {
-    if (!rawConfig.resolve) rawConfig.resolve = {};
-    if (!rawConfig.resolve.http) rawConfig.resolve.http = {};
-    rawConfig.resolve.http.headers = [
-      {
-        matches: `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry/**`,
-        name: 'Authorization',
-        envVariable: undefined,
-        value: (redoclyClient && (await redoclyClient.getAuthorizationHeader())) || '',
-      },
-      ...(rawConfig.resolve.http.headers ?? []),
-    ];
-  }
-  return new Config(rawConfig, configPath);
-}
-
-function findConfig() {
-  if (fs.existsSync('.redocly.yaml')) {
-    return '.redocly.yaml';
-  } else if (fs.existsSync('.redocly.yml')) {
-    return '.redocly.yml';
-  }
-  return undefined;
-}
-
-
 function resolvePresets(presets: string[], plugins: Plugin[]) {
   return presets.map((presetName) => {
-    let preset = builtInConfigs[presetName];
-    if (!preset && presetName.indexOf('/') > -1) {
-      const [pluginName, configName] = presetName.split('/');
-      const plugin = plugins.find((p) => p.id === pluginName);
-      if (!plugin) {
-        throw new Error(`Invalid config ${red(presetName)}: plugin ${pluginName} is not included.`);
-      }
+    const { pluginId, configName } = parsePresetName(presetName);
 
-      preset = plugin.configs?.[configName]!;
-      if (!preset) {
-        throw new Error(
-          `Invalid config ${red(
-            presetName,
-          )}: plugin ${pluginName} doesn't export config with name ${configName}.`,
-        );
-      }
-      return preset;
+    const plugin = plugins.find((p) => p.id === pluginId);
+    if (!plugin) {
+      throw new Error(`Invalid config ${red(presetName)}: plugin ${pluginId} is not included.`);
     }
 
+    const preset = plugin.configs?.[configName]!;
     if (!preset) {
-      throw new Error(`Invalid config ${red(presetName)}: there is no such built-in config.`);
+      throw new Error(
+        pluginId
+          ? `Invalid config ${red(
+              presetName,
+            )}: plugin ${pluginId} doesn't export config with name ${configName}.`
+          : `Invalid config ${red(presetName)}: there is no such built-in config.`,
+      );
     }
     return preset;
   });
 }
 
+function parsePresetName(presetName: string): { pluginId: string; configName: string } {
+  if (presetName.indexOf('/') > -1) {
+    const [pluginId, configName] = presetName.split('/');
+    return { pluginId, configName };
+  } else {
+    return { pluginId: '', configName: presetName };
+  }
+}
+
 function resolvePlugins(plugins: (string | Plugin)[] | null, configPath: string = ''): Plugin[] {
   if (!plugins) return [];
 
@@ -496,7 +446,7 @@ function resolvePlugins(plugins: (string | Plugin)[] | null, configPath: string
           : p;
 
       const id = pluginModule.id;
-      if (!id) {
+      if (typeof id !== 'string') {
         throw new Error(red(`Plugin must define \`id\` property in ${blue(p.toString())}.`));
       }
 
@@ -565,6 +515,8 @@ function resolvePlugins(plugins: (string | Plugin)[] | null, configPath: string
 }
 
 function prefixRules<T extends Record<string, any>>(rules: T, prefix: string) {
+  if (!prefix) return rules;
+
   const res: any = {};
   for (const name of Object.keys(rules)) {
     res[`${prefix}/${name}`] = rules[name];

package/src/config/load.ts

@@ -0,0 +1,60 @@
+import * as fs from 'fs';
+
+import { RedoclyClient } from '../redocly';
+import { loadYaml } from '../utils';
+import { Config, RawConfig } from './config';
+
+import { defaultPlugin } from './builtIn';
+
+export async function loadConfig(configPath?: string, customExtends?: string[]): Promise<Config> {
+  if (configPath === undefined) {
+    configPath = findConfig();
+  }
+  let rawConfig: RawConfig = {};
+
+  if (configPath !== undefined) {
+    try {
+      rawConfig = (await loadYaml(configPath)) as RawConfig;
+    } catch (e) {
+      throw new Error(`Error parsing config file at \`${configPath}\`: ${e.message}`);
+    }
+  }
+  if (customExtends !== undefined) {
+    rawConfig.lint = rawConfig.lint || {};
+    rawConfig.lint.extends = customExtends;
+  }
+
+  const redoclyClient = new RedoclyClient();
+  if (redoclyClient.hasToken()) {
+    if (!rawConfig.resolve) rawConfig.resolve = {};
+    if (!rawConfig.resolve.http) rawConfig.resolve.http = {};
+    rawConfig.resolve.http.headers = [
+      {
+        matches: `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry/**`,
+        name: 'Authorization',
+        envVariable: undefined,
+        value: (redoclyClient && (await redoclyClient.getAuthorizationHeader())) || '',
+      },
+      ...(rawConfig.resolve.http.headers ?? []),
+    ];
+  }
+  return new Config(
+    {
+      ...rawConfig,
+      lint: {
+        ...rawConfig?.lint,
+        plugins: [...(rawConfig?.lint?.plugins || []), defaultPlugin], // inject default plugin
+      },
+    },
+    configPath,
+  );
+}
+
+function findConfig() {
+  if (fs.existsSync('.redocly.yaml')) {
+    return '.redocly.yaml';
+  } else if (fs.existsSync('.redocly.yml')) {
+    return '.redocly.yml';
+  }
+  return undefined;
+}

package/src/config/rules.ts

@@ -1,4 +1,4 @@
-import { RuleSet, OasVersion } from '../lint';
+import { RuleSet, OasVersion } from '../oas-types';
 import { LintConfig } from './config';
 import { notUndefined } from '../utils';
 

package/src/format/codeframes.ts

@@ -134,7 +134,7 @@ export function getLineColLocation(location: LocationObject): LineColLocationObj
   if (location.pointer === undefined) return location;
 
   const { source, pointer, reportOnKey } = location;
-  const ast = source.getAst() as YAMLNode;
+  const ast = source.getAst(yamlAst.safeLoad) as YAMLNode;
   const astNode = getAstNodeByPointer(ast, pointer, !!reportOnKey);
   return {
     ...location,

package/src/index.ts

@@ -8,14 +8,15 @@ export { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
 
-export { loadConfig, Config, LintConfig, RawConfig, IGNORE_FILE } from './config/config';
+export { Config, LintConfig, RawConfig, IGNORE_FILE } from './config/config';
+export { loadConfig } from './config/load';
 export { RedoclyClient } from './redocly';
 export { Source, BaseResolver, Document, resolveDocument, ResolveError, YamlParseError } from './resolve';
 export { unescapePointer } from './ref-utils';
-export { detectOpenAPI, OasMajorVersion, openAPIMajor } from './lint';
+export { detectOpenAPI, OasMajorVersion, openAPIMajor, OasVersion } from './oas-types';
 export { normalizeVisitors } from './visitors';
 export { WalkContext, walkDocument, NormalizedProblem, ProblemSeverity, LineColLocationObject, LocationObject, Loc } from './walk';
 
 export { formatProblems, OutputFormat, getTotals, Totals } from './format/format';
-export { OasVersion, lint, lint as validate, lintDocument } from './lint';
+export { lint, lint as validate, lintDocument, lintFromString } from './lint';
 export { bundle } from './bundle';

package/src/lint.ts

@@ -1,10 +1,6 @@
-import { BaseResolver, resolveDocument, Document } from './resolve';
+import { BaseResolver, resolveDocument, Document, makeDocumentFromString } from './resolve';
 import {
-  Oas3Rule,
   normalizeVisitors,
-  Oas3Preprocessor,
-  Oas2Rule,
-  Oas2Preprocessor,
 } from './visitors';
 import { Oas3_1Types } from './types/oas3_1';
 import { Oas3Types } from './types/oas3';
@@ -15,25 +11,7 @@ import { LintConfig, Config } from './config/config';
 import { normalizeTypes } from './types';
 import { initRules } from './config/rules';
 import { releaseAjvInstance } from './rules/ajv';
-
-export enum OasVersion {
-  Version2 = 'oas2',
-  Version3_0 = 'oas3_0',
-  Version3_1 = 'oas3_1',
-}
-
-export enum OasMajorVersion {
-  Version2 = 'oas2',
-  Version3 = 'oas3',
-}
-
-export type RuleSet<T> = Record<string, T>;
-export type Oas3RuleSet = Record<string, Oas3Rule>;
-export type Oas2RuleSet = Record<string, Oas2Rule>;
-export type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
-export type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
-export type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
-export type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
+import { detectOpenAPI, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
 
 export async function lint(opts: {
   ref: string;
@@ -51,6 +29,23 @@ export async function lint(opts: {
   });
 }
 
+export async function lintFromString(opts: {
+  source: string;
+  absoluteRef?: string;
+  config: Config;
+  externalRefResolver?: BaseResolver;
+}) {
+  const { source, absoluteRef, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
+  const document = makeDocumentFromString(source, absoluteRef || '/');
+
+  return lintDocument({
+    document,
+    ...opts,
+    externalRefResolver,
+    config: opts.config.lint,
+  });
+}
+
 export async function lintDocument(opts: {
   document: Document;
   config: LintConfig;
@@ -94,35 +89,3 @@ export async function lintDocument(opts: {
   });
   return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
 }
-
-export function detectOpenAPI(root: any): OasVersion {
-  if (typeof root !== 'object') {
-    throw new Error(`Document must be JSON object, got ${typeof root}`);
-  }
-
-  if (!(root.openapi || root.swagger)) {
-    throw new Error('This doesn’t look like an OpenAPI document.\n');
-  }
-
-  if (root.openapi && root.openapi.startsWith('3.0')) {
-    return OasVersion.Version3_0;
-  }
-
-  if (root.openapi && root.openapi.startsWith('3.1')) {
-    return OasVersion.Version3_1;
-  }
-
-  if (root.swagger && root.swagger === '2.0') {
-    return OasVersion.Version2;
-  }
-
-  throw new Error(`Unsupported OpenAPI Version: ${root.openapi || root.swagger}`);
-}
-
-export function openAPIMajor(version: OasVersion): OasMajorVersion {
-  if (version === OasVersion.Version2) {
-    return OasMajorVersion.Version2;
-  } else {
-    return OasMajorVersion.Version3;
-  }
-}

package/src/oas-types.ts

@@ -0,0 +1,58 @@
+import {
+  Oas3Rule,
+  Oas3Preprocessor,
+  Oas2Rule,
+  Oas2Preprocessor,
+} from './visitors';
+
+export type RuleSet<T> = Record<string, T>;
+
+export enum OasVersion {
+  Version2 = 'oas2',
+  Version3_0 = 'oas3_0',
+  Version3_1 = 'oas3_1',
+}
+
+export enum OasMajorVersion {
+  Version2 = 'oas2',
+  Version3 = 'oas3',
+}
+
+export type Oas3RuleSet = Record<string, Oas3Rule>;
+export type Oas2RuleSet = Record<string, Oas2Rule>;
+export type Oas3PreprocessorsSet = Record<string, Oas3Preprocessor>;
+export type Oas2PreprocessorsSet = Record<string, Oas2Preprocessor>;
+export type Oas3DecoratorsSet = Record<string, Oas3Preprocessor>;
+export type Oas2DecoratorsSet = Record<string, Oas2Preprocessor>;
+
+export function detectOpenAPI(root: any): OasVersion {
+  if (typeof root !== 'object') {
+    throw new Error(`Document must be JSON object, got ${typeof root}`);
+  }
+
+  if (!(root.openapi || root.swagger)) {
+    throw new Error('This doesn’t look like an OpenAPI document.\n');
+  }
+
+  if (root.openapi && root.openapi.startsWith('3.0')) {
+    return OasVersion.Version3_0;
+  }
+
+  if (root.openapi && root.openapi.startsWith('3.1')) {
+    return OasVersion.Version3_1;
+  }
+
+  if (root.swagger && root.swagger === '2.0') {
+    return OasVersion.Version2;
+  }
+
+  throw new Error(`Unsupported OpenAPI Version: ${root.openapi || root.swagger}`);
+}
+
+export function openAPIMajor(version: OasVersion): OasMajorVersion {
+  if (version === OasVersion.Version2) {
+    return OasMajorVersion.Version2;
+  } else {
+    return OasMajorVersion.Version3;
+  }
+}

package/src/resolve.ts

@@ -4,7 +4,7 @@ import * as url from 'url';
 import * as yaml from 'js-yaml';
 import { OasRef } from './typings/openapi';
 import { isRef, joinPointer, escapePointer, parseRef, isAbsoluteUrl } from './ref-utils';
-import { safeLoad as safeLoadToAst, YAMLNode, Kind } from 'yaml-ast-parser';
+import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
 import { NormalizedNodeType, isNamedType } from './types';
 import { readFileFromUrl } from './utils';
 import { ResolveConfig } from './config/config';
@@ -17,14 +17,15 @@ export class Source {
   private _ast: YAMLNode | undefined;
   private _lines: string[] | undefined;
 
-  getAst() {
+  // pass safeLoad as argument to separate it from browser bundle
+  getAst(safeLoad: (input: string, options?: LoadOptions | undefined) => YAMLNode) {
     if (this._ast === undefined) {
-      this._ast = safeLoadToAst(this.body, { filename: this.absoluteRef }) ?? undefined;
+      this._ast = safeLoad(this.body, { filename: this.absoluteRef }) ?? undefined;
 
       // fix ast representation of file with newlines only
       if (
         this._ast &&
-        this._ast.kind === Kind.SCALAR &&
+        this._ast.kind === 0 && // KIND.scalar = 0
         this._ast.value === '' &&
         this._ast.startPosition !== 1
       ) {
@@ -73,6 +74,18 @@ export type Document = {
   parsed: any;
 };
 
+export function makeDocumentFromString(sourceString: string, absoluteRef: string) {
+  const source = new Source(absoluteRef, sourceString);
+  try {
+    return {
+      source,
+      parsed: yaml.safeLoad(sourceString, { filename: absoluteRef }),
+    };
+  } catch (e) {
+    throw new YamlParseError(e, source);
+  }
+}
+
 export class BaseResolver {
   cache: Map<string, Promise<Document | ResolveError>> = new Map();
 

package/src/rules/__tests__/config.ts

@@ -0,0 +1,10 @@
+import { LintConfig, RuleConfig } from "../../config/config";
+import { defaultPlugin } from '../../config/builtIn';
+
+export function makeConfig(rules: Record<string, RuleConfig>) {
+  return new LintConfig({
+    plugins: [defaultPlugin],
+    extends: [],
+    rules
+  });
+}