chore: update getReuniteUrl to take data from scorecard.fromProjectUrl (#2304)

Author: tatomyr

.changeset/ninety-sites-invent.md

@@ -0,0 +1,5 @@
+---
+"@redocly/openapi-core": patch
+---
+
+Updated @redocly/config to v0.31.0.

.changeset/ninety-spiders-chew.md

@@ -0,0 +1,5 @@
+---
+"@redocly/cli": patch
+---
+
+Updated authentication logic to get the residency from `scorecard.fromProjectUrl`.

package-lock.json

@@ -6,27 +6,31 @@ import { Buffer } from 'node:buffer';
 import { logger } from '@redocly/openapi-core';
 import { type Credentials, RedoclyOAuthDeviceFlow } from './device-flow.js';
 
-const SALT = '4618dbc9-8aed-4e27-aaf0-225f4603e5a4';
+const CREDENTIAL_SALT = '4618dbc9-8aed-4e27-aaf0-225f4603e5a4';
 const CRYPTO_ALGORITHM = 'aes-256-cbc';
 
 export class RedoclyOAuthClient {
-  public static readonly CREDENTIALS_FILE = 'credentials';
+  public readonly credentialsFolderPath: string;
+  public readonly credentialsFilePath: string;
+  public readonly credentialsFileName: string;
 
-  private readonly dir: string;
   private readonly key: Buffer;
   private readonly iv: Buffer;
 
   constructor() {
     const homeDirPath = homedir();
 
-    this.dir = path.join(homeDirPath, '.redocly');
-    mkdirSync(this.dir, { recursive: true });
+    this.credentialsFolderPath = path.join(homeDirPath, '.redocly');
+    this.credentialsFileName = 'credentials';
+    this.credentialsFilePath = path.join(this.credentialsFolderPath, this.credentialsFileName);
 
-    this.key = crypto.createHash('sha256').update(`${homeDirPath}${SALT}`).digest(); // 32-byte key
-    this.iv = crypto.createHash('md5').update(homeDirPath).digest(); // 16-byte IV
+    this.key = crypto.createHash('sha256').update(`${homeDirPath}${CREDENTIAL_SALT}`).digest();
+    this.iv = crypto.createHash('md5').update(homeDirPath).digest();
+
+    mkdirSync(this.credentialsFolderPath, { recursive: true });
   }
 
-  public async login(baseUrl: string) {
+  public async login(baseUrl: string): Promise<void> {
     const deviceFlow = new RedoclyOAuthDeviceFlow(baseUrl);
 
     const credentials = await deviceFlow.run();
@@ -79,35 +83,31 @@ export class RedoclyOAuthClient {
     }
   };
 
-  private get credentialsPath() {
-    return path.join(this.dir, RedoclyOAuthClient.CREDENTIALS_FILE);
-  }
-
   private async saveCredentials(credentials: Credentials): Promise<void> {
     try {
       const encryptedCredentials = this.encryptCredentials(credentials);
-      writeFileSync(this.credentialsPath, encryptedCredentials, 'utf8');
+      writeFileSync(this.credentialsFilePath, encryptedCredentials, 'utf8');
     } catch (error) {
       logger.error(`Failed to save credentials: ${error.message}`);
     }
   }
 
   private async readCredentials(): Promise<Credentials | null> {
-    if (!existsSync(this.credentialsPath)) {
+    if (!existsSync(this.credentialsFilePath)) {
       return null;
     }
 
     try {
-      const encryptedCredentials = readFileSync(this.credentialsPath, 'utf8');
+      const encryptedCredentials = readFileSync(this.credentialsFilePath, 'utf8');
       return this.decryptCredentials(encryptedCredentials);
     } catch {
       return null;
     }
   }
 
   private async removeCredentials(): Promise<void> {
-    if (existsSync(this.credentialsPath)) {
-      rmSync(this.credentialsPath);
+    if (existsSync(this.credentialsFilePath)) {
+      rmSync(this.credentialsFilePath);
     }
   }
 

packages/cli/src/auth/oauth-client.ts

@@ -48,25 +48,25 @@ describe('getReuniteUrl()', () => {
     expect(getReuniteUrl(config)).toBe('https://app.cloud.eu.redocly.com');
   });
 
-  it('should use projectUrl from config when no residency provided', async () => {
+  it('should use fromProjectUrl from config when no residency provided', async () => {
     const config = await createConfig({
-      reunite: { projectUrl: 'https://app.cloud.eu.redocly.com/org/test/project/test' },
+      scorecard: { fromProjectUrl: 'https://app.cloud.eu.redocly.com/org/test/project/test' },
     });
     expect(getReuniteUrl(config)).toBe('https://app.cloud.eu.redocly.com');
   });
 
-  it('should prioritize second parameter over config residency and projectUrl', async () => {
+  it('should prioritize second parameter over config residency and fromProjectUrl', async () => {
     const config = await createConfig({
       residency: 'us',
-      reunite: { projectUrl: 'https://app.cloud.eu.redocly.com/org/test/project/test' },
+      scorecard: { fromProjectUrl: 'https://app.cloud.eu.redocly.com/org/test/project/test' },
     });
     expect(getReuniteUrl(config, 'eu')).toBe('https://app.cloud.eu.redocly.com');
   });
 
-  it('should prioritize residency over projectUrl when both are provided', async () => {
+  it('should prioritize residency over fromProjectUrl when both are provided', async () => {
     const config = await createConfig({
       residency: 'us',
-      reunite: { projectUrl: 'https://app.cloud.eu.redocly.com/org/test/project/test' },
+      scorecard: { fromProjectUrl: 'https://app.cloud.eu.redocly.com/org/test/project/test' },
     });
     expect(getReuniteUrl(config)).toBe('https://app.cloud.redocly.com');
   });
@@ -76,9 +76,9 @@ describe('getReuniteUrl()', () => {
     expect(getReuniteUrl(config, 'https://custom.redocly.com')).toBe('https://custom.redocly.com');
   });
 
-  it('should handle projectUrl with custom domain and port', async () => {
+  it('should handle fromProjectUrl with custom domain and port', async () => {
     const config = await createConfig({
-      reunite: { projectUrl: 'https://custom.redocly.com:8080/org/test/project/test' },
+      scorecard: { fromProjectUrl: 'https://custom.redocly.com:8080/org/test/project/test' },
     });
     expect(getReuniteUrl(config)).toBe('https://custom.redocly.com:8080');
   });
@@ -89,9 +89,9 @@ describe('getReuniteUrl()', () => {
     expect(() => getReuniteUrl(testConfig, 'not-a-valid-url')).toThrow('Invalid Reunite URL');
   });
 
-  it('should throw error for invalid projectUrl', async () => {
+  it('should throw error for invalid fromProjectUrl', async () => {
     const config = await createConfig({
-      reunite: { projectUrl: 'not-a-valid-url' },
+      scorecard: { fromProjectUrl: 'not-a-valid-url' },
     });
     expect(() => getReuniteUrl(config)).toThrow('Invalid Reunite URL');
   });

packages/cli/src/reunite/api/__tests__/domains.test.ts

@@ -9,25 +9,45 @@ export function getDomain(): string {
   return process.env.REDOCLY_DOMAIN || REUNITE_URLS.us;
 }
 
-export function getReuniteUrl(config: Config | undefined, residencyOption?: string): string {
-  try {
-    const residency = residencyOption || config?.resolvedConfig.residency;
-
-    if (isLegacyResidency(residency)) {
-      return REUNITE_URLS[residency];
+export const getReuniteUrl = withHttpsValidation(
+  (config: Config | undefined, residencyOption?: string): string => {
+    try {
+      const residency = residencyOption || config?.resolvedConfig.residency;
+
+      if (isLegacyResidency(residency)) {
+        return REUNITE_URLS[residency];
+      }
+
+      if (residency) {
+        return new URL(residency).origin;
+      }
+
+      if (config?.resolvedConfig.scorecard?.fromProjectUrl) {
+        return new URL(config.resolvedConfig.scorecard.fromProjectUrl).origin;
+      }
+
+      return REUNITE_URLS.us;
+    } catch {
+      throw new InvalidReuniteUrlError();
     }
+  }
+);
 
-    if (residency) {
-      return new URL(residency).origin;
-    }
+function withHttpsValidation<Fn extends (...args: any[]) => string>(fn: Fn) {
+  return (...args: Parameters<Fn>) => {
+    const url = fn(...args);
 
-    if (config?.resolvedConfig.reunite?.projectUrl) {
-      return new URL(config.resolvedConfig.reunite.projectUrl).origin;
+    if (!url.startsWith('https://')) {
+      throw new InvalidReuniteUrlError();
     }
 
-    return REUNITE_URLS.us;
-  } catch {
-    throw new Error('Invalid Reunite URL');
+    return url;
+  };
+}
+
+export class InvalidReuniteUrlError extends Error {
+  constructor() {
+    super('Invalid Reunite URL');
   }
 }
 

packages/cli/src/reunite/api/domains.ts

@@ -58,7 +58,7 @@
   ],
   "dependencies": {
     "@redocly/ajv": "^8.11.2",
-    "@redocly/config": "^0.30.0",
+    "@redocly/config": "^0.31.0",
     "ajv-formats": "^2.1.1",
     "colorette": "^1.2.0",
     "js-levenshtein": "^1.1.6",

packages/core/package.json

@@ -7,17 +7,13 @@ import { isAbsoluteUrl, isExternalValue, isRef, refBaseName, replaceRef } from '
 import { initRules } from './config/rules.js';
 import { reportUnresolvedRef } from './rules/common/no-unresolved-refs.js';
 import { isTruthy } from './utils.js';
-import { dequal } from './dequal.js';
+import { dequal } from './utils/dequal.js';
 import { RemoveUnusedComponents as RemoveUnusedComponentsOas2 } from './decorators/oas2/remove-unused-components.js';
 import { RemoveUnusedComponents as RemoveUnusedComponentsOas3 } from './decorators/oas3/remove-unused-components.js';
 import { NormalizedConfigTypes } from './types/redocly-yaml.js';
-import { type Config } from './config/index.js';
-import {
-  CONFIG_BUNDLER_VISITOR_ID,
-  configBundlerVisitor,
-  pluginsCollectorVisitor,
-  PLUGINS_COLLECTOR_VISITOR_ID,
-} from './config/visitors.js';
+import { type Config } from './config/config.js';
+import { configBundlerVisitor, pluginsCollectorVisitor } from './config/visitors.js';
+import { CONFIG_BUNDLER_VISITOR_ID, PLUGINS_COLLECTOR_VISITOR_ID } from './config/constants.js';
 
 import type { ConfigBundlerVisitorData, PluginsCollectorVisitorData } from './config/visitors.js';
 import type { Plugin, ResolvedConfig } from './config/types.js';

packages/core/src/bundle.ts

@@ -20,7 +20,7 @@ import { colorize, logger } from '../logger.js';
 import { asserts, buildAssertCustomFunction } from '../rules/common/assertions/asserts.js';
 import { NormalizedConfigTypes } from '../types/redocly-yaml.js';
 import { bundleConfig, collectConfigPlugins } from '../bundle.js';
-import { CONFIG_FILE_NAME } from './load.js';
+import { CONFIG_FILE_NAME, DEFAULT_CONFIG, DEFAULT_PROJECT_PLUGIN_PATHS } from './constants.js';
 
 import type {
   Plugin,
@@ -38,8 +38,6 @@ import type {
 import type { Asserts, AssertionFn } from '../rules/common/assertions/asserts.js';
 import type { Document, ResolvedRefMap } from '../resolve.js';
 
-const DEFAULT_PROJECT_PLUGIN_PATHS = ['@theme/plugin.js', '@theme/plugin.cjs', '@theme/plugin.mjs'];
-
 // Cache instantiated plugins during a single execution
 const pluginsCache: Map<string, Plugin[]> = new Map();
 
@@ -66,8 +64,7 @@ export async function resolveConfig({
   resolvedRefMap: ResolvedRefMap;
   plugins: Plugin[];
 }> {
-  const config =
-    rawConfigDocument === undefined ? { extends: ['recommended'] } : rawConfigDocument.parsed;
+  const config = rawConfigDocument === undefined ? DEFAULT_CONFIG : rawConfigDocument.parsed;
 
   if (customExtends !== undefined && isPlainObject(config)) {
     config.extends = customExtends;

packages/core/src/config/config-resolvers.ts

@@ -8,6 +8,7 @@ import { getResolveConfig } from './utils.js';
 import { isAbsoluteUrl } from '../ref-utils.js';
 import { type Document, type ResolvedRefMap } from '../resolve.js';
 import { groupAssertionRules } from './config-resolvers.js';
+import { IGNORE_BANNER, IGNORE_FILE } from './constants.js';
 
 import type { NormalizedProblem } from '../walk.js';
 import type {
@@ -31,11 +32,6 @@ import type {
   RuleSettings,
 } from './types.js';
 
-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://redocly.com/docs/cli/ for more information.\n`;
-
 function getIgnoreFilePath(configPath?: string): string | undefined {
   if (configPath) {
     return doesYamlFileExist(configPath)