@redocly/openapi-core 1.18.1 → 1.20.0

package/lib/types/arazzo.js

@@ -1,219 +1,263 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ArazzoTypes = exports.arazzoSchema = exports.workflow = exports.step = exports.inherit = exports.criteriaObject = exports.requestBody = exports.replacement = exports.infoObject = exports.parameter = exports.sourceDescriptionSchema = exports.expectSchema = exports.operationMethod = exports.ARAZZO_ROOT_TYPE = void 0;
-const json_schema_adapter_1 = require("./json-schema-adapter");
-exports.ARAZZO_ROOT_TYPE = 'Root';
-exports.operationMethod = {
-    type: 'string',
-    enum: ['get', 'post', 'put', 'delete', 'patch'],
+exports.ArazzoTypes = void 0;
+const _1 = require(".");
+const oas3_1_1 = require("./oas3_1");
+const oas3_1 = require("./oas3");
+const Root = {
+    properties: {
+        arazzo: { type: 'string', enum: ['1.0.0'] },
+        info: 'Info',
+        sourceDescriptions: 'SourceDescriptions',
+        'x-parameters': 'Parameters',
+        workflows: 'Workflows',
+        components: 'Components',
+    },
+    required: ['arazzo', 'info', 'sourceDescriptions', 'workflows'],
+    extensionsPrefix: 'x-',
 };
-exports.expectSchema = {
-    type: 'object',
+const NamedParameters = {
+    properties: {},
+    additionalProperties: 'Parameter',
+};
+const NamedSuccessActions = {
+    properties: {},
+    additionalProperties: 'SuccessActionObject',
+};
+const NamedFailureActions = {
+    properties: {},
+    additionalProperties: 'FailureActionObject',
+};
+const Components = {
     properties: {
-        statusCode: { type: 'number' },
-        mimeType: { type: 'string' },
-        body: {},
-        schema: {
-            type: 'object',
-            additionalProperties: true,
-        },
+        inputs: 'NamedInputs',
+        parameters: 'NamedParameters',
+        successActions: 'NamedSuccessActions',
+        failureActions: 'NamedFailureActions',
     },
-    additionalProperties: false,
-    oneOf: [
-        { required: ['statusCode'] },
-        { required: ['mimeType'] },
-        { required: ['body'] },
-        { required: ['schema'] },
-    ],
+    extensionsPrefix: 'x-',
 };
-const openAPISourceDescriptionSchema = {
-    type: 'object',
+const NamedInputs = (0, _1.mapOf)('Schema');
+const Info = {
+    properties: {
+        title: { type: 'string' },
+        description: { type: 'string' },
+        summary: { type: 'string' },
+        version: { type: 'string' },
+    },
+    required: ['title', 'version'],
+    extensionsPrefix: 'x-',
+};
+const SourceDescriptions = {
+    properties: {},
+    items: (value) => {
+        if (value?.type === 'openapi') {
+            return 'OpenAPISourceDescription';
+        }
+        else if (value?.type === 'arazzo') {
+            return 'ArazzoSourceDescription';
+        }
+        else {
+            return 'NoneSourceDescription';
+        }
+    },
+};
+const OpenAPISourceDescription = {
     properties: {
         name: { type: 'string' },
         type: { type: 'string', enum: ['openapi'] },
         url: { type: 'string' },
         'x-serverUrl': { type: 'string' },
     },
-    additionalProperties: false,
     required: ['name', 'type', 'url'],
+    extensionsPrefix: 'x-',
 };
-const noneSourceDescriptionSchema = {
-    type: 'object',
+const NoneSourceDescription = {
     properties: {
         name: { type: 'string' },
         type: { type: 'string', enum: ['none'] },
         'x-serverUrl': { type: 'string' },
     },
-    additionalProperties: false,
     required: ['name', 'type', 'x-serverUrl'],
+    extensionsPrefix: 'x-',
 };
-const arazzoSourceDescriptionSchema = {
-    type: 'object',
+const ArazzoSourceDescription = {
     properties: {
         name: { type: 'string' },
         type: { type: 'string', enum: ['arazzo'] },
         url: { type: 'string' },
     },
-    additionalProperties: false,
     required: ['name', 'type', 'url'],
+    extensionsPrefix: 'x-',
 };
-exports.sourceDescriptionSchema = {
-    type: 'object',
-    oneOf: [
-        openAPISourceDescriptionSchema,
-        noneSourceDescriptionSchema,
-        arazzoSourceDescriptionSchema,
-    ],
-};
-const sourceDescriptionsSchema = {
-    type: 'array',
-    items: exports.sourceDescriptionSchema,
+const ReusableObject = {
+    properties: {
+        reference: { type: 'string' },
+        value: {
+            type: 'string',
+        },
+    },
+    required: ['reference'],
+    extensionsPrefix: 'x-',
 };
-const extendedOperation = {
-    type: 'object',
+const Parameter = {
     properties: {
-        path: { type: 'string' },
-        method: exports.operationMethod,
-        sourceDescriptionName: { type: 'string' },
-        serverUrl: { type: 'string' },
+        in: { type: 'string', enum: ['header', 'query', 'path', 'cookie', 'body'] },
+        name: { type: 'string' },
+        value: {}, // any
     },
-    additionalProperties: false,
-    required: ['path', 'method'],
+    required: ['name', 'value'],
+    extensionsPrefix: 'x-',
 };
-exports.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,
-        },
-    ],
+const Parameters = {
+    properties: {},
+    items: (value) => {
+        if (value?.in) {
+            return 'Parameter';
+        }
+        else {
+            return 'ReusableObject';
+        }
+    },
 };
-const parameters = {
-    type: 'array',
-    items: exports.parameter,
+const Workflow = {
+    properties: {
+        workflowId: { type: 'string' },
+        summary: { type: 'string' },
+        description: { type: 'string' },
+        parameters: 'Parameters',
+        dependsOn: { type: 'array', items: { type: 'string' } },
+        inputs: 'NamedInputs',
+        outputs: 'Outputs',
+        steps: 'Steps',
+        successActions: 'OnSuccessActionList',
+        failureActions: 'OnFailureActionList',
+    },
+    required: ['workflowId', 'steps'],
+    extensionsPrefix: 'x-',
 };
-exports.infoObject = {
-    type: 'object',
+const Workflows = (0, _1.listOf)('Workflow');
+const Steps = (0, _1.listOf)('Step');
+const Step = {
     properties: {
-        title: { type: 'string' },
+        stepId: { type: 'string' },
         description: { type: 'string' },
-        summary: { type: 'string' },
-        version: { type: 'string' },
+        operationId: { type: 'string' },
+        operationPath: { type: 'string' },
+        workflowId: { type: 'string' },
+        parameters: 'Parameters',
+        successCriteria: (0, _1.listOf)('CriterionObject'),
+        onSuccess: 'OnSuccessActionList',
+        onFailure: 'OnFailureActionList',
+        outputs: 'Outputs',
+        'x-inherit': { enum: ['auto', 'none'] },
+        'x-expect': 'ExpectSchema',
+        'x-assert': { type: 'string' },
+        'x-operation': 'ExtendedOperation',
+        requestBody: 'RequestBody',
+    },
+    required: ['stepId'],
+    requiredOneOf: ['x-operation', 'operationId', 'operationPath', 'workflowId'],
+    extensionsPrefix: 'x-',
+};
+const Outputs = {
+    properties: {},
+    additionalProperties: {
+        type: 'string',
     },
-    additionalProperties: false,
-    required: ['title', 'version'],
 };
-exports.replacement = {
-    type: 'object',
+const RequestBody = {
+    properties: {
+        contentType: { type: 'string' },
+        payload: {},
+        replacements: (0, _1.listOf)('Replacement'),
+    },
+    required: ['payload'],
+    extensionsPrefix: 'x-',
+};
+const Replacement = {
     properties: {
         target: { type: 'string' },
-        value: {
-            oneOf: [
-                { type: 'string' },
-                { type: 'object' },
-                { type: 'array' },
-                { type: 'number' },
-                { type: 'boolean' },
-            ],
-        },
+        value: {},
     },
+    required: ['target', 'value'],
+    extensionsPrefix: 'x-',
 };
-exports.requestBody = {
-    type: 'object',
+const ExtendedOperation = {
     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: exports.replacement,
+        path: { type: 'string' },
+        method: {
+            enum: ['get', 'post', 'put', 'delete', 'patch'],
         },
+        sourceDescriptionName: { type: 'string' },
+        serverUrl: { type: 'string' },
     },
-    additionalProperties: false,
-    required: ['payload'],
+    required: ['path', 'method'],
 };
-exports.criteriaObject = {
-    type: 'object',
+const ExpectSchema = {
+    properties: {
+        statusCode: { type: 'number' },
+        mimeType: { type: 'string' },
+        body: {},
+        schema: 'Schema',
+    },
+    requiredOneOf: ['statusCode', 'mimeType', 'body', 'schema'],
+};
+const CriterionObject = {
     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'] },
-                    },
-                },
-            ],
+        type: (value) => {
+            if (!value) {
+                return undefined;
+            }
+            else if (typeof value === 'string') {
+                return { enum: ['regex', 'jsonpath', 'simple', 'xpath'] };
+            }
+            else if (value.type === 'jsonpath') {
+                return 'JSONPathCriterion';
+            }
+            else {
+                return 'XPathCriterion';
+            }
         },
     },
     required: ['condition'],
-    additionalProperties: false,
 };
-const criteriaObjects = {
-    type: 'array',
-    items: exports.criteriaObject,
+const JSONPathCriterion = {
+    properties: {
+        type: { type: 'string', enum: ['jsonpath'] },
+        version: { type: 'string', enum: ['draft-goessner-dispatch-jsonpath-00'] },
+    },
 };
-exports.inherit = {
-    type: 'string',
-    enum: ['auto', 'none'],
+const XPathCriterion = {
+    properties: {
+        type: { type: 'string', enum: ['xpath'] },
+        version: { type: 'string', enum: ['xpath-30', 'xpath-20', 'xpath-10'] },
+    },
 };
-const onSuccessObject = {
-    type: 'object',
+const SuccessActionObject = {
     properties: {
         name: { type: 'string' },
         type: { type: 'string', enum: ['goto', 'end'] },
         stepId: { type: 'string' },
         workflowId: { type: 'string' },
-        criteria: criteriaObjects,
+        criteria: 'CriterionObject',
     },
-    additionalProperties: false,
     required: ['type', 'name'],
 };
-const onSuccessList = {
-    type: 'array',
-    items: onSuccessObject,
+const OnSuccessActionList = {
+    properties: {},
+    items: (value) => {
+        if (value?.type && value?.name) {
+            return 'SuccessActionObject';
+        }
+        else {
+            return 'ReusableObject';
+        }
+    },
 };
-const onFailureObject = {
-    type: 'object',
+const FailureActionObject = {
     properties: {
         name: { type: 'string' },
         type: { type: 'string', enum: ['goto', 'retry', 'end'] },
@@ -221,166 +265,59 @@ const onFailureObject = {
         stepId: { type: 'string' },
         retryAfter: { type: 'number' },
         retryLimit: { type: 'number' },
-        criteria: criteriaObjects,
+        criteria: 'CriterionObject',
     },
-    additionalProperties: false,
     required: ['type', 'name'],
 };
-const onFailureList = {
-    type: 'array',
-    items: onFailureObject,
-};
-exports.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': exports.inherit,
-        'x-expect': exports.expectSchema,
-        'x-assert': { type: 'string' },
-        'x-operation': extendedOperation,
-        requestBody: exports.requestBody,
-    },
-    required: ['stepId'],
-    oneOf: [
-        { required: ['x-operation'] },
-        { required: ['operationId'] },
-        { required: ['operationPath'] },
-        { required: ['workflowId'] },
-    ],
-};
-const steps = {
-    type: 'array',
-    items: exports.step,
-};
-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,
-};
-exports.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,
-        },
+const OnFailureActionList = {
+    properties: {},
+    items: (value) => {
+        if (value?.type && value?.name) {
+            return 'FailureActionObject';
+        }
+        else {
+            return 'ReusableObject';
+        }
     },
-    additionalProperties: false,
-    required: ['workflowId', 'steps'],
-};
-const workflows = {
-    type: 'array',
-    items: exports.workflow,
 };
-exports.arazzoSchema = {
-    type: 'object',
-    properties: {
-        arazzo: { type: 'string', enum: ['1.0.0'] },
-        info: exports.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: exports.parameter,
-                },
-                successActions: {
-                    type: 'object',
-                    additionalProperties: onSuccessObject,
-                },
-                failureActions: {
-                    type: 'object',
-                    additionalProperties: onFailureObject,
-                },
-            },
-        },
-    },
-    additionalProperties: false,
-    required: ['arazzo', 'info', 'sourceDescriptions', 'workflows'],
+exports.ArazzoTypes = {
+    Root,
+    Info,
+    SourceDescriptions,
+    OpenAPISourceDescription,
+    NoneSourceDescription,
+    ArazzoSourceDescription,
+    Parameters,
+    Parameter,
+    ReusableObject,
+    Workflows,
+    Workflow,
+    Steps,
+    Step,
+    RequestBody,
+    Replacement,
+    ExtendedOperation,
+    ExpectSchema,
+    Outputs,
+    CriterionObject,
+    XPathCriterion,
+    JSONPathCriterion,
+    SuccessActionObject,
+    OnSuccessActionList,
+    FailureActionObject,
+    OnFailureActionList,
+    Schema: oas3_1_1.Schema,
+    NamedSchemas: (0, _1.mapOf)('Schema'),
+    ExternalDocs: oas3_1.ExternalDocs,
+    DiscriminatorMapping: oas3_1.DiscriminatorMapping,
+    Discriminator: oas3_1.Discriminator,
+    DependentRequired: oas3_1_1.DependentRequired,
+    SchemaProperties: oas3_1_1.SchemaProperties,
+    PatternProperties: oas3_1_1.SchemaProperties,
+    Components,
+    NamedInputs,
+    NamedParameters,
+    NamedSuccessActions,
+    NamedFailureActions,
+    Xml: oas3_1.Xml,
 };
-exports.ArazzoTypes = (0, json_schema_adapter_1.getNodeTypesFromJSONSchema)(exports.ARAZZO_ROOT_TYPE, exports.arazzoSchema);

package/lib/types/asyncapi2.d.ts

@@ -0,0 +1,17 @@
+import type { NodeType } from '.';
+export declare const Tag: NodeType;
+export declare const ExternalDocs: NodeType;
+export declare const ServerMap: NodeType;
+export declare const ServerVariable: NodeType;
+export declare const Contact: NodeType;
+export declare const License: NodeType;
+export declare const CorrelationId: NodeType;
+export declare const MessageExample: NodeType;
+export declare const Schema: NodeType;
+export declare const SchemaProperties: NodeType;
+export declare const DiscriminatorMapping: NodeType;
+export declare const Discriminator: NodeType;
+export declare const SecuritySchemeFlows: NodeType;
+export declare const Dependencies: NodeType;
+export declare const AsyncApi2Bindings: Record<string, NodeType>;
+export declare const AsyncApi2Types: Record<string, NodeType>;