oas
Version:
Comprehensive tooling for working with OpenAPI definitions
255 lines (253 loc) • 8.21 kB
JavaScript
import {
Oas
} from "../chunk-R52B7CL7.js";
import "../chunk-3ZQFQFIG.js";
import {
query,
refizePointer
} from "../chunk-CKC36IL7.js";
import "../chunk-65ZD6K3I.js";
import "../chunk-S27IGTVG.js";
import "../chunk-PSNTODZL.js";
// src/analyzer/queries/openapi.ts
function additionalProperties(definition) {
return query(["$..additionalProperties"], definition).map((res) => refizePointer(res.pointer));
}
function callbacks(definition) {
return query(["$.components.callbacks", "$.paths.*[?(@.callbacks)].callbacks"], definition).map(
(res) => refizePointer(res.pointer)
);
}
async function circularRefs(definition) {
const oas = new Oas(structuredClone(definition));
await oas.dereference();
const results = oas.getCircularReferences();
results.sort();
return results;
}
function commonParameters(definition) {
return query(["$..paths[*].parameters"], definition).map((res) => refizePointer(res.pointer));
}
function discriminators(definition) {
return query(["$..discriminator"], definition).map((res) => refizePointer(res.pointer));
}
async function fileSize(definition) {
const oas = new Oas(structuredClone(definition));
const originalSizeInBytes = Buffer.from(JSON.stringify(oas.api)).length;
const raw = Number((originalSizeInBytes / (1024 * 1024)).toFixed(2));
await oas.dereference();
let dereferenced;
try {
const dereferencedSizeInBytes = Buffer.from(JSON.stringify(oas.api)).length;
dereferenced = Number((dereferencedSizeInBytes / (1024 * 1024)).toFixed(2));
} catch (err) {
if (err instanceof RangeError) {
dereferenced = NaN;
} else {
throw err;
}
}
return { raw, dereferenced };
}
function links(definition) {
return query(["$.components.links", "$.paths..responses.*.links"], definition).map((res) => refizePointer(res.pointer));
}
function mediaTypes(definition) {
const results = Array.from(
new Set(
query(["$..paths..content"], definition).flatMap((res) => {
return Object.keys(res.value);
})
)
);
results.sort();
return results;
}
function parameterSerialization(definition) {
return query(["$..parameters[*].style^"], definition).map((res) => refizePointer(res.pointer));
}
function polymorphism(definition) {
const results = Array.from(
new Set(query(["$..allOf^", "$..anyOf^", "$..oneOf^"], definition).map((res) => refizePointer(res.pointer)))
);
results.sort();
return results;
}
function references(definition) {
return query(["$..$ref^"], definition).map((res) => refizePointer(res.pointer));
}
function refNames(definition) {
return query(["$..['x-readme-ref-name']"], definition).map((res) => refizePointer(res.pointer));
}
function securityTypes(definition) {
return Array.from(new Set(query(["$.components.securitySchemes..type"], definition).map((res) => res.value)));
}
function serverVariables(definition) {
return query(["$.servers..variables^"], definition).map((res) => refizePointer(res.pointer));
}
function totalOperations(definition) {
return query(["$..paths[*]"], definition).flatMap((res) => Object.keys(res.value)).length;
}
function webhooks(definition) {
return query(["$.webhooks[*]"], definition).map((res) => refizePointer(res.pointer));
}
function xmlRequests(definition) {
return query(
[
"$..requestBody..['application/xml']",
"$..requestBody..['application/xml-external-parsed-entity']",
"$..requestBody..['application/xml-dtd']",
"$..requestBody..['text/xml']",
"$..requestBody..['text/xml-external-parsed-entity']",
"$..requestBody.content[?(@property.match(/\\+xml$/i))]"
],
definition
).map((res) => refizePointer(res.pointer));
}
function xmlResponses(definition) {
return query(
[
"$..responses..['application/xml']",
"$..responses..['application/xml-external-parsed-entity']",
"$..responses..['application/xml-dtd']",
"$..responses..['text/xml']",
"$..responses..['text/xml-external-parsed-entity']",
"$..responses[*].content[?(@property.match(/\\+xml$/i))]"
],
definition
).map((res) => refizePointer(res.pointer));
}
function xmlSchemas(definition) {
return query(["$.components.schemas..xml^", "$..parameters..xml^", "$..requestBody..xml^"], definition).map(
(res) => refizePointer(res.pointer)
);
}
// src/analyzer/index.ts
async function analyzer(definition) {
const additionalProperties2 = additionalProperties(definition);
const callbacks2 = callbacks(definition);
const circularRefs2 = await circularRefs(definition);
const commonParameters2 = commonParameters(definition);
const discriminators2 = discriminators(definition);
const { raw: rawFileSize, dereferenced: dereferencedFileSize } = await fileSize(definition);
const links2 = links(definition);
const parameterSerialization2 = parameterSerialization(definition);
const polymorphism2 = polymorphism(definition);
const references2 = references(definition);
const refNames2 = refNames(definition);
const serverVariables2 = serverVariables(definition);
const xmlSchemas2 = xmlSchemas(definition);
const xmlRequests2 = xmlRequests(definition);
const xmlResponses2 = xmlResponses(definition);
const webhooks2 = webhooks(definition);
const analysis = {
general: {
dereferencedFileSize: {
name: "Dereferenced File Size",
found: dereferencedFileSize
},
mediaTypes: {
name: "Media Type",
found: mediaTypes(definition)
},
operationTotal: {
name: "Operation",
found: totalOperations(definition)
},
rawFileSize: {
name: "Raw File Size",
found: rawFileSize
},
securityTypes: {
name: "Security Type",
found: securityTypes(definition)
}
},
openapi: {
additionalProperties: {
present: !!additionalProperties2.length,
locations: additionalProperties2
},
callbacks: {
present: !!callbacks2.length,
locations: callbacks2
},
circularRefs: {
present: !!circularRefs2.length,
locations: circularRefs2
},
commonParameters: {
present: !!commonParameters2.length,
locations: commonParameters2
},
discriminators: {
present: !!discriminators2.length,
locations: discriminators2
},
links: {
present: !!links2.length,
locations: links2
},
style: {
present: !!parameterSerialization2.length,
locations: parameterSerialization2
},
polymorphism: {
present: !!polymorphism2.length,
locations: polymorphism2
},
references: {
present: !!references2.length,
locations: references2
},
refNames: {
present: !!refNames2.length,
locations: refNames2
},
serverVariables: {
present: !!serverVariables2.length,
locations: serverVariables2
},
xmlRequests: {
present: !!xmlRequests2.length,
locations: xmlRequests2
},
xmlResponses: {
present: !!xmlResponses2.length,
locations: xmlResponses2
},
xmlSchemas: {
present: !!xmlSchemas2.length,
locations: xmlSchemas2
},
webhooks: {
present: !!webhooks2.length,
locations: webhooks2
}
}
};
return analysis;
}
export {
additionalProperties as analyzeAdditionalProperties,
callbacks as analyzeCallbacks,
circularRefs as analyzeCircularRefs,
commonParameters as analyzeCommonParameters,
discriminators as analyzeDiscriminators,
fileSize as analyzeFileSize,
links as analyzeLinks,
mediaTypes as analyzeMediaTypes,
parameterSerialization as analyzeParameterSerialization,
polymorphism as analyzePolymorphism,
refNames as analyzeRefNames,
references as analyzeReferences,
securityTypes as analyzeSecurityTypes,
serverVariables as analyzeServerVariables,
totalOperations as analyzeTotalOperations,
webhooks as analyzeWebhooks,
xmlRequests as analyzeXMLRequests,
xmlResponses as analyzeXMLResponses,
xmlSchemas as analyzeXMLSchemas,
analyzer
};
//# sourceMappingURL=index.js.map