@kubb/agent 4.33.1 → 4.33.2

package/.output/server/node_modules/@redocly/openapi-core/lib/lint-entity.js

@@ -0,0 +1,171 @@
+import * as redoclyConfig from '@redocly/config';
+import { createConfig } from './config/index.js';
+import { lintDocument } from './lint.js';
+import { BaseResolver, resolveDocument, makeDocumentFromString } from './resolve.js';
+import { EntityKeyValid } from './rules/catalog-entity/entity-key-valid.js';
+import { Assertions } from './rules/common/assertions/index.js';
+import { NoUnresolvedRefs } from './rules/common/no-unresolved-refs.js';
+import { Struct } from './rules/common/struct.js';
+import { createEntityTypes, ENTITY_DISCRIMINATOR_PROPERTY_NAME, ENTITY_TYPES_WITH_API_SUPPORT, } from './types/entity.js';
+import { normalizeTypes } from './types/index.js';
+import { isEmptyObject } from './utils/is-empty-object.js';
+import { isPlainObject } from './utils/is-plain-object.js';
+import { categorizeAssertions, findDataSchemaInDocument, transformScorecardRulesToAssertions, } from './utils/scorecards.js';
+import { normalizeVisitors, } from './visitors.js';
+import { walkDocument, } from './walk.js';
+export async function lintEntityFile(opts) {
+    const { document, entitySchema, entityDefaultSchema, severity, externalRefResolver = new BaseResolver(), assertionConfig = {}, } = opts;
+    const ctx = {
+        problems: [],
+        specVersion: 'entity', // FIXME: this should be proper SpecVersion
+        visitorsData: {},
+    };
+    const { entityTypes, discriminatorResolver } = createEntityTypes(entitySchema, entityDefaultSchema);
+    const types = normalizeTypes(entityTypes);
+    let rootType = types.Entity;
+    if (Array.isArray(document.parsed)) {
+        rootType = types.EntityFileArray;
+    }
+    else if (isPlainObject(document.parsed)) {
+        const discriminatedPropertyValue = document.parsed[ENTITY_DISCRIMINATOR_PROPERTY_NAME];
+        if (!discriminatedPropertyValue) {
+            rootType = types.Entity;
+        }
+        else {
+            const discriminatedTypeName = discriminatorResolver?.(document.parsed, discriminatedPropertyValue);
+            if (discriminatedTypeName &&
+                typeof discriminatedTypeName === 'string' &&
+                types[discriminatedTypeName]) {
+                rootType = types[discriminatedTypeName];
+            }
+        }
+    }
+    const assertionVisitors = Assertions(assertionConfig);
+    const flattenedAssertions = Array.isArray(assertionVisitors)
+        ? assertionVisitors.map((visitor) => ({
+            severity: severity || 'error',
+            ruleId: 'entity assertions',
+            visitor: visitor,
+        }))
+        : [
+            {
+                severity: severity || 'error',
+                ruleId: 'entity assertions',
+                visitor: assertionVisitors,
+            },
+        ];
+    const rules = [
+        {
+            severity: severity || 'error',
+            ruleId: 'entity struct',
+            visitor: Struct({ severity: 'error' }),
+        },
+        {
+            severity: severity || 'error',
+            ruleId: 'entity no-unresolved-refs',
+            visitor: NoUnresolvedRefs({ severity: 'error' }),
+        },
+        {
+            severity: severity || 'error',
+            ruleId: 'entity key-valid',
+            visitor: EntityKeyValid({ severity: 'error' }),
+        },
+        ...flattenedAssertions,
+    ];
+    const normalizedVisitors = normalizeVisitors(rules, types);
+    const resolvedRefMap = await resolveDocument({
+        rootDocument: document,
+        rootType,
+        externalRefResolver,
+    });
+    walkDocument({
+        document,
+        rootType,
+        normalizedVisitors,
+        resolvedRefMap,
+        ctx,
+    });
+    return ctx.problems;
+}
+export async function lintEntityWithScorecardLevel(entity, scorecardLevel, document) {
+    if (!scorecardLevel.rules) {
+        throw new Error(`Scorecard level "${scorecardLevel.name}" has no rules defined.`);
+    }
+    const externalRefResolver = new BaseResolver();
+    //Create a document from the entity object
+    const entityDocument = makeDocumentFromString(JSON.stringify(entity, null, 2), 'entity');
+    const discriminatorValue = entityDocument.parsed[ENTITY_DISCRIMINATOR_PROPERTY_NAME];
+    const assertionConfig = transformScorecardRulesToAssertions(discriminatorValue || 'unknown', scorecardLevel.rules);
+    const { entityRules, apiRules } = categorizeAssertions(assertionConfig);
+    const entityProblems = await lintEntityFile({
+        document: entityDocument,
+        entitySchema: redoclyConfig.entityFileSchema,
+        entityDefaultSchema: redoclyConfig.entityFileDefaultSchema,
+        externalRefResolver,
+        assertionConfig: entityRules,
+    });
+    if (ENTITY_TYPES_WITH_API_SUPPORT.includes(entity.type)) {
+        if (Object.keys(apiRules).length === 0) {
+            return entityProblems;
+        }
+        if (!document) {
+            throw new Error(`Document is required for entity type "${entity.type}". Provide the source API document to lint API rules.`);
+        }
+        if (entity.type === 'data-schema' && entity.metadata?.schema) {
+            Object.values(apiRules).forEach((rule) => {
+                if (typeof rule === 'object' && rule.subject.type !== 'Schema') {
+                    throw new Error(`API rules for "data-schema" entity must target Schema subject, but found "${rule.subject.type}".`);
+                }
+            });
+            const schema = findDataSchemaInDocument(entity.title, entity.metadata.schema, document);
+            if (!schema) {
+                throw new Error(`Schema "${entity.title}" not found in the document. Ensure the schema exists in components.schemas.`);
+            }
+            const schemaProblems = await lintSchema({
+                schema,
+                schemaKey: entity.title,
+                config: await createConfig({
+                    rules: apiRules,
+                }),
+                specType: entity.metadata.specType,
+                sourceDocument: document,
+                externalRefResolver,
+            });
+            return [...entityProblems, ...schemaProblems];
+        }
+        const apiProblems = await lintDocument({
+            document,
+            externalRefResolver,
+            config: await createConfig({
+                rules: apiRules,
+            }),
+        });
+        return [...entityProblems, ...apiProblems];
+    }
+    else if (!isEmptyObject(apiRules)) {
+        throw new Error(`API rules are not supported for entity type "${entity.type}". Only ${ENTITY_TYPES_WITH_API_SUPPORT.join(', ')} support API rules.`);
+    }
+    return entityProblems;
+}
+export async function lintSchema(opts) {
+    const { schema, schemaKey, config, sourceDocument, specType, externalRefResolver = new BaseResolver(config.resolve), } = opts;
+    const parsed = sourceDocument.parsed;
+    const specVersion = parsed[specType];
+    const info = parsed.info;
+    const schemaDocument = makeDocumentFromString(JSON.stringify({
+        [specType]: specVersion,
+        info,
+        components: {
+            schemas: {
+                [schemaKey]: schema,
+            },
+        },
+    }, null, 2), sourceDocument?.source.absoluteRef || `schema:${schemaKey}`);
+    const problems = await lintDocument({
+        document: schemaDocument,
+        config,
+        externalRefResolver,
+    });
+    return problems.filter((problem) => problem.location.some((loc) => loc.pointer?.includes(`/components/schemas/${schemaKey}`)));
+}
+//# sourceMappingURL=lint-entity.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/lint.js

@@ -0,0 +1,123 @@
+import { rootRedoclyConfigSchema } from '@redocly/config';
+import { initRules } from './config/rules.js';
+import { detectSpec, getMajorSpecVersion } from './detect-spec.js';
+import { getTypes } from './oas-types.js';
+import { BaseResolver, resolveDocument, makeDocumentFromString } from './resolve.js';
+import { releaseAjvInstance } from './rules/ajv.js';
+import { NoUnresolvedRefs } from './rules/common/no-unresolved-refs.js';
+import { Struct } from './rules/common/struct.js';
+import { normalizeTypes } from './types/index.js';
+import { createConfigTypes } from './types/redocly-yaml.js';
+import { normalizeVisitors } from './visitors.js';
+import { walkDocument } from './walk.js';
+// FIXME: remove this once we remove `theme` from the schema
+const { theme: _, ...propertiesWithoutTheme } = rootRedoclyConfigSchema.properties;
+const redoclyConfigSchemaWithoutTheme = {
+    ...rootRedoclyConfigSchema,
+    properties: propertiesWithoutTheme,
+};
+export async function lint(opts) {
+    const { ref, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
+    const document = (await externalRefResolver.resolveDocument(null, ref, true));
+    opts.collectSpecData?.(document.parsed);
+    return lintDocument({
+        document,
+        ...opts,
+        externalRefResolver,
+    });
+}
+export async function lintFromString(opts) {
+    const { source, absoluteRef, externalRefResolver = new BaseResolver(opts.config.resolve) } = opts;
+    const document = makeDocumentFromString(source, absoluteRef || '/');
+    return lintDocument({
+        document,
+        ...opts,
+        externalRefResolver,
+    });
+}
+export async function lintDocument(opts) {
+    releaseAjvInstance(); // FIXME: preprocessors can modify nodes which are then cached to ajv-instance by absolute path
+    const { document, customTypes, externalRefResolver, config } = opts;
+    const specVersion = detectSpec(document.parsed);
+    const specMajorVersion = getMajorSpecVersion(specVersion);
+    const rules = config.getRulesForSpecVersion(specMajorVersion);
+    const types = normalizeTypes(config.extendTypes(customTypes ?? getTypes(specVersion), specVersion), config);
+    const ctx = {
+        problems: [],
+        specVersion,
+        config,
+        visitorsData: {},
+    };
+    const preprocessors = initRules(rules, config, 'preprocessors', specVersion);
+    const regularRules = initRules(rules, config, 'rules', specVersion);
+    let resolvedRefMap = await resolveDocument({
+        rootDocument: document,
+        rootType: types.Root,
+        externalRefResolver,
+    });
+    if (preprocessors.length > 0) {
+        // Make additional pass to resolve refs defined in preprocessors.
+        walkDocument({
+            document,
+            rootType: types.Root,
+            normalizedVisitors: normalizeVisitors(preprocessors, types),
+            resolvedRefMap,
+            ctx,
+        });
+        resolvedRefMap = await resolveDocument({
+            rootDocument: document,
+            rootType: types.Root,
+            externalRefResolver,
+        });
+    }
+    const normalizedVisitors = normalizeVisitors(regularRules, types);
+    walkDocument({
+        document,
+        rootType: types.Root,
+        normalizedVisitors,
+        resolvedRefMap,
+        ctx,
+    });
+    return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
+}
+export async function lintConfig(opts) {
+    const { severity, externalRefResolver = new BaseResolver(), config } = opts;
+    if (!config.document) {
+        throw new Error('Config document is not set.');
+    }
+    const ctx = {
+        problems: [],
+        specVersion: 'oas3_0', // TODO: use config-specific version
+        config,
+        visitorsData: {},
+    };
+    const types = normalizeTypes(opts.externalConfigTypes || createConfigTypes(redoclyConfigSchemaWithoutTheme, config));
+    const rules = [
+        {
+            severity: severity || 'error',
+            ruleId: 'configuration struct',
+            visitor: Struct({ severity: 'error' }),
+        },
+        {
+            severity: severity || 'error',
+            ruleId: 'configuration no-unresolved-refs',
+            visitor: NoUnresolvedRefs({ severity: 'error' }),
+        },
+    ];
+    const normalizedVisitors = normalizeVisitors(rules, types);
+    const resolvedRefMap = config.resolvedRefMap ||
+        (await resolveDocument({
+            rootDocument: config.document,
+            rootType: types.ConfigRoot,
+            externalRefResolver,
+        }));
+    walkDocument({
+        document: config.document,
+        rootType: types.ConfigRoot,
+        normalizedVisitors,
+        resolvedRefMap,
+        ctx,
+    });
+    return ctx.problems;
+}
+//# sourceMappingURL=lint.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/logger.js

@@ -0,0 +1,56 @@
+import * as colorette from 'colorette';
+import { isBrowser } from './env.js';
+import { identity } from './utils/identity.js';
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore this works but some types are not working
+export const colorOptions = colorette.options;
+export const colorize = new Proxy(colorette, {
+    get(target, prop) {
+        if (isBrowser) {
+            return identity;
+        }
+        return target[prop];
+    },
+});
+class Logger {
+    info(str) {
+        return isBrowser ? console.info(str) : process.stderr.write(str);
+    }
+    warn(str) {
+        return isBrowser ? console.warn(str) : process.stderr.write(colorize.yellow(str));
+    }
+    error(str) {
+        return isBrowser ? console.error(str) : process.stderr.write(colorize.red(str));
+    }
+    output(str) {
+        return isBrowser ? console.log(str) : process.stdout.write(str);
+    }
+    printNewLine() {
+        if (isBrowser) {
+            console.log('\n');
+        }
+        else {
+            // Add a space to ensure the line is not empty in GitHub CI environments, otherwise it will be hidden
+            process.stdout.write(' \n');
+        }
+    }
+    printSeparator(separator) {
+        const windowWidth = process.stdout.columns || 80;
+        const separatorLine = separator
+            .repeat(Math.ceil(windowWidth / separator.length))
+            .slice(0, windowWidth);
+        const coloredSeparatorLine = isBrowser ? separatorLine : colorize.gray(separatorLine);
+        return isBrowser
+            ? console.log(coloredSeparatorLine)
+            : process.stdout.write(coloredSeparatorLine);
+    }
+    indent(str, level) {
+        const indentChar = isBrowser ? '  ' : '\xa0';
+        return str
+            .split('\n')
+            .map((line) => indentChar.repeat(level) + line)
+            .join('\n');
+    }
+}
+export const logger = new Logger();
+//# sourceMappingURL=logger.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/oas-types.js

@@ -0,0 +1,35 @@
+import { Arazzo1Types } from './types/arazzo.js';
+import { AsyncApi2Types } from './types/asyncapi2.js';
+import { AsyncApi3Types } from './types/asyncapi3.js';
+import { Oas2Types } from './types/oas2.js';
+import { Oas3Types } from './types/oas3.js';
+import { Oas3_1Types } from './types/oas3_1.js';
+import { Oas3_2Types } from './types/oas3_2.js';
+import { OpenRpcTypes } from './types/openrpc.js';
+import { Overlay1Types } from './types/overlay.js';
+export const specVersions = [
+    'oas2',
+    'oas3_0',
+    'oas3_1',
+    'oas3_2',
+    'async2',
+    'async3',
+    'arazzo1',
+    'overlay1',
+    'openrpc1',
+];
+const typesMap = {
+    oas2: Oas2Types,
+    oas3_0: Oas3Types,
+    oas3_1: Oas3_1Types,
+    oas3_2: Oas3_2Types,
+    async2: AsyncApi2Types,
+    async3: AsyncApi3Types,
+    arazzo1: Arazzo1Types,
+    overlay1: Overlay1Types,
+    openrpc1: OpenRpcTypes,
+};
+export function getTypes(spec) {
+    return typesMap[spec];
+}
+//# sourceMappingURL=oas-types.js.map

package/.output/server/node_modules/@redocly/openapi-core/lib/ref-utils.js

@@ -0,0 +1,109 @@
+import * as path from 'node:path';
+import { isPlainObject } from './utils/is-plain-object.js';
+import { isTruthy } from './utils/is-truthy.js';
+export function joinPointer(base, key) {
+    if (base === '')
+        base = '#/';
+    return base[base.length - 1] === '/' ? base + key : base + '/' + key;
+}
+export function isRef(node) {
+    return isPlainObject(node) && typeof node.$ref === 'string';
+}
+export function isExternalValue(node) {
+    return isPlainObject(node) && typeof node.externalValue === 'string';
+}
+export class Location {
+    constructor(source, pointer) {
+        this.source = source;
+        this.pointer = pointer;
+    }
+    child(components) {
+        return new Location(this.source, joinPointer(this.pointer, (Array.isArray(components) ? components : [components]).map(escapePointerFragment).join('/')));
+    }
+    key() {
+        return { ...this, reportOnKey: true };
+    }
+    get absolutePointer() {
+        return this.source.absoluteRef + (this.pointer === '#/' ? '' : this.pointer);
+    }
+}
+export function unescapePointerFragment(fragment) {
+    const unescaped = fragment.indexOf('~') === -1 ? fragment : fragment.replaceAll('~1', '/').replaceAll('~0', '~');
+    try {
+        return decodeURIComponent(unescaped);
+    }
+    catch (e) {
+        return unescaped;
+    }
+}
+export function escapePointerFragment(fragment) {
+    if (typeof fragment === 'number')
+        return fragment;
+    if (fragment.indexOf('/') === -1 && fragment.indexOf('~') === -1)
+        return fragment;
+    return fragment.replaceAll('~', '~0').replaceAll('/', '~1');
+}
+export function parseRef(ref) {
+    const [uri, pointer = ''] = ref.split('#/');
+    return {
+        uri: (uri.endsWith('#') ? uri.slice(0, -1) : uri) || null,
+        pointer: parsePointer(pointer),
+    };
+}
+export function parsePointer(pointer) {
+    return pointer.split('/').map(unescapePointerFragment).filter(isTruthy);
+}
+export function pointerBaseName(pointer) {
+    const parts = pointer.split('/');
+    return parts[parts.length - 1];
+}
+export function refBaseName(ref) {
+    // eslint-disable-next-line no-useless-escape
+    const parts = ref.split(/[\/\\]/); // split by '\' and '/'
+    return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
+}
+export function isAbsoluteUrl(ref) {
+    return (ref.startsWith('http://') ||
+        ref.startsWith('https://') ||
+        ref.startsWith('file://') ||
+        ref.startsWith('data:'));
+}
+export function getDir(filePath) {
+    if (!path.extname(filePath)) {
+        return filePath;
+    }
+    return isAbsoluteUrl(filePath)
+        ? filePath.substring(0, filePath.lastIndexOf('/'))
+        : path.dirname(filePath);
+}
+export function resolvePath(base, relative) {
+    if (isAbsoluteUrl(base)) {
+        return new URL(relative, base.endsWith('/') ? base : `${base}/`).href;
+    }
+    return path.resolve(base, relative);
+}
+export function isMappingRef(mapping) {
+    // TODO: proper detection of mapping refs
+    return (mapping.startsWith('#') ||
+        mapping.startsWith('https://') ||
+        mapping.startsWith('http://') ||
+        mapping.startsWith('./') ||
+        mapping.startsWith('../') ||
+        mapping.indexOf('/') > -1);
+}
+export function isAnchor(ref) {
+    return /^#[A-Za-z][A-Za-z0-9\-_:.]*$/.test(ref);
+}
+export function replaceRef(ref, resolved, ctx) {
+    if (!isPlainObject(resolved.node)) {
+        ctx.parent[ctx.key] = resolved.node;
+    }
+    else {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        delete ref.$ref;
+        const obj = Object.assign({}, resolved.node, ref);
+        Object.assign(ref, obj); // assign ref itself again so ref fields take precedence
+    }
+}
+//# sourceMappingURL=ref-utils.js.map