@redocly/openapi-core 1.0.0-beta.100

package/lib/walk.js

@@ -0,0 +1,253 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.walkDocument = void 0;
+const ref_utils_1 = require("./ref-utils");
+const resolve_1 = require("./resolve");
+const utils_1 = require("./utils");
+const types_1 = require("./types");
+function collectParents(ctx) {
+    var _a;
+    const parents = {};
+    while (ctx.parent) {
+        parents[ctx.parent.type.name] = (_a = ctx.parent.activatedOn) === null || _a === void 0 ? void 0 : _a.value.node;
+        ctx = ctx.parent;
+    }
+    return parents;
+}
+function collectParentsLocations(ctx) {
+    var _a, _b;
+    const locations = {};
+    while (ctx.parent) {
+        if ((_a = ctx.parent.activatedOn) === null || _a === void 0 ? void 0 : _a.value.location) {
+            locations[ctx.parent.type.name] = (_b = ctx.parent.activatedOn) === null || _b === void 0 ? void 0 : _b.value.location;
+        }
+        ctx = ctx.parent;
+    }
+    return locations;
+}
+function walkDocument(opts) {
+    const { document, rootType, normalizedVisitors, resolvedRefMap, ctx } = opts;
+    const seenNodesPerType = {};
+    const seenRefs = new Set();
+    walkNode(document.parsed, rootType, new ref_utils_1.Location(document.source, '#/'), undefined, '');
+    function walkNode(node, type, location, parent, key) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        let currentLocation = location;
+        const { node: resolvedNode, location: resolvedLocation, error } = resolve(node);
+        const enteredContexts = new Set();
+        if (ref_utils_1.isRef(node)) {
+            const refEnterVisitors = normalizedVisitors.ref.enter;
+            for (const { visit: visitor, ruleId, severity, context } of refEnterVisitors) {
+                if (!seenRefs.has(node)) {
+                    enteredContexts.add(context);
+                    const report = reportFn.bind(undefined, ruleId, severity);
+                    visitor(node, {
+                        report,
+                        resolve,
+                        location,
+                        type,
+                        parent,
+                        key,
+                        parentLocations: {},
+                        oasVersion: ctx.oasVersion,
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
+                    }, { node: resolvedNode, location: resolvedLocation, error });
+                    if ((resolvedLocation === null || resolvedLocation === void 0 ? void 0 : resolvedLocation.source.absoluteRef) && ctx.refTypes) {
+                        ctx.refTypes.set(resolvedLocation === null || resolvedLocation === void 0 ? void 0 : resolvedLocation.source.absoluteRef, type);
+                    }
+                }
+            }
+        }
+        if (resolvedNode !== undefined && resolvedLocation && type.name !== 'scalar') {
+            currentLocation = resolvedLocation;
+            const isNodeSeen = (_b = (_a = seenNodesPerType[type.name]) === null || _a === void 0 ? void 0 : _a.has) === null || _b === void 0 ? void 0 : _b.call(_a, resolvedNode);
+            let visitedBySome = false;
+            const anyEnterVisitors = normalizedVisitors.any.enter;
+            const currentEnterVisitors = anyEnterVisitors.concat(((_c = normalizedVisitors[type.name]) === null || _c === void 0 ? void 0 : _c.enter) || []);
+            const activatedContexts = [];
+            for (const { context, visit, skip, ruleId, severity } of currentEnterVisitors) {
+                if (context.isSkippedLevel) {
+                    if (context.parent.activatedOn &&
+                        !context.parent.activatedOn.value.nextLevelTypeActivated &&
+                        !context.seen.has(node)) {
+                        // TODO: test for walk through duplicated $ref-ed node
+                        context.seen.add(node);
+                        visitedBySome = true;
+                        activatedContexts.push(context);
+                    }
+                }
+                else {
+                    if ((context.parent && // if nested
+                        context.parent.activatedOn &&
+                        ((_d = context.activatedOn) === null || _d === void 0 ? void 0 : _d.value.withParentNode) !== context.parent.activatedOn.value.node &&
+                        // do not enter if visited by parent children (it works thanks because deeper visitors are sorted before)
+                        ((_e = context.parent.activatedOn.value.nextLevelTypeActivated) === null || _e === void 0 ? void 0 : _e.value) !== type) ||
+                        (!context.parent && !isNodeSeen) // if top-level visit each node just once
+                    ) {
+                        activatedContexts.push(context);
+                        const activatedOn = {
+                            node: resolvedNode,
+                            location: resolvedLocation,
+                            nextLevelTypeActivated: null,
+                            withParentNode: (_g = (_f = context.parent) === null || _f === void 0 ? void 0 : _f.activatedOn) === null || _g === void 0 ? void 0 : _g.value.node,
+                            skipped: (_k = (((_j = (_h = context.parent) === null || _h === void 0 ? void 0 : _h.activatedOn) === null || _j === void 0 ? void 0 : _j.value.skipped) || (skip === null || skip === void 0 ? void 0 : skip(resolvedNode, key)))) !== null && _k !== void 0 ? _k : false,
+                        };
+                        context.activatedOn = utils_1.pushStack(context.activatedOn, activatedOn);
+                        let ctx = context.parent;
+                        while (ctx) {
+                            ctx.activatedOn.value.nextLevelTypeActivated = utils_1.pushStack(ctx.activatedOn.value.nextLevelTypeActivated, type);
+                            ctx = ctx.parent;
+                        }
+                        if (!activatedOn.skipped) {
+                            visitedBySome = true;
+                            enteredContexts.add(context);
+                            const { ignoreNextVisitorsOnNode } = visitWithContext(visit, resolvedNode, context, ruleId, severity);
+                            if (ignoreNextVisitorsOnNode)
+                                break;
+                        }
+                    }
+                }
+            }
+            if (visitedBySome || !isNodeSeen) {
+                seenNodesPerType[type.name] = seenNodesPerType[type.name] || new Set();
+                seenNodesPerType[type.name].add(resolvedNode);
+                if (Array.isArray(resolvedNode)) {
+                    const itemsType = type.items;
+                    if (itemsType !== undefined) {
+                        for (let i = 0; i < resolvedNode.length; i++) {
+                            walkNode(resolvedNode[i], itemsType, resolvedLocation.child([i]), resolvedNode, i);
+                        }
+                    }
+                }
+                else if (typeof resolvedNode === 'object' && resolvedNode !== null) {
+                    // visit in order from type-tree first
+                    const props = Object.keys(type.properties);
+                    if (type.additionalProperties) {
+                        props.push(...Object.keys(resolvedNode).filter((k) => !props.includes(k)));
+                    }
+                    if (ref_utils_1.isRef(node)) {
+                        props.push(...Object.keys(node).filter((k) => k !== '$ref' && !props.includes(k))); // properties on the same level as $ref
+                    }
+                    for (const propName of props) {
+                        let value = resolvedNode[propName];
+                        let loc = resolvedLocation;
+                        if (value === undefined) {
+                            value = node[propName];
+                            loc = location; // properties on the same level as $ref should resolve against original location, not target
+                        }
+                        let propType = type.properties[propName];
+                        if (propType === undefined)
+                            propType = type.additionalProperties;
+                        if (typeof propType === 'function')
+                            propType = propType(value, propName);
+                        if (!types_1.isNamedType(propType) && (propType === null || propType === void 0 ? void 0 : propType.directResolveAs)) {
+                            propType = propType.directResolveAs;
+                            value = { $ref: value };
+                        }
+                        if (propType && propType.name === undefined && propType.resolvable !== false) {
+                            propType = { name: 'scalar', properties: {} };
+                        }
+                        if (!types_1.isNamedType(propType) || (propType.name === 'scalar' && !ref_utils_1.isRef(value))) {
+                            continue;
+                        }
+                        walkNode(value, propType, loc.child([propName]), resolvedNode, propName);
+                    }
+                }
+            }
+            const anyLeaveVisitors = normalizedVisitors.any.leave;
+            const currentLeaveVisitors = (((_l = normalizedVisitors[type.name]) === null || _l === void 0 ? void 0 : _l.leave) || []).concat(anyLeaveVisitors);
+            for (const context of activatedContexts.reverse()) {
+                if (context.isSkippedLevel) {
+                    context.seen.delete(resolvedNode);
+                }
+                else {
+                    context.activatedOn = utils_1.popStack(context.activatedOn);
+                    if (context.parent) {
+                        let ctx = context.parent;
+                        while (ctx) {
+                            ctx.activatedOn.value.nextLevelTypeActivated = utils_1.popStack(ctx.activatedOn.value.nextLevelTypeActivated);
+                            ctx = ctx.parent;
+                        }
+                    }
+                }
+            }
+            for (const { context, visit, ruleId, severity } of currentLeaveVisitors) {
+                if (!context.isSkippedLevel && enteredContexts.has(context)) {
+                    visitWithContext(visit, resolvedNode, context, ruleId, severity);
+                }
+            }
+        }
+        currentLocation = location;
+        if (ref_utils_1.isRef(node)) {
+            const refLeaveVisitors = normalizedVisitors.ref.leave;
+            for (const { visit: visitor, ruleId, severity, context } of refLeaveVisitors) {
+                if (enteredContexts.has(context)) {
+                    const report = reportFn.bind(undefined, ruleId, severity);
+                    visitor(node, {
+                        report,
+                        resolve,
+                        location,
+                        type,
+                        parent,
+                        key,
+                        parentLocations: {},
+                        oasVersion: ctx.oasVersion,
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
+                    }, { node: resolvedNode, location: resolvedLocation, error });
+                }
+            }
+        }
+        // returns true ignores all the next visitors on the specific node
+        function visitWithContext(visit, node, context, ruleId, severity) {
+            const report = reportFn.bind(undefined, ruleId, severity);
+            let ignoreNextVisitorsOnNode = false;
+            visit(node, {
+                report,
+                resolve,
+                location: currentLocation,
+                type,
+                parent,
+                key,
+                parentLocations: collectParentsLocations(context),
+                oasVersion: ctx.oasVersion,
+                ignoreNextVisitorsOnNode: () => { ignoreNextVisitorsOnNode = true; },
+                getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
+            }, collectParents(context), context);
+            return { ignoreNextVisitorsOnNode };
+        }
+        function resolve(ref, from = currentLocation.source.absoluteRef) {
+            if (!ref_utils_1.isRef(ref))
+                return { location, node: ref };
+            const refId = resolve_1.makeRefId(from, ref.$ref);
+            const resolvedRef = resolvedRefMap.get(refId);
+            if (!resolvedRef) {
+                return {
+                    location: undefined,
+                    node: undefined,
+                };
+            }
+            const { resolved, node, document, nodePointer, error } = resolvedRef;
+            const newLocation = resolved
+                ? new ref_utils_1.Location(document.source, nodePointer)
+                : error instanceof resolve_1.YamlParseError
+                    ? new ref_utils_1.Location(error.source, '')
+                    : undefined;
+            return { location: newLocation, node, error };
+        }
+        function reportFn(ruleId, severity, opts) {
+            const loc = opts.location
+                ? Array.isArray(opts.location)
+                    ? opts.location
+                    : [opts.location]
+                : [Object.assign(Object.assign({}, currentLocation), { reportOnKey: false })];
+            ctx.problems.push(Object.assign(Object.assign({ ruleId: opts.ruleId || ruleId, severity: opts.forceSeverity || severity }, opts), { suggest: opts.suggest || [], location: loc.map((loc) => {
+                    return Object.assign(Object.assign(Object.assign({}, currentLocation), { reportOnKey: false }), loc);
+                }) }));
+        }
+        function getVisitorDataFn(ruleId) {
+            ctx.visitorsData[ruleId] = ctx.visitorsData[ruleId] || {};
+            return ctx.visitorsData[ruleId];
+        }
+    }
+}
+exports.walkDocument = walkDocument;

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@redocly/openapi-core",
+  "version": "1.0.0-beta.100",
+  "description": "",
+  "main": "lib/index.js",
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "engineStrict": true,
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Redocly/redocly-cli.git"
+  },
+  "browser": {
+    "fs": false,
+    "path": "path-browserify",
+    "os": false,
+    "node-fetch": false
+  },
+  "homepage": "https://github.com/Redocly/redocly-cli",
+  "keywords": [
+    "linter",
+    "OpenAPI",
+    "Swagger",
+    "OpenAPI linter",
+    "Swagger linter",
+    "oas"
+  ],
+  "contributors": [
+    "Sergey Dubovyk <serhii@redoc.ly> (https://redoc.ly/)",
+    "Roman Hotsiy <roman@redoc.ly> (https://redoc.ly/)",
+    "Andriy Leliv <andriy@redoc.ly> (https://redoc.ly/)"
+  ],
+  "dependencies": {
+    "@redocly/ajv": "^8.6.4",
+    "@types/node": "^14.11.8",
+    "colorette": "^1.2.0",
+    "js-levenshtein": "^1.1.6",
+    "js-yaml": "^4.1.0",
+    "lodash.isequal": "^4.5.0",
+    "minimatch": "^5.0.1",
+    "node-fetch": "^2.6.1",
+    "pluralize": "^8.0.0",
+    "yaml-ast-parser": "0.0.43"
+  },
+  "devDependencies": {
+    "@types/js-levenshtein": "^1.1.0",
+    "@types/js-yaml": "^4.0.3",
+    "@types/lodash.isequal": "^4.5.5",
+    "@types/minimatch": "^3.0.5",
+    "@types/node-fetch": "^2.5.7",
+    "@types/pluralize": "^0.0.29",
+    "typescript": "^4.0.5"
+  }
+}

package/src/__tests__/__snapshots__/bundle.test.ts.snap

@@ -0,0 +1,255 @@
+// Jest Snapshot v1, https://goo.gl/fbAQLP
+
+exports[`bundle should bundle external refs 1`] = `
+openapi: 3.0.0
+paths:
+  /pet:
+    parameters:
+      - $ref: '#/components/parameters/path-param'
+    put:
+      parameters:
+        - $ref: '#/components/parameters/param-a'
+        - $ref: '#/components/parameters/param-b'
+        - name: test
+    get:
+      parameters:
+        - $ref: '#/components/parameters/param-a'
+        - $ref: '#/components/parameters/param-c'
+    post:
+      parameters:
+        - $ref: '#/paths/~1pet/put/parameters/2'
+components:
+  parameters:
+    param-a:
+      name: param_a
+      schema:
+        $ref: '#/components/schemas/schema-a'
+      examples:
+        first:
+          $ref: '#/components/examples/param-a-first'
+        second:
+          $ref: '#/components/examples/second'
+    path-param:
+      name: path_param
+      examples:
+        first:
+          $ref: '#/components/examples/first'
+    param-c:
+      name: param_c
+    param-b:
+      name: param_b
+  examples:
+    first:
+      value: b1
+    param-a-first:
+      value: a1
+    second:
+      value: a2
+  schemas:
+    schema-a:
+      type: string
+
+`;
+
+exports[`bundle should bundle external refs and warn for conflicting names 1`] = `
+openapi: 3.0.0
+paths:
+  /pet:
+    parameters:
+      - $ref: '#/components/parameters/path-param'
+    put:
+      parameters:
+        - $ref: '#/components/parameters/param-b'
+        - $ref: '#/components/parameters/param-b-2'
+    get:
+      parameters:
+        - $ref: '#/components/parameters/param-a'
+        - $ref: '#/components/parameters/param-c'
+components:
+  parameters:
+    param-a:
+      name: test
+    param-b:
+      name: param_b_alt
+    path-param:
+      name: path_param
+    param-c:
+      name: param_c
+    param-b-2:
+      name: param_b
+
+`;
+
+exports[`bundle should dereferenced correctly when used with dereference 1`] = `
+openapi: 3.0.0
+paths:
+  /pet:
+    get:
+      operationId: get
+      parameters:
+        - name: shared-a
+        - name: get_b
+    post:
+      operationId: post
+      parameters:
+        - name: shared-a
+components:
+  parameters:
+    shared_a:
+      name: shared-a
+
+`;
+
+exports[`bundle should not bundle url refs if used with keepUrlRefs 1`] = `
+openapi: 3.0.0
+paths:
+  /pet:
+    parameters:
+      - $ref: '#/components/parameters/path-param'
+    put:
+      parameters:
+        - $ref: https://someexternal.schema
+        - $ref: '#/components/parameters/param-b'
+        - name: test
+    get:
+      parameters:
+        - $ref: http://someexternal.schema
+        - $ref: '#/components/parameters/param-c'
+components:
+  parameters:
+    path-param:
+      name: path_param
+    param-c:
+      name: param_c
+    param-b:
+      name: param_b
+
+`;
+
+exports[`bundle should not place referened schema inline when component in question is not of type "schemas" 1`] = `
+openapi: 3.0.0
+paths:
+  /pet:
+    post:
+      requestBody:
+        content:
+          application/json:
+            schema:
+              $ref: '#/components/schemas/requestBody'
+components:
+  schemas:
+    requestBody:
+      content:
+        application/json:
+          schema:
+            type: object
+            properties:
+              a:
+                type: string
+              b:
+                type: number
+
+`;
+
+exports[`bundle should place referenced schema inline when referenced schema name resolves to original schema name 1`] = `
+openapi: 3.1.0
+info:
+  title: My API
+  description: It ain't so wonderful, but at least it's mine.
+  version: '1.0'
+  contact:
+    email: me@theintenet.com
+    name: me
+paths:
+  /test:
+    get:
+      summary: test
+      responses:
+        '200':
+          description: test
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/vendor.schema'
+components:
+  schemas:
+    vendor:
+      $ref: '#/components/schemas/vendor.schema'
+    myvendor:
+      $ref: '#/components/schemas/vendor.schema'
+    simple:
+      type: string
+    A:
+      type: string
+    test:
+      $ref: '#/components/schemas/rename-2'
+    rename:
+      type: string
+    rename-2:
+      type: number
+    vendor.schema:
+      title: vendor
+      type: object
+      description: Vendors
+      properties:
+        key:
+          type: string
+          description: System-assigned key for the vendor.
+          readOnly: true
+        id:
+          type: string
+          description: >
+            Unique identifier of the vendor.
+
+            You must specify a unique vendor ID when creating a vendor unless
+            document sequencing is configured, in which case the ID is
+            auto-generated.
+        name:
+          type: string
+          description: Name of the vendor.
+        isOneTimeUse:
+          type: boolean
+          description: One-time use
+          default: false
+
+`;
+
+exports[`bundle should pull hosted schema 1`] = `
+openapi: 3.0.3
+info:
+  title: bugtest
+  version: '1.0'
+  description: Demo
+  license:
+    name: DEMO
+    url: https://demo.com
+servers:
+  - url: http://demo.com/api
+paths:
+  /customer:
+    summary: Customer scope
+    get:
+      summary: Get demo no refs
+      operationId: GetCustomer
+      description: Returns Demo No Refs
+      responses:
+        '200':
+          description: Demo No Refs
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/Customer'
+components:
+  schemas:
+    Customer:
+      type: object
+      properties:
+        customerName:
+          type: string
+        accounts:
+          type: array
+          items:
+            $ref: '#/components/schemas/someexternal'
+    someexternal: External schema content
+
+`;