serene-core-server 0.1.1

package/dist/src/models/users/user-preference-model.js

@@ -0,0 +1,197 @@
+export class UserPreferenceModel {
+    // Consts
+    clName = 'UserPreferenceModel';
+    // Code
+    async create(prisma, userProfileId, category, key, value, values) {
+        // Debug
+        const fnName = `${this.clName}.create()`;
+        // Values can't be null
+        if (values == null) {
+            values = [];
+        }
+        // Create record
+        try {
+            return await prisma.userPreference.create({
+                data: {
+                    userProfileId: userProfileId,
+                    category: category,
+                    key: key,
+                    value: value,
+                    values: values
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async deleteById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.deleteById()`;
+        // Delete
+        try {
+            return await prisma.userPreference.delete({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+    }
+    async filter(prisma, userProfileId, category, key) {
+        // Debug
+        const fnName = `${this.clName}.filter()`;
+        // Query
+        try {
+            return await prisma.userPreference.findMany({
+                where: {
+                    userProfileId: userProfileId,
+                    category: category,
+                    key: key
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async filterManyKeys(prisma, userProfileId, keys) {
+        // Debug
+        const fnName = `${this.clName}.filter()`;
+        // Query
+        try {
+            return await prisma.userPreference.findMany({
+                where: {
+                    userProfileId: userProfileId,
+                    key: {
+                        in: keys
+                    }
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async getById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Query
+        var userpreference = null;
+        try {
+            userpreference = await prisma.userPreference.findUnique({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return
+        return userpreference;
+    }
+    async getByUniqueKey(prisma, userProfileId, key) {
+        // Debug
+        const fnName = `${this.clName}.getByUniqueKey()`;
+        // Query
+        var userpreference = null;
+        try {
+            userpreference = await prisma.userPreference.findFirst({
+                where: {
+                    userProfileId: userProfileId,
+                    key: key
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+        // Return
+        return userpreference;
+    }
+    async update(prisma, id, userProfileId, category, key, value, values) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Values can't be null
+        if (values == null) {
+            values = [];
+        }
+        // Update record
+        try {
+            return await prisma.userPreference.update({
+                data: {
+                    userProfileId: userProfileId,
+                    category: category,
+                    key: key,
+                    value: value,
+                    values: values
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, userProfileId, category, key, value, values) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // If id isn't specified, but the unique keys are, try to get the record
+        if (id == null &&
+            userProfileId != null &&
+            key != null) {
+            const userPreference = await this.getByUniqueKey(prisma, userProfileId, key);
+            if (userPreference != null) {
+                id = userPreference.id;
+            }
+        }
+        // Upsert
+        if (id == null) {
+            // Validate for create (mainly for type validation of the create call)
+            if (userProfileId == null) {
+                console.error(`${fnName}: id is null and userProfileId is null`);
+                throw 'Prisma error';
+            }
+            if (category == null) {
+                console.error(`${fnName}: id is null and category is null`);
+                throw 'Prisma error';
+            }
+            if (key == null) {
+                console.error(`${fnName}: id is null and key is null`);
+                throw 'Prisma error';
+            }
+            if (value === undefined) {
+                console.error(`${fnName}: id is null and value is undefined`);
+                throw 'Prisma error';
+            }
+            if (values === undefined) {
+                console.error(`${fnName}: id is null and values is undefined`);
+                throw 'Prisma error';
+            }
+            // Create
+            return await this.create(prisma, userProfileId, category, key, value, values);
+        }
+        else {
+            // Update
+            return await this.update(prisma, id, userProfileId, category, key, value, values);
+        }
+    }
+}

package/dist/src/models/users/user-profile-model.d.ts

@@ -0,0 +1,58 @@
+import { PrismaClient } from '@/prisma/client';
+export declare class UserProfileModel {
+    clName: string;
+    create(prisma: PrismaClient, userId: string | null, isAdmin: boolean, deletePending: Date | null): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    }>;
+    getById(prisma: PrismaClient, id: string): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    } | null | undefined>;
+    getByUserId(prisma: PrismaClient, userId: string): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    } | null | undefined>;
+    setOwnerType(prisma: PrismaClient, userProfile: any): Promise<{
+        status: boolean;
+        userProfile: any;
+    }>;
+    update(prisma: PrismaClient, id: string, userId: string | null | undefined, isAdmin: boolean | undefined, deletePending: Date | null | undefined): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    }>;
+    upsert(prisma: PrismaClient, id: string | undefined, userId: string | null | undefined, isAdmin: boolean | undefined, deletePending: Date | null | undefined): Promise<{
+        id: string;
+        userId: string | null;
+        created: Date;
+        updated: Date;
+        isAdmin: boolean;
+        ownerType: string | null;
+        roles: string[];
+        deletePending: Date | null;
+    }>;
+}

package/dist/src/models/users/user-profile-model.js

@@ -0,0 +1,146 @@
+import { UserTypes } from '../../types/user-types';
+export class UserProfileModel {
+    // Consts
+    clName = 'UserProfileModel';
+    // Code
+    async create(prisma, userId, isAdmin, deletePending) {
+        // Debug
+        const fnName = `${this.clName}.create()`;
+        // Create record
+        try {
+            return await prisma.userProfile.create({
+                data: {
+                    userId: userId,
+                    isAdmin: isAdmin,
+                    deletePending: deletePending
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async getById(prisma, id) {
+        // Debug
+        const fnName = `${this.clName}.getById()`;
+        // Get record
+        try {
+            return await prisma.userProfile.findUnique({
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+    }
+    async getByUserId(prisma, userId) {
+        // Debug
+        const fnName = `${this.clName}.getByUserId()`;
+        // Get record
+        try {
+            return await prisma.userProfile.findFirst({
+                where: {
+                    userId: userId
+                }
+            });
+        }
+        catch (error) {
+            if (!(error instanceof error.NotFound)) {
+                console.error(`${fnName}: error: ${error}`);
+                throw 'Prisma error';
+            }
+        }
+    }
+    async setOwnerType(prisma, userProfile) {
+        // Debug
+        const fnName = `${this.clName}.setOwnerType()`;
+        console.log(`${fnName}: starting with userProfile: ` +
+            JSON.stringify(userProfile));
+        // Return immediately if ownerType is set
+        if (userProfile.ownerType != null) {
+            return {
+                status: true,
+                userProfile: userProfile
+            };
+        }
+        // Set to human ownerType if the userId field is set
+        var ownerType = '';
+        if (userProfile.ownerType == null) {
+            ownerType = UserTypes.humanRoleOwnerType;
+        }
+        // Update record
+        userProfile = await prisma.userProfile.update({
+            data: {
+                ownerType: ownerType
+            },
+            where: {
+                id: userProfile.id
+            }
+        });
+        // Return
+        return {
+            status: true,
+            userProfile: userProfile
+        };
+    }
+    async update(prisma, id, userId, isAdmin, deletePending) {
+        // Debug
+        const fnName = `${this.clName}.update()`;
+        // Create record
+        try {
+            return await prisma.userProfile.update({
+                data: {
+                    userId: userId,
+                    isAdmin: isAdmin
+                },
+                where: {
+                    id: id
+                }
+            });
+        }
+        catch (error) {
+            console.error(`${fnName}: error: ${error}`);
+            throw 'Prisma error';
+        }
+    }
+    async upsert(prisma, id, userId, isAdmin, deletePending) {
+        // Debug
+        const fnName = `${this.clName}.upsert()`;
+        // If id isn't specified, but the unique keys are, try to get the record
+        if (id == null &&
+            userId != null) {
+            const userProfile = await this.getByUserId(prisma, userId);
+            if (userProfile != null) {
+                id = userProfile.id;
+            }
+        }
+        // Upsert
+        if (id == null) {
+            // Validate for create (mainly for type validation of the create call)
+            if (userId === undefined) {
+                console.error(`${fnName}: id is null and userId is undefined`);
+                throw 'Prisma error';
+            }
+            if (isAdmin == null) {
+                console.error(`${fnName}: id is null and isAdmin is null`);
+                throw 'Prisma error';
+            }
+            if (deletePending === undefined) {
+                console.error(`${fnName}: id is null and deletePending is undefined`);
+                throw 'Prisma error';
+            }
+            // Create
+            return await this.create(prisma, userId, isAdmin, deletePending);
+        }
+        else {
+            // Update
+            return await this.update(prisma, id, userId, isAdmin, deletePending);
+        }
+    }
+}

package/dist/src/services/access/access-service.d.ts

@@ -0,0 +1,12 @@
+import { PrismaClient } from '@/prisma/client';
+import { UsersService } from '../users/service';
+export declare class AccessService {
+    usersService: UsersService;
+    isAdminUser(prisma: PrismaClient, userProfileId: string): Promise<{
+        status: boolean;
+        message: string;
+    } | {
+        status: any;
+        message: null;
+    }>;
+}

package/dist/src/services/access/access-service.js

@@ -0,0 +1,27 @@
+import { UsersService } from '../users/service';
+export class AccessService {
+    usersService = new UsersService();
+    async isAdminUser(prisma, userProfileId) {
+        // Get UserProfile record
+        var userProfile = null;
+        try {
+            userProfile = await prisma.userProfile.findUnique({
+                where: {
+                    id: userProfileId
+                }
+            });
+        }
+        catch (NotFound) { }
+        if (userProfile == null) {
+            return {
+                status: false,
+                message: 'User not found'
+            };
+        }
+        // Return isAdmin value
+        return {
+            status: userProfile.isAdmin,
+            message: null
+        };
+    }
+}

package/dist/src/services/access/encrypt-service.d.ts

@@ -0,0 +1,13 @@
+import { CipherGCMTypes } from 'crypto';
+import { Buffer } from 'buffer';
+export declare class Encrypter {
+    clName: string;
+    header: string;
+    algorithm: CipherGCMTypes;
+    key: Buffer;
+    constructor(encryptionKey: string | undefined);
+    encrypt(clearText: string): string;
+    encryptAes256Gcm(clearText: string): string;
+    decrypt(encryptedText: string): string;
+    decryptAes256Gcm(encryptedText: string): string;
+}

package/dist/src/services/access/encrypt-service.js

@@ -0,0 +1,79 @@
+// Source: https://stackoverflow.com/a/66476430
+import crypto from 'crypto';
+import { Buffer } from 'buffer';
+export class Encrypter {
+    // Consts
+    clName = 'Encrypter';
+    header = '!enc%';
+    algorithm = 'aes-256-gcm';
+    // Vars
+    key;
+    // Code
+    constructor(encryptionKey) {
+        // Debug
+        const fnName = `${this.clName}.constructor()`;
+        // Validate
+        if (encryptionKey == null) {
+            throw new Error(`${fnName}: encryptionKey == null`);
+        }
+        // Set key
+        this.key = crypto.scryptSync(encryptionKey, 'salt', 32);
+    }
+    encrypt(clearText) {
+        return this.encryptAes256Gcm(clearText);
+    }
+    encryptAes256Gcm(clearText) {
+        // Get IV
+        const iv = crypto.randomBytes(16);
+        // Get cipher
+        const cipher = crypto.createCipheriv(this.algorithm, this.key, iv);
+        // Encrypt string
+        const encrypted = cipher.update(clearText, 'utf8', 'hex') + cipher.final('hex');
+        // Get the authTag
+        const authTag = cipher.getAuthTag().toString('hex');
+        // Return final string with metadata
+        return [
+            this.header,
+            this.algorithm,
+            encrypted,
+            iv.toString('hex'),
+            authTag
+        ].join('|');
+    }
+    decrypt(encryptedText) {
+        return this.decryptAes256Gcm(encryptedText);
+    }
+    decryptAes256Gcm(encryptedText) {
+        // Debug
+        const fnName = `${this.clName}.decryptAes256Gcm()`;
+        // console.log(`${fnName}: starting with encryptedText: ${encryptedText}`)
+        // Split string with metadata into separate vars
+        const [header, algorithm, encrypted, iv, authTag] = encryptedText.split('|');
+        // Validate
+        if (header !== this.header) {
+            throw new Error('Unexpected header, string is likely not encrypted');
+        }
+        if (algorithm !== this.algorithm) {
+            throw new Error('Unexpected/invalid encryption algorithm');
+        }
+        if (!iv) {
+            throw new Error('IV not found');
+        }
+        if (!authTag) {
+            throw new Error('authTag not found');
+        }
+        // Debug
+        // console.log(`${fnName}: decipher encrypted text..`)
+        // Decipher encrypted string
+        const decipher = crypto.createDecipheriv(this.algorithm, this.key, Buffer.from(iv, 'hex'));
+        decipher.setAuthTag(new Uint8Array(Buffer.from(authTag, 'hex')));
+        // Debug
+        // console.log(`${fnName}: decipher: ` + JSON.stringify(decipher))
+        // Get the final decrypted string
+        const decryptedText = decipher.update(encrypted, 'hex', 'utf8') + decipher.final('utf8');
+        // Debug
+        // console.log(`${fnName}: returning decrypted text..`)
+        // Return final decrypted string
+        return decryptedText;
+    }
+}

package/dist/src/services/api-usage/api-usage-base-service.d.ts

@@ -0,0 +1,15 @@
+import { PrismaClient } from '@/prisma/client';
+import { TechModel } from '../../models/tech/tech-model';
+import { RateLimitedApiModel } from '../../models/tech/rate-limited-api-model';
+import { RateLimitedApiEventModel } from '../../models/tech/rate-limited-api-event-model';
+export declare class ApiUsageBaseService {
+    clName: string;
+    rateLimitedApiEventModel: RateLimitedApiEventModel;
+    rateLimitedApiModel: RateLimitedApiModel;
+    techModel: TechModel;
+    isRateLimited(prisma: PrismaClient, variantName?: string | undefined, techId?: string | undefined): Promise<{
+        isRateLimited: boolean;
+        waitSeconds: number | null;
+        rateLimitedApiId: any;
+    } | null>;
+}

package/dist/src/services/api-usage/api-usage-base-service.js

@@ -0,0 +1,58 @@
+import { CustomError } from '../../types/errors';
+import { TechModel } from '../../models/tech/tech-model';
+import { RateLimitedApiModel } from '../../models/tech/rate-limited-api-model';
+import { RateLimitedApiEventModel } from '../../models/tech/rate-limited-api-event-model';
+export class ApiUsageBaseService {
+    // Consts
+    clName = 'ApiUsageBaseService';
+    // Models
+    rateLimitedApiEventModel = new RateLimitedApiEventModel();
+    rateLimitedApiModel = new RateLimitedApiModel();
+    techModel = new TechModel();
+    // Code
+    async isRateLimited(prisma, variantName = undefined, techId = undefined) {
+        // Debug
+        const fnName = `${this.clName}.isRateLimited()`;
+        // Validate
+        if (techId == null &&
+            variantName == null) {
+            throw new CustomError(`Either a techId or variantName must be specified`);
+        }
+        // Get the techId for the Apollo.io API
+        if (techId == null &&
+            variantName != null) {
+            const tech = await this.techModel.getByVariantName(prisma, variantName);
+            techId = tech.id;
+        }
+        if (techId == null) {
+            throw new CustomError(`techId not found`);
+        }
+        // Get API rate limiting data
+        const rateLimitedApi = await this.rateLimitedApiModel.getByTechId(prisma, techId);
+        // Return null if not a rate-limited tech
+        if (rateLimitedApi == null) {
+            return null;
+        }
+        // Determine if rate-limited
+        const eventCount = await this.rateLimitedApiEventModel.getUserSentForLastSpecifiedMinutes(prisma, 1); // For the last minute
+        // console.log(`${fnName}: is eventCount: ${eventCount} >= ` +
+        //   `rateLimitedApi.ratePerMinute: ${rateLimitedApi.ratePerMinute}`)
+        // Is the API currently rate limited?
+        var isRateLimited = false;
+        var waitSeconds = 0;
+        if (eventCount >= rateLimitedApi.ratePerMinute) {
+            isRateLimited = true;
+            // Get last record within the window
+            waitSeconds = await this.rateLimitedApiEventModel.getWaitSecondsSinceLastSpecifiedMinutes(prisma, 1); // For the last minute
+            if (waitSeconds == null ||
+                waitSeconds === 0) {
+                isRateLimited = false;
+            }
+        }
+        return {
+            isRateLimited: isRateLimited,
+            waitSeconds: waitSeconds,
+            rateLimitedApiId: rateLimitedApi.id
+        };
+    }
+}

package/dist/src/services/console/service.d.ts

@@ -0,0 +1,7 @@
+declare class ConsoleService {
+    private rl;
+    askQuestion(query: string): Promise<string>;
+    close(): void;
+}
+export declare const consoleService: ConsoleService;
+export {};

package/dist/src/services/console/service.js

@@ -0,0 +1,18 @@
+import chalk from 'chalk';
+import * as readline from 'node:readline/promises';
+import { stdin as input, stdout } from 'node:process';
+// Note: this class's console services can clash with other CLI libraries.
+class ConsoleService {
+    rl = readline.createInterface({ input });
+    async askQuestion(query) {
+        // Reuse the class-level interface
+        stdout.write(chalk.bold.cyan(query));
+        const answer = await this.rl.question('');
+        return answer;
+    }
+    close() {
+        this.rl.close();
+    }
+}
+// Export a single instance so that the interface is only created once
+export const consoleService = new ConsoleService();

package/dist/src/services/db/pg/pg-estimate-size-service.d.ts

@@ -0,0 +1,16 @@
+export type PgRecordEstimateInput = {
+    numberFields?: number[];
+    booleanFields?: boolean[];
+    stringFields?: string[];
+    jsonFields?: any[];
+    bigStringValues?: any[];
+    bigJsonValues?: any[];
+};
+export declare class PgEstimateSizeService {
+    clName: string;
+    estimateRecordSize(records: PgRecordEstimateInput[]): {
+        totalInline: number;
+        totalToast: number;
+        total: number;
+    };
+}