serene-core-server 0.1.1

package/src/models/instances/instance-setting-model.ts

@@ -0,0 +1,235 @@
+import { Prisma } from '@/prisma/client'
+
+export class InstanceSettingModel {
+
+  // Consts
+  clName = 'InstanceSettingModel'
+
+  // Code
+  async create(
+          prisma: Prisma.TransactionClient,
+          instanceId: string,
+          name: string,
+          value: string) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Create record
+    try {
+      return await prisma.instanceSetting.create({
+        data: {
+          instanceId: instanceId,
+          name: name,
+          value: value
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async deleteByInstanceId(
+          prisma: Prisma.TransactionClient,
+          instanceId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.deleteByInstanceId()`
+
+    // Delete records
+    try {
+      return await prisma.instanceSetting.deleteMany({
+        where: {
+          instanceId: instanceId
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async filter(
+          prisma: Prisma.TransactionClient,
+          instanceId: string | undefined,
+          name: string | undefined,
+          value: string | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+
+    // console.log(`${fnName}: starting..`)
+
+    // Query
+    try {
+      return await prisma.instanceSetting.findMany({
+        where: {
+          instanceId: instanceId,
+          name: name,
+          value: value
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async getById(
+          prisma: Prisma.TransactionClient,
+          id: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getById()`
+
+    // Query
+    var instanceSetting: any = null
+
+    try {
+      instanceSetting = await prisma.instanceSetting.findUnique({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return instanceSetting
+  }
+
+  async getByInstanceIdAndName(
+          prisma: Prisma.TransactionClient,
+          instanceId: string,
+          name: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getByInstanceIdAndName()`
+
+    // Validate
+    if (instanceId == null) {
+      console.error(`${fnName}: instanceId == null`)
+      throw 'Validation error'
+    }
+
+    if (name == null) {
+      console.error(`${fnName}: name == null`)
+      throw 'Validation error'
+    }
+
+    // Query
+    var instanceSetting: any
+
+    try {
+      instanceSetting = await prisma.instanceSetting.findFirst({
+        where: {
+          instanceId: instanceId,
+          name: name
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+
+    // Return
+    return instanceSetting
+  }
+
+  async update(
+          prisma: Prisma.TransactionClient,
+          id: string,
+          instanceId: string | undefined,
+          name: string | undefined,
+          value: string | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Update record
+    try {
+      return await prisma.instanceSetting.update({
+        data: {
+          instanceId: instanceId,
+          name: name,
+          value: value
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: Prisma.TransactionClient,
+               id: string | undefined,
+               instanceId: string | undefined,
+               name: string | undefined,
+               value: string | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // If id isn't specified, try to get by the unique key
+    if (id == null &&
+        instanceId != null &&
+        name != null) {
+
+      const instanceSetting = await
+              this.getByInstanceIdAndName(
+                prisma,
+                instanceId,
+                name)
+
+      if (instanceSetting != null) {
+        id = instanceSetting.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+
+      // Validate for create (mainly for type validation of the create call)
+      if (instanceId == null) {
+        console.error(`${fnName}: id is null and instanceId is null`)
+        throw 'Prisma error'
+      }
+
+      if (name == null) {
+        console.error(`${fnName}: id is null and name is null`)
+        throw 'Prisma error'
+      }
+
+      if (value == null) {
+        console.error(`${fnName}: id is null and value is null`)
+        throw 'Prisma error'
+      }
+
+      // Create
+      return await
+               this.create(
+                 prisma,
+                 instanceId,
+                 name,
+                 value)
+    } else {
+
+      // Update
+      return await
+               this.update(
+                 prisma,
+                 id,
+                 instanceId,
+                 name,
+                 value)
+    }
+  }
+}

package/src/models/mailing-lists/mailing-list-model.ts

@@ -0,0 +1,177 @@
+import { PrismaClient } from '@/prisma/client'
+
+export class MailingListModel {
+
+  // Consts
+  clName = 'MailingListModel'
+
+  // Code
+  async create(
+          prisma: PrismaClient,
+          name: string,
+          title: string) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Validate
+    if (name == null) {
+      console.error(`${fnName}: name == null`)
+      throw 'Validation error'
+    }
+
+    if (title == null) {
+      console.error(`${fnName}: title == null`)
+      throw 'Validation error'
+    }
+
+    // Create record
+    try {
+      return await prisma.mailingList.create({
+        data: {
+          name: name,
+          title: title
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async getAll(prisma: PrismaClient) {
+
+    // Debug
+    const fnName = `${this.clName}.getAll()`
+
+    // Query
+    try {
+      return await prisma.mailingList.findMany()
+    } 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 mailingList: any = null
+
+    try {
+      mailingList = await prisma.mailingList.findUnique({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return mailingList
+  }
+
+  async getByName(
+          prisma: PrismaClient,
+          name: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getByKey()`
+
+    // Validate
+    if (name == null) {
+      console.error(`${fnName}: name == null`)
+      throw 'Validation error'
+    }
+
+    // Query
+    var mailingList: any = null
+
+    try {
+      mailingList = await prisma.mailingList.findUnique({
+        where: {
+          name: name
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return mailingList
+  }
+
+  async update(
+          prisma: PrismaClient,
+          id: string,
+          name: string,
+          title: string) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Update record
+    try {
+      return await prisma.mailingList.update({
+        data: {
+          name: name,
+          title: title
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${JSON.stringify(error)}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(
+          prisma: PrismaClient,
+          id: string,
+          name: string,
+          title: string) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // Try to get an existing record
+    if (name != null) {
+      const mailingList = await
+              this.getByName(
+                prisma,
+                name)
+
+      if (mailingList != null) {
+        id = mailingList.id
+      }
+    }
+
+    if (id == null) {
+
+      return await this.create(
+                     prisma,
+                     name,
+                     title)
+    } else {
+      return await this.update(
+                     prisma,
+                     id,
+                     name,
+                     title)
+    }
+  }
+}

package/src/models/mailing-lists/mailing-list-subscriber-model.ts

@@ -0,0 +1,194 @@
+import { PrismaClient } from '@/prisma/client'
+
+export class MailingListSubscriberModel {
+
+  // Consts
+  clName = 'MailingListSubscriberModel'
+
+  // Code
+  async create(
+          prisma: PrismaClient,
+          mailingListId: string,
+          email: string,
+          firstName: string | undefined,
+          verificationCode: string | undefined,
+          verified: Date | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Validate
+    if (mailingListId == null) {
+      console.error(`${fnName}: mailingListId == null`)
+      throw 'Validation error'
+    }
+
+    if (email == null) {
+      console.error(`${fnName}: email == null`)
+      throw 'Validation error'
+    }
+
+    // Create record
+    try {
+      return await prisma.mailingListSubscriber.create({
+        data: {
+          mailingListId: mailingListId,
+          email: email,
+          firstName: firstName,
+          verificationCode: verificationCode,
+          verified: verified
+        }
+      })
+    } 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 mailingListSubscriber: any = null
+
+    try {
+      mailingListSubscriber = await prisma.mailingListSubscriber.findUnique({
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return mailingListSubscriber
+  }
+
+  async getByMailingListIdAndEmail(
+          prisma: PrismaClient,
+          mailingListId: string,
+          email: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getByMailingListIdAndEmail()`
+
+    // Validate
+    if (mailingListId == null) {
+      console.error(`${fnName}: mailingListId == null`)
+      throw 'Validation error'
+    }
+
+    if (email == null) {
+      console.error(`${fnName}: email == null`)
+      throw 'Validation error'
+    }
+
+    // Query
+    var mailingListSubscriber: any = null
+
+    try {
+      mailingListSubscriber = await prisma.mailingListSubscriber.findFirst({
+        where: {
+          mailingListId: mailingListId,
+          email: email
+        }
+      })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return
+    return mailingListSubscriber
+  }
+
+  async update(
+          prisma: PrismaClient,
+          id: string,
+          mailingListId: string,
+          email: string,
+          firstName: string | undefined,
+          verificationCode: string | undefined,
+          verified: Date | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Update record
+    try {
+      return await prisma.mailingListSubscriber.update({
+        data: {
+          mailingListId: mailingListId,
+          email: email,
+          firstName: firstName,
+          verificationCode: verificationCode,
+          verified: verified
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${JSON.stringify(error)}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(
+          prisma: PrismaClient,
+          id: string,
+          mailingListId: string,
+          email: string,
+          firstName: string | undefined,
+          verificationCode: string | undefined,
+          verified: Date | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // Try to get an existing record
+    if (mailingListId != null &&
+        email != null) {
+
+      const mailingListSubscriber = await
+              this.getByMailingListIdAndEmail(
+                prisma,
+                mailingListId,
+              email)
+
+      if (mailingListSubscriber != null) {
+        id = mailingListSubscriber.id
+      }
+    }
+
+    if (id == null) {
+
+      return await this.create(
+                     prisma,
+                     mailingListId,
+                     email,
+                     firstName,
+                     verificationCode,
+                     verified)
+    } else {
+      return await this.update(
+                     prisma,
+                     id,
+                     mailingListId,
+                     email,
+                     firstName,
+                     verificationCode,
+                     verified)
+    }
+  }
+}