@redocly/openapi-core 1.0.0-beta.100

package/README.md

@@ -0,0 +1,25 @@
+# openapi-core
+
+See https://github.com/Redocly/redocly-cli
+
+## Basic usage
+
+### Lint
+
+```js
+import { formatProblems, lint, loadConfig } from '@redocly/openapi-core';
+
+const pathToEntryPoint = 'openapi.yaml';
+const config = loadConfig('optional/path/to/.redocly.yaml');
+const lintResults = await lint({ ref: pathToEntryPoint, config });
+```
+
+### Bundle
+
+```js
+import { formatProblems, bundle, loadConfig } from '@redocly/openapi-core';
+
+const pathToEntryPoint = 'openapi.yaml';
+const config = loadConfig('optional/path/to/.redocly.yaml');
+const { bundle, problems } = await bundle({ ref: pathToEntryPoint, config });
+```

package/__tests__/utils.ts

@@ -0,0 +1,86 @@
+import * as path from 'path';
+
+import { Document, Source, NormalizedProblem, parseYaml, stringifyYaml } from '../src';
+import { LintConfig, resolveLint, resolvePlugins } from '../src/config';
+import { Oas3RuleSet } from '../src/oas-types';
+
+import type { RuleConfig, Plugin, DecoratorConfig } from '../src/config';
+
+export function parseYamlToDocument(body: string, absoluteRef: string = ''): Document {
+  return {
+    source: new Source(absoluteRef, body),
+    parsed: parseYaml(body, { filename: absoluteRef }),
+  };
+}
+
+export function replaceSourceWithRef(results: NormalizedProblem[], cwd?: string) {
+  const cwdRegexp = cwd ? new RegExp(cwd + path.sep, 'g') : /$^/;
+  return results.map((r) => {
+    const mapped = {
+      ...r,
+      message: r.message.replace(cwdRegexp, ''),
+      location: r.location.map((l) => ({
+        ...l,
+        source: cwd ? path.relative(cwd, l.source.absoluteRef) : l.source.absoluteRef,
+      })),
+    };
+    if (mapped.from) {
+      mapped.from = {
+        ...mapped.from,
+        source: cwd
+          ? path.relative(cwd, mapped.from.source.absoluteRef)
+          : (mapped.from.source.absoluteRef as any),
+      };
+    }
+    return mapped;
+  });
+}
+
+export const yamlSerializer = {
+  test: () => {
+    return true;
+  },
+  print: (val: any) => {
+    return stringifyYaml(val);
+  },
+};
+
+export function makeConfigForRuleset(
+  rules: Oas3RuleSet,
+  plugin?: Partial<Plugin>,
+  version: string = 'oas3',
+) {
+  const rulesConf: Record<string, RuleConfig> = {};
+  const ruleId = 'test';
+  Object.keys(rules).forEach((name) => {
+    rulesConf[`${ruleId}/${name}`] = 'error';
+  });
+  const plugins = resolvePlugins([
+    {
+      ...plugin,
+      id: ruleId,
+      rules: { [version]: rules },
+    },
+  ]);
+
+  return new LintConfig({
+    plugins,
+    rules: rulesConf,
+  });
+}
+
+export async function makeConfig(
+  rules: Record<string, RuleConfig>,
+  decorators?: Record<string, DecoratorConfig>,
+) {
+  return new LintConfig(
+    await resolveLint({
+      lintConfig: {
+        plugins: [],
+        extends: [],
+        rules,
+        decorators,
+      },
+    }),
+  );
+}

package/lib/benchmark/benches/lint-with-many-rules.bench.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "Validate with 50 top-level rules";
+export declare const count = 10;
+export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-many-rules.bench.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureAsync = exports.count = exports.name = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const lint_1 = require("../../lint");
+const resolve_1 = require("../../resolve");
+const utils_1 = require("../utils");
+exports.name = 'Validate with 50 top-level rules';
+exports.count = 10;
+const rebillyDefinitionRef = path_1.resolve(path_1.join(__dirname, 'rebilly.yaml'));
+const rebillyDocument = utils_1.parseYamlToDocument(fs_1.readFileSync(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
+const ruleset = {};
+for (let i = 0; i < 50; i++) {
+    ruleset['rule-' + i] = () => {
+        let count = 0;
+        return {
+            Schema() {
+                count++;
+                if (count === -1)
+                    throw new Error('Disable optimization');
+            },
+        };
+    };
+}
+const config = utils_1.makeConfigForRuleset(ruleset);
+function measureAsync() {
+    return lint_1.lintDocument({
+        externalRefResolver: new resolve_1.BaseResolver(),
+        document: rebillyDocument,
+        config,
+    });
+}
+exports.measureAsync = measureAsync;

package/lib/benchmark/benches/lint-with-nested-rule.bench.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "Validate with single nested rule";
+export declare const count = 10;
+export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-nested-rule.bench.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureAsync = exports.count = exports.name = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const lint_1 = require("../../lint");
+const resolve_1 = require("../../resolve");
+const utils_1 = require("../utils");
+exports.name = 'Validate with single nested rule';
+exports.count = 10;
+const rebillyDefinitionRef = path_1.resolve(path_1.join(__dirname, 'rebilly.yaml'));
+const rebillyDocument = utils_1.parseYamlToDocument(fs_1.readFileSync(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
+const visitor = {
+    test: () => {
+        let count = 0;
+        return {
+            PathItem: {
+                Parameter() {
+                    count++;
+                },
+                Operation: {
+                    Parameter() {
+                        count++;
+                        if (count === -1)
+                            throw new Error('Disable optimization');
+                    },
+                },
+            },
+        };
+    },
+};
+const config = utils_1.makeConfigForRuleset(visitor);
+function measureAsync() {
+    return lint_1.lintDocument({
+        externalRefResolver: new resolve_1.BaseResolver(),
+        document: rebillyDocument,
+        config,
+    });
+}
+exports.measureAsync = measureAsync;

package/lib/benchmark/benches/lint-with-no-rules.bench.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "Validate with no rules";
+export declare const count = 10;
+export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-no-rules.bench.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureAsync = exports.count = exports.name = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const lint_1 = require("../../lint");
+const resolve_1 = require("../../resolve");
+const utils_1 = require("../utils");
+exports.name = 'Validate with no rules';
+exports.count = 10;
+const rebillyDefinitionRef = path_1.resolve(path_1.join(__dirname, 'rebilly.yaml'));
+const rebillyDocument = utils_1.parseYamlToDocument(fs_1.readFileSync(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
+const config = utils_1.makeConfigForRuleset({});
+function measureAsync() {
+    return lint_1.lintDocument({
+        externalRefResolver: new resolve_1.BaseResolver(),
+        document: rebillyDocument,
+        config,
+    });
+}
+exports.measureAsync = measureAsync;

package/lib/benchmark/benches/lint-with-top-level-rule-report.bench.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "Validate with single top-level rule and report";
+export declare const count = 10;
+export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-top-level-rule-report.bench.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureAsync = exports.count = exports.name = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const lint_1 = require("../../lint");
+const resolve_1 = require("../../resolve");
+const utils_1 = require("../utils");
+exports.name = 'Validate with single top-level rule and report';
+exports.count = 10;
+const rebillyDefinitionRef = path_1.resolve(path_1.join(__dirname, 'rebilly.yaml'));
+const rebillyDocument = utils_1.parseYamlToDocument(fs_1.readFileSync(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
+const config = utils_1.makeConfigForRuleset({
+    test: () => {
+        return {
+            // @ts-ignore
+            Schema(schema, ctx) {
+                if (schema.type === 'number') {
+                    ctx.report({
+                        message: 'type number is not allowed',
+                    });
+                }
+            },
+        };
+    },
+});
+function measureAsync() {
+    return lint_1.lintDocument({
+        externalRefResolver: new resolve_1.BaseResolver(),
+        document: rebillyDocument,
+        config,
+    });
+}
+exports.measureAsync = measureAsync;

package/lib/benchmark/benches/lint-with-top-level-rule.bench.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "Validate with single top-level rule";
+export declare const count = 10;
+export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/lint-with-top-level-rule.bench.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureAsync = exports.count = exports.name = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const lint_1 = require("../../lint");
+const resolve_1 = require("../../resolve");
+const utils_1 = require("../utils");
+exports.name = 'Validate with single top-level rule';
+exports.count = 10;
+const rebillyDefinitionRef = path_1.resolve(path_1.join(__dirname, 'rebilly.yaml'));
+const rebillyDocument = utils_1.parseYamlToDocument(fs_1.readFileSync(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
+const config = utils_1.makeConfigForRuleset({
+    test: () => {
+        let count = 0;
+        return {
+            Schema() {
+                count++;
+                if (count === -1)
+                    throw new Error('Disable optimization');
+            },
+        };
+    },
+});
+function measureAsync() {
+    return lint_1.lintDocument({
+        externalRefResolver: new resolve_1.BaseResolver(),
+        document: rebillyDocument,
+        config,
+    });
+}
+exports.measureAsync = measureAsync;

package/lib/benchmark/benches/recommended-oas3.bench.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "Validate with recommended rules";
+export declare const count = 10;
+export declare function measureAsync(): Promise<import("../..").NormalizedProblem[]>;

package/lib/benchmark/benches/recommended-oas3.bench.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureAsync = exports.count = exports.name = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const lint_1 = require("../../lint");
+const config_1 = require("../../config");
+const resolve_1 = require("../../resolve");
+const utils_1 = require("../utils");
+exports.name = 'Validate with recommended rules';
+exports.count = 10;
+const rebillyDefinitionRef = path_1.resolve(path_1.join(__dirname, 'rebilly.yaml'));
+const rebillyDocument = utils_1.parseYamlToDocument(fs_1.readFileSync(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
+function measureAsync() {
+    return lint_1.lintDocument({
+        externalRefResolver: new resolve_1.BaseResolver(),
+        document: rebillyDocument,
+        config: new config_1.LintConfig(config_1.resolvePreset('recommended', [config_1.defaultPlugin])),
+    });
+}
+exports.measureAsync = measureAsync;

package/lib/benchmark/benches/resolve-with-no-external.bench.d.ts

@@ -0,0 +1,3 @@
+export declare const name = "Resolve with no external refs";
+export declare const count = 10;
+export declare function measureAsync(): Promise<import("../../resolve").ResolvedRefMap>;

package/lib/benchmark/benches/resolve-with-no-external.bench.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.measureAsync = exports.count = exports.name = void 0;
+const path = require("path");
+const fs_1 = require("fs");
+const resolve_1 = require("../../resolve");
+const utils_1 = require("../utils");
+const oas3_1 = require("../../types/oas3");
+const types_1 = require("../../types");
+exports.name = 'Resolve with no external refs';
+exports.count = 10;
+const rebillyDefinitionRef = path.resolve(path.join(__dirname, 'rebilly.yaml'));
+const rebillyDocument = utils_1.parseYamlToDocument(fs_1.readFileSync(rebillyDefinitionRef, 'utf-8'), rebillyDefinitionRef);
+const externalRefResolver = new resolve_1.BaseResolver();
+function measureAsync() {
+    return resolve_1.resolveDocument({
+        rootDocument: rebillyDocument,
+        externalRefResolver,
+        rootType: types_1.normalizeTypes(oas3_1.Oas3Types).DefinitionRoot,
+    });
+}
+exports.measureAsync = measureAsync;

package/lib/benchmark/utils.d.ts

@@ -0,0 +1,6 @@
+import { Document } from '../resolve';
+import { Oas3RuleSet } from '../oas-types';
+import { LintConfig } from '../config';
+import type { Plugin } from '../config/types';
+export declare function parseYamlToDocument(body: string, absoluteRef?: string): Document;
+export declare function makeConfigForRuleset(rules: Oas3RuleSet, plugin?: Partial<Plugin>): LintConfig;

package/lib/benchmark/utils.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeConfigForRuleset = exports.parseYamlToDocument = void 0;
+const js_yaml_1 = require("../js-yaml");
+const resolve_1 = require("../resolve");
+const config_1 = require("../config");
+function parseYamlToDocument(body, absoluteRef = '') {
+    return {
+        source: new resolve_1.Source(absoluteRef, body),
+        parsed: js_yaml_1.parseYaml(body, { filename: absoluteRef }),
+    };
+}
+exports.parseYamlToDocument = parseYamlToDocument;
+function makeConfigForRuleset(rules, plugin) {
+    const rulesConf = {};
+    const ruleId = 'test';
+    Object.keys(rules).forEach((name) => {
+        rulesConf[`${ruleId}/${name}`] = 'error';
+    });
+    const extendConfigs = [
+        config_1.resolvePlugins([
+            Object.assign(Object.assign({}, plugin), { id: ruleId, rules: { oas3: rules } }),
+        ]),
+    ];
+    if (rules) {
+        extendConfigs.push({ rules });
+    }
+    const lint = config_1.mergeExtends(extendConfigs);
+    return new config_1.LintConfig(lint);
+}
+exports.makeConfigForRuleset = makeConfigForRuleset;

package/lib/bundle.d.ts

@@ -0,0 +1,47 @@
+import { BaseResolver, Document } from './resolve';
+import { Oas3Rule } from './visitors';
+import { NormalizedNodeType, NodeType } from './types';
+import { OasMajorVersion } from './oas-types';
+import type { Config, LintConfig } from './config';
+export declare type Oas3RuleSet = Record<string, Oas3Rule>;
+export declare enum OasVersion {
+    Version2 = "oas2",
+    Version3_0 = "oas3_0",
+    Version3_1 = "oas3_1"
+}
+export declare function bundle(opts: {
+    ref?: string;
+    doc?: Document;
+    externalRefResolver?: BaseResolver;
+    config: Config;
+    dereference?: boolean;
+    base?: string;
+    skipRedoclyRegistryRefs?: boolean;
+    removeUnusedComponents?: boolean;
+    keepUrlRefs?: boolean;
+}): Promise<{
+    bundle: Document;
+    problems: import("./walk").NormalizedProblem[];
+    fileDependencies: Set<string>;
+    rootType: NormalizedNodeType;
+    refTypes: Map<string, NormalizedNodeType> | undefined;
+    visitorsData: Record<string, Record<string, unknown>>;
+}>;
+export declare function bundleDocument(opts: {
+    document: Document;
+    config: LintConfig;
+    customTypes?: Record<string, NodeType>;
+    externalRefResolver: BaseResolver;
+    dereference?: boolean;
+    skipRedoclyRegistryRefs?: boolean;
+    removeUnusedComponents?: boolean;
+    keepUrlRefs?: boolean;
+}): Promise<{
+    bundle: Document;
+    problems: import("./walk").NormalizedProblem[];
+    fileDependencies: Set<string>;
+    rootType: NormalizedNodeType;
+    refTypes: Map<string, NormalizedNodeType> | undefined;
+    visitorsData: Record<string, Record<string, unknown>>;
+}>;
+export declare function mapTypeToComponent(typeName: string, version: OasMajorVersion): "headers" | "definitions" | "parameters" | "examples" | "responses" | "schemas" | "requestBodies" | "securitySchemes" | "links" | "callbacks" | null;