@drax/identity-back 0.11.4 → 0.12.1

package/dist/repository/mongo/UserMongoRepository.js

@@ -1,10 +1,14 @@
 import { UserModel } from "../../models/UserModel.js";
-import { mongoose, MongooseErrorToValidationError, MongooseQueryFilter, MongooseSort, MongoServerErrorToValidationError, ValidationError } from "@drax/common-back";
-import { MongoServerError } from "mongodb";
+import { mongoose, MongooseValidationErrorToValidationError, MongooseQueryFilter, MongooseSort, ValidationError, MongooseCastErrorToValidationError } from "@drax/common-back";
 import RoleMongoRepository from "./RoleMongoRepository.js";
-class UserMongoRepository {
+import { AbstractMongoRepository } from "@drax/crud-back";
+class UserMongoRepository extends AbstractMongoRepository {
     constructor() {
+        super();
         this._searchFields = ['name', 'username', 'email', 'phone'];
+        this._populateFields = ['role', 'tenant'];
+        this._model = UserModel;
+        this._lean = false;
         this.roleRepository = new RoleMongoRepository();
     }
     async create(userData) {
@@ -14,100 +18,76 @@ class UserMongoRepository {
             }
             const user = new UserModel(userData);
             await user.save();
-            await user.populate(['role', 'tenant']);
+            await user.populate(this._populateFields);
             return user;
         }
         catch (e) {
             if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e);
+                throw MongooseValidationErrorToValidationError(e);
             }
-            throw e;
-        }
-    }
-    async update(id, userData) {
-        try {
-            const user = await UserModel.findOneAndUpdate({ _id: id }, userData, { new: true }).populate(['role', 'tenant']).exec();
-            return user;
-        }
-        catch (e) {
-            if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e);
-            }
-            if (e instanceof MongoServerError || e.name === 'MongoServerError') {
-                throw MongoServerErrorToValidationError(e);
-            }
-            throw e;
-        }
-    }
-    async updatePartial(id, data) {
-        try {
-            const item = await UserModel.findOneAndUpdate({ _id: id }, data, { new: true }).populate(['role', 'tenant']).exec();
-            return item;
-        }
-        catch (e) {
-            if (e instanceof mongoose.Error.ValidationError) {
-                throw MongooseErrorToValidationError(e);
+            if (e instanceof mongoose.Error.CastError) {
+                throw MongooseCastErrorToValidationError(e);
             }
             throw e;
         }
     }
-    async delete(id) {
-        const result = await UserModel.deleteOne({ _id: id }).exec();
-        return result.deletedCount == 1;
-    }
-    async findById(id) {
-        const user = await UserModel.findById(id).populate(['role', 'tenant']).exec();
-        return user;
-    }
     async findByUsername(username) {
-        const user = await UserModel.findOne({ username: username }).populate(['role', 'tenant']).exec();
+        const user = await UserModel
+            .findOne({ username: username })
+            .populate(['role', 'tenant'])
+            .lean(this._lean)
+            .exec();
         return user;
     }
     async findByUsernameWithPassword(username) {
-        const user = await UserModel.findOne({ username: username }).select('+password').populate(['role', 'tenant']).exec();
+        const user = await UserModel
+            .findOne({ username: username })
+            .select('+password')
+            .populate(['role', 'tenant'])
+            .lean(this._lean)
+            .exec();
+        return user;
+    }
+    async findByIdWithPassword(id) {
+        const user = await UserModel.findById(id)
+            .select('+password')
+            .populate(['role', 'tenant'])
+            .lean(this._lean)
+            .exec();
         return user;
     }
     async findByEmail(email) {
-        const user = await UserModel.findOne({ email: email }).populate(['role', 'tenant']).exec();
+        const user = await UserModel
+            .findOne({ email: email })
+            .populate(['role', 'tenant'])
+            .lean(this._lean)
+            .exec();
         return user;
     }
     async findByEmailCode(code) {
-        const user = await UserModel.findOne({ emailCode: { $eq: code }, emailVerified: { $eq: false } }).populate(['role', 'tenant']).exec();
+        const user = await UserModel
+            .findOne({ emailCode: { $eq: code }, emailVerified: { $eq: false } })
+            .populate(['role', 'tenant'])
+            .lean(this._lean)
+            .exec();
         return user;
     }
     async findByPhoneCode(code) {
-        const user = await UserModel.findOne({ phoneCode: { $eq: code }, phoneVerified: { $eq: false } }).populate(['role', 'tenant']).exec();
+        const user = await UserModel
+            .findOne({ phoneCode: { $eq: code }, phoneVerified: { $eq: false } })
+            .populate(['role', 'tenant'])
+            .lean(this._lean)
+            .exec();
         return user;
     }
     async findByRecoveryCode(code) {
-        const user = await UserModel.findOne({ recoveryCode: { $eq: code }, active: { $eq: true } }).populate(['role', 'tenant']).exec();
+        const user = await UserModel
+            .findOne({ recoveryCode: { $eq: code }, active: { $eq: true } })
+            .populate(['role', 'tenant'])
+            .lean(this._lean)
+            .exec();
         return user;
     }
-    async paginate({ page = 1, limit = 5, orderBy = '', order = false, search = '', filters = [] }) {
-        const query = {};
-        if (search) {
-            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
-        }
-        MongooseQueryFilter.applyFilters(query, filters);
-        const sort = MongooseSort.applySort(orderBy, order);
-        const options = { populate: ['role', 'tenant'], page, limit, sort };
-        const userPaginated = await UserModel.paginate(query, options);
-        return {
-            page: page,
-            limit: limit,
-            total: userPaginated.totalDocs,
-            items: userPaginated.docs
-        };
-    }
-    async search(value, limit = 1000, filters = []) {
-        const query = {};
-        if (value) {
-            query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(value.toString(), 'i') }));
-        }
-        MongooseQueryFilter.applyFilters(query, filters);
-        const items = await UserModel.find(query).limit(limit).exec();
-        return items;
-    }
     async changePassword(id, password) {
         try {
             await UserModel.findOneAndUpdate({ _id: id }, { password }).exec();
@@ -128,24 +108,15 @@ class UserMongoRepository {
             return false;
         }
     }
-    async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
-        const query = {};
-        if (search) {
-            query['$or'] = [
-                { name: new RegExp(search, 'i') },
-            ];
-        }
-        MongooseQueryFilter.applyFilters(query, filters);
-        const sort = MongooseSort.applySort(orderBy, order);
-        return await UserModel.find(query).populate(['role', 'tenant']).limit(limit).sort(sort);
-    }
     async findCursor({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
-        console.log("RoleMongoRepository.findCursor called");
         const query = {};
         if (search) {
-            query['$or'] = [
-                { name: new RegExp(search, 'i') },
-            ];
+            if (mongoose.Types.ObjectId.isValid(search)) {
+                query['_id'] = new mongoose.Types.ObjectId(search);
+            }
+            else {
+                query['$or'] = this._searchFields.map(field => ({ [field]: new RegExp(search.toString(), 'i') }));
+            }
         }
         MongooseQueryFilter.applyFilters(query, filters);
         const sort = MongooseSort.applySort(orderBy, order);

package/dist/repository/sqlite/RoleSqliteRepository.js

@@ -1,25 +1,23 @@
-import sqlite from "better-sqlite3";
-import { randomUUID } from "node:crypto";
-import { SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort } 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 {
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class RoleSqliteRepository extends AbstractSqliteRepository {
     constructor(dataBaseFile, verbose = false) {
-        this.dataBaseFile = dataBaseFile;
-        this.db = new sqlite(dataBaseFile, { verbose: verbose ? console.log : null });
-        this.table();
-    }
-    table() {
-        const builder = new SqliteTableBuilder(this.dataBaseFile, 'roles', tableFields, false);
-        builder.build('id');
-    }
-    normalizeData(roleData) {
+        super(dataBaseFile, verbose);
+        this.tableName = 'roles';
+        this.searchFields = [];
+        this.booleanFields = [];
+        this.identifier = '_id';
+        this.populateFields = [];
+        this.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 },
+        ];
+        this.tableName = 'roles';
+    }
+    async prepareData(roleData) {
         roleData.readonly = roleData.readonly ? 1 : 0;
         if (roleData.permissions && Array.isArray(roleData.permissions)) {
             roleData.permissions = roleData.permissions.join(",");
@@ -28,116 +26,33 @@ class RoleSqliteRepository {
             roleData.childRoles = roleData.childRoles.join(",");
         }
     }
-    async create(roleData) {
-        try {
-            if (!roleData.id) {
-                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(', ');
-            const stmt = this.db.prepare(`INSERT INTO roles (${fields}) VALUES (${values})`);
-            stmt.run(roleData);
-            return this.findById(roleData.id);
-        }
-        catch (e) {
-            console.log(e);
-            throw SqliteErrorToValidationError(e, roleData);
-        }
-    }
-    async update(id, roleData) {
-        try {
-            this.normalizeData(roleData);
-            roleData.updatedAt = (new Date().toISOString());
-            const setClauses = Object.keys(roleData)
-                .map(field => `${field} = @${field}`)
-                .join(', ');
-            roleData.id = id;
-            const stmt = this.db.prepare(`UPDATE roles SET ${setClauses} WHERE id = @id `);
-            stmt.run(roleData);
-            return this.findById(id);
-        }
-        catch (e) {
-            console.log(e);
-            throw SqliteErrorToValidationError(e, roleData);
-        }
-    }
-    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}%'`;
-        }
-        where = SqlQueryFilter.applyFilters(where, filters);
-        const sort = SqlSort.applySort(orderBy, order);
-        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM roles' + where).get();
-        where += sort;
-        const roles = this.db.prepare('SELECT * FROM roles ' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
-        for (const role of roles) {
-            await this.populateRole(role);
-        }
-        return {
-            page: page,
-            limit: limit,
-            total: rCount.count,
-            items: roles
-        };
-    }
-    async delete(id) {
-        const stmt = this.db.prepare('DELETE FROM roles WHERE id = ?');
-        stmt.run(id);
-        return true;
-    }
-    async deleteAll() {
-        const stmt = this.db.prepare('DELETE FROM roles');
-        stmt.run();
-        return true;
-    }
-    async findById(id) {
-        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
+    async prepareItem(role) {
         if (role) {
-            await this.populateRole(role);
+            role.permissions = role && role.permissions ? role.permissions.split(",") : [];
+            role.childRoles = role && role.childRoles ? role.childRoles.split(",") : [];
+            const childRoles = [];
+            for (const childRoleId of role.childRoles) {
+                const childRole = await this.findWithoutPopulateById(childRoleId);
+                childRoles.push(childRole);
+            }
+            role.childRoles = childRoles;
             return role;
         }
-        return undefined;
     }
     async findByName(name) {
         const role = this.db.prepare('SELECT * FROM roles WHERE name = ?').get(name);
         if (role) {
-            await this.populateRole(role);
+            await this.decorate(role);
             return role;
         }
         return undefined;
     }
-    async fetchAll() {
-        const roles = this.db.prepare('SELECT * FROM roles').all();
-        for (const role of roles) {
-            await this.populateRole(role);
-        }
-        return roles;
-    }
     async findWithoutPopulateById(id) {
-        const role = this.db.prepare('SELECT * FROM roles WHERE id = ?').get(id);
+        const role = this.db.prepare(`SELECT * FROM roles WHERE ${this.identifier} = ?`).get(id);
         if (role) {
             return role;
         }
         return undefined;
     }
-    async populateRole(role) {
-        role.permissions = role.permissions ? role.permissions.split(",") : [];
-        role.childRoles = role.childRoles ? role.childRoles.split(",") : [];
-        const childRoles = [];
-        for (const childRoleId of role.childRoles) {
-            const childRole = await this.findWithoutPopulateById(childRoleId);
-            childRoles.push(childRole);
-        }
-        role.childRoles = childRoles;
-        return role;
-    }
 }
 export default RoleSqliteRepository;

package/dist/repository/sqlite/TenantSqliteRepository.js

@@ -1,111 +1,21 @@
-import sqlite from "better-sqlite3";
-import { randomUUID } from "node:crypto";
-import { SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort } from "@drax/common-back";
-const tableFields = [
-    { name: "name", type: "TEXT", unique: false, primary: false },
-    { name: "createdAt", type: "TEXT", unique: false, primary: false },
-    { name: "updatedAt", type: "TEXT", unique: false, primary: false },
-];
-class TenantSqliteRepository {
-    constructor(dataBaseFile, verbose = false) {
-        this.dataBaseFile = dataBaseFile;
-        this.db = new sqlite(this.dataBaseFile, { verbose: verbose ? console.log : null });
-        this.table();
-    }
-    table() {
-        const builder = new SqliteTableBuilder(this.dataBaseFile, 'tenants', tableFields, false);
-        builder.build('id');
-    }
-    async create(tenantData) {
-        try {
-            if (!tenantData.id) {
-                tenantData.id = randomUUID();
-            }
-            tenantData.createdAt = (new Date().toISOString());
-            const fields = Object.keys(tenantData)
-                .map(field => `${field}`)
-                .join(', ');
-            const values = Object.keys(tenantData)
-                .map(field => `@${field}`)
-                .join(', ');
-            const stmt = this.db.prepare(`INSERT INTO tenants (${fields}) VALUES (${values})`);
-            stmt.run(tenantData);
-            return this.findById(tenantData.id);
-        }
-        catch (e) {
-            console.log(e);
-            throw SqliteErrorToValidationError(e, tenantData);
-        }
-    }
-    async findById(id) {
-        const tenant = this.db.prepare('SELECT * FROM tenants WHERE id = ?').get(id);
-        return tenant;
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class TenantSqliteRepository extends AbstractSqliteRepository {
+    constructor() {
+        super(...arguments);
+        this.tableName = 'tenants';
+        this.searchFields = [];
+        this.booleanFields = [];
+        this.identifier = '_id';
+        this.populateFields = [];
+        this.tableFields = [
+            { name: "name", type: "TEXT", unique: false, primary: false },
+            { name: "createdAt", type: "TEXT", unique: false, primary: false },
+            { name: "updatedAt", type: "TEXT", unique: false, primary: false },
+        ];
     }
     async findByName(name) {
-        const tenant = this.db.prepare('SELECT * FROM tenants WHERE name = ?').get(name);
+        const tenant = this.db.prepare(`SELECT * FROM ${this.tableName} WHERE name = ?`).get(name);
         return tenant;
     }
-    async update(id, tenantData) {
-        try {
-            tenantData.updatedAt = (new Date().toISOString());
-            const setClauses = Object.keys(tenantData)
-                .map(field => `${field} = @${field}`)
-                .join(', ');
-            tenantData.id = id;
-            const stmt = this.db.prepare(`UPDATE tenants SET ${setClauses} WHERE id = @id `);
-            stmt.run(tenantData);
-            return this.findById(id);
-        }
-        catch (e) {
-            console.log(e);
-            throw SqliteErrorToValidationError(e, tenantData);
-        }
-    }
-    async delete(id) {
-        const stmt = this.db.prepare('DELETE FROM tenants WHERE id = ?');
-        stmt.run(id);
-        return true;
-    }
-    async deleteAll() {
-        const stmt = this.db.prepare('DELETE FROM tenants');
-        stmt.run();
-        return true;
-    }
-    async fetchAll() {
-        const tenants = this.db.prepare('SELECT * FROM tenants').all();
-        for (const tenant of tenants) {
-            tenant.permissions = tenant.permissions ? tenant.permissions.split(",") : [];
-        }
-        return tenants;
-    }
-    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}%'`;
-        }
-        where = SqlQueryFilter.applyFilters(where, filters);
-        const sort = SqlSort.applySort(orderBy, order);
-        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM tenants' + where).get();
-        where += sort;
-        const tenants = this.db.prepare('SELECT * FROM tenants ' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
-        return {
-            page: page,
-            limit: limit,
-            total: rCount.count,
-            items: tenants
-        };
-    }
-    async find({ limit = 0, orderBy = '', order = false, search = '', filters = [] }) {
-        let where = "";
-        if (search) {
-            where = ` WHERE name LIKE '%${search}%'`;
-        }
-        where = SqlQueryFilter.applyFilters(where, filters);
-        const sort = SqlSort.applySort(orderBy, order);
-        where += sort;
-        const tenants = this.db.prepare('SELECT * FROM tenants ' + where).all();
-        return tenants;
-    }
 }
 export default TenantSqliteRepository;

package/dist/repository/sqlite/UserApiKeySqliteRepository.js

@@ -1,135 +1,62 @@
 import sqlite from "better-sqlite3";
-import { randomUUID } from "node:crypto";
-import { SqliteErrorToValidationError, SqliteTableBuilder, SqlQueryFilter, SqlSort } from "@drax/common-back";
 import UserSqliteRepository from "./UserSqliteRepository.js";
-const tableFields = [
-    { name: "secret", type: "TEXT", unique: true, primary: false },
-    { name: "name", type: "TEXT", unique: false, primary: false },
-    { name: "user", type: "TEXT", unique: false, primary: false },
-    { name: "ipv4", type: "TEXT", unique: false, primary: false },
-    { name: "ipv6", type: "TEXT", unique: false, primary: false },
-    { name: "createdAt", type: "TEXT", unique: false, primary: false }
-];
-class UserApiKeySqliteRepository {
+import { AbstractSqliteRepository } from "@drax/crud-back";
+class UserApiKeySqliteRepository extends AbstractSqliteRepository {
     constructor(dataBaseFile, verbose = false) {
+        super(dataBaseFile, verbose);
+        this.tableName = 'user_api_keys';
+        this.searchFields = [];
+        this.booleanFields = [];
+        this.identifier = '_id';
+        this.populateFields = [];
+        this.tableFields = [
+            { name: "secret", type: "TEXT", unique: true, primary: false },
+            { name: "name", type: "TEXT", unique: false, primary: false },
+            { name: "user", type: "TEXT", unique: false, primary: false },
+            { name: "ipv4", type: "TEXT", unique: false, primary: false },
+            { name: "ipv6", type: "TEXT", unique: false, primary: false },
+            { name: "createdBy", type: "TEXT", unique: false, primary: false },
+            { name: "createdAt", type: "TEXT", unique: false, primary: false }
+        ];
         this.dataBaseFile = dataBaseFile;
         this.userRepository = new UserSqliteRepository(dataBaseFile, verbose);
         this.db = new sqlite(dataBaseFile, { verbose: verbose ? console.log : null });
-        this.table();
     }
     async findUserById(id) {
         return await this.userRepository.findById(id);
     }
-    table() {
-        const builder = new SqliteTableBuilder(this.dataBaseFile, 'user_api_keys', tableFields, false);
-        builder.build('id');
-    }
-    async create(userApiKeyData) {
-        try {
-            if (!userApiKeyData.id) {
-                userApiKeyData.id = randomUUID();
-            }
-            if (userApiKeyData.ipv4 && Array.isArray(userApiKeyData.ipv4) && userApiKeyData.ipv4.length > 0) {
-                userApiKeyData.ipv4 = userApiKeyData.ipv4.join(',');
-            }
-            else {
-                userApiKeyData.ipv4 = "";
-            }
-            if (userApiKeyData.ipv6 && Array.isArray(userApiKeyData.ipv6) && userApiKeyData.ipv6.length > 0) {
-                userApiKeyData.ipv6 = userApiKeyData.ipv6.join(',');
-            }
-            else {
-                userApiKeyData.ipv6 = "";
-            }
-            userApiKeyData.createdAt = (new Date().toISOString());
-            const fields = Object.keys(userApiKeyData)
-                .map(field => `${field}`)
-                .join(', ');
-            const values = Object.keys(userApiKeyData)
-                .map(field => `@${field}`)
-                .join(', ');
-            const stmt = this.db.prepare(`INSERT INTO user_api_keys (${fields})
-                                          VALUES (${values})`);
-            stmt.run(userApiKeyData);
-            return this.findById(userApiKeyData.id);
+    async prepareItem(item) {
+        if (item && item.user) {
+            item.user = await this.findUserById(item.user);
         }
-        catch (e) {
-            console.log(e);
-            throw SqliteErrorToValidationError(e, userApiKeyData);
+        if (item && item.createdBy) {
+            item.createdBy = await this.findUserById(item.createdBy);
         }
-    }
-    async findById(id) {
-        const userApiKey = this.db.prepare('SELECT * FROM user_api_keys WHERE id = ?').get(id);
-        userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : [];
-        userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : [];
-        userApiKey.user = await this.findUserById(userApiKey.user);
-        return userApiKey;
-    }
-    async findBySecret(secret) {
-        const userApiKey = this.db.prepare('SELECT * FROM user_api_keys WHERE secret = ?').get(secret);
-        userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : [];
-        userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : [];
-        userApiKey.user = await this.findUserById(userApiKey.user);
-        return userApiKey;
-    }
-    async update(id, userApiKeyData) {
-        try {
-            if (userApiKeyData.ipv4 && Array.isArray(userApiKeyData.ipv4) && userApiKeyData.ipv4.length > 0) {
-                userApiKeyData.ipv4 = userApiKeyData.ipv4.join(',');
-            }
-            else {
-                userApiKeyData.ipv4 = "";
-            }
-            if (userApiKeyData.ipv6 && Array.isArray(userApiKeyData.ipv6) && userApiKeyData.ipv6.length > 0) {
-                userApiKeyData.ipv6 = userApiKeyData.ipv6.join(',');
-            }
-            else {
-                userApiKeyData.ipv6 = "";
-            }
-            delete userApiKeyData.secret;
-            const setClauses = Object.keys(userApiKeyData)
-                .map(field => `${field} = @${field}`)
-                .join(', ');
-            userApiKeyData.id = id;
-            const stmt = this.db.prepare(`UPDATE user_api_keys
-                                          SET ${setClauses}
-                                          WHERE id = @id `);
-            stmt.run(userApiKeyData);
-            return this.findById(id);
+        if (item && item.ipv4) {
+            item.ipv4 = item.ipv4 != "" ? item.ipv4.split(',') : [];
         }
-        catch (e) {
-            console.log(e);
-            throw SqliteErrorToValidationError(e, userApiKeyData);
+        if (item && item.ipv6) {
+            item.ipv6 = item.ipv6 != "" ? item.ipv6.split(',') : [];
         }
     }
-    async delete(id) {
-        const stmt = this.db.prepare('DELETE FROM user_api_keys WHERE id = ?');
-        stmt.run(id);
-        return true;
-    }
-    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}%'`;
+    async prepareData(userApiKeyData) {
+        if (userApiKeyData.ipv4 && Array.isArray(userApiKeyData.ipv4) && userApiKeyData.ipv4.length > 0) {
+            userApiKeyData.ipv4 = userApiKeyData.ipv4.join(',');
+        }
+        else {
+            userApiKeyData.ipv4 = "";
         }
-        where = SqlQueryFilter.applyFilters(where, filters);
-        const sort = SqlSort.applySort(orderBy, order);
-        console.log("where", where);
-        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM user_api_keys' + where).get();
-        where += sort;
-        const userApiKeys = this.db.prepare('SELECT * FROM user_api_keys ' + where + ' LIMIT ? OFFSET ?').all([limit, offset]);
-        for (const userApiKey of userApiKeys) {
-            userApiKey.ipv4 = userApiKey.ipv4 != "" ? userApiKey.ipv4.split(',') : [];
-            userApiKey.ipv6 = userApiKey.ipv6 != "" ? userApiKey.ipv6.split(',') : [];
-            userApiKey.user = await this.findUserById(userApiKey.user);
+        if (userApiKeyData.ipv6 && Array.isArray(userApiKeyData.ipv6) && userApiKeyData.ipv6.length > 0) {
+            userApiKeyData.ipv6 = userApiKeyData.ipv6.join(',');
         }
-        return {
-            page: page,
-            limit: limit,
-            total: rCount.count,
-            items: userApiKeys
-        };
+        else {
+            userApiKeyData.ipv6 = "";
+        }
+    }
+    async findBySecret(secret) {
+        const userApiKey = this.db.prepare('SELECT * FROM user_api_keys WHERE secret = ?').get(secret);
+        await this.decorate(userApiKey);
+        return userApiKey;
     }
 }
 export default UserApiKeySqliteRepository;