@drax/identity-back 0.0.30 → 0.1.0

package/dist/config/IdentityConfig.js

@@ -1,11 +1,10 @@
 var IdentityConfig;
 (function (IdentityConfig) {
-    IdentityConfig["DbEngine"] = "DRAX_DB_ENGINE";
-    IdentityConfig["SqliteDbFile"] = "DRAX_SQLITE_FILE";
-    IdentityConfig["MongoDbUri"] = "DRAX_MONGO_URI";
     IdentityConfig["JwtSecret"] = "DRAX_JWT_SECRET";
     IdentityConfig["JwtExpiration"] = "DRAX_JWT_EXPIRATION";
     IdentityConfig["JwtIssuer"] = "DRAX_JWT_ISSUER";
+    IdentityConfig["ApiKeySecret"] = "DRAX_APIKEY_SECRET";
+    IdentityConfig["ApiKeyCacheTTL"] = "DRAX_APIKEY_CACHE_TTL";
     IdentityConfig["RbacCacheTTL"] = "DRAX_RBAC_CACHE_TTL";
     IdentityConfig["AvatarDir"] = "DRAX_AVATAR_DIR";
 })(IdentityConfig || (IdentityConfig = {}));

package/dist/factory/RoleServiceFactory.js

@@ -1,20 +1,21 @@
+import { DraxConfig, CommonConfig, COMMON } from "@drax/common-back";
 import RoleService from "../services/RoleService.js";
 import RoleMongoRepository from "../repository/mongo/RoleMongoRepository.js";
 import RoleSqliteRepository from "../repository/sqlite/RoleSqliteRepository.js";
-import { DbSetupUtils, DbEngine } from "../utils/DbSetupUtils.js";
 let roleService;
 const RoleServiceFactory = (verbose = false) => {
     if (!roleService) {
         let roleRepository;
-        switch (DbSetupUtils.getDbEngine()) {
-            case DbEngine.Mongo:
-                console.log("RoleServiceFactory DB ENGINE MONGODB");
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
                 roleRepository = new RoleMongoRepository();
                 break;
-            case DbEngine.Sqlite:
-                console.log("RoleServiceFactory DB ENGINE SQLITE");
-                roleRepository = new RoleSqliteRepository(DbSetupUtils.getDbConfig(), verbose);
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                roleRepository = new RoleSqliteRepository(dbFile, verbose);
                 break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
         }
         roleService = new RoleService(roleRepository);
     }

package/dist/factory/TenantServiceFactory.js

@@ -1,20 +1,21 @@
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
 import TenantService from "../services/TenantService.js";
 import TenantMongoRepository from "../repository/mongo/TenantMongoRepository.js";
 import TenantSqliteRepository from "../repository/sqlite/TenantSqliteRepository.js";
-import { DbSetupUtils, DbEngine } from "../utils/DbSetupUtils.js";
 let tenantService;
 const TenantServiceFactory = (verbose = false) => {
     if (!tenantService) {
         let tenantRepository;
-        switch (DbSetupUtils.getDbEngine()) {
-            case DbEngine.Mongo:
-                console.log("TenantServiceFactory DB ENGINE MONGODB");
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
                 tenantRepository = new TenantMongoRepository();
                 break;
-            case DbEngine.Sqlite:
-                console.log("TenantServiceFactory DB ENGINE SQLITE");
-                tenantRepository = new TenantSqliteRepository(DbSetupUtils.getDbConfig(), verbose);
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                tenantRepository = new TenantSqliteRepository(dbFile, verbose);
                 break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
         }
         tenantService = new TenantService(tenantRepository);
     }

package/dist/factory/UserApiKeyServiceFactory.js

@@ -0,0 +1,24 @@
+import UserApiKeyMongoRepository from "../repository/mongo/UserApiKeyMongoRepository.js";
+import UserApiKeyService from "../services/UserApiKeyService.js";
+import UserApiKeySqliteRepository from "../repository/sqlite/UserApiKeySqliteRepository.js";
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
+let userService;
+const UserApiKeyServiceFactory = (verbose = false) => {
+    if (!userService) {
+        let userRepository;
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
+                userRepository = new UserApiKeyMongoRepository();
+                break;
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                userRepository = new UserApiKeySqliteRepository(dbFile, verbose);
+                break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+        }
+        userService = new UserApiKeyService(userRepository);
+    }
+    return userService;
+};
+export default UserApiKeyServiceFactory;

package/dist/factory/UserServiceFactory.js

@@ -1,20 +1,21 @@
 import UserMongoRepository from "../repository/mongo/UserMongoRepository.js";
 import UserService from "../services/UserService.js";
 import UserSqliteRepository from "../repository/sqlite/UserSqliteRepository.js";
-import { DbEngine, DbSetupUtils } from "../utils/DbSetupUtils.js";
+import { COMMON, CommonConfig, DraxConfig } from "@drax/common-back";
 let userService;
 const UserServiceFactory = (verbose = false) => {
     if (!userService) {
         let userRepository;
-        switch (DbSetupUtils.getDbEngine()) {
-            case DbEngine.Mongo:
-                console.log("UserServiceFactory DB ENGINE MONGODB");
+        switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+            case COMMON.DB_ENGINES.MONGODB:
                 userRepository = new UserMongoRepository();
                 break;
-            case DbEngine.Sqlite:
-                console.log("UserServiceFactory DB ENGINE SQLITE");
-                userRepository = new UserSqliteRepository(DbSetupUtils.getDbConfig(), verbose);
+            case COMMON.DB_ENGINES.SQLITE:
+                const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile);
+                userRepository = new UserSqliteRepository(dbFile, verbose);
                 break;
+            default:
+                throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
         }
         userService = new UserService(userRepository);
     }

package/dist/graphql/resolvers/user-api-key.resolvers.js

@@ -0,0 +1,89 @@
+import UserApiKeyServiceFactory from "../../factory/UserApiKeyServiceFactory.js";
+import { IdentityPermissions } from "../../permissions/IdentityPermissions.js";
+import { ValidationError, ValidationErrorToGraphQLError } from "@drax/common-back";
+import { GraphQLError } from "graphql";
+import UnauthorizedError from "../../errors/UnauthorizedError.js";
+import * as crypto from "node:crypto";
+export default {
+    Query: {
+        paginateUserApiKey: async (_, { options = { page: 1, limit: 5, orderBy: "", orderDesc: false, search: "", filters: [] } }, { rbac, authUser }) => {
+            try {
+                rbac.assertAuthenticated();
+                rbac.assertOrPermissions([
+                    IdentityPermissions.ViewUserApiKey,
+                    IdentityPermissions.ViewMyUserApiKey
+                ]);
+                if (!Array.isArray(options.filters)) {
+                    options.filters = [];
+                }
+                if (!rbac.hasPermission(IdentityPermissions.ViewUserApiKey)) {
+                    options.filters.push({ field: "user", operator: "eq", value: rbac.authUser.id });
+                }
+                const userApiKeyService = UserApiKeyServiceFactory();
+                return await userApiKeyService.paginate(options);
+            }
+            catch (e) {
+                console.error("paginateUserApiKey", e);
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message);
+                }
+                throw new GraphQLError('error.server');
+            }
+        }
+    },
+    Mutation: {
+        createUserApiKey: async (_, { input }, { rbac }) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.CreateUserApiKey);
+                input.user = rbac.authUser.id;
+                input.secret = crypto.randomUUID();
+                const userApiKeyService = UserApiKeyServiceFactory(true);
+                return await userApiKeyService.create(input);
+            }
+            catch (e) {
+                console.error("createUserApiKey", e);
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e);
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message);
+                }
+                throw new GraphQLError('error.server');
+            }
+        },
+        updateUserApiKey: async (_, { id, input }, { rbac }) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.UpdateUserApiKey);
+                const userApiKeyService = UserApiKeyServiceFactory();
+                return await userApiKeyService.update(id, input);
+            }
+            catch (e) {
+                console.error("updateUserApiKey", e);
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e);
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message);
+                }
+                throw new GraphQLError('error.server');
+            }
+        },
+        deleteUserApiKey: async (_, { id }, { rbac }) => {
+            try {
+                rbac.assertPermission(IdentityPermissions.DeleteUserApiKey);
+                const userApiKeyService = UserApiKeyServiceFactory();
+                return await userApiKeyService.delete(id);
+            }
+            catch (e) {
+                console.error("deleteUserApiKey", e);
+                if (e instanceof ValidationError) {
+                    throw ValidationErrorToGraphQLError(e);
+                }
+                if (e instanceof UnauthorizedError) {
+                    throw new GraphQLError(e.message);
+                }
+                throw new GraphQLError('error.server');
+            }
+        }
+    }
+};

package/dist/graphql/resolvers/user.resolvers.js

@@ -13,7 +13,7 @@ export default {
                 if (authUser) {
                     let userService = UserServiceFactory();
                     let user = await userService.findById(authUser.id);
-                    delete user.password;
+                    user.password = undefined;
                     return user;
                 }
                 throw new UnauthorizedError();
@@ -27,7 +27,9 @@ export default {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewUser);
                 let userService = UserServiceFactory();
-                return await userService.findById(id);
+                let user = await userService.findById(id);
+                user.password = undefined;
+                return user;
             }
             catch (e) {
                 if (e instanceof UnauthorizedError) {
@@ -40,6 +42,9 @@ export default {
             try {
                 rbac.assertPermission(IdentityPermissions.ViewUser);
                 let userService = UserServiceFactory();
+                if (!options.filters) {
+                    options.filters = [];
+                }
                 if (rbac.getAuthUser.tenantId) {
                     options.filters.push({ field: 'tenant', operator: '$eq', value: rbac.getAuthUser.tenantId });
                 }

package/dist/graphql/types/tenant.graphql

@@ -1,6 +1,8 @@
 type Tenant {
     id: ID!
     name: String
+    createdAt: Date
+    updatedAt: Date
 }
 
 type TenantPaginated{

package/dist/graphql/types/user.graphql

@@ -8,6 +8,8 @@ type User {
     phone: String
     avatar: String
     active: Boolean
+    createdAt: Date
+    updatedAt: Date
 }
 
 type UserPaginated{

package/dist/graphql/types/userApiKey.graphql

@@ -0,0 +1,33 @@
+type UserApiKey {
+    id: ID!
+    name: String
+    secret: String
+    ipv4: [String]
+    ipv6: [String]
+    user: User
+    createdAt: Date
+    updatedAt: Date
+}
+
+type UserApiKeyPaginated{
+    total: Int
+    page: Int
+    limit: Int
+    items: [UserApiKey]
+}
+
+type Query{
+    paginateUserApiKey(options: PaginateOptions): UserApiKeyPaginated
+}
+
+input UserApiKeyInput{
+    name: String
+    ipv4: [String]
+    ipv6: [String]
+}
+
+type Mutation{
+    createUserApiKey(input: UserApiKeyInput): UserApiKey
+    updateUserApiKey(id: ID!, input: UserApiKeyInput): UserApiKey
+    deleteUserApiKey(id: ID!): Boolean
+}

package/dist/index.js

@@ -11,9 +11,11 @@ import { UserRoutes } from "./routes/UserRoutes.js";
 import { UserAvatarRoutes } from "./routes/UserAvatarRoutes.js";
 import { RoleRoutes } from "./routes/RoleRoutes.js";
 import { TenantRoutes } from "./routes/TenantRoutes.js";
+import { UserApiKeyRoutes } from "./routes/UserApiKeyRoutes.js";
 import AuthUtils from "./utils/AuthUtils.js";
 import { jwtMiddleware } from "./middleware/jwtMiddleware.js";
 import { rbacMiddleware } from "./middleware/rbacMiddleware.js";
+import { apiKeyMiddleware } from "./middleware/apiKeyMiddleware.js";
 import IdentityPermissions from "./permissions/IdentityPermissions.js";
 import IdentityConfig from "./config/IdentityConfig.js";
 import UnauthorizedError from "./errors/UnauthorizedError.js";
@@ -34,9 +36,9 @@ UserServiceFactory, RoleServiceFactory, TenantServiceFactory,
 //GQL
 identityTypeDefs, identityResolvers, 
 //API REST
-UserRoutes, RoleRoutes, TenantRoutes, UserAvatarRoutes, AuthUtils, 
+UserRoutes, RoleRoutes, TenantRoutes, UserAvatarRoutes, UserApiKeyRoutes, AuthUtils, 
 //API MIDDLEWARE
-jwtMiddleware, rbacMiddleware, 
+jwtMiddleware, rbacMiddleware, apiKeyMiddleware, 
 //Permissions
 IdentityPermissions, 
 //Config

package/dist/interfaces/IUserApiKeyRepository.js

@@ -0,0 +1 @@
+export {};

package/dist/middleware/apiKeyMiddleware.js

@@ -0,0 +1,30 @@
+import { DraxCache, DraxConfig } from "@drax/common-back";
+import UserApiKeyServiceFactory from "../factory/UserApiKeyServiceFactory.js";
+import IdentityConfig from "../config/IdentityConfig.js";
+const cacheTTL = DraxConfig.getOrLoad(IdentityConfig.ApiKeyCacheTTL) ? parseInt(DraxConfig.getOrLoad(IdentityConfig.ApiKeyCacheTTL)) : 10000;
+const draxCache = new DraxCache(cacheTTL);
+async function userApiKeyLoader(k) {
+    const userApiKeyService = UserApiKeyServiceFactory();
+    const userApiKey = await userApiKeyService.findBySecret(k);
+    return userApiKey;
+}
+async function apiKeyMiddleware(request, reply) {
+    try {
+        const apiKey = request.headers['x-api-key'];
+        if (apiKey) {
+            const userApiKey = await draxCache.getOrLoad(apiKey, userApiKeyLoader);
+            if (userApiKey && userApiKey.user) {
+                request.authUser = userApiKey.user;
+                request.authUser.roleId = userApiKey.user.role.id;
+                request.authUser.tenantId = userApiKey.user.tenant.id;
+            }
+        }
+        return;
+    }
+    catch (e) {
+        console.error(e);
+        reply.code(500).send({ error: 'APIKEY ERROR' });
+    }
+}
+export default apiKeyMiddleware;
+export { apiKeyMiddleware };

package/dist/middleware/rbacMiddleware.js

@@ -11,7 +11,6 @@ async function roleLoader(k) {
 }
 async function rbacMiddleware(request, reply) {
     try {
-        //console.log("rbacMiddleware authUser",request.authUser)
         if (request.authUser) {
             const authUser = request.authUser;
             const cacheKey = authUser.roleId;

package/dist/models/TenantModel.js

@@ -3,10 +3,8 @@ import uniqueValidator from 'mongoose-unique-validator';
 import mongoosePaginate from 'mongoose-paginate-v2';
 const Schema = mongoose.Schema;
 const TenantSchema = new Schema({
-    name: {
-        type: String, unique: true, required: true, index: true,
-    },
-});
+    name: { type: String, unique: true, required: true, index: true, },
+}, { timestamps: true });
 TenantSchema.plugin(uniqueValidator, { message: 'validation.unique' });
 TenantSchema.plugin(MongooseSoftDelete);
 TenantSchema.plugin(mongoosePaginate);

package/dist/models/UserApiKeyModel.js

@@ -0,0 +1,44 @@
+import { mongoose, MongooseSoftDelete } from '@drax/common-back';
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2';
+// Defining user Mongoose Schema
+const UserApiKeySchema = new mongoose.Schema({
+    name: {
+        type: String,
+        unique: false,
+        required: true,
+        index: false,
+    },
+    secret: {
+        type: String,
+        unique: false,
+        required: true,
+        index: true,
+    },
+    user: {
+        type: mongoose.Schema.Types.ObjectId,
+        ref: 'User',
+        required: true,
+    },
+    ipv4: [{
+            type: String,
+            unique: false,
+            required: false,
+            index: false,
+        }],
+    ipv6: [{
+            type: String,
+            unique: false,
+            required: false,
+            index: false,
+        }],
+}, { timestamps: true });
+UserApiKeySchema.set('toJSON', { getters: true });
+UserApiKeySchema.plugin(uniqueValidator, { message: 'validation.unique' });
+UserApiKeySchema.plugin(MongooseSoftDelete);
+UserApiKeySchema.plugin(mongoosePaginate);
+const MODEL_NAME = 'UserApiKey';
+const COLLECTION_NAME = 'userApiKeys';
+const UserApiKeyModel = mongoose.model(MODEL_NAME, UserApiKeySchema, COLLECTION_NAME);
+export { UserApiKeySchema, UserApiKeyModel };
+export default UserApiKeyModel;

package/dist/permissions/IdentityPermissions.js

@@ -5,6 +5,12 @@ var IdentityPermissions;
     IdentityPermissions["DeleteUser"] = "user:delete";
     IdentityPermissions["ViewUser"] = "user:view";
     IdentityPermissions["ManageUser"] = "user:manage";
+    IdentityPermissions["CreateUserApiKey"] = "userApiKey:create";
+    IdentityPermissions["UpdateUserApiKey"] = "userApiKey:update";
+    IdentityPermissions["DeleteUserApiKey"] = "userApiKey:delete";
+    IdentityPermissions["ViewUserApiKey"] = "userApiKey:view";
+    IdentityPermissions["ViewMyUserApiKey"] = "userApiKey:myView";
+    IdentityPermissions["ManageUserApiKey"] = "userApiKey:manage";
     IdentityPermissions["CreateRole"] = "role:create";
     IdentityPermissions["UpdateRole"] = "role:update";
     IdentityPermissions["DeleteRole"] = "role:delete";

package/dist/rbac/Rbac.js

@@ -21,6 +21,14 @@ class Rbac {
             throw new UnauthorizedError();
         }
     }
+    assertOrPermissions(requiredPermissions) {
+        for (let requiredPermission of requiredPermissions) {
+            if (this.hasPermission(requiredPermission)) {
+                return true;
+            }
+        }
+        throw new UnauthorizedError();
+    }
     assertAuthenticated() {
         if (!this.authUser) {
             throw new UnauthorizedError();

package/dist/repository/mongo/UserApiKeyMongoRepository.js

@@ -0,0 +1,82 @@
+import { UserApiKeyModel } from "../../models/UserApiKeyModel.js";
+import { mongoose, MongooseErrorToValidationError, MongoServerErrorToValidationError } from "@drax/common-back";
+import { MongoServerError } from "mongodb";
+class UserMongoRepository {
+    constructor() {
+    }
+    async create(data) {
+        try {
+            const userApiKey = new UserApiKeyModel(data);
+            await userApiKey.save();
+            await userApiKey.populate({ path: 'user', populate: { path: 'tenant role' } });
+            return userApiKey;
+        }
+        catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e);
+            }
+            throw e;
+        }
+    }
+    async update(id, data) {
+        try {
+            delete data.secret;
+            const userApiKey = await UserApiKeyModel.findOneAndUpdate({ _id: id }, data, { new: true }).populate({ path: 'user', populate: { path: 'tenant role' } }).exec();
+            return userApiKey;
+        }
+        catch (e) {
+            if (e instanceof mongoose.Error.ValidationError) {
+                throw MongooseErrorToValidationError(e);
+            }
+            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
+                throw MongoServerErrorToValidationError(e);
+            }
+            throw e;
+        }
+    }
+    async delete(id) {
+        const userApiKey = await UserApiKeyModel.findById(id);
+        userApiKey.softDelete();
+        return true;
+    }
+    async findById(id) {
+        const userApiKey = await UserApiKeyModel.findById(id).populate({ path: 'user', populate: { path: 'tenant role' } }).exec();
+        return userApiKey;
+    }
+    async findBySecret(secret) {
+        const userApiKey = await UserApiKeyModel.findOne({ secret: secret }).populate({ path: 'user', populate: { path: 'tenant role' } }).exec();
+        return userApiKey;
+    }
+    async paginate({ page = 1, limit = 5, orderBy = '', orderDesc = false, search = '', filters = [] }) {
+        const query = {
+            deleted: false
+        };
+        if (search) {
+            query['$or'] = [
+                { name: new RegExp(search, 'i') },
+            ];
+        }
+        if (filters) {
+            for (const filter of filters) {
+                if (['eq', '$eq'].includes(filter.operator)) {
+                    query[filter.field] = { $eq: filter.value };
+                }
+                if (['ne', '$ne'].includes(filter.operator)) {
+                    query[filter.field] = { $ne: filter.value };
+                }
+                if (['in', '$in'].includes(filter.operator)) {
+                    query[filter.field] = { $in: filter.value };
+                }
+            }
+        }
+        const options = { populate: ['user', 'user.tenant', 'user.role'], page: page, limit: limit };
+        const userApiKeyPaginated = await UserApiKeyModel.paginate(query, options);
+        return {
+            page: page,
+            limit: limit,
+            total: userApiKeyPaginated.totalDocs,
+            items: userApiKeyPaginated.docs
+        };
+    }
+}
+export default UserMongoRepository;

package/dist/repository/mongo/UserMongoRepository.js

@@ -61,13 +61,13 @@ class UserMongoRepository {
         }
         if (filters) {
             for (const filter of filters) {
-                if (filter.operator === '$eq') {
+                if (['eq', '$eq'].includes(filter.operator)) {
                     query[filter.field] = { $eq: filter.value };
                 }
-                if (filter.operator === '$ne') {
+                if (['ne', '$ne'].includes(filter.operator)) {
                     query[filter.field] = { $ne: filter.value };
                 }
-                if (filter.operator === '$in') {
+                if (['in', '$in'].includes(filter.operator)) {
                     query[filter.field] = { $in: filter.value };
                 }
             }

package/dist/repository/sqlite/RoleSqliteRepository.js

@@ -1,24 +1,23 @@
 import sqlite from "better-sqlite3";
 import { randomUUID } from "node:crypto";
-import { SqliteErrorToValidationError } from "@drax/common-back";
-const roleTableSQL = `
-    CREATE TABLE IF NOT EXISTS roles
-    (
-        id TEXT PRIMARY KEY,
-        name TEXT,
-        permissions TEXT,
-        readonly INTEGER,
-        childRoles TEXT
-        
-    );
-`;
+import { SqliteErrorToValidationError, SqliteTableBuilder } from "@drax/common-back";
+const tableFields = [
+    { name: "name", type: "TEXT", unique: true, primary: false },
+    { name: "permissions", type: "TEXT", unique: false, primary: false },
+    { name: "childRoles", type: "TEXT", unique: false, primary: false },
+    { name: "readonly", type: "INTEGER", unique: false, primary: false },
+    { name: "createdAt", type: "TEXT", unique: false, primary: false },
+    { name: "updatedAt", type: "TEXT", unique: false, primary: false },
+];
 class RoleSqliteRepository {
-    constructor(DATABASE, verbose = false) {
-        this.db = new sqlite(DATABASE, { verbose: verbose ? console.log : null });
+    constructor(dataBaseFile, verbose = false) {
+        this.dataBaseFile = dataBaseFile;
+        this.db = new sqlite(dataBaseFile, { verbose: verbose ? console.log : null });
         this.table();
     }
     table() {
-        this.db.exec(roleTableSQL);
+        const builder = new SqliteTableBuilder(this.dataBaseFile, 'roles', tableFields, false);
+        builder.build('id');
     }
     normalizeData(roleData) {
         roleData.readonly = roleData.readonly ? 1 : 0;
@@ -35,15 +34,13 @@ class RoleSqliteRepository {
                 roleData.id = randomUUID();
             }
             this.normalizeData(roleData);
+            roleData.createdAt = (new Date().toISOString());
             const fields = Object.keys(roleData)
                 .map(field => `${field}`)
                 .join(', ');
             const values = Object.keys(roleData)
                 .map(field => `@${field}`)
                 .join(', ');
-            /* console.log("fields", fields)
-             console.log("values",values)
-             console.log("userData",roleData)*/
             const stmt = this.db.prepare(`INSERT INTO roles (${fields}) VALUES (${values})`);
             stmt.run(roleData);
             return this.findById(roleData.id);
@@ -56,6 +53,7 @@ class RoleSqliteRepository {
     async update(id, roleData) {
         try {
             this.normalizeData(roleData);
+            roleData.updatedAt = (new Date().toISOString());
             const setClauses = Object.keys(roleData)
                 .map(field => `${field} = @${field}`)
                 .join(', ');