serene-core-server 0.1.1

package/src/models/users/user-group-member-model.ts

@@ -0,0 +1,233 @@
+import { PrismaClient } from '@/prisma/client'
+
+export class UserGroupMemberModel {
+
+  // Consts
+  clName = 'UserGroupMemberModel'
+
+  // Code
+  async create(
+          prisma: PrismaClient,
+          userGroupId: string,
+          userProfileId: string,
+          isGroupAdmin: boolean) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Create record
+    try {
+      return await prisma.userGroupMember.create({
+        data: {
+          userGroupId: userGroupId,
+          userProfileId: userProfileId,
+          isGroupAdmin: isGroupAdmin
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async delete(
+          prisma: PrismaClient,
+          id: string) {
+
+    // Debug
+    const fnName = `${this.clName}.delete()`
+
+    // Delete record
+    try {
+      return await prisma.userGroupMember.delete({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async filter(
+          prisma: PrismaClient,
+          userGroupId: string | undefined,
+          isGroupAdmin: boolean | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+
+    // Query
+    try {
+      return await prisma.userGroupMember.findMany({
+        where: {
+          userGroupId: userGroupId,
+          isGroupAdmin: isGroupAdmin
+        }
+      })
+    } 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 userGroupMember: any = null
+
+    try {
+      userGroupMember = await prisma.userGroupMember.findUnique({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return userGroupMember
+  }
+
+  async getByUniqueKey(
+          prisma: PrismaClient,
+          userGroupId: string,
+          userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getByUniqueKey()`
+
+    // Validate
+    if (userGroupId == null) {
+      console.error(`${fnName}: id is null and userGroupId is null`)
+      throw 'Prisma error'
+    }
+
+    if (userProfileId == null) {
+      console.error(`${fnName}: id is null and userProfileId is null`)
+      throw 'Prisma error'
+    }
+
+    // Query
+    var userGroupMember: any = null
+
+    try {
+      userGroupMember = await prisma.userGroupMember.findFirst({
+        where: {
+          userGroupId: userGroupId,
+          userProfileId: userProfileId
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return userGroupMember
+  }
+
+  async update(
+          prisma: PrismaClient,
+          id: string,
+          userGroupId: string | undefined,
+          userProfileId: string | undefined,
+          isGroupAdmin: boolean | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Update record
+    try {
+      return await prisma.userGroupMember.update({
+        data: {
+          userGroupId: userGroupId,
+          userProfileId: userProfileId,
+          isGroupAdmin: isGroupAdmin
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: PrismaClient,
+               id: string | undefined,
+               userGroupId: string | undefined,
+               userProfileId: string | undefined,
+               isGroupAdmin: boolean | 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 &&
+        userGroupId != null &&
+        userProfileId != null) {
+
+      const userGroupMember = await
+              this.getByUniqueKey(
+                prisma,
+                userGroupId,
+                userProfileId)
+
+      if (userGroupMember != null) {
+        id = userGroupMember.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+
+      // Validate for create (mainly for type validation of the create call)
+      if (userGroupId == null) {
+        console.error(`${fnName}: id is null and userGroupId is null`)
+        throw 'Prisma error'
+      }
+
+      if (userProfileId == null) {
+        console.error(`${fnName}: id is null and userProfileId is null`)
+        throw 'Prisma error'
+      }
+
+      if (isGroupAdmin == null) {
+        console.error(`${fnName}: id is null and isGroupAdmin is null`)
+        throw 'Prisma error'
+      }
+
+      // Create
+      return await
+               this.create(
+                 prisma,
+                 userGroupId,
+                 userProfileId,
+                 isGroupAdmin)
+    } else {
+
+      // Update
+      return await
+               this.update(
+                 prisma,
+                 id,
+                 userGroupId,
+                 userProfileId,
+                 isGroupAdmin)
+    }
+  }
+}

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

@@ -0,0 +1,174 @@
+import { PrismaClient } from '@/prisma/client'
+
+export class UserGroupModel {
+
+  // Consts
+  clName = 'UserGroupModel'
+
+  // Code
+  async create(
+          prisma: PrismaClient,
+          ownerUserProfileId: string,
+          name: string) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Create record
+    try {
+      return await prisma.userGroup.create({
+        data: {
+          ownerUserProfileId: ownerUserProfileId,
+          name: name
+        }
+      })
+    } 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 userGroup: any = null
+
+    try {
+      userGroup = await prisma.userGroup.findUnique({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return userGroup
+  }
+
+  async getByUniqueKey(
+          prisma: PrismaClient,
+          ownerUserProfileId: string,
+          name: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getByUniqueKey()`
+
+    // Validate
+    if (name == null) {
+      console.error(`${fnName}: id is null and name is null`)
+      throw 'Prisma error'
+    }
+
+    // Query
+    var userGroup: any = null
+
+    try {
+      userGroup = await prisma.userGroup.findFirst({
+        where: {
+          ownerUserProfileId: ownerUserProfileId,
+          name: name
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return userGroup
+  }
+
+  async update(
+          prisma: PrismaClient,
+          id: string,
+          ownerUserProfileId: string | undefined,
+          name: string | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Update record
+    try {
+      return await prisma.userGroup.update({
+        data: {
+          ownerUserProfileId: ownerUserProfileId,
+          name: name
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: PrismaClient,
+               ownerUserProfileId: string | undefined,
+               id: string | undefined,
+               name: string | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // If id isn't specified, try to get by the unique key
+    if (id == null &&
+        ownerUserProfileId != null &&
+        name != null) {
+
+      const userGroup = await
+              this.getByUniqueKey(
+                prisma,
+                ownerUserProfileId,
+                name)
+
+      if (userGroup != null) {
+        id = userGroup.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+
+      // Validate for create (mainly for type validation of the create call)
+      if (ownerUserProfileId == null) {
+        console.error(`${fnName}: id is null and ownerUserProfileId is null`)
+        throw 'Prisma error'
+      }
+
+      if (name == null) {
+        console.error(`${fnName}: id is null and name is null`)
+        throw 'Prisma error'
+      }
+
+      // Create
+      return await
+               this.create(
+                 prisma,
+                 ownerUserProfileId,
+                 name)
+    } else {
+
+      // Update
+      return await
+               this.update(
+                 prisma,
+                 id,
+                 ownerUserProfileId,
+                 name)
+    }
+  }
+}

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

@@ -0,0 +1,172 @@
+import { PrismaClient } from '@/prisma/client'
+
+export class UserModel {
+
+  // Consts
+  clName = 'UserModel'
+
+  // Code
+  async create(prisma: PrismaClient,
+               email: string,
+               name: string | null | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Format email
+    const emailLower = email.toLocaleLowerCase().trim()
+
+    // Create record
+    try {
+      return await prisma.user.create({
+        data: {
+          email: emailLower,
+          name: name
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async filter(prisma: PrismaClient) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+  
+    // Filter
+    try {
+      return await prisma.user.findMany({})
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+  }
+
+  async getByEmail(prisma: PrismaClient,
+                   email: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getByEmail()`
+  
+    // Get formatted email for DB storage
+    const emailLower = email.toLocaleLowerCase().trim()
+
+    // Get record
+    try {
+      return await prisma.user.findUnique({
+        where: {
+          email: emailLower
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        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.user.findUnique({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+  }
+
+  async update(prisma: PrismaClient,
+               id: string,
+               email: string | undefined,
+               name: string | null | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Update record
+    try {
+      return await prisma.user.update({
+        data: {
+          email: email,
+          name: name
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: PrismaClient,
+               id: string | undefined,
+               email: string,
+               name: 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 &&
+        email != null) {
+
+      const user = await
+              this.getByEmail(
+                prisma,
+                email)
+
+      if (user != null) {
+        id = user.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+
+      // Validate for create (mainly for type validation of the create call)
+      if (email == null) {
+        console.error(`${fnName}: id is null and email is null`)
+        throw 'Prisma error'
+      }
+
+      if (name === undefined) {
+        console.error(`${fnName}: id is null and name is undefined`)
+        throw 'Prisma error'
+      }
+
+      // Create
+      return await
+               this.create(
+                 prisma,
+                 email,
+                 name)
+    } else {
+
+      // Update
+      return await
+               this.update(
+                 prisma,
+                 id,
+                 email,
+                 name)
+    }
+  }
+}