@redocly/openapi-core 1.34.4 → 2.0.0-next.0

package/src/redocly/index.ts

@@ -1,177 +0,0 @@
-import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
-import { resolve } from 'path';
-import { homedir } from 'os';
-import { RegistryApi } from './registry-api';
-import { env } from '../env';
-import { isNotEmptyArray, isNotEmptyObject } from '../utils';
-import { colorize } from '../logger';
-import {
-  AVAILABLE_REGIONS,
-  DEFAULT_REGION,
-  DOMAINS,
-  getRedoclyDomain,
-  setRedoclyDomain,
-} from './domains';
-
-import type { RegionalToken, RegionalTokenWithValidity } from './redocly-client-types';
-import type { AccessTokens, Region } from '../config/types';
-
-export const TOKEN_FILENAME = '.redocly-config.json';
-
-export class RedoclyClient {
-  private accessTokens: AccessTokens = {};
-  private region: Region;
-  domain: string;
-  registryApi: RegistryApi;
-
-  constructor(region?: Region) {
-    this.region = this.loadRegion(region);
-    this.loadTokens();
-    this.domain = region ? DOMAINS[region] : env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
-
-    setRedoclyDomain(this.domain);
-    this.registryApi = new RegistryApi(this.accessTokens, this.region);
-  }
-
-  loadRegion(region?: Region) {
-    if (region && !DOMAINS[region]) {
-      throw new Error(
-        `Invalid argument: region in config file.\nGiven: ${colorize.green(
-          region
-        )}, choices: "us", "eu".`
-      );
-    }
-
-    if (getRedoclyDomain()) {
-      return (AVAILABLE_REGIONS.find(
-        (region) => DOMAINS[region as Region] === getRedoclyDomain()
-      ) || DEFAULT_REGION) as Region;
-    }
-    return region || DEFAULT_REGION;
-  }
-
-  getRegion(): Region {
-    return this.region;
-  }
-
-  hasTokens(): boolean {
-    return isNotEmptyObject(this.accessTokens);
-  }
-
-  // <backward compatibility: old versions of portal>
-  hasToken() {
-    return !!this.accessTokens[this.region];
-  }
-
-  async getAuthorizationHeader(): Promise<string | undefined> {
-    return this.accessTokens[this.region];
-  }
-  // </backward compatibility: portal>
-
-  setAccessTokens(accessTokens: AccessTokens) {
-    this.accessTokens = accessTokens;
-  }
-
-  loadTokens(): void {
-    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
-    const credentials = this.readCredentialsFile(credentialsPath);
-    if (isNotEmptyObject(credentials)) {
-      this.setAccessTokens({
-        ...credentials,
-        ...(credentials.token &&
-          !credentials[this.region] && {
-            [this.region]: credentials.token,
-          }),
-      });
-    }
-    if (env.REDOCLY_AUTHORIZATION) {
-      this.setAccessTokens({
-        ...this.accessTokens,
-        [this.region]: env.REDOCLY_AUTHORIZATION,
-      });
-    }
-  }
-
-  getAllTokens(): RegionalToken[] {
-    return (<[Region, string][]>Object.entries(this.accessTokens))
-      .filter(([region]) => AVAILABLE_REGIONS.includes(region))
-      .map(([region, token]) => ({ region, token }));
-  }
-
-  async getValidTokens(): Promise<RegionalTokenWithValidity[]> {
-    const allTokens = this.getAllTokens();
-
-    const verifiedTokens = await Promise.allSettled(
-      allTokens.map(({ token }) => this.verifyToken(token))
-    );
-
-    return allTokens
-      .filter((_, index) => verifiedTokens[index].status === 'fulfilled')
-      .map(({ token, region }) => ({ token, region, valid: true }));
-  }
-
-  async getTokens() {
-    return this.hasTokens() ? await this.getValidTokens() : [];
-  }
-
-  async isAuthorizedWithRedoclyByRegion(): Promise<boolean> {
-    if (!this.hasTokens()) {
-      return false;
-    }
-
-    const accessToken = this.accessTokens[this.region];
-
-    if (!accessToken) {
-      return false;
-    }
-
-    try {
-      await this.verifyToken(accessToken);
-
-      return true;
-    } catch (err) {
-      return false;
-    }
-  }
-
-  async isAuthorizedWithRedocly(): Promise<boolean> {
-    return this.hasTokens() && isNotEmptyArray(await this.getValidTokens());
-  }
-
-  readCredentialsFile(credentialsPath: string) {
-    return existsSync(credentialsPath) ? JSON.parse(readFileSync(credentialsPath, 'utf-8')) : {};
-  }
-
-  async verifyToken(
-    accessToken: string,
-    verbose: boolean = false
-  ): Promise<{ viewerId: string; organizations: string[] }> {
-    return this.registryApi.authStatus(accessToken, verbose);
-  }
-
-  async login(accessToken: string, verbose: boolean = false) {
-    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
-
-    try {
-      await this.verifyToken(accessToken, verbose);
-    } catch (err) {
-      throw new Error('Authorization failed. Please check if you entered a valid API key.');
-    }
-
-    const credentials = {
-      ...this.readCredentialsFile(credentialsPath),
-      [this.region]: accessToken,
-      token: accessToken, // FIXME: backward compatibility, remove on 1.0.0
-    };
-    this.accessTokens = credentials;
-    this.registryApi.setAccessTokens(credentials);
-    writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
-  }
-
-  logout(): void {
-    const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
-    if (existsSync(credentialsPath)) {
-      unlinkSync(credentialsPath);
-    }
-  }
-}

package/src/redocly/redocly-client-types.ts

@@ -1,10 +0,0 @@
-import type { Region } from '../config/types';
-
-export interface RegionalToken {
-  region: Region;
-  token: string;
-}
-
-export interface RegionalTokenWithValidity extends RegionalToken {
-  valid: boolean;
-}

package/src/redocly/registry-api-types.ts

@@ -1,32 +0,0 @@
-interface VersionParams {
-  organizationId: string;
-  name: string;
-  version: string;
-}
-
-export interface PrepareFileuploadParams extends VersionParams {
-  filesHash: string;
-  filename: string;
-  isUpsert?: boolean;
-}
-
-export interface PushApiParams extends VersionParams {
-  rootFilePath: string;
-  filePaths: string[];
-  branch?: string;
-  isUpsert?: boolean;
-  isPublic?: boolean;
-  batchId?: string;
-  batchSize?: number;
-}
-
-export interface PrepareFileuploadOKResponse {
-  filePath: string;
-  signedUploadUrl: string;
-}
-
-export interface NotFoundProblemResponse {
-  status: 404;
-  title: 'Not Found';
-  code: 'ORGANIZATION_NOT_FOUND' | 'API_VERSION_NOT_FOUND';
-}

package/src/redocly/registry-api.ts

@@ -1,147 +0,0 @@
-import { getProxyAgent, isNotEmptyObject } from '../utils';
-import { getRedoclyDomain } from './domains';
-
-import type {
-  NotFoundProblemResponse,
-  PrepareFileuploadOKResponse,
-  PrepareFileuploadParams,
-  PushApiParams,
-} from './registry-api-types';
-import type { AccessTokens, Region } from '../config/types';
-
-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() {
-    return `https://api.${getRedoclyDomain()}/registry`;
-  }
-
-  setAccessTokens(accessTokens: AccessTokens) {
-    this.accessTokens = accessTokens;
-    return this;
-  }
-
-  private async request(path = '', options: RequestInit = {}) {
-    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 requestOptions = {
-      ...options,
-      headers,
-      agent: getProxyAgent(),
-    };
-
-    const response = await fetch(`${this.getBaseUrl()}${path}`, requestOptions);
-
-    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,
-    verbose = false
-  ): Promise<{ viewerId: string; organizations: string[] }> {
-    try {
-      const response = await this.request('', { headers: { authorization: accessToken } });
-
-      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,
-        }),
-      }
-    );
-
-    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,
-      }),
-    });
-
-    if (response.ok) {
-      return;
-    }
-
-    throw new Error('Could not push api');
-  }
-}

package/src/ref-utils.ts

@@ -1,91 +0,0 @@
-import { isPlainObject, isTruthy } from './utils';
-
-import type { Source } from './resolve';
-import type { OasRef } from './typings/openapi';
-
-export function joinPointer(base: string, key: string | number) {
-  if (base === '') base = '#/';
-  return base[base.length - 1] === '/' ? base + key : base + '/' + key;
-}
-
-export function isRef(node: unknown): node is OasRef {
-  return isPlainObject(node) && typeof node.$ref === 'string';
-}
-
-export function isExternalValue(node: unknown) {
-  return isPlainObject(node) && typeof node.externalValue === '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.endsWith('#') ? uri.slice(0, -1) : uri) || null,
-    pointer: parsePointer(pointer),
-  };
-}
-
-export function parsePointer(pointer: string) {
-  return pointer.split('/').map(unescapePointer).filter(isTruthy);
-}
-
-export function pointerBaseName(pointer: string) {
-  const parts = pointer.split('/');
-  return parts[parts.length - 1];
-}
-
-export function refBaseName(ref: string) {
-  // eslint-disable-next-line no-useless-escape
-  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);
-}