@drax/identity-back 0.0.31 → 0.1.2

package/src/repository/mongo/UserApiKeyMongoRepository.ts

@@ -0,0 +1,114 @@
+import {UserApiKeyModel} from "../../models/UserApiKeyModel.js";
+import {
+    mongoose,
+    MongooseErrorToValidationError,
+    MongoServerErrorToValidationError,
+    ValidationError
+} from "@drax/common-back"
+import type {IUserApiKey, IUserApiKeyBase, IUserApiKeySoftDelete} from "@drax/identity-share";
+import {DeleteResult, MongoServerError} from "mongodb";
+import {PaginateResult} from "mongoose";
+import {IDraxPaginateOptions, IDraxPaginateResult} from "@drax/common-share";
+import {IUserApiKeyRepository} from "../../interfaces/IUserApiKeyRepository";
+
+class UserMongoRepository implements IUserApiKeyRepository {
+
+
+    constructor() {
+    }
+
+    async create(data: IUserApiKeyBase): Promise<IUserApiKey> {
+        try {
+
+            const userApiKey: mongoose.HydratedDocument<IUserApiKey> = 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: string, data: IUserApiKeyBase): Promise<IUserApiKey> {
+        try {
+            delete data.secret
+            const userApiKey: mongoose.HydratedDocument<IUserApiKey> = 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: string): Promise<boolean> {
+        const userApiKey: mongoose.HydratedDocument<IUserApiKeySoftDelete> = await UserApiKeyModel.findById(id)
+        userApiKey.softDelete()
+        return true
+    }
+
+    async findById(id: string): Promise<IUserApiKey> {
+        const userApiKey: mongoose.HydratedDocument<IUserApiKey> = await UserApiKeyModel.findById(id).populate({path: 'user', populate: {path: 'tenant role'} }).exec()
+        return userApiKey
+    }
+
+    async findBySecret(secret: string): Promise<IUserApiKey> {
+        const userApiKey: mongoose.HydratedDocument<IUserApiKey> = 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 = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
+
+        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: PaginateResult<IUserApiKey> = await UserApiKeyModel.paginate(query, options)
+        return {
+            page: page,
+            limit: limit,
+            total: userApiKeyPaginated.totalDocs,
+            items: userApiKeyPaginated.docs
+        }
+    }
+
+}
+
+export default UserMongoRepository

package/src/repository/mongo/UserMongoRepository.ts

@@ -86,13 +86,13 @@ class UserMongoRepository implements IUserRepository {
 
         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/src/repository/sqlite/RoleSqliteRepository.ts

@@ -4,31 +4,36 @@ import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
 import {IRole, IRoleBase} from "@drax/identity-share";
-import {SqliteErrorToValidationError} from "@drax/common-back";
-
-const roleTableSQL: string = `
-    CREATE TABLE IF NOT EXISTS roles
-    (
-        id TEXT PRIMARY KEY,
-        name TEXT,
-        permissions TEXT,
-        readonly INTEGER,
-        childRoles TEXT
-        
-    );
-`;
+import {SqliteErrorToValidationError, SqliteTableBuilder, SqliteTableField} from "@drax/common-back";
+
+const tableFields: SqliteTableField[] = [
+    {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 implements IRoleRepository{
 
     private db: any;
+    private dataBaseFile: string;
 
-    constructor(DATABASE:string, verbose:boolean = false) {
-        this.db = new sqlite(DATABASE, {verbose: verbose ? console.log : null});
+    constructor(dataBaseFile:string, verbose:boolean = 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: IRoleBase){
@@ -52,7 +57,7 @@ class RoleSqliteRepository implements IRoleRepository{
             }
 
             this.normalizeData(roleData)
-
+            roleData.createdAt = (new Date().toISOString())
 
             const fields = Object.keys(roleData)
                 .map(field => `${field}`)
@@ -62,9 +67,6 @@ class RoleSqliteRepository implements IRoleRepository{
                 .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)
@@ -80,12 +82,18 @@ class RoleSqliteRepository implements IRoleRepository{
     async update(id: string, roleData: IRoleBase): Promise<IRole> {
         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)

package/src/repository/sqlite/TenantSqliteRepository.ts

@@ -4,27 +4,35 @@ import {UUID} from "crypto";
 import sqlite from "better-sqlite3";
 import {randomUUID} from "node:crypto";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
-import {SqliteErrorToValidationError} from "@drax/common-back";
+import {SqliteErrorToValidationError, SqliteTableBuilder} from "@drax/common-back";
+import type {SqliteTableField} from "@drax/common-back";
+
+
+const tableFields: SqliteTableField[] = [
+    {name: "name", type: "TEXT", unique: false, primary: false},
+    {name: "createdAt", type: "TEXT", unique: false, primary: false},
+    {name: "updatedAt", type: "TEXT", unique: false, primary: false},
+]
 
-const tenantTableSQL: string = `
-    CREATE TABLE IF NOT EXISTS tenants
-    (
-        id TEXT PRIMARY KEY,
-        name TEXT
-    );
-`;
 
 class TenantSqliteRepository implements ITenantRepository{
 
     private db: any;
+    private dataBaseFile: string;
 
-    constructor(DATABASE:string, verbose:boolean = false) {
-        this.db = new sqlite(DATABASE, {verbose: verbose ? console.log : null});
+    constructor(dataBaseFile:string, verbose:boolean = false) {
+        this.dataBaseFile = dataBaseFile;
+        this.db = new sqlite(this.dataBaseFile, {verbose: verbose ? console.log : null});
         this.table()
     }
 
     table() {
-        this.db.exec(tenantTableSQL);
+        const builder = new SqliteTableBuilder(
+            this.dataBaseFile,
+            'tenants',
+            tableFields,
+            false);
+        builder.build('id')
     }
 
 
@@ -36,6 +44,7 @@ class TenantSqliteRepository implements ITenantRepository{
                 tenantData.id = randomUUID()
             }
 
+            tenantData.createdAt = (new Date().toISOString())
 
             const fields = Object.keys(tenantData)
                 .map(field => `${field}`)
@@ -66,10 +75,15 @@ class TenantSqliteRepository implements ITenantRepository{
 
     async update(id: string, tenantData: ITenantBase): Promise<ITenant> {
         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)

package/src/repository/sqlite/UserApiKeySqliteRepository.ts

@@ -0,0 +1,197 @@
+import {IUserApiKey, IUserApiKeyBase} from '@drax/identity-share'
+import {IUserApiKeyRepository} from '../../interfaces/IUserApiKeyRepository'
+import {UUID} from "crypto";
+import sqlite from "better-sqlite3";
+import {randomUUID} from "node:crypto";
+import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
+import {SqliteErrorToValidationError, SqliteTableBuilder} from "@drax/common-back";
+import type {SqliteTableField} from "@drax/common-back";
+import UserSqliteRepository from "./UserSqliteRepository.js";
+
+
+const tableFields: SqliteTableField[] = [
+    {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 implements IUserApiKeyRepository {
+
+    private db: any;
+    private dataBaseFile: string;
+    private userRepository: UserSqliteRepository;
+
+    constructor(dataBaseFile: string, verbose: boolean = 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: string) {
+        return await this.userRepository.findById(id)
+    }
+
+    table() {
+        const builder = new SqliteTableBuilder(
+            this.dataBaseFile,
+            'user_api_keys',
+            tableFields,
+            false);
+        builder.build('id')
+    }
+
+
+    async create(userApiKeyData: IUserApiKeyBase): Promise<IUserApiKey> {
+        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 as UUID)
+        } catch (e) {
+            console.log(e)
+            throw SqliteErrorToValidationError(e, userApiKeyData)
+        }
+    }
+
+    async findById(id: string): Promise<IUserApiKey | null> {
+        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: string): Promise<IUserApiKey | null> {
+        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: string, userApiKeyData: IUserApiKeyBase): Promise<IUserApiKey> {
+        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)
+        } catch (e) {
+            console.log(e)
+            throw SqliteErrorToValidationError(e, userApiKeyData)
+        }
+
+    }
+
+    async delete(id: string): Promise<boolean> {
+        const stmt = this.db.prepare('DELETE FROM user_api_keys WHERE id = ?');
+        stmt.run(id);
+        return true
+    }
+
+
+    async paginate({
+                       page = 1,
+                       limit = 5,
+                       orderBy = '',
+                       orderDesc = false,
+                       search = '',
+                       filters = []
+                   }: IDraxPaginateOptions): Promise<IDraxPaginateResult<IUserApiKey>> {
+        const offset = page > 1 ? (page - 1) * limit : 0
+
+        let where = ""
+        if (search) {
+            where = ` WHERE name LIKE '%${search}%'`
+        }
+
+        let whereFilters= []
+        if(filters && filters.length > 0 ){
+            where = where ? ` AND ` : ` WHERE `
+            for(const filter of filters){
+                if(['eq','$eq'].includes(filter.operator)){
+                    whereFilters.push(` ${filter.field} = '${filter.value}' `)
+                }
+                if(['ne','$ne'].includes(filter.operator)){
+                    whereFilters.push(` ${filter.field} != '${filter.value}' `)
+                }
+                if(['in','$in'].includes(filter.operator)){
+                    whereFilters.push(` ${filter.field} LIKE '%${filter.value}%' `)
+                }
+            }
+            where += whereFilters.join(" AND ")
+        }
+
+        const rCount = this.db.prepare('SELECT COUNT(*) as count FROM user_api_keys' + where).get();
+        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)
+        }
+
+        return {
+            page: page,
+            limit: limit,
+            total: rCount.count,
+            items: userApiKeys
+        }
+    }
+
+
+}
+
+export default UserApiKeySqliteRepository

package/src/repository/sqlite/UserSqliteRepository.ts

@@ -4,42 +4,48 @@ import {randomUUID} from "node:crypto";
 import {UUID} from "crypto";
 import {IUserRepository} from "../../interfaces/IUserRepository";
 import {IDraxPaginateResult, IDraxPaginateOptions} from "@drax/common-share";
-import { SqliteErrorToValidationError, ValidationError} from "@drax/common-back";
+import {SqliteErrorToValidationError, SqliteTableBuilder, ValidationError} from "@drax/common-back";
+import type {SqliteTableField} from "@drax/common-back";
 import RoleSqliteRepository from "./RoleSqliteRepository.js";
 import TenantSqliteRepository from "./TenantSqliteRepository.js";
 
-
-const userTableSQL: string = `
-    CREATE TABLE IF NOT EXISTS users
-    (
-        id TEXT PRIMARY KEY,
-        name TEXT,
-        username TEXT UNIQUE,
-        active INTEGER,
-        password TEXT,
-        email TEXT UNIQUE,
-        phone TEXT,
-        role TEXT,
-        tenant TEXT,
-        groups TEXT,
-        avatar TEXT
-    );
-`;
+const tableFields: SqliteTableField[] = [
+    {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: "createdAt", type: "TEXT", unique: false, primary: false},
+    {name: "updatedAt", type: "TEXT", unique: false, primary: false}
+]
 
 class UserSqliteRepository implements IUserRepository {
     private db: any;
     private roleRepository: RoleSqliteRepository;
     private tenantRepository: TenantSqliteRepository;
+    private dataBaseFile: string;
 
-    constructor(DATABASE: string, verbose: boolean = false) {
-        this.db = new sqlite(DATABASE, {verbose: verbose ? console.log : null});
-        this.roleRepository = new RoleSqliteRepository(DATABASE, verbose)
-        this.tenantRepository = new TenantSqliteRepository(DATABASE, verbose)
+    constructor(dataBaseFile: string, verbose: boolean = false) {
+        this.dataBaseFile = dataBaseFile
+        this.db = new sqlite(dataBaseFile, {verbose: verbose ? console.log : null});
+        this.roleRepository = new RoleSqliteRepository(dataBaseFile, verbose)
+        this.tenantRepository = new TenantSqliteRepository(dataBaseFile, verbose)
         this.table()
     }
 
     table() {
-        this.db.exec(userTableSQL);
+        const builder = new SqliteTableBuilder(
+            this.dataBaseFile,
+            'users',
+            tableFields,
+            false);
+        builder.build('id')
     }
 
     normalizeData(userData: IUserCreate | IUserUpdate): void {
@@ -58,6 +64,8 @@ class UserSqliteRepository implements IUserRepository {
             throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
         }
 
+        userData.createdAt = (new Date().toISOString())
+
         this.normalizeData(userData)
 
         try {
@@ -86,6 +94,8 @@ class UserSqliteRepository implements IUserRepository {
                 throw new ValidationError([{field: 'role', reason: 'validation.notfound', value: userData.role}])
             }
 
+            userData.updatedAt = (new Date().toISOString())
+
             this.normalizeData(userData)
 
             const setClauses = Object.keys(userData)
@@ -153,20 +163,20 @@ class UserSqliteRepository implements IUserRepository {
         if(filters && filters.length > 0 ){
             where = where ? ` AND ` : ` WHERE `
             for(const filter of filters){
-                if(filter.operator === '$eq'){
+                if(['eq','$eq'].includes(filter.operator)){
                     whereFilters.push(` ${filter.field} = '${filter.value}' `)
                 }
-                if(filter.operator === '$ne'){
+                if(['ne','$ne'].includes(filter.operator)){
                     whereFilters.push(` ${filter.field} != '${filter.value}' `)
                 }
-                if(filter.operator === '$in'){
+                if(['in','$in'].includes(filter.operator)){
                     whereFilters.push(` ${filter.field} LIKE '%${filter.value}%' `)
                 }
             }
             where += whereFilters.join(" AND ")
         }
 
-       // console.log("paginate where ", where, "search", search, "filters", filters, "whereFilters", whereFilters)
+        console.log("paginate where ", where, "search", search, "filters", filters, "whereFilters", whereFilters)
 
         const rCount = this.db.prepare('SELECT COUNT(*) as count FROM users' + where).get();