@redocly/openapi-core 1.17.1 → 1.18.1

package/src/types/arazzo.ts

@@ -0,0 +1,391 @@
+import type { NodeType } from '.';
+
+import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
+
+export const ARAZZO_ROOT_TYPE = 'Root';
+
+export const operationMethod = {
+  type: 'string',
+  enum: ['get', 'post', 'put', 'delete', 'patch'],
+} as const;
+export const expectSchema = {
+  type: 'object',
+  properties: {
+    statusCode: { type: 'number' },
+    mimeType: { type: 'string' },
+    body: {},
+    schema: {
+      type: 'object',
+      additionalProperties: true,
+    },
+  },
+  additionalProperties: false,
+  oneOf: [
+    { required: ['statusCode'] },
+    { required: ['mimeType'] },
+    { required: ['body'] },
+    { required: ['schema'] },
+  ],
+} as const;
+const openAPISourceDescriptionSchema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['openapi'] },
+    url: { type: 'string' },
+    'x-serverUrl': { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['name', 'type', 'url'],
+} as const;
+const noneSourceDescriptionSchema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['none'] },
+    'x-serverUrl': { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['name', 'type', 'x-serverUrl'],
+} as const;
+const arazzoSourceDescriptionSchema = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['arazzo'] },
+    url: { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['name', 'type', 'url'],
+} as const;
+export const sourceDescriptionSchema = {
+  type: 'object',
+  oneOf: [
+    openAPISourceDescriptionSchema,
+    noneSourceDescriptionSchema,
+    arazzoSourceDescriptionSchema,
+  ],
+} as const;
+const sourceDescriptionsSchema = {
+  type: 'array',
+  items: sourceDescriptionSchema,
+} as const;
+const extendedOperation = {
+  type: 'object',
+  properties: {
+    path: { type: 'string' },
+    method: operationMethod,
+    sourceDescriptionName: { type: 'string' },
+    serverUrl: { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['path', 'method'],
+} as const;
+export const parameter = {
+  type: 'object',
+  oneOf: [
+    {
+      type: 'object',
+      properties: {
+        in: { type: 'string', enum: ['header', 'query', 'path', 'cookie', 'body'] },
+        name: { type: 'string' },
+        value: {
+          oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+        },
+      },
+      required: ['name', 'value'],
+      additionalProperties: false,
+    },
+    {
+      type: 'object',
+      properties: {
+        reference: { type: 'string' },
+        value: {
+          oneOf: [{ type: 'string' }, { type: 'number' }, { type: 'boolean' }],
+        },
+      },
+      required: ['reference'],
+      additionalProperties: false,
+    },
+  ],
+} as const;
+const parameters = {
+  type: 'array',
+  items: parameter,
+} as const;
+export const infoObject = {
+  type: 'object',
+  properties: {
+    title: { type: 'string' },
+    description: { type: 'string' },
+    summary: { type: 'string' },
+    version: { type: 'string' },
+  },
+  additionalProperties: false,
+  required: ['title', 'version'],
+} as const;
+export const replacement = {
+  type: 'object',
+  properties: {
+    target: { type: 'string' },
+    value: {
+      oneOf: [
+        { type: 'string' },
+        { type: 'object' },
+        { type: 'array' },
+        { type: 'number' },
+        { type: 'boolean' },
+      ],
+    },
+  },
+} as const;
+export const requestBody = {
+  type: 'object',
+  properties: {
+    contentType: { type: 'string' },
+    payload: {
+      oneOf: [
+        { type: 'string' },
+        { type: 'object', additionalProperties: true },
+        { type: 'array' },
+        { type: 'number' },
+        { type: 'boolean' },
+      ],
+    },
+    encoding: { type: 'string' },
+    replacements: {
+      type: 'array',
+      items: replacement,
+    },
+  },
+  additionalProperties: false,
+  required: ['payload'],
+} as const;
+export const criteriaObject = {
+  type: 'object',
+  properties: {
+    condition: { type: 'string' },
+    context: { type: 'string' },
+    type: {
+      oneOf: [
+        { type: 'string', enum: ['regex', 'jsonpath', 'simple', 'xpath'] },
+        {
+          type: 'object',
+          properties: {
+            type: { type: 'string', enum: ['jsonpath'] },
+            version: { type: 'string', enum: ['draft-goessner-dispatch-jsonpath-00'] },
+          },
+        },
+        {
+          type: 'object',
+          properties: {
+            type: { type: 'string', enum: ['xpath'] },
+            version: { type: 'string', enum: ['xpath-30', 'xpath-20', 'xpath-10'] },
+          },
+        },
+      ],
+    },
+  },
+  required: ['condition'],
+  additionalProperties: false,
+} as const;
+const criteriaObjects = {
+  type: 'array',
+  items: criteriaObject,
+} as const;
+export const inherit = {
+  type: 'string',
+  enum: ['auto', 'none'],
+} as const;
+const onSuccessObject = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['goto', 'end'] },
+    stepId: { type: 'string' },
+    workflowId: { type: 'string' },
+    criteria: criteriaObjects,
+  },
+  additionalProperties: false,
+  required: ['type', 'name'],
+} as const;
+const onSuccessList = {
+  type: 'array',
+  items: onSuccessObject,
+} as const;
+const onFailureObject = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    type: { type: 'string', enum: ['goto', 'retry', 'end'] },
+    workflowId: { type: 'string' },
+    stepId: { type: 'string' },
+    retryAfter: { type: 'number' },
+    retryLimit: { type: 'number' },
+    criteria: criteriaObjects,
+  },
+  additionalProperties: false,
+  required: ['type', 'name'],
+} as const;
+const onFailureList = {
+  type: 'array',
+  items: onFailureObject,
+} as const;
+export const step = {
+  type: 'object',
+  properties: {
+    stepId: { type: 'string' },
+    description: { type: 'string' },
+    operationId: { type: 'string' },
+    operationPath: { type: 'string' },
+    workflowId: { type: 'string' },
+    parameters: parameters,
+    successCriteria: criteriaObjects,
+    onSuccess: onSuccessList,
+    onFailure: onFailureList,
+    outputs: {
+      type: 'object',
+      additionalProperties: {
+        oneOf: [
+          {
+            type: 'string',
+          },
+          {
+            type: 'object',
+          },
+          {
+            type: 'array',
+          },
+          {
+            type: 'boolean',
+          },
+          {
+            type: 'number',
+          },
+        ],
+      },
+    },
+    'x-inherit': inherit,
+    'x-expect': expectSchema,
+    'x-assert': { type: 'string' },
+    'x-operation': extendedOperation,
+    requestBody: requestBody,
+  },
+  required: ['stepId'],
+  oneOf: [
+    { required: ['x-operation'] },
+    { required: ['operationId'] },
+    { required: ['operationPath'] },
+    { required: ['workflowId'] },
+  ],
+} as const;
+const steps = {
+  type: 'array',
+  items: step,
+} as const;
+const JSONSchema = {
+  type: 'object',
+  properties: {
+    type: {
+      type: 'string',
+      enum: ['object', 'array', 'string', 'number', 'integer', 'boolean', 'null'],
+    },
+    properties: {
+      type: 'object',
+      additionalProperties: true,
+    },
+    required: {
+      type: 'array',
+      items: { type: 'string' },
+    },
+    items: {
+      type: 'object',
+      additionalProperties: true,
+    },
+  },
+  required: ['type'],
+  additionalProperties: true,
+} as const;
+export const workflow = {
+  type: 'object',
+  properties: {
+    workflowId: { type: 'string' },
+    summary: { type: 'string' },
+    description: { type: 'string' },
+    parameters: parameters,
+    dependsOn: { type: 'array', items: { type: 'string' } },
+    inputs: JSONSchema,
+    outputs: {
+      type: 'object',
+      additionalProperties: {
+        type: 'string',
+      },
+    },
+    steps: steps,
+    successActions: {
+      type: 'array',
+      items: onSuccessObject,
+    },
+    failureActions: {
+      type: 'array',
+      items: onFailureObject,
+    },
+  },
+  additionalProperties: false,
+  required: ['workflowId', 'steps'],
+} as const;
+const workflows = {
+  type: 'array',
+  items: workflow,
+} as const;
+export const arazzoSchema = {
+  type: 'object',
+  properties: {
+    arazzo: { type: 'string', enum: ['1.0.0'] },
+    info: infoObject,
+    sourceDescriptions: sourceDescriptionsSchema,
+    'x-parameters': parameters,
+    workflows: workflows,
+    components: {
+      type: 'object',
+      properties: {
+        inputs: {
+          type: 'object',
+          additionalProperties: {
+            type: 'object',
+            additionalProperties: true,
+            properties: {
+              type: {
+                type: 'string',
+              },
+              properties: {
+                type: 'object',
+                additionalProperties: true,
+              },
+            },
+            required: ['type'],
+          },
+        },
+        parameters: {
+          type: 'object',
+          additionalProperties: parameter,
+        },
+        successActions: {
+          type: 'object',
+          additionalProperties: onSuccessObject,
+        },
+        failureActions: {
+          type: 'object',
+          additionalProperties: onFailureObject,
+        },
+      },
+    },
+  },
+  additionalProperties: false,
+  required: ['arazzo', 'info', 'sourceDescriptions', 'workflows'],
+} as const;
+
+export const ArazzoTypes: Record<string, NodeType> = getNodeTypesFromJSONSchema(
+  ARAZZO_ROOT_TYPE,
+  arazzoSchema
+);

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.ts

@@ -346,13 +346,6 @@ const Schema: NodeType = {
         return 'Schema';
       }
     },
-    additionalItems: (value: any) => {
-      if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-      } else {
-        return 'Schema';
-      }
-    },
     additionalProperties: (value: any) => {
       if (typeof value === 'boolean') {
         return { type: 'boolean' };

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/types/redocly-yaml.ts

@@ -8,17 +8,12 @@ import type { JSONSchema } from 'json-schema-to-ts';
 import { SpecVersion, getTypes } from '../oas-types';
 import { Config } from '../config';
 
-const builtInCommonRules = [
+const builtInCommonOASRules = [
   'spec',
   'info-contact',
   'operation-operationId',
   'tag-description',
   'tags-alphabetical',
-] as const;
-
-export type BuiltInCommonRuleId = typeof builtInCommonRules[number];
-
-const builtInCommonOASRules = [
   'info-license-url',
   'info-license',
   'no-ambiguous-paths',
@@ -87,16 +82,28 @@ const builtInOAS3Rules = [
 
 export type BuiltInOAS3RuleId = typeof builtInOAS3Rules[number];
 
-const builtInAsync2Rules = ['channels-kebab-case', 'no-channel-trailing-slash'] as const;
+const builtInAsync2Rules = [
+  'spec',
+  'info-contact',
+  'operation-operationId',
+  'tag-description',
+  'tags-alphabetical',
+  'channels-kebab-case',
+  'no-channel-trailing-slash',
+] as const;
 
 export type BuiltInAsync2RuleId = typeof builtInAsync2Rules[number];
 
+const builtInArazzoRules = ['spec'] as const;
+
+export type BuiltInArazzoRuleId = typeof builtInArazzoRules[number];
+
 const builtInRules = [
-  ...builtInCommonRules,
   ...builtInCommonOASRules,
   ...builtInOAS2Rules,
   ...builtInOAS3Rules,
   ...builtInAsync2Rules,
+  ...builtInArazzoRules,
 ] as const;
 
 type BuiltInRuleId = typeof builtInRules[number];
@@ -238,16 +245,19 @@ const ConfigStyleguide: NodeType = {
     oas3_0Rules: 'Rules',
     oas3_1Rules: 'Rules',
     async2Rules: 'Rules',
+    arazzoRules: 'Rules',
     preprocessors: { type: 'object' },
     oas2Preprocessors: { type: 'object' },
     oas3_0Preprocessors: { type: 'object' },
     oas3_1Preprocessors: { type: 'object' },
     async2Preprocessors: { type: 'object' },
+    arazzoPreprocessors: { type: 'object' },
     decorators: { type: 'object' },
     oas2Decorators: { type: 'object' },
     oas3_0Decorators: { type: 'object' },
     oas3_1Decorators: { type: 'object' },
     async2Decorators: { type: 'object' },
+    arazzoDecorators: { type: 'object' },
   },
 };
 

package/src/typings/arazzo.ts

@@ -0,0 +1,44 @@
+import type { FromSchema } from 'json-schema-to-ts';
+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[];
+};