@skmtc/core 0.29.0 → 0.31.0

package/script/parse/v3-2/pathItem/toPathItemV3.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPathItemResultV3 = exports.toPathItemV3 = void 0;
+const toParameterV3_js_1 = require("../parameter/toParameterV3.js");
+const PathItem_js_1 = require("../../../oas/pathItem/PathItem.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const isEmpty_js_1 = require("../../../helpers/isEmpty.js");
+const toPathItemV3 = ({ pathItem, stackTrail, context }) => {
+    const { summary, description, parameters, ...skipped } = pathItem;
+    return new PathItem_js_1.OasPathItem({
+        summary,
+        description,
+        parameters: stackTrail.trace('parameters', st => (0, toParameterV3_js_1.toParameterListV3)({ parameters, stackTrail: st, context })),
+        extensionFields: (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+            skipped,
+            parent: pathItem,
+            context,
+            stackTrail,
+            parentType: 'pathItem'
+        })
+    });
+};
+exports.toPathItemV3 = toPathItemV3;
+/**
+ * Parses a path item's shared fields without letting a throw escape. A
+ * path-level parameter that fails validation (for example `in: body`) logs
+ * one `INVALID_OPERATION` at the path and returns `{ valid: false }`, so
+ * the caller skips that path and keeps the rest.
+ */
+const toPathItemResultV3 = ({ pathItem, stackTrail, context }) => {
+    if ((0, isEmpty_js_1.isEmpty)(pathItem)) {
+        return { valid: true, pathItem: undefined };
+    }
+    try {
+        return { valid: true, pathItem: (0, exports.toPathItemV3)({ pathItem, stackTrail, context }) };
+    }
+    catch (error) {
+        const normalized = error instanceof Error ? error : new Error(String(error));
+        context.logIssueNoKey({
+            parent: pathItem,
+            level: 'error',
+            message: normalized.message,
+            cause: normalized,
+            stackTrail,
+            type: 'INVALID_OPERATION'
+        });
+        return { valid: false };
+    }
+};
+exports.toPathItemResultV3 = toPathItemResultV3;

package/script/parse/v3-2/ref/toRefV31.d.ts

@@ -0,0 +1,19 @@
+import type { OpenAPIV3_1 } from 'openapi-types';
+import type { OasRefData } from '../../../oas/ref/ref-types.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+type ToRefV31Args<T extends OasRefData['refType']> = {
+    ref: OpenAPIV3_1.ReferenceObject;
+    refType: T;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+    /**
+     * Use-site nullability to stamp on the OasRef node. Passed explicitly
+     * by the single-member `oneOf`/`anyOf` collapse for a nullable
+     * reference; omitted everywhere else (a plain `$ref` is non-nullable).
+     */
+    nullable?: boolean;
+};
+export declare const toRefV31: <T extends OasRefData["refType"]>({ ref, refType, stackTrail, context, nullable }: ToRefV31Args<T>) => OasRef<T>;
+export {};

package/script/parse/v3-2/ref/toRefV31.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRefV31 = void 0;
+const Ref_js_1 = require("../../../oas/ref/Ref.js");
+const isEmpty_js_1 = require("../../../helpers/isEmpty.js");
+const toRefV31 = ({ ref, refType, stackTrail, context, nullable }) => {
+    const { $ref, ...skipped } = ref;
+    if (!(0, isEmpty_js_1.isEmpty)(skipped)) {
+        context.logSkippedFields({ skipped, parent: ref, parentType: 'ref', stackTrail });
+    }
+    context.registerRef(stackTrail.clone(), $ref);
+    return context.withStackTrail(stackTrail, () => new Ref_js_1.OasRef({ refType, $ref, nullable }, context));
+};
+exports.toRefV31 = toRefV31;

package/script/parse/v3-2/requestBody/toRequestBodiesV3.d.ts

@@ -0,0 +1,18 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasRequestBody } from '../../../oas/requestBody/RequestBody.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToRequestBodyV3Args = {
+    requestBody: OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject | undefined;
+    forceRef?: boolean;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toRequestBodyV3: ({ requestBody, stackTrail, context }: ToRequestBodyV3Args) => OasRequestBody | OasRef<"requestBody"> | undefined;
+export type ToRequestBodiesV3Args = {
+    requestBodies: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.RequestBodyObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toRequestBodiesV3: ({ requestBodies, stackTrail, context }: ToRequestBodiesV3Args) => Record<string, OasRequestBody | OasRef<"requestBody">> | undefined;

package/script/parse/v3-2/requestBody/toRequestBodiesV3.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toRequestBodiesV3 = exports.toRequestBodyV3 = void 0;
+const refFns_js_1 = require("../../../helpers/refFns.js");
+const toRefV31_js_1 = require("../ref/toRefV31.js");
+const toMediaTypeItemV3_js_1 = require("../mediaType/toMediaTypeItemV3.js");
+const RequestBody_js_1 = require("../../../oas/requestBody/RequestBody.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const logBodyMediaTypes_js_1 = require("../../logBodyMediaTypes.js");
+const toRequestBodyV3 = ({ requestBody, stackTrail, context }) => {
+    if (!requestBody) {
+        return undefined;
+    }
+    if ((0, refFns_js_1.isRef)(requestBody)) {
+        return (0, toRefV31_js_1.toRefV31)({ ref: requestBody, refType: 'requestBody', stackTrail, context });
+    }
+    const { description, content, required, ...skipped } = requestBody;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: requestBody,
+        context,
+        stackTrail,
+        parentType: 'requestBody'
+    });
+    const fields = {
+        description,
+        content: stackTrail.trace('content', st => {
+            return (0, toMediaTypeItemV3_js_1.toMediaTypeItemsV3)({ content, stackTrail: st, context });
+        }),
+        required,
+        extensionFields
+    };
+    const parsed = context.withStackTrail(stackTrail, () => new RequestBody_js_1.OasRequestBody(fields, context));
+    (0, logBodyMediaTypes_js_1.logBodyMediaTypes)({ content: fields.content, stackTrail, context });
+    return parsed;
+};
+exports.toRequestBodyV3 = toRequestBodyV3;
+const toRequestBodiesV3 = ({ requestBodies, stackTrail, context }) => {
+    if (!requestBodies) {
+        return undefined;
+    }
+    const entries = Object.entries(requestBodies)
+        .map(([key, value]) => {
+        return [
+            key,
+            stackTrail.trace(key, st => (0, exports.toRequestBodyV3)({ requestBody: value, stackTrail: st, context }))
+        ];
+    })
+        .filter(([, value]) => Boolean(value));
+    return Object.fromEntries(entries);
+};
+exports.toRequestBodiesV3 = toRequestBodiesV3;

package/script/parse/v3-2/response/toResponseV3.d.ts

@@ -0,0 +1,29 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasResponse } from '../../../oas/response/Response.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+/** A 3.2 Response Object: the 3.0 shape plus `summary`. */
+export type ResponseObjectV32 = OpenAPIV3.ResponseObject & {
+    summary?: string;
+};
+/** A 3.2 Responses Object: status code to a 3.2 Response Object or a reference. */
+export type ResponsesObjectV32 = Record<string, OpenAPIV3.ReferenceObject | ResponseObjectV32>;
+export type ToResponsesV3Args = {
+    responses: ResponsesObjectV32;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toResponsesV3: ({ responses, stackTrail, context }: ToResponsesV3Args) => Record<string, OasResponse | OasRef<"response">>;
+export type ToOptionalResponsesV3Args = {
+    responses: ResponsesObjectV32 | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalResponsesV3: ({ responses, stackTrail, context }: ToOptionalResponsesV3Args) => Record<string, OasResponse | OasRef<"response">> | undefined;
+export type ToResponseV3Args = {
+    response: OpenAPIV3.ReferenceObject | ResponseObjectV32;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toResponseV3: ({ response, stackTrail, context }: ToResponseV3Args) => OasResponse | OasRef<"response">;

package/script/parse/v3-2/response/toResponseV3.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toResponseV3 = exports.toOptionalResponsesV3 = exports.toResponsesV3 = void 0;
+const toRefV31_js_1 = require("../ref/toRefV31.js");
+const toHeadersV3_js_1 = require("../header/toHeadersV3.js");
+const toLinksV3_js_1 = require("../link/toLinksV3.js");
+const refFns_js_1 = require("../../../helpers/refFns.js");
+const toMediaTypeItemV3_js_1 = require("../mediaType/toMediaTypeItemV3.js");
+const Response_js_1 = require("../../../oas/response/Response.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const tryParseAt_js_1 = require("../../../context/tryParseAt.js");
+const logBodyMediaTypes_js_1 = require("../../logBodyMediaTypes.js");
+const toResponsesV3 = ({ responses, stackTrail, context }) => {
+    const output = {};
+    const entries = Object.entries(responses);
+    for (const [key, value] of entries) {
+        const parsed = (0, tryParseAt_js_1.tryParseAt)({
+            stackTrail,
+            key,
+            context,
+            type: 'INVALID_RESPONSE',
+            parent: value,
+            fn: st => (0, exports.toResponseV3)({ response: value, stackTrail: st, context })
+        });
+        if (parsed !== undefined) {
+            output[key] = parsed;
+        }
+    }
+    return output;
+};
+exports.toResponsesV3 = toResponsesV3;
+const toOptionalResponsesV3 = ({ responses, stackTrail, context }) => {
+    if (!responses) {
+        return undefined;
+    }
+    return (0, exports.toResponsesV3)({ responses, stackTrail, context });
+};
+exports.toOptionalResponsesV3 = toOptionalResponsesV3;
+const toResponseV3 = ({ response, stackTrail, context }) => {
+    if ((0, refFns_js_1.isRef)(response)) {
+        return (0, toRefV31_js_1.toRefV31)({ ref: response, refType: 'response', stackTrail, context });
+    }
+    const { summary, description, headers, links, content, ...skipped } = response;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: response,
+        context,
+        stackTrail,
+        parentType: 'response'
+    });
+    const parsedHeaders = stackTrail.trace('headers', st => (0, toHeadersV3_js_1.toHeadersV3)({ headers, stackTrail: st, context }));
+    const parsedLinks = stackTrail.trace('links', st => (0, toLinksV3_js_1.toLinksV3)({ links, stackTrail: st, context }));
+    const parsedContent = stackTrail.trace('content', st => (0, toMediaTypeItemV3_js_1.toOptionalMediaTypeItemsV3)({ content, stackTrail: st, context }));
+    const parsed = context.withStackTrail(stackTrail, () => new Response_js_1.OasResponse({
+        summary,
+        description,
+        headers: parsedHeaders,
+        links: parsedLinks,
+        content: parsedContent,
+        extensionFields
+    }, context));
+    (0, logBodyMediaTypes_js_1.logBodyMediaTypes)({ content: parsedContent, stackTrail, context });
+    return parsed;
+};
+exports.toResponseV3 = toResponseV3;

package/script/parse/v3-2/schema/toSchemasV3.d.ts

@@ -0,0 +1,29 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import type { OasSchema } from '../../../oas/schema/Schema.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToSchemasV3Args = {
+    schemas: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject>;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSchemasV3: ({ schemas, stackTrail, context }: ToSchemasV3Args) => Record<string, OasSchema | OasRef<"schema">>;
+export type ToOptionalSchemasV3Args = {
+    schemas: Record<string, OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalSchemasV3: ({ schemas, stackTrail, context }: ToOptionalSchemasV3Args) => Record<string, OasSchema | OasRef<"schema">> | undefined;
+export type ToSchemaV3Args = {
+    schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toSchemaV3: ({ schema, stackTrail, context }: ToSchemaV3Args) => OasSchema | OasRef<"schema">;
+export type ToOptionalSchemaV3Args = {
+    schema: OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalSchemaV3: ({ schema, stackTrail, context }: ToOptionalSchemaV3Args) => OasSchema | OasRef<"schema"> | undefined;