update types

Author: omermecitoglu

src/core/form-data.ts

@@ -1,6 +1,8 @@
-import type { Operation } from "./openapi";
+import { getBodyRequest } from "./resolvers/body-request";
+import type { OperationObject } from "@omer-x/openapi-types/operation";
 
-export function hasFormData(operation: Operation) {
+export function hasFormData(operation: OperationObject) {
   if (!operation.requestBody) return false;
-  return "multipart/form-data" in operation.requestBody.content;
+  const body = getBodyRequest(operation.requestBody);
+  return "multipart/form-data" in body.content;
 }

src/core/openapi.ts

@@ -1,15 +1,15 @@
-import type { OpenAPI } from "~/core/openapi";
 import { type DeclaredOperation, resolveDeclaredOperations } from "~/core/resolvers/declared-operation";
 import { resolveSchemas } from "~/core/resolvers/imported-schema";
 import getTemplate from "~/core/template";
 import declarationTemplate from "~/templates/declaration.hbs";
+import type { PathsObject } from "@omer-x/openapi-types/paths";
 
 type DeclarationTemplate = {
   importedSchemas: string[],
   operations: DeclaredOperation[],
 };
 
-export default function generateDeclaration(paths: OpenAPI["paths"], framework: string | null) {
+export default function generateDeclaration(paths: PathsObject, framework: string | null) {
   const template = getTemplate<DeclarationTemplate>(declarationTemplate);
   return template({
     importedSchemas: resolveSchemas(paths),

src/core/renderers/declaration.ts

@@ -1,8 +1,8 @@
 import Handlebars from "handlebars";
-import type { OpenAPI } from "~/core/openapi";
 import { type DocumentedOperation, resolveDocumentedOperations } from "~/core/resolvers/documented-operation";
 import getTemplate from "~/core/template";
 import documentationTemplate from "~/templates/documentation.hbs";
+import type { PathsObject } from "@omer-x/openapi-types/paths";
 
 type DocumentationTemplate = {
   serviceName: string,
@@ -15,7 +15,7 @@ export default function generateDocumentation(
   serviceName: string,
   packageName: string,
   envName: string,
-  paths: OpenAPI["paths"]
+  paths: PathsObject
 ) {
   const template = getTemplate<DocumentationTemplate>(documentationTemplate);
   return template({

src/core/renderers/documentation.ts

@@ -0,0 +1,7 @@
+import type { ReferenceObject } from "@omer-x/openapi-types/reference";
+import type { RequestBodyObject } from "@omer-x/openapi-types/request-body";
+
+export function getBodyRequest(source: RequestBodyObject | ReferenceObject) {
+  if ("$ref" in source) throw new Error("Request Body references not implemented yet.");
+  return source;
+}

src/core/resolvers/body-request.ts

@@ -1,8 +1,8 @@
-import type { Content } from "~/core/openapi";
+import type { MediaTypeObject } from "@omer-x/openapi-types/media-type";
 
-export default function getContentSchema(content: Content) {
+export default function getContentSchema(content: Record<string, MediaTypeObject>) {
   if ("multipart/form-data" in content) {
     return content["multipart/form-data"].schema;
   }
-  return (content["application/json"] as Content["application/json"]).schema;
+  return content["application/json"].schema;
 }

src/core/resolvers/content.ts

@@ -1,25 +1,34 @@
-import type { OpenAPI, Operation } from "~/core/openapi";
 import getContentSchema from "./content";
 import resolveEndpoints from "./enpoint";
+import { defaultOperationName } from "./operation-name";
 import { resolveOperationParams } from "./operation-param";
+import { getResponse } from "./response";
 import { resolveSchema } from "./schema-definition";
+import type { PathsObject } from "@omer-x/openapi-types/paths";
+import type { ResponsesObject } from "@omer-x/openapi-types/response";
 
 export type DeclaredOperation = {
   name: string,
   parameters: string,
   result: string,
 };
 
-function resolveOperationResult(responses: Operation["responses"]) {
-  const schemas = Object.values(responses).map(response => {
-    return response.content ? resolveSchema(getContentSchema(response.content)) : null;
+function resolveOperationResult(responses?: ResponsesObject) {
+  if (!responses) return "unknown";
+  const schemas = Object.values(responses).map(resp => {
+    if (!resp) return null;
+    const response = getResponse(resp);
+    if (!response.content) return null;
+    const schema = getContentSchema(response.content);
+    if (!schema) return null;
+    return resolveSchema(schema);
   });
   return schemas.find(s => typeof s === "string") ?? "unknown";
 }
 
-export function resolveDeclaredOperations(paths: OpenAPI["paths"], framework: string | null) {
-  return resolveEndpoints(paths).map<DeclaredOperation>(({ method, operation }) => ({
-    name: operation.operationId,
+export function resolveDeclaredOperations(paths: PathsObject, framework: string | null) {
+  return resolveEndpoints(paths).map<DeclaredOperation>(({ method, path, operation }) => ({
+    name: operation.operationId || defaultOperationName(method, path),
     parameters: resolveOperationParams(operation, method, true, framework).join(", "),
     result: resolveOperationResult(operation.responses),
   }));

src/core/resolvers/declared-operation.ts

@@ -1,8 +1,11 @@
-import type { OpenAPI, Operation } from "~/core/openapi";
 import getContentSchema from "./content";
 import resolveEndpoints from "./enpoint";
+import { defaultOperationName } from "./operation-name";
+import { getParameter } from "./operation-param";
 import { resolveResponsesForDocs } from "./response";
 import { resolveSchema } from "./schema-definition";
+import type { PathsObject } from "@omer-x/openapi-types/paths";
+import type { ResponsesObject } from "@omer-x/openapi-types/response";
 
 type DocumentedParam = {
   name: string,
@@ -26,18 +29,21 @@ export type DocumentedOperation = {
   exceptions: DocumentedException[],
 };
 
-export function resolveDocumentedOperations(paths: OpenAPI["paths"]) {
-  return resolveEndpoints(paths).map<DocumentedOperation>(({ operation }) => {
-    const parameters = (operation.parameters ?? []).map<DocumentedParam>(p => ({
-      name: p.name,
-      description: p.description,
-      type: resolveSchema(p.schema),
-      optional: !p.required,
-    }));
+export function resolveDocumentedOperations(paths: PathsObject) {
+  return resolveEndpoints(paths).map<DocumentedOperation>(({ method, path, operation }) => {
+    const parameters = (operation.parameters ?? []).map<DocumentedParam>(p => {
+      const param = getParameter(p);
+      return {
+        name: param.name,
+        description: p.description || "missing description",
+        type: resolveSchema(param.schema),
+        optional: !param.required,
+      };
+    });
     return {
-      name: operation.operationId,
-      summary: operation.summary,
-      description: operation.description,
+      name: operation.operationId || defaultOperationName(method, path),
+      summary: operation.summary || "missing summary",
+      description: operation.description || "missing description",
       parameters: parameters.map(p => p.name).join(", "),
       parametersRaw: parameters,
       result: resolveOperationResult(operation.responses),
@@ -46,9 +52,13 @@ export function resolveDocumentedOperations(paths: OpenAPI["paths"]) {
   });
 }
 
-function resolveOperationResult(responses: Operation["responses"]) {
+function resolveOperationResult(responses?: ResponsesObject) {
+  if (!responses) return "unknown";
   const schemas = Object.values(responses).map(response => {
-    return response.content ? resolveSchema(getContentSchema(response.content)) : null;
+    if (response && "content" in response && response.content) {
+      return resolveSchema(getContentSchema(response.content));
+    }
+    return null;
   });
   return schemas.find(s => typeof s === "string") ?? "unknown";
 }

src/core/resolvers/documented-operation.ts

@@ -1,17 +1,21 @@
-import type { OpenAPI } from "~/core/openapi";
+import type { OperationObject } from "@omer-x/openapi-types/operation";
+import type { PathItemObject, PathsObject } from "@omer-x/openapi-types/paths";
 
 type ResolvedEndpoint = {
-  method: keyof OpenAPI["paths"][string],
-  path: keyof OpenAPI["paths"],
-  operation: OpenAPI["paths"][string]["get"],
+  method: keyof PathItemObject,
+  path: keyof PathsObject,
+  operation: OperationObject,
 };
 
-export default function resolveEndpoints(paths: OpenAPI["paths"]) {
+export default function resolveEndpoints(paths: PathsObject) {
   return Object.entries(paths).map(([path, methods]) => {
-    return Object.entries(methods).map<ResolvedEndpoint>(([method, operation]) => ({
-      method: method as keyof OpenAPI["paths"][string],
-      path,
-      operation,
-    }));
+    return Object.entries(methods).reduce((collection, [method, operation]) => {
+      if (typeof operation === "string" || Array.isArray(operation)) return collection;
+      return [...collection, {
+        method: method as keyof PathItemObject,
+        path,
+        operation,
+      }];
+    }, [] as ResolvedEndpoint[]);
   }).flat();
 }

src/core/resolvers/enpoint.ts

@@ -1,16 +1,25 @@
-import type { OpenAPI, Operation, SchemaDefinition } from "~/core/openapi";
 import { getTupleItems, isTuple } from "~/core/tuple";
+import { getBodyRequest } from "./body-request";
 import getContentSchema from "./content";
 import resolveEndpoints from "./enpoint";
+import { getResponse } from "./response";
 import { filterGenericSchemas, resolveSchema, simplifySchema } from "./schema-definition";
+import type { PathsObject } from "@omer-x/openapi-types/paths";
+import type { ReferenceObject } from "@omer-x/openapi-types/reference";
+import type { RequestBodyObject } from "@omer-x/openapi-types/request-body";
+import type { ResponsesObject } from "@omer-x/openapi-types/response";
+import type { SchemaObject } from "@omer-x/openapi-types/schema";
 
-function resolveRequestSchemas(requestBody: Operation["requestBody"]) {
-  if (!requestBody) return [];
+function resolveRequestSchemas(body?: RequestBodyObject | ReferenceObject) {
+  if (!body) return [];
+  const requestBody = getBodyRequest(body);
   return [resolveSchema(getContentSchema(requestBody.content))];
 }
 
-function resolveResponseSchemas(responses: Operation["responses"]) {
-  return Object.values(responses).map(response => {
+function resolveResponseSchemas(responses?: ResponsesObject) {
+  if (!responses) return [];
+  return Object.values(responses).map(resp => {
+    const response = getResponse(resp);
     return Object.values(response.content ?? {}).map(content => {
       return simplifySchema(resolveSchema(content.schema));
     }).flat();
@@ -26,7 +35,7 @@ function extractTuples(collection: string[]) {
   }).flat();
 }
 
-export function resolveSchemas(paths: OpenAPI["paths"]) {
+export function resolveSchemas(paths: PathsObject) {
   const collection = resolveEndpoints(paths).map(({ operation }) => ([
     ...resolveRequestSchemas(operation.requestBody),
     ...resolveResponseSchemas(operation.responses),
@@ -35,23 +44,23 @@ export function resolveSchemas(paths: OpenAPI["paths"]) {
   return filterGenericSchemas(uniqueCollection).toSorted();
 }
 
-function resolvePropDefinition(definition: SchemaDefinition) {
+function resolvePropDefinition(definition: SchemaObject) {
+  if (definition.$ref) {
+    return [definition.$ref.replace("#/components/schemas/", "")];
+  }
   if (definition.type === "array" && definition.items) {
     if (Array.isArray(definition.items)) {
       return definition.items.map<string[]>(resolvePropDefinition).flat();
     }
     return [resolveSchema(definition.items)];
   }
-  if (definition.$ref) {
-    return [definition.$ref.replace("#/components/schemas/", "")];
-  }
   if (definition.oneOf) {
     return definition.oneOf.map<string[]>(resolvePropDefinition).flat();
   }
   return [];
 }
 
-export function resolveSchemasFromProps(props: Record<string, SchemaDefinition>) {
+export function resolveSchemasFromProps(props: Record<string, SchemaObject>) {
   const collection = Object.values(props).map(resolvePropDefinition).flat();
   const uniqueCollection = Array.from(new Set(extractTuples(collection)));
   return filterGenericSchemas(uniqueCollection).toSorted();