@volcanicminds/typeorm 2.0.1 → 2.1.1

package/lib/entities/token.ts

@@ -0,0 +1,17 @@
+import { BaseEntity } from 'typeorm'
+
+export abstract class Token extends BaseEntity {
+  // abstract id: any
+  abstract externalId: string
+  abstract name: string
+  abstract description: string
+  abstract blocked: boolean
+  abstract blockedReason: string
+  abstract blockedAt: Date
+  abstract roles: string[]
+  abstract createdAt: Date
+  abstract updatedAt: Date
+  abstract deletedAt: Date
+  abstract setId(id: any)
+  abstract getId(): any
+}

package/lib/entities/user.ts

@@ -0,0 +1,24 @@
+import { BaseEntity } from 'typeorm'
+
+export abstract class User extends BaseEntity {
+  // abstract id: any
+  abstract externalId: string
+  abstract username: string
+  abstract email: string
+  abstract password: string
+  abstract confirmed: boolean
+  abstract confirmedAt: Date
+  abstract passwordChangedAt: Date
+  abstract blocked: boolean
+  abstract blockedReason: string
+  abstract blockedAt: Date
+  abstract resetPasswordToken: string
+  abstract confirmationToken: string
+  abstract roles: string[]
+  abstract version: number
+  abstract createdAt: Date
+  abstract updatedAt: Date
+  abstract deletedAt: Date
+  abstract setId(id: any)
+  abstract getId(): any
+}

package/lib/loader/dataBaseManager.ts

@@ -0,0 +1,37 @@
+import * as log from '../util/logger.js'
+
+export function isImplemented() {
+  return true
+}
+
+export async function synchronizeSchemas() {
+  try {
+    await global.connection.synchronize()
+    return true
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveBy(entityName, entityId) {
+  try {
+    return await global.entity[entityName].findOneById(entityId)
+  } catch (error) {
+    if (!(entityName in global.entity)) {
+      log.error(`${entityName} not found in global.entity`)
+    }
+    throw error
+  }
+}
+
+export async function addChange(entityName, entityId, status, userId, contents, changeEntity = 'Change') {
+  try {
+    const newChange = await global.entity[changeEntity].create({ entityName, entityId, status, userId, contents })
+    return global.entity[changeEntity].save(newChange)
+  } catch (error) {
+    if (!(changeEntity in global.entity)) {
+      log.error(`${changeEntity} not found in global.entity`)
+    }
+    throw error
+  }
+}

package/lib/loader/entities.ts

@@ -0,0 +1,35 @@
+import * as path from 'path'
+import { globSync } from 'glob'
+import pluralize from 'pluralize'
+import { createRequire } from 'module'
+import { fileURLToPath } from 'url'
+
+const require = createRequire(import.meta.url)
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export function load() {
+  const classes: any = {}
+  const repositories: any = {}
+  const entities: any[] = []
+
+  const patterns = [
+    path.join(__dirname, '..', 'entities', '*.e.{ts,js}'),
+    path.join(process.cwd(), 'src', 'entities', '*.e.{ts,js}')
+  ]
+
+  patterns.forEach((pattern) => {
+    globSync(pattern, { nodir: true, windowsPathsNoEscape: true }).forEach((f: string) => {
+      const entityClass = require(f)
+      const entityNames = Object.keys(entityClass)
+
+      entityNames.map((name) => {
+        classes[name] = entityClass[name]
+        repositories[pluralize(name.toLowerCase())] = entityClass[name]
+        entities.push(entityClass[name])
+      })
+    })
+  })
+
+  return { classes, repositories, entities }
+}

package/lib/loader/tokenManager.ts

@@ -0,0 +1,128 @@
+import * as Crypto from 'crypto'
+import { ServiceError } from '../util/error.js'
+import { executeCountQuery, executeFindQuery } from '../query.js'
+
+export function isImplemented() {
+  return true
+}
+
+export async function isValidToken(data: typeof global.entity.Token) {
+  return !!data && (!!data._id || !!data.id) && !!data.externalId && !!data.name
+}
+
+export async function createToken(data: typeof global.entity.Token) {
+  const { name, description } = data
+
+  if (!name) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+
+  try {
+    let externalId, token
+    do {
+      externalId = Crypto.randomUUID({ disableEntropyCache: true })
+
+      token = await global.repository.tokens.findOneBy({ externalId: externalId })
+    } while (token != null)
+
+    token = await global.entity.Token.create({
+      ...data,
+      name: name,
+      description: description,
+      blocked: false,
+      blockedReason: null,
+      externalId: externalId
+    } as typeof global.entity.Token)
+
+    return await global.entity.Token.save(token)
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function resetExternalId(id: string) {
+  if (!id) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+
+  try {
+    let externalId, token
+    do {
+      externalId = Crypto.randomUUID({ disableEntropyCache: true })
+      token = await global.repository.tokens.findOneBy({ externalId: externalId })
+    } while (token != null)
+
+    // TODO: use externalId instead id
+    return await updateTokenById(id, { externalId: externalId })
+  } catch (error) {
+    if (error?.code == 23505) {
+      throw new Error('External ID not changed')
+    }
+    throw error
+  }
+}
+
+export async function updateTokenById(id: string, token: typeof global.entity.Token) {
+  if (!id || !token) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    const tokenEx = await global.repository.tokens.findOneById(id)
+    if (!tokenEx) {
+      throw new ServiceError('Token not found', 404)
+    }
+    const merged = global.repository.tokens.merge(tokenEx, token)
+    return await global.entity.Token.save(merged)
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveTokenById(id: string) {
+  if (!id) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.tokens.findOneById(id)
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveTokenByExternalId(externalId: string) {
+  if (!externalId) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.tokens.findOneBy({ externalId: externalId })
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function blockTokenById(id: string, reason: string) {
+  return updateTokenById(id, { blocked: true, blockedAt: new Date(), blockedReason: reason })
+}
+
+export async function unblockTokenById(id: string) {
+  return updateTokenById(id, { blocked: false, blockedAt: new Date(), blockedReason: null })
+}
+
+export async function countQuery(data: any) {
+  return await executeCountQuery(global.repository.tokens, data, {})
+}
+
+export async function findQuery(data: any) {
+  return await executeFindQuery(global.repository.tokens, {}, data)
+}
+
+export async function removeTokenById(id: string) {
+  if (!id) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.tokens.delete(id)
+  } catch (error) {
+    throw error
+  }
+}

package/lib/loader/userManager.ts

@@ -0,0 +1,304 @@
+import * as bcrypt from 'bcrypt'
+import * as Crypto from 'crypto'
+import { ServiceError } from '../util/error.js'
+import { executeCountQuery, executeFindQuery } from '../query.js'
+
+export function isImplemented() {
+  return true
+}
+
+export async function isValidUser(data: typeof global.entity.User) {
+  return !!data && (!!data._id || !!data.id) && !!data.externalId && !!data.email && !!data.password
+}
+
+export async function createUser(data: typeof global.entity.User) {
+  const { username, email, password } = data
+
+  if (!email || !password) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+
+  const salt = await bcrypt.genSalt(12)
+  const hashedPassword = await bcrypt.hash(password, salt)
+
+  try {
+    let externalId, user
+    do {
+      externalId = Crypto.randomUUID({ disableEntropyCache: true })
+
+      user = await global.repository.users.findOneBy({ externalId: externalId })
+    } while (user != null)
+
+    user = await global.entity.User.create({
+      ...data,
+      passwordChangedAt: new Date(),
+      confirmed: false,
+      confirmationToken: Crypto.randomBytes(64).toString('hex'),
+      blocked: false,
+      blockedReason: null,
+      externalId: externalId,
+      email: email,
+      username: username || email,
+      password: hashedPassword
+    } as typeof global.entity.User)
+
+    return await global.entity.User.save(user)
+  } catch (error) {
+    if (error?.code == 23505) {
+      throw new ServiceError('Email or username already registered', 409)
+    }
+    throw error
+  }
+}
+
+export async function deleteUser(id: string) {
+  if (!id) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+
+  try {
+    const userEx = await retrieveUserById(id)
+    if (!userEx) {
+      throw new ServiceError('User not found', 404)
+    }
+
+    return global.entity.User.delete(id)
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function resetExternalId(id: string) {
+  if (!id) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+
+  try {
+    let externalId, user
+    do {
+      externalId = Crypto.randomUUID({ disableEntropyCache: true })
+      user = await global.repository.users.findOneBy({ externalId: externalId })
+    } while (user != null)
+
+    // TODO: use externalId instead id
+    return await updateUserById(id, { externalId: externalId })
+  } catch (error) {
+    if (error?.code == 23505) {
+      throw new ServiceError('External ID not changed', 409)
+    }
+    throw error
+  }
+}
+
+export async function updateUserById(id: string, user: typeof global.entity.User) {
+  if (!id || !user) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    const userEx = await retrieveUserById(id)
+    if (!userEx) {
+      throw new ServiceError('User not found', 404)
+    }
+    const merged = global.repository.users.merge(userEx, user)
+    return await global.entity.User.save(merged)
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveUserById(id: string) {
+  if (!id) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.users.findOneById(id)
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveUserByEmail(email: string) {
+  if (!email) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.users.findOneBy({ email: email })
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveUserByUsername(username: string) {
+  if (!username) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.users.findOneBy({ username })
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveUserByConfirmationToken(code: string) {
+  if (!code) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.users.findOneBy({ confirmationToken: code })
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveUserByResetPasswordToken(code: string) {
+  if (!code) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.users.findOneBy({ resetPasswordToken: code })
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveUserByExternalId(externalId: string) {
+  if (!externalId) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.repository.users.findOne({
+      where: { externalId: externalId },
+      cache: global.cacheTimeout
+    })
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function retrieveUserByPassword(email: string, password: string) {
+  if (!email || !password) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    const user = await global.repository.users.findOneBy({ email: email })
+    if (!user) {
+      throw new Error('Wrong credentials')
+    }
+    const match = await bcrypt.compare(password, user.password)
+    return match ? user : null
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function changePassword(email: string, password: string, oldPassword: string) {
+  if (!email || !password || !oldPassword) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    const user = await global.repository.users.findOneBy({ email: email })
+    const match = await bcrypt.compare(oldPassword, user.password)
+    if (match) {
+      const salt = await bcrypt.genSalt(12)
+      const hashedPassword = await bcrypt.hash(password, salt)
+      return await global.entity.User.save({ ...user, passwordChangedAt: new Date(), password: hashedPassword })
+    }
+    throw new ServiceError('Password not changed', 400)
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function forgotPassword(email: string) {
+  if (!email) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    const user = await global.repository.users.findOneBy({ email: email })
+
+    if (user) {
+      return await global.entity.User.save({
+        ...user,
+        resetPasswordToken: Crypto.randomBytes(64).toString('hex')
+      })
+    }
+    throw new ServiceError('Password not changed', 400)
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function resetPassword(user: typeof global.entity.User, password: string) {
+  if (!user || !password) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    const salt = await bcrypt.genSalt(12)
+    const hashedPassword = await bcrypt.hash(password, salt)
+    return await global.entity.User.save({
+      ...user,
+      passwordChangedAt: new Date(),
+      confirmed: true,
+      confirmedAt: new Date(),
+      resetPasswordToken: null,
+      password: hashedPassword
+    })
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function userConfirmation(user: typeof global.entity.User) {
+  if (!user) {
+    throw new ServiceError('Invalid parameters', 400)
+  }
+  try {
+    return await global.entity.User.save({ ...user, confirmed: true, confirmedAt: new Date(), confirmationToken: null })
+  } catch (error) {
+    throw error
+  }
+}
+
+export async function blockUserById(id: string, reason: string) {
+  return updateUserById(id, { blocked: true, blockedAt: new Date(), blockedReason: reason })
+}
+
+export async function unblockUserById(id: string) {
+  return updateUserById(id, { blocked: false, blockedAt: new Date(), blockedReason: null })
+}
+
+export function isPasswordToBeChanged(user: typeof global.entity.User) {
+  if (process.env.PASSWORD_EXPIRATION_DAYS != null) {
+    let passwordExpirationDays = -1
+    try {
+      passwordExpirationDays = Number(process.env.PASSWORD_EXPIRATION_DAYS)
+      if (passwordExpirationDays <= 0) {
+        throw new Error('PASSWORD_EXPIRATION_DAYS_ENV_INVALID')
+      }
+    } catch (e) {
+      throw new Error(e)
+    }
+    const { passwordChangedAt } = user
+    const date1 = new Date(passwordChangedAt)
+    const date2 = new Date()
+    const differenceInTime = date2.getTime() - date1.getTime()
+    const differenceInDays = differenceInTime / (1000 * 3600 * 24)
+
+    return differenceInDays >= passwordExpirationDays
+  }
+
+  return false
+}
+
+export async function countQuery(data: any) {
+  return await executeCountQuery(global.repository.users, data)
+}
+
+export async function findQuery(data: any) {
+  return await executeFindQuery(global.repository.users, {}, data)
+}
+
+export async function disableUserById(id: string) {
+  await updateUserById(id, { blocked: true, blockedAt: new Date(), blockedReason: 'User disabled to unregister' })
+  return resetExternalId(id)
+}

package/lib/query/builder.ts

@@ -0,0 +1,38 @@
+const combineSqlAnd = (left, right) => {
+  if (Array.isArray(left) || Array.isArray(right)) {
+    throw new Error('Combining OR conditions with AND is not supported in this simplified SQL builder.')
+  }
+  return { ...left, ...right }
+}
+
+export const buildWhereFromAst = (ast: any, aliasMap: Map<string, any>, isMongo: boolean) => {
+  if (!ast) {
+    return {}
+  }
+
+  if (ast.type === 'operand') {
+    if (!aliasMap.has(ast.value)) {
+      throw new Error(`Alias "${ast.value}" used in _logic not found in query parameters.`)
+    }
+    return aliasMap.get(ast.value)
+  }
+
+  const left = buildWhereFromAst(ast.left, aliasMap, isMongo)
+  const right = buildWhereFromAst(ast.right, aliasMap, isMongo)
+
+  if (ast.type === 'AND') {
+    if (isMongo) {
+      return { $and: [left, right].flat() }
+    }
+    return combineSqlAnd(left, right)
+  }
+
+  if (ast.type === 'OR') {
+    if (isMongo) {
+      return { $or: [left, right].flat() }
+    }
+    return [left, right].flat()
+  }
+
+  return {}
+}

package/lib/query/parser.ts

@@ -0,0 +1,29 @@
+export const parseLogicExpression = (logic: string) => {
+  const tokens = logic.match(/\(|\)|[A-Za-z0-9_:]+|\s*(AND|OR)\s*/g)?.filter((t) => t.trim()) || []
+  let pos = 0
+
+  const parseExpression = () => {
+    let left = parseTerm()
+    while (pos < tokens.length && (tokens[pos].trim() === 'OR' || tokens[pos].trim() === 'AND')) {
+      const operator = tokens[pos++].trim()
+      const right = parseTerm()
+      left = { type: operator, left, right }
+    }
+    return left
+  }
+
+  const parseTerm = () => {
+    if (tokens[pos] === '(') {
+      pos++
+      const node = parseExpression()
+      if (tokens[pos] !== ')') {
+        throw new Error('Mismatched parentheses in _logic expression')
+      }
+      pos++
+      return node
+    }
+    return { type: 'operand', value: tokens[pos++] }
+  }
+
+  return parseExpression()
+}