@skmtc/core 0.28.7 → 0.30.1

package/script/parse/v3-2/methods.d.ts

@@ -0,0 +1,17 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Method } from '../../types/Method.js';
+/**
+ * The path item fields that hold an Operation Object in OpenAPI 3.2.
+ * `query` is new in 3.2.
+ */
+export declare const pathItemMethods: readonly Method[];
+/**
+ * A 3.2 path item: the `openapi-types` path item plus the `query` operation.
+ */
+export type PathItemObjectV3 = OpenAPIV3.PathItemObject & {
+    query?: OpenAPIV3.OperationObject;
+};
+/**
+ * Returns `key` as a {@link Method} when it is one of {@link pathItemMethods}.
+ */
+export declare const toPathItemMethod: (key: string) => Method | undefined;

package/script/parse/v3-2/methods.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPathItemMethod = exports.pathItemMethods = void 0;
+/**
+ * The path item fields that hold an Operation Object in OpenAPI 3.2.
+ * `query` is new in 3.2.
+ */
+exports.pathItemMethods = [
+    'get',
+    'put',
+    'post',
+    'delete',
+    'options',
+    'head',
+    'patch',
+    'trace',
+    'query'
+];
+/**
+ * Returns `key` as a {@link Method} when it is one of {@link pathItemMethods}.
+ */
+const toPathItemMethod = (key) => {
+    return exports.pathItemMethods.find(method => method === key);
+};
+exports.toPathItemMethod = toPathItemMethod;

package/script/parse/v3-2/number/toNumber.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasNumber } from '../../../oas/number/Number.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToNumberArgs = {
+    value: OpenAPIV3.SchemaObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toNumber: ({ context, value, stackTrail }: ToNumberArgs) => OasNumber;

package/script/parse/v3-2/number/toNumber.js

@@ -0,0 +1,152 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toNumber = void 0;
+const Number_js_1 = require("../../../oas/number/Number.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const number_types_js_1 = require("../../../oas/number/number-types.js");
+const parseNullable_js_1 = require("../_helpers/parseNullable.js");
+const parseEnum_js_1 = require("../_helpers/parseEnum.js");
+const parseExample_js_1 = require("../_helpers/parseExample.js");
+const parseDefault_js_1 = require("../_helpers/parseDefault.js");
+const v = __importStar(require("valibot"));
+const toNumber = ({ context, value, stackTrail }) => {
+    const { nullable, value: valueWithoutNullable } = (0, parseNullable_js_1.parseNullable)({
+        value,
+        context,
+        stackTrail
+    });
+    const { example: unparsedExample, ...valueWithoutExample } = valueWithoutNullable;
+    const example = (0, parseExample_js_1.parseExample)({
+        value: unparsedExample,
+        context,
+        parent: valueWithoutNullable,
+        nullable,
+        check: isNumber,
+        toMessage: item => `Removed invalid example. Expected "number", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
+        nullable,
+        stackTrail,
+        parent: valueWithoutExample,
+        context,
+        check: isNumber,
+        toMessage: item => `Removed invalid enum. Expected "number", got: ${item}`
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = (0, parseDefault_js_1.parseDefault)({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isNumber,
+        toMessage: item => `Removed invalid default. Expected "number", got: ${item}`,
+        stackTrail
+    });
+    return toParsedNumber({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        value: valueWithoutDefault,
+        stackTrail
+    });
+};
+exports.toNumber = toNumber;
+const toParsedNumber = ({ context, nullable, example, enums, defaultValue, value: valueWithoutEnums, stackTrail }) => {
+    const { format: unparsedFormat, ...valueWithoutFormat } = valueWithoutEnums;
+    const format = parseNumberFormat({
+        format: unparsedFormat,
+        context,
+        stackTrail,
+        parent: valueWithoutEnums
+    });
+    if (!v.is(number_types_js_1.oasNumberData, valueWithoutFormat)) {
+        v.parse(number_types_js_1.oasNumberData, valueWithoutFormat);
+    }
+    const { type: _type, title, description, multipleOf, maximum, exclusiveMaximum, minimum, exclusiveMinimum, readOnly, writeOnly, deprecated, ...skipped } = valueWithoutFormat;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: valueWithoutFormat,
+        context,
+        stackTrail,
+        parentType: 'schema:number'
+    });
+    return context.withStackTrail(stackTrail, () => new Number_js_1.OasNumber({
+        title,
+        description,
+        nullable,
+        default: defaultValue,
+        extensionFields,
+        example,
+        enums,
+        format,
+        multipleOf,
+        maximum,
+        exclusiveMaximum,
+        minimum,
+        readOnly,
+        writeOnly,
+        exclusiveMinimum,
+        deprecated
+    }, context));
+};
+const parseNumberFormat = ({ format, context, parent, stackTrail }) => {
+    if (format === undefined) {
+        return undefined;
+    }
+    if (!v.is(number_types_js_1.numberFormat, format)) {
+        // `format` is an open vocabulary; a value the IR's numberFormat can't
+        // hold (e.g. `decimal`) is dropped. Recorded at `debug` — the dropped
+        // hint is informational, not a correctness issue.
+        context.logIssue({
+            key: 'format',
+            level: 'debug',
+            message: `Invalid format: ${format}`,
+            parent,
+            stackTrail,
+            type: 'INVALID_FORMAT'
+        });
+        return undefined;
+    }
+    return format;
+};
+const isNumber = (value) => {
+    return typeof value === 'number';
+};

package/script/parse/v3-2/object/toAdditionalPropertiesV3.d.ts

@@ -0,0 +1,11 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+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 ToAdditionalPropertiesV3Args = {
+    additionalProperties: boolean | OpenAPIV3.ReferenceObject | OpenAPIV3.SchemaObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toAdditionalPropertiesV3: ({ additionalProperties, stackTrail, context }: ToAdditionalPropertiesV3Args) => OasSchema | OasRef<"schema"> | boolean | undefined;

package/script/parse/v3-2/object/toAdditionalPropertiesV3.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAdditionalPropertiesV3 = void 0;
+const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
+const toAdditionalPropertiesV3 = ({ additionalProperties, stackTrail, context }) => {
+    if (typeof additionalProperties === 'boolean') {
+        return additionalProperties;
+    }
+    if (additionalProperties === undefined) {
+        return undefined;
+    }
+    return (0, toSchemasV3_js_1.toSchemaV3)({ schema: additionalProperties, stackTrail, context });
+};
+exports.toAdditionalPropertiesV3 = toAdditionalPropertiesV3;

package/script/parse/v3-2/object/toObject.d.ts

@@ -0,0 +1,10 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasObject } from '../../../oas/object/Object.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToObjectArgs = {
+    value: OpenAPIV3.SchemaObject;
+    context: ParseContextType;
+    stackTrail: StackTrail;
+};
+export declare const toObject: ({ value, context, stackTrail }: ToObjectArgs) => OasObject;

package/script/parse/v3-2/object/toObject.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toObject = void 0;
+const Object_js_1 = require("../../../oas/object/Object.js");
+const toSchemasV3_js_1 = require("../schema/toSchemasV3.js");
+const toAdditionalPropertiesV3_js_1 = require("./toAdditionalPropertiesV3.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const parseNullable_js_1 = require("../_helpers/parseNullable.js");
+const parseEnum_js_1 = require("../_helpers/parseEnum.js");
+const parseExample_js_1 = require("../_helpers/parseExample.js");
+const parseDefault_js_1 = require("../_helpers/parseDefault.js");
+const toExternalDocs_js_1 = require("../externalDocs/toExternalDocs.js");
+const toObject = ({ value, context, stackTrail }) => {
+    const { nullable, value: valueWithoutNullable } = (0, parseNullable_js_1.parseNullable)({
+        value,
+        context,
+        stackTrail
+    });
+    const { example: unparsedExample, ...valueWithoutExample } = valueWithoutNullable;
+    const example = (0, parseExample_js_1.parseExample)({
+        value: unparsedExample,
+        context,
+        parent: valueWithoutNullable,
+        nullable,
+        check: isObject,
+        toMessage: item => `Removed invalid example. Expected "object", got: ${item}`,
+        stackTrail
+    });
+    const { enum: unparsedEnums, ...valueWithoutEnums } = valueWithoutExample;
+    const enums = (0, parseEnum_js_1.parseEnum)({
+        value: unparsedEnums,
+        nullable,
+        parent: valueWithoutExample,
+        context,
+        stackTrail,
+        check: isObject,
+        toMessage: item => `Removed invalid enum. Expected "object", got: ${item}`
+    });
+    const { default: unparsedDefaultValue, ...valueWithoutDefault } = valueWithoutEnums;
+    const defaultValue = (0, parseDefault_js_1.parseDefault)({
+        value: unparsedDefaultValue,
+        context,
+        parent: valueWithoutEnums,
+        nullable,
+        check: isObject,
+        toMessage: item => `Removed invalid default. Expected "object", got: ${item}`,
+        stackTrail
+    });
+    return toParsedObject({
+        context,
+        nullable,
+        example,
+        enums,
+        defaultValue,
+        value: valueWithoutDefault,
+        stackTrail
+    });
+};
+exports.toObject = toObject;
+const toParsedObject = ({ context, stackTrail, nullable, example, enums, defaultValue, value }) => {
+    const { type: _type, title, description, externalDocs, deprecated, properties, required, maxProperties, minProperties, additionalProperties, readOnly, writeOnly, ...skipped } = value;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: value,
+        context,
+        stackTrail,
+        parentType: 'schema:object'
+    });
+    return context.withStackTrail(stackTrail, () => new Object_js_1.OasObject({
+        title,
+        description,
+        externalDocs: stackTrail.trace('externalDocs', st => (0, toExternalDocs_js_1.toExternalDocs)({ externalDocs, stackTrail: st, context })),
+        nullable,
+        example,
+        enums,
+        properties: stackTrail.trace('properties', st => (0, toSchemasV3_js_1.toOptionalSchemasV3)({
+            schemas: properties,
+            stackTrail: st,
+            context
+        })),
+        required,
+        maxProperties,
+        minProperties,
+        additionalProperties: stackTrail.trace('additionalProperties', st => (0, toAdditionalPropertiesV3_js_1.toAdditionalPropertiesV3)({ additionalProperties, stackTrail: st, context })),
+        extensionFields,
+        default: defaultValue,
+        deprecated,
+        readOnly,
+        writeOnly
+    }, context));
+};
+const isObject = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};

package/script/parse/v3-2/operation/toOperationsV3.d.ts

@@ -0,0 +1,25 @@
+import type { OpenAPIV3 } from 'openapi-types';
+import type { Method } from '../../../types/Method.js';
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { OasOperation } from '../../../oas/operation/Operation.js';
+import type { OasPathItem } from '../../../oas/pathItem/PathItem.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+type OperationInfo = {
+    method: Method;
+    path: string;
+    pathItem: OasPathItem | undefined;
+};
+export type ToOperationV3Args = {
+    operation: OpenAPIV3.OperationObject;
+    operationInfo: OperationInfo;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOperationV3: ({ operation, operationInfo, stackTrail, context }: ToOperationV3Args) => OasOperation;
+export type ToOperationsV3Args = {
+    paths: OpenAPIV3.PathsObject | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOperationsV3: ({ paths, stackTrail, context }: ToOperationsV3Args) => OasOperation[];
+export {};

package/script/parse/v3-2/operation/toOperationsV3.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOperationsV3 = exports.toOperationV3 = void 0;
+const toRequestBodiesV3_js_1 = require("../requestBody/toRequestBodiesV3.js");
+const toResponseV3_js_1 = require("../response/toResponseV3.js");
+const toParameterV3_js_1 = require("../parameter/toParameterV3.js");
+const Operation_js_1 = require("../../../oas/operation/Operation.js");
+const toPathItemV3_js_1 = require("../pathItem/toPathItemV3.js");
+const methods_js_1 = require("../methods.js");
+const dropAdditionalOperationsV3_js_1 = require("../pathItem/dropAdditionalOperationsV3.js");
+const warnQuerystringConflictsV3_js_1 = require("../parameter/warnQuerystringConflictsV3.js");
+const toSpecificationExtensionsV3_js_1 = require("../specificationExtensions/toSpecificationExtensionsV3.js");
+const toSecurityRequirement_js_1 = require("../securityRequirement/toSecurityRequirement.js");
+const toExternalDocs_js_1 = require("../externalDocs/toExternalDocs.js");
+const toServerV3_js_1 = require("../server/toServerV3.js");
+const toOperationV3 = ({ operation, operationInfo, stackTrail, context }) => {
+    const { method, path, pathItem } = operationInfo;
+    const { operationId, tags, summary, description, parameters, requestBody, responses, deprecated, security, externalDocs, servers, 
+    // Callbacks are a deliberate non-goal (no out-of-band callback codegen).
+    // Pull it out so it is dropped silently instead of warned as an
+    // unexpected property on every operation that declares one.
+    callbacks: _callbacks, ...skipped } = operation;
+    const extensionFields = (0, toSpecificationExtensionsV3_js_1.toSpecificationExtensionsV3)({
+        skipped,
+        parent: operation,
+        context,
+        stackTrail,
+        parentType: 'operation'
+    });
+    const parsedParameters = stackTrail.trace('parameters', st => (0, toParameterV3_js_1.toParameterListV3)({ parameters, stackTrail: st, context }));
+    (0, warnQuerystringConflictsV3_js_1.warnQuerystringConflictsV3)({ parameters: parsedParameters, pathItem, stackTrail, context });
+    const parsedRequestBody = stackTrail.trace('requestBody', st => (0, toRequestBodiesV3_js_1.toRequestBodyV3)({ requestBody, stackTrail: st, context }));
+    const parsedResponses = stackTrail.trace('responses', st => (0, toResponseV3_js_1.toResponsesV3)({ responses, stackTrail: st, context }));
+    const parsedSecurity = stackTrail.trace('security', st => (0, toSecurityRequirement_js_1.toSecurityRequirementsV3)({ security, stackTrail: st, context }));
+    const parsedExternalDocs = stackTrail.trace('externalDocs', st => (0, toExternalDocs_js_1.toExternalDocs)({ externalDocs, stackTrail: st, context }));
+    const parsedServers = stackTrail.trace('servers', st => (0, toServerV3_js_1.toOptionalServersV3)({ servers, stackTrail: st, context }));
+    return context.withStackTrail(stackTrail, () => new Operation_js_1.OasOperation({
+        pathItem,
+        path,
+        method,
+        operationId,
+        summary,
+        tags,
+        description,
+        parameters: parsedParameters,
+        requestBody: parsedRequestBody,
+        responses: parsedResponses,
+        deprecated,
+        security: parsedSecurity,
+        externalDocs: parsedExternalDocs,
+        servers: parsedServers,
+        extensionFields
+    }, context));
+};
+exports.toOperationV3 = toOperationV3;
+const toOperationsV3 = ({ paths, stackTrail, context }) => {
+    if (!paths) {
+        return [];
+    }
+    return Object.entries(paths).flatMap(([path, pathItem]) => {
+        return stackTrail.trace(path, pathStack => {
+            if (!pathItem) {
+                return [];
+            }
+            const fixedFields = (0, dropAdditionalOperationsV3_js_1.dropAdditionalOperationsV3)({ pathItem, stackTrail: pathStack, context });
+            const cleaned = Object.entries(fixedFields).reduce(({ rest, methodObject }, [key, operation]) => {
+                const method = (0, methods_js_1.toPathItemMethod)(key);
+                if (method) {
+                    const { [method]: _deleted, ...remaining } = rest;
+                    return {
+                        rest: remaining,
+                        methodObject: {
+                            ...methodObject,
+                            [method]: operation
+                        }
+                    };
+                }
+                return { rest, methodObject };
+            }, {
+                rest: fixedFields,
+                methodObject: {}
+            });
+            const pathItemResult = (0, toPathItemV3_js_1.toPathItemResultV3)({
+                pathItem: cleaned.rest,
+                stackTrail: pathStack,
+                context
+            });
+            if (!pathItemResult.valid) {
+                return [];
+            }
+            const pathItemObject = pathItemResult.pathItem;
+            return Object.entries(cleaned.methodObject)
+                .map(([method, operation]) => {
+                // Use `pathStack` (the trail with `path` already pushed),
+                // not the outer `stackTrail` — otherwise downstream traces
+                // record paths:<method>:... and lose the actual path
+                // segment, which breaks `OasDocument.removeItem` and the
+                // dependency-ref invalidation it backs.
+                return pathStack.trace(method, st => {
+                    if (!operation) {
+                        return;
+                    }
+                    try {
+                        return (0, exports.toOperationV3)({
+                            operation,
+                            operationInfo: {
+                                method: method,
+                                path,
+                                pathItem: pathItemObject
+                            },
+                            stackTrail: st,
+                            context
+                        });
+                    }
+                    catch (error) {
+                        const normalized = error instanceof Error ? error : new Error(String(error));
+                        context.logIssue({
+                            key: method,
+                            parent: operation,
+                            level: 'error',
+                            message: normalized.message,
+                            cause: normalized,
+                            stackTrail: st,
+                            type: 'INVALID_OPERATION'
+                        });
+                        return undefined;
+                    }
+                });
+            })
+                .filter((item) => Boolean(item));
+        });
+    });
+};
+exports.toOperationsV3 = toOperationsV3;

package/script/parse/v3-2/parameter/toParameterV3.d.ts

@@ -0,0 +1,39 @@
+import type { ParseContextType } from '../../../context/parseTypes.js';
+import { type OasParameterLocation } from '../../../oas/parameter/parameter-types.js';
+import type { OpenAPIV3 } from 'openapi-types';
+import { OasParameter } from '../../../oas/parameter/Parameter.js';
+import type { OasRef } from '../../../oas/ref/Ref.js';
+import type { StackTrail } from '../../../context/StackTrail.js';
+export type ToParameterListV3Args = {
+    parameters: (OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject)[] | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toParameterListV3: ({ parameters, stackTrail, context }: ToParameterListV3Args) => (OasParameter | OasRef<"parameter">)[] | undefined;
+export type ToParametersV3Args = {
+    parameters: Record<string, OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject>;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toParametersV3: ({ parameters, stackTrail, context }: ToParametersV3Args) => Record<string, OasParameter | OasRef<"parameter">>;
+export type ToOptionalParametersV3Args = {
+    parameters: Record<string, OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject> | undefined;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export declare const toOptionalParametersV3: ({ parameters, stackTrail, context }: ToOptionalParametersV3Args) => Record<string, OasParameter | OasRef<"parameter">> | undefined;
+export type ToParameterV3Args = {
+    parameter: OpenAPIV3.ParameterObject | OpenAPIV3.ReferenceObject;
+    stackTrail: StackTrail;
+    context: ParseContextType;
+};
+export type ToStyleArgs = {
+    style: string | undefined;
+    location: OasParameterLocation;
+    stackTrail: StackTrail;
+};
+export type ToExplodeArgs = {
+    explode: boolean | undefined;
+    style: string | undefined;
+    stackTrail: StackTrail;
+};