@drax/identity-back 0.11.4 → 0.12.1

package/dist/repository/sqlite/UserSqliteRepository.js

@@ -1,130 +1,79 @@
-import sqlite from "better-sqlite3";
-import { randomUUID } from "node:crypto";
-import { SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort, ValidationError } from "@drax/common-back";
+import { ValidationError } from "@drax/common-back";
 import RoleSqliteRepository from "./RoleSqliteRepository.js";
 import TenantSqliteRepository from "./TenantSqliteRepository.js";
-const tableFields = [
-    { name: "name", type: "TEXT", unique: false, primary: false },
-    { name: "username", type: "TEXT", unique: true, primary: false },
-    { name: "active", type: "INTEGER", unique: false, primary: false },
-    { name: "active", type: "INTEGER", unique: false, primary: false },
-    { name: "password", type: "TEXT", unique: false, primary: false },
-    { name: "email", type: "TEXT", unique: true, primary: false },
-    { name: "phone", type: "TEXT", unique: false, primary: false },
-    { name: "role", type: "TEXT", unique: false, primary: false },
-    { name: "tenant", type: "TEXT", unique: false, primary: false },
-    { name: "groups", type: "TEXT", unique: false, primary: false },
-    { name: "avatar", type: "TEXT", unique: false, primary: false },
-    { name: "origin", type: "TEXT", unique: false, primary: false },
-    { name: "createdAt", type: "TEXT", unique: false, primary: false },
-    { name: "updatedAt", type: "TEXT", unique: false, primary: false },
-    { name: "emailVerified", type: "INTEGER", unique: false, primary: false },
-    { name: "phoneVerified", type: "INTEGER", unique: false, primary: false },
-    { name: "emailCode", type: "TEXT", unique: false, primary: false },
-    { name: "phoneCode", type: "TEXT", unique: false, primary: false },
-];
-class UserSqliteRepository {
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class UserSqliteRepository extends AbstractSqliteRepository {
     constructor(dataBaseFile, verbose = false) {
-        this.dataBaseFile = dataBaseFile;
-        this.db = new sqlite(dataBaseFile, { verbose: verbose ? console.log : null });
+        super(dataBaseFile, verbose);
+        this.tableName = 'users';
+        this.searchFields = [];
+        this.booleanFields = ['active'];
+        this.identifier = '_id';
+        this.populateFields = [];
+        this.tableFields = [
+            { name: "name", type: "TEXT", unique: false, primary: false },
+            { name: "username", type: "TEXT", unique: true, primary: false },
+            { name: "active", type: "INTEGER", unique: false, primary: false },
+            { name: "password", type: "TEXT", unique: false, primary: false },
+            { name: "email", type: "TEXT", unique: true, primary: false },
+            { name: "phone", type: "TEXT", unique: false, primary: false },
+            { name: "role", type: "TEXT", unique: false, primary: false },
+            { name: "tenant", type: "TEXT", unique: false, primary: false },
+            { name: "groups", type: "TEXT", unique: false, primary: false },
+            { name: "avatar", type: "TEXT", unique: false, primary: false },
+            { name: "origin", type: "TEXT", unique: false, primary: false },
+            { name: "createdAt", type: "TEXT", unique: false, primary: false },
+            { name: "updatedAt", type: "TEXT", unique: false, primary: false },
+            { name: "emailVerified", type: "INTEGER", unique: false, primary: false },
+            { name: "phoneVerified", type: "INTEGER", unique: false, primary: false },
+            { name: "emailCode", type: "TEXT", unique: false, primary: false },
+            { name: "phoneCode", type: "TEXT", unique: false, primary: false },
+        ];
         this.roleRepository = new RoleSqliteRepository(dataBaseFile, verbose);
         this.tenantRepository = new TenantSqliteRepository(dataBaseFile, verbose);
-        this.table();
     }
-    table() {
-        const builder = new SqliteTableBuilder(this.dataBaseFile, 'users', tableFields, false);
-        builder.build('id');
-    }
-    normalizeData(userData) {
+    async prepareData(userData) {
         if (userData.groups && Array.isArray(userData.groups)) {
             userData.groups = userData.groups.join(",");
         }
         userData.active = userData.active ? 1 : 0;
-    }
-    async create(userData) {
-        if (!userData.id) {
-            userData.id = randomUUID();
-        }
         if (!await this.findRoleById(userData.role)) {
             throw new ValidationError([{ field: 'role', reason: 'validation.notfound', value: userData.role }]);
         }
-        userData.createdAt = (new Date().toISOString());
-        this.normalizeData(userData);
-        try {
-            const fields = Object.keys(userData)
-                .map(field => `${field}`)
-                .join(', ');
-            const values = Object.keys(userData)
-                .map(field => `@${field}`)
-                .join(', ');
-            const stmt = this.db.prepare(`INSERT INTO users (${fields})
-                                          VALUES (${values})`);
-            stmt.run(userData);
-            return this.findById(userData.id);
+    }
+    async prepareItem(user) {
+        if (user && user.role) {
+            user.role = await this.findRoleById(user.role);
         }
-        catch (e) {
-            throw SqliteErrorToValidationError(e, userData);
+        if (user && user.tenant) {
+            user.tenant = await this.findTenantById(user.tenant);
         }
     }
     async updatePartial(id, userData) {
         return this.update(id, userData);
     }
-    async update(id, userData) {
-        try {
-            if (!await this.findRoleById(userData.role)) {
-                throw new ValidationError([{ field: 'role', reason: 'validation.notfound', value: userData.role }]);
-            }
-            userData.updatedAt = (new Date().toISOString());
-            this.normalizeData(userData);
-            const setClauses = Object.keys(userData)
-                .map(field => `${field} = @${field}`)
-                .join(', ');
-            userData.id = id;
-            const stmt = this.db.prepare(`UPDATE users
-                                          SET ${setClauses}
-                                          WHERE id = @id `);
-            stmt.run(userData);
-        }
-        catch (e) {
-            throw SqliteErrorToValidationError(e, userData);
-        }
-        return this.findById(id);
-    }
-    async delete(id) {
-        const stmt = this.db.prepare('DELETE FROM users WHERE id = ?');
-        stmt.run(id);
-        return true;
-    }
-    async deleteAll() {
-        const stmt = this.db.prepare('DELETE FROM users');
-        stmt.run();
-        return true;
-    }
-    async findById(id) {
-        const user = this.db.prepare('SELECT * FROM users WHERE id = ?').get(id);
+    async findByUsername(username) {
+        const user = this.db.prepare('SELECT * FROM users WHERE username = ?').get(username);
         if (!user) {
             return null;
         }
-        user.role = await this.findRoleById(user.role);
-        user.tenant = await this.findTenantById(user.tenant);
+        await this.decorate(user);
         return user;
     }
-    async findByUsername(username) {
+    async findByUsernameWithPassword(username) {
         const user = this.db.prepare('SELECT * FROM users WHERE username = ?').get(username);
         if (!user) {
             return null;
         }
-        user.role = await this.findRoleById(user.role);
-        user.tenant = await this.findTenantById(user.tenant);
+        await this.decorate(user);
         return user;
     }
-    async findByUsernameWithPassword(username) {
-        const user = this.db.prepare('SELECT * FROM users WHERE username = ?').get(username);
+    async findByIdWithPassword(id) {
+        const user = this.db.prepare('SELECT * FROM users WHERE ${this.identifier} = ?').get(id);
         if (!user) {
             return null;
         }
-        user.role = await this.findRoleById(user.role);
-        user.tenant = await this.findTenantById(user.tenant);
+        await this.decorate(user);
         return user;
     }
     async findByEmail(email) {
@@ -132,8 +81,7 @@ class UserSqliteRepository {
         if (!user) {
             return null;
         }
-        user.role = await this.findRoleById(user.role);
-        user.tenant = await this.findTenantById(user.tenant);
+        await this.decorate(user);
         return user;
     }
     async findByEmailCode(code) {
@@ -141,8 +89,7 @@ class UserSqliteRepository {
         if (!user) {
             return null;
         }
-        user.role = await this.findRoleById(user.role);
-        user.tenant = await this.findTenantById(user.tenant);
+        await this.decorate(user);
         return user;
     }
     async findByRecoveryCode(code) {
@@ -150,8 +97,7 @@ class UserSqliteRepository {
         if (!user) {
             return null;
         }
-        user.role = await this.findRoleById(user.role);
-        user.tenant = await this.findTenantById(user.tenant);
+        await this.decorate(user);
         return user;
     }
     async findByPhoneCode(code) {
@@ -159,36 +105,9 @@ class UserSqliteRepository {
         if (!user) {
             return null;
         }
-        user.role = await this.findRoleById(user.role);
-        user.tenant = await this.findTenantById(user.tenant);
+        await this.decorate(user);
         return user;
     }
-    async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
-        const offset = page > 1 ? (page - 1) * limit : 0;
-        let where = "";
-        if (search) {
-            where = ` WHERE (name LIKE '%${search}%' OR username LIKE '%${search}%') `;
-        }
-        where = SqlQueryFilter.applyFilters(where, filters);
-        const sort = SqlSort.applySort(orderBy, order);
-        console.log("paginate where ", where, "search", search, "filters", filters);
-        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM users' + where).get();
-        where += sort;
-        const users = this.db.prepare('SELECT * FROM users' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
-        for (const user of users) {
-            let role = await this.findRoleById(user.role);
-            user.role = role ? role : null;
-            let tenant = await this.findTenantById(user.tenant);
-            user.tenant = tenant ? tenant : null;
-            user.active = user.active === 1;
-        }
-        return {
-            page: page,
-            limit: limit,
-            total: rCount.count,
-            items: users
-        };
-    }
     async findRoleById(id) {
         return await this.roleRepository.findById(id);
     }
@@ -198,14 +117,14 @@ class UserSqliteRepository {
     async changePassword(id, password) {
         const stmt = this.db.prepare(`UPDATE users
                                       SET password = @password
-                                      WHERE id = @id `);
+                                      WHERE ${this.identifier} = @id `);
         stmt.run({ id: id, password: password });
         return true;
     }
     async changeAvatar(id, avatar) {
         const stmt = this.db.prepare(`UPDATE users
                                       SET avatar = @avatar
-                                      WHERE id = @id `);
+                                      WHERE ${this.identifier} = @id `);
         stmt.run({ id: id, avatar: avatar });
         return true;
     }

package/dist/routes/RoleRoutes.js

@@ -1,16 +1,41 @@
 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();
-    fastify.get('/api/permissions', (req, rep) => controller.permissions(req, rep));
-    fastify.get('/api/roles/export', (req, rep) => controller.export(req, rep));
-    fastify.get('/api/roles/search', (req, rep) => controller.search(req, rep));
-    fastify.get('/api/roles/:id', (req, rep) => controller.findById(req, rep));
-    fastify.get('/api/roles/name/:name', (req, rep) => controller.findByName(req, rep));
-    fastify.get('/api/roles/all', (req, rep) => controller.all(req, rep));
-    fastify.get('/api/roles', (req, rep) => controller.paginate(req, rep));
-    fastify.post('/api/roles', (req, rep) => controller.create(req, rep));
-    fastify.put('/api/roles/:id', (req, rep) => controller.update(req, rep));
-    fastify.delete('/api/roles/:id', (req, rep) => controller.delete(req, rep));
+    const schemas = new CrudSchemaBuilder(RoleSchema, RoleBaseSchema, RoleBaseSchema, 'role', 'openApi3', ['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));
+    fastify.get('/api/roles', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.post('/api/roles', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));
+    fastify.put('/api/roles/:id', { schema: schemas.updateSchema }, (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/roles/:id', { schema: schemas.deleteSchema }, (req, rep) => controller.delete(req, rep));
+    fastify.get('/api/roles/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));
+    fastify.get('/api/permissions', {
+        schema: {
+            tags: ['Identity'],
+            response: {
+                200: zodToJsonSchema(zod.array(zod.string())),
+                401: schemas.jsonErrorBodyResponse,
+                403: schemas.jsonErrorBodyResponse,
+            }
+        }
+    }, (req, rep) => controller.permissions(req, rep));
+    fastify.get('/api/roles/name/:name', {
+        schema: {
+            tags: ['Identity'],
+            params: zodToJsonSchema(zod.object({ name: zod.string() })),
+            response: {
+                200: schemas.jsonEntitySchema,
+                401: schemas.jsonErrorBodyResponse,
+                403: schemas.jsonErrorBodyResponse,
+                404: schemas.jsonErrorBodyResponse,
+            }
+        }
+    }, (req, rep) => controller.findByName(req, rep));
 }
 export default RoleRoutes;
 export { RoleRoutes };

package/dist/routes/TenantRoutes.js

@@ -1,15 +1,24 @@
+import { CrudSchemaBuilder } from "@drax/crud-back";
 import TenantController from '../controllers/TenantController.js';
+import { TenantSchema, TenantBaseSchema } from '../schemas/TenantSchema.js';
 async function TenantRoutes(fastify, options) {
     const controller = new TenantController();
-    fastify.get('/api/tenants/export', (req, rep) => controller.export(req, rep));
-    fastify.get('/api/tenants/search', (req, rep) => controller.search(req, rep));
-    fastify.get('/api/tenants/:id', (req, rep) => controller.findById(req, rep));
-    fastify.get('/api/tenants/name/:name', (req, rep) => controller.findByName(req, rep));
-    fastify.get('/api/tenants/all', (req, rep) => controller.all(req, rep));
-    fastify.get('/api/tenants', (req, rep) => controller.paginate(req, rep));
-    fastify.post('/api/tenants', (req, rep) => controller.create(req, rep));
-    fastify.put('/api/tenants/:id', (req, rep) => controller.update(req, rep));
-    fastify.delete('/api/tenants/:id', (req, rep) => controller.delete(req, rep));
+    const schemas = new CrudSchemaBuilder(TenantSchema, TenantBaseSchema, TenantBaseSchema, 'tenant', 'openApi3', ['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));
+    fastify.get('/api/tenants/all', { schema: schemas.allSchema }, (req, rep) => controller.all(req, rep));
+    fastify.get('/api/tenants/find', { schema: schemas.findSchema }, (req, rep) => controller.find(req, rep));
+    fastify.get('/api/tenants/find-one', { schema: schemas.findOneSchema }, (req, rep) => controller.findOne(req, rep));
+    fastify.get('/api/tenants/find-by/:field/:value', { schema: schemas.findBySchema }, (req, rep) => controller.findBy(req, rep));
+    fastify.get('/api/tenants/find-one-by/:field/:value', { schema: schemas.findOneBySchema }, (req, rep) => controller.findOneBy(req, rep));
+    fastify.get('/api/tenants', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    //Mutations
+    fastify.post('/api/tenants', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));
+    fastify.put('/api/tenants/:id', { schema: schemas.updateSchema }, (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/tenants/:id', { schema: schemas.deleteSchema }, (req, rep) => controller.delete(req, rep));
+    //Others
+    fastify.get('/api/tenants/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));
 }
 export default TenantRoutes;
 export { TenantRoutes };

package/dist/routes/UserApiKeyRoutes.js

@@ -1,10 +1,26 @@
 import UserApiKeyController from "../controllers/UserApiKeyController.js";
 async function UserApiKeyRoutes(fastify, options) {
     const controller = new UserApiKeyController();
-    fastify.get('/api/user-api-keys', (req, rep) => controller.paginate(req, rep));
-    fastify.post('/api/user-api-keys', (req, rep) => controller.create(req, rep));
-    fastify.put('/api/user-api-keys/:id', (req, rep) => controller.update(req, rep));
-    fastify.delete('/api/user-api-keys/:id', (req, rep) => controller.delete(req, rep));
+    fastify.get('/api/user-api-keys', {
+        schema: {
+            tags: ['Identity'],
+        }
+    }, (req, rep) => controller.paginate(req, rep));
+    fastify.post('/api/user-api-keys', {
+        schema: {
+            tags: ['Identity'],
+        }
+    }, (req, rep) => controller.create(req, rep));
+    fastify.put('/api/user-api-keys/:id', {
+        schema: {
+            tags: ['Identity'],
+        }
+    }, (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/user-api-keys/:id', {
+        schema: {
+            tags: ['Identity'],
+        }
+    }, (req, rep) => controller.delete(req, rep));
 }
 export default UserApiKeyRoutes;
 export { UserApiKeyRoutes };

package/dist/routes/UserRoutes.js

@@ -1,23 +1,98 @@
 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";
 async function UserRoutes(fastify, options) {
     const controller = new UserController();
-    fastify.post('/api/auth/login', (req, rep) => controller.auth(req, rep));
-    fastify.get('/api/auth/me', (req, rep) => controller.me(req, rep));
-    fastify.get('/api/users/search', (req, rep) => controller.search(req, rep));
-    fastify.get('/api/users/export', (req, rep) => controller.export(req, rep));
-    fastify.get('/api/users', (req, rep) => controller.paginate(req, rep));
-    fastify.post('/api/users', (req, rep) => controller.create(req, rep));
-    fastify.put('/api/users/:id', (req, rep) => controller.update(req, rep));
-    fastify.delete('/api/users/:id', (req, rep) => controller.delete(req, rep));
-    fastify.post('/api/users/register', (req, rep) => controller.register(req, rep));
-    fastify.get('/api/users/verify-email/:code', (req, rep) => controller.verifyEmail(req, rep));
-    fastify.get('/api/users/verify-phone/:code', (req, rep) => controller.verifyPhone(req, rep));
-    fastify.post('/api/users/password/change', (req, rep) => controller.changeMyPassword(req, rep));
-    fastify.post('/api/users/password/change/:id', (req, rep) => controller.changePassword(req, rep));
-    fastify.post('/api/users/password/recovery/request', (req, rep) => controller.passwordRecoveryRequest(req, rep));
-    fastify.post('/api/users/password/recovery/complete', (req, rep) => controller.recoveryPasswordComplete(req, rep));
-    fastify.post('/api/users/avatar', (req, rep) => controller.updateAvatar(req, rep));
-    fastify.get('/api/users/avatar/:filename', (req, rep) => controller.getAvatar(req, rep));
+    const schemas = new CrudSchemaBuilder(UserSchema, UserCreateSchema, UserUpdateSchema, 'tenant', 'openApi3', ['Identity']);
+    fastify.get('/api/users/search', { schema: schemas.searchSchema }, async (req, rep) => await controller.search(req, rep));
+    fastify.get('/api/users/export', { schema: schemas.exportSchema }, (req, rep) => controller.export(req, rep));
+    fastify.get('/api/users', { schema: schemas.paginateSchema }, (req, rep) => controller.paginate(req, rep));
+    fastify.post('/api/users', { schema: schemas.createSchema }, (req, rep) => controller.create(req, rep));
+    fastify.put('/api/users/:id', { schema: schemas.updateSchema }, (req, rep) => controller.update(req, rep));
+    fastify.delete('/api/users/:id', { schema: schemas.deleteSchema }, (req, rep) => controller.delete(req, rep));
+    fastify.post('/api/auth/login', {
+        schema: {
+            tags: ['Auth'],
+            body: zodToJsonSchema(LoginBodyRequestSchema),
+            response: {
+                200: zodToJsonSchema(LoginBodyResponseSchema),
+                400: schemas.jsonErrorBodyResponse,
+            },
+        },
+    }, (req, rep) => controller.auth(req, rep));
+    fastify.get('/api/auth/me', {
+        schema: {
+            tags: ['Auth'],
+            response: {
+                200: schemas.jsonEntitySchema,
+                401: schemas.jsonErrorBodyResponse,
+                500: schemas.jsonErrorBodyResponse,
+            },
+        },
+    }, (req, rep) => controller.me(req, rep));
+    fastify.post('/api/users/register', {
+        schema: {
+            tags: ['Auth'],
+            body: zodToJsonSchema(RegisterBodyRequestSchema),
+            response: {
+                200: zodToJsonSchema(RegisterBodyResponseSchema),
+                400: schemas.jsonErrorBodyResponse,
+                500: schemas.jsonErrorBodyResponse,
+            },
+        },
+    }, (req, rep) => controller.register(req, rep));
+    fastify.get('/api/users/verify-email/:code', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.verifyEmail(req, rep));
+    fastify.get('/api/users/verify-phone/:code', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.verifyPhone(req, rep));
+    fastify.post('/api/users/password/change', {
+        schema: {
+            tags: ['Auth'],
+            body: zodToJsonSchema(MyPasswordBodyRequestSchema),
+            200: zodToJsonSchema(PasswordBodyResponseSchema),
+            400: schemas.jsonErrorBodyResponse,
+            500: schemas.jsonErrorBodyResponse,
+        }
+    }, (req, rep) => controller.changeMyPassword(req, rep));
+    fastify.post('/api/users/password/change/:id', {
+        schema: {
+            tags: ['Auth'],
+            body: zodToJsonSchema(PasswordBodyRequestSchema),
+            200: zodToJsonSchema(PasswordBodyResponseSchema),
+            400: schemas.jsonErrorBodyResponse,
+            500: schemas.jsonErrorBodyResponse,
+        }
+    }, (req, rep) => controller.changePassword(req, rep));
+    fastify.post('/api/users/password/recovery/request', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.passwordRecoveryRequest(req, rep));
+    fastify.post('/api/users/password/recovery/complete', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.recoveryPasswordComplete(req, rep));
+    fastify.post('/api/users/avatar', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.updateAvatar(req, rep));
+    fastify.get('/api/users/avatar/:filename', {
+        schema: {
+            tags: ['Auth'],
+        }
+    }, (req, rep) => controller.getAvatar(req, rep));
 }
 export default UserRoutes;
 export { UserRoutes };

package/dist/schemas/LoginSchema.js

@@ -0,0 +1,9 @@
+import z from "zod";
+const LoginBodyRequestSchema = z.object({
+    username: z.string(),
+    password: z.string(),
+});
+const LoginBodyResponseSchema = z.object({
+    accessToken: z.string()
+});
+export { LoginBodyRequestSchema, LoginBodyResponseSchema };

package/dist/schemas/PasswordSchema.js

@@ -0,0 +1,12 @@
+import z from "zod";
+const MyPasswordBodyRequestSchema = z.object({
+    currentPassword: z.string(),
+    newPassword: z.string(),
+});
+const PasswordBodyRequestSchema = z.object({
+    newPassword: z.string()
+});
+const PasswordBodyResponseSchema = z.object({
+    message: z.string()
+});
+export { MyPasswordBodyRequestSchema, PasswordBodyRequestSchema, PasswordBodyResponseSchema };

package/dist/schemas/RegisterSchema.js

@@ -0,0 +1,19 @@
+import z, { string } from "zod";
+const RegisterBodyRequestSchema = z.object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    username: string({ required_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" })
+        .min(1, "validation.required")
+        .min(8, "validation.password.min8")
+        .max(64, "validation.password.max64"),
+});
+const RegisterBodyResponseSchema = z.object({
+    success: z.boolean(),
+    message: z.string().optional(),
+});
+export { RegisterBodyRequestSchema, RegisterBodyResponseSchema };

package/dist/schemas/RoleSchema.js

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

package/dist/schemas/TenantSchema.js

@@ -0,0 +1,13 @@
+import { object, string, date } from "zod";
+const TenantBaseSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .regex(/^[A-Z]/, "validation.startWithUpperCase"),
+});
+const TenantSchema = TenantBaseSchema.extend({
+    _id: string(),
+    id: string().optional(),
+    createdAt: date(),
+    updatedAt: date()
+});
+export { TenantSchema, TenantBaseSchema };

package/dist/schemas/UserApiKeySchema.js

@@ -0,0 +1,14 @@
+import { array, object, string } from "zod";
+const UserApiKeyBaseSchema = object({
+    name: string({ required_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' })),
+});
+const UserApiKeySchema = UserApiKeyBaseSchema.extend({
+    _id: string(),
+    id: string().optional(),
+    createdBy: string(),
+});
+export default UserApiKeyBaseSchema;
+export { UserApiKeyBaseSchema, UserApiKeySchema };

package/dist/schemas/UserSchema.js

@@ -0,0 +1,39 @@
+import { date, object, string, boolean, array } from "zod";
+const UserBaseSchema = object({
+    name: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    username: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    email: string({ required_error: "validation.required" })
+        .email("validation.email.invalid"),
+    phone: string({ required_error: "validation.required" }).optional(),
+    active: boolean().optional(),
+    role: string({ required_error: "validation.required" })
+        .min(1, "validation.required"),
+    tenant: string({ required_error: "validation.required" }).nullable().optional()
+});
+const UserCreateSchema = UserBaseSchema.extend({
+    password: string({ required_error: "validation.required" })
+        .min(1, "validation.required")
+        .min(8, "validation.password.min8")
+        .max(64, "validation.password.max64"),
+});
+const UserUpdateSchema = UserBaseSchema.extend({});
+const UserSchema = UserBaseSchema
+    .extend({
+    _id: string(),
+    role: object({
+        _id: string(),
+        id: string().optional(),
+        name: string(),
+        permissions: array(string())
+    }).optional(),
+    active: boolean(),
+    tenant: object({
+        _id: string(),
+        id: string().optional(),
+        name: string(),
+    }).nullable().optional(),
+    createdAt: date().optional()
+});
+export { UserBaseSchema, UserSchema, UserCreateSchema, UserUpdateSchema, };