update

Author: omermecitoglu

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@omer-x/ts-openapi-interface-generator",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "description": "OpenAPI interface generator for TypeScript",
   "keywords": [
     "typescript",

package.json

@@ -2,7 +2,7 @@ import yargs from "yargs";
 
 const argv = yargs.option("output", {
   alias: "o",
-  describe: "Specify the output directry",
+  describe: "Specify the output directory",
   type: "string",
   demandOption: false,
 }).argv;

src/core/arguments.ts

@@ -0,0 +1,9 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+export default async function createFile(content: string, fileName: string, outputDir: string, targetFolder = ".") {
+  const targetPath = path.resolve(outputDir, targetFolder);
+  await fs.mkdir(targetPath, { recursive: true });
+  const filePath = path.resolve(targetPath, fileName);
+  await fs.writeFile(filePath, content);
+}

src/core/file.ts

@@ -1,9 +1,3 @@
-type SchemaComponent = {
-  type: "object" | "unknown",
-  properties: Record<string, SchemaDefinition>,
-  required?: string[],
-};
-
 export type SchemaDefinition = {
   type?: "string" | "number" | "array" | "object",
   format?: "date" | "unknown",
@@ -15,18 +9,24 @@ export type SchemaDefinition = {
   enum?: (string | null)[],
 };
 
-export type PathParameter = {
+type SchemaComponent = {
+  type: "object" | "unknown",
+  properties: Record<string, SchemaDefinition>,
+  required?: string[],
+};
+
+export type OperationParameter = {
   in: "path" | "query" | "header" | "cookie",
   name: string,
   description: string,
   required: boolean,
   schema: SchemaDefinition,
 };
 
-export type RequestBody = {
+type RequestBody = {
   description: string,
   required: boolean,
-  content: Record<ContentType, ResponseContent>,
+  content: Content,
 };
 
 type ResponseContent = {
@@ -35,33 +35,29 @@ type ResponseContent = {
 
 type ContentType = "application/json" | "text/plain";
 
-export type HttpResponse = {
+export type Content = Record<ContentType, ResponseContent>;
+
+type HttpResponse = {
   description: string,
-  content?: Record<ContentType, ResponseContent>,
+  content?: Content,
 };
 
 type HttpCode = "200" | "404";
 
-export type ApiPath = {
-  summary: string,
+export type Operation = {
   operationId: string,
-  parameters?: PathParameter[],
+  summary: string,
+  description: string,
+  parameters?: OperationParameter[],
   requestBody?: RequestBody,
   responses: Record<HttpCode, HttpResponse>,
 };
 
-export type HttpMethod = "get" | "post" | "patch" | "put" | "delete";
+type HttpMethod = "get" | "post" | "patch" | "put" | "delete";
 
-type OpenApiSpecification = {
+export type OpenAPI = {
   components: {
     schemas: Record<string, SchemaComponent>,
   },
-  paths: Record<string, Record<HttpMethod, ApiPath>>,
+  paths: Record<string, Record<HttpMethod, Operation>>,
 };
-
-export async function getSwaggerJSON(base: string, specs?: string) {
-  const url = new URL(specs ?? "/swagger", base);
-  const response = await fetch(url);
-  const data = await response.json();
-  return data as OpenApiSpecification;
-}

src/core/interface.ts

@@ -0,0 +1,18 @@
+import Handlebars from "handlebars";
+import type { OperationTemplate } from "~/core/resolvers/operation";
+import interfaceTemplate from "~/templates/interface.hbs";
+
+type InterfaceTemplate = {
+  baseUrl: string,
+  schemas: string[],
+  operations: OperationTemplate[],
+};
+
+export default function generateInterface(baseUrl: string, schemas: string[], operations: OperationTemplate[]) {
+  const template = Handlebars.compile<InterfaceTemplate>(interfaceTemplate);
+  return template({
+    baseUrl,
+    schemas,
+    operations,
+  });
+}

src/core/openapi.ts

@@ -0,0 +1,8 @@
+import Handlebars from "handlebars";
+import operationTemplate from "~/templates/operation.hbs";
+
+Handlebars.registerHelper("hasRequestBody", (input: string[]) => {
+  return input.includes("requestBody");
+});
+
+Handlebars.registerPartial("operation", operationTemplate);

src/core/operation.ts

@@ -0,0 +1,4 @@
+import Handlebars from "handlebars";
+import searchParamTemplate from "~/templates/search-param.hbs";
+
+Handlebars.registerPartial("searchParam", searchParamTemplate);

src/core/parameters.ts

@@ -0,0 +1,18 @@
+import type { ModelProperty } from "~/core/resolvers/property";
+import getTemplate from "~/core/template";
+import schemaTemplate from "~/templates/schema.hbs";
+
+type SchemaTemplate = {
+  importedSchemas: string[],
+  name: string,
+  properties: ModelProperty[],
+};
+
+export default function generateSchema(name: string, properties: ModelProperty[], importedSchemas: string[]) {
+  const template = getTemplate<SchemaTemplate>(schemaTemplate);
+  return template({
+    name,
+    properties,
+    importedSchemas,
+  });
+}

src/core/renderers/interface.ts

@@ -0,0 +1,5 @@
+import type { Content } from "~/core/openapi";
+
+export default function getContentSchema(content: Content) {
+  return content["application/json"].schema;
+}

src/core/renderers/operation.ts

@@ -0,0 +1,17 @@
+import type { OpenAPI } from "~/core/openapi";
+
+type ResolvedEndpoint = {
+  method: keyof OpenAPI["paths"][string],
+  path: keyof OpenAPI["paths"],
+  operation: OpenAPI["paths"][string]["get"],
+};
+
+export default function resolveEndpoints(paths: OpenAPI["paths"]) {
+  return Object.entries(paths).map(([path, methods]) => {
+    return Object.entries(methods).map<ResolvedEndpoint>(([method, operation]) => ({
+      method: method as keyof OpenAPI["paths"][string],
+      path,
+      operation,
+    }));
+  }).flat();
+}

src/core/renderers/parameter.ts

@@ -1,12 +1,14 @@
+import type { OpenAPI, Operation, SchemaDefinition } from "~/core/openapi";
+import getContentSchema from "./content";
+import resolveEndpoints from "./enpoint";
 import { filterGenericSchemas, resolveSchema, simplifySchema } from "./schema-definition";
-import type { ApiPath, HttpMethod, HttpResponse, RequestBody, SchemaDefinition } from "./openapi";
 
-function resolveRequestSchemas(requestBody?: RequestBody) {
+function resolveRequestSchemas(requestBody: Operation["requestBody"]) {
   if (!requestBody) return [];
-  return [resolveSchema(requestBody.content["application/json"].schema)];
+  return [resolveSchema(getContentSchema(requestBody.content))];
 }
 
-function resolveResponseSchemas(responses: Record<string, HttpResponse>) {
+function resolveResponseSchemas(responses: Operation["responses"]) {
   return Object.values(responses).map(response => {
     const resolvedSchemas = Object.values(response.content ?? {}).map(content => {
       return simplifySchema(resolveSchema(content.schema));
@@ -15,15 +17,11 @@ function resolveResponseSchemas(responses: Record<string, HttpResponse>) {
   }).flat();
 }
 
-export function resolveSchemas(paths: Record<string, Record<HttpMethod, ApiPath>>) {
-  const collection = Object.values(paths).map(methods => {
-    return Object.values(methods).map(path => {
-      return [
-        ...resolveRequestSchemas(path.requestBody),
-        ...resolveResponseSchemas(path.responses),
-      ];
-    }).flat();
-  }).flat();
+export function resolveSchemas(paths: OpenAPI["paths"]) {
+  const collection = resolveEndpoints(paths).map(({ operation }) => ([
+    ...resolveRequestSchemas(operation.requestBody),
+    ...resolveResponseSchemas(operation.responses),
+  ])).flat();
   return Array.from(new Set(collection)).toSorted();
 }
 

src/core/renderers/schema.ts

@@ -0,0 +1,30 @@
+import type { Operation, OperationParameter } from "~/core/openapi";
+import { resolveSchema } from "~/core/resolvers/schema-definition";
+import getContentSchema from "./content";
+
+function resolveParam(param: OperationParameter, typescript: boolean) {
+  if (!typescript) return param.name;
+  return `${param.name}${param.required ? "" : "?"}: ${resolveSchema(param.schema)}`;
+}
+
+function resolveRequestBody(body: Exclude<Operation["requestBody"], undefined>, typescript: boolean) {
+  if (!typescript) return "requestBody";
+  return `requestBody${body.required ? "" : "?"}: ${resolveSchema(getContentSchema(body.content))}`;
+}
+
+function sortRequiredParamsFirst(paramA: OperationParameter, paramB: OperationParameter) {
+  if (paramA.required === paramB.required) return 0;
+  return paramA.required ? -1 : 1;
+}
+
+export function resolveOperationParams(operation: Operation, typescript: boolean) {
+  const resolvedParams = (operation.parameters ?? [])
+    .filter(param => param.in === "path" || param.in === "query")
+    .toSorted(sortRequiredParamsFirst)
+    .map(p => resolveParam(p, typescript));
+  const collection = [
+    ...resolvedParams,
+  ];
+  if (operation.requestBody) collection.push(resolveRequestBody(operation.requestBody, typescript));
+  return collection;
+}