@redocly/openapi-core 1.0.0-beta.125 → 1.0.0-beta.127

package/src/redocly/registry-api.ts

@@ -1,149 +0,0 @@
-import fetch, { RequestInit, HeadersInit } from 'node-fetch';
-import type {
-  NotFoundProblemResponse,
-  PrepareFileuploadOKResponse,
-  PrepareFileuploadParams,
-  PushApiParams,
-} from './registry-api-types';
-import type { AccessTokens, Region } from '../config/types';
-import { DEFAULT_REGION, DOMAINS } from '../config/config';
-import { isNotEmptyObject } from '../utils';
-const version = require('../../package.json').version;
-
-export class RegistryApi {
-  constructor(private accessTokens: AccessTokens, private region: Region) {}
-
-  get accessToken() {
-    return isNotEmptyObject(this.accessTokens) && this.accessTokens[this.region];
-  }
-
-  getBaseUrl(region: Region = DEFAULT_REGION) {
-    return `https://api.${DOMAINS[region]}/registry`;
-  }
-
-  setAccessTokens(accessTokens: AccessTokens) {
-    this.accessTokens = accessTokens;
-    return this;
-  }
-
-  private async request(path = '', options: RequestInit = {}, region?: Region) {
-    const currentCommand =
-      typeof process !== 'undefined' ? process.env?.REDOCLY_CLI_COMMAND || '' : '';
-    const redoclyEnv = typeof process !== 'undefined' ? process.env?.REDOCLY_ENVIRONMENT || '' : '';
-
-    const headers = Object.assign({}, options.headers || {}, {
-      'x-redocly-cli-version': version,
-      'user-agent': `redocly-cli / ${version} ${currentCommand} ${redoclyEnv}`,
-    });
-
-    if (!headers.hasOwnProperty('authorization')) {
-      throw new Error('Unauthorized');
-    }
-
-    const response = await fetch(
-      `${this.getBaseUrl(region)}${path}`,
-      Object.assign({}, options, { headers })
-    );
-
-    if (response.status === 401) {
-      throw new Error('Unauthorized');
-    }
-
-    if (response.status === 404) {
-      const body: NotFoundProblemResponse = await response.json();
-      throw new Error(body.code);
-    }
-
-    return response;
-  }
-
-  async authStatus(
-    accessToken: string,
-    region: Region,
-    verbose = false
-  ): Promise<{ viewerId: string; organizations: string[] }> {
-    try {
-      const response = await this.request('', { headers: { authorization: accessToken } }, region);
-
-      return await response.json();
-    } catch (error) {
-      if (verbose) {
-        console.log(error);
-      }
-
-      throw error;
-    }
-  }
-
-  async prepareFileUpload({
-    organizationId,
-    name,
-    version,
-    filesHash,
-    filename,
-    isUpsert,
-  }: PrepareFileuploadParams): Promise<PrepareFileuploadOKResponse> {
-    const response = await this.request(
-      `/${organizationId}/${name}/${version}/prepare-file-upload`,
-      {
-        method: 'POST',
-        headers: {
-          'content-type': 'application/json',
-          authorization: this.accessToken,
-        } as HeadersInit,
-        body: JSON.stringify({
-          filesHash,
-          filename,
-          isUpsert,
-        }),
-      },
-      this.region
-    );
-
-    if (response.ok) {
-      return response.json();
-    }
-
-    throw new Error('Could not prepare file upload');
-  }
-
-  async pushApi({
-    organizationId,
-    name,
-    version,
-    rootFilePath,
-    filePaths,
-    branch,
-    isUpsert,
-    isPublic,
-    batchId,
-    batchSize,
-  }: PushApiParams) {
-    const response = await this.request(
-      `/${organizationId}/${name}/${version}`,
-      {
-        method: 'PUT',
-        headers: {
-          'content-type': 'application/json',
-          authorization: this.accessToken,
-        } as HeadersInit,
-        body: JSON.stringify({
-          rootFilePath,
-          filePaths,
-          branch,
-          isUpsert,
-          isPublic,
-          batchId,
-          batchSize,
-        }),
-      },
-      this.region
-    );
-
-    if (response.ok) {
-      return;
-    }
-
-    throw new Error('Could not push api');
-  }
-}

package/src/ref-utils.ts

@@ -1,85 +0,0 @@
-import { Source } from './resolve';
-import { OasRef } from './typings/openapi';
-import { isTruthy } from './utils';
-
-export function joinPointer(base: string, key: string | number) {
-  if (base === '') base = '#/';
-  return base[base.length - 1] === '/' ? base + key : base + '/' + key;
-}
-
-export function isRef(node: any): node is OasRef {
-  return node && typeof node.$ref === 'string';
-}
-
-export class Location {
-  constructor(public source: Source, public pointer: string) {}
-
-  child(components: (string | number)[] | string | number) {
-    return new Location(
-      this.source,
-      joinPointer(
-        this.pointer,
-        (Array.isArray(components) ? components : [components]).map(escapePointer).join('/')
-      )
-    );
-  }
-
-  key() {
-    return { ...this, reportOnKey: true };
-  }
-
-  get absolutePointer() {
-    return this.source.absoluteRef + (this.pointer === '#/' ? '' : this.pointer);
-  }
-}
-
-export function unescapePointer(fragment: string): string {
-  return decodeURIComponent(fragment.replace(/~1/g, '/').replace(/~0/g, '~'));
-}
-
-export function escapePointer<T extends string | number>(fragment: T): T {
-  if (typeof fragment === 'number') return fragment;
-  return (fragment as string).replace(/~/g, '~0').replace(/\//g, '~1') as T;
-}
-
-export function parseRef(ref: string): { uri: string | null; pointer: string[] } {
-  const [uri, pointer] = ref.split('#/');
-  return {
-    uri: uri || null,
-    pointer: pointer ? pointer.split('/').map(unescapePointer).filter(isTruthy) : [],
-  };
-}
-
-export function parsePointer(pointer: string) {
-  return pointer.substr(2).split('/').map(unescapePointer);
-}
-
-export function pointerBaseName(pointer: string) {
-  const parts = pointer.split('/');
-  return parts[parts.length - 1];
-}
-
-export function refBaseName(ref: string) {
-  const parts = ref.split(/[\/\\]/); // split by '\' and '/'
-  return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
-}
-
-export function isAbsoluteUrl(ref: string) {
-  return ref.startsWith('http://') || ref.startsWith('https://');
-}
-
-export function isMappingRef(mapping: string) {
-  // TODO: proper detection of mapping refs
-  return (
-    mapping.startsWith('#') ||
-    mapping.startsWith('https://') ||
-    mapping.startsWith('http://') ||
-    mapping.startsWith('./') ||
-    mapping.startsWith('../') ||
-    mapping.indexOf('/') > -1
-  );
-}
-
-export function isAnchor(ref: string) {
-  return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(ref);
-}

package/src/resolve.ts

@@ -1,412 +0,0 @@
-import * as fs from 'fs';
-import * as path from 'path';
-import { OasRef } from './typings/openapi';
-import { isRef, joinPointer, escapePointer, parseRef, isAbsoluteUrl, isAnchor } from './ref-utils';
-import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
-import { NormalizedNodeType, isNamedType, SpecExtension } from './types';
-import { readFileFromUrl, parseYaml, nextTick } from './utils';
-import { ResolveConfig } from './config/types';
-
-export type CollectedRefs = Map<string /* absoluteFilePath */, Document>;
-
-export class Source {
-  constructor(public absoluteRef: string, public body: string, public mimeType?: string) {}
-
-  private _ast: YAMLNode | undefined;
-  private _lines: string[] | undefined;
-
-  // pass safeLoad as argument to separate it from browser bundle
-  getAst(safeLoad: (input: string, options?: LoadOptions | undefined) => YAMLNode) {
-    if (this._ast === undefined) {
-      this._ast = safeLoad(this.body, { filename: this.absoluteRef }) ?? undefined;
-
-      // fix ast representation of file with newlines only
-      if (
-        this._ast &&
-        this._ast.kind === 0 && // KIND.scalar = 0
-        this._ast.value === '' &&
-        this._ast.startPosition !== 1
-      ) {
-        this._ast.startPosition = 1;
-        this._ast.endPosition = 1;
-      }
-    }
-    return this._ast;
-  }
-
-  getLines() {
-    if (this._lines === undefined) {
-      this._lines = this.body.split(/\r\n|[\n\r]/g);
-    }
-    return this._lines;
-  }
-}
-
-export class ResolveError extends Error {
-  constructor(public originalError: Error) {
-    super(originalError.message);
-    // Set the prototype explicitly.
-    Object.setPrototypeOf(this, ResolveError.prototype);
-  }
-}
-
-const jsYamlErrorLineColRegexp = /\((\d+):(\d+)\)$/;
-
-export class YamlParseError extends Error {
-  col: number;
-  line: number;
-
-  constructor(public originalError: Error, public source: Source) {
-    super(originalError.message.split('\n')[0]);
-    // Set the prototype explicitly.
-    Object.setPrototypeOf(this, YamlParseError.prototype);
-
-    const [, line, col] = this.message.match(jsYamlErrorLineColRegexp) || [];
-    this.line = parseInt(line, 10);
-    this.col = parseInt(col, 10);
-  }
-}
-
-export type Document = {
-  source: Source;
-  parsed: any;
-};
-
-export function makeRefId(absoluteRef: string, pointer: string) {
-  return absoluteRef + '::' + pointer;
-}
-
-export function makeDocumentFromString(sourceString: string, absoluteRef: string) {
-  const source = new Source(absoluteRef, sourceString);
-  try {
-    return {
-      source,
-      parsed: parseYaml(sourceString, { filename: absoluteRef }),
-    };
-  } catch (e) {
-    throw new YamlParseError(e, source);
-  }
-}
-
-export class BaseResolver {
-  cache: Map<string, Promise<Document | ResolveError>> = new Map();
-
-  constructor(protected config: ResolveConfig = { http: { headers: [] } }) {}
-
-  getFiles() {
-    return new Set(Array.from(this.cache.keys()));
-  }
-
-  resolveExternalRef(base: string | null, ref: string): string {
-    if (isAbsoluteUrl(ref)) {
-      return ref;
-    }
-
-    if (base && isAbsoluteUrl(base)) {
-      return new URL(ref, base).href;
-    }
-
-    return path.resolve(base ? path.dirname(base) : process.cwd(), ref);
-  }
-
-  async loadExternalRef(absoluteRef: string): Promise<Source> {
-    try {
-      if (isAbsoluteUrl(absoluteRef)) {
-        const { body, mimeType } = await readFileFromUrl(absoluteRef, this.config.http);
-        return new Source(absoluteRef, body, mimeType);
-      } else {
-        const content = await fs.promises.readFile(absoluteRef, 'utf-8');
-        // In some cases file have \r\n line delimeters like on windows, we should skip it.
-        return new Source(absoluteRef, content.replace(/\r\n/g, '\n'));
-      }
-    } catch (error) {
-      throw new ResolveError(error);
-    }
-  }
-
-  parseDocument(source: Source, isRoot: boolean = false): Document {
-    const ext = source.absoluteRef.substr(source.absoluteRef.lastIndexOf('.'));
-    if (
-      !['.json', '.json', '.yml', '.yaml'].includes(ext) &&
-      !source.mimeType?.match(/(json|yaml|openapi)/) &&
-      !isRoot // always parse root
-    ) {
-      return { source, parsed: source.body };
-    }
-
-    try {
-      return {
-        source,
-        parsed: parseYaml(source.body, { filename: source.absoluteRef }),
-      };
-    } catch (e) {
-      throw new YamlParseError(e, source);
-    }
-  }
-
-  async resolveDocument(
-    base: string | null,
-    ref: string,
-    isRoot: boolean = false
-  ): Promise<Document | ResolveError | YamlParseError> {
-    const absoluteRef = this.resolveExternalRef(base, ref);
-    const cachedDocument = this.cache.get(absoluteRef);
-    if (cachedDocument) {
-      return cachedDocument;
-    }
-
-    const doc = this.loadExternalRef(absoluteRef).then((source) => {
-      return this.parseDocument(source, isRoot);
-    });
-
-    this.cache.set(absoluteRef, doc);
-
-    return doc;
-  }
-}
-
-export type ResolvedRef =
-  | {
-      resolved: false;
-      isRemote: boolean;
-      nodePointer?: string;
-      document?: Document;
-      source?: Source;
-      error?: ResolveError | YamlParseError;
-      node?: any;
-    }
-  | {
-      resolved: true;
-      node: any;
-      document: Document;
-      nodePointer: string;
-      isRemote: boolean;
-      error?: undefined;
-    };
-
-export type ResolvedRefMap = Map<string, ResolvedRef>;
-
-type RefFrame = {
-  prev: RefFrame | null;
-  node: any;
-};
-
-function pushRef(head: RefFrame, node: any): RefFrame {
-  return {
-    prev: head,
-    node,
-  };
-}
-
-function hasRef(head: RefFrame | null, node: any): boolean {
-  while (head) {
-    if (head.node === node) {
-      return true;
-    }
-    head = head.prev;
-  }
-  return false;
-}
-
-const unknownType = { name: 'unknown', properties: {} };
-const resolvableScalarType = { name: 'scalar', properties: {} };
-
-export async function resolveDocument(opts: {
-  rootDocument: Document;
-  externalRefResolver: BaseResolver;
-  rootType: NormalizedNodeType;
-}): Promise<ResolvedRefMap> {
-  const { rootDocument, externalRefResolver, rootType } = opts;
-  const resolvedRefMap: ResolvedRefMap = new Map();
-  const seedNodes = new Set<string>(); // format "${type}::${absoluteRef}${pointer}"
-
-  const resolvePromises: Array<Promise<void>> = [];
-  resolveRefsInParallel(rootDocument.parsed, rootDocument, '#/', rootType);
-
-  let resolved;
-  do {
-    resolved = await Promise.all(resolvePromises);
-  } while (resolvePromises.length !== resolved.length);
-
-  return resolvedRefMap;
-
-  function resolveRefsInParallel(
-    rootNode: any,
-    rootNodeDocument: Document,
-    rootNodePointer: string,
-    type: any
-  ) {
-    const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
-    const anchorRefsMap: Map<string, any> = new Map();
-
-    walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
-
-    function walk(node: any, type: NormalizedNodeType, nodeAbsoluteRef: string) {
-      if (typeof node !== 'object' || node === null) {
-        return;
-      }
-
-      const nodeId = `${type.name}::${nodeAbsoluteRef}`;
-      if (seedNodes.has(nodeId)) {
-        return;
-      }
-
-      seedNodes.add(nodeId);
-
-      const [_, anchor] = Object.entries(node).find(([key]) => key === '$anchor') || [];
-      if (anchor) {
-        anchorRefsMap.set(`#${anchor}`, node);
-      }
-
-      if (Array.isArray(node)) {
-        const itemsType = type.items;
-        // we continue resolving unknown types, but stop early on known scalars
-        if (type !== unknownType && itemsType === undefined) {
-          return;
-        }
-        for (let i = 0; i < node.length; i++) {
-          walk(node[i], itemsType || unknownType, joinPointer(nodeAbsoluteRef, i));
-        }
-        return;
-      }
-
-      for (const propName of Object.keys(node)) {
-        let propValue = node[propName];
-        let propType = type.properties[propName];
-        if (propType === undefined) propType = type.additionalProperties;
-        if (typeof propType === 'function') propType = propType(propValue, propName);
-        if (propType === undefined) propType = unknownType;
-        if (
-          type.extensionsPrefix &&
-          propName.startsWith(type.extensionsPrefix) &&
-          propType === unknownType
-        ) {
-          propType = SpecExtension;
-        }
-
-        if (!isNamedType(propType) && propType?.directResolveAs) {
-          propType = propType.directResolveAs;
-          propValue = { $ref: propValue };
-        }
-
-        if (propType && propType.name === undefined && propType.resolvable !== false) {
-          propType = resolvableScalarType;
-        }
-
-        if (!isNamedType(propType) || typeof propValue !== 'object') {
-          continue;
-        }
-
-        walk(propValue, propType, joinPointer(nodeAbsoluteRef, escapePointer(propName)));
-      }
-
-      if (isRef(node)) {
-        const promise = followRef(rootNodeDocument, node, {
-          prev: null,
-          node,
-        }).then((resolvedRef) => {
-          if (resolvedRef.resolved) {
-            resolveRefsInParallel(
-              resolvedRef.node,
-              resolvedRef.document,
-              resolvedRef.nodePointer!,
-              type
-            );
-          }
-        });
-        resolvePromises.push(promise);
-      }
-    }
-
-    async function followRef(
-      document: Document,
-      ref: OasRef,
-      refStack: RefFrame
-    ): Promise<ResolvedRef> {
-      if (hasRef(refStack.prev, ref)) {
-        throw new Error('Self-referencing circular pointer');
-      }
-
-      if (isAnchor(ref.$ref)) {
-        // Wait for all anchors in the document to be collected firstly.
-        await nextTick();
-        const resolvedRef: ResolvedRef = {
-          resolved: true,
-          isRemote: false,
-          node: anchorRefsMap.get(ref.$ref),
-          document,
-          nodePointer: ref.$ref,
-        };
-        const refId = makeRefId(document.source.absoluteRef, ref.$ref);
-        resolvedRefMap.set(refId, resolvedRef);
-        return resolvedRef;
-      }
-
-      const { uri, pointer } = parseRef(ref.$ref);
-      const isRemote = uri !== null;
-      let targetDoc: Document;
-      try {
-        targetDoc = isRemote
-          ? ((await externalRefResolver.resolveDocument(
-              document.source.absoluteRef,
-              uri!
-            )) as Document)
-          : document;
-      } catch (error) {
-        const resolvedRef = {
-          resolved: false as const,
-          isRemote,
-          document: undefined,
-          error: error,
-        };
-        const refId = makeRefId(document.source.absoluteRef, ref.$ref);
-        resolvedRefMap.set(refId, resolvedRef);
-        return resolvedRef;
-      }
-
-      let resolvedRef: ResolvedRef = {
-        resolved: true,
-        document: targetDoc,
-        isRemote,
-        node: document.parsed,
-        nodePointer: '#/',
-      };
-
-      let target = targetDoc.parsed as any;
-
-      const segments = pointer;
-      for (const segment of segments) {
-        if (typeof target !== 'object') {
-          target = undefined;
-          break;
-        } else if (target[segment] !== undefined) {
-          target = target[segment];
-          resolvedRef.nodePointer = joinPointer(resolvedRef.nodePointer!, escapePointer(segment));
-        } else if (isRef(target)) {
-          resolvedRef = await followRef(targetDoc, target, pushRef(refStack, target));
-          targetDoc = resolvedRef.document || targetDoc;
-
-          if (typeof resolvedRef.node !== 'object') {
-            target = undefined;
-            break;
-          }
-
-          target = resolvedRef.node[segment];
-          resolvedRef.nodePointer = joinPointer(resolvedRef.nodePointer!, escapePointer(segment));
-        } else {
-          target = undefined;
-          break;
-        }
-      }
-
-      resolvedRef.node = target;
-      resolvedRef.document = targetDoc;
-      const refId = makeRefId(document.source.absoluteRef, ref.$ref);
-      if (resolvedRef.document && isRef(target)) {
-        resolvedRef = await followRef(resolvedRef.document, target, pushRef(refStack, target));
-      }
-      resolvedRefMap.set(refId, resolvedRef);
-      return { ...resolvedRef };
-    }
-  }
-}

package/src/rules/__tests__/fixtures/code-sample.php

@@ -1,9 +0,0 @@
-$form = new \PetStore\Entities\Pet();
-$form->setPetType("Dog");
-$form->setName("Rex");
-// set other fields
-try {
-    $pet = $client->pets()->create($form);
-} catch (UnprocessableEntityException $e) {
-    var_dump($e->getErrors());
-}

package/src/rules/__tests__/fixtures/invalid-yaml.yaml

@@ -1 +0,0 @@
-test: '

package/src/rules/__tests__/fixtures/ref.yaml

@@ -1 +0,0 @@
-test: 1