@skmtc/core 0.0.787 → 0.0.788

package/script/oas/operation/Operation.js

@@ -3,7 +3,113 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.OasOperation = void 0;
 require("../../_dnt.polyfills.js");
 const Object_js_1 = require("../object/Object.js");
-/** Operation represents a resource path and a method that can be enacted against it */
+/**
+ * Represents an OpenAPI Operation Object in the SKMTC OAS processing system.
+ *
+ * The `OasOperation` class encapsulates a single API operation (path + method combination)
+ * with all its associated metadata, parameters, request/response specifications, and
+ * security requirements. It provides utilities for extracting common operation data
+ * like success responses and request bodies.
+ *
+ * ## Key Features
+ *
+ * - **Path and Method**: Unique combination identifying the operation
+ * - **Metadata Access**: Operation ID, summary, description, tags, and deprecation status
+ * - **Parameter Handling**: Query, path, header, and cookie parameters
+ * - **Request/Response Specs**: Type-safe access to request body and response definitions
+ * - **Security Context**: Operation-specific security requirements
+ * - **Success Response Utils**: Helper methods to identify and extract successful responses
+ *
+ * @example Basic operation properties
+ * ```typescript
+ * import { OasOperation } from '@skmtc/core';
+ *
+ * // Typically created during document parsing
+ * const getUserOp = new OasOperation({
+ *   path: '/users/{id}',
+ *   method: 'get',
+ *   operationId: 'getUserById',
+ *   summary: 'Get user by ID',
+ *   description: 'Retrieves a single user by their unique identifier',
+ *   parameters: [
+ *     // Path parameter for user ID
+ *     { name: 'id', in: 'path', required: true, schema: { type: 'string' } }
+ *   ],
+ *   responses: {
+ *     '200': { description: 'User found', content: { ... } },
+ *     '404': { description: 'User not found' }
+ *   }
+ * });
+ *
+ * console.log(getUserOp.path);        // '/users/{id}'
+ * console.log(getUserOp.method);      // 'get'
+ * console.log(getUserOp.operationId); // 'getUserById'
+ * ```
+ *
+ * @example Working with success responses
+ * ```typescript
+ * // Find the primary success response
+ * const successResponse = operation.toSuccessResponse();
+ * if (successResponse) {
+ *   const resolved = successResponse.resolve();
+ *   console.log('Success response:', resolved.description);
+ * }
+ *
+ * // Get the HTTP status code for success
+ * const successCode = operation.toSuccessResponseCode();
+ * console.log('Success status:', successCode); // '200', '201', 'default', etc.
+ * ```
+ *
+ * @example Extracting request body data
+ * ```typescript
+ * // Extract request body with custom transformation
+ * const requestData = operation.toRequestBody(({ schema, requestBody }) => {
+ *   return {
+ *     schema: schema,
+ *     contentType: 'application/json',
+ *     required: requestBody.required ?? false,
+ *     description: requestBody.description
+ *   };
+ * });
+ *
+ * if (requestData) {
+ *   console.log('Request schema:', requestData.schema);
+ *   console.log('Required:', requestData.required);
+ * }
+ * ```
+ *
+ * @example Parameter processing
+ * ```typescript
+ * // Process operation parameters by location
+ * const pathParams = operation.parameters?.filter(param => {
+ *   const resolved = param.resolve();
+ *   return resolved.in === 'path';
+ * });
+ *
+ * const queryParams = operation.parameters?.filter(param => {
+ *   const resolved = param.resolve();
+ *   return resolved.in === 'query';
+ * });
+ *
+ * console.log('Path parameters:', pathParams?.length);
+ * console.log('Query parameters:', queryParams?.length);
+ * ```
+ *
+ * @example Security requirements
+ * ```typescript
+ * if (operation.security) {
+ *   console.log('Operation has specific security requirements');
+ *   for (const requirement of operation.security) {
+ *     // Process security schemes for this operation
+ *     Object.keys(requirement.schemes).forEach(scheme => {
+ *       console.log(`Security scheme: ${scheme}`);
+ *     });
+ *   }
+ * } else {
+ *   console.log('Operation uses default document security');
+ * }
+ * ```
+ */
 class OasOperation {
     constructor(fields) {
         Object.defineProperty(this, "oasType", {

package/script/oas/ref/Ref.d.ts

@@ -14,6 +14,92 @@ export type RefFields<T extends OasRefData['refType']> = {
     refType: T;
     $ref: string;
 };
+/**
+ * Represents an OpenAPI reference ($ref) in the SKMTC OAS processing system.
+ *
+ * The `OasRef` class handles OpenAPI JSON Reference Objects that point to reusable
+ * components within the same document. It provides type-safe reference resolution
+ * with support for chained references and circular reference detection.
+ *
+ * ## Key Features
+ *
+ * - **Type Safety**: Generic parameter ensures resolved types match the reference type
+ * - **Lazy Resolution**: References are resolved on-demand, not during construction
+ * - **Chain Resolution**: Handles references that point to other references
+ * - **Circular Detection**: Prevents infinite loops with maximum lookup limits
+ * - **Type Validation**: Ensures resolved objects match expected reference types
+ *
+ * @template T - The type of component this reference points to
+ *
+ * @example Basic reference resolution
+ * ```typescript
+ * import { OasRef } from '@skmtc/core';
+ *
+ * // Reference to a schema component
+ * const userRef = new OasRef<'schema'>({
+ *   refType: 'schema',
+ *   $ref: '#/components/schemas/User'
+ * }, document);
+ *
+ * // Resolve the reference
+ * const userSchema = userRef.resolve();
+ * console.log(userSchema.properties); // Access resolved schema properties
+ * ```
+ *
+ * @example Working with different reference types
+ * ```typescript
+ * // Schema reference
+ * const schemaRef = new OasRef<'schema'>({
+ *   refType: 'schema',
+ *   $ref: '#/components/schemas/Product'
+ * }, document);
+ *
+ * // Response reference
+ * const responseRef = new OasRef<'response'>({
+ *   refType: 'response',
+ *   $ref: '#/components/responses/ErrorResponse'
+ * }, document);
+ *
+ * // Parameter reference
+ * const paramRef = new OasRef<'parameter'>({
+ *   refType: 'parameter',
+ *   $ref: '#/components/parameters/PageSize'
+ * }, document);
+ * ```
+ *
+ * @example Reference checking and conditional resolution
+ * ```typescript
+ * function processSchemaOrRef(schema: OasSchema | OasRef<'schema'>) {
+ *   if (schema.isRef()) {
+ *     // Handle reference
+ *     const refName = schema.toRefName();
+ *     console.log(`Processing reference: ${refName}`);
+ *
+ *     // Resolve only when needed
+ *     const resolved = schema.resolve();
+ *     return processed(resolved);
+ *   } else {
+ *     // Handle direct schema
+ *     return process(schema);
+ *   }
+ * }
+ * ```
+ *
+ * @example Chained reference handling
+ * ```typescript
+ * // References can point to other references
+ * const chainedRef = new OasRef<'schema'>({
+ *   refType: 'schema',
+ *   $ref: '#/components/schemas/AliasToUser'
+ * }, document);
+ *
+ * // resolve() automatically follows the chain
+ * const finalSchema = chainedRef.resolve(); // Follows chain to final schema
+ *
+ * // resolveOnce() resolves only one step
+ * const oneStep = chainedRef.resolveOnce(); // May still be a reference
+ * ```
+ */
 export declare class OasRef<T extends OasRefData['refType']> {
     #private;
     oasType: 'ref';

package/script/oas/ref/Ref.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Ref.d.ts","sourceRoot":"","sources":["../../../src/oas/ref/Ref.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAA;AAI7E,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,IAAI;IACvD,OAAO,EAAE,CAAC,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,qBAAa,MAAM,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC;;IACjD,OAAO,EAAE,KAAK,CAAQ;IACtB,IAAI,EAAE,KAAK,CAAQ;gBAIP,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,WAAW;IAK1D,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC;IAI1B,OAAO,CAAC,gBAAgB,GAAE,MAAU,GAAG,WAAW,CAAC,CAAC,CAAC;IAUrD,WAAW,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAsCzC,SAAS,IAAI,OAAO;IAIpB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,UAAU,CAAC,SAAS,CAAC,CAEnC;IAED,IAAI,WAAW,IAAI,WAAW,CAE7B;IAED,YAAY,CAAC,EACX,OAAO,EACR,EAAE,mBAAmB,GAAG,SAAS,CAAC,eAAe,GAAG,mBAAmB,CAAC,CAAC,CAAC;IAsB3E,MAAM,IAAI,MAAM;CAajB;AAED,KAAK,mBAAmB,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,IAAI,UAAU,CACpE,WAAW,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAC/B,CAAA;AAED,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,WAAW,GACX,YAAY,GACZ,UAAU,GACV,cAAc,GACd,SAAS,GACT,iBAAiB,CAAA;AAErB,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC,gBAAgB,EAAE;IAAE,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,CAAA"}
+{"version":3,"file":"Ref.d.ts","sourceRoot":"","sources":["../../../src/oas/ref/Ref.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD,OAAO,KAAK,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AACzE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAA;AAI7E,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,IAAI;IACvD,OAAO,EAAE,CAAC,CAAA;IACV,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqFG;AACH,qBAAa,MAAM,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC;;IACjD,OAAO,EAAE,KAAK,CAAQ;IACtB,IAAI,EAAE,KAAK,CAAQ;gBAIP,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,WAAW,EAAE,WAAW;IAK1D,KAAK,IAAI,IAAI,IAAI,MAAM,CAAC,CAAC,CAAC;IAI1B,OAAO,CAAC,gBAAgB,GAAE,MAAU,GAAG,WAAW,CAAC,CAAC,CAAC;IAUrD,WAAW,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC;IAsCzC,SAAS,IAAI,OAAO;IAIpB,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED,IAAI,OAAO,IAAI,UAAU,CAAC,SAAS,CAAC,CAEnC;IAED,IAAI,WAAW,IAAI,WAAW,CAE7B;IAED,YAAY,CAAC,EACX,OAAO,EACR,EAAE,mBAAmB,GAAG,SAAS,CAAC,eAAe,GAAG,mBAAmB,CAAC,CAAC,CAAC;IAsB3E,MAAM,IAAI,MAAM;CAajB;AAED,KAAK,mBAAmB,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,IAAI,UAAU,CACpE,WAAW,CAAC,CAAC,CAAC,CAAC,cAAc,CAAC,CAC/B,CAAA;AAED,MAAM,MAAM,gBAAgB,GACxB,SAAS,GACT,WAAW,GACX,YAAY,GACZ,UAAU,GACV,cAAc,GACd,SAAS,GACT,iBAAiB,CAAA;AAErB,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,IAAI,OAAO,CAAC,gBAAgB,EAAE;IAAE,OAAO,EAAE,CAAC,CAAA;CAAE,CAAC,CAAA"}

package/script/oas/ref/Ref.js

@@ -17,6 +17,92 @@ require("../../_dnt.polyfills.js");
 const refFns_js_1 = require("../../helpers/refFns.js");
 const ts_pattern_1 = require("ts-pattern");
 const MAX_LOOKUPS = 10;
+/**
+ * Represents an OpenAPI reference ($ref) in the SKMTC OAS processing system.
+ *
+ * The `OasRef` class handles OpenAPI JSON Reference Objects that point to reusable
+ * components within the same document. It provides type-safe reference resolution
+ * with support for chained references and circular reference detection.
+ *
+ * ## Key Features
+ *
+ * - **Type Safety**: Generic parameter ensures resolved types match the reference type
+ * - **Lazy Resolution**: References are resolved on-demand, not during construction
+ * - **Chain Resolution**: Handles references that point to other references
+ * - **Circular Detection**: Prevents infinite loops with maximum lookup limits
+ * - **Type Validation**: Ensures resolved objects match expected reference types
+ *
+ * @template T - The type of component this reference points to
+ *
+ * @example Basic reference resolution
+ * ```typescript
+ * import { OasRef } from '@skmtc/core';
+ *
+ * // Reference to a schema component
+ * const userRef = new OasRef<'schema'>({
+ *   refType: 'schema',
+ *   $ref: '#/components/schemas/User'
+ * }, document);
+ *
+ * // Resolve the reference
+ * const userSchema = userRef.resolve();
+ * console.log(userSchema.properties); // Access resolved schema properties
+ * ```
+ *
+ * @example Working with different reference types
+ * ```typescript
+ * // Schema reference
+ * const schemaRef = new OasRef<'schema'>({
+ *   refType: 'schema',
+ *   $ref: '#/components/schemas/Product'
+ * }, document);
+ *
+ * // Response reference
+ * const responseRef = new OasRef<'response'>({
+ *   refType: 'response',
+ *   $ref: '#/components/responses/ErrorResponse'
+ * }, document);
+ *
+ * // Parameter reference
+ * const paramRef = new OasRef<'parameter'>({
+ *   refType: 'parameter',
+ *   $ref: '#/components/parameters/PageSize'
+ * }, document);
+ * ```
+ *
+ * @example Reference checking and conditional resolution
+ * ```typescript
+ * function processSchemaOrRef(schema: OasSchema | OasRef<'schema'>) {
+ *   if (schema.isRef()) {
+ *     // Handle reference
+ *     const refName = schema.toRefName();
+ *     console.log(`Processing reference: ${refName}`);
+ *
+ *     // Resolve only when needed
+ *     const resolved = schema.resolve();
+ *     return processed(resolved);
+ *   } else {
+ *     // Handle direct schema
+ *     return process(schema);
+ *   }
+ * }
+ * ```
+ *
+ * @example Chained reference handling
+ * ```typescript
+ * // References can point to other references
+ * const chainedRef = new OasRef<'schema'>({
+ *   refType: 'schema',
+ *   $ref: '#/components/schemas/AliasToUser'
+ * }, document);
+ *
+ * // resolve() automatically follows the chain
+ * const finalSchema = chainedRef.resolve(); // Follows chain to final schema
+ *
+ * // resolveOnce() resolves only one step
+ * const oneStep = chainedRef.resolveOnce(); // May still be a reference
+ * ```
+ */
 class OasRef {
     constructor(fields, oasDocument) {
         Object.defineProperty(this, "oasType", {