create-arkos 2.0.0-next.17 → 2.0.0-next.19

package/templates/basic/prisma/schema/schema.prisma.hbs

@@ -1,9 +1,8 @@
 generator client {
-  provider = "prisma-client-js"
+  provider = "prisma-client"
+  output   = "../src/generated/prisma"
 }
 
 datasource db {
   provider = "{{prisma.provider}}"
-  url      = env("DATABASE_URL")
 }
-

package/templates/basic/prisma/schema/user-permission.prisma.hbs

@@ -0,0 +1,18 @@
+model UserPermission {
+  id           String  @id @default(uuid())
+  createdAt    DateTime   @default(now())
+  updatedAt    DateTime   @updatedAt
+
+  effect       UserPermissionEffect @default(Allow)
+  userId       String
+  user         User           @relation(fields: [userId], references: [id])
+  permissionId String
+  permission   AuthPermission @relation(fields: [permissionId], references: [id])
+
+  @@unique([userId, permissionId])
+}
+
+enum UserPermissionEffect {
+  Allow
+  Deny
+}

package/templates/basic/prisma/schema/user.prisma.hbs

@@ -1,4 +1,4 @@
-{{#if (neq authentication.type "define later")}}
+{{#if (neq authentication.type "none")}}
 model User {
   id                   String    {{{prisma.idDatabaseType}}}
   {{authentication.usernameField}}  String   @unique
@@ -30,9 +30,11 @@ model User {
       {{/if}}
     {{/if}}
   {{/if}}
+ {{#if (eq authentication.type "dynamic")}}
+  permissions          UserPermission[]
+  {{/if}}
   createdAt            DateTime @default(now())
   updatedAt            DateTime @updatedAt
-  // other fields for your application
 }
 
 {{#if (eq authentication.type "static")}}

package/templates/basic/prisma.config.ts.hbs

@@ -0,0 +1,10 @@
+import { loadEnvironmentVariables } from "arkos/utils";
+loadEnvironmentVariables()
+
+import { defineConfig, env } from "prisma/config";
+
+export default defineConfig({
+  datasource: {
+    url: env("DATABASE_URL"),
+  },
+});

package/templates/basic/src/app.ts.hbs

@@ -1,12 +1,14 @@
 import arkos from "arkos";
-import router from "@/src/router"
-import loadables from "@/src/loadables"
+import router from "@/src/router";
 
-const app = arkos()
+const app = arkos();
 
-app.set("trust proxy", 1)
+app.set("trust proxy", 1);
+app.use(router);
 
-app.load(loadables)
-app.use(router)
+{{#if (eq entryPoint "src/app")}}
+app.listen();
+{{else}}
+export default app;
+{{/if}}
 
-app.listen()

package/templates/basic/src/modules/auth/auth.policy.ts.hbs

@@ -1,5 +1,5 @@
 import { ArkosPolicy } from "arkos";
 
-const authPolicy = ArkosPolicy("auth-permission")
+const authPolicy = ArkosPolicy("auth")
 
 export default authPolicy;

package/templates/basic/src/modules/auth/auth.router.ts.hbs

@@ -1,11 +1,76 @@
-import { ArkosRouter } from "arkos";
-{{#if authentication}}
-import authPolicy from "@/src/modules/auth/auth.policy";
+import { ArkosRouter, ArkosRouteHook } from 'arkos';
+{{#if (neq authentication.type "none")}}
+import authPolicy from '@/src/modules/auth/auth.policy';
 {{/if}}
+{{#if validation.type}}
+import LoginDto from '@/src/modules/auth/dtos/login.dto';
+import SignupDto from '@/src/modules/auth/dtos/signup.dto';
+import UpdateMeDto from '@/src/modules/auth/dtos/update-me.dto';
+import UpdatePasswordDto from '@/src/modules/auth/dtos/update-password.dto';
+{{/if}}
+
+const authRouteHook = ArkosRouteHook("auth");
+
+authRouteHook.login({
+  {{#if validation.type}}validation: { body: LoginDto },{{/if}}
+});
+
+authRouteHook.signup({
+  {{#if validation.type}}validation: { body: SignupDto },{{/if}}
+  prismaArgs: {
+    omit: { password: true },
+  },
+});
+
+authRouteHook.getMe({
+  prismaArgs: {
+    omit: { password: true },
+    {{#if (eq authentication.type "dynamic")}}
+    include: {
+      {{#if authentication.multipleRoles}}
+      roles: {
+        include: {
+          role: {
+            include: {
+              permissions: true,
+            },
+          },
+        },
+      },
+      {{else}}
+      role: {
+        include: {
+          role: {
+            include: {
+              permissions: true,
+            },
+          },
+        },
+      },
+      {{/if}}
+    },
+    {{/if}}
+  },
+});
+
+authRouteHook.updateMe({
+  {{#if validation.type}}validation: { body: UpdateMeDto },{{/if}}
+  prismaArgs: {
+    omit: { password: true },
+  },
+});
+
+authRouteHook.updatePassword({
+  {{#if validation.type}}validation: { body: UpdatePasswordDto },{{/if}}
+});
+
+authRouteHook.logout({});
+
+const authRouter = ArkosRouter({
+  prefix: "/auth",
+  openapi: { tags: ["Authentication"] },
+});
 
-const authRouter = ArkosRouter({ 
-    prefix: "/auth",
-    openapi: { tags: ["Authentication"] } 
-  });
+authRouter.load(authRouteHook);
 
 export default authRouter;

package/templates/basic/src/modules/auth/dtos/login.dto.ts.hbs

@@ -8,7 +8,7 @@ const LoginDto = z.object({
 
 export default LoginDto;
 {{#if typescript}}
-export type LoginDtoType = z.infer<typeof LoginDto>;
+export type LoginDto = z.infer<typeof LoginDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/auth/dtos/signup.dto.ts.hbs

@@ -8,7 +8,7 @@ const SignupDto = z.object({
 
 export default SignupDto;
 {{#if typescript}}
-export type SignupDtoType = z.infer<typeof SignupDto>;
+export type SignupDto = z.infer<typeof SignupDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/auth/dtos/update-me.dto.ts.hbs

@@ -7,7 +7,7 @@ const UpdateMeDto = z.object({
 
 export default UpdateMeDto;
 {{#if typescript}}
-export type UpdateMeDtoType = z.infer<typeof UpdateMeDto>;
+export type UpdateMeDto = z.infer<typeof UpdateMeDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/auth/dtos/update-password.dto.ts.hbs

@@ -8,7 +8,7 @@ const UpdatePasswordDto = z.object({
 
 export default UpdatePasswordDto;
 {{#if typescript}}
-export type UpdatePasswordDtoType = z.infer<typeof UpdatePasswordDto>;
+export type UpdatePasswordDto = z.infer<typeof UpdatePasswordDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/auth-permission/auth-permission.router.ts.hbs

@@ -1,11 +1,43 @@
-import { ArkosRouter } from "arkos";
-{{#if authentication}}
-import authPermissionPolicy from "@/src/modules/auth-permission/auth-permission.policy";
+import { ArkosRouter, ArkosRouteHook } from 'arkos';
+{{#if (neq authentication.type "none")}}
+import authPermissionPolicy from '@/src/modules/auth-permission/auth-permission.policy';
 {{/if}}
+{{#if validation.type}}
+import CreateAuthPermissionDto from '@/src/modules/auth-permission/dtos/create-auth-permission.dto';
+import UpdateAuthPermissionDto from '@/src/modules/auth-permission/dtos/update-auth-permission.dto';
+import QueryAuthPermissionDto from '@/src/modules/auth-permission/dtos/query-auth-permission.dto';
+{{/if}}
+
+const authPermissionRouteHook = ArkosRouteHook("auth-permission");
+
+authPermissionRouteHook.createOne({
+  {{#if validation.type}}validation: { body: CreateAuthPermissionDto },{{/if}}
+  {{#if (neq authentication.type "none")}}authentication: authPermissionPolicy.Create,{{/if}}
+});
+
+authPermissionRouteHook.findOne({
+  {{#if (neq authentication.type "none")}}authentication: authPermissionPolicy.View,{{/if}}
+});
+
+authPermissionRouteHook.findMany({
+  {{#if validation.type}}validation: { query: QueryAuthPermissionDto },{{/if}}
+  {{#if (neq authentication.type "none")}}authentication: authPermissionPolicy.View,{{/if}}
+});
+
+authPermissionRouteHook.updateOne({
+  {{#if validation.type}}validation: { body: UpdateAuthPermissionDto },{{/if}}
+  {{#if (neq authentication.type "none")}}authentication: authPermissionPolicy.Update,{{/if}}
+});
+
+authPermissionRouteHook.deleteOne({
+  {{#if (neq authentication.type "none")}}authentication: authPermissionPolicy.Delete,{{/if}}
+});
+
+const authPermissionRouter = ArkosRouter({
+  prefix: "/auth-permissions",
+  openapi: { tags: ["Auth Permissions"] },
+});
 
-const authPermissionRouter = ArkosRouter({ 
-    prefix: "/auth-permissions",
-    openapi: { tags: ["Auth Permissions"] } 
-  });
+authPermissionRouter.load(authPermissionRouteHook);
 
 export default authPermissionRouter;

package/templates/basic/src/modules/auth-permission/auth-permission.service.ts.hbs

@@ -1,11 +1,9 @@
-import { BaseService } from "arkos/services";
-{{#if typescript}}
-import { Prisma } from "@prisma/client"
+import { ArkosPrismaService } from "arkos/services";
 
-class AuthPermissionService extends BaseService<"auth-permission"> {}
+{{#if typescript}}
+class AuthPermissionService extends ArkosPrismaService<"auth-permission"> {}
 {{else}}
-
-class AuthPermissionService extends BaseService {}
+class AuthPermissionService extends ArkosPrismaService {}
 {{/if}}
 
 const authPermissionService = new AuthPermissionService("auth-permission");

package/templates/basic/src/modules/auth-permission/dtos/create-auth-permission.dto.ts.hbs

@@ -4,19 +4,19 @@ import { z } from 'zod';
 const CreateAuthPermissionDto = z.object({
   resource: z.string().min(1, 'Resource is required'),
   action: z.string().default('View'),
-  role: z.object({
+  roles: z.array(z.object({
     id: z.string().min(1, 'Role ID is required'),
-  }),
+  })).optional(),
   description: z.string().optional(),
 });
 
 export default CreateAuthPermissionDto;
 {{#if typescript}}
-export type CreateAuthPermissionDtoType = z.infer<typeof CreateAuthPermissionDto>;
+export type CreateAuthPermissionDto = z.infer<typeof CreateAuthPermissionDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}
-import { IsString, IsNotEmpty, IsOptional, IsValidateNested } from 'class-validator';
+import { IsString, IsNotEmpty, IsOptional, IsArray, ValidateNested } from 'class-validator';
 import { Type, Transform } from 'class-transformer';
 import 'reflect-metadata';
 
@@ -35,7 +35,8 @@ export default class CreateAuthPermissionDto {
   @Transform(({ value }) => value || 'View')
   action?: string = 'View';
 
-  @ValidateNested()
+  @ValidateNested({ each: true })
+  @IsArray()
   @Type(() => RoleConnectDto)
   @IsOptional()
   roles?: RoleConnectDto[];

package/templates/basic/src/modules/auth-permission/dtos/{query-auth-role.dto.ts.hbs → query-auth-permission.dto.ts.hbs}

@@ -18,7 +18,7 @@ const QueryAuthPermissionDto = z.object({
 
 export default QueryAuthPermissionDto;
 {{#if typescript}}
-export type QueryAuthPermissionDtoType = z.infer<typeof QueryAuthPermissionDto>;
+export type QueryAuthPermissionDto = z.infer<typeof QueryAuthPermissionDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/auth-permission/dtos/update-auth-permission.dto.ts.hbs

@@ -5,18 +5,27 @@ const UpdateAuthPermissionDto = z.object({
   resource: z.string().optional(),
   action: z.string().optional(),
   description: z.string().optional(),
+  roles: z.array(z.object({
+    id: z.string().min(1, 'Role ID is required'),
+  })).optional(),
 });
 
 export default UpdateAuthPermissionDto;
 {{#if typescript}}
-export type UpdateAuthPermissionDtoType = z.infer<typeof UpdateAuthPermissionDto>;
+export type UpdateAuthPermissionDto = z.infer<typeof UpdateAuthPermissionDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}
-import { IsString, IsOptional } from 'class-validator';
-import { Transform } from 'class-transformer';
+import { IsString, IsOptional, IsArray, ValidateNested } from 'class-validator';
+import { Transform, Type } from 'class-transformer';
 import 'reflect-metadata';
 
+class RoleConnectDto {
+  @IsString()
+  @IsNotEmpty({ message: 'Role ID is required' })
+  id!: string;
+}
+
 export default class UpdateAuthPermissionDto {
   @IsOptional()
   @IsString()
@@ -25,7 +34,11 @@ export default class UpdateAuthPermissionDto {
   @IsOptional()
   @IsString()
   @Transform(({ value }) => String(value))
-  action?: string
+  action?: string;
+
+  @IsOptional()
+  @IsString()
+  description?: string;
 
   @ValidateNested({ each: true })
   @IsArray()

package/templates/basic/src/modules/auth-role/auth-role.router.ts.hbs

@@ -1,11 +1,43 @@
-import { ArkosRouter } from "arkos";
-{{#if authentication}}
-import authRolePolicy from "@/src/modules/auth-role/auth-role.policy";
+import { ArkosRouter, ArkosRouteHook } from 'arkos';
+{{#if (neq authentication.type "none")}}
+import authRolePolicy from '@/src/modules/auth-role/auth-role.policy';
 {{/if}}
+{{#if validation.type}}
+import CreateAuthRoleDto from '@/src/modules/auth-role/dtos/create-auth-role.dto';
+import UpdateAuthRoleDto from '@/src/modules/auth-role/dtos/update-auth-role.dto';
+import QueryAuthRoleDto from '@/src/modules/auth-role/dtos/query-auth-role.dto';
+{{/if}}
+
+const authRoleRouteHook = ArkosRouteHook("auth-role");
+
+authRoleRouteHook.createOne({
+  {{#if validation.type}}validation: { body: CreateAuthRoleDto },{{/if}}
+  {{#if (neq authentication.type "none")}}authentication: authRolePolicy.Create,{{/if}}
+});
+
+authRoleRouteHook.findOne({
+  {{#if (neq authentication.type "none")}}authentication: authRolePolicy.View,{{/if}}
+});
+
+authRoleRouteHook.findMany({
+  {{#if validation.type}}validation: { query: QueryAuthRoleDto },{{/if}}
+  {{#if (neq authentication.type "none")}}authentication: authRolePolicy.View,{{/if}}
+});
+
+authRoleRouteHook.updateOne({
+  {{#if validation.type}}validation: { body: UpdateAuthRoleDto },{{/if}}
+  {{#if (neq authentication.type "none")}}authentication: authRolePolicy.Update,{{/if}}
+});
+
+authRoleRouteHook.deleteOne({
+  {{#if (neq authentication.type "none")}}authentication: authRolePolicy.Delete,{{/if}}
+});
 
 const authRoleRouter = ArkosRouter({
-    prefix: "/auth-roles",
-    openapi: { tags: ["Auth Roles"] } 
-  });
+  prefix: "/auth-roles",
+  openapi: { tags: ["Auth Roles"] },
+});
+
+authRoleRouter.load(authRoleRouteHook);
 
 export default authRoleRouter;

package/templates/basic/src/modules/auth-role/auth-role.service.ts.hbs

@@ -1,11 +1,9 @@
-import { BaseService } from "arkos/services";
-{{#if typescript}}
-import { Prisma } from "@prisma/client"
+import { ArkosPrismaService } from "arkos/services";
 
-class AuthRoleService extends BaseService<"auth-role"> {}
+{{#if typescript}}
+class AuthRoleService extends ArkosPrismaService<"auth-role"> {}
 {{else}}
-
-class AuthRoleService extends BaseService {}
+class AuthRoleService extends ArkosPrismaService {}
 {{/if}}
 
 const authRoleService = new AuthRoleService("auth-role");

package/templates/basic/src/modules/auth-role/dtos/create-auth-role.dto.ts.hbs

@@ -15,7 +15,7 @@ const CreateAuthRoleDto = z.object({
 
 export default CreateAuthRoleDto;
 {{#if typescript}}
-export type CreateAuthRoleDtoType = z.infer<typeof CreateAuthRoleDto>;
+export type CreateAuthRoleDto = z.infer<typeof CreateAuthRoleDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/auth-role/dtos/query-auth-role.dto.ts.hbs

@@ -22,7 +22,7 @@ const QueryAuthRoleDto = z.object({
 
 export default QueryAuthRoleDto;
 {{#if typescript}}
-export type QueryAuthRoleDtoType = z.infer<typeof QueryAuthRoleDto>;
+export type QueryAuthRoleDto = z.infer<typeof QueryAuthRoleDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/auth-role/dtos/update-auth-role.dto.ts.hbs

@@ -17,7 +17,7 @@ const UpdateAuthRoleDto = z.object({
 
 export default UpdateAuthRoleDto;
 {{#if typescript}}
-export type UpdateAuthRoleDtoType = z.infer<typeof UpdateAuthRoleDto>;
+export type UpdateAuthRoleDto = z.infer<typeof UpdateAuthRoleDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}
@@ -27,6 +27,7 @@ import 'reflect-metadata';
 
 export enum ApiAction {
   connect = 'connect',
+  disconnect = 'disconnect',
   delete = 'delete',
   create = 'create',
   update = 'update'

package/templates/basic/src/modules/file-upload/file-upload.router.ts.hbs

@@ -1,12 +1,32 @@
-import { ArkosRouter } from "arkos";
-{{#if authentication}}
-import fileUploadPolicy from "@/src/modules/file-upload/file-upload.policy";
+import { ArkosRouter, ArkosRouteHook } from 'arkos';
+{{#if (neq authentication.type "none")}}
+import fileUploadPolicy from '@/src/modules/file-upload/file-upload.policy';
 {{/if}}
-import config from "@/arkos.config"
+import config from '@/arkos.config';
 
-const fileUploadRouter = ArkosRouter({ 
-    prefix: config?.fileUpload?.baseRoute,
-    openapi: { tags: ["File Uploads"] } 
-  });
+const fileUploadRouteHook = ArkosRouteHook("file-upload");
+
+fileUploadRouteHook.findFile({
+  {{#if (neq authentication.type "none")}}authentication: fileUploadPolicy.View,{{/if}}
+});
+
+fileUploadRouteHook.uploadFile({
+  {{#if (neq authentication.type "none")}}authentication: fileUploadPolicy.Create,{{/if}}
+});
+
+fileUploadRouteHook.updateFile({
+  {{#if (neq authentication.type "none")}}authentication: fileUploadPolicy.Update,{{/if}}
+});
+
+fileUploadRouteHook.deleteFile({
+  {{#if (neq authentication.type "none")}}authentication: fileUploadPolicy.Delete,{{/if}}
+});
+
+const fileUploadRouter = ArkosRouter({
+  prefix: config?.fileUpload?.baseRoute,
+  openapi: { tags: ["File Upload"] },
+});
+
+fileUploadRouter.load(fileUploadRouteHook);
 
 export default fileUploadRouter;

package/templates/basic/src/modules/user/dtos/create-user.dto.ts.hbs

@@ -20,9 +20,9 @@ const CreateUserDto = z.object({
   role: z.string(),
   {{else}}
   {{#if authentication.multipleRoles}}
-  roles: z.array(z.nativeEnum(UserRole)),
+  roles: z.array(z.enum(UserRole)),
   {{else}}
-  role: z.nativeEnum(UserRole),
+  role: z.enum(UserRole),
   {{/if}}
   {{/if}}
   {{else}}
@@ -40,7 +40,7 @@ const CreateUserDto = z.object({
 
 export default CreateUserDto;
 {{#if typescript}}
-export type CreateUserDtoType = z.infer<typeof CreateUserDto>;
+export type CreateUserDto = z.infer<typeof CreateUserDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/user/dtos/update-user.dto.ts.hbs

@@ -22,9 +22,9 @@ const UpdateUserDto = z.object({
   role: z.string().optional(),
   {{else}}
   {{#if authentication.multipleRoles}}
-  roles: z.array(z.nativeEnum(UserRole)).optional(),
+  roles: z.array(z.enum(UserRole)).optional(),
   {{else}}
-  role: z.nativeEnum(UserRole).optional(),
+  role: z.enum(UserRole).optional(),
   {{/if}}
   {{/if}}
   {{else}}
@@ -46,7 +46,7 @@ const UpdateUserDto = z.object({
 
 export default UpdateUserDto;
 {{#if typescript}}
-export type UpdateUserDtoType = z.infer<typeof UpdateUserDto>;
+export type UpdateUserDto = z.infer<typeof UpdateUserDto>;
 {{/if}}
 {{/if}}
 {{#if (eq validation.type "class-validator")}}

package/templates/basic/src/modules/user/user.router.ts.hbs

@@ -1,11 +1,95 @@
-import { ArkosRouter } from "arkos";
-{{#if authentication}}
-import userPolicy from "@/src/modules/user/user.policy";
+import { ArkosRouter, ArkosRouteHook } from 'arkos';
+{{#if (neq authentication.type "none")}}
+import userPolicy from '@/src/modules/user/user.policy';
 {{/if}}
+{{#if validation.type}}
+import CreateUserDto from '@/src/modules/user/dtos/create-user.dto';
+import UpdateUserDto from '@/src/modules/user/dtos/update-user.dto';
+{{/if}}
+
+const userRouteHook = ArkosRouteHook("user");
+
+userRouteHook.createOne({
+  {{#if validation.type}}validation: { body: CreateUserDto },{{/if}}
+  {{#if (neq authentication.type "none")}}authentication: userPolicy.Create,{{/if}}
+  prismaArgs: {
+    omit: { password: true },
+  },
+});
+
+userRouteHook.findOne({
+  {{#if (neq authentication.type "none")}}authentication: userPolicy.View,{{/if}}
+  prismaArgs: {
+    omit: { password: true },
+    {{#if (eq authentication.type "dynamic")}}
+    include: {
+      {{#if authentication.multipleRoles}}
+      roles: {
+        include: {
+          role: {
+            include: {
+              permissions: true,
+            },
+          },
+        },
+      },
+      {{else}}
+      role: {
+        include: {
+          role: {
+            include: {
+              permissions: true,
+            },
+          },
+        },
+      },
+      {{/if}}
+    },
+    {{/if}}
+  },
+});
+
+userRouteHook.findMany({
+  {{#if (neq authentication.type "none")}}authentication: userPolicy.View,{{/if}}
+  prismaArgs: {
+    omit: { password: true },
+    {{#if (eq authentication.type "dynamic")}}
+    include: {
+      {{#if authentication.multipleRoles}}
+      roles: {
+        include: {
+          role: true,
+        },
+      },
+      {{else}}
+      role: {
+        include: {
+          role: true,
+        },
+      },
+      {{/if}}
+    },
+    {{/if}}
+  },
+});
+
+userRouteHook.updateOne({
+  {{#if validation.type}}validation: { body: UpdateUserDto },{{/if}}
+  {{#if (neq authentication.type "none")}}authentication: userPolicy.Update,{{/if}}
+  prismaArgs: {
+    omit: { password: true },
+  },
+});
+
+userRouteHook.deleteOne({
+  {{#if (neq authentication.type "none")}}authentication: userPolicy.Delete,{{/if}}
+});
+
+const userRouter = ArkosRouter({
+  prefix: "/users",
+  openapi: { tags: ["Users"] },
+});
 
-const userRouter = ArkosRouter({ 
-    prefix: "/users",
-    openapi: { tags: ["Users"] }
-  });
+userRouter.load(userRouteHook);
 
 export default userRouter;