feat: Initial user will be admin, Make console panel searchable

idp/package.json

@@ -25,7 +25,7 @@
     "hashids": "2.3.0",
     "jose": "5.3.0",
     "js-yaml": "4.1.0",
-    "meilisearch": "0.40.0",
+    "meilisearch": "^0.40.0",
     "mime-types": "2.1.35",
     "minio": "8.0.0",
     "morgan": "1.10.0",

idp/src/account/service.ts

@@ -16,13 +16,14 @@ import { hashPassword } from '@/infra/password'
 import search, { USER_SEARCH_INDEX } from '@/infra/search'
 import { User } from '@/user/model'
 import userRepo from '@/user/repo'
-import { UserDTO, mapEntity } from '@/user/service'
+import {UserDTO, mapEntity, getUserCount} from '@/user/service'
 
 export type AccountCreateOptions = {
   email: string
   password: string
   fullName: string
   picture?: string
+  isAdmin?: boolean
 }
 
 export type AccountResetPasswordOptions = {
@@ -53,6 +54,9 @@ export async function createUser(
   if (!(await userRepo.isUsernameAvailable(options.email))) {
     throw newError({ code: ErrorCode.UsernameUnavailable })
   }
+  if (await getUserCount() === 0) {
+    options.isAdmin = true
+  }
   try {
     const emailConfirmationToken = newHyphenlessUuid()
     const user = await userRepo.insert({
@@ -64,6 +68,7 @@ export async function createUser(
       passwordHash: hashPassword(options.password),
       emailConfirmationToken,
       createTime: newDateTime(),
+      isAdmin: options.isAdmin,
     })
     await search.index(USER_SEARCH_INDEX).addDocuments([
       {
@@ -72,9 +77,8 @@ export async function createUser(
         email: user.email,
         fullName: user.fullName,
         isEmailConfirmed: user.isEmailConfirmed,
-        isAdmin: user.isAdmin,
-        isActive: user.isActive,
         createTime: user.createTime,
+        updateTime: user.updateTime
       },
     ])
     await sendTemplateMail('email-confirmation', options.email, {
@@ -106,8 +110,14 @@ export async function confirmEmail(options: AccountConfirmEmailOptions) {
   })
   await search.index(USER_SEARCH_INDEX).updateDocuments([
     {
-      ...user,
+      id: user.id,
+      username: user.username,
+      email: user.email,
+      fullName: user.fullName,
       isEmailConfirmed: user.isEmailConfirmed,
+      createTime: user.createTime,
+      updateTime: user.updateTime,
+      picture: user.picture,
     },
   ])
 }

idp/src/infra/admin-requests.ts

@@ -8,11 +8,18 @@
 // by the GNU Affero General Public License v3.0 only, included in the file
 // licenses/AGPL.txt.
 import { Request } from 'express'
+import {User} from "@/user/model";
 
 export interface UserIdPostRequest extends Request {
   id: string
 }
 
+export type SearchRequest = {
+  page: string
+  size: string
+  query: string
+}
+
 export interface UserSuspendPostRequest extends UserIdPostRequest {
   suspend: boolean
 }
@@ -21,19 +28,21 @@ export interface UserAdminPostRequest extends UserIdPostRequest {
   makeAdmin: boolean
 }
 
-export type Pagination = {
-  page: string
-  size: string
-}
-
 export type UserId = {
   id: string
 }
 
-export interface PaginatedRequest extends Request {
-  query: Pagination
+export interface SearchPaginatedRequest extends Request {
+  query: SearchRequest
 }
 
 export interface UserIdRequest extends Request {
   query: UserId
 }
+
+export interface UserSearchResponse {
+  data: User[]
+  page: number
+  size: number
+  totalElements: number
+}

idp/src/infra/error.ts

@@ -25,7 +25,8 @@ export enum ErrorCode {
   UserSuspended = 'user_suspended',
   MissingPermission = 'missing_permission',
   UserNotFound = 'user_not_found',
-  OrphanError = 'orphan_error'
+  OrphanError = 'orphan_error',
+  SearchError = 'search_error'
 }
 
 const statuses: { [key: string]: number } = {
@@ -44,7 +45,8 @@ const statuses: { [key: string]: number } = {
   [ErrorCode.UserSuspended]: 403,
   [ErrorCode.MissingPermission]: 403,
   [ErrorCode.UserNotFound]: 404,
-  [ErrorCode.OrphanError]: 400
+  [ErrorCode.OrphanError]: 400,
+  [ErrorCode.SearchError]: 500
 }
 
 const userMessages: { [key: string]: string } = {
@@ -54,7 +56,8 @@ const userMessages: { [key: string]: string } = {
   [ErrorCode.InvalidUsernameOrPassword]: 'Invalid username or password.',
   [ErrorCode.UserSuspended]: 'User suspended.',
   [ErrorCode.MissingPermission]: 'You are not an console',
-  [ErrorCode.OrphanError]: 'You cannot suspend last console'
+  [ErrorCode.OrphanError]: 'You cannot suspend last console',
+  [ErrorCode.SearchError]: 'Search engine encountered error or is not available'
 }
 
 export type ErrorData = {

idp/src/user/repo.ts

@@ -144,6 +144,24 @@ class UserRepoImpl {
     return this.mapList(rows)
   }
 
+  async listAllByIds(idList: number[]): Promise<User[]> {
+    const { rowCount, rows } = await client.query(
+      `SELECT *
+       FROM "user"
+       WHERE id = ANY ($1)
+       ORDER BY create_time`,
+      [idList],
+    )
+    if (rowCount < 1) {
+      throw newError({
+        code: ErrorCode.ResourceNotFound,
+        error: `User list is empty`,
+        userMessage: `Not found users`
+      })
+    }
+    return this.mapList(rows)
+  }
+
   async getUserCount(): Promise<number> {
     const { rowCount, rows } = await client.query(
       `SELECT COUNT(id) as count FROM "user"`,
@@ -154,7 +172,7 @@ class UserRepoImpl {
         error: `Fatal database error (no users present in database)`,
       })
     }
-    return rows[0].count
+    return parseInt(rows[0].count)
   }
 
   async isUsernameAvailable(username: string): Promise<boolean> {

idp/src/user/router.ts

@@ -14,7 +14,7 @@ import multer from 'multer'
 import os from 'os'
 import passport from 'passport'
 import {
-  PaginatedRequest,
+  SearchPaginatedRequest,
   UserAdminPostRequest,
   UserIdRequest,
   UserSuspendPostRequest
@@ -36,8 +36,7 @@ import {
   UserUpdateEmailConfirmationOptions,
   updateEmailRequest,
   updateEmailConfirmation,
-  getUserListPaginated,
-  getUserCount, suspendUser, makeAdminUser, getUserByAdmin,
+  suspendUser, makeAdminUser, getUserByAdmin, searchUserListPaginated
 } from './service'
 
 const router = Router()
@@ -222,18 +221,10 @@ router.get(
 router.get(
   '/all',
   passport.authenticate('jwt', { session: false }),
-  async (req: PaginatedRequest, res: Response, next: NextFunction) => {
+  async (req: SearchPaginatedRequest, res: Response, next: NextFunction) => {
     try {
       checkAdmin(req.header('Authorization'))
-      res.json({
-        data: await getUserListPaginated(
-          parseInt(req.query.page),
-          parseInt(req.query.size),
-        ),
-        totalElements: await getUserCount(),
-        page: req.query.page,
-        size: req.query.size,
-      })
+      res.json(await searchUserListPaginated(req.query.query, parseInt(req.query.size), parseInt(req.query.page)))
     } catch (err) {
       next(err)
     }

idp/src/user/service.ts

@@ -16,7 +16,7 @@ import {hashPassword, verifyPassword} from '@/infra/password'
 import search, {USER_SEARCH_INDEX} from '@/infra/search'
 import {User} from '@/user/model'
 import userRepo from '@/user/repo'
-import {UserAdminPostRequest, UserSuspendPostRequest} from "@/infra/admin-requests";
+import {UserAdminPostRequest, UserSearchResponse, UserSuspendPostRequest} from "@/infra/admin-requests";
 
 export type UserDTO = {
   id: string
@@ -65,11 +65,19 @@ export async function getUserByAdmin(id: string): Promise<User> {
   return adminMapEntity(await userRepo.findByID(id))
 }
 
-export async function getUserListPaginated(
-  page: number,
-  size: number,
-): Promise<User[]> {
-  return await userRepo.listAllPaginated(page, size)
+export async function searchUserListPaginated(query: string, size: number, page: number
+): Promise<UserSearchResponse> {
+  if (query && query.length >= 3) {
+    const users = await search.index(USER_SEARCH_INDEX).search(query, {page: page, hitsPerPage: size}).then((value) =>{
+      return {
+        data: value.hits,
+        totalElements: value.totalHits
+      }
+    })
+    return {data: await userRepo.listAllByIds(users.data.map((value) => {return value.id})), totalElements: users.totalElements, size: size, page: page}
+  } else {
+    return {data: await userRepo.listAllPaginated(page, size), totalElements: await userRepo.getUserCount(), size: size, page: page}
+  }
 }
 
 export async function getUserCount(): Promise<number> {
@@ -88,13 +96,23 @@ export async function updateFullName(
   user = await userRepo.update({ id: user.id, fullName: options.fullName })
   await search.index(USER_SEARCH_INDEX).updateDocuments([
     {
-      ...user,
+      id: user.id,
+      username: user.username,
+      email: user.email,
       fullName: user.fullName,
+      isEmailConfirmed: user.isEmailConfirmed,
+      createTime: user.createTime,
+      updateTime: user.updateTime,
+      picture: user.picture,
     },
   ])
   return mapEntity(user)
 }
 
+export const raiseSearchError = () => {
+  throw newError({code: ErrorCode.SearchError})
+}
+
 export async function updateEmailRequest(
   id: string,
   options: UserUpdateEmailRequestOptions,
@@ -154,11 +172,14 @@ export async function updateEmailConfirmation(
   })
   await search.index(USER_SEARCH_INDEX).updateDocuments([
     {
-      ...user,
+      id: user.id,
+      username: user.username,
       email: user.email,
-      username: user.email,
-      emailUpdateToken: null,
-      emailUpdateValue: null,
+      fullName: user.fullName,
+      isEmailConfirmed: user.isEmailConfirmed,
+      createTime: user.createTime,
+      updateTime: user.updateTime,
+      picture: user.picture,
     },
   ])
   return mapEntity(user)
@@ -191,12 +212,36 @@ export async function updatePicture(
     id: userId,
     picture: `data:${contentType};base64,${picture}`,
   })
+  await search.index(USER_SEARCH_INDEX).updateDocuments([
+    {
+      id: user.id,
+      username: user.username,
+      email: user.email,
+      fullName: user.fullName,
+      isEmailConfirmed: user.isEmailConfirmed,
+      createTime: user.createTime,
+      updateTime: user.updateTime,
+      picture: user.picture,
+    },
+  ])
   return mapEntity(user)
 }
 
 export async function deletePicture(id: string): Promise<UserDTO> {
   let user = await userRepo.findByID(id)
   user = await userRepo.update({ id: user.id, picture: null })
+  await search.index(USER_SEARCH_INDEX).updateDocuments([
+    {
+      id: user.id,
+      username: user.username,
+      email: user.email,
+      fullName: user.fullName,
+      isEmailConfirmed: user.isEmailConfirmed,
+      createTime: user.createTime,
+      updateTime: user.updateTime,
+      picture: user.picture,
+    },
+  ])
   return mapEntity(user)
 }
 
@@ -217,6 +262,18 @@ export async function suspendUser(options: UserSuspendPostRequest) {
   }
   if (user) {
     await userRepo.suspend(user.id, options.suspend)
+    await search.index(USER_SEARCH_INDEX).updateDocuments([
+      {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        fullName: user.fullName,
+        isEmailConfirmed: user.isEmailConfirmed,
+        createTime: user.createTime,
+        updateTime: user.updateTime,
+        picture: user.picture,
+      },
+    ])
   } else {
     throw newError({ code: ErrorCode.UserNotFound })
   }
@@ -229,6 +286,18 @@ export async function makeAdminUser(options: UserAdminPostRequest) {
   }
   if (user) {
     await userRepo.makeAdmin(user.id, options.makeAdmin)
+    await search.index(USER_SEARCH_INDEX).updateDocuments([
+      {
+        id: user.id,
+        username: user.username,
+        email: user.email,
+        fullName: user.fullName,
+        isEmailConfirmed: user.isEmailConfirmed,
+        createTime: user.createTime,
+        updateTime: user.updateTime,
+        picture: user.picture,
+      },
+    ])
   } else {
     throw newError({ code: ErrorCode.UserNotFound })
   }