@redocly/openapi-core 1.18.0 → 1.18.1

package/src/rules/common/path-segment-plural.ts

@@ -1,6 +1,7 @@
+import * as pluralize from 'pluralize';
 import { Oas3Rule, Oas2Rule } from '../../visitors';
 import { UserContext } from '../../walk';
-import { isPathParameter, isSingular } from '../../utils';
+import { isPathParameter } from '../../utils';
 
 export const PathSegmentPlural: Oas3Rule | Oas2Rule = (opts) => {
   const { ignoreLastPathSegment, exceptions } = opts;
@@ -17,7 +18,7 @@ export const PathSegmentPlural: Oas3Rule | Oas2Rule = (opts) => {
 
           for (const pathSegment of pathSegments) {
             if (exceptions && exceptions.includes(pathSegment)) continue;
-            if (!isPathParameter(pathSegment) && isSingular(pathSegment)) {
+            if (!isPathParameter(pathSegment) && pluralize.isSingular(pathSegment)) {
               report({
                 message: `path segment \`${pathSegment}\` should be plural.`,
                 location: location.key(),

package/src/types/arazzo.ts

@@ -4,11 +4,11 @@ import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
 
 export const ARAZZO_ROOT_TYPE = 'Root';
 
-const operationMethod = {
+export const operationMethod = {
   type: 'string',
   enum: ['get', 'post', 'put', 'delete', 'patch'],
 } as const;
-const expectSchema = {
+export const expectSchema = {
   type: 'object',
   properties: {
     statusCode: { type: 'number' },
@@ -58,7 +58,7 @@ const arazzoSourceDescriptionSchema = {
   additionalProperties: false,
   required: ['name', 'type', 'url'],
 } as const;
-const sourceDescriptionSchema = {
+export const sourceDescriptionSchema = {
   type: 'object',
   oneOf: [
     openAPISourceDescriptionSchema,
@@ -81,7 +81,7 @@ const extendedOperation = {
   additionalProperties: false,
   required: ['path', 'method'],
 } as const;
-const parameter = {
+export const parameter = {
   type: 'object',
   oneOf: [
     {
@@ -96,17 +96,6 @@ const parameter = {
       required: ['name', 'value'],
       additionalProperties: false,
     },
-    {
-      type: 'object',
-      properties: {
-        $ref: { type: 'string' },
-        value: {
-          oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
-        },
-      },
-      required: ['$ref'],
-      additionalProperties: false,
-    },
     {
       type: 'object',
       properties: {
@@ -124,7 +113,7 @@ const parameters = {
   type: 'array',
   items: parameter,
 } as const;
-const infoObject = {
+export const infoObject = {
   type: 'object',
   properties: {
     title: { type: 'string' },
@@ -135,7 +124,7 @@ const infoObject = {
   additionalProperties: false,
   required: ['title', 'version'],
 } as const;
-const replacement = {
+export const replacement = {
   type: 'object',
   properties: {
     target: { type: 'string' },
@@ -150,7 +139,7 @@ const replacement = {
     },
   },
 } as const;
-const requestBody = {
+export const requestBody = {
   type: 'object',
   properties: {
     contentType: { type: 'string' },
@@ -172,7 +161,7 @@ const requestBody = {
   additionalProperties: false,
   required: ['payload'],
 } as const;
-const criteriaObject = {
+export const criteriaObject = {
   type: 'object',
   properties: {
     condition: { type: 'string' },
@@ -204,7 +193,7 @@ const criteriaObjects = {
   type: 'array',
   items: criteriaObject,
 } as const;
-const inherit = {
+export const inherit = {
   type: 'string',
   enum: ['auto', 'none'],
 } as const;
@@ -242,7 +231,7 @@ const onFailureList = {
   type: 'array',
   items: onFailureObject,
 } as const;
-const step = {
+export const step = {
   type: 'object',
   properties: {
     stepId: { type: 'string' },
@@ -257,7 +246,23 @@ const step = {
     outputs: {
       type: 'object',
       additionalProperties: {
-        type: 'string',
+        oneOf: [
+          {
+            type: 'string',
+          },
+          {
+            type: 'object',
+          },
+          {
+            type: 'array',
+          },
+          {
+            type: 'boolean',
+          },
+          {
+            type: 'number',
+          },
+        ],
       },
     },
     'x-inherit': inherit,
@@ -301,7 +306,7 @@ const JSONSchema = {
   required: ['type'],
   additionalProperties: true,
 } as const;
-const workflow = {
+export const workflow = {
   type: 'object',
   properties: {
     workflowId: { type: 'string' },

package/src/types/asyncapi.ts

@@ -334,11 +334,8 @@ const MessageExample: NodeType = {
 const Schema: NodeType = {
   properties: {
     $id: { type: 'string' },
-    id: { type: 'string' },
     $schema: { type: 'string' },
     definitions: 'NamedSchemas',
-    $defs: 'NamedSchemas',
-    $vocabulary: { type: 'string' },
     externalDocs: 'ExternalDocs',
     discriminator: 'Discriminator',
     myArbitraryKeyword: { type: 'boolean' },
@@ -359,16 +356,14 @@ const Schema: NodeType = {
     required: { type: 'array', items: { type: 'string' } },
     enum: { type: 'array' },
     type: (value: any) => {
-      if (Array.isArray(value)) {
-        return {
-          type: 'array',
-          items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
-        };
-      } else {
-        return {
-          enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
-        };
-      }
+      return Array.isArray(value)
+        ? {
+            type: 'array',
+            items: { enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'] },
+          }
+        : {
+            enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
+          };
     },
     allOf: listOf('Schema'),
     anyOf: listOf('Schema'),
@@ -377,35 +372,12 @@ const Schema: NodeType = {
     if: 'Schema',
     then: 'Schema',
     else: 'Schema',
-    dependentSchemas: listOf('Schema'),
-    prefixItems: listOf('Schema'),
     contains: 'Schema',
-    minContains: { type: 'integer', minimum: 0 },
-    maxContains: { type: 'integer', minimum: 0 },
     patternProperties: { type: 'object' },
     propertyNames: 'Schema',
-    unevaluatedItems: (value: unknown) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
-    },
-    unevaluatedProperties: (value: unknown) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
-    },
-    summary: { type: 'string' },
     properties: 'SchemaProperties',
     items: (value: any) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
+      return Array.isArray(value) ? listOf('Schema') : 'Schema';
     },
     additionalProperties: (value: any) => {
       return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
@@ -417,23 +389,22 @@ const Schema: NodeType = {
     default: null,
     readOnly: { type: 'boolean' },
     writeOnly: { type: 'boolean' },
-    // xml: 'Xml',
     examples: { type: 'array' },
     example: { isExample: true },
     deprecated: { type: 'boolean' },
     const: null,
     $comment: { type: 'string' },
-    dependencies: { type: 'object' }, // TODO
+    additionalItems: (value: any) => {
+      return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
+    },
+    dependencies: 'Dependencies',
   },
 };
 
 const SchemaProperties: NodeType = {
   properties: {},
   additionalProperties: (value: any) => {
-    if (typeof value === 'boolean') {
-      return { type: 'boolean' };
-    }
-    return 'Schema';
+    return typeof value === 'boolean' ? { type: 'boolean' } : 'Schema';
   },
 };
 
@@ -584,6 +555,13 @@ const SecurityScheme: NodeType = {
   extensionsPrefix: 'x-',
 };
 
+const Dependencies: NodeType = {
+  properties: {},
+  additionalProperties: (value: any) => {
+    return Array.isArray(value) ? { type: 'array', items: { type: 'string' } } : 'Schema';
+  },
+};
+
 // --- Per-protocol node types
 
 // http
@@ -1133,4 +1111,5 @@ export const AsyncApi2Types: Record<string, NodeType> = {
   MessageTrait,
   MessageTraitList: listOf('MessageTrait'),
   CorrelationId,
+  Dependencies,
 };

package/src/types/oas3_1.ts

@@ -133,13 +133,13 @@ const Schema: NodeType = {
     if: 'Schema',
     then: 'Schema',
     else: 'Schema',
-    dependentSchemas: listOf('Schema'),
+    dependentSchemas: mapOf('Schema'),
     dependentRequired: 'DependentRequired',
     prefixItems: listOf('Schema'),
     contains: 'Schema',
     minContains: { type: 'integer', minimum: 0 },
     maxContains: { type: 'integer', minimum: 0 },
-    patternProperties: { type: 'object' },
+    patternProperties: 'SchemaProperties',
     propertyNames: 'Schema',
     unevaluatedItems: (value: unknown) => {
       if (typeof value === 'boolean') {

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/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> = {
@@ -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,40 @@ 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;
+}