serene-core-server 0.1.1

package/src/models/users/user-preference-model.ts

@@ -0,0 +1,285 @@
+import { PrismaClient } from '@/prisma/client'
+
+export class UserPreferenceModel {
+
+  // Consts
+  clName = 'UserPreferenceModel'
+
+  // Code
+  async create(
+          prisma: PrismaClient,
+          userProfileId: string,
+          category: string,
+          key: string,
+          value: string | null,
+          values: string[] | null) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Values can't be null
+    if (values == null) {
+
+      values = []
+    }
+
+    // Create record
+    try {
+      return await prisma.userPreference.create({
+        data: {
+          userProfileId: userProfileId,
+          category: category,
+          key: key,
+          value: value,
+          values: values
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async deleteById(
+          prisma: PrismaClient,
+          id: string) {
+
+    // Debug
+    const fnName = `${this.clName}.deleteById()`
+
+    // Delete
+    try {
+      return await prisma.userPreference.delete({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+  }
+
+  async filter(
+          prisma: PrismaClient,
+          userProfileId: string | undefined,
+          category: string | undefined,
+          key: string | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+
+    // Query
+    try {
+      return await prisma.userPreference.findMany({
+        where: {
+          userProfileId: userProfileId,
+          category: category,
+          key: key
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async filterManyKeys(
+          prisma: PrismaClient,
+          userProfileId: string | undefined,
+          keys: string[] | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+
+    // Query
+    try {
+      return await prisma.userPreference.findMany({
+        where: {
+          userProfileId: userProfileId,
+          key: {
+            in: keys
+          }
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async getById(
+          prisma: PrismaClient,
+          id: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getById()`
+
+    // Query
+    var userpreference: any = null
+
+    try {
+      userpreference = await prisma.userPreference.findUnique({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return userpreference
+  }
+
+  async getByUniqueKey(
+          prisma: PrismaClient,
+          userProfileId: string,
+          key: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getByUniqueKey()`
+
+    // Query
+    var userpreference: any = null
+
+    try {
+      userpreference = await prisma.userPreference.findFirst({
+        where: {
+          userProfileId: userProfileId,
+          key: key
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+    // Return
+    return userpreference
+  }
+
+  async update(
+          prisma: PrismaClient,
+          id: string,
+          userProfileId: string | undefined,
+          category: string | undefined,
+          key: string | undefined,
+          value: string | null | undefined,
+          values: string[] | null | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Values can't be null
+    if (values == null) {
+
+      values = []
+    }
+
+    // Update record
+    try {
+      return await prisma.userPreference.update({
+        data: {
+          userProfileId: userProfileId,
+          category: category,
+          key: key,
+          value: value,
+          values: values
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: PrismaClient,
+               id: string | undefined,
+               userProfileId: string | undefined,
+               category: string | undefined,
+               key: string | undefined,
+               value: string | null | undefined,
+               values: string[] | null | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // If id isn't specified, but the unique keys are, try to get the record
+    if (id == null &&
+        userProfileId != null &&
+        key != null) {
+
+      const userPreference = await
+              this.getByUniqueKey(
+                prisma,
+                userProfileId,
+                key)
+
+      if (userPreference != null) {
+        id = userPreference.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+
+      // Validate for create (mainly for type validation of the create call)
+      if (userProfileId == null) {
+        console.error(`${fnName}: id is null and userProfileId is null`)
+        throw 'Prisma error'
+      }
+
+      if (category == null) {
+        console.error(`${fnName}: id is null and category is null`)
+        throw 'Prisma error'
+      }
+
+      if (key == null) {
+        console.error(`${fnName}: id is null and key is null`)
+        throw 'Prisma error'
+      }
+
+      if (value === undefined) {
+        console.error(`${fnName}: id is null and value is undefined`)
+        throw 'Prisma error'
+      }
+
+      if (values === undefined) {
+        console.error(`${fnName}: id is null and values is undefined`)
+        throw 'Prisma error'
+      }
+
+      // Create
+      return await
+               this.create(
+                 prisma,
+                 userProfileId,
+                 category,
+                 key,
+                 value,
+                 values)
+    } else {
+
+      // Update
+      return await
+               this.update(
+                 prisma,
+                 id,
+                 userProfileId,
+                 category,
+                 key,
+                 value,
+                 values)
+    }
+  }
+}

package/src/models/users/user-profile-model.ts

@@ -0,0 +1,207 @@
+import { PrismaClient } from '@/prisma/client'
+import { UserTypes } from '../../types/user-types'
+
+export class UserProfileModel {
+
+  // Consts
+  clName = 'UserProfileModel'
+
+  // Code
+  async create(prisma: PrismaClient,
+               userId: string | null,
+               isAdmin: boolean,
+               deletePending: Date | null) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Create record
+    try {
+      return await prisma.userProfile.create({
+        data: {
+          userId: userId,
+          isAdmin: isAdmin,
+          deletePending: deletePending
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async getById(prisma: PrismaClient,
+                id: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getById()`
+  
+    // Get record
+    try {
+      return await prisma.userProfile.findUnique({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+  }
+
+  async getByUserId(
+          prisma: PrismaClient,
+          userId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getByUserId()`
+  
+    // Get record
+    try {
+      return await prisma.userProfile.findFirst({
+        where: {
+          userId: userId
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+  }
+
+  async setOwnerType(
+          prisma: PrismaClient,
+          userProfile: any) {
+
+    // Debug
+    const fnName = `${this.clName}.setOwnerType()`
+
+    console.log(`${fnName}: starting with userProfile: ` +
+                JSON.stringify(userProfile))
+
+    // Return immediately if ownerType is set
+    if (userProfile.ownerType != null) {
+
+      return {
+        status: true,
+        userProfile: userProfile
+      }
+    }
+
+    // Set to human ownerType if the userId field is set
+    var ownerType: string = ''
+
+    if (userProfile.ownerType == null) {
+
+      ownerType = UserTypes.humanRoleOwnerType
+    }
+
+    // Update record
+    userProfile = await prisma.userProfile.update({
+      data: {
+        ownerType: ownerType
+      },
+      where: {
+        id: userProfile.id
+      }
+    })
+
+    // Return
+    return {
+      status: true,
+      userProfile: userProfile
+    }
+  }
+
+  async update(prisma: PrismaClient,
+               id: string,
+               userId: string | null | undefined,
+               isAdmin: boolean | undefined,
+               deletePending: Date | null | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Create record
+    try {
+      return await prisma.userProfile.update({
+        data: {
+          userId: userId,
+          isAdmin: isAdmin
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: PrismaClient,
+               id: string | undefined,
+               userId: string | null | undefined,
+               isAdmin: boolean | undefined,
+               deletePending: Date | null | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // If id isn't specified, but the unique keys are, try to get the record
+    if (id == null &&
+        userId != null) {
+
+      const userProfile = await
+              this.getByUserId(
+                prisma,
+                userId)
+
+      if (userProfile != null) {
+        id = userProfile.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+
+      // Validate for create (mainly for type validation of the create call)
+      if (userId === undefined) {
+        console.error(`${fnName}: id is null and userId is undefined`)
+        throw 'Prisma error'
+      }
+
+      if (isAdmin == null) {
+        console.error(`${fnName}: id is null and isAdmin is null`)
+        throw 'Prisma error'
+      }
+
+      if (deletePending === undefined) {
+        console.error(`${fnName}: id is null and deletePending is undefined`)
+        throw 'Prisma error'
+      }
+
+      // Create
+      return await
+               this.create(
+                 prisma,
+                 userId,
+                 isAdmin,
+                 deletePending)
+    } else {
+
+      // Update
+      return await
+               this.update(
+                 prisma,
+                 id,
+                 userId,
+                 isAdmin,
+                 deletePending)
+    }
+  }
+}

package/src/services/access/access-service.ts

@@ -0,0 +1,36 @@
+import { PrismaClient } from '@/prisma/client'
+import { UsersService } from '../users/service'
+
+export class AccessService {
+
+  usersService = new UsersService()
+
+  async isAdminUser(
+          prisma: PrismaClient,
+          userProfileId: string) {
+
+    // Get UserProfile record
+    var userProfile: any = null
+
+    try {
+      userProfile = await prisma.userProfile.findUnique({
+        where: {
+          id: userProfileId
+        }
+      })
+    } catch(NotFound) {}
+
+    if (userProfile == null) {
+      return {
+        status: false,
+        message: 'User not found'
+      }
+    }
+
+    // Return isAdmin value
+    return {
+      status: userProfile.isAdmin,
+      message: null
+    }
+  }
+}

package/src/services/access/encrypt-service.ts

@@ -0,0 +1,122 @@
+// Source: https://stackoverflow.com/a/66476430
+
+import crypto, { BinaryLike, CipherGCMTypes, CipherKey } from 'crypto'
+import { Buffer } from 'buffer'
+
+export class Encrypter {
+
+  // Consts
+  clName = 'Encrypter'
+  header = '!enc%'
+  algorithm: CipherGCMTypes = 'aes-256-gcm'
+
+  // Vars
+  key: Buffer
+
+  // Code
+  constructor(encryptionKey: string | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.constructor()`
+
+    // Validate
+    if (encryptionKey == null) {
+
+      throw new Error(`${fnName}: encryptionKey == null`)
+    }
+
+    // Set key
+    this.key = crypto.scryptSync(encryptionKey, 'salt', 32)
+  }
+
+  encrypt(clearText: string) {
+
+    return this.encryptAes256Gcm(clearText)
+  }
+
+  encryptAes256Gcm(clearText: string) {
+
+    // Get IV
+    const iv: Buffer = crypto.randomBytes(16)
+
+    // Get cipher
+    const cipher =
+            crypto.createCipheriv(
+              this.algorithm,
+              this.key as unknown as CipherKey,
+              iv as unknown as BinaryLike)
+
+    // Encrypt string
+    const encrypted = cipher.update(clearText, 'utf8', 'hex') + cipher.final('hex')
+
+    // Get the authTag
+    const authTag = cipher.getAuthTag().toString('hex')
+  
+    // Return final string with metadata
+    return [
+      this.header,
+      this.algorithm,
+      encrypted,
+      iv.toString('hex'),
+      authTag
+    ].join('|')
+  }
+
+  decrypt(encryptedText: string) {
+
+    return this.decryptAes256Gcm(encryptedText)
+  }
+
+  decryptAes256Gcm(encryptedText: string) {
+
+    // Debug
+    const fnName = `${this.clName}.decryptAes256Gcm()`
+
+    // console.log(`${fnName}: starting with encryptedText: ${encryptedText}`)
+
+    // Split string with metadata into separate vars
+    const [header, algorithm, encrypted, iv, authTag] = encryptedText.split('|')
+
+    // Validate
+    if (header !== this.header) {
+      throw new Error('Unexpected header, string is likely not encrypted')
+    }
+
+    if (algorithm !== this.algorithm) {
+      throw new Error('Unexpected/invalid encryption algorithm')
+    }
+
+    if (!iv) {
+      throw new Error('IV not found')
+    }
+
+    if (!authTag) {
+      throw new Error('authTag not found')
+    }
+
+    // Debug
+    // console.log(`${fnName}: decipher encrypted text..`)
+
+    // Decipher encrypted string
+    const decipher =
+            crypto.createDecipheriv(
+              this.algorithm,
+              this.key as unknown as CipherKey,
+              Buffer.from(iv, 'hex') as unknown as BinaryLike)
+
+    decipher.setAuthTag(new Uint8Array(Buffer.from(authTag, 'hex')))
+
+    // Debug
+    // console.log(`${fnName}: decipher: ` + JSON.stringify(decipher))
+
+    // Get the final decrypted string
+    const decryptedText =
+            decipher.update(encrypted, 'hex', 'utf8') + decipher.final('utf8')
+
+    // Debug
+    // console.log(`${fnName}: returning decrypted text..`)
+
+    // Return final decrypted string
+    return decryptedText
+  }
+}