@pextran/db 0.0.3

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@pextran/db",
+  "version": "0.0.3",
+  "description": "pextran DB Utilities",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "files": [
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc --noEmit",
+    "prepublishOnly": "npm run build",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "patch": "pnpm pkg:addonly && pnpm run build && git add package.json ../../pnpm-lock.yaml && (git diff --staged --quiet || HUSKY=0 git commit -m \"chore(@pextran/db): sync dependencies\" --no-verify) && HUSKY=0 npm version patch && npm publish && git push --follow-tags",
+    "pkg:addonly": "pnpm remove @pextran/core && pnpm add @pextran/core@latest --ignore-scripts",
+    "pkg": "pnpm run pkg:addonly && git add . && git commit --no-verify -m \"pextran packages upgraded\"",
+    "pkg:push": "pnpm install && pnpm run pkg && git push"
+  },
+  "keywords": [
+    "typescript",
+    "db",
+    "utils"
+  ],
+  "author": "Hassen Mohammed",
+  "license": "MIT",
+  "peerDependencies": {
+    "next": "^14.0.0",
+    "next-auth": "5.0.0-beta.4",
+    "react": "^18.0.0",
+    "react-dom": "^18.0.0",
+    "zustand": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/jsonwebtoken": "^9.0.9",
+    "@types/node": "^20.6.0",
+    "@types/react": "^18.0.0",
+    "@types/react-dom": "^18.0.0",
+    "typescript": "^5.2.2"
+  },
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "dependencies": {
+    "@pextran/core": "^0.0.5",
+    "jsonwebtoken": "^9.0.2",
+    "pdf-lib": "^1.17.1"
+  }
+}

package/src/README.md

@@ -0,0 +1 @@
+# Arcisol DB Package

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './prisma';
+export * from './repository/approvalRepository';
+export * from './repository/employeesRepository';
+export * from './repository/mediaRepository';
+

package/src/prisma.ts

@@ -0,0 +1,40 @@
+export interface IPrisma {
+    employee: {
+        findFirst: (args: any) => Promise<any>
+    }
+    tenant: {
+        findFirst: (args: any) => Promise<any>
+    }
+    organization: {
+        findFirst: (args: any) => Promise<any>
+    }
+    role: {
+        findMany: (args: any) => Promise<any>
+    }
+    // Add media model methods to satisfy mediaRepository.ts usage
+    media: {
+        findFirst: (args: any) => Promise<any>
+        findUnique: (args: any) => Promise<any>
+        findMany: (args: any) => Promise<any>
+        create: (args: any) => Promise<any>
+        update: (args: any) => Promise<any>
+        delete: (args: any) => Promise<any>
+    }
+    // Add approval model methods to satisfy approvalRepository.ts usage
+    approval: {
+        findFirst: (args: any) => Promise<any>
+        findUnique: (args: any) => Promise<any>
+        findMany: (args: any) => Promise<any>
+        create: (args: any) => Promise<any>
+        update: (args: any) => Promise<any>
+        delete: (args: any) => Promise<any>
+        groupBy: (args: any) => Promise<any>
+    }
+    department: {
+        findFirst: (args: any) => Promise<any>
+    }
+    resourceApproval: {
+        findFirst: (args: any) => Promise<any>
+        delete: (args: any) => Promise<any>
+    }
+}

package/src/repository/approvalRepository.ts

@@ -0,0 +1,122 @@
+'use server'
+import { ApprovalDTO, logger, NexiResponse, ResourceApprovalDTO, ResponseFactory } from "@pextran/core";
+import { IPrisma } from "../prisma";
+
+export async function findApprovalById(prisma: IPrisma, tenant: string, id: string): Promise<NexiResponse<ApprovalDTO>> {
+    try {
+        const approval = await prisma.approval.findFirst({
+            where: { id, tenant },
+            orderBy: { version: 'desc' },
+            take: 1
+        });
+
+        if (!approval) {
+            return ResponseFactory.error('Approval not found');
+        }
+
+        return ResponseFactory.success(approvalDbToDTO(approval));
+    } catch (error) {
+        logger.error('Error finding approval by ID:', error);
+        return ResponseFactory.error('Error finding approval');
+    }
+}
+
+export async function findApprovalByResourceType(
+    prisma: IPrisma,
+    tenant: string,
+    resourceType: string
+): Promise<NexiResponse<ApprovalDTO>> {
+    try {
+        const approval = await prisma.approval.findFirst({
+            where: {
+                resourceType,
+                tenant
+            },
+            orderBy: { version: 'desc' },
+            take: 1
+        });
+
+        if (!approval) {
+            return ResponseFactory.error('Approval not found for resource type');
+        }
+
+        return ResponseFactory.success(approvalDbToDTO(approval));
+    } catch (error) {
+        logger.error('Error finding approval by resource type:', error);
+        return ResponseFactory.error('Error finding approval');
+    }
+}
+
+export async function getApprovalsForTenant(
+    prisma: IPrisma,
+    tenant: string
+): Promise<NexiResponse<ApprovalDTO[]>> {
+    try {
+        // First, get the latest version for each resourceType
+        const latestApprovalIds = await prisma.approval.groupBy({
+            by: ['resourceType'],
+            where: { tenant },
+            _max: {
+                version: true
+            }
+        });
+
+        // Then fetch the full approval records for the latest versions
+        const approvals = await Promise.all(
+            latestApprovalIds.map(async (group: any) => {
+                return await prisma.approval.findFirst({
+                    where: {
+                        tenant,
+                        resourceType: group.resourceType,
+                        version: group._max.version
+                    }
+                });
+            })
+        );
+
+        // Filter out any null results and convert to DTOs
+        const approvalDTOs = approvals
+            .filter((approval: any) => approval !== null)
+            .map(approvalDbToDTO);
+
+        return ResponseFactory.success(approvalDTOs);
+    } catch (error) {
+        logger.error('Error getting approvals for tenant:', error);
+        return ResponseFactory.error('Error retrieving approvals');
+    }
+}
+
+function approvalDbToDTO(approval: any): ApprovalDTO {
+    return {
+        id: approval.id,
+        version: approval.version,
+        resourceType: approval.resourceType,
+        moduleId: approval.moduleId,
+        approvalLevels: approval.approvalLevels,
+        tenant: approval.tenant,
+        createdAt: approval.createdAt?.toISOString(),
+        updatedAt: approval.updatedAt?.toISOString(),
+        audits: approval.audits || []
+    } as ApprovalDTO;
+}
+
+export async function getResourceApprovalsForResource(
+    prisma: IPrisma,
+    tenant: string,
+    resourceId: string,
+    resourceType: string
+): Promise<NexiResponse<ResourceApprovalDTO | null>> {
+    try {
+        const resourceApproval = await prisma.resourceApproval.findFirst({
+            where: {
+                tenant,
+                resourceId,
+                resourceType
+            }
+        }) as unknown as ResourceApprovalDTO;
+        return ResponseFactory.success(resourceApproval);
+    } catch (error) {
+        logger.error('Error getting resource approvals for resource:', error);
+        return ResponseFactory.error('Failed to get resource approvals for resource');
+    }
+}

package/src/repository/employeesRepository.ts

@@ -0,0 +1,161 @@
+import { AuthClaims, DepartmentClaims, MODULES, RoleDTO } from "@pextran/core";
+import { IPrisma } from "../prisma";
+
+export async function getEmployeeClaims(prisma: IPrisma, tenantId: string, email: string, role: string, getOrgLogo: (orgId: string) => Promise<string | null>): Promise<{ claims: AuthClaims } | null> {
+    if (!email || !tenantId) return null
+
+    const employee = await prisma.employee.findFirst({
+        where: {
+            orgId: tenantId,
+            email: {
+                equals: email,
+                mode: 'insensitive'
+            },
+            active: true,
+            deleted: false
+        },
+        select: {
+            id: true,
+            email: true,
+            userId: true,
+            emailVerified: true,
+            firstName: true,
+            middleName: true,
+            lastName: true,
+            phone: true,
+            roles: true,
+            preferences: true,
+            orgId: true,
+            employment: true,
+            compensations: true,
+            financialDetails: true,
+            metadata: true,
+        }
+    }) as any
+
+    if (!employee) {
+        console.warn(`No employee found ! request tenantId:${tenantId}, email:${email}`)
+        return null
+    }
+    let department: DepartmentClaims | null = null;
+    if (employee.employment?.departmentId) {
+        const departmentData = await prisma.department.findFirst({
+            where: { id: employee.employment?.departmentId, tenant: tenantId },
+            select: {
+                id: true,
+                name: true,
+                managerId: true
+            }
+        }) as any
+        department = {
+            id: departmentData?.id,
+            name: departmentData?.name,
+            isHead: departmentData?.managerId === employee.id
+        }
+    }
+
+    employee.profilePicture = await getOrgLogo(tenantId);
+
+    const tenantData = await prisma.tenant.findFirst({
+        where: { id: employee?.orgId },
+        select: {
+            id: true,
+            organization: {
+                select: {
+                    name: true
+                }
+            },
+            modules: true,
+            preferences: true,
+            subscription: true
+        }
+    })
+
+    const orgData = await prisma.organization.findFirst({
+        where: { id: employee?.orgId },
+        select: {
+            email: true,
+            website: true,
+            phone: true
+        }
+    }) as any
+
+    const roles = await prisma.role.findMany({
+        where: { orgId: tenantId, key: { in: employee.roles } },
+        select: {
+            key: true,
+            permissions: true,
+            modules: true
+        }
+    })
+
+    const otherRoles: { role: string, modules: MODULES[] }[] = [];
+    tenantData.modules.forEach((m: MODULES) => {
+        const rolesWithModule = roles.filter((r: RoleDTO) => r.modules.includes(m) || r.modules.includes(MODULES.ALL)) as RoleDTO[]
+        if (rolesWithModule.length > 0) {
+            rolesWithModule.forEach((role: RoleDTO) => {
+                if (otherRoles.find((r: { role: string, modules: MODULES[] }) => r.role === role.key)) {
+                    //update the modules
+                    const modules = otherRoles.find((r: { role: string, modules: MODULES[] }) => r.role === role.key)!.modules
+                    const mergedModules = modules.concat(role.modules)
+                    const uniqueModules = mergedModules.filter((m, idx) => mergedModules.indexOf(m) === idx)
+                    otherRoles.find((r: { role: string, modules: MODULES[] }) => r.role === role.key)!.modules = uniqueModules
+                } else {
+                    otherRoles.push({ role: role.key, modules: role.modules })
+                }
+            })
+        }
+    })
+
+    if (role && roles.find((r: RoleDTO) => r.key === role)) {
+        employee.preferences = { ...(employee.preferences as any), activeRole: role }
+    } else if (!(employee.preferences as any)?.activeRole && roles.length > 0) {
+        employee.preferences = { ...(employee.preferences as any), activeRole: roles[0].key }
+    }
+
+    const claims = {
+        claims: {
+            employee: {
+                id: employee.id,
+                userId: employee.userId,
+                email: employee.email,
+                emailVerified: employee.emailVerified,
+                firstName: employee.firstName,
+                middleName: employee.middleName || '',
+                lastName: employee.lastName,
+                phone: employee.phone || '',
+                name: employee.firstName + ' ' + employee.lastName,
+                roles: roles.map((r: RoleDTO) => r.key === employee.preferences?.activeRole ? ({
+                    role: r.key,
+                    permissions: r.permissions,
+                    modules: r.modules
+                }) : ({
+                    role: r.key,
+                    modules: r.modules
+                })),
+                preferences: employee.preferences,
+                profilePicture: employee.profilePicture,
+                department,
+                otherRoles: otherRoles
+            },
+            tenant: {
+                id: tenantData?.id,
+                name: tenantData?.organization?.name,
+                modules: tenantData?.modules,
+                preferences: tenantData?.preferences,
+                subscription: tenantData?.subscription
+            },
+            org: {
+                id: tenantData?.id,
+                name: tenantData?.organization?.name,
+                email: orgData?.email,
+                website: orgData?.website,
+                logo: employee.profilePicture,
+                phone: orgData?.phone
+            },
+            user: {} as any
+        } as AuthClaims
+    }
+
+    return claims as any
+}   

package/src/repository/mediaRepository.ts

@@ -0,0 +1,228 @@
+'use server'
+import { CATEGORY_UTILIZED_MEDIA_TYPES, logger, MediaDTO, MediaType, MULTI_FILE_MEDIA_TYPES, NexiResponse, ResourceType, ResponseFactory } from "@pextran/core";
+import { IPrisma } from "../prisma";
+
+export async function upsertMedia(prisma: IPrisma, tenant: string, media: MediaDTO, resourceId: string, resourceType?: ResourceType): Promise<MediaDTO> {
+    const upserted = await upsertMedias(prisma, tenant, [media], resourceId, resourceType) || [];
+    return upserted[0];
+}
+
+export async function upsertMedias(prisma: IPrisma, tenant: string, medias: MediaDTO[], resourceId: string, resourceType?: ResourceType): Promise<MediaDTO[]> {
+
+    //if medias is empty, return empty array
+    if (!medias || medias.length === 0) {
+        return [];
+    }
+
+    const updatedMedias: MediaDTO[] = [];
+    // console.log('upserting medias:', medias, tenant, resourceId);
+    for (const media of (medias || []).filter(m => !!m && (m.url || m.signedUrl)) || []) {
+        // console.log('upserting media:', media);
+        const { modified, ...rest } = media;
+        let updatedMedia = {
+            ...rest,
+            tenant,
+            resourceId,
+            resourceType,
+            name: media.name || ''
+        } as MediaDTO
+        // console.log('updatedMedia:', updatedMedia);
+        let id = media.id
+        let existingButDeleted = false;
+        //ttachments have order is as unique key allowing multiple media of same type
+        const type = media.type as MediaType;
+        if (!id && !MULTI_FILE_MEDIA_TYPES.includes(type) && !(media.category && CATEGORY_UTILIZED_MEDIA_TYPES.includes(type))) {
+            const existingMD = await prisma.media.findFirst({
+                where: {
+                    tenant, resourceId, type, deleted: false
+                }
+            })
+            if (existingMD?.id) {
+                id = existingMD.id;
+                existingButDeleted = existingMD.deleted;
+            }
+        }
+
+        let order = media.order || 1;
+
+        if (!id && MULTI_FILE_MEDIA_TYPES.includes(type)) {
+            //get the last attachment and increment the order
+            const lastAttachment = await prisma.media.findFirst({
+                where: {
+                    tenant, resourceId, type
+                },
+                orderBy: {
+                    order: 'desc'
+                }
+            }).then(m => m?.order);
+
+            order = lastAttachment ? lastAttachment + 1 : 1;
+        }
+        updatedMedia = {
+            ...updatedMedia,
+            order
+        } as MediaDTO;
+
+        let existingMedia: MediaDTO | null = null;
+        if (id) {
+            existingMedia = await prisma.media.findUnique({
+                where: { id, tenant }
+            }) as unknown as MediaDTO;
+        }
+
+        if (!id && !MULTI_FILE_MEDIA_TYPES.includes(type) && CATEGORY_UTILIZED_MEDIA_TYPES.includes(type)) {
+            //check if media with same name and type already exists
+            const existingMedia = await prisma.media.findFirst({
+                where: { tenant, resourceId, type, category: updatedMedia.category ?? null, name: media.name }
+            })
+            if (existingMedia?.id) {
+                id = existingMedia.id;
+            }
+        }
+        if (!id && !MULTI_FILE_MEDIA_TYPES.includes(type) && !CATEGORY_UTILIZED_MEDIA_TYPES.includes(type)) {
+            //check if media with same name and type already exists
+            const existingMedia = await prisma.media.findFirst({
+                where: { tenant, resourceId, type, name: media.name }
+            })
+            if (existingMedia?.id) {
+                id = existingMedia.id;
+            }
+        }
+
+        if (!id || !existingMedia) {
+            const { id, ...rest } = updatedMedia;
+            // console.log('creating media:', rest);
+            const md = await prisma.media.create({
+                data: rest
+            }) as unknown as MediaDTO;
+            updatedMedias.push(md);
+        } else if (modified || existingButDeleted) {
+            // console.log('updating media:', updatedMedia);
+            const md = await prisma.media.update({
+                where: { id, tenant },
+                data: updatedMedia
+            }) as unknown as MediaDTO;
+            updatedMedias.push(md);
+        } else {
+            updatedMedias.push(updatedMedia);
+        }
+    }
+    return updatedMedias;
+}
+
+export const getOrgLogo = async (prisma: IPrisma, orgId: string): Promise<string | null> => {
+    const logo = await prisma.media.findFirst({
+        where: { tenant: orgId, type: MediaType.Logo, resourceId: orgId, deleted: false }
+    }) as unknown as MediaDTO;
+    return logo?.url || logo?.signedUrl || null;
+}
+
+export const moveAndDeleteMedia = async (prisma: IPrisma, tenant: string, id: string, resourceId: string): Promise<MediaDTO | null> => {
+    const newId = resourceId + '_' + new Date().getTime().toString();
+    const movedMedia = await prisma.media.update({
+        where: { tenant, id },
+        data: {
+            deleted: true,
+            resourceId: newId
+        }
+    }) as unknown as MediaDTO;
+    return movedMedia;
+}
+
+export const findMediasForResourceId = async (prisma: IPrisma, tenant: string, resourceId: string): Promise<NexiResponse<MediaDTO[]>> => {
+    console.log('findMediasForResourceId:', tenant, resourceId);
+    const medias = await prisma.media.findMany({
+        where: { tenant, resourceId, deleted: false }
+    }) as unknown as MediaDTO[];
+    // console.log('medias:', medias);
+    return ResponseFactory.success(medias as MediaDTO[]);
+}
+
+export const findMediasForTypeAndResourceId = async (prisma: IPrisma, tenant: string, type: MediaType, resourceId: string, includeDeleted: boolean = false): Promise<MediaDTO[]> => {
+    const medias = includeDeleted ? await prisma.media.findMany({
+        where: { tenant, type, resourceId }
+    }) as unknown as MediaDTO[] : await prisma.media.findMany({
+        where: { tenant, type, resourceId, deleted: false }
+    }) as unknown as MediaDTO[];
+    return medias;
+}
+
+export const findMediasForTypeAndResourceIdAndCategory = async (prisma: IPrisma, tenant: string, type: MediaType, resourceId: string, category: string, includeDeleted: boolean = false): Promise<MediaDTO[]> => {
+    const medias = includeDeleted ? await prisma.media.findMany({
+        where: { tenant, type, resourceId, category }
+    }) as unknown as MediaDTO[] : await prisma.media.findMany({
+        where: { tenant, type, resourceId, category, deleted: false }
+    }) as unknown as MediaDTO[];
+    return medias;
+}
+
+export const findMediaById = async (prisma: IPrisma, id: string): Promise<MediaDTO | null> => {
+
+    return await prisma.media.findFirst({
+        where: { id, deleted: false },
+    }) as unknown as MediaDTO;
+}
+
+export const getMediasForQuery = async (prisma: IPrisma, query: Record<string, string>, tenant: string): Promise<MediaDTO[]> => {
+    const medias = await prisma.media.findMany({
+        where: {
+            tenant,
+            AND: Object.entries(query).map(([key, value]) => ({
+                [key]: { contains: value, mode: 'insensitive' }
+            })),
+            deleted: false
+        }
+    }) as unknown as MediaDTO[];
+    return medias as MediaDTO[];
+}
+
+export const deleteMedia = async (prisma: IPrisma, tenant: string, id: string): Promise<MediaDTO | null> => {
+    try {
+        return await prisma.media.update({
+            where: { tenant, id },
+            data: {
+                deleted: true
+            }
+        }) as unknown as MediaDTO;
+
+        // this will flag the media as deleted and associated images will be deleted from the file storage by cron job
+    } catch (error) {
+        logger.error('Error deleting media', { error, tenant, id });
+        return null;
+    }
+}
+
+export const getDeletedMedias = async (prisma: IPrisma): Promise<MediaDTO[]> => {
+    try {
+        return await prisma.media.findMany({
+            where: { deleted: true },
+            select: {
+                id: true,
+                tenant: true,
+                type: true,
+                resourceId: true,
+                resourceType: true,
+                name: true,
+                url: true,
+                signedUrl: true,
+                deleted: true,
+                order: true,
+                storagePath: true
+            }
+        }) as unknown as MediaDTO[];
+    } catch (error) {
+        logger.error('Error getting deleted medias', { error });
+        return [];
+    }
+}
+
+export const hardDeleteMedia = async (prisma: IPrisma, tenant: string, id: string): Promise<MediaDTO | null> => {
+    try {
+        return await prisma.media.delete({
+            where: { tenant, id }
+        }) as unknown as MediaDTO;
+    } catch (error) {
+        logger.error('Error hard deleting media', { error, tenant, id });
+        return null;
+    }
+}