update

Author: omermecitoglu

src/core/app.ts

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export default function getAppName(): string {
+  try {
+    const filePath = path.resolve(process.cwd(), "package.json");
+    const content = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return data.name;
+  } catch (error) {
+    return "unknown-service";
+  }
+}

src/core/arguments.ts

@@ -1,11 +1,19 @@
 import yargs from "yargs";
 
-const argv = yargs.option("output", {
-  alias: "o",
-  describe: "Specify the output directory",
-  type: "string",
-  demandOption: false,
-}).argv;
+const argv = yargs
+  .option("source", {
+    alias: "s",
+    describe: "Specify the source directory",
+    type: "string",
+    demandOption: false,
+  })
+  .option("output", {
+    alias: "o",
+    describe: "Specify the output directory",
+    type: "string",
+    demandOption: false,
+  })
+  .argv;
 
 export default async function getArgument(name: string) {
   const a = argv instanceof Promise ? await argv : argv;

src/core/renderers/interface.ts

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

src/core/resolvers/operation.ts

@@ -27,7 +27,7 @@ export default function resolveOperations(paths: OpenAPI["paths"]) {
     name: operation.operationId,
     method: method.toUpperCase(),
     path: quotePathName(path, operation.parameters ?? []),
-    parameters: resolveOperationParams(operation, true).join(", "),
+    parameters: resolveOperationParams(operation, false).join(", "),
     searchParams: getSearchParams(operation.parameters ?? []),
     responses: resolveResponses(operation.responses),
   }));

src/core/resolvers/response.ts

@@ -21,6 +21,6 @@ function handleResponse(statusCode: string, response: Operation["responses"]["20
 
 export function resolveResponses(responses: Operation["responses"]) {
   return Object.entries(responses).map(([statusCode, response]) => (
-    `case ${statusCode}: ${handleResponse(statusCode, response, true)};`
+    `case ${statusCode}: ${handleResponse(statusCode, response, false)};`
   ));
 }

src/core/source.ts

@@ -1,8 +1,21 @@
+import path from "node:path";
+import swaggerJsdoc from "swagger-jsdoc";
+import getAppVersion from "./version";
 import type { OpenAPI } from "./openapi";
 
-export default 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 OpenAPI;
+export default function generateSwaggerJson(sourcePath: string,) {
+  const spec = swaggerJsdoc({
+    apis: [
+      path.resolve(sourcePath, "**", "*.ts"),
+      path.resolve(sourcePath, "**", "*.js"),
+    ],
+    definition: {
+      openapi: "3.0.0",
+      info: {
+        title: "Next.js API",
+        version: getAppVersion(),
+      },
+    },
+  });
+  return spec as OpenAPI;
 }

src/core/swagger.ts

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export default function getAppVersion(): string {
+  try {
+    const filePath = path.resolve(process.cwd(), "package.json");
+    const content = fs.readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    return data.version;
+  } catch (error) {
+    return "?.?.?";
+  }
+}

src/core/version.ts

@@ -1,34 +1,40 @@
 import "~/core/renderers/operation";
 import "~/core/renderers/parameter";
 import path from "node:path";
+import getAppName from "./core/app";
 import getArgument from "./core/arguments";
 import createFile from "./core/file";
 import generateInterface from "./core/renderers/interface";
 import generateSchema from "./core/renderers/schema";
 import { resolveSchemas, resolveSchemasFromProps } from "./core/resolvers/imported-schema";
 import resolveOperations from "./core/resolvers/operation";
 import resolveProperties from "./core/resolvers/property";
-import readSource from "./core/source";
-import getSwaggerJSON from "./core/swagger";
+import generateSwaggerJson from "./core/swagger";
 
 (async () => {
-  const outputFolder = await getArgument("output") ?? "src";
+  const sourceFolder = await getArgument("source") ?? "src";
+  const sourceDir = path.resolve(process.cwd(), sourceFolder);
+
+  const outputFolder = await getArgument("output") ?? "dist";
   const outputDir = path.resolve(process.cwd(), outputFolder);
 
-  const source = await readSource();
-  for (const service of source.services) {
-    const data = await getSwaggerJSON(service.url, service.specs);
-    for (const [schemaName, schema] of Object.entries(data.components.schemas)) {
-      if (schema.type === "object") {
-        const properties = resolveProperties(schema.properties, schema.required ?? []);
-        const importedSchemas = resolveSchemasFromProps(schema.properties);
-        const content = generateSchema(schemaName, properties, importedSchemas);
-        await createFile(content, `${schemaName}.ts`, outputDir, "schemas");
-      }
+  const data = generateSwaggerJson(sourceDir);
+  for (const [schemaName, schema] of Object.entries(data.components.schemas)) {
+    if (schema.type === "object") {
+      const properties = resolveProperties(schema.properties, schema.required ?? []);
+      const importedSchemas = resolveSchemasFromProps(schema.properties);
+      const content = generateSchema(schemaName, properties, importedSchemas);
+      await createFile(content, `${schemaName}.ts`, outputDir, "schemas");
     }
-    const schemas = resolveSchemas(data.paths);
-    const paths = resolveOperations(data.paths);
-    const content = generateInterface(service.url, schemas, paths);
-    await createFile(content, `${service.name}.ts`, outputDir);
   }
+
+  const packageName = getAppName();
+  const appName = packageName.split("/").pop() ?? "unknown-service";
+  const envName = `${appName.replace(/-/g, "_").toUpperCase()}_BASE_URL`;
+
+  const schemas = resolveSchemas(data.paths);
+  const resolvedPaths = resolveOperations(data.paths);
+
+  const content = generateInterface(envName, resolvedPaths);
+  await createFile(content, "index.js", outputDir);
 })();

src/index.ts

@@ -1,10 +1,10 @@
-{{#each schemas}}
-import type {{this}} from "./schemas/{{this}}";
-{{/each}}
-
-const BASE_URL = "{{baseUrl}}";
-
+function createURL(endPoint) {
+  if (!process.env.{{envName}}) {
+    throw new Error("Base URL is not defined for this service! Please add {{envName}} to the environment variables.");
+  }
+  return new URL(endPoint, process.env.{{envName}});
+}
 {{#each operations}}
-{{> operation }}
 
+{{> operation }}
 {{/each}}