Removing DependsOnMethod

CHANGELOG.md

@@ -4,7 +4,20 @@
 
 ### v26.0.0
 
-- TODO: Add stuff here
+- `DependsOnMethod` removed: use flat syntax with explicit method and a slash;
+
+```patch
+  const routing: Routing = {
+-   "/v1/users": new DependsOnMethod({
++   "/v1/users": {
+-     get: getUserEndpoint,
++     "get /": getUserEndpoint,
+-   }).nest({
+      create: makeUserEndpoint
+-   }),
++   },
+  };
+```
 
 ## Version 25
 

README.md

@@ -280,7 +280,7 @@ in one place, illustrating how you can structure your API using whichever method
 architecture — or even mix them seamlessly.
 
 ```ts
-import { Routing, DependsOnMethod, ServeStatic } from "express-zod-api";
+import { Routing, ServeStatic } from "express-zod-api";
 
 const routing: Routing = {
   // flat syntax — /v1/users
@@ -298,12 +298,12 @@ const routing: Routing = {
     // mixed syntax with explicit method — /v1/user/:id
     "delete /user/:id": deleteUserEndpoint,
     // method-based routing — /v1/account
-    account: new DependsOnMethod({
-      get: endpointA,
-      delete: endpointA,
-      post: endpointB,
-      patch: endpointB,
-    }),
+    account: {
+      "get /": endpointA,
+      "delete /": endpointA,
+      "post /": endpointB,
+      "patch /": endpointB,
+    },
   },
   // static file serving — /public serves files from ./assets
   public: new ServeStatic("assets", {
@@ -1175,11 +1175,11 @@ new Documentation({
 ## Deprecated schemas and routes
 
 As your API evolves, you may need to mark some parameters or routes as deprecated before deleting them. For this
-purpose, the `.deprecated()` method is available on each schema, `Endpoint` and `DependsOnMethod`, it's immutable.
+purpose, the `.deprecated()` method is available on each schema and `Endpoint`, it's immutable.
 You can also deprecate all routes the `Endpoint` assigned to by setting `EndpointsFactory::build({ deprecated: true })`.
 
 ```ts
-import { Routing, DependsOnMethod } from "express-zod-api";
+import { Routing } from "express-zod-api";
 import { z } from "zod";
 
 const someEndpoint = factory.build({
@@ -1191,8 +1191,7 @@ const someEndpoint = factory.build({
 
 const routing: Routing = {
   v1: oldEndpoint.deprecated(), // deprecates the /v1 path
-  v2: new DependsOnMethod({ get: oldEndpoint }).deprecated(), // deprecates the /v2 path
-  v3: someEndpoint, // the path is assigned with initially deprecated endpoint (also deprecated)
+  v2: someEndpoint, // the path is assigned with initially deprecated endpoint (also deprecated)
 };
 ```
 

example/routing.ts

@@ -1,4 +1,4 @@
-import { DependsOnMethod, Routing, ServeStatic } from "express-zod-api";
+import { Routing, ServeStatic } from "express-zod-api";
 import { rawAcceptingEndpoint } from "./endpoints/accept-raw";
 import { createUserEndpoint } from "./endpoints/create-user";
 import { deleteUserEndpoint } from "./endpoints/delete-user";
@@ -16,12 +16,12 @@ export const routing: Routing = {
     user: {
       // syntax 1: methods are defined within the endpoint
       retrieve: retrieveUserEndpoint, // path: /v1/user/retrieve
-      // syntax 2: methods are defined within the route (id is the route path param by the way)
-      ":id": new DependsOnMethod({
-        patch: updateUserEndpoint, // demonstrates authentication
-      }).nest({
+      // id is the route path param
+      ":id": {
         remove: deleteUserEndpoint, // nested path: /v1/user/:id/remove
-      }),
+        // syntax 2: methods are defined within the route
+        "patch /": updateUserEndpoint, // demonstrates authentication
+      },
       // demonstrates different response schemas depending on status code
       create: createUserEndpoint,
       // this one demonstrates the legacy array based response

express-zod-api/src/endpoint.ts

@@ -27,8 +27,8 @@ import { AbstractMiddleware, ExpressMiddleware } from "./middleware";
 import { ContentType } from "./content-type";
 import { ezRawBrand } from "./raw-schema";
 import { DiscriminatedResult, pullResponseExamples } from "./result-helpers";
-import { Routable } from "./routable";
 import { AbstractResultHandler } from "./result-handler";
+import type { Routing } from "./routing";
 import { Security } from "./security";
 import { ezUploadBrand } from "./upload-schema";
 
@@ -41,7 +41,13 @@ export type Handler<IN, OUT, OPT> = (params: {
   logger: ActualLogger;
 }) => Promise<OUT>;
 
-export abstract class AbstractEndpoint extends Routable {
+export abstract class AbstractEndpoint {
+  /** @desc Enables nested routes within the path assigned to the subject */
+  public nest(routing: Routing): Routing {
+    return Object.assign(routing, { "": this });
+  }
+  /** @desc Marks the route as deprecated (makes a copy of the endpoint) */
+  public abstract deprecated(): this;
   public abstract execute(params: {
     request: Request;
     response: Response;

express-zod-api/src/endpoints-factory.ts

@@ -52,8 +52,7 @@ interface BuildProps<
   operationId?: string | ((method: ClientMethod) => string);
   /**
    * @desc HTTP method(s) this endpoint can handle
-   * @default "get" unless the Endpoint is assigned within DependsOnMethod
-   * @see DependsOnMethod
+   * @default "get" unless method is explicitly defined by Routing
    * */
   method?: Method | [Method, ...Method[]];
   /**

express-zod-api/src/index.ts

@@ -14,7 +14,6 @@ export {
   defaultResultHandler,
   arrayResultHandler,
 } from "./result-handler";
-export { DependsOnMethod } from "./depends-on-method";
 export { ServeStatic } from "./serve-static";
 export { createServer, attachRouting } from "./server";
 export { Documentation } from "./documentation";

express-zod-api/src/routing-walker.ts

@@ -1,4 +1,3 @@
-import { DependsOnMethod } from "./depends-on-method";
 import { AbstractEndpoint } from "./endpoint";
 import { RoutingError } from "./errors";
 import { ClientMethod, isMethod, Method } from "./method";
@@ -98,13 +97,6 @@ export const walkRouting = ({
       if (explicitMethod) prohibit(explicitMethod, path);
       if (element instanceof ServeStatic) {
         if (onStatic) element.apply(path, onStatic);
-      } else if (element instanceof DependsOnMethod) {
-        for (const [method, endpoint] of element.entries) {
-          const { methods } = endpoint;
-          checkDuplicate(method, path, visited);
-          checkMethodSupported(method, path, methods);
-          onEndpoint(method, path, endpoint);
-        }
       } else {
         stack.unshift(...processEntries(element, path));
       }

express-zod-api/src/routing.ts

@@ -3,9 +3,8 @@ import createHttpError from "http-errors";
 import { isProduction } from "./common-helpers";
 import { CommonConfig } from "./config-type";
 import { ContentType } from "./content-type";
-import { DependsOnMethod } from "./depends-on-method";
 import { Diagnostics } from "./diagnostics";
-import { AbstractEndpoint } from "./endpoint";
+import type { AbstractEndpoint } from "./endpoint";
 import { CORSMethod, isMethod } from "./method";
 import { OnEndpoint, walkRouting } from "./routing-walker";
 import { ServeStatic } from "./serve-static";
@@ -19,7 +18,7 @@ import * as R from "ramda";
  * @example { v1: { "patch /books/:bookId": changeBookEndpoint } }
  * */
 export interface Routing {
-  [K: string]: Routing | DependsOnMethod | AbstractEndpoint | ServeStatic;
+  [K: string]: Routing | AbstractEndpoint | ServeStatic;
 }
 
 export type Parsers = Partial<Record<ContentType, RequestHandler[]>>;

express-zod-api/tests/__snapshots__/index.spec.ts.snap

@@ -2,8 +2,6 @@
 
 exports[`Index Entrypoint > exports > BuiltinLogger should have certain value 1`] = `[Function]`;
 
-exports[`Index Entrypoint > exports > DependsOnMethod should have certain value 1`] = `[Function]`;
-
 exports[`Index Entrypoint > exports > Documentation should have certain value 1`] = `[Function]`;
 
 exports[`Index Entrypoint > exports > DocumentationError should have certain value 1`] = `[Function]`;
@@ -84,7 +82,6 @@ exports[`Index Entrypoint > exports > should have certain entities exposed 1`] =
   "ResultHandler",
   "defaultResultHandler",
   "arrayResultHandler",
-  "DependsOnMethod",
   "ServeStatic",
   "createServer",
   "attachRouting",

express-zod-api/tests/__snapshots__/routing.spec.ts.snap

@@ -10,7 +10,7 @@ RoutingError({
 })
 `;
 
-exports[`Routing > initRouting() > Should check if endpoint supports the method it's assigned to within DependsOnMethod 1`] = `
+exports[`Routing > initRouting() > Should check if endpoint supports the method it's assigned to 1`] = `
 RoutingError({
   "cause": {
     "method": "post",
@@ -20,7 +20,7 @@ RoutingError({
 })
 `;
 
-exports[`Routing > initRouting() > Should prohibit DependsOnMethod for a route having explicit method 1`] = `
+exports[`Routing > initRouting() > Should prohibit ServeStatic for a route having explicit method 1`] = `
 RoutingError({
   "cause": {
     "method": "get",
@@ -30,27 +30,27 @@ RoutingError({
 })
 `;
 
-exports[`Routing > initRouting() > Should prohibit ServeStatic for a route having explicit method 1`] = `
+exports[`Routing > initRouting() > Should prohibit duplicated routes 1`] = `
 RoutingError({
   "cause": {
     "method": "get",
-    "path": "/v1/user/retrieve",
+    "path": "/v1/test",
   },
-  "message": "Route with explicit method can only be assigned with Endpoint",
+  "message": "Route has a duplicate",
 })
 `;
 
-exports[`Routing > initRouting() > Should prohibit duplicated routes 1`] = `
+exports[`Routing > initRouting() > Should prohibit nested routing within a route having explicit method 1`] = `
 RoutingError({
   "cause": {
     "method": "get",
-    "path": "/v1/test",
+    "path": "/v1/user/retrieve",
   },
-  "message": "Route has a duplicate",
+  "message": "Route with explicit method can only be assigned with Endpoint",
 })
 `;
 
-exports[`Routing > initRouting() > Should prohibit nested routing within a route having explicit method 1`] = `
+exports[`Routing > initRouting() > Should prohibit nesting for a route having explicit method 1`] = `
 RoutingError({
   "cause": {
     "method": "get",

express-zod-api/tests/endpoint.spec.ts

@@ -131,6 +131,20 @@ describe("Endpoint", () => {
     });
   });
 
+  describe(".nest()", () => {
+    test("should return Routing arrangement", () => {
+      const subject = defaultEndpointsFactory.build({
+        output: z.object({}),
+        handler: vi.fn(),
+      });
+      expect(subject).toHaveProperty("nest", expect.any(Function));
+      expect(subject.nest({ subpath: subject })).toEqual({
+        "": subject,
+        subpath: subject,
+      });
+    });
+  });
+
   describe("#parseOutput", () => {
     test("Should throw on output validation failure", async () => {
       const endpoint = defaultEndpointsFactory.build({