feat: Update OpenAPI class to support adding multiple endpoints and enhance endpoint builder functionality

Author: GroophyLifefor

deno.json

@@ -1,7 +1,7 @@
 {
   "name": "@murat/openapi",
   "exports": "./mod.ts",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "tasks": {
     "lint": "deno lint",
     "test": "deno test --allow-all",

jsr.json

@@ -1,6 +1,6 @@
 {
   "name": "@murat/openapi",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "license": "MIT",
   "exports": "./mod.ts",
   "imports": {

src/Core.ts

@@ -1,27 +1,71 @@
 import type {
   OpenAPICore,
+  OpenAPIPathItem,
   OpenAPISecurityRequirement,
   OpenAPITag,
-} from "./Core.types.ts";
-import { createEndpointBuilder } from "./EndpointBuilder.ts";
-import { createEndpointPath, type EndpointPath } from "./EndpointPath.ts";
-import type { AllowedLicenses } from "./Licenses.types.ts";
+} from './Core.types.ts';
+import { createEndpointBuilder, EndpointBuilder } from './EndpointBuilder.ts';
+import { createEndpointPath, type EndpointPath } from './EndpointPath.ts';
+import type { AllowedLicenses } from './Licenses.types.ts';
 
 class OpenAPI {
   private raw: OpenAPICore;
+  private endpoints: EndpointBuilder[];
 
   constructor() {
     this.raw = {
-      openapi: "3.1.0",
+      openapi: '3.1.0',
       info: {
-        title: "OpenAPI 3.1.0",
-        version: "1.0.0",
+        title: 'OpenAPI 3.1.0',
+        version: '1.0.0',
       },
     };
+    this.endpoints = [];
   }
 
   getJSON(): OpenAPICore {
-    return this.raw;
+    // Create a deep copy of the raw object
+    const result = JSON.parse(JSON.stringify(this.raw)) as OpenAPICore;
+
+    // Process and group endpoints by path
+    if (this.endpoints.length > 0) {
+      if (!result.paths) {
+        result.paths = {};
+      }
+
+      for (const endpoint of this.endpoints) {
+        if (!endpoint.path || !endpoint.method) {
+          console.warn(
+            'Endpoint is missing path or method, skipping',
+            endpoint
+          );
+          continue;
+        }
+
+        if (!result.paths[endpoint.path]) {
+          result.paths[endpoint.path] = {} as OpenAPIPathItem;
+        }
+
+        const pathItem = result.paths[endpoint.path] as OpenAPIPathItem;
+        pathItem[endpoint.method as keyof OpenAPIPathItem] =
+          // deno-lint-ignore no-explicit-any
+          endpoint.operation as any;
+      }
+    }
+
+    return result;
+  }
+
+  // Add an array of endpoints
+  addEndpoints(endpoints: EndpointBuilder[]): this {
+    this.endpoints.push(...endpoints);
+    return this;
+  }
+
+  // Add a single endpoint
+  addEndpoint(endpoint: EndpointBuilder): this {
+    this.endpoints.push(endpoint);
+    return this;
   }
 
   setTitle(title: string): this {
@@ -63,19 +107,19 @@ class OpenAPI {
   }
 
   setLicenseName(name: string): this {
-    this.raw.info.license = this.raw.info.license || { name: "" };
+    this.raw.info.license = this.raw.info.license || { name: '' };
     this.raw.info.license.name = name;
     return this;
   }
 
   setLicenseUrl(url: string): this {
-    this.raw.info.license = this.raw.info.license || { name: "" };
+    this.raw.info.license = this.raw.info.license || { name: '' };
     this.raw.info.license.url = url;
     return this;
   }
 
   setLicenseIdentifier(identifier: AllowedLicenses): this {
-    this.raw.info.license = this.raw.info.license || { name: "" };
+    this.raw.info.license = this.raw.info.license || { name: '' };
     this.raw.info.license.identifier = identifier;
     return this;
   }
@@ -104,7 +148,7 @@ class OpenAPI {
   }
 
   setSecurity(scheme: {
-    type: "apiKey" | "http" | "oauth2" | "openIdConnect";
+    type: 'apiKey' | 'http' | 'oauth2' | 'openIdConnect';
     name: string;
     scopes?: string[];
   }): this {
@@ -157,6 +201,7 @@ export { createEndpointBuilder, createEndpointPath, OpenAPI };
 
 // const openAPI = new OpenAPI();
 
+// // OLD USAGE
 // openAPI
 //   .setTitle('My API')
 //   .setVersion('1.0.0')
@@ -233,3 +278,30 @@ export { createEndpointBuilder, createEndpointPath, OpenAPI };
 //           })
 //       )
 //   );
+
+// // NEW USAGE
+// const endpoint1 = createEndpointBuilder()
+//   .setMethod('get')
+//   .setPath('/tasks')
+//   .setSummary('Get Tasks');
+
+// const endpoint2 = createEndpointBuilder()
+//   .setMethod('post')
+//   .setPath('/tasks')
+//   .setSummary('Create Task')
+//   .setRequestBody(
+//     {
+//       'application/json': {
+//         schema: {
+//           type: 'object',
+//           properties: {
+//             title: { type: 'string' },
+//             completed: { type: 'boolean' },
+//           },
+//         },
+//       },
+//     },
+//     true
+//   );
+
+// openAPI.addEndpoints([endpoint1, endpoint2]);

src/EndpointBuilder.ts

@@ -5,13 +5,25 @@ import type {
 
 class EndpointBuilder {
   method: string;
+  path: string;
   operation: OpenAPIOperation;
 
-  constructor(method: string) {
-    this.method = method;
+  constructor(method?: string) {
+    this.method = method || "";
+    this.path = "";
     this.operation = {} as OpenAPIOperation;
   }
 
+  setMethod(method: string): this {
+    this.method = method.toLowerCase();
+    return this;
+  }
+
+  setPath(path: string): this {
+    this.path = path;
+    return this;
+  }
+
   setOperationId(operationId: string): this {
     this.operation.operationId = operationId;
     return this;
@@ -106,7 +118,7 @@ class EndpointBuilder {
 }
 
 function createEndpointBuilder(
-  method: string,
+  method?: string,
 ): EndpointBuilder {
   return new EndpointBuilder(method);
 }

src/EndpointPath.ts

@@ -53,8 +53,8 @@ class EndpointPath {
       );
     }
 
-    // deno-lint-ignore no-explicit-any
     this.pathItem[builder.method as keyof OpenAPIPathItem] = builder
+      // deno-lint-ignore no-explicit-any
       .operation as any;
     return this;
   }

test/new_usage_test.ts

@@ -0,0 +1,112 @@
+import { createEndpointBuilder, OpenAPI } from "../src/Core.ts";
+import { assertEquals } from "@std/assert";
+
+Deno.test("New usage with individual endpoints", () => {
+  const api = new OpenAPI()
+    .setTitle("Tasks API")
+    .setVersion("1.0.0");
+
+  const endpoint1 = createEndpointBuilder()
+    .setMethod('get')
+    .setPath('/tasks')
+    .setSummary('Get Tasks')
+    .setOperationId('getTasks')
+    .setResponses({
+      200: {
+        description: "Success response",
+        content: {
+          "application/json": {
+            schema: {
+              type: "array",
+              items: {
+                type: "object",
+                properties: {
+                  id: { type: "string" },
+                  title: { type: "string" },
+                  completed: { type: "boolean" },
+                },
+              },
+            },
+          },
+        },
+      },
+    });
+
+  const endpoint2 = createEndpointBuilder()
+    .setMethod('post')
+    .setPath('/tasks')
+    .setSummary('Create Task')
+    .setOperationId('createTask')
+    .setRequestBody(
+      {
+        'application/json': {
+          schema: {
+            type: 'object',
+            properties: {
+              title: { type: 'string' },
+              completed: { type: 'boolean' },
+            },
+          },
+        },
+      },
+      true
+    )
+    .setResponses({
+      201: {
+        description: "Task created",
+      },
+    });
+
+  // Add endpoint with different path
+  const endpoint3 = createEndpointBuilder()
+    .setMethod('get')
+    .setPath('/tasks/{taskId}')
+    .setSummary('Get Task by ID')
+    .setOperationId('getTaskById')
+    .setParameter('taskId', 'path', true, 'Task identifier')
+    .setResponses({
+      200: {
+        description: "Task details",
+      },
+      404: {
+        description: "Task not found",
+      },
+    });
+
+  api.addEndpoints([endpoint1, endpoint2, endpoint3]);
+
+  const result = api.getJSON();
+
+  // Verify that we have two distinct paths
+  assertEquals(Object.keys(result.paths || {}).length, 2);
+  
+  // Check that /tasks has both GET and POST methods
+  // deno-lint-ignore no-explicit-any
+  const tasksPath = result.paths?.['/tasks'] as any;
+  assertEquals(typeof tasksPath?.get, 'object');
+  assertEquals(typeof tasksPath?.post, 'object');
+  assertEquals(tasksPath?.get?.operationId, 'getTasks');
+  assertEquals(tasksPath?.post?.operationId, 'createTask');
+  
+  // Check that /tasks/{taskId} has GET method
+  // deno-lint-ignore no-explicit-any
+  const taskByIdPath = result.paths?.['/tasks/{taskId}'] as any;
+  assertEquals(typeof taskByIdPath?.get, 'object');
+  assertEquals(taskByIdPath?.get?.operationId, 'getTaskById');
+});
+
+Deno.test("Adding a single endpoint works", () => {
+  const api = new OpenAPI();
+  
+  api.addEndpoint(
+    createEndpointBuilder()
+      .setMethod('get')
+      .setPath('/users')
+      .setOperationId('getUsers')
+  );
+  
+  // deno-lint-ignore no-explicit-any
+  const result = api.getJSON() as any;
+  assertEquals(typeof result.paths?.['/users']?.get, 'object');
+  assertEquals(result.paths?.['/users']?.get?.operationId, 'getUsers');
+});