oas/dist/analyzer/index.js

Comprehensive tooling for working with OpenAPI definitions

import {
  Oas
} from "../chunk-36L32E7W.js";
import "../chunk-HGHW4JSM.js";
import "../chunk-W2TD4LSC.js";
import "../chunk-5KFARTQ3.js";
import "../chunk-L2OVXZK3.js";
import "../chunk-DPTPURCR.js";
import {
  query,
  refizePointer
} from "../chunk-CKC36IL7.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"], definition).map((res) => refizePointer(res.pointer));
}
async function circularRefs(definition) {
  const oas = new Oas(JSON.parse(JSON.stringify(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));
}
function links(definition) {
  return query(["$..links"], definition).map((res) => refizePointer(res.pointer));
}
function mediaTypes(definition) {
  const results = Array.from(
    new Set(
      query(["$..paths..content"], definition).map((res) => {
        return Object.keys(res.value);
      }).flat()
    )
  );
  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 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).map((res) => Object.keys(res.value)).flat().length;
}
function webhooks(definition) {
  return query(["$.webhooks[*]"], definition).map((res) => refizePointer(res.pointer));
}
function xml(definition) {
  return query(
    [
      "$.components.schemas..xml^",
      "$..parameters..xml^",
      "$..requestBody..xml^",
      "$..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))]",
      "$..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));
}

// src/analyzer/queries/readme.ts
function authDefaults(definition) {
  return query(["$.components.securitySchemes..['x-default']^"], definition).map((res) => refizePointer(res.pointer));
}
function codeSampleLanguages(definition) {
  const results = Array.from(
    new Set(
      query(["$..['x-readme']['samples-languages']", "$..['x-samples-languages']"], definition).map((res) => res.value).reduce((prev, next) => prev.concat(next), [])
    )
  );
  results.sort();
  return results;
}
function codeSamplesDisabled(definition) {
  return Array.from(
    new Set(
      query(
        [
          "$['x-samples-enabled']^",
          "$['x-readme']['samples-enabled']",
          "$..paths[*]..['x-samples-enabled']^",
          "$..paths[*]..['x-readme']['samples-enabled']^^"
        ],
        definition
      ).map((res) => refizePointer(res.pointer))
    )
  );
}
function corsProxyDisabled(definition) {
  return Array.from(
    new Set(
      query(
        [
          "$['x-proxy-enabled']^",
          "$['x-readme']['proxy-enabled']",
          "$..paths[*]..['x-proxy-enabled']^",
          "$..paths[*]..['x-readme']['proxy-enabled']^^"
        ],
        definition
      ).map((res) => refizePointer(res.pointer))
    )
  );
}
function customCodeSamples(definition) {
  return query(["$..['x-code-samples']", "$..['x-readme']['code-samples']"], definition).filter((res) => {
    return Array.isArray(res.value) && res.value.length ? res : false;
  }).map((res) => refizePointer(res.pointer));
}
function explorerDisabled(definition) {
  return query(
    [
      "$['x-explorer-enabled']^",
      "$['x-readme']['explorer-enabled']",
      "$..paths[*]..['x-explorer-enabled']^",
      "$..paths[*]..['x-readme']['explorer-enabled']^^"
    ],
    definition
  ).map((res) => refizePointer(res.pointer));
}
function rawBody(definition) {
  return query(["$..RAW_BODY^^"], definition).map((res) => refizePointer(res.pointer));
}
function staticHeaders(definition) {
  return query(["$..['x-headers']", "$..['x-readme']['headers']"], definition).filter((res) => {
    return Array.isArray(res.value) && res.value.length ? res : false;
  }).map((res) => refizePointer(res.pointer));
}
function refNames(definition) {
  return query(["$..['x-readme-ref-name']"], 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 links2 = links(definition);
  const parameterSerialization2 = parameterSerialization(definition);
  const polymorphism2 = polymorphism(definition);
  const serverVariables2 = serverVariables(definition);
  const webhooks2 = webhooks(definition);
  const xml2 = xml(definition);
  const authDefaults2 = authDefaults(definition);
  const codeSampleLanguages2 = codeSampleLanguages(definition);
  const customCodeSamples2 = customCodeSamples(definition);
  const codeSamplesDisabled2 = codeSamplesDisabled(definition);
  const disabledCorsProxy = corsProxyDisabled(definition);
  const explorerDisabled2 = explorerDisabled(definition);
  const staticHeaders2 = staticHeaders(definition);
  const rawBody2 = rawBody(definition);
  const refNames2 = refNames(definition);
  const analysis = {
    general: {
      mediaTypes: {
        name: "Media Type",
        found: mediaTypes(definition)
      },
      operationTotal: {
        name: "Operation",
        found: totalOperations(definition)
      },
      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
      },
      serverVariables: {
        present: !!serverVariables2.length,
        locations: serverVariables2
      },
      webhooks: {
        present: !!webhooks2.length,
        locations: webhooks2
      },
      xml: {
        present: !!xml2.length,
        locations: xml2
      }
    },
    readme: {
      "x-default": {
        present: !!authDefaults2.length,
        locations: authDefaults2
      },
      "x-readme.code-samples": {
        present: !!customCodeSamples2.length,
        locations: customCodeSamples2
      },
      "x-readme.headers": {
        present: !!staticHeaders2.length,
        locations: staticHeaders2
      },
      "x-readme.explorer-enabled": {
        present: !!explorerDisabled2.length,
        locations: explorerDisabled2
      },
      "x-readme.proxy-enabled": {
        present: !!disabledCorsProxy.length,
        locations: disabledCorsProxy
      },
      "x-readme.samples-languages": {
        present: !!codeSampleLanguages2.length,
        locations: codeSampleLanguages2
      },
      "x-readme-ref-name": {
        present: !!refNames2.length,
        locations: refNames2
      }
    }
  };
  if (codeSamplesDisabled2.length) {
    analysis.readme["x-readme.samples-enabled"] = {
      present: !!codeSamplesDisabled2.length,
      locations: codeSamplesDisabled2
    };
  }
  if (rawBody2.length) {
    analysis.readme.raw_body = {
      present: !!rawBody2.length,
      locations: rawBody2
    };
  }
  return analysis;
}
export {
  analyzer as default
};
//# sourceMappingURL=index.js.map