serene-core-server 0.1.1

package/src/models/quotas/resource-quota-total-model.ts

@@ -0,0 +1,243 @@
+import { Prisma } from '@/prisma/client'
+
+export class ResourceQuotaTotalModel {
+
+  // Consts
+  clName = 'ResourceQuotaTotalModel'
+
+  // Code
+  async create(prisma: Prisma.TransactionClient,
+               userProfileId: string,
+               resource: string,
+               fromDay: Date,
+               toDay: Date,
+               quota: number) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+
+    // Create
+    try {
+      return await prisma.resourceQuotaTotal.create({
+        data: {
+          userProfileId: userProfileId,
+          resource: resource,
+          fromDay: fromDay,
+          toDay: toDay,
+          quota: quota
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async deleteByUserProfileId(
+          prisma: Prisma.TransactionClient,
+          userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.deleteByUserProfileId()`
+
+    // Query
+    try {
+      return await prisma.resourceQuotaTotal.deleteMany({
+        where: {
+          userProfileId: userProfileId
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw `Prisma error`
+    }
+  }
+
+  async filter(prisma: Prisma.TransactionClient,
+               userProfileId: string,
+               resource: string,
+               day: Date) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+
+    // Query
+    try {
+      return await prisma.resourceQuotaTotal.findMany({
+        where: {
+          userProfileId: userProfileId,
+          resource: resource,
+          AND: day != null ? [
+            {
+              fromDay: {
+                lte: day
+              }
+            },
+            {
+              toDay: {
+                gte: day
+              }
+            }
+          ] : undefined
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw `Prisma error`
+    }
+  }
+
+  async getByUniqueKey(
+          prisma: Prisma.TransactionClient,
+          userProfileId: string,
+          resource: string,
+          fromDay: Date,
+          toDay: Date) {
+
+    // Debug
+    const fnName = `${this.clName}.getByUniqueKey()`
+
+    // Query
+    try {
+      return await prisma.resourceQuotaTotal.findFirst({
+        where: {
+          userProfileId: userProfileId,
+          resource: resource,
+          fromDay: fromDay,
+          toDay: toDay
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw `Prisma error`
+    }
+  }
+
+  async sum(prisma: Prisma.TransactionClient,
+            userProfileId: string,
+            resource: string,
+            day: Date) {
+
+    // Debug
+    const fnName = `${this.clName}.sum()`
+
+    // Query
+    var aggregations: any = undefined
+
+    try {
+      aggregations = await prisma.resourceQuotaTotal.aggregate({
+        _sum: {
+          quota: true
+        },
+        where: {
+          userProfileId: userProfileId,
+          resource: resource,
+          AND: [
+            {
+              fromDay: {
+                lte: day
+              }
+            },
+            {
+              toDay: {
+                gte: day
+              }
+            }
+          ]
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw `Prisma error`
+    }
+
+    // Return
+    return aggregations._sum.quota ?? 0
+  }
+
+  async update(prisma: Prisma.TransactionClient,
+               id: string,
+               userProfileId: string | undefined,
+               resource: string | undefined,
+               fromDay: Date | undefined,
+               toDay: Date | undefined,
+               quota: number | undefined) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Create
+    try {
+      return await prisma.resourceQuotaTotal.update({
+        data: {
+          userProfileId: userProfileId,
+          resource: resource,
+          fromDay: fromDay,
+          toDay: toDay,
+          quota: quota
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: Prisma.TransactionClient,
+               id: string | undefined,
+               userProfileId: string,
+               resource: string,
+               fromDay: Date,
+               toDay: Date,
+               quota: number) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // Validate
+    if (quota == null ||
+        Number.isNaN(quota)) {
+
+      throw `${fnName}: quota is ${JSON.stringify(quota)}`
+    }
+
+    // Get by userProfileId and day if id is null
+    if (id == null) {
+
+      const resourceQuotaTotal = await
+              this.getByUniqueKey(
+                prisma,
+                userProfileId,
+                resource,
+                fromDay,
+                toDay)
+
+      if (resourceQuotaTotal != null) {
+        id = resourceQuotaTotal.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+      return await this.create(
+                     prisma,
+                     userProfileId,
+                     resource,
+                     fromDay,
+                     toDay,
+                     quota)
+    } else {
+      return await this.update(
+                     prisma,
+                     id,
+                     userProfileId,
+                     resource,
+                     fromDay,
+                     toDay,
+                     quota)
+    }
+  }
+}

package/src/models/quotas/resource-quota-usage-model.ts

@@ -0,0 +1,219 @@
+import { Prisma } from '@/prisma/client'
+
+export class ResourceQuotaUsageModel {
+
+  // Consts
+  clName = 'ResourceQuotaUsageModel'
+
+  // Code
+  async create(prisma: Prisma.TransactionClient,
+               userProfileId: string,
+               resource: string,
+               day: Date,
+               usage: number) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+
+    // Create
+    try {
+      return await prisma.resourceQuotaUsage.create({
+        data: {
+          userProfileId: userProfileId,
+          resource: resource,
+          day: day,
+          usage: usage
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async deleteByUserProfileId(
+          prisma: Prisma.TransactionClient,
+          userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.deleteByUserProfileId()`
+
+    // Query
+    try {
+      return await prisma.resourceQuotaUsage.deleteMany({
+        where: {
+          userProfileId: userProfileId
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw `Prisma error`
+    }
+  }
+
+  async filter(prisma: Prisma.TransactionClient,
+               userProfileId: string,
+               resource: string,
+               fromDay: Date,
+               toDay: Date) {
+
+    // Debug
+    const fnName = `${this.clName}.filter()`
+
+    // Query
+    try {
+      return await prisma.resourceQuotaUsage.findMany({
+        where: {
+          userProfileId: userProfileId,
+          resource: resource,
+          day: {
+            gte: fromDay,
+            lte: toDay
+          }
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw `Prisma error`
+    }
+  }
+
+  async getByUserProfileIdAndResourceAndDay(
+          prisma: Prisma.TransactionClient,
+          userProfileId: string,
+          resource: string,
+          day: Date) {
+
+    // Debug
+    const fnName = `${this.clName}.getByUserProfileIdAndResourceAndDay()`
+
+    // Query
+    try {
+      return await prisma.resourceQuotaUsage.findFirst({
+        where: {
+          userProfileId: userProfileId,
+          resource: resource,
+          day: day
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw `Prisma error`
+    }
+  }
+
+  async sum(prisma: Prisma.TransactionClient,
+            userProfileId: string,
+            resource: string,
+            fromDay: Date,
+            toDay: Date) {
+
+    // Debug
+    const fnName = `${this.clName}.sum()`
+
+    // Query
+    var aggregations: any = undefined
+
+    try {
+      aggregations = await prisma.resourceQuotaUsage.aggregate({
+        _sum: {
+          usage: true
+        },
+        where: {
+          userProfileId: userProfileId,
+          resource: resource,
+          day: {
+            gte: fromDay,
+            lte: toDay
+          }
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw `Prisma error`
+    }
+
+    // Return
+    return aggregations._sum.usage ?? 0
+  }
+
+  async update(prisma: Prisma.TransactionClient,
+               id: string,
+               userProfileId: string,
+               resource: string,
+               day: Date,
+               usage: number) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Create
+    try {
+      return await prisma.resourceQuotaUsage.update({
+        data: {
+          userProfileId: userProfileId,
+          resource: resource,
+          day: day,
+          usage: usage
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: Prisma.TransactionClient,
+               id: string | undefined,
+               userProfileId: string,
+               resource: string,
+               day: Date,
+               usage: number) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // Validate
+    if (usage == null ||
+        Number.isNaN(usage)) {
+
+      throw `${fnName}: usage is ${JSON.stringify(usage)}`
+    }
+
+    // Get by userProfileId and day if id is null
+    if (id == null) {
+
+      const resourceQuotaUsage = await
+              this.getByUserProfileIdAndResourceAndDay(
+                prisma,
+                userProfileId,
+                resource,
+                day)
+
+      if (resourceQuotaUsage != null) {
+        id = resourceQuotaUsage.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+      return await this.create(
+                     prisma,
+                     userProfileId,
+                     resource,
+                     day,
+                     usage)
+    } else {
+      return await this.update(
+                     prisma,
+                     id,
+                     userProfileId,
+                     resource,
+                     day,
+                     usage)
+    }
+  }
+}

package/src/models/tech/rate-limited-api-event-model.ts

@@ -0,0 +1,190 @@
+import { PrismaClient } from '@/prisma/client'
+
+export class RateLimitedApiEventModel {
+
+  // Consts
+  clName = 'RateLimitedApiEventModel'
+
+  // Code
+  async create(prisma: PrismaClient,
+               id: string | undefined,
+               rateLimitedApiId: string,
+               userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.create()`
+
+    // Create record
+    try {
+      return await prisma.rateLimitedApiEvent.create({
+        data: {
+          id: id,
+          rateLimitedApiId: rateLimitedApiId,
+          userProfileId: userProfileId
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async getById(prisma: PrismaClient,
+                id: string) {
+
+    // Debug
+    const fnName = `${this.clName}.getById()`
+
+    // Query record
+    var rateLimitedApiEvent: any = undefined
+
+    try {
+      rateLimitedApiEvent = await
+        prisma.rateLimitedApiEvent.findUnique({
+          where: {
+            id: id
+          }
+        })
+    } catch(error: any) {
+      if (!(error instanceof error.NotFound)) {
+        console.error(`${fnName}: error: ${error}`)
+        throw 'Prisma error'
+      }
+    }
+
+    // Return OK
+    return rateLimitedApiEvent
+  }
+
+  async getWaitSecondsSinceLastSpecifiedMinutes(
+          prisma: PrismaClient,
+          lastMinutes: number = 1) {
+
+    const fnName = `${this.clName}.getWaitSecondsSinceLastSpecifiedMinutes()`
+
+    // Get time to check from
+    var xMinutesAgoInUtc = new Date()
+    xMinutesAgoInUtc.setUTCMinutes(xMinutesAgoInUtc.getUTCMinutes() - 1)
+
+    // Get first record in window
+    var rateLimitedApiEvent: any
+
+    try {
+      rateLimitedApiEvent = await prisma.rateLimitedApiEvent.findFirst({
+        where: {
+          created: {
+            gte: xMinutesAgoInUtc
+          }
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+
+    // console.log(`${fnName}: rateLimitedApiEvent: ` +
+    //             JSON.stringify(rateLimitedApiEvent))
+
+    if (rateLimitedApiEvent == null) {
+      return null
+    }
+
+    // Get diff in seconds and return the time to go
+    var utc = new Date()
+    utc.setUTCMinutes(utc.getUTCMinutes())
+
+    return (lastMinutes * 60) -
+              Math.trunc(
+                (utc.getTime() -
+                rateLimitedApiEvent.created.getTime()) / 1000)
+  }
+
+  async getUserSentForLastSpecifiedMinutes(
+          prisma: PrismaClient,
+          lastMinutes: number) {
+
+    const fnName = `${this.clName}.getForLastSpecifiedMinutes()`
+
+    // Get time to check from
+    var xMinutesAgoInUtc = new Date()
+    xMinutesAgoInUtc.setUTCMinutes(xMinutesAgoInUtc.getUTCMinutes() - 1)
+
+    // Count records
+    try {
+      return await prisma.rateLimitedApiEvent.count({
+        where: {
+          created: {
+            gte: xMinutesAgoInUtc
+          }
+        }
+      })
+    } catch(error: any) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async update(prisma: PrismaClient,
+               id: string,
+               rateLimitedApiId: string,
+               userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.update()`
+
+    // Update record
+    try {
+      return await prisma.rateLimitedApiEvent.update({
+        data: {
+          rateLimitedApiId: rateLimitedApiId,
+          userProfileId: userProfileId
+        },
+        where: {
+          id: id
+        }
+      })
+    } catch(error) {
+      console.error(`${fnName}: error: ${error}`)
+      throw 'Prisma error'
+    }
+  }
+
+  async upsert(prisma: PrismaClient,
+               id: string | undefined,
+               rateLimitedApiId: string,
+               userProfileId: string) {
+
+    // Debug
+    const fnName = `${this.clName}.upsert()`
+
+    // If the id is specified, try to get it
+    if (id != null) {
+
+      const rateLimitedApiEvent = await
+              this.getById(
+                prisma,
+                id)
+
+      if (rateLimitedApiEvent != null) {
+        id = rateLimitedApiEvent.id
+      }
+    }
+
+    // Upsert
+    if (id == null) {
+
+      return await this.create(
+                     prisma,
+                     id,
+                     rateLimitedApiId,
+                     userProfileId)
+    } else {
+
+      return await this.update(
+                     prisma,
+                     id,
+                     rateLimitedApiId,
+                     userProfileId)
+    }
+  }
+}