@skmtc/core 0.0.787 → 0.0.789
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/esm/context/GenerateContext.d.ts +95 -0
- package/esm/context/GenerateContext.d.ts.map +1 -1
- package/esm/context/GenerateContext.js +95 -0
- package/esm/context/ParseContext.d.ts +178 -0
- package/esm/context/ParseContext.d.ts.map +1 -1
- package/esm/context/ParseContext.js +108 -0
- package/esm/dsl/Inserted.d.ts +240 -0
- package/esm/dsl/Inserted.d.ts.map +1 -1
- package/esm/dsl/Inserted.js +231 -0
- package/esm/dsl/JsonFile.d.ts +162 -0
- package/esm/dsl/JsonFile.d.ts.map +1 -1
- package/esm/dsl/JsonFile.js +157 -0
- package/esm/helpers/refFns.d.ts +160 -0
- package/esm/helpers/refFns.d.ts.map +1 -1
- package/esm/helpers/refFns.js +156 -0
- package/esm/oas/components/Components.d.ts +252 -2
- package/esm/oas/components/Components.d.ts.map +1 -1
- package/esm/oas/components/Components.js +241 -2
- package/esm/oas/operation/Operation.d.ts +107 -1
- package/esm/oas/operation/Operation.d.ts.map +1 -1
- package/esm/oas/operation/Operation.js +107 -1
- package/esm/oas/ref/Ref.d.ts +86 -0
- package/esm/oas/ref/Ref.d.ts.map +1 -1
- package/esm/oas/ref/Ref.js +86 -0
- package/esm/oas/union/Union.d.ts +119 -5
- package/esm/oas/union/Union.d.ts.map +1 -1
- package/esm/oas/union/Union.js +108 -5
- package/package.json +1 -1
- package/script/context/GenerateContext.d.ts +95 -0
- package/script/context/GenerateContext.d.ts.map +1 -1
- package/script/context/GenerateContext.js +95 -0
- package/script/context/ParseContext.d.ts +178 -0
- package/script/context/ParseContext.d.ts.map +1 -1
- package/script/context/ParseContext.js +108 -0
- package/script/dsl/Inserted.d.ts +240 -0
- package/script/dsl/Inserted.d.ts.map +1 -1
- package/script/dsl/Inserted.js +231 -0
- package/script/dsl/JsonFile.d.ts +162 -0
- package/script/dsl/JsonFile.d.ts.map +1 -1
- package/script/dsl/JsonFile.js +157 -0
- package/script/helpers/refFns.d.ts +160 -0
- package/script/helpers/refFns.d.ts.map +1 -1
- package/script/helpers/refFns.js +156 -0
- package/script/oas/components/Components.d.ts +252 -2
- package/script/oas/components/Components.d.ts.map +1 -1
- package/script/oas/components/Components.js +241 -2
- package/script/oas/operation/Operation.d.ts +107 -1
- package/script/oas/operation/Operation.d.ts.map +1 -1
- package/script/oas/operation/Operation.js +107 -1
- package/script/oas/ref/Ref.d.ts +86 -0
- package/script/oas/ref/Ref.d.ts.map +1 -1
- package/script/oas/ref/Ref.js +86 -0
- package/script/oas/union/Union.d.ts +119 -5
- package/script/oas/union/Union.d.ts.map +1 -1
- package/script/oas/union/Union.js +108 -5
|
@@ -9,29 +9,279 @@ import type { OasRef } from '../ref/Ref.js';
|
|
|
9
9
|
import type { OasSchema } from '../schema/Schema.js';
|
|
10
10
|
import type { RefName } from '../../types/RefName.js';
|
|
11
11
|
import type { OasSecurityScheme } from '../securitySchemes/SecurityScheme.js';
|
|
12
|
+
/**
|
|
13
|
+
* Available component types in an OpenAPI document.
|
|
14
|
+
*/
|
|
12
15
|
export declare const componentsKeys: string[];
|
|
16
|
+
/**
|
|
17
|
+
* Constructor fields for {@link OasComponents}.
|
|
18
|
+
*/
|
|
13
19
|
export type ComponentsFields = {
|
|
20
|
+
/** Reusable schema components */
|
|
14
21
|
schemas?: Record<RefName, OasSchema | OasRef<'schema'>>;
|
|
22
|
+
/** Reusable response components */
|
|
15
23
|
responses?: Record<RefName, OasResponse | OasRef<'response'>>;
|
|
24
|
+
/** Reusable parameter components */
|
|
16
25
|
parameters?: Record<RefName, OasParameter | OasRef<'parameter'>>;
|
|
26
|
+
/** Reusable example components */
|
|
17
27
|
examples?: Record<RefName, OasExample | OasRef<'example'>>;
|
|
28
|
+
/** Reusable request body components */
|
|
18
29
|
requestBodies?: Record<RefName, OasRequestBody | OasRef<'requestBody'>>;
|
|
30
|
+
/** Reusable header components */
|
|
19
31
|
headers?: Record<RefName, OasHeader | OasRef<'header'>>;
|
|
32
|
+
/** Reusable security scheme components */
|
|
20
33
|
securitySchemes?: Record<string, OasSecurityScheme | OasRef<'securityScheme'>>;
|
|
34
|
+
/** Custom extension fields (x-* properties) */
|
|
21
35
|
extensionFields?: Record<string, unknown>;
|
|
22
36
|
};
|
|
23
|
-
/**
|
|
37
|
+
/**
|
|
38
|
+
* Represents the OpenAPI Components Object in the SKMTC OAS processing system.
|
|
39
|
+
*
|
|
40
|
+
* The `OasComponents` class manages the reusable components section of an OpenAPI
|
|
41
|
+
* document, providing centralized access to shared schemas, responses, parameters,
|
|
42
|
+
* and other reusable elements that can be referenced throughout the API specification.
|
|
43
|
+
*
|
|
44
|
+
* This class serves as the central registry for all reusable components, enabling
|
|
45
|
+
* efficient reference resolution and reducing duplication in OpenAPI documents.
|
|
46
|
+
*
|
|
47
|
+
* ## Key Features
|
|
48
|
+
*
|
|
49
|
+
* - **Schema Management**: Central repository for reusable data schemas
|
|
50
|
+
* - **Response Reuse**: Common response definitions for consistent API responses
|
|
51
|
+
* - **Parameter Standardization**: Shared parameter definitions across operations
|
|
52
|
+
* - **Reference Resolution**: Support for internal references ($ref) to components
|
|
53
|
+
* - **Type Safety**: Strongly typed access to different component categories
|
|
54
|
+
* - **Extension Support**: Custom OpenAPI extension field handling
|
|
55
|
+
*
|
|
56
|
+
* @example Basic component access
|
|
57
|
+
* ```typescript
|
|
58
|
+
* import { OasComponents } from '@skmtc/core';
|
|
59
|
+
*
|
|
60
|
+
* // Typically created during document parsing
|
|
61
|
+
* const components = new OasComponents({
|
|
62
|
+
* schemas: {
|
|
63
|
+
* User: new OasObject({
|
|
64
|
+
* properties: {
|
|
65
|
+
* id: new OasString(),
|
|
66
|
+
* name: new OasString()
|
|
67
|
+
* }
|
|
68
|
+
* }),
|
|
69
|
+
* Product: new OasObject({
|
|
70
|
+
* properties: {
|
|
71
|
+
* id: new OasString(),
|
|
72
|
+
* price: new OasNumber()
|
|
73
|
+
* }
|
|
74
|
+
* })
|
|
75
|
+
* },
|
|
76
|
+
* responses: {
|
|
77
|
+
* NotFound: new OasResponse({
|
|
78
|
+
* description: '404 - Resource not found'
|
|
79
|
+
* })
|
|
80
|
+
* }
|
|
81
|
+
* });
|
|
82
|
+
*
|
|
83
|
+
* // Access schemas
|
|
84
|
+
* const userSchema = components.schemas?.['User'];
|
|
85
|
+
* const productSchema = components.schemas?.['Product'];
|
|
86
|
+
*
|
|
87
|
+
* // Access responses
|
|
88
|
+
* const notFoundResponse = components.responses?.['NotFound'];
|
|
89
|
+
* ```
|
|
90
|
+
*
|
|
91
|
+
* @example Schema management
|
|
92
|
+
* ```typescript
|
|
93
|
+
* // Get all schema reference names
|
|
94
|
+
* const schemaNames = components.toSchemasRefNames();
|
|
95
|
+
* console.log(schemaNames); // ['User', 'Product', 'Order']
|
|
96
|
+
*
|
|
97
|
+
* // Remove a schema (useful for processing)
|
|
98
|
+
* const removedSchema = components.removeSchema('ObsoleteSchema');
|
|
99
|
+
* console.log('Removed:', removedSchema);
|
|
100
|
+
*
|
|
101
|
+
* // Check remaining schemas
|
|
102
|
+
* const remainingSchemas = components.toSchemasRefNames();
|
|
103
|
+
* console.log('Remaining:', remainingSchemas);
|
|
104
|
+
* ```
|
|
105
|
+
*
|
|
106
|
+
* @example Parameter reuse
|
|
107
|
+
* ```typescript
|
|
108
|
+
* const components = new OasComponents({
|
|
109
|
+
* parameters: {
|
|
110
|
+
* PageSize: new OasParameter({
|
|
111
|
+
* name: 'pageSize',
|
|
112
|
+
* in: 'query',
|
|
113
|
+
* schema: new OasInteger({ minimum: 1, maximum: 100, default: 20 })
|
|
114
|
+
* }),
|
|
115
|
+
* PageNumber: new OasParameter({
|
|
116
|
+
* name: 'page',
|
|
117
|
+
* in: 'query',
|
|
118
|
+
* schema: new OasInteger({ minimum: 1, default: 1 })
|
|
119
|
+
* })
|
|
120
|
+
* }
|
|
121
|
+
* });
|
|
122
|
+
*
|
|
123
|
+
* // These parameters can be referenced in operations:
|
|
124
|
+
* // $ref: '#/components/parameters/PageSize'
|
|
125
|
+
* // $ref: '#/components/parameters/PageNumber'
|
|
126
|
+
* ```
|
|
127
|
+
*
|
|
128
|
+
* @example Response standardization
|
|
129
|
+
* ```typescript
|
|
130
|
+
* const components = new OasComponents({
|
|
131
|
+
* responses: {
|
|
132
|
+
* Success: new OasResponse({
|
|
133
|
+
* description: 'Successful operation',
|
|
134
|
+
* content: {
|
|
135
|
+
* 'application/json': {
|
|
136
|
+
* schema: new OasObject({
|
|
137
|
+
* properties: {
|
|
138
|
+
* success: new OasBoolean({ default: true }),
|
|
139
|
+
* data: new OasObject({ additionalProperties: true })
|
|
140
|
+
* }
|
|
141
|
+
* })
|
|
142
|
+
* }
|
|
143
|
+
* }
|
|
144
|
+
* }),
|
|
145
|
+
* ValidationError: new OasResponse({
|
|
146
|
+
* description: 'Validation failed',
|
|
147
|
+
* content: {
|
|
148
|
+
* 'application/json': {
|
|
149
|
+
* schema: new OasObject({
|
|
150
|
+
* properties: {
|
|
151
|
+
* error: new OasString(),
|
|
152
|
+
* details: new OasArray({
|
|
153
|
+
* items: new OasString()
|
|
154
|
+
* })
|
|
155
|
+
* }
|
|
156
|
+
* })
|
|
157
|
+
* }
|
|
158
|
+
* }
|
|
159
|
+
* })
|
|
160
|
+
* }
|
|
161
|
+
* });
|
|
162
|
+
*
|
|
163
|
+
* // Standardized responses across all operations
|
|
164
|
+
* ```
|
|
165
|
+
*
|
|
166
|
+
* @example Processing components in generators
|
|
167
|
+
* ```typescript
|
|
168
|
+
* class ComponentProcessor {
|
|
169
|
+
* processDocument(document: OasDocument) {
|
|
170
|
+
* const components = document.components;
|
|
171
|
+
* if (!components) return;
|
|
172
|
+
*
|
|
173
|
+
* // Process all schemas
|
|
174
|
+
* if (components.schemas) {
|
|
175
|
+
* Object.entries(components.schemas).forEach(([name, schema]) => {
|
|
176
|
+
* if (schema.isRef()) {
|
|
177
|
+
* console.log(`Schema ${name} is a reference to ${schema.$ref}`);
|
|
178
|
+
* } else {
|
|
179
|
+
* console.log(`Schema ${name} is a direct definition`);
|
|
180
|
+
* }
|
|
181
|
+
* });
|
|
182
|
+
* }
|
|
24
183
|
*
|
|
25
|
-
*
|
|
184
|
+
* // Process parameters
|
|
185
|
+
* if (components.parameters) {
|
|
186
|
+
* Object.keys(components.parameters).forEach(paramName => {
|
|
187
|
+
* console.log(`Reusable parameter: ${paramName}`);
|
|
188
|
+
* });
|
|
189
|
+
* }
|
|
190
|
+
* }
|
|
191
|
+
* }
|
|
192
|
+
* ```
|
|
26
193
|
*/
|
|
27
194
|
export declare class OasComponents {
|
|
28
195
|
#private;
|
|
29
196
|
/** Static identifier property for OasComponents */
|
|
30
197
|
oasType: "components";
|
|
198
|
+
/**
|
|
199
|
+
* Creates a new OasComponents instance.
|
|
200
|
+
*
|
|
201
|
+
* @param fields - Component definitions (defaults to empty object)
|
|
202
|
+
*
|
|
203
|
+
* @example
|
|
204
|
+
* ```typescript
|
|
205
|
+
* const components = new OasComponents({
|
|
206
|
+
* schemas: {
|
|
207
|
+
* User: userSchema,
|
|
208
|
+
* Product: productSchema
|
|
209
|
+
* },
|
|
210
|
+
* responses: {
|
|
211
|
+
* NotFound: notFoundResponse
|
|
212
|
+
* }
|
|
213
|
+
* });
|
|
214
|
+
* ```
|
|
215
|
+
*/
|
|
31
216
|
constructor(fields?: ComponentsFields);
|
|
217
|
+
/**
|
|
218
|
+
* Gets all schema reference names.
|
|
219
|
+
*
|
|
220
|
+
* This method extracts the keys from the schemas object and returns them
|
|
221
|
+
* as an array of RefName types. Useful for iterating over all available
|
|
222
|
+
* schemas or checking schema availability.
|
|
223
|
+
*
|
|
224
|
+
* @returns Array of reference names for all schemas
|
|
225
|
+
*
|
|
226
|
+
* @example
|
|
227
|
+
* ```typescript
|
|
228
|
+
* const components = new OasComponents({
|
|
229
|
+
* schemas: {
|
|
230
|
+
* User: userSchema,
|
|
231
|
+
* Product: productSchema,
|
|
232
|
+
* Order: orderSchema
|
|
233
|
+
* }
|
|
234
|
+
* });
|
|
235
|
+
*
|
|
236
|
+
* const schemaNames = components.toSchemasRefNames();
|
|
237
|
+
* console.log(schemaNames); // ['User', 'Product', 'Order']
|
|
238
|
+
*
|
|
239
|
+
* // Use for processing
|
|
240
|
+
* schemaNames.forEach(name => {
|
|
241
|
+
* const schema = components.schemas?.[name];
|
|
242
|
+
* console.log(`Processing schema: ${name}`);
|
|
243
|
+
* });
|
|
244
|
+
* ```
|
|
245
|
+
*/
|
|
32
246
|
toSchemasRefNames(): RefName[];
|
|
33
247
|
/** Record holding re-usable {@link OasSchema} objects or Refs */
|
|
34
248
|
get schemas(): Record<RefName, OasSchema | OasRef<'schema'>> | undefined;
|
|
249
|
+
/**
|
|
250
|
+
* Removes a schema from the components and returns it.
|
|
251
|
+
*
|
|
252
|
+
* This method permanently removes a schema from the components object
|
|
253
|
+
* and returns the removed schema. This is useful during processing when
|
|
254
|
+
* you need to extract and handle specific schemas separately.
|
|
255
|
+
*
|
|
256
|
+
* @param refName - The reference name of the schema to remove
|
|
257
|
+
* @returns The removed schema object or reference
|
|
258
|
+
*
|
|
259
|
+
* @throws {Error} When the schema doesn't exist or schemas object is undefined
|
|
260
|
+
*
|
|
261
|
+
* @example
|
|
262
|
+
* ```typescript
|
|
263
|
+
* const components = new OasComponents({
|
|
264
|
+
* schemas: {
|
|
265
|
+
* User: userSchema,
|
|
266
|
+
* Product: productSchema,
|
|
267
|
+
* Internal: internalSchema
|
|
268
|
+
* }
|
|
269
|
+
* });
|
|
270
|
+
*
|
|
271
|
+
* // Remove internal schema that shouldn't be exposed
|
|
272
|
+
* const internalSchema = components.removeSchema('Internal');
|
|
273
|
+
* console.log('Removed internal schema');
|
|
274
|
+
*
|
|
275
|
+
* // Check remaining schemas
|
|
276
|
+
* const remainingSchemas = components.toSchemasRefNames();
|
|
277
|
+
* console.log(remainingSchemas); // ['User', 'Product']
|
|
278
|
+
*
|
|
279
|
+
* // Process removed schema separately
|
|
280
|
+
* if (!internalSchema.isRef()) {
|
|
281
|
+
* console.log('Processing internal schema privately');
|
|
282
|
+
* }
|
|
283
|
+
* ```
|
|
284
|
+
*/
|
|
35
285
|
removeSchema(refName: RefName): OasSchema | OasRef<'schema'>;
|
|
36
286
|
/** Record holding re-usable {@link OasResponse} objects or Refs */
|
|
37
287
|
get responses(): Record<RefName, OasResponse | OasRef<'response'>> | undefined;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"Components.d.ts","sourceRoot":"","sources":["../../../src/oas/components/Components.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AACjC,OAAO,yBAAyB,CAAC;AACjC,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,MAAM,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAA;AACrD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sCAAsC,CAAA;AAE7E,eAAO,MAAM,cAAc,UAQ1B,CAAA;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,OAAO,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAA;IAC7D,UAAU,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,CAAA;IAChE,QAAQ,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,UAAU,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAA;IAC1D,aAAa,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,cAAc,GAAG,MAAM,CAAC,aAAa,CAAC,CAAC,CAAA;IACvE,OAAO,CAAC,EAAE,MAAM,CAAC,OAAO,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAA;IACvD,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAAC,gBAAgB,CAAC,CAAC,CAAA;IAC9E,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC1C,CAAA;AAED
|
|
1
|
+
{"version":3,"file":"Components.d.ts","sourceRoot":"","sources":["../../../src/oas/components/Components.ts"],"names":[],"mappings":"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"}
|
|
@@ -15,6 +15,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
|
|
|
15
15
|
exports.OasComponents = exports.componentsKeys = void 0;
|
|
16
16
|
require("../../_dnt.polyfills.js");
|
|
17
17
|
require("../../_dnt.polyfills.js");
|
|
18
|
+
/**
|
|
19
|
+
* Available component types in an OpenAPI document.
|
|
20
|
+
*/
|
|
18
21
|
exports.componentsKeys = [
|
|
19
22
|
'schemas',
|
|
20
23
|
'responses',
|
|
@@ -24,11 +27,182 @@ exports.componentsKeys = [
|
|
|
24
27
|
'headers',
|
|
25
28
|
'securitySchemes'
|
|
26
29
|
];
|
|
27
|
-
/**
|
|
30
|
+
/**
|
|
31
|
+
* Represents the OpenAPI Components Object in the SKMTC OAS processing system.
|
|
32
|
+
*
|
|
33
|
+
* The `OasComponents` class manages the reusable components section of an OpenAPI
|
|
34
|
+
* document, providing centralized access to shared schemas, responses, parameters,
|
|
35
|
+
* and other reusable elements that can be referenced throughout the API specification.
|
|
36
|
+
*
|
|
37
|
+
* This class serves as the central registry for all reusable components, enabling
|
|
38
|
+
* efficient reference resolution and reducing duplication in OpenAPI documents.
|
|
39
|
+
*
|
|
40
|
+
* ## Key Features
|
|
41
|
+
*
|
|
42
|
+
* - **Schema Management**: Central repository for reusable data schemas
|
|
43
|
+
* - **Response Reuse**: Common response definitions for consistent API responses
|
|
44
|
+
* - **Parameter Standardization**: Shared parameter definitions across operations
|
|
45
|
+
* - **Reference Resolution**: Support for internal references ($ref) to components
|
|
46
|
+
* - **Type Safety**: Strongly typed access to different component categories
|
|
47
|
+
* - **Extension Support**: Custom OpenAPI extension field handling
|
|
48
|
+
*
|
|
49
|
+
* @example Basic component access
|
|
50
|
+
* ```typescript
|
|
51
|
+
* import { OasComponents } from '@skmtc/core';
|
|
52
|
+
*
|
|
53
|
+
* // Typically created during document parsing
|
|
54
|
+
* const components = new OasComponents({
|
|
55
|
+
* schemas: {
|
|
56
|
+
* User: new OasObject({
|
|
57
|
+
* properties: {
|
|
58
|
+
* id: new OasString(),
|
|
59
|
+
* name: new OasString()
|
|
60
|
+
* }
|
|
61
|
+
* }),
|
|
62
|
+
* Product: new OasObject({
|
|
63
|
+
* properties: {
|
|
64
|
+
* id: new OasString(),
|
|
65
|
+
* price: new OasNumber()
|
|
66
|
+
* }
|
|
67
|
+
* })
|
|
68
|
+
* },
|
|
69
|
+
* responses: {
|
|
70
|
+
* NotFound: new OasResponse({
|
|
71
|
+
* description: '404 - Resource not found'
|
|
72
|
+
* })
|
|
73
|
+
* }
|
|
74
|
+
* });
|
|
75
|
+
*
|
|
76
|
+
* // Access schemas
|
|
77
|
+
* const userSchema = components.schemas?.['User'];
|
|
78
|
+
* const productSchema = components.schemas?.['Product'];
|
|
79
|
+
*
|
|
80
|
+
* // Access responses
|
|
81
|
+
* const notFoundResponse = components.responses?.['NotFound'];
|
|
82
|
+
* ```
|
|
83
|
+
*
|
|
84
|
+
* @example Schema management
|
|
85
|
+
* ```typescript
|
|
86
|
+
* // Get all schema reference names
|
|
87
|
+
* const schemaNames = components.toSchemasRefNames();
|
|
88
|
+
* console.log(schemaNames); // ['User', 'Product', 'Order']
|
|
89
|
+
*
|
|
90
|
+
* // Remove a schema (useful for processing)
|
|
91
|
+
* const removedSchema = components.removeSchema('ObsoleteSchema');
|
|
92
|
+
* console.log('Removed:', removedSchema);
|
|
93
|
+
*
|
|
94
|
+
* // Check remaining schemas
|
|
95
|
+
* const remainingSchemas = components.toSchemasRefNames();
|
|
96
|
+
* console.log('Remaining:', remainingSchemas);
|
|
97
|
+
* ```
|
|
98
|
+
*
|
|
99
|
+
* @example Parameter reuse
|
|
100
|
+
* ```typescript
|
|
101
|
+
* const components = new OasComponents({
|
|
102
|
+
* parameters: {
|
|
103
|
+
* PageSize: new OasParameter({
|
|
104
|
+
* name: 'pageSize',
|
|
105
|
+
* in: 'query',
|
|
106
|
+
* schema: new OasInteger({ minimum: 1, maximum: 100, default: 20 })
|
|
107
|
+
* }),
|
|
108
|
+
* PageNumber: new OasParameter({
|
|
109
|
+
* name: 'page',
|
|
110
|
+
* in: 'query',
|
|
111
|
+
* schema: new OasInteger({ minimum: 1, default: 1 })
|
|
112
|
+
* })
|
|
113
|
+
* }
|
|
114
|
+
* });
|
|
115
|
+
*
|
|
116
|
+
* // These parameters can be referenced in operations:
|
|
117
|
+
* // $ref: '#/components/parameters/PageSize'
|
|
118
|
+
* // $ref: '#/components/parameters/PageNumber'
|
|
119
|
+
* ```
|
|
120
|
+
*
|
|
121
|
+
* @example Response standardization
|
|
122
|
+
* ```typescript
|
|
123
|
+
* const components = new OasComponents({
|
|
124
|
+
* responses: {
|
|
125
|
+
* Success: new OasResponse({
|
|
126
|
+
* description: 'Successful operation',
|
|
127
|
+
* content: {
|
|
128
|
+
* 'application/json': {
|
|
129
|
+
* schema: new OasObject({
|
|
130
|
+
* properties: {
|
|
131
|
+
* success: new OasBoolean({ default: true }),
|
|
132
|
+
* data: new OasObject({ additionalProperties: true })
|
|
133
|
+
* }
|
|
134
|
+
* })
|
|
135
|
+
* }
|
|
136
|
+
* }
|
|
137
|
+
* }),
|
|
138
|
+
* ValidationError: new OasResponse({
|
|
139
|
+
* description: 'Validation failed',
|
|
140
|
+
* content: {
|
|
141
|
+
* 'application/json': {
|
|
142
|
+
* schema: new OasObject({
|
|
143
|
+
* properties: {
|
|
144
|
+
* error: new OasString(),
|
|
145
|
+
* details: new OasArray({
|
|
146
|
+
* items: new OasString()
|
|
147
|
+
* })
|
|
148
|
+
* }
|
|
149
|
+
* })
|
|
150
|
+
* }
|
|
151
|
+
* }
|
|
152
|
+
* })
|
|
153
|
+
* }
|
|
154
|
+
* });
|
|
155
|
+
*
|
|
156
|
+
* // Standardized responses across all operations
|
|
157
|
+
* ```
|
|
158
|
+
*
|
|
159
|
+
* @example Processing components in generators
|
|
160
|
+
* ```typescript
|
|
161
|
+
* class ComponentProcessor {
|
|
162
|
+
* processDocument(document: OasDocument) {
|
|
163
|
+
* const components = document.components;
|
|
164
|
+
* if (!components) return;
|
|
165
|
+
*
|
|
166
|
+
* // Process all schemas
|
|
167
|
+
* if (components.schemas) {
|
|
168
|
+
* Object.entries(components.schemas).forEach(([name, schema]) => {
|
|
169
|
+
* if (schema.isRef()) {
|
|
170
|
+
* console.log(`Schema ${name} is a reference to ${schema.$ref}`);
|
|
171
|
+
* } else {
|
|
172
|
+
* console.log(`Schema ${name} is a direct definition`);
|
|
173
|
+
* }
|
|
174
|
+
* });
|
|
175
|
+
* }
|
|
28
176
|
*
|
|
29
|
-
*
|
|
177
|
+
* // Process parameters
|
|
178
|
+
* if (components.parameters) {
|
|
179
|
+
* Object.keys(components.parameters).forEach(paramName => {
|
|
180
|
+
* console.log(`Reusable parameter: ${paramName}`);
|
|
181
|
+
* });
|
|
182
|
+
* }
|
|
183
|
+
* }
|
|
184
|
+
* }
|
|
185
|
+
* ```
|
|
30
186
|
*/
|
|
31
187
|
class OasComponents {
|
|
188
|
+
/**
|
|
189
|
+
* Creates a new OasComponents instance.
|
|
190
|
+
*
|
|
191
|
+
* @param fields - Component definitions (defaults to empty object)
|
|
192
|
+
*
|
|
193
|
+
* @example
|
|
194
|
+
* ```typescript
|
|
195
|
+
* const components = new OasComponents({
|
|
196
|
+
* schemas: {
|
|
197
|
+
* User: userSchema,
|
|
198
|
+
* Product: productSchema
|
|
199
|
+
* },
|
|
200
|
+
* responses: {
|
|
201
|
+
* NotFound: notFoundResponse
|
|
202
|
+
* }
|
|
203
|
+
* });
|
|
204
|
+
* ```
|
|
205
|
+
*/
|
|
32
206
|
constructor(fields = {}) {
|
|
33
207
|
/** Static identifier property for OasComponents */
|
|
34
208
|
Object.defineProperty(this, "oasType", {
|
|
@@ -41,6 +215,35 @@ class OasComponents {
|
|
|
41
215
|
_OasComponents_fields.set(this, void 0);
|
|
42
216
|
__classPrivateFieldSet(this, _OasComponents_fields, fields, "f");
|
|
43
217
|
}
|
|
218
|
+
/**
|
|
219
|
+
* Gets all schema reference names.
|
|
220
|
+
*
|
|
221
|
+
* This method extracts the keys from the schemas object and returns them
|
|
222
|
+
* as an array of RefName types. Useful for iterating over all available
|
|
223
|
+
* schemas or checking schema availability.
|
|
224
|
+
*
|
|
225
|
+
* @returns Array of reference names for all schemas
|
|
226
|
+
*
|
|
227
|
+
* @example
|
|
228
|
+
* ```typescript
|
|
229
|
+
* const components = new OasComponents({
|
|
230
|
+
* schemas: {
|
|
231
|
+
* User: userSchema,
|
|
232
|
+
* Product: productSchema,
|
|
233
|
+
* Order: orderSchema
|
|
234
|
+
* }
|
|
235
|
+
* });
|
|
236
|
+
*
|
|
237
|
+
* const schemaNames = components.toSchemasRefNames();
|
|
238
|
+
* console.log(schemaNames); // ['User', 'Product', 'Order']
|
|
239
|
+
*
|
|
240
|
+
* // Use for processing
|
|
241
|
+
* schemaNames.forEach(name => {
|
|
242
|
+
* const schema = components.schemas?.[name];
|
|
243
|
+
* console.log(`Processing schema: ${name}`);
|
|
244
|
+
* });
|
|
245
|
+
* ```
|
|
246
|
+
*/
|
|
44
247
|
toSchemasRefNames() {
|
|
45
248
|
return Object.keys(__classPrivateFieldGet(this, _OasComponents_fields, "f").schemas ?? {});
|
|
46
249
|
}
|
|
@@ -48,6 +251,42 @@ class OasComponents {
|
|
|
48
251
|
get schemas() {
|
|
49
252
|
return __classPrivateFieldGet(this, _OasComponents_fields, "f").schemas;
|
|
50
253
|
}
|
|
254
|
+
/**
|
|
255
|
+
* Removes a schema from the components and returns it.
|
|
256
|
+
*
|
|
257
|
+
* This method permanently removes a schema from the components object
|
|
258
|
+
* and returns the removed schema. This is useful during processing when
|
|
259
|
+
* you need to extract and handle specific schemas separately.
|
|
260
|
+
*
|
|
261
|
+
* @param refName - The reference name of the schema to remove
|
|
262
|
+
* @returns The removed schema object or reference
|
|
263
|
+
*
|
|
264
|
+
* @throws {Error} When the schema doesn't exist or schemas object is undefined
|
|
265
|
+
*
|
|
266
|
+
* @example
|
|
267
|
+
* ```typescript
|
|
268
|
+
* const components = new OasComponents({
|
|
269
|
+
* schemas: {
|
|
270
|
+
* User: userSchema,
|
|
271
|
+
* Product: productSchema,
|
|
272
|
+
* Internal: internalSchema
|
|
273
|
+
* }
|
|
274
|
+
* });
|
|
275
|
+
*
|
|
276
|
+
* // Remove internal schema that shouldn't be exposed
|
|
277
|
+
* const internalSchema = components.removeSchema('Internal');
|
|
278
|
+
* console.log('Removed internal schema');
|
|
279
|
+
*
|
|
280
|
+
* // Check remaining schemas
|
|
281
|
+
* const remainingSchemas = components.toSchemasRefNames();
|
|
282
|
+
* console.log(remainingSchemas); // ['User', 'Product']
|
|
283
|
+
*
|
|
284
|
+
* // Process removed schema separately
|
|
285
|
+
* if (!internalSchema.isRef()) {
|
|
286
|
+
* console.log('Processing internal schema privately');
|
|
287
|
+
* }
|
|
288
|
+
* ```
|
|
289
|
+
*/
|
|
51
290
|
removeSchema(refName) {
|
|
52
291
|
const { [refName]: removed, ...rest } = __classPrivateFieldGet(this, _OasComponents_fields, "f").schemas;
|
|
53
292
|
__classPrivateFieldGet(this, _OasComponents_fields, "f").schemas = rest;
|
|
@@ -30,7 +30,113 @@ type ToRequestBodyMapArgs = {
|
|
|
30
30
|
schema: OasSchema | OasRef<'schema'>;
|
|
31
31
|
requestBody: OasRequestBody;
|
|
32
32
|
};
|
|
33
|
-
/**
|
|
33
|
+
/**
|
|
34
|
+
* Represents an OpenAPI Operation Object in the SKMTC OAS processing system.
|
|
35
|
+
*
|
|
36
|
+
* The `OasOperation` class encapsulates a single API operation (path + method combination)
|
|
37
|
+
* with all its associated metadata, parameters, request/response specifications, and
|
|
38
|
+
* security requirements. It provides utilities for extracting common operation data
|
|
39
|
+
* like success responses and request bodies.
|
|
40
|
+
*
|
|
41
|
+
* ## Key Features
|
|
42
|
+
*
|
|
43
|
+
* - **Path and Method**: Unique combination identifying the operation
|
|
44
|
+
* - **Metadata Access**: Operation ID, summary, description, tags, and deprecation status
|
|
45
|
+
* - **Parameter Handling**: Query, path, header, and cookie parameters
|
|
46
|
+
* - **Request/Response Specs**: Type-safe access to request body and response definitions
|
|
47
|
+
* - **Security Context**: Operation-specific security requirements
|
|
48
|
+
* - **Success Response Utils**: Helper methods to identify and extract successful responses
|
|
49
|
+
*
|
|
50
|
+
* @example Basic operation properties
|
|
51
|
+
* ```typescript
|
|
52
|
+
* import { OasOperation } from '@skmtc/core';
|
|
53
|
+
*
|
|
54
|
+
* // Typically created during document parsing
|
|
55
|
+
* const getUserOp = new OasOperation({
|
|
56
|
+
* path: '/users/{id}',
|
|
57
|
+
* method: 'get',
|
|
58
|
+
* operationId: 'getUserById',
|
|
59
|
+
* summary: 'Get user by ID',
|
|
60
|
+
* description: 'Retrieves a single user by their unique identifier',
|
|
61
|
+
* parameters: [
|
|
62
|
+
* // Path parameter for user ID
|
|
63
|
+
* { name: 'id', in: 'path', required: true, schema: { type: 'string' } }
|
|
64
|
+
* ],
|
|
65
|
+
* responses: {
|
|
66
|
+
* '200': { description: 'User found', content: { ... } },
|
|
67
|
+
* '404': { description: 'User not found' }
|
|
68
|
+
* }
|
|
69
|
+
* });
|
|
70
|
+
*
|
|
71
|
+
* console.log(getUserOp.path); // '/users/{id}'
|
|
72
|
+
* console.log(getUserOp.method); // 'get'
|
|
73
|
+
* console.log(getUserOp.operationId); // 'getUserById'
|
|
74
|
+
* ```
|
|
75
|
+
*
|
|
76
|
+
* @example Working with success responses
|
|
77
|
+
* ```typescript
|
|
78
|
+
* // Find the primary success response
|
|
79
|
+
* const successResponse = operation.toSuccessResponse();
|
|
80
|
+
* if (successResponse) {
|
|
81
|
+
* const resolved = successResponse.resolve();
|
|
82
|
+
* console.log('Success response:', resolved.description);
|
|
83
|
+
* }
|
|
84
|
+
*
|
|
85
|
+
* // Get the HTTP status code for success
|
|
86
|
+
* const successCode = operation.toSuccessResponseCode();
|
|
87
|
+
* console.log('Success status:', successCode); // '200', '201', 'default', etc.
|
|
88
|
+
* ```
|
|
89
|
+
*
|
|
90
|
+
* @example Extracting request body data
|
|
91
|
+
* ```typescript
|
|
92
|
+
* // Extract request body with custom transformation
|
|
93
|
+
* const requestData = operation.toRequestBody(({ schema, requestBody }) => {
|
|
94
|
+
* return {
|
|
95
|
+
* schema: schema,
|
|
96
|
+
* contentType: 'application/json',
|
|
97
|
+
* required: requestBody.required ?? false,
|
|
98
|
+
* description: requestBody.description
|
|
99
|
+
* };
|
|
100
|
+
* });
|
|
101
|
+
*
|
|
102
|
+
* if (requestData) {
|
|
103
|
+
* console.log('Request schema:', requestData.schema);
|
|
104
|
+
* console.log('Required:', requestData.required);
|
|
105
|
+
* }
|
|
106
|
+
* ```
|
|
107
|
+
*
|
|
108
|
+
* @example Parameter processing
|
|
109
|
+
* ```typescript
|
|
110
|
+
* // Process operation parameters by location
|
|
111
|
+
* const pathParams = operation.parameters?.filter(param => {
|
|
112
|
+
* const resolved = param.resolve();
|
|
113
|
+
* return resolved.in === 'path';
|
|
114
|
+
* });
|
|
115
|
+
*
|
|
116
|
+
* const queryParams = operation.parameters?.filter(param => {
|
|
117
|
+
* const resolved = param.resolve();
|
|
118
|
+
* return resolved.in === 'query';
|
|
119
|
+
* });
|
|
120
|
+
*
|
|
121
|
+
* console.log('Path parameters:', pathParams?.length);
|
|
122
|
+
* console.log('Query parameters:', queryParams?.length);
|
|
123
|
+
* ```
|
|
124
|
+
*
|
|
125
|
+
* @example Security requirements
|
|
126
|
+
* ```typescript
|
|
127
|
+
* if (operation.security) {
|
|
128
|
+
* console.log('Operation has specific security requirements');
|
|
129
|
+
* for (const requirement of operation.security) {
|
|
130
|
+
* // Process security schemes for this operation
|
|
131
|
+
* Object.keys(requirement.schemes).forEach(scheme => {
|
|
132
|
+
* console.log(`Security scheme: ${scheme}`);
|
|
133
|
+
* });
|
|
134
|
+
* }
|
|
135
|
+
* } else {
|
|
136
|
+
* console.log('Operation uses default document security');
|
|
137
|
+
* }
|
|
138
|
+
* ```
|
|
139
|
+
*/
|
|
34
140
|
export declare class OasOperation {
|
|
35
141
|
oasType: 'operation';
|
|
36
142
|
path: string;
|
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"Operation.d.ts","sourceRoot":"","sources":["../../../src/oas/operation/Operation.ts"],"names":[],"mappings":"AAAA,OAAO,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,uBAAuB,CAAA;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAA;AAC7D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAA;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,iCAAiC,CAAA;AAC3E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAC3C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC/C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,eAAe,CAAA;AAC9C,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,+CAA+C,CAAA;AAC3F,MAAM,MAAM,eAAe,GAAG;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,WAAW,GAAG,SAAS,CAAA;IACjC,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,OAAO,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC5B,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAA;IAC3B,WAAW,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAChC,UAAU,CAAC,EAAE,CAAC,YAAY,GAAG,MAAM,CAAC,WAAW,CAAC,CAAC,EAAE,GAAG,SAAS,CAAA;IAC/D,WAAW,CAAC,EAAE,cAAc,GAAG,MAAM,CAAC,aAAa,CAAC,GAAG,SAAS,CAAA;IAChE,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,GAAG,MAAM,CAAC,UAAU,CAAC,CAAC,CAAA;IAC3D,QAAQ,CAAC,EAAE,sBAAsB,EAAE,GAAG,SAAS,CAAA;IAC/C,UAAU,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;IAChC,eAAe,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC1C,CAAA;AAED,KAAK,oBAAoB,GAAG;IAC1B,MAAM,EAAE,SAAS,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAA;IACpC,WAAW,EAAE,cAAc,CAAA;CAC5B,CAAA;AAED
|
|
1
|
+
{"version":3,"file":"Operation.d.ts","sourceRoot":"","sources":["../../../src/oas/operation/Operation.ts"],"names":[],"mappings":"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"}
|