@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/redocly/index.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedoclyClient = exports.TOKEN_FILENAME = void 0;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const registry_api_1 = require("./registry-api");
+const env_1 = require("../env");
+const utils_1 = require("../utils");
+const logger_1 = require("../logger");
+const domains_1 = require("./domains");
+exports.TOKEN_FILENAME = '.redocly-config.json';
+class RedoclyClient {
+    constructor(region) {
+        this.accessTokens = {};
+        this.region = this.loadRegion(region);
+        this.loadTokens();
+        this.domain = region ? domains_1.DOMAINS[region] : env_1.env.REDOCLY_DOMAIN || domains_1.DOMAINS[domains_1.DEFAULT_REGION];
+        (0, domains_1.setRedoclyDomain)(this.domain);
+        this.registryApi = new registry_api_1.RegistryApi(this.accessTokens, this.region);
+    }
+    loadRegion(region) {
+        if (region && !domains_1.DOMAINS[region]) {
+            throw new Error(`Invalid argument: region in config file.\nGiven: ${logger_1.colorize.green(region)}, choices: "us", "eu".`);
+        }
+        if ((0, domains_1.getRedoclyDomain)()) {
+            return (domains_1.AVAILABLE_REGIONS.find((region) => domains_1.DOMAINS[region] === (0, domains_1.getRedoclyDomain)()) || domains_1.DEFAULT_REGION);
+        }
+        return region || domains_1.DEFAULT_REGION;
+    }
+    getRegion() {
+        return this.region;
+    }
+    hasTokens() {
+        return (0, utils_1.isNotEmptyObject)(this.accessTokens);
+    }
+    // <backward compatibility: old versions of portal>
+    hasToken() {
+        return !!this.accessTokens[this.region];
+    }
+    async getAuthorizationHeader() {
+        return this.accessTokens[this.region];
+    }
+    // </backward compatibility: portal>
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+    }
+    loadTokens() {
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);
+        const credentials = this.readCredentialsFile(credentialsPath);
+        if ((0, utils_1.isNotEmptyObject)(credentials)) {
+            this.setAccessTokens({
+                ...credentials,
+                ...(credentials.token &&
+                    !credentials[this.region] && {
+                    [this.region]: credentials.token,
+                }),
+            });
+        }
+        if (env_1.env.REDOCLY_AUTHORIZATION) {
+            this.setAccessTokens({
+                ...this.accessTokens,
+                [this.region]: env_1.env.REDOCLY_AUTHORIZATION,
+            });
+        }
+    }
+    getAllTokens() {
+        return Object.entries(this.accessTokens)
+            .filter(([region]) => domains_1.AVAILABLE_REGIONS.includes(region))
+            .map(([region, token]) => ({ region, token }));
+    }
+    async getValidTokens() {
+        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() {
+        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() {
+        return this.hasTokens() && (0, utils_1.isNotEmptyArray)(await this.getValidTokens());
+    }
+    readCredentialsFile(credentialsPath) {
+        return (0, fs_1.existsSync)(credentialsPath) ? JSON.parse((0, fs_1.readFileSync)(credentialsPath, 'utf-8')) : {};
+    }
+    async verifyToken(accessToken, verbose = false) {
+        return this.registryApi.authStatus(accessToken, verbose);
+    }
+    async login(accessToken, verbose = false) {
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.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);
+        (0, fs_1.writeFileSync)(credentialsPath, JSON.stringify(credentials, null, 2));
+    }
+    logout() {
+        const credentialsPath = (0, path_1.resolve)((0, os_1.homedir)(), exports.TOKEN_FILENAME);
+        if ((0, fs_1.existsSync)(credentialsPath)) {
+            (0, fs_1.unlinkSync)(credentialsPath);
+        }
+    }
+}
+exports.RedoclyClient = RedoclyClient;

package/lib/redocly/redocly-client-types.d.ts

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

package/lib/redocly/redocly-client-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/redocly/registry-api-types.d.ts

@@ -0,0 +1,29 @@
+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';
+}
+export {};

package/lib/redocly/registry-api-types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/redocly/registry-api.d.ts

@@ -0,0 +1,17 @@
+import type { PrepareFileuploadOKResponse, PrepareFileuploadParams, PushApiParams } from './registry-api-types';
+import type { AccessTokens, Region } from '../config/types';
+export declare class RegistryApi {
+    private accessTokens;
+    private region;
+    constructor(accessTokens: AccessTokens, region: Region);
+    get accessToken(): string | false | undefined;
+    getBaseUrl(): string;
+    setAccessTokens(accessTokens: AccessTokens): this;
+    private request;
+    authStatus(accessToken: string, verbose?: boolean): Promise<{
+        viewerId: string;
+        organizations: string[];
+    }>;
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }: PrepareFileuploadParams): Promise<PrepareFileuploadOKResponse>;
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, isPublic, batchId, batchSize, }: PushApiParams): Promise<void>;
+}

package/lib/redocly/registry-api.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryApi = void 0;
+const node_fetch_1 = require("node-fetch");
+const utils_1 = require("../utils");
+const domains_1 = require("./domains");
+const version = require('../../package.json').version;
+class RegistryApi {
+    constructor(accessTokens, region) {
+        this.accessTokens = accessTokens;
+        this.region = region;
+    }
+    get accessToken() {
+        return (0, utils_1.isNotEmptyObject)(this.accessTokens) && this.accessTokens[this.region];
+    }
+    getBaseUrl() {
+        return `https://api.${(0, domains_1.getRedoclyDomain)()}/registry`;
+    }
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+        return this;
+    }
+    async request(path = '', options = {}) {
+        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 (0, node_fetch_1.default)(`${this.getBaseUrl()}${path}`, Object.assign({}, options, { headers, agent: (0, utils_1.getProxyAgent)() }));
+        if (response.status === 401) {
+            throw new Error('Unauthorized');
+        }
+        if (response.status === 404) {
+            const body = await response.json();
+            throw new Error(body.code);
+        }
+        return response;
+    }
+    async authStatus(accessToken, verbose = false) {
+        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, }) {
+        const response = await this.request(`/${organizationId}/${name}/${version}/prepare-file-upload`, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+                authorization: this.accessToken,
+            },
+            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, }) {
+        const response = await this.request(`/${organizationId}/${name}/${version}`, {
+            method: 'PUT',
+            headers: {
+                'content-type': 'application/json',
+                authorization: this.accessToken,
+            },
+            body: JSON.stringify({
+                rootFilePath,
+                filePaths,
+                branch,
+                isUpsert,
+                isPublic,
+                batchId,
+                batchSize,
+            }),
+        });
+        if (response.ok) {
+            return;
+        }
+        throw new Error('Could not push api');
+    }
+}
+exports.RegistryApi = RegistryApi;

package/lib/ref-utils.d.ts

@@ -0,0 +1,27 @@
+import type { Source } from './resolve';
+import type { OasRef } from './typings/openapi';
+export declare function joinPointer(base: string, key: string | number): string;
+export declare function isRef(node: unknown): node is OasRef;
+export declare function isExternalValue(node: unknown): boolean;
+export declare class Location {
+    source: Source;
+    pointer: string;
+    constructor(source: Source, pointer: string);
+    child(components: (string | number)[] | string | number): Location;
+    key(): this & {
+        reportOnKey: boolean;
+    };
+    get absolutePointer(): string;
+}
+export declare function unescapePointer(fragment: string): string;
+export declare function escapePointer<T extends string | number>(fragment: T): T;
+export declare function parseRef(ref: string): {
+    uri: string | null;
+    pointer: string[];
+};
+export declare function parsePointer(pointer: string): string[];
+export declare function pointerBaseName(pointer: string): string;
+export declare function refBaseName(ref: string): string;
+export declare function isAbsoluteUrl(ref: string): boolean;
+export declare function isMappingRef(mapping: string): boolean;
+export declare function isAnchor(ref: string): boolean;

package/lib/ref-utils.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Location = void 0;
+exports.joinPointer = joinPointer;
+exports.isRef = isRef;
+exports.isExternalValue = isExternalValue;
+exports.unescapePointer = unescapePointer;
+exports.escapePointer = escapePointer;
+exports.parseRef = parseRef;
+exports.parsePointer = parsePointer;
+exports.pointerBaseName = pointerBaseName;
+exports.refBaseName = refBaseName;
+exports.isAbsoluteUrl = isAbsoluteUrl;
+exports.isMappingRef = isMappingRef;
+exports.isAnchor = isAnchor;
+const utils_1 = require("./utils");
+function joinPointer(base, key) {
+    if (base === '')
+        base = '#/';
+    return base[base.length - 1] === '/' ? base + key : base + '/' + key;
+}
+function isRef(node) {
+    return (0, utils_1.isPlainObject)(node) && typeof node.$ref === 'string';
+}
+function isExternalValue(node) {
+    return (0, utils_1.isPlainObject)(node) && typeof node.externalValue === 'string';
+}
+class Location {
+    constructor(source, pointer) {
+        this.source = source;
+        this.pointer = pointer;
+    }
+    child(components) {
+        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);
+    }
+}
+exports.Location = Location;
+function unescapePointer(fragment) {
+    return decodeURIComponent(fragment.replace(/~1/g, '/').replace(/~0/g, '~'));
+}
+function escapePointer(fragment) {
+    if (typeof fragment === 'number')
+        return fragment;
+    return fragment.replace(/~/g, '~0').replace(/\//g, '~1');
+}
+function parseRef(ref) {
+    const [uri, pointer = ''] = ref.split('#/');
+    return {
+        uri: (uri.endsWith('#') ? uri.slice(0, -1) : uri) || null,
+        pointer: parsePointer(pointer),
+    };
+}
+function parsePointer(pointer) {
+    return pointer.split('/').map(unescapePointer).filter(utils_1.isTruthy);
+}
+function pointerBaseName(pointer) {
+    const parts = pointer.split('/');
+    return parts[parts.length - 1];
+}
+function refBaseName(ref) {
+    // 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
+}
+function isAbsoluteUrl(ref) {
+    return ref.startsWith('http://') || ref.startsWith('https://');
+}
+function isMappingRef(mapping) {
+    // TODO: proper detection of mapping refs
+    return (mapping.startsWith('#') ||
+        mapping.startsWith('https://') ||
+        mapping.startsWith('http://') ||
+        mapping.startsWith('./') ||
+        mapping.startsWith('../') ||
+        mapping.indexOf('/') > -1);
+}
+function isAnchor(ref) {
+    return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(ref);
+}

package/lib/resolve.d.ts

@@ -0,0 +1,66 @@
+import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
+import type { NormalizedNodeType } from './types';
+import type { ResolveConfig } from './config/types';
+export type CollectedRefs = Map<string, Document>;
+export declare class Source {
+    absoluteRef: string;
+    body: string;
+    mimeType?: string | undefined;
+    constructor(absoluteRef: string, body: string, mimeType?: string | undefined);
+    private _ast;
+    private _lines;
+    getAst(safeLoad: (input: string, options?: LoadOptions | undefined) => YAMLNode): YAMLNode;
+    getLines(): string[];
+}
+export declare class ResolveError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}
+export declare class YamlParseError extends Error {
+    originalError: Error;
+    source: Source;
+    col: number;
+    line: number;
+    constructor(originalError: Error, source: Source);
+}
+export type Document = {
+    source: Source;
+    parsed: any;
+};
+export declare function makeRefId(absoluteRef: string, pointer: string): string;
+export declare function makeDocumentFromString(sourceString: string, absoluteRef: string): {
+    source: Source;
+    parsed: unknown;
+};
+export declare class BaseResolver {
+    protected config: ResolveConfig;
+    cache: Map<string, Promise<Document | ResolveError>>;
+    constructor(config?: ResolveConfig);
+    getFiles(): Set<string>;
+    resolveExternalRef(base: string | null, ref: string): string;
+    loadExternalRef(absoluteRef: string): Promise<Source>;
+    parseDocument(source: Source, isRoot?: boolean): Document;
+    resolveDocument(base: string | null, ref: string, isRoot?: boolean): Promise<Document | ResolveError | YamlParseError>;
+}
+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>;
+export declare function resolveDocument(opts: {
+    rootDocument: Document;
+    externalRefResolver: BaseResolver;
+    rootType: NormalizedNodeType;
+}): Promise<ResolvedRefMap>;