@redocly/openapi-core 1.0.0-beta.99 → 1.0.0-rc.2

package/src/config/config-resolvers.ts

@@ -1,359 +0,0 @@
-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

@@ -1,312 +0,0 @@
-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

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