@drax/identity-back 0.51.0 → 1.0.0

package/dist/controllers/UserController.js

@@ -151,6 +151,7 @@ class UserController extends AbstractFastifyController {
                 item.password = undefined;
                 delete item.password;
             }
+            console.log("Paginated users: ", JSON.stringify(paginateResult, null, 4));
             return paginateResult;
         }
         catch (e) {

package/dist/routes/RoleRoutes.js

@@ -1,11 +1,10 @@
 import RoleController from "../controllers/RoleController.js";
 import { CrudSchemaBuilder } from "@drax/crud-back";
 import { RoleBaseSchema, RoleSchema } from "../schemas/RoleSchema.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import zod from "zod";
 async function RoleRoutes(fastify, options) {
     const controller = new RoleController();
-    const schemas = new CrudSchemaBuilder(RoleSchema, RoleBaseSchema, RoleBaseSchema, 'role', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(RoleSchema, RoleBaseSchema, RoleBaseSchema, 'role', 'openapi-3.0', ['Identity']);
     fastify.get('/api/roles/search', { schema: schemas.searchSchema }, (req, rep) => controller.search(req, rep));
     fastify.get('/api/roles/:id', { schema: schemas.findByIdSchema }, (req, rep) => controller.findById(req, rep));
     fastify.get('/api/roles/all', { schema: schemas.allSchema }, (req, rep) => controller.all(req, rep));
@@ -18,7 +17,7 @@ async function RoleRoutes(fastify, options) {
         schema: {
             tags: ['Identity'],
             response: {
-                200: zodToJsonSchema(zod.array(zod.string())),
+                200: zod.toJSONSchema(zod.array(zod.string())),
                 401: schemas.jsonErrorBodyResponse,
                 403: schemas.jsonErrorBodyResponse,
             }
@@ -27,7 +26,7 @@ async function RoleRoutes(fastify, options) {
     fastify.get('/api/roles/name/:name', {
         schema: {
             tags: ['Identity'],
-            params: zodToJsonSchema(zod.object({ name: zod.string() })),
+            params: zod.toJSONSchema(zod.object({ name: zod.string() })),
             response: {
                 200: schemas.jsonEntitySchema,
                 401: schemas.jsonErrorBodyResponse,

package/dist/routes/TenantRoutes.js

@@ -3,7 +3,7 @@ import TenantController from '../controllers/TenantController.js';
 import { TenantSchema, TenantBaseSchema } from '../schemas/TenantSchema.js';
 async function TenantRoutes(fastify, options) {
     const controller = new TenantController();
-    const schemas = new CrudSchemaBuilder(TenantSchema, TenantBaseSchema, TenantBaseSchema, 'tenant', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(TenantSchema, TenantBaseSchema, TenantBaseSchema, 'tenant', 'openapi-3.0', ['Identity']);
     //Getters
     fastify.get('/api/tenants/search', { schema: schemas.searchSchema }, (req, rep) => controller.search(req, rep));
     fastify.get('/api/tenants/:id', { schema: schemas.findByIdSchema }, (req, rep) => controller.findById(req, rep));

package/dist/routes/UserLoginFailRoutes.js

@@ -3,7 +3,7 @@ import { CrudSchemaBuilder } from "@drax/crud-back";
 import { UserLoginFailSchema, UserLoginFailBaseSchema } from '../schemas/UserLoginFailSchema.js';
 async function UserLoginFailRoutes(fastify, options) {
     const controller = new UserLoginFailController();
-    const schemas = new CrudSchemaBuilder(UserLoginFailSchema, UserLoginFailBaseSchema, UserLoginFailBaseSchema, 'UserLoginFail', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(UserLoginFailSchema, UserLoginFailBaseSchema, UserLoginFailBaseSchema, 'UserLoginFail', 'openapi-3.0', ['Identity']);
     fastify.get('/api/user-login-fails', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
     fastify.get('/api/user-login-fails/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
     fastify.get('/api/user-login-fails/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));

package/dist/routes/UserRoutes.js

@@ -1,14 +1,14 @@
 import UserController from "../controllers/UserController.js";
-import { zodToJsonSchema } from "zod-to-json-schema";
 import { CrudSchemaBuilder } from "@drax/crud-back";
 import { LoginBodyRequestSchema, LoginBodyResponseSchema } from "../schemas/LoginSchema.js";
 import { UserSchema, UserCreateSchema, UserUpdateSchema } from "../schemas/UserSchema.js";
 import { RegisterBodyRequestSchema, RegisterBodyResponseSchema } from "../schemas/RegisterSchema.js";
 import { MyPasswordBodyRequestSchema, PasswordBodyRequestSchema, PasswordBodyResponseSchema } from "../schemas/PasswordSchema.js";
 import { SwitchTenantBodyRequestSchema, SwitchTenantBodyResponseSchema } from "../schemas/SwitchTenantSchema.js";
+import zod from "zod";
 async function UserRoutes(fastify, options) {
     const controller = new UserController();
-    const schemas = new CrudSchemaBuilder(UserSchema, UserCreateSchema, UserUpdateSchema, 'tenant', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(UserSchema, UserCreateSchema, UserUpdateSchema, 'tenant', 'openapi-3.0', ['Identity']);
     fastify.get('/api/users/search', { schema: schemas.searchSchema }, async (req, rep) => await controller.search(req, rep));
     fastify.get('/api/users/group-by', { schema: schemas.groupBySchema }, async (req, rep) => await controller.groupBy(req, rep));
     fastify.get('/api/users/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));
@@ -19,9 +19,9 @@ async function UserRoutes(fastify, options) {
     fastify.post('/api/auth/login', {
         schema: {
             tags: ['Auth'],
-            body: zodToJsonSchema(LoginBodyRequestSchema),
+            body: zod.toJSONSchema(LoginBodyRequestSchema),
             response: {
-                200: zodToJsonSchema(LoginBodyResponseSchema),
+                200: zod.toJSONSchema(LoginBodyResponseSchema),
                 400: schemas.jsonErrorBodyResponse,
             },
         },
@@ -39,9 +39,9 @@ async function UserRoutes(fastify, options) {
     fastify.post('/api/auth/switch-tenant', {
         schema: {
             tags: ['Auth'],
-            body: zodToJsonSchema(SwitchTenantBodyRequestSchema),
+            body: zod.toJSONSchema(SwitchTenantBodyRequestSchema),
             response: {
-                200: zodToJsonSchema(SwitchTenantBodyResponseSchema),
+                200: zod.toJSONSchema(SwitchTenantBodyResponseSchema),
                 400: schemas.jsonErrorBodyResponse,
             },
         },
@@ -49,9 +49,9 @@ async function UserRoutes(fastify, options) {
     fastify.post('/api/users/register', {
         schema: {
             tags: ['Auth'],
-            body: zodToJsonSchema(RegisterBodyRequestSchema),
+            body: zod.toJSONSchema(RegisterBodyRequestSchema),
             response: {
-                200: zodToJsonSchema(RegisterBodyResponseSchema),
+                200: zod.toJSONSchema(RegisterBodyResponseSchema),
                 400: schemas.jsonErrorBodyResponse,
                 500: schemas.jsonErrorBodyResponse,
             },
@@ -70,8 +70,8 @@ async function UserRoutes(fastify, options) {
     fastify.post('/api/users/password/change', {
         schema: {
             tags: ['Auth'],
-            body: zodToJsonSchema(MyPasswordBodyRequestSchema),
-            200: zodToJsonSchema(PasswordBodyResponseSchema),
+            body: zod.toJSONSchema(MyPasswordBodyRequestSchema),
+            200: zod.toJSONSchema(PasswordBodyResponseSchema),
             400: schemas.jsonErrorBodyResponse,
             500: schemas.jsonErrorBodyResponse,
         }
@@ -79,8 +79,8 @@ async function UserRoutes(fastify, options) {
     fastify.post('/api/users/password/change/:id', {
         schema: {
             tags: ['Auth'],
-            body: zodToJsonSchema(PasswordBodyRequestSchema),
-            200: zodToJsonSchema(PasswordBodyResponseSchema),
+            body: zod.toJSONSchema(PasswordBodyRequestSchema),
+            200: zod.toJSONSchema(PasswordBodyResponseSchema),
             400: schemas.jsonErrorBodyResponse,
             500: schemas.jsonErrorBodyResponse,
         }

package/dist/routes/UserSessionRoutes.js

@@ -3,7 +3,7 @@ import { CrudSchemaBuilder } from "@drax/crud-back";
 import { UserSessionSchema, UserSessionBaseSchema } from '../schemas/UserSessionSchema.js';
 async function UserSessionRoutes(fastify, options) {
     const controller = new UserSessionController();
-    const schemas = new CrudSchemaBuilder(UserSessionSchema, UserSessionBaseSchema, UserSessionBaseSchema, 'UserSession', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(UserSessionSchema, UserSessionBaseSchema, UserSessionBaseSchema, 'UserSession', 'openapi-3.0', ['Identity']);
     fastify.get('/api/user-sessions', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
     fastify.get('/api/user-sessions/group-by', { schema: schemas.groupBySchema }, (req, rep) => controller.groupBy(req, rep));
     fastify.get('/api/user-sessions/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));

package/dist/schemas/RegisterSchema.js

@@ -1,13 +1,12 @@
-import z, { string } from "zod";
+import z, { string, email } from "zod";
 const RegisterBodyRequestSchema = z.object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    username: string({ required_error: "validation.required" })
+    username: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    email: string({ required_error: "validation.required" })
-        .email("validation.email.invalid"),
-    phone: string({ required_error: "validation.required" }).optional(),
-    password: string({ required_error: "validation.required" })
+    email: email("validation.email.invalid"),
+    phone: string({ error: "validation.required" }).optional(),
+    password: string({ error: "validation.required" })
         .min(1, "validation.required")
         .min(8, "validation.password.min8")
         .max(64, "validation.password.max64"),

package/dist/schemas/RoleSchema.js

@@ -1,6 +1,6 @@
-import { date, object, string, array, boolean } from "zod";
+import { object, string, array, boolean, iso } from "zod";
 const RoleBaseSchema = object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required")
         .regex(/^[A-Z]/, "validation.startWithUpperCase"),
     permissions: array(string()).optional(),
@@ -20,8 +20,8 @@ const RoleSchema = RoleBaseSchema.extend({
         id: string().optional(),
         name: string()
     })).optional(),
-    createdAt: date().optional(),
-    updatedAt: date().optional()
+    createdAt: iso.datetime().optional(),
+    updatedAt: iso.datetime().optional()
 });
 export default RoleSchema;
 export { RoleSchema, RoleBaseSchema };

package/dist/schemas/TenantSchema.js

@@ -1,6 +1,6 @@
-import { object, string, date, record, any } from "zod";
+import { object, string, record, any, iso } from "zod";
 const TenantBaseSchema = object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required")
     //.regex(/^[A-Z]/, "validation.startWithUpperCase"),
 });
@@ -8,7 +8,7 @@ const TenantSchema = TenantBaseSchema.extend({
     _id: string(),
     id: string().optional(),
     custom: record(string(), any()).optional(),
-    createdAt: date(),
-    updatedAt: date()
+    createdAt: iso.datetime().optional(),
+    updatedAt: iso.datetime().optional()
 });
 export { TenantSchema, TenantBaseSchema };

package/dist/schemas/UserApiKeySchema.js

@@ -1,9 +1,9 @@
-import { array, object, string } from "zod";
+import { array, object, string, ipv4, ipv6 } from "zod";
 const UserApiKeyBaseSchema = object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    ipv4: array(string().ip({ version: "v4", message: 'validation.invalidIpv4' })),
-    ipv6: array(string().ip({ version: "v6", message: 'validation.invalidIpv6' })),
+    ipv4: array(ipv4({ message: 'validation.invalidIpv4' })),
+    ipv6: array(ipv6({ message: 'validation.invalidIpv6' })),
 });
 const UserApiKeySchema = UserApiKeyBaseSchema.extend({
     _id: string(),

package/dist/schemas/UserLoginFailSchema.js

@@ -7,7 +7,7 @@ const UserLoginFailBaseSchema = z.object({
 const UserLoginFailSchema = UserLoginFailBaseSchema
     .extend({
     _id: z.string(),
-    createdAt: z.coerce.date().nullable().optional()
+    createdAt: z.iso.datetime().nullable().optional()
 });
 export default UserLoginFailSchema;
 export { UserLoginFailSchema, UserLoginFailBaseSchema };

package/dist/schemas/UserSchema.js

@@ -1,19 +1,18 @@
-import { date, object, string, boolean, array, record, any } from "zod";
+import { email, iso, object, string, boolean, array, record, any } from "zod";
 const UserBaseSchema = object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    username: string({ required_error: "validation.required" })
+    username: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    email: string({ required_error: "validation.required" })
-        .email("validation.email.invalid"),
-    phone: string({ required_error: "validation.required" }).optional(),
+    email: email("validation.email.invalid"),
+    phone: string({ error: "validation.required" }).optional(),
     active: boolean().optional(),
-    role: string({ required_error: "validation.required" })
+    role: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    tenant: string({ required_error: "validation.required" }).nullable().optional()
+    tenant: string({ error: "validation.required" }).nullable().optional()
 });
 const UserCreateSchema = UserBaseSchema.extend({
-    password: string({ required_error: "validation.required" })
+    password: string({ error: "validation.required" })
         .min(1, "validation.required")
         .min(8, "validation.password.min8")
         .max(64, "validation.password.max64"),
@@ -37,8 +36,8 @@ const UserSchema = UserBaseSchema
         id: string().optional(),
         name: string(),
         custom: record(string(), any()).optional(),
-    }).nullable().optional(),
-    createdAt: date().optional(),
+    }).nullish(),
+    createdAt: iso.datetime().optional(),
     avatar: string().optional()
 });
 export { UserBaseSchema, UserSchema, UserCreateSchema, UserUpdateSchema, };

package/dist/schemas/UserSessionSchema.js

@@ -9,7 +9,7 @@ const UserSessionSchema = UserSessionBaseSchema
     .extend({
     _id: z.string(),
     user: z.object({ _id: z.string(), username: z.string() }),
-    createdAt: z.coerce.date().nullable().optional()
+    createdAt: z.iso.datetime().nullable().optional()
 });
 export default UserSessionSchema;
 export { UserSessionSchema, UserSessionBaseSchema };

package/package.json

@@ -3,7 +3,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.51.0",
+  "version": "1.0.0",
   "description": "Identity module for user management, authentication and authorization.",
   "main": "dist/index.js",
   "types": "types/index.d.ts",
@@ -28,11 +28,11 @@
   "author": "Cristian Incarnato & Drax Team",
   "license": "ISC",
   "dependencies": {
-    "@drax/common-back": "^0.51.0",
-    "@drax/crud-back": "^0.51.0",
-    "@drax/crud-share": "^0.51.0",
-    "@drax/email-back": "^0.51.0",
-    "@drax/identity-share": "^0.51.0",
+    "@drax/common-back": "^1.0.0",
+    "@drax/crud-back": "^1.0.0",
+    "@drax/crud-share": "^1.0.0",
+    "@drax/email-back": "^1.0.0",
+    "@drax/identity-share": "^1.0.0",
     "bcryptjs": "^2.4.3",
     "graphql": "^16.8.2",
     "jsonwebtoken": "^9.0.2"
@@ -43,7 +43,7 @@
     "mongoose": "^8.21.0",
     "mongoose-paginate-v2": "^1.8.3",
     "mongoose-unique-validator": "^5.0.1",
-    "zod": "^3.23.8"
+    "zod": "^4.3.5"
   },
   "devDependencies": {
     "@types/bcryptjs": "^2.4.6",
@@ -63,5 +63,5 @@
       "debug": "0"
     }
   },
-  "gitHead": "a8fe4fe11637e3b899686b8dd8d658d62933ea5a"
+  "gitHead": "8e60f7548448f339e7e9bb665ceacd3e051ef32e"
 }

package/src/controllers/UserController.ts

@@ -180,6 +180,7 @@ class UserController extends AbstractFastifyController<IUser, IUserCreate, IUser
                 item.password = undefined
                 delete item.password
             }
+            console.log("Paginated users: ", JSON.stringify(paginateResult,null,4))
             return paginateResult
         } catch (e) {
             this.handleError(e, reply)

package/src/routes/RoleRoutes.ts

@@ -1,13 +1,12 @@
 import RoleController from "../controllers/RoleController.js";
 import {CrudSchemaBuilder} from "@drax/crud-back";
 import {RoleBaseSchema, RoleSchema} from "../schemas/RoleSchema.js";
-import {zodToJsonSchema} from "zod-to-json-schema";
 import zod from "zod";
 
 async function RoleRoutes(fastify, options) {
 
     const controller: RoleController = new RoleController()
-    const schemas = new CrudSchemaBuilder(RoleSchema, RoleBaseSchema, RoleBaseSchema, 'role','openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(RoleSchema, RoleBaseSchema, RoleBaseSchema, 'role','openapi-3.0', ['Identity']);
 
     fastify.get('/api/roles/search', {schema: schemas.searchSchema}, (req, rep) => controller.search(req, rep))
 
@@ -29,7 +28,7 @@ async function RoleRoutes(fastify, options) {
         schema: {
             tags: ['Identity'],
             response: {
-                200: zodToJsonSchema(zod.array(zod.string())),
+                200: zod.toJSONSchema(zod.array(zod.string())),
                 401: schemas.jsonErrorBodyResponse,
                 403: schemas.jsonErrorBodyResponse,
             }
@@ -39,7 +38,7 @@ async function RoleRoutes(fastify, options) {
     fastify.get('/api/roles/name/:name', {
         schema: {
             tags: ['Identity'],
-            params: zodToJsonSchema(zod.object({name: zod.string()})),
+            params: zod.toJSONSchema(zod.object({name: zod.string()})),
             response: {
                 200: schemas.jsonEntitySchema,
                 401: schemas.jsonErrorBodyResponse,

package/src/routes/TenantRoutes.ts

@@ -7,7 +7,7 @@ import {TenantSchema, TenantBaseSchema} from '../schemas/TenantSchema.js'
 async function TenantRoutes(fastify, options) {
 
     const controller: TenantController = new TenantController()
-    const schemas = new CrudSchemaBuilder(TenantSchema, TenantBaseSchema,TenantBaseSchema, 'tenant', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(TenantSchema, TenantBaseSchema,TenantBaseSchema, 'tenant', 'openapi-3.0', ['Identity']);
 
     //Getters
     fastify.get('/api/tenants/search', {schema: schemas.searchSchema}, (req, rep) => controller.search(req, rep))

package/src/routes/UserLoginFailRoutes.ts

@@ -6,7 +6,7 @@ import {UserLoginFailSchema, UserLoginFailBaseSchema} from '../schemas/UserLogin
 async function UserLoginFailRoutes(fastify, options) {
 
     const controller: UserLoginFailController = new UserLoginFailController()
-    const schemas = new CrudSchemaBuilder(UserLoginFailSchema, UserLoginFailBaseSchema,UserLoginFailBaseSchema, 'UserLoginFail', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(UserLoginFailSchema, UserLoginFailBaseSchema,UserLoginFailBaseSchema, 'UserLoginFail', 'openapi-3.0', ['Identity']);
 
     fastify.get('/api/user-login-fails', {schema: schemas.paginateSchema}, (req,rep) => controller.paginate(req,rep))
 

package/src/routes/UserRoutes.ts

@@ -1,5 +1,4 @@
 import UserController from "../controllers/UserController.js";
-import {zodToJsonSchema} from "zod-to-json-schema";
 import {CrudSchemaBuilder} from "@drax/crud-back";
 import {LoginBodyRequestSchema, LoginBodyResponseSchema} from "../schemas/LoginSchema.js"
 import {UserSchema, UserCreateSchema, UserUpdateSchema} from "../schemas/UserSchema.js";
@@ -10,11 +9,12 @@ import {
     PasswordBodyResponseSchema
 } from "../schemas/PasswordSchema.js";
 import {SwitchTenantBodyRequestSchema, SwitchTenantBodyResponseSchema} from "../schemas/SwitchTenantSchema.js";
+import zod from "zod"
 
 async function UserRoutes(fastify, options) {
 
     const controller: UserController = new UserController()
-    const schemas = new CrudSchemaBuilder(UserSchema, UserCreateSchema, UserUpdateSchema, 'tenant', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(UserSchema, UserCreateSchema, UserUpdateSchema, 'tenant', 'openapi-3.0', ['Identity']);
 
 
     fastify.get('/api/users/search', {schema: schemas.searchSchema}, async (req, rep) => await controller.search(req, rep))
@@ -35,9 +35,9 @@ async function UserRoutes(fastify, options) {
         {
             schema: {
                 tags: ['Auth'],
-                body: zodToJsonSchema(LoginBodyRequestSchema),
+                body: zod.toJSONSchema(LoginBodyRequestSchema),
                 response: {
-                    200: zodToJsonSchema(LoginBodyResponseSchema),
+                    200: zod.toJSONSchema(LoginBodyResponseSchema),
                     400: schemas.jsonErrorBodyResponse,
                 },
             },
@@ -59,9 +59,9 @@ async function UserRoutes(fastify, options) {
         {
             schema: {
                 tags: ['Auth'],
-                body: zodToJsonSchema(SwitchTenantBodyRequestSchema),
+                body: zod.toJSONSchema(SwitchTenantBodyRequestSchema),
                 response: {
-                    200: zodToJsonSchema(SwitchTenantBodyResponseSchema),
+                    200: zod.toJSONSchema(SwitchTenantBodyResponseSchema),
                     400: schemas.jsonErrorBodyResponse,
                 },
             },
@@ -72,9 +72,9 @@ async function UserRoutes(fastify, options) {
     fastify.post('/api/users/register', {
         schema: {
             tags: ['Auth'],
-            body: zodToJsonSchema(RegisterBodyRequestSchema),
+            body: zod.toJSONSchema(RegisterBodyRequestSchema),
             response: {
-                200: zodToJsonSchema(RegisterBodyResponseSchema),
+                200: zod.toJSONSchema(RegisterBodyResponseSchema),
                 400: schemas.jsonErrorBodyResponse,
                 500: schemas.jsonErrorBodyResponse,
             },
@@ -96,8 +96,8 @@ async function UserRoutes(fastify, options) {
     fastify.post('/api/users/password/change', {
         schema: {
             tags: ['Auth'],
-            body: zodToJsonSchema(MyPasswordBodyRequestSchema),
-            200: zodToJsonSchema(PasswordBodyResponseSchema),
+            body: zod.toJSONSchema(MyPasswordBodyRequestSchema),
+            200: zod.toJSONSchema(PasswordBodyResponseSchema),
             400: schemas.jsonErrorBodyResponse,
             500: schemas.jsonErrorBodyResponse,
         }
@@ -106,8 +106,8 @@ async function UserRoutes(fastify, options) {
     fastify.post('/api/users/password/change/:id', {
         schema: {
             tags: ['Auth'],
-            body: zodToJsonSchema(PasswordBodyRequestSchema),
-            200: zodToJsonSchema(PasswordBodyResponseSchema),
+            body: zod.toJSONSchema(PasswordBodyRequestSchema),
+            200: zod.toJSONSchema(PasswordBodyResponseSchema),
             400: schemas.jsonErrorBodyResponse,
             500: schemas.jsonErrorBodyResponse,
         }

package/src/routes/UserSessionRoutes.ts

@@ -6,7 +6,7 @@ import {UserSessionSchema, UserSessionBaseSchema} from '../schemas/UserSessionSc
 async function UserSessionRoutes(fastify, options) {
 
     const controller: UserSessionController = new UserSessionController()
-    const schemas = new CrudSchemaBuilder(UserSessionSchema, UserSessionBaseSchema,UserSessionBaseSchema, 'UserSession', 'openApi3', ['Identity']);
+    const schemas = new CrudSchemaBuilder(UserSessionSchema, UserSessionBaseSchema,UserSessionBaseSchema, 'UserSession', 'openapi-3.0', ['Identity']);
 
     fastify.get('/api/user-sessions', {schema: schemas.paginateSchema}, (req,rep) => controller.paginate(req,rep))
 

package/src/schemas/RegisterSchema.ts

@@ -1,14 +1,13 @@
-import z, {string} from "zod"
+import z, {string, email} from "zod"
 
 const RegisterBodyRequestSchema = z.object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    username: string({ required_error: "validation.required" })
+    username: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    email: string({ required_error: "validation.required" })
-        .email("validation.email.invalid"),
-    phone: string({ required_error: "validation.required" }).optional(),
-    password: string({ required_error: "validation.required" })
+    email: email("validation.email.invalid"),
+    phone: string({ error: "validation.required" }).optional(),
+    password: string({ error: "validation.required" })
         .min(1, "validation.required")
         .min(8, "validation.password.min8")
         .max(64, "validation.password.max64"),

package/src/schemas/RoleSchema.ts

@@ -1,7 +1,7 @@
-import {date, object, string, array, boolean} from "zod"
+import { object, string, array, boolean, iso} from "zod"
 
 const RoleBaseSchema = object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required")
         .regex(/^[A-Z]/, "validation.startWithUpperCase"),
     permissions: array(string()).optional(),
@@ -22,8 +22,8 @@ const RoleSchema = RoleBaseSchema.extend({
         id: string().optional(),
         name: string()
     })).optional(),
-    createdAt: date().optional(),
-    updatedAt: date().optional()
+    createdAt: iso.datetime().optional(),
+    updatedAt: iso.datetime().optional()
 })
 
 

package/src/schemas/TenantSchema.ts

@@ -1,7 +1,7 @@
-import { object, string, date, record, any } from "zod"
+import { object, string,  record, any, iso } from "zod"
 
 const TenantBaseSchema = object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required")
         //.regex(/^[A-Z]/, "validation.startWithUpperCase"),
 })
@@ -11,8 +11,8 @@ const TenantSchema = TenantBaseSchema.extend({
     _id: string(),
     id: string().optional(),
     custom: record(string(), any()).optional(),
-    createdAt: date(),
-    updatedAt: date()
+    createdAt: iso.datetime().optional(),
+    updatedAt: iso.datetime().optional()
 });
 
 

package/src/schemas/UserApiKeySchema.ts

@@ -1,10 +1,10 @@
-import {array, object, string} from "zod"
+import {array, object, string, ipv4, ipv6} from "zod"
 
 const UserApiKeyBaseSchema = object({
-    name: string({ required_error: "validation.required" })
+    name: string({ error: "validation.required" })
         .min(1, "validation.required"),
-    ipv4: array(string().ip({version: "v4", message: 'validation.invalidIpv4'})),
-    ipv6: array(string().ip({version: "v6", message: 'validation.invalidIpv6'})),
+    ipv4: array(ipv4({ message: 'validation.invalidIpv4'})),
+    ipv6: array(ipv6({ message: 'validation.invalidIpv6'})),
 
 })
 

package/src/schemas/UserLoginFailSchema.ts

@@ -11,7 +11,7 @@ const UserLoginFailBaseSchema = z.object({
 const UserLoginFailSchema = UserLoginFailBaseSchema
     .extend({
         _id: z.string(),
-        createdAt: z.coerce.date().nullable().optional()
+        createdAt: z.iso.datetime().nullable().optional()
     })
 
 export default UserLoginFailSchema;

package/src/schemas/UserSchema.ts

@@ -1,23 +1,22 @@
-import {date, object, string, boolean, array, record, any} from "zod"
+import {email, iso,  object, string, boolean, array, record, any} from "zod"
 
 const UserBaseSchema = object({
-    name: string({required_error: "validation.required"})
+    name: string({error: "validation.required"})
         .min(1, "validation.required"),
-    username: string({required_error: "validation.required"})
+    username: string({error: "validation.required"})
         .min(1, "validation.required"),
-    email: string({required_error: "validation.required"})
-        .email("validation.email.invalid"),
-    phone: string({required_error: "validation.required"}).optional(),
+    email: email("validation.email.invalid"),
+    phone: string({error: "validation.required"}).optional(),
     active: boolean().optional(),
-    role: string({required_error: "validation.required"})
+    role: string({error: "validation.required"})
         .min(1, "validation.required"),
-    tenant: string({required_error: "validation.required"}).nullable().optional()
+    tenant: string({error: "validation.required"}).nullable().optional()
 
 
 })
 
 const UserCreateSchema = UserBaseSchema.extend({
-    password: string({required_error: "validation.required"})
+    password: string({error: "validation.required"})
         .min(1, "validation.required")
         .min(8, "validation.password.min8")
         .max(64, "validation.password.max64"),
@@ -44,8 +43,8 @@ const UserSchema = UserBaseSchema
             id: string().optional(),
             name: string(),
             custom: record(string(), any()).optional(),
-        }).nullable().optional(),
-        createdAt: date().optional(),
+        }).nullish(),
+        createdAt: iso.datetime().optional(),
         avatar: string().optional()
     });
 

package/src/schemas/UserSessionSchema.ts

@@ -13,7 +13,7 @@ const UserSessionSchema = UserSessionBaseSchema
     .extend({
         _id: z.string(),
         user: z.object({_id: z.string(), username: z.string()}),
-        createdAt: z.coerce.date().nullable().optional()
+        createdAt: z.iso.datetime().nullable().optional()
     })
 
 export default UserSessionSchema;

package/test/schemas/lab-schema.test.ts

@@ -37,7 +37,7 @@ describe("Test Schema", function () {
             }).optional().nullable()
         })
 
-        let jsonSchema = zodToJsonSchema(zSchema,{target:'openApi3'})
+        let jsonSchema = zodToJsonSchema(zSchema,{target:'openapi-3.0'})
         console.log("jsonUserSchema", JSON.stringify(jsonSchema, null,4))
 
         let row1 = {