@redocly/openapi-core 1.0.0-beta.100

package/src/config/config-resolvers.ts

@@ -0,0 +1,359 @@
+import * as path from 'path';
+import { blue, red } from 'colorette';
+import { isAbsoluteUrl } from '../ref-utils';
+import { BaseResolver } from '../resolve';
+import { defaultPlugin } from './builtIn';
+import {
+  getResolveConfig,
+  getUniquePlugins,
+  mergeExtends,
+  parsePresetName,
+  prefixRules,
+  transformConfig,
+} from './utils';
+import type {
+  LintRawConfig,
+  Plugin,
+  RawConfig,
+  ResolvedApi,
+  ResolvedLintConfig,
+  RuleConfig,
+} from './types';
+import { isNotString, isString, notUndefined, parseYaml } from '../utils';
+import { Config } from './config';
+
+export async function resolveConfig(rawConfig: RawConfig, configPath?: string) {
+  if (rawConfig.lint?.extends?.some(isNotString)) {
+    throw new Error(
+      `Error configuration format not detected in extends value must contain strings`,
+    );
+  }
+
+  const resolver = new BaseResolver(getResolveConfig(rawConfig.resolve));
+  const configExtends = rawConfig?.lint?.extends ?? ['recommended'];
+  const recommendedFallback = !rawConfig?.lint?.extends;
+  const lintConfig = {
+    ...rawConfig?.lint,
+    extends: configExtends,
+    recommendedFallback,
+  };
+
+  const apis = await resolveApis({
+    rawConfig: {
+      ...rawConfig,
+      lint: lintConfig,
+    },
+    configPath,
+    resolver,
+  });
+
+  const lint = await resolveLint({
+    lintConfig,
+    configPath,
+    resolver,
+  });
+
+  return new Config(
+    {
+      ...rawConfig,
+      apis,
+      lint,
+    },
+    configPath,
+  );
+}
+
+export function resolvePlugins(
+  plugins: (string | Plugin)[] | null,
+  configPath: string = '',
+): Plugin[] {
+  if (!plugins) return [];
+
+  // @ts-ignore
+  const requireFunc = typeof __webpack_require__ === 'function' ? __non_webpack_require__ : require;
+
+  const seenPluginIds = new Map<string, string>();
+
+  return plugins
+    .map((p) => {
+      if (isString(p) && isAbsoluteUrl(p)) {
+        throw new Error(red(`We don't support remote plugins yet.`));
+      }
+
+      // TODO: resolve npm packages similar to eslint
+      const pluginModule = isString(p)
+        ? (requireFunc(path.resolve(path.dirname(configPath), p)) as Plugin)
+        : p;
+
+      const id = pluginModule.id;
+      if (typeof id !== 'string') {
+        throw new Error(red(`Plugin must define \`id\` property in ${blue(p.toString())}.`));
+      }
+
+      if (seenPluginIds.has(id)) {
+        const pluginPath = seenPluginIds.get(id)!;
+        throw new Error(
+          red(
+            `Plugin "id" must be unique. Plugin ${blue(p.toString())} uses id "${blue(
+              id,
+            )}" already seen in ${blue(pluginPath)}`,
+          ),
+        );
+      }
+
+      seenPluginIds.set(id, p.toString());
+
+      const plugin: Plugin = {
+        id,
+        ...(pluginModule.configs ? { configs: pluginModule.configs } : {}),
+        ...(pluginModule.typeExtension ? { typeExtension: pluginModule.typeExtension } : {}),
+      };
+
+      if (pluginModule.rules) {
+        if (!pluginModule.rules.oas3 && !pluginModule.rules.oas2) {
+          throw new Error(`Plugin rules must have \`oas3\` or \`oas2\` rules "${p}.`);
+        }
+        plugin.rules = {};
+        if (pluginModule.rules.oas3) {
+          plugin.rules.oas3 = prefixRules(pluginModule.rules.oas3, id);
+        }
+        if (pluginModule.rules.oas2) {
+          plugin.rules.oas2 = prefixRules(pluginModule.rules.oas2, id);
+        }
+      }
+      if (pluginModule.preprocessors) {
+        if (!pluginModule.preprocessors.oas3 && !pluginModule.preprocessors.oas2) {
+          throw new Error(
+            `Plugin \`preprocessors\` must have \`oas3\` or \`oas2\` preprocessors "${p}.`,
+          );
+        }
+        plugin.preprocessors = {};
+        if (pluginModule.preprocessors.oas3) {
+          plugin.preprocessors.oas3 = prefixRules(pluginModule.preprocessors.oas3, id);
+        }
+        if (pluginModule.preprocessors.oas2) {
+          plugin.preprocessors.oas2 = prefixRules(pluginModule.preprocessors.oas2, id);
+        }
+      }
+
+      if (pluginModule.decorators) {
+        if (!pluginModule.decorators.oas3 && !pluginModule.decorators.oas2) {
+          throw new Error(`Plugin \`decorators\` must have \`oas3\` or \`oas2\` decorators "${p}.`);
+        }
+        plugin.decorators = {};
+        if (pluginModule.decorators.oas3) {
+          plugin.decorators.oas3 = prefixRules(pluginModule.decorators.oas3, id);
+        }
+        if (pluginModule.decorators.oas2) {
+          plugin.decorators.oas2 = prefixRules(pluginModule.decorators.oas2, id);
+        }
+      }
+
+      return plugin;
+    })
+    .filter(notUndefined);
+}
+
+export async function resolveApis({
+  rawConfig,
+  configPath = '',
+  resolver,
+}: {
+  rawConfig: RawConfig;
+  configPath?: string;
+  resolver?: BaseResolver;
+}): Promise<Record<string, ResolvedApi>> {
+  const { apis = {}, lint: lintConfig = {} } = rawConfig;
+  let resolvedApis: Record<string, ResolvedApi> = {};
+  for (const [apiName, apiContent] of Object.entries(apis || {})) {
+    if (apiContent.lint?.extends?.some(isNotString)) {
+      throw new Error(
+        `Error configuration format not detected in extends value must contain strings`,
+      );
+    }
+    const rawLintConfig = getMergedLintRawConfig(lintConfig, apiContent.lint);
+    const apiLint = await resolveLint({
+      lintConfig: rawLintConfig,
+      configPath,
+      resolver,
+    });
+    resolvedApis[apiName] = { ...apiContent, lint: apiLint };
+  }
+  return resolvedApis;
+}
+
+async function resolveAndMergeNestedLint(
+  {
+    lintConfig,
+    configPath = '',
+    resolver = new BaseResolver(),
+  }: {
+    lintConfig?: LintRawConfig;
+    configPath?: string;
+    resolver?: BaseResolver;
+  },
+  parentConfigPaths: string[] = [],
+  extendPaths: string[] = [],
+): Promise<ResolvedLintConfig> {
+  if (parentConfigPaths.includes(configPath)) {
+    throw new Error(`Circular dependency in config file: "${configPath}"`);
+  }
+  const plugins = getUniquePlugins(
+    resolvePlugins([...(lintConfig?.plugins || []), defaultPlugin], configPath),
+  );
+  const pluginPaths = lintConfig?.plugins
+    ?.filter(isString)
+    .map((p) => path.resolve(path.dirname(configPath), p));
+
+  const resolvedConfigPath = isAbsoluteUrl(configPath)
+    ? configPath
+    : configPath && path.resolve(configPath);
+
+  const extendConfigs: ResolvedLintConfig[] = await Promise.all(
+    lintConfig?.extends?.map(async (presetItem) => {
+      if (!isAbsoluteUrl(presetItem) && !path.extname(presetItem)) {
+        return resolvePreset(presetItem, plugins);
+      }
+      const pathItem = isAbsoluteUrl(presetItem)
+        ? presetItem
+        : isAbsoluteUrl(configPath)
+        ? new URL(presetItem, configPath).href
+        : path.resolve(path.dirname(configPath), presetItem);
+      const extendedLintConfig = await loadExtendLintConfig(pathItem, resolver);
+      return await resolveAndMergeNestedLint(
+        {
+          lintConfig: extendedLintConfig,
+          configPath: pathItem,
+          resolver: resolver,
+        },
+        [...parentConfigPaths, resolvedConfigPath],
+        extendPaths,
+      );
+    }) || [],
+  );
+
+  const { plugins: mergedPlugins = [], ...lint } = mergeExtends([
+    ...extendConfigs,
+    {
+      ...lintConfig,
+      plugins,
+      extends: undefined,
+      extendPaths: [...parentConfigPaths, resolvedConfigPath],
+      pluginPaths,
+    },
+  ]);
+
+  return {
+    ...lint,
+    extendPaths: lint.extendPaths?.filter((path) => path && !isAbsoluteUrl(path)),
+    plugins: getUniquePlugins(mergedPlugins),
+    recommendedFallback: lintConfig?.recommendedFallback,
+    doNotResolveExamples: lintConfig?.doNotResolveExamples,
+  };
+}
+
+export async function resolveLint(
+  lintOpts: {
+    lintConfig?: LintRawConfig;
+    configPath?: string;
+    resolver?: BaseResolver;
+  },
+  parentConfigPaths: string[] = [],
+  extendPaths: string[] = [],
+): Promise<ResolvedLintConfig> {
+  const resolvedLint = await resolveAndMergeNestedLint(lintOpts, parentConfigPaths, extendPaths);
+
+  return {
+    ...resolvedLint,
+    rules: resolvedLint.rules && groupLintAssertionRules(resolvedLint.rules),
+  };
+}
+
+export function resolvePreset(presetName: string, plugins: Plugin[]): ResolvedLintConfig {
+  const { pluginId, configName } = parsePresetName(presetName);
+  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]! as ResolvedLintConfig;
+  if (!preset) {
+    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;
+}
+
+async function loadExtendLintConfig(
+  filePath: string,
+  resolver: BaseResolver,
+): Promise<LintRawConfig> {
+  try {
+    const fileSource = await resolver.loadExternalRef(filePath);
+    const rawConfig = transformConfig(parseYaml(fileSource.body) as RawConfig);
+    if (!rawConfig.lint) {
+      throw new Error(`Lint configuration format not detected: "${filePath}"`);
+    }
+
+    return rawConfig.lint;
+  } catch (error) {
+    throw new Error(`Failed to load "${filePath}": ${error.message}`);
+  }
+}
+
+function getMergedLintRawConfig(configLint: LintRawConfig, apiLint?: LintRawConfig) {
+  const resultLint = {
+    ...configLint,
+    ...apiLint,
+    rules: { ...configLint?.rules, ...apiLint?.rules },
+    oas2Rules: { ...configLint?.oas2Rules, ...apiLint?.oas2Rules },
+    oas3_0Rules: { ...configLint?.oas3_0Rules, ...apiLint?.oas3_0Rules },
+    oas3_1Rules: { ...configLint?.oas3_1Rules, ...apiLint?.oas3_1Rules },
+    preprocessors: { ...configLint?.preprocessors, ...apiLint?.preprocessors },
+    oas2Preprocessors: { ...configLint?.oas2Preprocessors, ...apiLint?.oas2Preprocessors },
+    oas3_0Preprocessors: { ...configLint?.oas3_0Preprocessors, ...apiLint?.oas3_0Preprocessors },
+    oas3_1Preprocessors: { ...configLint?.oas3_1Preprocessors, ...apiLint?.oas3_1Preprocessors },
+    decorators: { ...configLint?.decorators, ...apiLint?.decorators },
+    oas2Decorators: { ...configLint?.oas2Decorators, ...apiLint?.oas2Decorators },
+    oas3_0Decorators: { ...configLint?.oas3_0Decorators, ...apiLint?.oas3_0Decorators },
+    oas3_1Decorators: { ...configLint?.oas3_1Decorators, ...apiLint?.oas3_1Decorators },
+    recommendedFallback: apiLint?.extends ? false : configLint.recommendedFallback,
+  };
+  return resultLint;
+}
+
+function groupLintAssertionRules(
+  rules: Record<string, RuleConfig> | undefined,
+): Record<string, RuleConfig> | undefined {
+  if (!rules) {
+    return rules;
+  }
+
+  // Create a new record to avoid mutating original
+  const transformedRules: Record<string, RuleConfig> = {};
+
+  // Collect assertion rules
+  const assertions = [];
+  for (const [ruleKey, rule] of Object.entries(rules)) {
+    if (ruleKey.startsWith('assert/') && typeof rule === 'object' && rule !== null) {
+      const assertion = rule;
+      assertions.push({
+        ...assertion,
+        assertionId: ruleKey.replace('assert/', ''),
+      });
+    } else {
+      // If it's not an assertion, keep it as is
+      transformedRules[ruleKey] = rule;
+    }
+  }
+  if (assertions.length > 0) {
+    transformedRules.assertions = assertions;
+  }
+
+  return transformedRules;
+}

package/src/config/config.ts

@@ -0,0 +1,312 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { parseYaml, stringifyYaml } from '../js-yaml';
+import { slash } from '../utils';
+import { NormalizedProblem } from '../walk';
+import { OasVersion, OasMajorVersion, Oas2RuleSet, Oas3RuleSet } from '../oas-types';
+
+import type { NodeType } from '../types';
+import type {
+  DecoratorConfig,
+  Plugin,
+  PreprocessorConfig,
+  Region,
+  ResolveConfig,
+  ResolvedApi,
+  ResolvedConfig,
+  ResolvedLintConfig,
+  RuleConfig,
+} from './types';
+import { getResolveConfig } from './utils';
+
+// Alias environment here so this file can work in browser environments too.
+export const env = typeof process !== 'undefined' ? process.env || {} : {};
+
+export const IGNORE_FILE = '.redocly.lint-ignore.yaml';
+const IGNORE_BANNER =
+  `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
+  `# See https://redoc.ly/docs/cli/ for more information.\n`;
+
+export const DEFAULT_REGION = 'us';
+
+function getDomains() {
+  const domains: { [region in Region]: string } = {
+    us: 'redocly.com',
+    eu: 'eu.redocly.com',
+  };
+
+  // FIXME: temporary fix for our lab environments
+  const domain = env.REDOCLY_DOMAIN;
+  if (domain?.endsWith('.redocly.host')) {
+    domains[domain.split('.')[0] as Region] = domain;
+  }
+  if (domain === 'redoc.online') {
+    domains[domain as Region] = domain;
+  }
+  return domains;
+}
+
+export const DOMAINS = getDomains();
+export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
+
+export class LintConfig {
+  plugins: Plugin[];
+  ignore: Record<string, Record<string, Set<string>>> = {};
+  doNotResolveExamples: boolean;
+  rules: Record<OasVersion, Record<string, RuleConfig>>;
+  preprocessors: Record<OasVersion, Record<string, PreprocessorConfig>>;
+  decorators: Record<OasVersion, Record<string, DecoratorConfig>>;
+
+  private _usedRules: Set<string> = new Set();
+  private _usedVersions: Set<OasVersion> = new Set();
+
+  recommendedFallback: boolean;
+
+  extendPaths: string[];
+  pluginPaths: string[];
+
+  constructor(public rawConfig: ResolvedLintConfig, public configFile?: string) {
+    this.plugins = rawConfig.plugins || [];
+    this.doNotResolveExamples = !!rawConfig.doNotResolveExamples;
+
+    this.recommendedFallback = rawConfig.recommendedFallback || false
+
+    this.rules = {
+      [OasVersion.Version2]: { ...rawConfig.rules, ...rawConfig.oas2Rules },
+      [OasVersion.Version3_0]: { ...rawConfig.rules, ...rawConfig.oas3_0Rules },
+      [OasVersion.Version3_1]: { ...rawConfig.rules, ...rawConfig.oas3_1Rules },
+    };
+
+    this.preprocessors = {
+      [OasVersion.Version2]: { ...rawConfig.preprocessors, ...rawConfig.oas2Preprocessors },
+      [OasVersion.Version3_0]: { ...rawConfig.preprocessors, ...rawConfig.oas3_0Preprocessors },
+      [OasVersion.Version3_1]: { ...rawConfig.preprocessors, ...rawConfig.oas3_1Preprocessors },
+    };
+
+    this.decorators = {
+      [OasVersion.Version2]: { ...rawConfig.decorators, ...rawConfig.oas2Decorators },
+      [OasVersion.Version3_0]: { ...rawConfig.decorators, ...rawConfig.oas3_0Decorators },
+      [OasVersion.Version3_1]: { ...rawConfig.decorators, ...rawConfig.oas3_1Decorators },
+    };
+
+    this.extendPaths = rawConfig.extendPaths || [];
+    this.pluginPaths = rawConfig.pluginPaths || [];
+
+    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 */
+    if (fs.hasOwnProperty('existsSync') && fs.existsSync(ignoreFile)) {
+      // TODO: parse errors
+      this.ignore =
+        (parseYaml(fs.readFileSync(ignoreFile, 'utf-8')) as Record<
+          string,
+          Record<string, Set<string>>
+        >) || {};
+
+      // resolve ignore paths
+      for (const fileName of Object.keys(this.ignore)) {
+        this.ignore[path.resolve(path.dirname(ignoreFile), fileName)] = this.ignore[fileName];
+        for (const ruleId of Object.keys(this.ignore[fileName])) {
+          this.ignore[fileName][ruleId] = new Set(this.ignore[fileName][ruleId]);
+        }
+        delete this.ignore[fileName];
+      }
+    }
+  }
+
+  saveIgnore() {
+    const dir = this.configFile ? path.dirname(this.configFile) : process.cwd();
+    const ignoreFile = path.join(dir, IGNORE_FILE);
+    const mapped: Record<string, any> = {};
+    for (const absFileName of Object.keys(this.ignore)) {
+      const ignoredRules = (mapped[slash(path.relative(dir, absFileName))] =
+        this.ignore[absFileName]);
+      for (const ruleId of Object.keys(ignoredRules)) {
+        ignoredRules[ruleId] = Array.from(ignoredRules[ruleId]) as any;
+      }
+    }
+    fs.writeFileSync(ignoreFile, IGNORE_BANNER + stringifyYaml(mapped));
+  }
+
+  addIgnore(problem: NormalizedProblem) {
+    const ignore = this.ignore;
+    const loc = problem.location[0];
+    if (loc.pointer === undefined) return;
+
+    const fileIgnore = (ignore[loc.source.absoluteRef] = ignore[loc.source.absoluteRef] || {});
+    const ruleIgnore = (fileIgnore[problem.ruleId] = fileIgnore[problem.ruleId] || new Set());
+
+    ruleIgnore.add(loc.pointer);
+  }
+
+  addProblemToIgnore(problem: NormalizedProblem) {
+    const loc = problem.location[0];
+    if (loc.pointer === undefined) return problem;
+
+    const fileIgnore = this.ignore[loc.source.absoluteRef] || {};
+    const ruleIgnore = fileIgnore[problem.ruleId];
+    const ignored = ruleIgnore && ruleIgnore.has(loc.pointer);
+    return ignored
+      ? {
+          ...problem,
+          ignored,
+        }
+      : problem;
+  }
+
+  extendTypes(types: Record<string, NodeType>, version: OasVersion) {
+    let extendedTypes = types;
+    for (const plugin of this.plugins) {
+      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:
+            if (!plugin.typeExtension.oas2) continue;
+            extendedTypes = plugin.typeExtension.oas2(extendedTypes, version);
+          default:
+            throw new Error('Not implemented');
+        }
+      }
+    }
+    return extendedTypes;
+  }
+
+  getRuleSettings(ruleId: string, oasVersion: OasVersion) {
+    this._usedRules.add(ruleId);
+    this._usedVersions.add(oasVersion);
+    const settings = this.rules[oasVersion][ruleId] || 'off';
+    if (typeof settings === 'string') {
+      return {
+        severity: settings,
+      };
+    } else {
+      return { severity: 'error' as 'error', ...settings };
+    }
+  }
+
+  getPreprocessorSettings(ruleId: string, oasVersion: OasVersion) {
+    this._usedRules.add(ruleId);
+    this._usedVersions.add(oasVersion);
+
+    const settings = this.preprocessors[oasVersion][ruleId] || 'off';
+    if (typeof settings === 'string') {
+      return {
+        severity: settings === 'on' ? ('error' as 'error') : settings,
+      };
+    } else {
+      return { severity: 'error' as 'error', ...settings };
+    }
+  }
+
+  getDecoratorSettings(ruleId: string, oasVersion: OasVersion) {
+    this._usedRules.add(ruleId);
+    this._usedVersions.add(oasVersion);
+    const settings = this.decorators[oasVersion][ruleId] || 'off';
+    if (typeof settings === 'string') {
+      return {
+        severity: settings === 'on' ? ('error' as 'error') : settings,
+      };
+    } else {
+      return { severity: 'error' as 'error', ...settings };
+    }
+  }
+
+  getUnusedRules() {
+    const rules = [];
+    const decorators = [];
+    const preprocessors = [];
+
+    for (const usedVersion of Array.from(this._usedVersions)) {
+      rules.push(
+        ...Object.keys(this.rules[usedVersion]).filter((name) => !this._usedRules.has(name)),
+      );
+      decorators.push(
+        ...Object.keys(this.decorators[usedVersion]).filter((name) => !this._usedRules.has(name)),
+      );
+      preprocessors.push(
+        ...Object.keys(this.preprocessors[usedVersion]).filter(
+          (name) => !this._usedRules.has(name),
+        ),
+      );
+    }
+
+    return {
+      rules,
+      preprocessors,
+      decorators,
+    };
+  }
+
+  getRulesForOasVersion(version: OasMajorVersion) {
+    switch (version) {
+      case OasMajorVersion.Version3:
+        const oas3Rules: Oas3RuleSet[] = []; // default ruleset
+        this.plugins.forEach((p) => p.preprocessors?.oas3 && oas3Rules.push(p.preprocessors.oas3));
+        this.plugins.forEach((p) => p.rules?.oas3 && oas3Rules.push(p.rules.oas3));
+        this.plugins.forEach((p) => p.decorators?.oas3 && oas3Rules.push(p.decorators.oas3));
+        return oas3Rules;
+      case OasMajorVersion.Version2:
+        const oas2Rules: Oas2RuleSet[] = []; // default ruleset
+        this.plugins.forEach((p) => p.preprocessors?.oas2 && oas2Rules.push(p.preprocessors.oas2));
+        this.plugins.forEach((p) => p.rules?.oas2 && oas2Rules.push(p.rules.oas2));
+        this.plugins.forEach((p) => p.decorators?.oas2 && oas2Rules.push(p.decorators.oas2));
+        return oas2Rules;
+    }
+  }
+
+  skipRules(rules?: string[]) {
+    for (const ruleId of rules || []) {
+      for (const version of Object.values(OasVersion)) {
+        if (this.rules[version][ruleId]) {
+          this.rules[version][ruleId] = 'off';
+        }
+      }
+    }
+  }
+
+  skipPreprocessors(preprocessors?: string[]) {
+    for (const preprocessorId of preprocessors || []) {
+      for (const version of Object.values(OasVersion)) {
+        if (this.preprocessors[version][preprocessorId]) {
+          this.preprocessors[version][preprocessorId] = 'off';
+        }
+      }
+    }
+  }
+
+  skipDecorators(decorators?: string[]) {
+    for (const decoratorId of decorators || []) {
+      for (const version of Object.values(OasVersion)) {
+        if (this.decorators[version][decoratorId]) {
+          this.decorators[version][decoratorId] = 'off';
+        }
+      }
+    }
+  }
+}
+
+export class Config {
+  apis: Record<string, ResolvedApi>;
+  lint: LintConfig;
+  resolve: ResolveConfig;
+  licenseKey?: string;
+  region?: Region;
+  'features.openapi': Record<string, any>;
+  'features.mockServer'?: Record<string, any>;
+  organization?: string;
+  constructor(public rawConfig: ResolvedConfig, public configFile?: string) {
+    this.apis = rawConfig.apis || {};
+    this.lint = new LintConfig(rawConfig.lint || {}, configFile);
+    this['features.openapi'] = rawConfig['features.openapi'] || {};
+    this['features.mockServer'] = rawConfig['features.mockServer'] || {};
+    this.resolve = getResolveConfig(rawConfig?.resolve);
+    this.region = rawConfig.region;
+    this.organization = rawConfig.organization;
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,7 @@
+export * from './config';
+export * from './types';
+export * from './rules';
+export * from './builtIn';
+export * from './load';
+export * from './utils';
+export * from './config-resolvers';