@redocly/cli 1.0.0-beta.96

package/lib/utils.js

@@ -0,0 +1,260 @@
+"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.isSubdir = exports.exitWithError = exports.printUnusedWarnings = exports.getOutputFileName = exports.printLintTotals = exports.handleError = exports.pluralize = exports.writeYaml = exports.readYaml = exports.promptUser = exports.saveBundle = exports.dumpBundle = exports.CircularJSONNotSupportedError = exports.pathToFilename = exports.printExecutionTime = exports.getExecutionTime = exports.getFallbackEntryPointsOrExit = void 0;
+const path_1 = require("path");
+const colorette_1 = require("colorette");
+const perf_hooks_1 = require("perf_hooks");
+const glob = require("glob-promise");
+const fs = require("fs");
+const path = require("path");
+const readline = require("readline");
+const stream_1 = require("stream");
+const openapi_core_1 = require("@redocly/openapi-core");
+const types_1 = require("./types");
+function getFallbackEntryPointsOrExit(argsEntrypoints, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { apis } = config;
+        const shouldFallbackToAllDefinitions = !isNotEmptyArray(argsEntrypoints) && apis && Object.keys(apis).length > 0;
+        const res = shouldFallbackToAllDefinitions
+            ? Object.entries(apis).map(([alias, { root }]) => ({
+                path: path_1.resolve(getConfigDirectory(config), root),
+                alias,
+            }))
+            : (yield expandGlobsInEntrypoints(argsEntrypoints, config));
+        if (!isNotEmptyArray(res)) {
+            process.stderr.write('error: missing required argument `entrypoints`.\n');
+            process.exit(1);
+        }
+        return res;
+    });
+}
+exports.getFallbackEntryPointsOrExit = getFallbackEntryPointsOrExit;
+function getConfigDirectory(config) {
+    return config.configFile ? path_1.dirname(config.configFile) : process.cwd();
+}
+function isNotEmptyArray(args) {
+    return Array.isArray(args) && !!args.length;
+}
+function getAliasOrPath(config, aliasOrPath) {
+    var _a;
+    return config.apis[aliasOrPath]
+        ? { path: (_a = config.apis[aliasOrPath]) === null || _a === void 0 ? void 0 : _a.root, alias: aliasOrPath }
+        : { path: aliasOrPath };
+}
+function expandGlobsInEntrypoints(args, config) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return (yield Promise.all(args.map((aliasOrPath) => __awaiter(this, void 0, void 0, function* () {
+            return glob.hasMagic(aliasOrPath)
+                ? (yield glob(aliasOrPath)).map((g) => getAliasOrPath(config, g))
+                : getAliasOrPath(config, aliasOrPath);
+        })))).flat();
+    });
+}
+function getExecutionTime(startedAt) {
+    return process.env.NODE_ENV === 'test'
+        ? '<test>ms'
+        : `${Math.ceil(perf_hooks_1.performance.now() - startedAt)}ms`;
+}
+exports.getExecutionTime = getExecutionTime;
+function printExecutionTime(commandName, startedAt, entrypoint) {
+    const elapsed = getExecutionTime(startedAt);
+    process.stderr.write(colorette_1.gray(`\n${entrypoint}: ${commandName} processed in ${elapsed}\n\n`));
+}
+exports.printExecutionTime = printExecutionTime;
+function pathToFilename(path, pathSeparator) {
+    return path
+        .replace(/~1/g, '/')
+        .replace(/~0/g, '~')
+        .replace(/^\//, '')
+        .replace(/\//g, pathSeparator);
+}
+exports.pathToFilename = pathToFilename;
+class CircularJSONNotSupportedError extends Error {
+    constructor(originalError) {
+        super(originalError.message);
+        this.originalError = originalError;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, CircularJSONNotSupportedError.prototype);
+    }
+}
+exports.CircularJSONNotSupportedError = CircularJSONNotSupportedError;
+function dumpBundle(obj, format, dereference) {
+    if (format === 'json') {
+        try {
+            return JSON.stringify(obj, null, 2);
+        }
+        catch (e) {
+            if (e.message.indexOf('circular') > -1) {
+                throw new CircularJSONNotSupportedError(e);
+            }
+            throw e;
+        }
+    }
+    else {
+        return openapi_core_1.stringifyYaml(obj, {
+            noRefs: !dereference,
+        });
+    }
+}
+exports.dumpBundle = dumpBundle;
+function saveBundle(filename, output) {
+    fs.mkdirSync(path.dirname(filename), { recursive: true });
+    fs.writeFileSync(filename, output);
+}
+exports.saveBundle = saveBundle;
+function promptUser(query, hideUserInput = false) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return new Promise((resolve) => {
+            let output = process.stdout;
+            let isOutputMuted = false;
+            if (hideUserInput) {
+                output = new stream_1.Writable({
+                    write: (chunk, encoding, callback) => {
+                        if (!isOutputMuted) {
+                            process.stdout.write(chunk, encoding);
+                        }
+                        callback();
+                    },
+                });
+            }
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output,
+                terminal: true,
+                historySize: hideUserInput ? 0 : 30,
+            });
+            rl.question(`${query}:\n\n  `, (answer) => {
+                rl.close();
+                resolve(answer);
+            });
+            isOutputMuted = hideUserInput;
+        });
+    });
+}
+exports.promptUser = promptUser;
+function readYaml(filename) {
+    return openapi_core_1.parseYaml(fs.readFileSync(filename, 'utf-8'), { filename });
+}
+exports.readYaml = readYaml;
+function writeYaml(data, filename, noRefs = false) {
+    const content = openapi_core_1.stringifyYaml(data, { noRefs });
+    if (process.env.NODE_ENV === 'test') {
+        process.stderr.write(content);
+        return;
+    }
+    fs.writeFileSync(filename, content);
+}
+exports.writeYaml = writeYaml;
+function pluralize(label, num) {
+    if (label.endsWith('is')) {
+        [label] = label.split(' ');
+        return num === 1 ? `${label} is` : `${label}s are`;
+    }
+    return num === 1 ? `${label}` : `${label}s`;
+}
+exports.pluralize = pluralize;
+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`);
+        // TODO: codeframe
+    }
+    else { // @ts-ignore
+        if (e instanceof CircularJSONNotSupportedError) {
+            process.stderr.write(colorette_1.red(`Detected circular reference which can't be converted to JSON.\n`) +
+                `Try to use ${colorette_1.blue('yaml')} output or remove ${colorette_1.blue('--dereferenced')}.\n\n`);
+        }
+        else {
+            process.stderr.write(`Something went wrong when processing ${ref}:\n\n  - ${e.message}.\n\n`);
+            throw e;
+        }
+    }
+}
+exports.handleError = handleError;
+function printLintTotals(totals, definitionsCount) {
+    const ignored = totals.ignored
+        ? colorette_1.yellow(`${totals.ignored} ${pluralize('problem is', totals.ignored)} explicitly ignored.\n\n`)
+        : '';
+    if (totals.errors > 0) {
+        process.stderr.write(colorette_1.red(`❌ Validation failed with ${totals.errors} ${pluralize('error', totals.errors)}${totals.warnings > 0
+            ? ` and ${totals.warnings} ${pluralize('warning', totals.warnings)}`
+            : ''}.\n${ignored}`));
+    }
+    else if (totals.warnings > 0) {
+        process.stderr.write(colorette_1.green(`Woohoo! Your OpenAPI ${pluralize('definition is', definitionsCount)} valid. 🎉\n`));
+        process.stderr.write(colorette_1.yellow(`You have ${totals.warnings} ${pluralize('warning', totals.warnings)}.\n${ignored}`));
+    }
+    else {
+        process.stderr.write(colorette_1.green(`Woohoo! Your OpenAPI ${pluralize('definition is', definitionsCount)} valid. 🎉\n${ignored}`));
+    }
+    if (totals.errors > 0) {
+        process.stderr.write(colorette_1.gray(`run \`openapi lint --generate-ignore-file\` to add all problems to the ignore file.\n`));
+    }
+    process.stderr.write('\n');
+}
+exports.printLintTotals = printLintTotals;
+function getOutputFileName(entrypoint, entries, output, ext) {
+    if (!output) {
+        return { outputFile: 'stdout', ext: ext || 'yaml' };
+    }
+    let outputFile = output;
+    if (entries > 1) {
+        ext = ext || path_1.extname(entrypoint).substring(1);
+        if (!types_1.outputExtensions.includes(ext)) {
+            throw new Error(`Invalid file extension: ${ext}.`);
+        }
+        outputFile = path_1.join(output, path_1.basename(entrypoint, path_1.extname(entrypoint))) + '.' + ext;
+    }
+    else {
+        if (output) {
+            ext = ext || path_1.extname(output).substring(1);
+        }
+        ext = ext || path_1.extname(entrypoint).substring(1);
+        if (!types_1.outputExtensions.includes(ext)) {
+            throw new Error(`Invalid file extension: ${ext}.`);
+        }
+        outputFile = path_1.join(path_1.dirname(outputFile), path_1.basename(outputFile, path_1.extname(outputFile))) + '.' + ext;
+    }
+    return { outputFile, ext };
+}
+exports.getOutputFileName = getOutputFileName;
+function printUnusedWarnings(config) {
+    const { preprocessors, rules, decorators } = config.getUnusedRules();
+    if (rules.length) {
+        process.stderr.write(colorette_1.yellow(`[WARNING] Unused rules found in ${colorette_1.blue(config.configFile || '')}: ${rules.join(', ')}.\n`));
+    }
+    if (preprocessors.length) {
+        process.stderr.write(colorette_1.yellow(`[WARNING] Unused preprocessors found in ${colorette_1.blue(config.configFile || '')}: ${preprocessors.join(', ')}.\n`));
+    }
+    if (decorators.length) {
+        process.stderr.write(colorette_1.yellow(`[WARNING] Unused decorators found in ${colorette_1.blue(config.configFile || '')}: ${decorators.join(', ')}.\n`));
+    }
+    if (rules.length || preprocessors.length) {
+        process.stderr.write(`Check the spelling and verify you added plugin prefix.\n`);
+    }
+}
+exports.printUnusedWarnings = printUnusedWarnings;
+function exitWithError(message) {
+    process.stderr.write(colorette_1.red(message) + '\n\n');
+    process.exit(1);
+}
+exports.exitWithError = exitWithError;
+/**
+ * Checks if dir is subdir of parent
+ */
+function isSubdir(parent, dir) {
+    const relative = path.relative(parent, dir);
+    return !!relative && !/^..($|\/)/.test(relative) && !path.isAbsolute(relative);
+}
+exports.isSubdir = isSubdir;

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "@redocly/cli",
+  "version": "1.0.0-beta.96",
+  "description": "",
+  "license": "MIT",
+  "bin": {
+    "openapi": "bin/cli.js",
+    "redocly":  "bin/cli.js"
+  },
+  "engines": {
+    "node": ">=12.0.0"
+  },
+  "engineStrict": true,
+  "scripts": {
+    "compile": "tsc",
+    "copy-assets": "cp src/commands/preview-docs/preview-server/default.hbs lib/commands/preview-docs/preview-server/default.hbs && cp src/commands/preview-docs/preview-server/hot.js lib/commands/preview-docs/preview-server/hot.js && cp src/commands/preview-docs/preview-server/oauth2-redirect.html lib/commands/preview-docs/preview-server/oauth2-redirect.html",
+    "prepublishOnly": "npm run copy-assets"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Redocly/redocly-cli.git"
+  },
+  "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/openapi-core": "1.0.0-beta.96",
+    "@types/node": "^14.11.8",
+    "assert-node-version": "^1.0.3",
+    "chokidar": "^3.5.1",
+    "colorette": "^1.2.0",
+    "glob": "^7.1.6",
+    "glob-promise": "^3.4.0",
+    "handlebars": "^4.7.6",
+    "portfinder": "^1.0.26",
+    "simple-websocket": "^9.0.0",
+    "yargs": "17.0.1"
+  },
+  "devDependencies": {
+    "@types/yargs": "16.0.2",
+    "typescript": "^4.0.3"
+  }
+}

package/src/__mocks__/utils.ts

@@ -0,0 +1,11 @@
+export const getFallbackEntryPointsOrExit = jest.fn((entrypoints) => entrypoints.map(() => ({ path: '' })));
+export const getTotals = jest.fn(() => ({ errors: 0 }));
+export const dumpBundle = jest.fn(() => '');
+export const slash = jest.fn();
+export const pluralize = jest.fn();
+export const getExecutionTime = jest.fn();
+export const printExecutionTime = jest.fn();
+export const printUnusedWarnings = jest.fn();
+export const printLintTotals = jest.fn();
+export const getOutputFileName = jest.fn(() => ({ outputFile: 'test.yaml', ext: 'yaml' }));
+export const handleError = jest.fn();

package/src/__tests__/commands/bundle.test.ts

@@ -0,0 +1,120 @@
+import { lint, bundle, getTotals, getMergedConfig } from '@redocly/openapi-core';
+
+import { handleBundle } from '../../commands/bundle';
+import SpyInstance = jest.SpyInstance;
+
+jest.mock('@redocly/openapi-core');
+jest.mock('../../utils');
+
+(getMergedConfig as jest.Mock).mockImplementation(config => config)
+
+describe('bundle', () => {
+  let processExitMock: SpyInstance;
+  let exitCb: any;
+
+  beforeEach(() => {
+    processExitMock = jest.spyOn(process, 'exit').mockImplementation();
+    jest.spyOn(process, 'once').mockImplementation((_e, cb) => {
+      exitCb = cb;
+      return process.on(_e, cb);
+    });
+    jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    (lint as jest.Mock).mockClear();
+    (bundle as jest.Mock).mockClear();
+    (getTotals as jest.Mock).mockClear();
+  });
+
+  it('bundles definitions w/o linting', async () => {
+    const entrypoints = ['foo.yaml', 'bar.yaml'];
+
+    await handleBundle(
+      {
+        entrypoints,
+        ext: 'yaml',
+        format: 'codeframe',
+      },
+      '1.0.0',
+    );
+
+    expect(lint).toBeCalledTimes(0);
+    expect(bundle).toBeCalledTimes(entrypoints.length);
+  });
+
+  it('exits with code 0 when bundles definitions', async () => {
+    const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+
+    await handleBundle(
+      {
+        entrypoints,
+        ext: 'yaml',
+        format: 'codeframe',
+      },
+      '1.0.0',
+    );
+
+    exitCb?.();
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('bundles definitions w/ linting', async () => {
+    const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+
+    await handleBundle(
+      {
+        entrypoints,
+        ext: 'yaml',
+        format: 'codeframe',
+        lint: true,
+      },
+      '1.0.0',
+    );
+
+    expect(lint).toBeCalledTimes(entrypoints.length);
+    expect(bundle).toBeCalledTimes(entrypoints.length);
+  });
+
+  it('exits with code 0 when bundles definitions w/linting w/o errors', async () => {
+    const entrypoints = ['foo.yaml', 'bar.yaml', 'foobar.yaml'];
+
+    await handleBundle(
+      {
+        entrypoints,
+        ext: 'yaml',
+        format: 'codeframe',
+        lint: true,
+      },
+      '1.0.0',
+    );
+
+    exitCb?.();
+    expect(processExitMock).toHaveBeenCalledWith(0);
+  });
+
+  it('exits with code 1 when bundles definitions w/linting w/errors', async () => {
+    const entrypoints = ['foo.yaml'];
+
+    (getTotals as jest.Mock).mockReturnValue({
+      errors: 1,
+      warnings: 0,
+      ignored: 0
+    });
+
+    await handleBundle(
+      {
+        entrypoints,
+        ext: 'yaml',
+        format: 'codeframe',
+        lint: true,
+      },
+      '1.0.0',
+    );
+
+    expect(lint).toBeCalledTimes(entrypoints.length);
+    exitCb?.();
+    expect(processExitMock).toHaveBeenCalledWith(1);
+  });
+
+});

package/src/__tests__/commands/push-region.test.ts

@@ -0,0 +1,51 @@
+import { getMergedConfig } from '@redocly/openapi-core';
+import { handlePush } from '../../commands/push';
+import { promptClientToken } from '../../commands/login';
+
+jest.mock('fs');
+jest.mock('node-fetch', () => ({
+  default: jest.fn(() => ({
+    ok: true,
+    json: jest.fn().mockResolvedValue({}),
+  })),
+}));
+jest.mock('@redocly/openapi-core');
+jest.mock('../../commands/login');
+jest.mock('../../utils');
+
+(getMergedConfig as jest.Mock).mockImplementation((config) => config);
+
+const mockPromptClientToken = promptClientToken as jest.MockedFunction<typeof promptClientToken>;
+
+describe('push-with-region', () => {
+  const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+  redoclyClient.isAuthorizedWithRedoclyByRegion = jest.fn().mockResolvedValue(false);
+
+  beforeAll(() => {
+    jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  it('should call login with default domain when region is US', async () => {
+    redoclyClient.domain = 'redoc.ly';
+    await handlePush({
+      upsert: true,
+      entrypoint: 'spec.json',
+      destination: '@org/my-api@1.0.0',
+      branchName: 'test',
+    });
+    expect(mockPromptClientToken).toBeCalledTimes(1);
+    expect(mockPromptClientToken).toHaveBeenCalledWith(redoclyClient.domain);
+  });
+
+  it('should call login with EU domain when region is EU', async () => {
+    redoclyClient.domain = 'eu.redocly.com';
+    await handlePush({
+      upsert: true,
+      entrypoint: 'spec.json',
+      destination: '@org/my-api@1.0.0',
+      branchName: 'test',
+    });
+    expect(mockPromptClientToken).toBeCalledTimes(1);
+    expect(mockPromptClientToken).toHaveBeenCalledWith(redoclyClient.domain);
+  });
+});

package/src/__tests__/commands/push.test.ts

@@ -0,0 +1,156 @@
+import { Config, getMergedConfig } from '@redocly/openapi-core';
+import {
+  getApiEntrypoint,
+  getDestinationProps,
+  handlePush,
+  transformPush,
+} from '../../commands/push';
+
+jest.mock('fs');
+jest.mock('node-fetch', () => ({
+  default: jest.fn(() => ({
+    ok: true,
+    json: jest.fn().mockResolvedValue({}),
+  })),
+}));
+jest.mock('@redocly/openapi-core');
+jest.mock('../../utils');
+
+(getMergedConfig as jest.Mock).mockImplementation((config) => config);
+
+describe('push', () => {
+  const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
+
+  beforeEach(() => {
+    jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  it('pushes definition', async () => {
+    await handlePush({
+      upsert: true,
+      entrypoint: 'spec.json',
+      destination: '@org/my-api@1.0.0',
+      branchName: 'test',
+    });
+
+    expect(redoclyClient.registryApi.prepareFileUpload).toBeCalledTimes(1);
+    expect(redoclyClient.registryApi.pushApi).toBeCalledTimes(1);
+    expect(redoclyClient.registryApi.pushApi).toHaveBeenLastCalledWith({
+      branch: 'test',
+      filePaths: ['filePath'],
+      isUpsert: true,
+      name: 'my-api',
+      organizationId: 'org',
+      rootFilePath: 'filePath',
+      version: '1.0.0',
+    });
+  });
+});
+
+describe('transformPush', () => {
+  it('should adapt the existing syntax', () => {
+    const cb = jest.fn();
+    transformPush(cb)({
+      maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+      maybeDestination: '@testing_org/main@v1',
+    });
+    expect(cb).toBeCalledWith({
+      entrypoint: 'openapi.yaml',
+      destination: '@testing_org/main@v1',
+    });
+  });
+  it('should adapt the existing syntax (including branchName)', () => {
+    const cb = jest.fn();
+    transformPush(cb)({
+      maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+      maybeDestination: '@testing_org/main@v1',
+      maybeBranchName: 'other',
+    });
+    expect(cb).toBeCalledWith({
+      entrypoint: 'openapi.yaml',
+      destination: '@testing_org/main@v1',
+      branchName: 'other',
+    });
+  });
+  it('should use --branch option firstly', () => {
+    const cb = jest.fn();
+    transformPush(cb)({
+      maybeEntrypointOrAliasOrDestination: 'openapi.yaml',
+      maybeDestination: '@testing_org/main@v1',
+      maybeBranchName: 'other',
+      branch: 'priority-branch',
+    });
+    expect(cb).toBeCalledWith({
+      entrypoint: 'openapi.yaml',
+      destination: '@testing_org/main@v1',
+      branchName: 'priority-branch',
+    });
+  });
+  it('should work for a destination only', () => {
+    const cb = jest.fn();
+    transformPush(cb)({
+      maybeEntrypointOrAliasOrDestination: '@testing_org/main@v1',
+    });
+    expect(cb).toBeCalledWith({
+      destination: '@testing_org/main@v1',
+    });
+  });
+  it('should accept aliases for the old syntax', () => {
+    const cb = jest.fn();
+    transformPush(cb)({
+      maybeEntrypointOrAliasOrDestination: 'alias',
+      maybeDestination: '@testing_org/main@v1',
+    });
+    expect(cb).toBeCalledWith({
+      destination: '@testing_org/main@v1',
+      entrypoint: 'alias',
+    });
+  });
+  it('should accept no arguments at all', () => {
+    const cb = jest.fn();
+    transformPush(cb)({});
+    expect(cb).toBeCalledWith({});
+  });
+});
+
+describe('getDestinationProps', () => {
+  it('should get valid destination props for the full destination syntax', () => {
+    expect(getDestinationProps('@testing_org/main@v1', 'org-from-config')).toEqual([
+      'testing_org',
+      'main',
+      'v1',
+    ]);
+  });
+  it('should fallback the organizationId from a config for the short destination syntax', () => {
+    expect(getDestinationProps('main@v1', 'org-from-config')).toEqual([
+      'org-from-config',
+      'main',
+      'v1',
+    ]);
+  });
+  it('should fallback the organizationId from a config if no destination provided', () => {
+    expect(getDestinationProps(undefined, 'org-from-config')).toEqual(['org-from-config']);
+  });
+  it('should return empty organizationId if there is no one found', () => {
+    expect(getDestinationProps('main@v1', undefined)).toEqual([, 'main', 'v1']);
+  });
+});
+
+describe('getApiEntrypoint', () => {
+  let config: Config = {
+    apis: {
+      'main@v1': {
+        root: 'openapi.yaml',
+      },
+      main: {
+        root: 'latest.yaml',
+      },
+    },
+  } as unknown as Config;
+  it('should resolve the correct api for a valid name & version', () => {
+    expect(getApiEntrypoint({ name: 'main', version: 'v1', config })).toEqual('openapi.yaml');
+  });
+  it('should resolve the latest version of api if there is no matching version', () => {
+    expect(getApiEntrypoint({ name: 'main', version: 'latest', config })).toEqual('latest.yaml');
+  });
+});