@kubb/agent 5.0.0-alpha.36 → 5.0.0-alpha.38

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

@@ -1,171 +0,0 @@
-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

@@ -1,123 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,35 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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 (typeof mapping === 'string' &&
-        (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