@redocly/openapi-core 1.0.0-beta.96 → 1.0.0-beta.99

package/src/bundle.ts

@@ -7,7 +7,7 @@ import { Oas3_1Types } from './types/oas3_1';
 import { NormalizedNodeType, normalizeTypes, NodeType } from './types';
 import { WalkContext, walkDocument, UserContext, ResolveResult } from './walk';
 import { detectOpenAPI, openAPIMajor, OasMajorVersion } from './oas-types';
-import { isRef, Location, refBaseName } from './ref-utils';
+import {isAbsoluteUrl, isRef, Location, refBaseName} from './ref-utils';
 import { initRules } from './config/rules';
 import { reportUnresolvedRef } from './rules/no-unresolved-refs';
 import { isPlainObject } from './utils';
@@ -35,6 +35,7 @@ export async function bundle(opts: {
   base?: string;
   skipRedoclyRegistryRefs?: boolean;
   removeUnusedComponents?: boolean;
+  keepUrlRefs?: boolean;
 }) {
   const {
     ref,
@@ -71,6 +72,7 @@ export async function bundleDocument(opts: {
   dereference?: boolean;
   skipRedoclyRegistryRefs?: boolean;
   removeUnusedComponents?: boolean;
+  keepUrlRefs?: boolean;
 }) {
   const {
     document,
@@ -80,6 +82,7 @@ export async function bundleDocument(opts: {
     dereference = false,
     skipRedoclyRegistryRefs = false,
     removeUnusedComponents = false,
+    keepUrlRefs = false,
   } = opts;
   const oasVersion = detectOpenAPI(document.parsed);
   const oasMajorVersion = openAPIMajor(oasVersion);
@@ -128,7 +131,14 @@ export async function bundleDocument(opts: {
       {
         severity: 'error',
         ruleId: 'bundler',
-        visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document, resolvedRefMap),
+        visitor: makeBundleVisitor(
+          oasMajorVersion,
+          dereference,
+          skipRedoclyRegistryRefs,
+          document,
+          resolvedRefMap,
+          keepUrlRefs,
+        ),
       },
       ...decorators,
     ] as any,
@@ -199,7 +209,8 @@ function makeBundleVisitor(
   dereference: boolean,
   skipRedoclyRegistryRefs: boolean,
   rootDocument: Document,
-  resolvedRefMap: ResolvedRefMap
+  resolvedRefMap: ResolvedRefMap,
+  keepUrlRefs: boolean,
 ) {
   let components: Record<string, Record<string, any>>;
 
@@ -224,6 +235,10 @@ function makeBundleVisitor(
           return;
         }
 
+        if (keepUrlRefs && isAbsoluteUrl(node.$ref)) {
+          return;
+        }
+
         const componentType = mapTypeToComponent(ctx.type.name, version);
         if (!componentType) {
           replaceRef(node, resolved, ctx);

package/src/config/__tests__/__snapshots__/config-resolvers.test.ts.snap

@@ -103,7 +103,24 @@ Object {
   "preprocessors": Object {},
   "recommendedFallback": undefined,
   "rules": Object {
-    "assertions": "warn",
+    "assertions": Array [
+      Object {
+        "assertionId": "path-item-get-defined",
+        "defined": true,
+        "message": "Every path item must have a GET operation.",
+        "property": "get",
+        "subject": "PathItem",
+      },
+      Object {
+        "assertionId": "tag-description",
+        "message": "Tag description must be at least 13 characters and end with a full stop.",
+        "minLength": 13,
+        "pattern": "/\\\\.$/",
+        "property": "description",
+        "severity": "error",
+        "subject": "Tag",
+      },
+    ],
     "boolean-parameter-prefixes": "error",
     "info-contact": "off",
     "info-description": "warn",

package/src/config/__tests__/config-resolvers.test.ts

@@ -130,11 +130,42 @@ describe('resolveLint', () => {
     expect(lint).toMatchSnapshot();
   });
 
+  it('should correctly merge assertions from nested config', async () => {
+    const lintConfig = {
+      extends: ['local-config-with-file.yaml'],
+    };
+
+    const lint = await resolveLint({
+      lintConfig,
+      configPath,
+    });
+
+    expect(Array.isArray(lint.rules?.assertions)).toEqual(true);
+    expect(lint.rules?.assertions).toMatchObject( [
+      {
+        subject: 'PathItem',
+        property: 'get',
+        message: 'Every path item must have a GET operation.',
+        defined: true,
+        assertionId: 'path-item-get-defined'
+      },
+      {
+        subject: 'Tag',
+        property: 'description',
+        message: 'Tag description must be at least 13 characters and end with a full stop.',
+        severity: 'error',
+        minLength: 13,
+        pattern: '/\\.$/',
+        assertionId: 'tag-description'
+      }
+    ])
+  });
+
   it('should resolve extends with url file config witch contains path to nested config', async () => {
     const lintConfig = {
       // This points to ./fixtures/resolve-remote-configs/remote-config.yaml
       extends: [
-        'https://raw.githubusercontent.com/Redocly/openapi-cli/master/packages/core/src/config/__tests__/fixtures/resolve-remote-configs/remote-config.yaml',
+        'https://raw.githubusercontent.com/Redocly/redocly-cli/master/packages/core/src/config/__tests__/fixtures/resolve-remote-configs/remote-config.yaml',
       ],
     };
 

package/src/config/__tests__/fixtures/resolve-config/api/nested-config.yaml

@@ -3,5 +3,10 @@ lint:
     - plugin.js
   rules:
     operation-2xx-response: error
+    assert/path-item-get-defined:
+      subject: PathItem
+      property: get
+      message: Every path item must have a GET operation.
+      defined: true
   extends:
     - test-plugin-nested/all

package/src/config/__tests__/fixtures/resolve-config/local-config-with-file.yaml

@@ -2,6 +2,13 @@ lint:
   rules:
     no-invalid-media-type-examples: warn
     operation-4xx-response: off
+    assert/tag-description:
+      subject: Tag
+      property: description
+      message: Tag description must be at least 13 characters and end with a full stop.
+      severity: error
+      minLength: 13
+      pattern: /\.$/
   plugins:
     - plugin.js
     - api/plugin.js

package/src/config/all.ts

@@ -42,6 +42,7 @@ export default {
     spec: 'error',
     'no-invalid-schema-examples': 'error',
     'no-invalid-parameter-examples': 'error',
+    'scalar-property-missing-example': 'error',
   },
   oas3_0Rules: {
     'no-invalid-media-type-examples': 'error',

package/src/config/config-resolvers.ts

@@ -11,7 +11,14 @@ import {
   prefixRules,
   transformConfig,
 } from './utils';
-import type { LintRawConfig, Plugin, RawConfig, ResolvedApi, ResolvedLintConfig } from './types';
+import type {
+  LintRawConfig,
+  Plugin,
+  RawConfig,
+  ResolvedApi,
+  ResolvedLintConfig,
+  RuleConfig,
+} from './types';
 import { isNotString, isString, notUndefined, parseYaml } from '../utils';
 import { Config } from './config';
 
@@ -175,7 +182,7 @@ export async function resolveApis({
   return resolvedApis;
 }
 
-export async function resolveLint(
+async function resolveAndMergeNestedLint(
   {
     lintConfig,
     configPath = '',
@@ -213,7 +220,7 @@ export async function resolveLint(
         ? new URL(presetItem, configPath).href
         : path.resolve(path.dirname(configPath), presetItem);
       const extendedLintConfig = await loadExtendLintConfig(pathItem, resolver);
-      return await resolveLint(
+      return await resolveAndMergeNestedLint(
         {
           lintConfig: extendedLintConfig,
           configPath: pathItem,
@@ -245,6 +252,23 @@ export async function resolveLint(
   };
 }
 
+export async function resolveLint(
+  lintOpts: {
+    lintConfig?: LintRawConfig;
+    configPath?: string;
+    resolver?: BaseResolver;
+  },
+  parentConfigPaths: string[] = [],
+  extendPaths: string[] = [],
+): Promise<ResolvedLintConfig> {
+  const resolvedLint = await resolveAndMergeNestedLint(lintOpts, parentConfigPaths, extendPaths);
+
+  return {
+    ...resolvedLint,
+    rules: resolvedLint.rules && groupLintAssertionRules(resolvedLint.rules),
+  };
+}
+
 export function resolvePreset(presetName: string, plugins: Plugin[]): ResolvedLintConfig {
   const { pluginId, configName } = parsePresetName(presetName);
   const plugin = plugins.find((p) => p.id === pluginId);
@@ -302,3 +326,34 @@ function getMergedLintRawConfig(configLint: LintRawConfig, apiLint?: LintRawConf
   };
   return resultLint;
 }
+
+function groupLintAssertionRules(
+  rules: Record<string, RuleConfig> | undefined,
+): Record<string, RuleConfig> | undefined {
+  if (!rules) {
+    return rules;
+  }
+
+  // Create a new record to avoid mutating original
+  const transformedRules: Record<string, RuleConfig> = {};
+
+  // Collect assertion rules
+  const assertions = [];
+  for (const [ruleKey, rule] of Object.entries(rules)) {
+    if (ruleKey.startsWith('assert/') && typeof rule === 'object' && rule !== null) {
+      const assertion = rule;
+      assertions.push({
+        ...assertion,
+        assertionId: ruleKey.replace('assert/', ''),
+      });
+    } else {
+      // If it's not an assertion, keep it as is
+      transformedRules[ruleKey] = rule;
+    }
+  }
+  if (assertions.length > 0) {
+    transformedRules.assertions = assertions;
+  }
+
+  return transformedRules;
+}

package/src/config/config.ts

@@ -19,25 +19,34 @@ import type {
 } from './types';
 import { getResolveConfig } from './utils';
 
+// Alias environment here so this file can work in browser environments too.
+export const env = typeof process !== 'undefined' ? process.env || {} : {};
+
 export const IGNORE_FILE = '.redocly.lint-ignore.yaml';
 const IGNORE_BANNER =
   `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
   `# See https://redoc.ly/docs/cli/ for more information.\n`;
 
 export const DEFAULT_REGION = 'us';
-const REDOCLY_DOMAIN = process.env.REDOCLY_DOMAIN;
-export const DOMAINS: { [region in Region]: string } = {
-  us: 'redocly.com',
-  eu: 'eu.redocly.com',
-};
-
-// FIXME: temporary fix for our lab environments
-if (REDOCLY_DOMAIN?.endsWith('.redocly.host')) {
-  DOMAINS[REDOCLY_DOMAIN.split('.')[0] as Region] = REDOCLY_DOMAIN;
-}
-if (REDOCLY_DOMAIN === 'redoc.online') {
-  DOMAINS[REDOCLY_DOMAIN as Region] = REDOCLY_DOMAIN;
+
+function getDomains() {
+  const domains: { [region in Region]: string } = {
+    us: 'redocly.com',
+    eu: 'eu.redocly.com',
+  };
+
+  // FIXME: temporary fix for our lab environments
+  const domain = env.REDOCLY_DOMAIN;
+  if (domain?.endsWith('.redocly.host')) {
+    domains[domain.split('.')[0] as Region] = domain;
+  }
+  if (domain === 'redoc.online') {
+    domains[domain as Region] = domain;
+  }
+  return domains;
 }
+
+export const DOMAINS = getDomains();
 export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
 
 export class LintConfig {

package/src/format/format.ts

@@ -14,6 +14,7 @@ const coreVersion = require('../../package.json').version;
 
 import { NormalizedProblem, ProblemSeverity, LineColLocationObject, LocationObject } from '../walk';
 import { getCodeframe, getLineColLocation } from './codeframes';
+import { env } from "../config";
 
 export type Totals = {
   errors: number;
@@ -202,7 +203,7 @@ export function formatProblems(
             : undefined,
         };
 
-        if (process.env.FORMAT_JSON_WITH_CODEFRAMES) {
+        if (env.FORMAT_JSON_WITH_CODEFRAMES) {
           const location = p.location[0]; // TODO: support multiple locations
           const loc = getLineColLocation(location);
           (problem as any).codeframe = getCodeframe(loc, color);

package/src/redocly/index.ts

@@ -1,9 +1,9 @@
 import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { resolve } from 'path';
 import { homedir } from 'os';
-import { red, green, gray, yellow } from 'colorette';
+import { green } from 'colorette';
 import { RegistryApi } from './registry-api';
-import { DEFAULT_REGION, DOMAINS, AVAILABLE_REGIONS } from '../config/config';
+import { DEFAULT_REGION, DOMAINS, AVAILABLE_REGIONS, env } from '../config/config';
 import { RegionalToken, RegionalTokenWithValidity } from './redocly-client-types';
 import { isNotEmptyObject } from '../utils';
 
@@ -11,7 +11,6 @@ import type { AccessTokens, Region } from '../config/types';
 
 const TOKEN_FILENAME = '.redocly-config.json';
 
-let REDOCLY_DOMAIN: string; // workaround for the isRedoclyRegistryURL, see more below
 export class RedoclyClient {
   private accessTokens: AccessTokens = {};
   private region: Region;
@@ -21,31 +20,20 @@ export class RedoclyClient {
   constructor(region?: Region) {
     this.region = this.loadRegion(region);
     this.loadTokens();
-    this.domain = region ? DOMAINS[region] : process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
+    this.domain = region ? DOMAINS[region] : env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
 
-    /*
-     * We can't use process.env here because it is replaced by a const in some client-side bundles,
-     * which breaks assignment.
-     */
-    REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
+    env.REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
     this.registryApi = new RegistryApi(this.accessTokens, this.region);
   }
 
   loadRegion(region?: Region) {
     if (region && !DOMAINS[region]) {
-      process.stdout.write(
-        red(
-          `Invalid argument: region in config file.\nGiven: ${green(
-            region,
-          )}, choices: "us", "eu".\n`,
-        ),
-      );
-      process.exit(1);
+      throw new Error(`Invalid argument: region in config file.\nGiven: ${green(region)}, choices: "us", "eu".`);
     }
 
-    if (process.env.REDOCLY_DOMAIN) {
+    if (env.REDOCLY_DOMAIN) {
       return (AVAILABLE_REGIONS.find(
-        (region) => DOMAINS[region as Region] === process.env.REDOCLY_DOMAIN,
+        (region) => DOMAINS[region as Region] === env.REDOCLY_DOMAIN,
       ) || DEFAULT_REGION) as Region;
     }
     return region || DEFAULT_REGION;
@@ -65,18 +53,7 @@ export class RedoclyClient {
   }
 
   async getAuthorizationHeader(): Promise<string | undefined> {
-    const token = this.accessTokens[this.region];
-    // print this only if there is token but invalid
-    if (token && !this.isAuthorizedWithRedoclyByRegion()) {
-      process.stderr.write(
-        `${yellow(
-          'Warning:',
-        )} invalid Redocly API key. Use "npx @redocly/cli login" to provide your API key\n`,
-      );
-      return undefined;
-    }
-
-    return token;
+    return this.accessTokens[this.region];
   }
   // </backward compatibility: portal>
 
@@ -96,10 +73,10 @@ export class RedoclyClient {
           }),
       });
     }
-    if (process.env.REDOCLY_AUTHORIZATION) {
+    if (env.REDOCLY_AUTHORIZATION) {
       this.setAccessTokens({
         ...this.accessTokens,
-        [this.region]: process.env.REDOCLY_AUTHORIZATION,
+        [this.region]: env.REDOCLY_AUTHORIZATION,
       });
     }
   }
@@ -164,15 +141,11 @@ export class RedoclyClient {
 
   async login(accessToken: string, verbose: boolean = false) {
     const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
-    process.stdout.write(gray('\n  Logging in...\n'));
 
     try {
       await this.verifyToken(accessToken, this.region, verbose);
     } catch (err) {
-      process.stdout.write(
-        red('Authorization failed. Please check if you entered a valid API key.\n'),
-      );
-      process.exit(1);
+      throw new Error('Authorization failed. Please check if you entered a valid API key.');
     }
 
     const credentials = {
@@ -183,7 +156,6 @@ export class RedoclyClient {
     this.accessTokens = credentials;
     this.registryApi.setAccessTokens(credentials);
     writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
-    process.stdout.write(green('  Authorization confirmed. ✅\n\n'));
   }
 
   logout(): void {
@@ -191,12 +163,11 @@ export class RedoclyClient {
     if (existsSync(credentialsPath)) {
       unlinkSync(credentialsPath);
     }
-    process.stdout.write('Logged out from the Redocly account. ✋\n');
   }
 }
 
 export function isRedoclyRegistryURL(link: string): boolean {
-  const domain = REDOCLY_DOMAIN || process.env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
+  const domain = env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
 
   const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
 

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

@@ -16,6 +16,7 @@ export namespace RegistryApiTypes {
     filePaths: string[];
     branch?: string;
     isUpsert?: boolean;
+    isPublic?: boolean;
   }
 
   export interface PrepareFileuploadOKResponse {

package/src/redocly/registry-api.ts

@@ -104,6 +104,7 @@ export class RegistryApi {
     filePaths,
     branch,
     isUpsert,
+    isPublic,
   }: RegistryApiTypes.PushApiParams) {
     const response = await this.request(
       `/${organizationId}/${name}/${version}`,
@@ -118,6 +119,7 @@ export class RegistryApi {
           filePaths,
           branch,
           isUpsert,
+          isPublic,
         }),
       },
       this.region,

package/src/ref-utils.ts

@@ -72,6 +72,7 @@ export function isMappingRef(mapping: string) {
   return (
     mapping.startsWith('#') ||
     mapping.startsWith('https://') ||
+    mapping.startsWith('http://') ||
     mapping.startsWith('./') ||
     mapping.startsWith('../') ||
     mapping.indexOf('/') > -1