@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/rules/arazzo/sourceDescriptions-name-unique.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceDescriptionsNameUnique = void 0;
+const SourceDescriptionsNameUnique = () => {
+    const seenSourceDescriptions = new Set();
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions, { report, location }) {
+                if (!sourceDescriptions.length)
+                    return;
+                for (const sourceDescription of sourceDescriptions) {
+                    if (seenSourceDescriptions.has(sourceDescription.name)) {
+                        report({
+                            message: 'The `name` must be unique amongst all SourceDescriptions.',
+                            location: location.child([sourceDescriptions.indexOf(sourceDescription)]),
+                        });
+                    }
+                    seenSourceDescriptions.add(sourceDescription.name);
+                }
+            },
+        },
+    };
+};
+exports.SourceDescriptionsNameUnique = SourceDescriptionsNameUnique;

package/lib/rules/arazzo/sourceDescriptions-not-empty.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const SourceDescriptionsNotEmpty: Arazzo1Rule;

package/lib/rules/arazzo/sourceDescriptions-not-empty.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceDescriptionsNotEmpty = void 0;
+const SourceDescriptionsNotEmpty = () => {
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions, { report, location }) {
+                if (!sourceDescriptions?.length) {
+                    report({
+                        message: 'The `sourceDescriptions` list must have at least one entry.',
+                        location,
+                    });
+                }
+            },
+        },
+    };
+};
+exports.SourceDescriptionsNotEmpty = SourceDescriptionsNotEmpty;

package/lib/rules/arazzo/step-onFailure-unique.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const StepOnFailureUnique: Arazzo1Rule;

package/lib/rules/arazzo/step-onFailure-unique.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepOnFailureUnique = void 0;
+const StepOnFailureUnique = () => {
+    return {
+        OnFailureActionList: {
+            enter(onFailureActionList, { report, location }) {
+                if (!onFailureActionList)
+                    return;
+                const seenFailureActions = new Set();
+                for (const onFailureAction of onFailureActionList) {
+                    if (seenFailureActions.has(onFailureAction?.name)) {
+                        report({
+                            message: 'The action `name` must be unique amongst listed `onFailure` actions.',
+                            location: location.child([onFailureActionList.indexOf(onFailureAction)]),
+                        });
+                    }
+                    if (seenFailureActions.has(onFailureAction?.reference)) {
+                        report({
+                            message: 'The action `reference` must be unique amongst listed `onFailure` actions.',
+                            location: location.child([onFailureActionList.indexOf(onFailureAction)]),
+                        });
+                    }
+                    onFailureAction?.name
+                        ? seenFailureActions.add(onFailureAction.name)
+                        : seenFailureActions.add(onFailureAction.reference);
+                }
+            },
+        },
+    };
+};
+exports.StepOnFailureUnique = StepOnFailureUnique;

package/lib/rules/arazzo/step-onSuccess-unique.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const StepOnSuccessUnique: Arazzo1Rule;

package/lib/rules/arazzo/step-onSuccess-unique.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepOnSuccessUnique = void 0;
+const StepOnSuccessUnique = () => {
+    return {
+        OnSuccessActionList: {
+            enter(onSuccessActionList, { report, location }) {
+                if (!onSuccessActionList)
+                    return;
+                const seenSuccessActions = new Set();
+                for (const onSuccessAction of onSuccessActionList) {
+                    if (seenSuccessActions.has(onSuccessAction?.name)) {
+                        report({
+                            message: 'The action `name` must be unique amongst listed `onSuccess` actions.',
+                            location: location.child([onSuccessActionList.indexOf(onSuccessAction)]),
+                        });
+                    }
+                    if (seenSuccessActions.has(onSuccessAction?.reference)) {
+                        report({
+                            message: 'The action `reference` must be unique amongst listed `onSuccess` actions.',
+                            location: location.child([onSuccessActionList.indexOf(onSuccessAction)]),
+                        });
+                    }
+                    onSuccessAction?.name
+                        ? seenSuccessActions.add(onSuccessAction.name)
+                        : seenSuccessActions.add(onSuccessAction.reference);
+                }
+            },
+        },
+    };
+};
+exports.StepOnSuccessUnique = StepOnSuccessUnique;

package/lib/rules/arazzo/stepId-unique.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const StepIdUnique: Arazzo1Rule;

package/lib/rules/arazzo/stepId-unique.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StepIdUnique = void 0;
+const StepIdUnique = () => {
+    return {
+        Workflow: {
+            enter(workflow, { report, location }) {
+                if (!workflow.steps)
+                    return;
+                const seenSteps = new Set();
+                for (const step of workflow.steps) {
+                    if (!step.stepId)
+                        return;
+                    if (seenSteps.has(step.stepId)) {
+                        report({
+                            message: 'The `stepId` must be unique amongst all steps described in the workflow.',
+                            location: location.child(['steps', workflow.steps.indexOf(step)]),
+                        });
+                    }
+                    seenSteps.add(step.stepId);
+                }
+            },
+        },
+    };
+};
+exports.StepIdUnique = StepIdUnique;

package/lib/rules/arazzo/workflow-dependsOn.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const WorkflowDependsOn: Arazzo1Rule;

package/lib/rules/arazzo/workflow-dependsOn.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowDependsOn = void 0;
+const WorkflowDependsOn = () => {
+    const seenWorkflow = new Set();
+    const existingSourceDescriptions = new Set();
+    const existingWorkflowIds = new Set();
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions) {
+                for (const sourceDescription of sourceDescriptions) {
+                    existingSourceDescriptions.add(sourceDescription.name);
+                }
+            },
+        },
+        Workflows: {
+            enter(workflows) {
+                for (const workflow of workflows) {
+                    existingWorkflowIds.add(workflow.workflowId);
+                }
+            },
+        },
+        Workflow: {
+            leave(workflow, { report, location }) {
+                if (!workflow.dependsOn)
+                    return;
+                for (const item of workflow.dependsOn) {
+                    // Possible dependsOn workflow pattern: $sourceDescriptions.<name>.<workflowId>
+                    if (item.startsWith('$sourceDescriptions.')) {
+                        const sourceDescriptionName = item.split('.')[1];
+                        if (!existingSourceDescriptions.has(sourceDescriptionName)) {
+                            report({
+                                message: `SourceDescription ${sourceDescriptionName} must be defined in sourceDescriptions.`,
+                                location: location.child([`dependsOn`, workflow.dependsOn.indexOf(item)]),
+                            });
+                        }
+                    }
+                    if (!item.startsWith('$sourceDescriptions') && !existingWorkflowIds.has(item)) {
+                        report({
+                            message: `Workflow ${item} must be defined in workflows.`,
+                            location: location.child([`dependsOn`, workflow.dependsOn.indexOf(item)]),
+                        });
+                    }
+                    if (seenWorkflow.has(item)) {
+                        report({
+                            message: 'Every workflow in dependsOn must be unique.',
+                            location: location.child([`dependsOn`]),
+                        });
+                    }
+                    seenWorkflow.add(item);
+                }
+            },
+        },
+    };
+};
+exports.WorkflowDependsOn = WorkflowDependsOn;

package/lib/rules/arazzo/workflowId-unique.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const WorkflowIdUnique: Arazzo1Rule;

package/lib/rules/arazzo/workflowId-unique.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkflowIdUnique = void 0;
+const WorkflowIdUnique = () => {
+    const seenWorkflow = new Set();
+    return {
+        Workflow: {
+            enter(workflow, { report, location }) {
+                if (!workflow.workflowId)
+                    return;
+                if (seenWorkflow.has(workflow.workflowId)) {
+                    report({
+                        message: 'Every workflow must have a unique `workflowId`.',
+                        location: location.child([workflow.workflowId]),
+                    });
+                }
+                seenWorkflow.add(workflow.workflowId);
+            },
+        },
+    };
+};
+exports.WorkflowIdUnique = WorkflowIdUnique;

package/lib/rules/async2/channels-kebab-case.d.ts

@@ -0,0 +1,2 @@
+import type { Async2Rule } from '../../visitors';
+export declare const ChannelsKebabCase: Async2Rule;

package/lib/rules/async2/channels-kebab-case.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsKebabCase = void 0;
+const ChannelsKebabCase = () => {
+    return {
+        Channel(_channel, { report, key }) {
+            const segments = key
+                .split(/[/.:]/) // split on / or : as likely channel namespacers
+                .filter((s) => s !== ''); // filter out empty segments
+            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+                report({
+                    message: `\`${key}\` does not use kebab-case.`,
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.ChannelsKebabCase = ChannelsKebabCase;

package/lib/rules/async2/index.d.ts

@@ -0,0 +1,3 @@
+import type { Async2RuleSet } from '../../oas-types';
+export declare const rules: Async2RuleSet<'built-in'>;
+export declare const preprocessors: {};

package/lib/rules/async2/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessors = exports.rules = void 0;
+const assertions_1 = require("../common/assertions");
+const struct_1 = require("../common/struct");
+const info_contact_1 = require("../common/info-contact");
+const info_license_strict_1 = require("../common/info-license-strict");
+const operation_operationId_1 = require("../common/operation-operationId");
+const tag_description_1 = require("../common/tag-description");
+const tags_alphabetical_1 = require("../common/tags-alphabetical");
+const channels_kebab_case_1 = require("./channels-kebab-case");
+const no_channel_trailing_slash_1 = require("./no-channel-trailing-slash");
+exports.rules = {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    //@ts-ignore TODO: This is depricated property `spec` and should be removed in the future
+    spec: struct_1.Struct,
+    struct: struct_1.Struct,
+    assertions: assertions_1.Assertions,
+    'info-contact': info_contact_1.InfoContact,
+    'info-license-strict': info_license_strict_1.InfoLicenseStrict,
+    'operation-operationId': operation_operationId_1.OperationOperationId,
+    'channels-kebab-case': channels_kebab_case_1.ChannelsKebabCase,
+    'no-channel-trailing-slash': no_channel_trailing_slash_1.NoChannelTrailingSlash,
+    'tag-description': tag_description_1.TagDescription,
+    'tags-alphabetical': tags_alphabetical_1.TagsAlphabetical,
+};
+exports.preprocessors = {};

package/lib/rules/async2/no-channel-trailing-slash.d.ts

@@ -0,0 +1,2 @@
+import type { Async2Rule } from '../../visitors';
+export declare const NoChannelTrailingSlash: Async2Rule;

package/lib/rules/async2/no-channel-trailing-slash.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoChannelTrailingSlash = void 0;
+const NoChannelTrailingSlash = () => {
+    return {
+        Channel(_channel, { report, key, location }) {
+            if (key.endsWith('/') && key !== '/') {
+                report({
+                    message: `\`${key}\` should not have a trailing slash.`,
+                    location: location.key(),
+                });
+            }
+        },
+    };
+};
+exports.NoChannelTrailingSlash = NoChannelTrailingSlash;

package/lib/rules/async3/channels-kebab-case.d.ts

@@ -0,0 +1,2 @@
+import type { Async3Rule } from '../../visitors';
+export declare const ChannelsKebabCase: Async3Rule;

package/lib/rules/async3/channels-kebab-case.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChannelsKebabCase = void 0;
+const ChannelsKebabCase = () => {
+    return {
+        Channel(channel, { report }) {
+            const segments = (channel.address || '')
+                .split(/[/.:]/) // split on / or : as likely channel namespacers
+                .filter((s) => s !== ''); // filter out empty segments
+            if (!segments.every((segment) => /^{.+}$/.test(segment) || /^[a-z0-9-.]+$/.test(segment))) {
+                report({
+                    message: `\`${channel.address}\` does not use kebab-case.`,
+                    location: { reportOnKey: true },
+                });
+            }
+        },
+    };
+};
+exports.ChannelsKebabCase = ChannelsKebabCase;

package/lib/rules/async3/index.d.ts

@@ -0,0 +1,3 @@
+import type { Async3RuleSet } from '../../oas-types';
+export declare const rules: Async3RuleSet<'built-in'>;
+export declare const preprocessors: {};

package/lib/rules/async3/index.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessors = exports.rules = void 0;
+const assertions_1 = require("../common/assertions");
+const struct_1 = require("../common/struct");
+const info_contact_1 = require("../common/info-contact");
+const info_license_strict_1 = require("../common/info-license-strict");
+const operation_operationId_1 = require("../common/operation-operationId");
+const tag_description_1 = require("../common/tag-description");
+const tags_alphabetical_1 = require("../common/tags-alphabetical");
+const channels_kebab_case_1 = require("./channels-kebab-case");
+const no_channel_trailing_slash_1 = require("./no-channel-trailing-slash");
+exports.rules = {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    //@ts-ignore TODO: This is depricated property `spec` and should be removed in the future
+    spec: struct_1.Struct,
+    struct: struct_1.Struct,
+    assertions: assertions_1.Assertions,
+    'info-contact': info_contact_1.InfoContact,
+    'info-license-strict': info_license_strict_1.InfoLicenseStrict,
+    'operation-operationId': operation_operationId_1.OperationOperationId,
+    'channels-kebab-case': channels_kebab_case_1.ChannelsKebabCase,
+    'no-channel-trailing-slash': no_channel_trailing_slash_1.NoChannelTrailingSlash,
+    'tag-description': tag_description_1.TagDescription,
+    'tags-alphabetical': tags_alphabetical_1.TagsAlphabetical,
+};
+exports.preprocessors = {};

package/lib/rules/async3/no-channel-trailing-slash.d.ts

@@ -0,0 +1,2 @@
+import type { Async3Rule } from '../../visitors';
+export declare const NoChannelTrailingSlash: Async3Rule;

package/lib/rules/async3/no-channel-trailing-slash.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NoChannelTrailingSlash = void 0;
+const NoChannelTrailingSlash = () => {
+    return {
+        Channel(channel, { report, location }) {
+            if (channel.address.endsWith('/') && channel.address !== '/') {
+                report({
+                    message: `\`${channel.address}\` should not have a trailing slash.`,
+                    location: location.key(),
+                });
+            }
+        },
+    };
+};
+exports.NoChannelTrailingSlash = NoChannelTrailingSlash;

package/lib/rules/common/assertions/asserts.d.ts

@@ -0,0 +1,30 @@
+import type { AssertionContext, AssertResult, CustomFunction } from '../../../config/types';
+import type { Location } from '../../../ref-utils';
+export type AssertionFnContext = AssertionContext & {
+    baseLocation: Location;
+    rawValue?: any;
+};
+export type AssertionFn = (value: any, condition: any, ctx: AssertionFnContext) => AssertResult[];
+export type Asserts = {
+    pattern: AssertionFn;
+    notPattern: AssertionFn;
+    enum: AssertionFn;
+    defined: AssertionFn;
+    required: AssertionFn;
+    disallowed: AssertionFn;
+    undefined: AssertionFn;
+    nonEmpty: AssertionFn;
+    minLength: AssertionFn;
+    maxLength: AssertionFn;
+    casing: AssertionFn;
+    sortOrder: AssertionFn;
+    mutuallyExclusive: AssertionFn;
+    mutuallyRequired: AssertionFn;
+    requireAny: AssertionFn;
+    ref: AssertionFn;
+    const: AssertionFn;
+};
+export declare const runOnKeysSet: Set<keyof Asserts>;
+export declare const runOnValuesSet: Set<keyof Asserts>;
+export declare const asserts: Asserts;
+export declare function buildAssertCustomFunction(fn: CustomFunction): AssertionFn;