prefixed data entity endpoints with /entity

app/src/data/api/DataApi.ts

@@ -23,7 +23,10 @@ export class DataApi extends ModuleApi<DataApiOptions> {
       id: PrimaryFieldType,
       query: Omit<RepoQueryIn, "where" | "limit" | "offset"> = {}
    ) {
-      return this.get<Pick<RepositoryResponse<Data>, "meta" | "data">>([entity as any, id], query);
+      return this.get<Pick<RepositoryResponse<Data>, "meta" | "data">>(
+         ["entity", entity as any, id],
+         query
+      );
    }
 
    readMany<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
@@ -33,13 +36,13 @@ export class DataApi extends ModuleApi<DataApiOptions> {
       type T = Pick<RepositoryResponse<Data[]>, "meta" | "data">;
 
       const input = query ?? this.options.defaultQuery;
-      const req = this.get<T>([entity as any], input);
+      const req = this.get<T>(["entity", entity as any], input);
 
       if (req.request.url.length <= this.options.queryLengthLimit) {
          return req;
       }
 
-      return this.post<T>([entity as any, "query"], input);
+      return this.post<T>(["entity", entity as any, "query"], input);
    }
 
    readManyByReference<
@@ -48,7 +51,7 @@ export class DataApi extends ModuleApi<DataApiOptions> {
       Data = R extends keyof DB ? DB[R] : EntityData
    >(entity: E, id: PrimaryFieldType, reference: R, query: RepoQueryIn = {}) {
       return this.get<Pick<RepositoryResponse<Data[]>, "meta" | "data">>(
-         [entity as any, id, reference],
+         ["entity", entity as any, id, reference],
          query ?? this.options.defaultQuery
       );
    }
@@ -57,7 +60,7 @@ export class DataApi extends ModuleApi<DataApiOptions> {
       entity: E,
       input: Omit<Data, "id">
    ) {
-      return this.post<RepositoryResponse<Data>>([entity as any], input);
+      return this.post<RepositoryResponse<Data>>(["entity", entity as any], input);
    }
 
    updateOne<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
@@ -65,19 +68,19 @@ export class DataApi extends ModuleApi<DataApiOptions> {
       id: PrimaryFieldType,
       input: Partial<Omit<Data, "id">>
    ) {
-      return this.patch<RepositoryResponse<Data>>([entity as any, id], input);
+      return this.patch<RepositoryResponse<Data>>(["entity", entity as any, id], input);
    }
 
    deleteOne<E extends keyof DB | string, Data = E extends keyof DB ? DB[E] : EntityData>(
       entity: E,
       id: PrimaryFieldType
    ) {
-      return this.delete<RepositoryResponse<Data>>([entity as any, id]);
+      return this.delete<RepositoryResponse<Data>>(["entity", entity as any, id]);
    }
 
    count<E extends keyof DB | string>(entity: E, where: RepoQuery["where"] = {}) {
       return this.post<RepositoryResponse<{ entity: E; count: number }>>(
-         [entity as any, "fn", "count"],
+         ["entity", entity as any, "fn", "count"],
          where
       );
    }

app/src/data/api/DataController.ts

@@ -109,44 +109,7 @@ export class DataController extends Controller {
       });
 
       /**
-       * Function endpoints
-       */
-      hono
-         // fn: count
-         .post(
-            "/:entity/fn/count",
-            permission(DataPermissions.entityRead),
-            tb("param", Type.Object({ entity: Type.String() })),
-            async (c) => {
-               const { entity } = c.req.valid("param");
-               if (!this.entityExists(entity)) {
-                  return c.notFound();
-               }
-
-               const where = c.req.json() as any;
-               const result = await this.em.repository(entity).count(where);
-               return c.json({ entity, count: result.count });
-            }
-         )
-         // fn: exists
-         .post(
-            "/:entity/fn/exists",
-            permission(DataPermissions.entityRead),
-            tb("param", Type.Object({ entity: Type.String() })),
-            async (c) => {
-               const { entity } = c.req.valid("param");
-               if (!this.entityExists(entity)) {
-                  return c.notFound();
-               }
-
-               const where = c.req.json() as any;
-               const result = await this.em.repository(entity).exists(where);
-               return c.json({ entity, exists: result.exists });
-            }
-         );
-
-      /**
-       * Read endpoints
+       * Schema endpoints
        */
       hono
          // read entity schema
@@ -197,7 +160,64 @@ export class DataController extends Controller {
                   ...schema
                });
             }
+         );
+
+      // entity endpoints
+      hono.route("/entity", this.getEntityRoutes());
+
+      return hono.all("*", (c) => c.notFound());
+   }
+
+   private getEntityRoutes() {
+      const { permission } = this.middlewares;
+      const hono = this.create();
+
+      const definedEntities = this.em.entities.map((e) => e.name);
+      const tbNumber = Type.Transform(Type.String({ pattern: "^[1-9][0-9]{0,}$" }))
+         .Decode(Number.parseInt)
+         .Encode(String);
+
+      /**
+       * Function endpoints
+       */
+      hono
+         // fn: count
+         .post(
+            "/:entity/fn/count",
+            permission(DataPermissions.entityRead),
+            tb("param", Type.Object({ entity: Type.String() })),
+            async (c) => {
+               const { entity } = c.req.valid("param");
+               if (!this.entityExists(entity)) {
+                  return c.notFound();
+               }
+
+               const where = c.req.json() as any;
+               const result = await this.em.repository(entity).count(where);
+               return c.json({ entity, count: result.count });
+            }
          )
+         // fn: exists
+         .post(
+            "/:entity/fn/exists",
+            permission(DataPermissions.entityRead),
+            tb("param", Type.Object({ entity: Type.String() })),
+            async (c) => {
+               const { entity } = c.req.valid("param");
+               if (!this.entityExists(entity)) {
+                  return c.notFound();
+               }
+
+               const where = c.req.json() as any;
+               const result = await this.em.repository(entity).exists(where);
+               return c.json({ entity, exists: result.exists });
+            }
+         );
+
+      /**
+       * Read endpoints
+       */
+      hono
          // read many
          .get(
             "/:entity",