@redocly/openapi-core 1.18.0 → 1.19.0

package/src/types/redocly-yaml.ts

@@ -92,8 +92,20 @@ const builtInAsync2Rules = [
   'no-channel-trailing-slash',
 ] as const;
 
+const builtInAsync3Rules = [
+  'spec',
+  'info-contact',
+  'operation-operationId',
+  'tag-description',
+  'tags-alphabetical',
+  'channels-kebab-case',
+  'no-channel-trailing-slash',
+] as const;
+
 export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
 
+export type BuiltInAsync3RuleId = typeof builtInAsync3Rules[number];
+
 const builtInArazzoRules = ['spec'] as const;
 
 export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];
@@ -103,6 +115,7 @@ const builtInRules = [
   ...builtInOAS2Rules,
   ...builtInOAS3Rules,
   ...builtInAsync2Rules,
+  ...builtInAsync3Rules,
   ...builtInArazzoRules,
 ] as const;
 
@@ -221,6 +234,7 @@ const oas3_1NodeTypesList = [
   'Root',
   'Schema',
   'SchemaProperties',
+  'PatternProperties',
   'Info',
   'License',
   'Components',

package/src/typings/arazzo.ts

@@ -1,4 +1,44 @@
 import type { FromSchema } from 'json-schema-to-ts';
-import type { arazzoSchema } from '../types/arazzo';
+import type {
+  arazzoSchema,
+  parameter,
+  operationMethod,
+  expectSchema,
+  sourceDescriptionSchema,
+  infoObject,
+  requestBody,
+  replacement,
+  inherit,
+  criteriaObject,
+  step,
+  workflow,
+} from '../types/arazzo';
 
 export type ArazzoDefinition = FromSchema<typeof arazzoSchema>;
+export type OperationMethod = FromSchema<typeof operationMethod>;
+export type ResponseContext = {
+  statusCode: number;
+  body: any;
+  headers: Headers;
+  mimeType: string;
+} & Record<string, any>;
+export type Expect = FromSchema<typeof expectSchema>;
+export type SourceDescription = FromSchema<typeof sourceDescriptionSchema>;
+export type Parameter = FromSchema<typeof parameter>;
+export type InfoObject = FromSchema<typeof infoObject>;
+export type RequestBody = FromSchema<typeof requestBody>;
+export type Replacement = FromSchema<typeof replacement>;
+export type Inherit = FromSchema<typeof inherit>;
+export type CriteriaObject = FromSchema<typeof criteriaObject>;
+export type VerboseLog = {
+  method: OperationMethod;
+  path: string;
+  host: string;
+  body?: any;
+  headerParams?: Record<string, string>;
+  statusCode?: number;
+};
+export type Step = FromSchema<typeof step>;
+export type Workflow = FromSchema<typeof workflow> & {
+  steps: Step[];
+};

package/src/typings/asyncapi3.ts

@@ -0,0 +1,61 @@
+export interface Async3Definition {
+  asyncapi: string;
+  servers?: Record<string, any>;
+  info: Async3Info;
+  channels?: Record<string, Channel>;
+  components?: Record<string, any>;
+  operations?: Record<string, any>;
+  defaultContentType?: string;
+}
+
+export interface Async3Info {
+  title: string;
+  version: string;
+
+  description?: string;
+  termsOfService?: string;
+  contact?: Async3Contact;
+  license?: Async3License;
+  tags?: Tag[];
+  externalDocs?: ExternalDoc;
+}
+
+export interface Async3Contact {
+  name?: string;
+  url?: string;
+  email?: string;
+}
+
+export interface Async3License {
+  name: string;
+  url?: string;
+}
+
+export interface Tag {
+  name: string;
+  description?: string;
+  externalDocs?: ExternalDoc;
+}
+
+export interface ExternalDoc {
+  url: string;
+  description?: string;
+}
+
+export interface Channel {
+  address?: string | null;
+  messages?: Record<string, any>;
+  title?: string;
+  summary?: string;
+  description?: string;
+  servers?: Record<string, any>[];
+  parameters?: Record<string, any>;
+  tags?: Record<string, any>;
+  externalDocs?: ExternalDocumentation;
+  bindings?: Record<string, any>;
+}
+
+export interface ExternalDocumentation {
+  url: string;
+  description?: string;
+}

package/src/utils.ts

@@ -2,14 +2,14 @@ import * as fs from 'fs';
 import { extname } from 'path';
 import * as minimatch from 'minimatch';
 import fetch from 'node-fetch';
-import * as pluralize from 'pluralize';
 import { parseYaml } from './js-yaml';
-import { UserContext } from './walk';
 import { env } from './env';
 import { logger, colorize } from './logger';
-import { HttpResolveConfig } from './config';
 import { HttpsProxyAgent } from 'https-proxy-agent';
 
+import type { HttpResolveConfig } from './config';
+import type { UserContext } from './walk';
+
 export { parseYaml, stringifyYaml } from './js-yaml';
 
 export type StackFrame<T> = {
@@ -38,15 +38,15 @@ export function isDefined<T>(x: T | undefined): x is T {
   return x !== undefined;
 }
 
-export function isPlainObject(value: any): value is Record<string, unknown> {
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
 
-export function isEmptyObject(value: any): value is Record<string, unknown> {
+export function isEmptyObject(value: unknown): value is Record<string, unknown> {
   return isPlainObject(value) && Object.keys(value).length === 0;
 }
 
-export function isEmptyArray(value: any) {
+export function isEmptyArray(value: unknown) {
   return Array.isArray(value) && value.length === 0;
 }
 
@@ -146,10 +146,6 @@ export function validateMimeTypeOAS3(
   }
 }
 
-export function isSingular(path: string) {
-  return pluralize.isSingular(path);
-}
-
 export function readFileAsStringSync(filePath: string) {
   return fs.readFileSync(filePath, 'utf-8');
 }
@@ -267,7 +263,7 @@ export function pickDefined<T extends Record<string, unknown>>(
 }
 
 export function nextTick() {
-  new Promise((resolve) => {
+  return new Promise((resolve) => {
     setTimeout(resolve);
   });
 }
@@ -284,3 +280,42 @@ export function getProxyAgent() {
   const proxy = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
   return proxy ? new HttpsProxyAgent(proxy) : undefined;
 }
+
+/**
+ * Checks if two objects are deeply equal.
+ * Borrowed the source code from https://github.com/lukeed/dequal.
+ */
+export function dequal(foo: any, bar: any): boolean {
+  let ctor, len;
+  if (foo === bar) return true;
+
+  if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+    if (ctor === Date) return foo.getTime() === bar.getTime();
+    if (ctor === RegExp) return foo.toString() === bar.toString();
+
+    if (ctor === Array) {
+      if ((len = foo.length) === bar.length) {
+        while (len-- && dequal(foo[len], bar[len]));
+      }
+      return len === -1;
+    }
+
+    if (!ctor || typeof foo === 'object') {
+      len = 0;
+      for (ctor in foo) {
+        if (
+          Object.prototype.hasOwnProperty.call(foo, ctor) &&
+          ++len &&
+          !Object.prototype.hasOwnProperty.call(bar, ctor)
+        )
+          return false;
+        if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor])) return false;
+      }
+      return Object.keys(bar).length === len;
+    }
+  }
+
+  return foo !== foo && bar !== bar;
+}
+
+export type CollectFn = (value: unknown) => void;

package/src/visitors.ts

@@ -50,6 +50,7 @@ import type {
   Oas2SecurityScheme,
 } from './typings/swagger';
 import type { Async2Definition } from './typings/asyncapi';
+import type { Async3Definition } from './typings/asyncapi3';
 import type { ArazzoDefinition } from './typings/arazzo';
 
 export type SkipFunctionContext = Pick<
@@ -213,6 +214,10 @@ type Async2FlatVisitor = {
   Root?: VisitFunctionOrObject<Async2Definition>;
 };
 
+type Async3FlatVisitor = {
+  Root?: VisitFunctionOrObject<Async3Definition>;
+};
+
 type ArazzoFlatVisitor = {
   Root?: VisitFunctionOrObject<ArazzoDefinition>;
 };
@@ -249,6 +254,12 @@ type Async2NestedVisitor = {
     : Async2FlatVisitor[T] & NestedVisitor<Async2NestedVisitor>;
 };
 
+type Async3NestedVisitor = {
+  [T in keyof Async3FlatVisitor]: Async3FlatVisitor[T] extends Function
+    ? Async3FlatVisitor[T]
+    : Async3FlatVisitor[T] & NestedVisitor<Async3NestedVisitor>;
+};
+
 type ArazzoNestedVisitor = {
   [T in keyof ArazzoFlatVisitor]: ArazzoFlatVisitor[T] extends Function
     ? ArazzoFlatVisitor[T]
@@ -267,6 +278,10 @@ export type Async2Visitor = BaseVisitor &
   Async2NestedVisitor &
   Record<string, VisitFunction<any> | NestedVisitObject<any, Async2NestedVisitor>>;
 
+export type Async3Visitor = BaseVisitor &
+  Async3NestedVisitor &
+  Record<string, VisitFunction<any> | NestedVisitObject<any, Async3NestedVisitor>>;
+
 export type ArazzoVisitor = BaseVisitor &
   ArazzoNestedVisitor &
   Record<string, VisitFunction<any> | NestedVisitObject<any, ArazzoNestedVisitor>>;
@@ -293,14 +308,17 @@ export type NormalizedOasVisitors<T extends BaseVisitor> = {
 export type Oas3Rule = (options: Record<string, any>) => Oas3Visitor | Oas3Visitor[];
 export type Oas2Rule = (options: Record<string, any>) => Oas2Visitor | Oas2Visitor[];
 export type Async2Rule = (options: Record<string, any>) => Async2Visitor | Async2Visitor[];
+export type Async3Rule = (options: Record<string, any>) => Async3Visitor | Async3Visitor[];
 export type ArazzoRule = (options: Record<string, any>) => ArazzoVisitor | ArazzoVisitor[];
 export type Oas3Preprocessor = (options: Record<string, any>) => Oas3Visitor;
 export type Oas2Preprocessor = (options: Record<string, any>) => Oas2Visitor;
 export type Async2Preprocessor = (options: Record<string, any>) => Async2Visitor;
+export type Async3Preprocessor = (options: Record<string, any>) => Async3Visitor;
 export type ArazzoPreprocessor = (options: Record<string, any>) => ArazzoVisitor;
 export type Oas3Decorator = (options: Record<string, any>) => Oas3Visitor;
 export type Oas2Decorator = (options: Record<string, any>) => Oas2Visitor;
 export type Async2Decorator = (options: Record<string, any>) => Async2Visitor;
+export type Async3Decorator = (options: Record<string, any>) => Async3Visitor;
 export type ArazzoDecorator = (options: Record<string, any>) => ArazzoVisitor;
 
 // alias for the latest version supported