@xyd-js/openapi 0.1.0-xyd.11 → 0.1.0-xyd.13

package/src/examples.ts

@@ -1,116 +0,0 @@
-import {OpenAPIV3} from "openapi-types";
-import Oas from "oas";
-// @ts-ignore
-import {Operation} from 'oas/operation'; // TODO: fix ts
-import oasToSnippet from "@readme/oas-to-snippet";
-import OpenAPISampler from "openapi-sampler";
-import type {JSONSchema7} from "json-schema";
-
-import {ExampleGroup, Example} from "@xyd-js/uniform";
-
-// TODO: option with another languages
-// TODO: uniform plugins
-// TODO: fs uniform plugins
-export function oapExamples(
-    oas: Oas,
-    operation: Operation
-): ExampleGroup[] {
-    const exampleGroups: ExampleGroup[] = []
-
-    if (operation.schema.requestBody) {
-        const body = operation.schema.requestBody as OpenAPIV3.RequestBodyObject
-        const schema = fixAllOfBug(
-            body.content["application/json"].schema as JSONSchema7
-        )
-
-        if (!schema) {
-            return exampleGroups
-        }
-
-        const fakeData = OpenAPISampler.sample(schema)
-
-        // TODO: snippet languages options
-        const {code} = oasToSnippet(oas, operation, {
-            body: fakeData
-        }, null, "shell");
-
-        const examples: Example[] = []
-
-        examples.push({
-            codeblock: {
-                tabs: [{
-                    title: "curl",
-                    language: "curl",
-                    code: code || "",
-                }]
-            }
-        })
-
-        exampleGroups.push({
-            description: "Example request",
-            examples
-        })
-    }
-
-    if (operation.schema.responses) {
-        const responses = operation.schema.responses as OpenAPIV3.ResponsesObject
-
-        const examples: Example[] = []
-
-        Object.entries(responses).forEach(([status, r]) => {
-            const response = r as OpenAPIV3.ResponseObject
-            const schema = response?.content?.["application/json"].schema as JSONSchema7
-
-            if (!schema) {
-                return
-            }
-
-            const fakeData = OpenAPISampler.sample(schema)
-
-            examples.push({
-                codeblock: {
-                    title: status,
-                    tabs: [{
-                        title: "json",
-                        language: "json",
-                        code: JSON.stringify(fakeData, null, 2) || "",
-                    }]
-                }
-            })
-        })
-
-        exampleGroups.push({
-            description: "Response",
-            examples
-        })
-    }
-
-    return exampleGroups
-}
-
-/*
-fixAllOfBug fixes below case:
-
-```yaml
-  allOf:
-    - $ref: '#/components/schemas/SomeSchema'
-    - type: object
-      required:
-      properties:
-```
-*/
-function fixAllOfBug(schema: JSONSchema7) {
-    const modifiedSchema = {...schema}
-
-    if (schema.allOf) {
-        schema.allOf.forEach((prop, i) => {
-            const propObj = prop as object
-
-            if ("properties" in propObj && !propObj["properties"]) {
-                delete modifiedSchema.allOf?.[i]
-            }
-        })
-    }
-
-    return modifiedSchema
-}

package/src/paths.ts

@@ -1,103 +0,0 @@
-import {OpenAPIV3} from "openapi-types";
-import {Definition, ExampleGroup, Reference, ReferenceCategory} from "@xyd-js/uniform";
-
-import {oapParametersToDefinitionProperties} from "./parameters";
-import {oapRequestBodyToDefinitionProperties} from "./requestBody";
-import {oapResponseToDefinitionProperties} from "./responses";
-import {
-    httpMethodToUniformMethod,
-    toPascalCase
-} from "./utils";
-
-// oapPathToReference converts an OpenAPI path to a uniform Reference
-export function oapPathToReference(
-    httpMethod: "get" | "put" | "post" | "delete" | "patch", // TODO: ts type
-    path: string,
-    oapPath: OpenAPIV3.PathItemObject,
-): Reference | null {
-    const mType = httpMethodToUniformMethod(httpMethod)
-
-    if (!mType) {
-        console.error(`Unsupported method v222: ${httpMethod}`)
-        return null
-    }
-
-    const definitions: Definition[] = []
-    const exampleGroups: ExampleGroup[] = []
-
-    const oapMethod = oapPath?.[httpMethod] as OpenAPIV3.OperationObject
-
-    if (!oapMethod) {
-        return null
-    }
-
-    const endpointRef: Reference = {
-        title: oapMethod?.summary || "",
-        canonical: toPascalCase(oapMethod?.summary || ""),
-        description: oapMethod?.description || "",
-
-        category: ReferenceCategory.REST,
-        type: mType,
-
-        context: {
-            method: httpMethod,
-
-            path: `${encodeURIComponent(path)}`,
-        },
-
-        examples: {
-            groups: exampleGroups,
-        },
-        definitions: definitions,
-    }
-
-    if (oapMethod.parameters) {
-        const parameters = oapMethod.parameters as OpenAPIV3.ParameterObject[]
-
-        const paramtersMap = oapParametersToDefinitionProperties(parameters) // TODO: finish
-
-        Object.entries(paramtersMap).forEach(([key, definitionProperties]) => {
-            let title: string
-
-            switch (key) {
-                case 'path':
-                    title = "Path parameters"
-                    break
-                case 'query':
-                    title = "Query"
-                    break
-                case 'header':
-                    title = "Header"
-                    break
-                default:
-                    console.error(`Unsupported parameter type: ${key} for ${httpMethod} ${path}`)
-                    return
-            }
-
-            definitions.push({
-                title,
-                properties: definitionProperties
-            })
-        })
-    }
-
-    if (oapMethod.requestBody) {
-        const reqBody = oapMethod.requestBody as OpenAPIV3.RequestBodyObject
-
-        definitions.push({
-            title: 'Request body',
-            properties: oapRequestBodyToDefinitionProperties(reqBody) || []
-        })
-    }
-
-    if (oapMethod.responses) {
-        const responses = oapMethod.responses as OpenAPIV3.ResponsesObject
-
-        definitions.push({
-            title: 'Response',
-            properties: oapResponseToDefinitionProperties(responses) || []
-        })
-    }
-
-    return endpointRef
-}

package/src/properties.ts

@@ -1,37 +0,0 @@
-import {OpenAPIV3} from "openapi-types";
-import {DefinitionProperty} from "@xyd-js/uniform";
-
-// schemaObjectToDefinitionProperties converts OpenAPI schema object to uniform DefinitionProperty[]
-export function schemaObjectToDefinitionProperties(v: OpenAPIV3.SchemaObject): DefinitionProperty[] {
-    return Object.entries(v.properties || {}).map(([name, prop]) => {
-        let objProp = prop as OpenAPIV3.SchemaObject
-
-        let merged: DefinitionProperty[] = []
-
-        if (objProp.allOf) {
-            merged = objProp.allOf.reduce((acc, of) => {
-                return [
-                    ...acc,
-                    ...schemaObjectToDefinitionProperties(of as OpenAPIV3.SchemaObject)
-                ]
-            }, [] as DefinitionProperty[])
-        }
-
-        if (objProp.type === "array") {
-            const items = objProp.items as OpenAPIV3.SchemaObject
-
-            merged = schemaObjectToDefinitionProperties(items)
-        }
-
-        return {
-            name: name,
-            type: objProp.type || "",
-            description: objProp.description || "",
-            properties: (
-                merged?.length
-                    ? merged
-                    : objProp.properties ? schemaObjectToDefinitionProperties(objProp) : []
-            )
-        }
-    })
-}

package/src/responses.ts

@@ -1,38 +0,0 @@
-import {OpenAPIV3} from "openapi-types";
-import {DefinitionProperty} from "@xyd-js/uniform";
-
-import {schemaObjectToDefinitionProperties} from "./properties";
-
-export function oapResponseToDefinitionProperties(
-    responses: OpenAPIV3.ResponsesObject
-): DefinitionProperty[] | null {
-    let schemaObject: OpenAPIV3.SchemaObject | undefined
-    // TODO: support another statuses
-    if (responses["default"]) {
-        const w = responses["default"] as OpenAPIV3.ResponseObject
-
-        schemaObject = w?.content?.['application/json']?.schema as OpenAPIV3.SchemaObject
-    } else if (responses["200"]) {
-        const w = responses["200"] as OpenAPIV3.ResponseObject
-
-        schemaObject = w?.content?.['application/json']?.schema as OpenAPIV3.SchemaObject
-    }
-
-    if (!schemaObject) {
-        return null
-    }
-
-    switch (schemaObject.type) {
-        case 'array':
-            const arrSchema = schemaObject as OpenAPIV3.ArraySchemaObject
-
-            const items = arrSchema.items as OpenAPIV3.SchemaObject
-
-            schemaObject = items
-            break
-        default:
-            break
-    }
-
-    return schemaObjectToDefinitionProperties(schemaObject)
-}

package/src/schema.ts

@@ -1,62 +0,0 @@
-import {OpenAPIV3} from "openapi-types";
-import Oas from "oas";
-
-import type {Reference, OpenAPIReferenceContext} from "@xyd-js/uniform";
-
-import {SUPPORTED_HTTP_METHODS} from "./const";
-import {oapPathToReference} from "./paths";
-import {oapExamples} from "./examples";
-
-// TODO: support one-of
-// TODO: support $ref - currently we use $refParser.dereference that converts $ref into objects
-// TODO: better method check system - currently we need to manually check that in few methods
-
-// oapSchemaToReferences converts an OpenAPI schema to a list of uniform References
-export function oapSchemaToReferences(
-    schema: OpenAPIV3.Document
-): Reference[] {
-    const references: Reference[] = [];
-    const oas = new Oas(schema as any);
-
-    const server = schema.servers?.[0]?.url || ""
-
-    Object.entries(schema.paths).forEach(([path, oapPath]) => {
-        SUPPORTED_HTTP_METHODS.forEach((eachMethod) => {
-            const httpMethod = eachMethod.toLowerCase()
-
-            switch (httpMethod) {
-                case 'get':
-                    break
-                case 'put':
-                    break
-                case 'post':
-                    break
-                case 'delete':
-                    break
-                case 'patch':
-                    break
-                default:
-                    console.error(`Unsupported method v111: ${httpMethod}`)
-                    return
-            }
-
-            const reference = oapPathToReference(
-                httpMethod,
-                path,
-                oapPath as OpenAPIV3.PathItemObject
-            )
-
-            if (reference) {
-                const ctx = reference.context as OpenAPIReferenceContext
-                ctx.path = `${encodeURIComponent(server)}${encodeURIComponent(path)}` // TODO: it should be inside `oapPathToReference` ?
-
-                const operation = oas.operation(path, httpMethod);
-                reference.examples.groups = oapExamples(oas, operation)
-
-                references.push(reference)
-            }
-        })
-    })
-
-    return references
-}