serene-core-server 0.1.1

package/dist/src/models/quotas/resource-quota-usage-model.js

@@ -0,0 +1,151 @@
+export class ResourceQuotaUsageModel {
+    // Consts
+    clName = 'ResourceQuotaUsageModel';
+    // Code
+    async create(prisma, userProfileId, resource, day, usage) {
+        // 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, userProfileId) {
+        // 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, userProfileId, resource, fromDay, toDay) {
+        // 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, userProfileId, resource, day) {
+        // 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, userProfileId, resource, fromDay, toDay) {
+        // Debug
+        const fnName = `${this.clName}.sum()`;
+        // Query
+        var aggregations = 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, id, userProfileId, resource, day, usage) {
+        // 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, id, userProfileId, resource, day, usage) {
+        // 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/dist/src/models/tech/rate-limited-api-event-model.d.ts

@@ -0,0 +1,25 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class RateLimitedApiEventModel {
+    clName: string;
+    create(prisma: PrismaClient, id: string | undefined, rateLimitedApiId: string, userProfileId: string): Promise<{
+        id: string;
+        userProfileId: string;
+        created: Date;
+        rateLimitedApiId: string;
+    }>;
+    getById(prisma: PrismaClient, id: string): Promise<any>;
+    getWaitSecondsSinceLastSpecifiedMinutes(prisma: PrismaClient, lastMinutes?: number): Promise<number | null>;
+    getUserSentForLastSpecifiedMinutes(prisma: PrismaClient, lastMinutes: number): Promise<number>;
+    update(prisma: PrismaClient, id: string, rateLimitedApiId: string, userProfileId: string): Promise<{
+        id: string;
+        userProfileId: string;
+        created: Date;
+        rateLimitedApiId: string;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, rateLimitedApiId: string, userProfileId: string): Promise<{
+        id: string;
+        userProfileId: string;
+        created: Date;
+        rateLimitedApiId: string;
+    }>;
+}

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

@@ -0,0 +1,134 @@
+export class RateLimitedApiEventModel {
+    // Consts
+    clName = 'RateLimitedApiEventModel';
+    // Code
+    async create(prisma, id, rateLimitedApiId, userProfileId) {
+        // 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, id) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Query record
+        var rateLimitedApiEvent = undefined;
+        try {
+            rateLimitedApiEvent = await prisma.rateLimitedApiEvent.findUnique({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return OK
+        return rateLimitedApiEvent;
+    }
+    async getWaitSecondsSinceLastSpecifiedMinutes(prisma, lastMinutes = 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;
+        try {
+            rateLimitedApiEvent = await prisma.rateLimitedApiEvent.findFirst({
+                where: {
+                    created: {
+                        gte: xMinutesAgoInUtc
+                    }
+                }
+            });
+        }
+        catch (error) {
+            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, lastMinutes) {
+        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) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async update(prisma, id, rateLimitedApiId, userProfileId) {
+        // 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, id, rateLimitedApiId, userProfileId) {
+        // 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);
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class RateLimitedApiModel {
+    clName: string;
+    create(prisma: PrismaClient, id: string | undefined, techId: string, ratePerMinute: number): Promise<{
+        id: string;
+        techId: string | null;
+        ratePerMinute: number;
+    }>;
+    getById(prisma: PrismaClient, id: string): Promise<any>;
+    getByTechId(prisma: PrismaClient, techId: string): Promise<any>;
+    update(prisma: PrismaClient, id: string, techId: string, ratePerMinute: number): Promise<{
+        id: string;
+        techId: string | null;
+        ratePerMinute: number;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, techId: string, ratePerMinute: number): Promise<{
+        id: string;
+        techId: string | null;
+        ratePerMinute: number;
+    }>;
+}

package/dist/src/models/tech/rate-limited-api-model.js

@@ -0,0 +1,116 @@
+export class RateLimitedApiModel {
+    // Consts
+    clName = 'RateLimitedApiModel';
+    // Code
+    async create(prisma, id, techId, ratePerMinute) {
+        // Debug
+        const fnName = `${this.clName}.create()`;
+        // Create record
+        try {
+            return await prisma.rateLimitedApi.create({
+                data: {
+                    id: id,
+                    techId: techId,
+                    ratePerMinute: ratePerMinute
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async getById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Query record
+        var rateLimitedApi = undefined;
+        try {
+            rateLimitedApi = await prisma.rateLimitedApi.findUnique({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return OK
+        return rateLimitedApi;
+    }
+    async getByTechId(prisma, techId) {
+        // Debug
+        const fnName = `${this.clName}.getByTechId()`;
+        // Validate
+        if (techId == null) {
+            console.error(`${fnName}: id is null and techId is null`);
+            throw 'Prisma error';
+        }
+        // Query record
+        var rateLimitedApi = undefined;
+        try {
+            rateLimitedApi = await prisma.rateLimitedApi.findFirst({
+                where: {
+                    techId: techId
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return OK
+        return rateLimitedApi;
+    }
+    async update(prisma, id, techId, ratePerMinute) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Update record
+        try {
+            return await prisma.rateLimitedApi.update({
+                data: {
+                    techId: techId,
+                    ratePerMinute: ratePerMinute
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, techId, ratePerMinute) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // If the id is specified, try to get it
+        if (id != null) {
+            const rateLimitedApi = await this.getById(prisma, id);
+            if (rateLimitedApi != null) {
+                id = rateLimitedApi.id;
+            }
+        }
+        // Try to get by unique key
+        if (id == null) {
+            const rateLimitedApi = await this.getByTechId(prisma, techId);
+            if (rateLimitedApi != null) {
+                id = rateLimitedApi.id;
+            }
+        }
+        // Upsert
+        if (id == null) {
+            return await this.create(prisma, id, techId, ratePerMinute);
+        }
+        else {
+            return await this.update(prisma, id, techId, ratePerMinute);
+        }
+    }
+}

package/dist/src/models/tech/tech-model.d.ts

@@ -0,0 +1,44 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class TechModel {
+    clName: string;
+    create(prisma: PrismaClient, techProviderId: string, status: string, variantName: string, resource: string, model: string | null, protocol: string | null, pricingTier: string, isDefaultProvider: boolean, isAdminOnly: boolean): Promise<{
+        id: string;
+        status: string;
+        model: string | null;
+        resource: string;
+        techProviderId: string;
+        variantName: string;
+        protocol: string | null;
+        pricingTier: string;
+        isDefaultProvider: boolean;
+        isAdminOnly: boolean;
+    }>;
+    filter(prisma: PrismaClient, techProviderId: string | undefined, status: string | undefined, resource: string | undefined, model: string | null | undefined, protocol: string | null | undefined, isAdminOnly: boolean | undefined): Promise<any>;
+    getById(prisma: PrismaClient, id: string, includeTechProvider?: boolean): Promise<any>;
+    getDefaultProvider(prisma: PrismaClient, resource: string, includeTechProvider?: boolean): Promise<any>;
+    getByVariantName(prisma: PrismaClient, variantName: string, includeTechProvider?: boolean): Promise<any>;
+    update(prisma: PrismaClient, id: string, techProviderId: string | undefined, status: string | undefined, variantName: string | undefined, resource: string | undefined, model: string | null | undefined, protocol: string | null | undefined, pricingTier: string | undefined, isDefaultProvider: boolean | undefined, isAdminOnly: boolean | undefined): Promise<{
+        id: string;
+        status: string;
+        model: string | null;
+        resource: string;
+        techProviderId: string;
+        variantName: string;
+        protocol: string | null;
+        pricingTier: string;
+        isDefaultProvider: boolean;
+        isAdminOnly: boolean;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, techProviderId: string | undefined, status: string | undefined, variantName: string | undefined, resource: string | undefined, model: string | null | undefined, protocol: string | null | undefined, pricingTier: string | undefined, isDefaultProvider: boolean | undefined, isAdminOnly: boolean | undefined): Promise<{
+        id: string;
+        status: string;
+        model: string | null;
+        resource: string;
+        techProviderId: string;
+        variantName: string;
+        protocol: string | null;
+        pricingTier: string;
+        isDefaultProvider: boolean;
+        isAdminOnly: boolean;
+    }>;
+}