@redocly/cli 1.0.0-beta.96

package/lib/commands/preview-docs/index.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = exports.previewDocs = void 0;
+const colorette = require("colorette");
+const chockidar = require("chokidar");
+const openapi_core_1 = require("@redocly/openapi-core");
+const utils_1 = require("../../utils");
+const preview_server_1 = require("./preview-server/preview-server");
+function previewDocs(argv) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let isAuthorizedWithRedocly = false;
+        let redocOptions = {};
+        let config = yield reloadConfig();
+        const entrypoints = yield utils_1.getFallbackEntryPointsOrExit(argv.entrypoint ? [argv.entrypoint] : [], config);
+        const entrypoint = entrypoints[0];
+        let cachedBundle;
+        const deps = new Set();
+        function getBundle() {
+            return __awaiter(this, void 0, void 0, function* () {
+                return cachedBundle;
+            });
+        }
+        function updateBundle() {
+            return __awaiter(this, void 0, void 0, function* () {
+                process.stdout.write('\nBundling...\n\n');
+                try {
+                    const { bundle: openapiBundle, problems, fileDependencies, } = yield openapi_core_1.bundle({
+                        ref: entrypoint.path,
+                        config,
+                    });
+                    const removed = [...deps].filter((x) => !fileDependencies.has(x));
+                    watcher.unwatch(removed);
+                    watcher.add([...fileDependencies]);
+                    deps.clear();
+                    fileDependencies.forEach(deps.add, deps);
+                    const fileTotals = openapi_core_1.getTotals(problems);
+                    if (fileTotals.errors === 0) {
+                        process.stdout.write(fileTotals.errors === 0
+                            ? `Created a bundle for ${entrypoint.alias || entrypoint.path} ${fileTotals.warnings > 0 ? 'with warnings' : 'successfully'}\n`
+                            : colorette.yellow(`Created a bundle for ${entrypoint.alias || entrypoint.path} with errors. Docs may be broken or not accurate\n`));
+                    }
+                    return openapiBundle.parsed;
+                }
+                catch (e) {
+                    handleError(e, entrypoint.path);
+                }
+            });
+        }
+        setImmediate(() => {
+            cachedBundle = updateBundle();
+        }); // initial cache
+        const isAuthorized = isAuthorizedWithRedocly || redocOptions.licenseKey;
+        if (!isAuthorized) {
+            process.stderr.write(`Using Redoc community edition.\nLogin with redocly ${colorette.blue('login')} or use an enterprise license key to preview with the premium docs.\n\n`);
+        }
+        const hotClients = yield preview_server_1.default(argv.port, argv.host, {
+            getBundle,
+            getOptions: () => redocOptions,
+            useRedocPro: isAuthorized && !redocOptions.useCommunityEdition,
+        });
+        const watchPaths = [entrypoint.path, config.configFile].filter((e) => !!e);
+        const watcher = chockidar.watch(watchPaths, {
+            disableGlobbing: true,
+            ignoreInitial: true,
+        });
+        const debouncedUpdatedBundle = debounce(() => __awaiter(this, void 0, void 0, function* () {
+            cachedBundle = updateBundle();
+            yield cachedBundle;
+            hotClients.broadcast('{"type": "reload", "bundle": true}');
+        }), 2000);
+        const changeHandler = (type, file) => __awaiter(this, void 0, void 0, function* () {
+            process.stdout.write(`${colorette.green('watch')} ${type} ${colorette.blue(file)}\n`);
+            if (file === config.configFile) {
+                config = yield reloadConfig();
+                hotClients.broadcast(JSON.stringify({ type: 'reload' }));
+                return;
+            }
+            debouncedUpdatedBundle();
+        });
+        watcher.on('change', changeHandler.bind(undefined, 'changed'));
+        watcher.on('add', changeHandler.bind(undefined, 'added'));
+        watcher.on('unlink', changeHandler.bind(undefined, 'removed'));
+        watcher.on('ready', () => {
+            process.stdout.write(`\n  👀  Watching ${colorette.blue(entrypoint.path)} and all related resources for changes\n\n`);
+        });
+        function reloadConfig() {
+            return __awaiter(this, void 0, void 0, function* () {
+                let config = yield openapi_core_1.loadConfig(argv.config);
+                const redoclyClient = new openapi_core_1.RedoclyClient();
+                isAuthorizedWithRedocly = yield redoclyClient.isAuthorizedWithRedocly();
+                const resolvedConfig = openapi_core_1.getMergedConfig(config, argv.entrypoint);
+                resolvedConfig.lint.skipRules(argv['skip-rule']);
+                resolvedConfig.lint.skipPreprocessors(argv['skip-preprocessor']);
+                resolvedConfig.lint.skipDecorators(argv['skip-decorator']);
+                const referenceDocs = resolvedConfig['features.openapi'];
+                redocOptions = Object.assign(Object.assign({}, referenceDocs), { useCommunityEdition: argv['use-community-edition'] || referenceDocs.useCommunityEdition, licenseKey: process.env.REDOCLY_LICENSE_KEY || referenceDocs.licenseKey });
+                return resolvedConfig;
+            });
+        }
+    });
+}
+exports.previewDocs = previewDocs;
+function debounce(func, wait, immediate) {
+    let timeout;
+    return function executedFunction(...args) {
+        // @ts-ignore
+        const context = this;
+        const later = () => {
+            timeout = null;
+            if (!immediate)
+                func.apply(context, args);
+        };
+        const callNow = immediate && !timeout;
+        if (timeout)
+            clearTimeout(timeout);
+        timeout = setTimeout(later, wait);
+        if (callNow)
+            func.apply(context, args);
+    };
+}
+exports.debounce = debounce;
+function handleError(e, ref) {
+    if (e instanceof openapi_core_1.ResolveError) {
+        process.stderr.write(`Failed to resolve entrypoint definition at ${ref}:\n\n  - ${e.message}.\n\n`);
+    }
+    else if (e instanceof openapi_core_1.YamlParseError) {
+        process.stderr.write(`Failed to parse entrypoint definition at ${ref}:\n\n  - ${e.message}.\n\n`);
+    }
+    else {
+        process.stderr.write(`Something went wrong when processing ${ref}:\n\n  - ${e.message}.\n\n`);
+    }
+}

package/lib/commands/preview-docs/preview-server/default.hbs

@@ -0,0 +1,24 @@
+
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf8" />
+  <title>{{title}}</title>
+  <!-- needed for adaptive design -->
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body {
+      padding: 0;
+      margin: 0;
+    }
+  </style>
+  {{{redocHead}}}
+  <link href="https://fonts.googleapis.com/css?family=Montserrat:300,400,700|Roboto:300,400,700" rel="stylesheet">
+</head>
+
+<body>
+  {{{redocHTML}}}
+</body>
+
+</html>

package/lib/commands/preview-docs/preview-server/hot.js

@@ -0,0 +1,42 @@
+(function run() {
+  const Socket = window.SimpleWebsocket;
+  const port = window.__OPENAPI_CLI_WS_PORT;
+
+  let socket;
+
+  reconnect();
+
+  function reconnect() {
+    socket = new Socket(`ws://127.0.0.1:${port}`);
+    socket.on('connect', () => {
+      socket.send('{"type": "ping"}');
+    });
+
+    socket.on('data', (data) => {
+      const message = JSON.parse(data);
+      switch (message.type) {
+        case 'pong':
+          console.log('[hot] hot reloading connected');
+          break;
+        case 'reload':
+          console.log('[hot] full page reload');
+          window.location.reload();
+          break;
+        default:
+          console.log(`[hot] ${message.type} received`);
+      }
+    });
+
+    socket.on('close', () => {
+      socket.destroy();
+      console.log('Connection lost, trying to reconnect in 4s');
+      setTimeout(() => {
+        reconnect();
+      }, 4000);
+    });
+
+    socket.on('error', () => {
+      socket.destroy();
+    });
+  }
+})();

package/lib/commands/preview-docs/preview-server/oauth2-redirect.html

@@ -0,0 +1,21 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1,shrink-to-fit=no" />
+    <title>Redocly Reference Docs: OAuth2 Redirect</title>
+    <style>
+      .user-info {
+        margin: 150px auto auto;
+        width: 50%;
+        background-color: whitesmoke;
+        padding: 20px;
+        text-align: center;
+      }
+    </style>
+  </head>
+  <body>
+    <script src="https://cdn.jsdelivr.net/npm/@redocly/reference-docs@latest/dist/oauth2-redirect.js"></script>
+    <noscript>You need to enable JavaScript to run this app.</noscript>
+  </body>
+</html>

package/lib/commands/preview-docs/preview-server/preview-server.d.ts

@@ -0,0 +1,5 @@
+export default function startPreviewServer(port: number, host: string, { getBundle, getOptions, useRedocPro, }: {
+    getBundle: Function;
+    getOptions: Function;
+    useRedocPro: boolean;
+}): Promise<any>;

package/lib/commands/preview-docs/preview-server/preview-server.js

@@ -0,0 +1,120 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const handlebars_1 = require("handlebars");
+const colorette = require("colorette");
+const portfinder = require("portfinder");
+const fs_1 = require("fs");
+const path = require("path");
+const server_1 = require("./server");
+const utils_1 = require("../../../utils");
+function getPageHTML(htmlTemplate, redocOptions = {}, useRedocPro, wsPort) {
+    let templateSrc = fs_1.readFileSync(htmlTemplate, 'utf-8');
+    // fix template for backward compatibility
+    templateSrc = templateSrc
+        .replace(/{?{{redocHead}}}?/, '{{{redocHead}}}')
+        .replace('{{redocBody}}', '{{{redocHTML}}}');
+    const template = handlebars_1.compile(templateSrc);
+    return template({
+        redocHead: `
+  <script>
+    window.__REDOC_EXPORT = '${useRedocPro ? 'RedoclyReferenceDocs' : 'Redoc'}';
+    window.__OPENAPI_CLI_WS_PORT = ${wsPort};
+  </script>
+  <script src="/simplewebsocket.min.js"></script>
+  <script src="/hot.js"></script>
+  <script src="${useRedocPro
+            ? 'https://cdn.jsdelivr.net/npm/@redocly/reference-docs@latest/dist/redocly-reference-docs.min.js'
+            : 'https://cdn.jsdelivr.net/npm/redoc@latest/bundles/redoc.standalone.js'}"></script>
+`,
+        redocHTML: `
+  <div id="redoc"></div>
+  <script>
+    var container = document.getElementById('redoc');
+    ${useRedocPro
+            ? "window[window.__REDOC_EXPORT].setPublicPath('https://cdn.jsdelivr.net/npm/@redocly/reference-docs@latest/dist/');"
+            : ''}
+    window[window.__REDOC_EXPORT].init("/openapi.json", ${JSON.stringify(redocOptions)}, container)
+  </script>`,
+    });
+}
+function startPreviewServer(port, host, { getBundle, getOptions, useRedocPro, }) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const defaultTemplate = path.join(__dirname, 'default.hbs');
+        const handler = (request, response) => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            console.time(colorette.dim(`GET ${request.url}`));
+            const { htmlTemplate } = getOptions() || {};
+            if (((_a = request.url) === null || _a === void 0 ? void 0 : _a.endsWith('/')) || path.extname(request.url) === '') {
+                server_1.respondWithGzip(getPageHTML(htmlTemplate || defaultTemplate, getOptions(), useRedocPro, wsPort), request, response, {
+                    'Content-Type': 'text/html',
+                });
+            }
+            else if (request.url === '/openapi.json') {
+                const bundle = yield getBundle();
+                if (bundle === undefined) {
+                    server_1.respondWithGzip(JSON.stringify({
+                        openapi: '3.0.0',
+                        info: {
+                            description: '<code> Failed to generate bundle: check out console output for more details </code>',
+                        },
+                        paths: {},
+                    }), request, response, {
+                        'Content-Type': 'application/json',
+                    });
+                }
+                else {
+                    server_1.respondWithGzip(JSON.stringify(bundle), request, response, {
+                        'Content-Type': 'application/json',
+                    });
+                }
+            }
+            else {
+                const filePath = 
+                // @ts-ignore
+                {
+                    '/hot.js': path.join(__dirname, 'hot.js'),
+                    '/oauth2-redirect.html': path.join(__dirname, 'oauth2-redirect.html'),
+                    '/simplewebsocket.min.js': require.resolve('simple-websocket/simplewebsocket.min.js'),
+                }[request.url || ''] ||
+                    path.resolve(htmlTemplate ? path.dirname(htmlTemplate) : process.cwd(), `.${request.url}`);
+                if (!utils_1.isSubdir(process.cwd(), filePath)) {
+                    server_1.respondWithGzip('404 Not Found', request, response, { 'Content-Type': 'text/html' }, 404);
+                    console.timeEnd(colorette.dim(`GET ${request.url}`));
+                    return;
+                }
+                const extname = String(path.extname(filePath)).toLowerCase();
+                const contentType = server_1.mimeTypes[extname] || 'application/octet-stream';
+                try {
+                    server_1.respondWithGzip(yield fs_1.promises.readFile(filePath), request, response, {
+                        'Content-Type': contentType,
+                    });
+                }
+                catch (e) {
+                    if (e.code === 'ENOENT') {
+                        server_1.respondWithGzip('404 Not Found', request, response, { 'Content-Type': 'text/html' }, 404);
+                    }
+                    else {
+                        server_1.respondWithGzip(`Something went wrong: ${e.code || e.message}...\n`, request, response, {}, 500);
+                    }
+                }
+            }
+            console.timeEnd(colorette.dim(`GET ${request.url}`));
+        });
+        let wsPort = yield portfinder.getPortPromise({ port: 32201 });
+        const server = server_1.startHttpServer(port, host, handler);
+        server.on('listening', () => {
+            process.stdout.write(`\n  🔎  Preview server running at ${colorette.blue(`http://${host}:${port}\n`)}`);
+        });
+        return server_1.startWsServer(wsPort);
+    });
+}
+exports.default = startPreviewServer;

package/lib/commands/preview-docs/preview-server/server.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import * as http from 'http';
+import { ReadStream } from 'fs';
+export declare const mimeTypes: {
+    '.html': string;
+    '.js': string;
+    '.css': string;
+    '.json': string;
+    '.png': string;
+    '.jpg': string;
+    '.gif': string;
+    '.svg': string;
+    '.wav': string;
+    '.mp4': string;
+    '.woff': string;
+    '.ttf': string;
+    '.eot': string;
+    '.otf': string;
+    '.wasm': string;
+};
+export declare function respondWithGzip(contents: string | Buffer | ReadStream, request: http.IncomingMessage, response: http.ServerResponse, headers?: {}, code?: number): void;
+export declare function startHttpServer(port: number, host: string, handler: http.RequestListener): http.Server;
+export declare function startWsServer(port: number): any;

package/lib/commands/preview-docs/preview-server/server.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startWsServer = exports.startHttpServer = exports.respondWithGzip = exports.mimeTypes = void 0;
+const http = require("http");
+const zlib = require("zlib");
+const SocketServer = require('simple-websocket/server.js');
+exports.mimeTypes = {
+    '.html': 'text/html',
+    '.js': 'text/javascript',
+    '.css': 'text/css',
+    '.json': 'application/json',
+    '.png': 'image/png',
+    '.jpg': 'image/jpg',
+    '.gif': 'image/gif',
+    '.svg': 'image/svg+xml',
+    '.wav': 'audio/wav',
+    '.mp4': 'video/mp4',
+    '.woff': 'application/font-woff',
+    '.ttf': 'application/font-ttf',
+    '.eot': 'application/vnd.ms-fontobject',
+    '.otf': 'application/font-otf',
+    '.wasm': 'application/wasm',
+};
+// credits: https://stackoverflow.com/a/9238214/1749888
+function respondWithGzip(contents, request, response, headers = {}, code = 200) {
+    let compressedStream;
+    const acceptEncoding = request.headers['accept-encoding'] || '';
+    if (acceptEncoding.match(/\bdeflate\b/)) {
+        response.writeHead(code, Object.assign(Object.assign({}, headers), { 'content-encoding': 'deflate' }));
+        compressedStream = zlib.createDeflate();
+    }
+    else if (acceptEncoding.match(/\bgzip\b/)) {
+        response.writeHead(code, Object.assign(Object.assign({}, headers), { 'content-encoding': 'gzip' }));
+        compressedStream = zlib.createGzip();
+    }
+    else {
+        response.writeHead(code, headers);
+        if (typeof contents === 'string' || Buffer.isBuffer(contents)) {
+            response.write(contents);
+            response.end();
+        }
+        else if (response !== undefined) {
+            contents.pipe(response);
+        }
+        return;
+    }
+    if (typeof contents === 'string' || Buffer.isBuffer(contents)) {
+        compressedStream.write(contents);
+        compressedStream.pipe(response);
+        compressedStream.end();
+    }
+    else {
+        contents.pipe(compressedStream).pipe(response);
+    }
+}
+exports.respondWithGzip = respondWithGzip;
+function startHttpServer(port, host, handler) {
+    return http.createServer(handler).listen(port, host);
+}
+exports.startHttpServer = startHttpServer;
+function startWsServer(port) {
+    const socketServer = new SocketServer({ port, clientTracking: true });
+    socketServer.on('connection', (socket) => {
+        socket.on('data', (data) => {
+            const message = JSON.parse(data);
+            switch (message.type) {
+                case 'ping':
+                    socket.send('{"type": "pong"}');
+                    break;
+                default:
+                // nope
+            }
+        });
+    });
+    socketServer.broadcast = (message) => {
+        socketServer._server.clients.forEach((client) => {
+            if (client.readyState === 1) {
+                // OPEN
+                client.send(message);
+            }
+        });
+    };
+    return socketServer;
+}
+exports.startWsServer = startWsServer;

package/lib/commands/push.d.ts

@@ -0,0 +1,25 @@
+import { Config, Region } from '@redocly/openapi-core';
+declare type PushArgs = {
+    entrypoint?: string;
+    destination?: string;
+    branchName?: string;
+    upsert?: boolean;
+    'run-id'?: string;
+    region?: Region;
+    'skip-decorator'?: string[];
+};
+export declare function handlePush(argv: PushArgs): Promise<void>;
+export declare function getDestinationProps(destination: string | undefined, organization: string | undefined): (string | undefined)[];
+declare type BarePushArgs = Omit<PushArgs, 'entrypoint' | 'destination' | 'branchName'> & {
+    maybeEntrypointOrAliasOrDestination?: string;
+    maybeDestination?: string;
+    maybeBranchName?: string;
+    branch?: string;
+};
+export declare const transformPush: (callback: typeof handlePush) => ({ maybeEntrypointOrAliasOrDestination, maybeDestination, maybeBranchName, branch, ...rest }: BarePushArgs) => Promise<void>;
+export declare function getApiEntrypoint({ name, version, config: { apis }, }: {
+    name: string;
+    version: string;
+    config: Config;
+}): string;
+export {};