serene-core-server 0.1.1

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

@@ -0,0 +1,181 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceQuotaUsageModel = void 0;
+class ResourceQuotaUsageModel {
+    constructor() {
+        // Consts
+        this.clName = 'ResourceQuotaUsageModel';
+    }
+    // Code
+    create(prisma, userProfileId, resource, day, usage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.filter()`;
+            // Create
+            try {
+                return yield prisma.resourceQuotaUsage.create({
+                    data: {
+                        userProfileId: userProfileId,
+                        resource: resource,
+                        day: day,
+                        usage: usage
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    deleteByUserProfileId(prisma, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.deleteByUserProfileId()`;
+            // Query
+            try {
+                return yield prisma.resourceQuotaUsage.deleteMany({
+                    where: {
+                        userProfileId: userProfileId
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw `Prisma error`;
+            }
+        });
+    }
+    filter(prisma, userProfileId, resource, fromDay, toDay) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.filter()`;
+            // Query
+            try {
+                return yield prisma.resourceQuotaUsage.findMany({
+                    where: {
+                        userProfileId: userProfileId,
+                        resource: resource,
+                        day: {
+                            gte: fromDay,
+                            lte: toDay
+                        }
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw `Prisma error`;
+            }
+        });
+    }
+    getByUserProfileIdAndResourceAndDay(prisma, userProfileId, resource, day) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getByUserProfileIdAndResourceAndDay()`;
+            // Query
+            try {
+                return yield prisma.resourceQuotaUsage.findFirst({
+                    where: {
+                        userProfileId: userProfileId,
+                        resource: resource,
+                        day: day
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw `Prisma error`;
+            }
+        });
+    }
+    sum(prisma, userProfileId, resource, fromDay, toDay) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            // Debug
+            const fnName = `${this.clName}.sum()`;
+            // Query
+            var aggregations = undefined;
+            try {
+                aggregations = yield 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 (_a = aggregations._sum.usage) !== null && _a !== void 0 ? _a : 0;
+        });
+    }
+    update(prisma, id, userProfileId, resource, day, usage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.update()`;
+            // Create
+            try {
+                return yield 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';
+            }
+        });
+    }
+    upsert(prisma, id, userProfileId, resource, day, usage) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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 = yield this.getByUserProfileIdAndResourceAndDay(prisma, userProfileId, resource, day);
+                if (resourceQuotaUsage != null) {
+                    id = resourceQuotaUsage.id;
+                }
+            }
+            // Upsert
+            if (id == null) {
+                return yield this.create(prisma, userProfileId, resource, day, usage);
+            }
+            else {
+                return yield this.update(prisma, id, userProfileId, resource, day, usage);
+            }
+        });
+    }
+}
+exports.ResourceQuotaUsageModel = ResourceQuotaUsageModel;

package/dist/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/models/tech/rate-limited-api-event-model.js

@@ -0,0 +1,161 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitedApiEventModel = void 0;
+class RateLimitedApiEventModel {
+    constructor() {
+        // Consts
+        this.clName = 'RateLimitedApiEventModel';
+    }
+    // Code
+    create(prisma, id, rateLimitedApiId, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.create()`;
+            // Create record
+            try {
+                return yield prisma.rateLimitedApiEvent.create({
+                    data: {
+                        id: id,
+                        rateLimitedApiId: rateLimitedApiId,
+                        userProfileId: userProfileId
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    getById(prisma, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getById()`;
+            // Query record
+            var rateLimitedApiEvent = undefined;
+            try {
+                rateLimitedApiEvent = yield 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;
+        });
+    }
+    getWaitSecondsSinceLastSpecifiedMinutes(prisma_1) {
+        return __awaiter(this, arguments, void 0, function* (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 = yield 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);
+        });
+    }
+    getUserSentForLastSpecifiedMinutes(prisma, lastMinutes) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const fnName = `${this.clName}.getForLastSpecifiedMinutes()`;
+            // Get time to check from
+            var xMinutesAgoInUtc = new Date();
+            xMinutesAgoInUtc.setUTCMinutes(xMinutesAgoInUtc.getUTCMinutes() - 1);
+            // Count records
+            try {
+                return yield prisma.rateLimitedApiEvent.count({
+                    where: {
+                        created: {
+                            gte: xMinutesAgoInUtc
+                        }
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    update(prisma, id, rateLimitedApiId, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.update()`;
+            // Update record
+            try {
+                return yield prisma.rateLimitedApiEvent.update({
+                    data: {
+                        rateLimitedApiId: rateLimitedApiId,
+                        userProfileId: userProfileId
+                    },
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    upsert(prisma, id, rateLimitedApiId, userProfileId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.upsert()`;
+            // If the id is specified, try to get it
+            if (id != null) {
+                const rateLimitedApiEvent = yield this.getById(prisma, id);
+                if (rateLimitedApiEvent != null) {
+                    id = rateLimitedApiEvent.id;
+                }
+            }
+            // Upsert
+            if (id == null) {
+                return yield this.create(prisma, id, rateLimitedApiId, userProfileId);
+            }
+            else {
+                return yield this.update(prisma, id, rateLimitedApiId, userProfileId);
+            }
+        });
+    }
+}
+exports.RateLimitedApiEventModel = RateLimitedApiEventModel;

package/dist/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/models/tech/rate-limited-api-model.js

@@ -0,0 +1,141 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RateLimitedApiModel = void 0;
+class RateLimitedApiModel {
+    constructor() {
+        // Consts
+        this.clName = 'RateLimitedApiModel';
+    }
+    // Code
+    create(prisma, id, techId, ratePerMinute) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.create()`;
+            // Create record
+            try {
+                return yield prisma.rateLimitedApi.create({
+                    data: {
+                        id: id,
+                        techId: techId,
+                        ratePerMinute: ratePerMinute
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    getById(prisma, id) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.getById()`;
+            // Query record
+            var rateLimitedApi = undefined;
+            try {
+                rateLimitedApi = yield 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;
+        });
+    }
+    getByTechId(prisma, techId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // 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 = yield 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;
+        });
+    }
+    update(prisma, id, techId, ratePerMinute) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.update()`;
+            // Update record
+            try {
+                return yield prisma.rateLimitedApi.update({
+                    data: {
+                        techId: techId,
+                        ratePerMinute: ratePerMinute
+                    },
+                    where: {
+                        id: id
+                    }
+                });
+            }
+            catch (error) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        });
+    }
+    upsert(prisma, id, techId, ratePerMinute) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Debug
+            const fnName = `${this.clName}.upsert()`;
+            // If the id is specified, try to get it
+            if (id != null) {
+                const rateLimitedApi = yield this.getById(prisma, id);
+                if (rateLimitedApi != null) {
+                    id = rateLimitedApi.id;
+                }
+            }
+            // Try to get by unique key
+            if (id == null) {
+                const rateLimitedApi = yield this.getByTechId(prisma, techId);
+                if (rateLimitedApi != null) {
+                    id = rateLimitedApi.id;
+                }
+            }
+            // Upsert
+            if (id == null) {
+                return yield this.create(prisma, id, techId, ratePerMinute);
+            }
+            else {
+                return yield this.update(prisma, id, techId, ratePerMinute);
+            }
+        });
+    }
+}
+exports.RateLimitedApiModel = RateLimitedApiModel;

package/dist/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;
+    }>;
+}