Scheduling infrastructure for absolutely everyone.
fix: add InsightsBookingRepository (#22003)
Eunjae Lee3fd9ef366fae
diff --git a/packages/lib/server/repository/__tests__/insightsBooking.integration-test.ts b/packages/lib/server/repository/__tests__/insightsBooking.integration-test.tsnew file mode 100644index 00000000000..3a015ec9a50--- /dev/null+++ b/packages/lib/server/repository/__tests__/insightsBooking.integration-test.ts@@ -0,0 +1,611 @@+import type { Team, User, Membership } from "@prisma/client";+import { describe, expect, it } from "vitest";++import prisma from "@calcom/prisma";+import { BookingStatus, MembershipRole } from "@calcom/prisma/enums";++import { InsightsBookingRepository } from "../insightsBooking";++// Helper function to create unique test data+async function createTestData({+ teamRole = MembershipRole.MEMBER,+ orgRole = MembershipRole.MEMBER,+ moreTeamsAndUsers = [],+}: {+ teamRole?: MembershipRole;+ orgRole?: MembershipRole;+ moreTeamsAndUsers?: MembershipRole[][]; // Array of teams, each team has array of user roles+} = {}) {+ const timestamp = Date.now();+ const randomSuffix = Math.random().toString(36).substring(7);++ // Create test user+ const user = await prisma.user.create({+ data: {+ email: `test-user-${timestamp}-${randomSuffix}@example.com`,+ username: `testuser-${timestamp}-${randomSuffix}`,+ name: "Test User",+ },+ });++ // Create test organization+ const org = await prisma.team.create({+ data: {+ name: `Test Org ${timestamp}-${randomSuffix}`,+ slug: `test-org-${timestamp}-${randomSuffix}`,+ isOrganization: true,+ },+ });++ // Create test team under the organization+ const team = await prisma.team.create({+ data: {+ name: `Test Team ${timestamp}-${randomSuffix}`,+ slug: `test-team-${timestamp}-${randomSuffix}`,+ isOrganization: false,+ parentId: org.id,+ },+ });++ // Create test event type+ const eventType = await prisma.eventType.create({+ data: {+ title: "Test Event Type",+ slug: "test-event-type",+ length: 60,+ userId: user.id,+ teamId: team.id,+ },+ });++ // Create test booking+ const booking = await prisma.booking.create({+ data: {+ uid: `test-booking-${timestamp}-${randomSuffix}`,+ title: "Test Booking",+ startTime: new Date(),+ endTime: new Date(Date.now() + 60 * 60 * 1000),+ userId: user.id,+ eventTypeId: eventType.id,+ status: BookingStatus.PENDING,+ },+ });++ const membership = await prisma.membership.create({+ data: {+ userId: user.id,+ teamId: team.id,+ role: teamRole,+ accepted: true,+ },+ });++ const orgMembership = await prisma.membership.create({+ data: {+ userId: user.id,+ teamId: org.id,+ role: orgRole,+ accepted: true,+ },+ });++ // Create additional teams and users based on moreTeamsAndUsers+ const additionalTeams: Team[] = [];+ const additionalUsers: User[] = [];+ const additionalMemberships: Membership[] = [];++ for (let teamIndex = 0; teamIndex < moreTeamsAndUsers.length; teamIndex++) {+ const teamUserRoles = moreTeamsAndUsers[teamIndex];++ // Create the team+ const additionalTeam = await prisma.team.create({+ data: {+ name: `Test Team ${teamIndex + 2} ${timestamp}-${randomSuffix}`,+ slug: `test-team-${teamIndex + 2}-${timestamp}-${randomSuffix}`,+ isOrganization: false,+ parentId: org.id,+ },+ });+ additionalTeams.push(additionalTeam);++ // Create users for this team+ for (let userIndex = 0; userIndex < teamUserRoles.length; userIndex++) {+ const userRole = teamUserRoles[userIndex];++ // Create the user+ const additionalUser = await prisma.user.create({+ data: {+ email: `test-user-team${teamIndex + 2}-${userIndex + 1}-${timestamp}-${randomSuffix}@example.com`,+ username: `testuser-team${teamIndex + 2}-${userIndex + 1}-${timestamp}-${randomSuffix}`,+ name: `Test User Team${teamIndex + 2}-${userIndex + 1}`,+ },+ });+ additionalUsers.push(additionalUser);++ // Create the membership+ const additionalMembership = await prisma.membership.create({+ data: {+ userId: additionalUser.id,+ teamId: additionalTeam.id,+ role: userRole,+ accepted: true,+ },+ });+ additionalMemberships.push(additionalMembership);+ }+ }++ // Return test data and cleanup function+ return {+ user,+ org,+ orgMembership,+ team,+ eventType,+ booking,+ membership,+ additionalTeams,+ additionalUsers,+ additionalMemberships,+ cleanup: async () => {+ // Clean up additional memberships+ for (const membership of additionalMemberships) {+ await prisma.membership.delete({+ where: { id: membership.id },+ });+ }++ // Clean up additional users+ for (const user of additionalUsers) {+ await prisma.user.delete({+ where: { id: user.id },+ });+ }++ // Clean up additional teams+ for (const team of additionalTeams) {+ await prisma.team.delete({+ where: { id: team.id },+ });+ }++ // Clean up main test data+ await prisma.booking.deleteMany({+ where: { id: booking.id },+ });+ await prisma.eventType.deleteMany({+ where: { id: eventType.id },+ });+ await prisma.membership.deleteMany({+ where: { id: membership.id },+ });+ await prisma.membership.delete({+ where: { id: orgMembership.id },+ });+ await prisma.team.deleteMany({+ where: { id: team.id },+ });+ await prisma.team.deleteMany({+ where: { id: org.id },+ });+ await prisma.user.deleteMany({+ where: { id: user.id },+ });+ },+ };+}++describe("InsightsBookingRepository Integration Tests", () => {+ describe("Authorization Conditions", () => {+ it("should return NOTHING for invalid options", async () => {+ const repository = new InsightsBookingRepository({+ prisma,+ options: null as any,+ });++ const conditions = await repository.getAuthorizationConditions();+ expect(conditions).toEqual({ id: -1 });+ });++ it("should return NOTHING for non-owner/admin user", async () => {+ const testData = await createTestData();++ // Create a regular user who is not an owner/admin+ const regularUser = await prisma.user.create({+ data: {+ email: `regular-user-${Date.now()}-${Math.random().toString(36).substring(7)}@example.com`,+ username: `regularuser-${Date.now()}-${Math.random().toString(36).substring(7)}`,+ name: "Regular User",+ },+ });++ // Add the user as a regular member (not owner/admin) to the organization+ const membership = await prisma.membership.create({+ data: {+ userId: regularUser.id,+ teamId: testData.org.id,+ role: MembershipRole.MEMBER,+ accepted: true,+ },+ });++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "org",+ userId: regularUser.id,+ orgId: testData.org.id,+ },+ });++ const conditions = await repository.getAuthorizationConditions();+ expect(conditions).toEqual({ id: -1 });++ // Clean up+ await prisma.membership.delete({+ where: { id: membership.id },+ });+ await prisma.user.delete({+ where: { id: regularUser.id },+ });+ await testData.cleanup();+ });++ it("should build user scope conditions", async () => {+ const testData = await createTestData({+ teamRole: MembershipRole.OWNER,+ orgRole: MembershipRole.OWNER,+ });++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "user",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ });++ const conditions = await repository.getAuthorizationConditions();+ expect(conditions).toEqual({+ AND: [+ {+ userId: testData.user.id,+ teamId: null,+ },+ ],+ });++ await testData.cleanup();+ });++ it("should build team scope conditions", async () => {+ const testData = await createTestData({+ teamRole: MembershipRole.OWNER,+ orgRole: MembershipRole.OWNER,+ });++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "team",+ userId: testData.user.id,+ orgId: testData.org.id,+ teamId: testData.team.id,+ },+ });++ const conditions = await repository.getAuthorizationConditions();+ expect(conditions).toEqual({+ AND: [+ {+ OR: [+ {+ teamId: testData.team.id,+ isTeamBooking: true,+ },+ {+ userId: {+ in: [testData.user.id],+ },+ isTeamBooking: false,+ },+ ],+ },+ ],+ });++ // Clean up+ await testData.cleanup();+ });++ it("should build org scope conditions", async () => {+ const testData = await createTestData({+ teamRole: MembershipRole.OWNER,+ orgRole: MembershipRole.OWNER,+ moreTeamsAndUsers: [+ [MembershipRole.MEMBER], // Team 2: 1 user with MEMBER role+ [MembershipRole.MEMBER], // Team 3: 1 user with MEMBER role+ ],+ });++ // Get references to additional data+ const user2 = testData.additionalUsers[0]; // First user from first team+ const user3 = testData.additionalUsers[1]; // First user from second team+ const team2 = testData.additionalTeams[0]; // First additional team+ const team3 = testData.additionalTeams[1]; // Second additional team++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "org",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ });++ const conditions = await repository.getAuthorizationConditions();++ expect(conditions).toEqual({+ AND: [+ {+ OR: [+ {+ teamId: {+ in: [testData.org.id, testData.team.id, team2.id, team3.id],+ },+ isTeamBooking: true,+ },+ {+ userId: {+ in: [testData.user.id, user2.id, user3.id],+ },+ isTeamBooking: false,+ },+ ],+ },+ ],+ });++ await testData.cleanup();+ });+ });++ describe("Filter Conditions", () => {+ it("should return null when no filters are provided", async () => {+ const testData = await createTestData();++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "user",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ });++ const conditions = await repository.getFilterConditions();+ expect(conditions).toBeNull();++ await testData.cleanup();+ });++ it("should build eventTypeId filter conditions", async () => {+ const testData = await createTestData();++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "user",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ filters: {+ eventTypeId: testData.eventType.id,+ },+ });++ const conditions = await repository.getFilterConditions();+ expect(conditions).toEqual({+ AND: [+ {+ OR: [{ eventTypeId: testData.eventType.id }, { eventParentId: testData.eventType.id }],+ },+ ],+ });++ await testData.cleanup();+ });++ it("should build memberUserId filter conditions", async () => {+ const testData = await createTestData();++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "user",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ filters: {+ memberUserId: testData.user.id,+ },+ });++ const conditions = await repository.getFilterConditions();+ expect(conditions).toEqual({+ AND: [+ {+ userId: testData.user.id,+ },+ ],+ });++ await testData.cleanup();+ });++ it("should combine multiple filter conditions", async () => {+ const testData = await createTestData();++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "user",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ filters: {+ eventTypeId: testData.eventType.id,+ memberUserId: testData.user.id,+ },+ });++ const conditions = await repository.getFilterConditions();+ expect(conditions).toEqual({+ AND: [+ {+ OR: [{ eventTypeId: testData.eventType.id }, { eventParentId: testData.eventType.id }],+ },+ {+ userId: testData.user.id,+ },+ ],+ });++ await testData.cleanup();+ });+ });++ describe("Caching", () => {+ it("should cache authorization conditions", async () => {+ const testData = await createTestData({+ teamRole: MembershipRole.OWNER,+ orgRole: MembershipRole.OWNER,+ });++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "user",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ });++ // First call should build conditions+ const conditions1 = await repository.getAuthorizationConditions();+ expect(conditions1).toEqual({+ AND: [+ {+ userId: testData.user.id,+ teamId: null,+ },+ ],+ });++ // Second call should use cached conditions+ const conditions2 = await repository.getAuthorizationConditions();+ expect(conditions2).toEqual(conditions1);++ // Clean up+ await testData.cleanup();+ });++ it("should cache filter conditions", async () => {+ const testData = await createTestData();++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "user",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ filters: {+ eventTypeId: testData.eventType.id,+ },+ });++ // First call should build conditions+ const conditions1 = await repository.getFilterConditions();+ expect(conditions1).toEqual({+ AND: [+ {+ OR: [{ eventTypeId: testData.eventType.id }, { eventParentId: testData.eventType.id }],+ },+ ],+ });++ // Second call should use cached conditions+ const conditions2 = await repository.getFilterConditions();+ expect(conditions2).toEqual(conditions1);++ await testData.cleanup();+ });+ });++ describe("findMany", () => {+ it("should combine authorization and filter conditions", async () => {+ const testData = await createTestData({+ teamRole: MembershipRole.OWNER,+ orgRole: MembershipRole.OWNER,+ });++ // Create a user-scoped event type (not team-scoped)+ const userEventType = await prisma.eventType.create({+ data: {+ title: "User Event Type",+ slug: "user-event-type",+ length: 60,+ userId: testData.user.id,+ teamId: null, // User-scoped, not team-scoped+ },+ });++ // Create a booking for the user-scoped event type+ const userBooking = await prisma.booking.create({+ data: {+ uid: `user-booking-${Date.now()}-${Math.random().toString(36).substring(7)}`,+ title: "User Booking",+ startTime: new Date(),+ endTime: new Date(Date.now() + 60 * 60 * 1000),+ userId: testData.user.id,+ eventTypeId: userEventType.id,+ status: BookingStatus.PENDING,+ },+ });++ const repository = new InsightsBookingRepository({+ prisma,+ options: {+ scope: "user",+ userId: testData.user.id,+ orgId: testData.org.id,+ },+ filters: {+ eventTypeId: userEventType.id,+ },+ });++ const results = await repository.findMany({+ select: {+ id: true,+ title: true,+ },+ });++ // Should return the user booking since it matches both conditions+ expect(results).toHaveLength(1);+ expect(results[0]?.id).toBe(userBooking.id);++ // Clean up+ await prisma.booking.delete({+ where: { id: userBooking.id },+ });+ await prisma.eventType.delete({+ where: { id: userEventType.id },+ });+ await testData.cleanup();+ });+ });+});diff --git a/packages/lib/server/repository/insightsBooking.ts b/packages/lib/server/repository/insightsBooking.tsnew file mode 100644index 00000000000..6923d2098ea--- /dev/null+++ b/packages/lib/server/repository/insightsBooking.ts@@ -0,0 +1,256 @@+import type { Prisma } from "@prisma/client";+import { z } from "zod";++import type { readonlyPrisma } from "@calcom/prisma";++export const insightsBookingRepositoryOptionsSchema = z.discriminatedUnion("scope", [+ z.object({+ scope: z.literal("user"),+ userId: z.number(),+ orgId: z.number(),+ }),+ z.object({+ scope: z.literal("org"),+ userId: z.number(),+ orgId: z.number(),+ }),+ z.object({+ scope: z.literal("team"),+ userId: z.number(),+ orgId: z.number(),+ teamId: z.number(),+ }),+]);++export type InsightsBookingRepositoryOptions = z.infer<typeof insightsBookingRepositoryOptionsSchema>;++export type InsightsBookingRepositoryFilterOptions = {+ eventTypeId?: number;+ memberUserId?: number;+};++const NOTHING = {+ id: -1,+} as const;++export class InsightsBookingRepository {+ private prisma: typeof readonlyPrisma;+ private options: InsightsBookingRepositoryOptions | null;+ private filters?: InsightsBookingRepositoryFilterOptions;+ private cachedAuthConditions?: Prisma.BookingTimeStatusDenormalizedWhereInput;+ private cachedFilterConditions?: Prisma.BookingTimeStatusDenormalizedWhereInput | null;++ constructor({+ prisma,+ options,+ filters,+ }: {+ prisma: typeof readonlyPrisma;+ options: InsightsBookingRepositoryOptions;+ filters?: InsightsBookingRepositoryFilterOptions;+ }) {+ this.prisma = prisma;++ const validation = insightsBookingRepositoryOptionsSchema.safeParse(options);+ this.options = validation.success ? validation.data : null;++ this.filters = filters;+ }++ async findMany(findManyArgs: Prisma.BookingTimeStatusDenormalizedFindManyArgs) {+ const authConditions = await this.getAuthorizationConditions();+ const filterConditions = await this.getFilterConditions();++ return this.prisma.bookingTimeStatusDenormalized.findMany({+ ...findManyArgs,+ where: {+ ...findManyArgs.where,+ AND: [authConditions, filterConditions].filter(+ (c): c is Prisma.BookingTimeStatusDenormalizedWhereInput => c !== null+ ),+ },+ });+ }++ async getAuthorizationConditions(): Promise<Prisma.BookingTimeStatusDenormalizedWhereInput> {+ if (this.cachedAuthConditions === undefined) {+ this.cachedAuthConditions = await this.buildAuthorizationConditions();+ }+ return this.cachedAuthConditions;+ }++ async getFilterConditions(): Promise<Prisma.BookingTimeStatusDenormalizedWhereInput | null> {+ if (this.cachedFilterConditions === undefined) {+ this.cachedFilterConditions = await this.buildFilterConditions();+ }+ return this.cachedFilterConditions;+ }++ async buildFilterConditions(): Promise<Prisma.BookingTimeStatusDenormalizedWhereInput | null> {+ const conditions: Prisma.BookingTimeStatusDenormalizedWhereInput[] = [];++ if (!this.filters) {+ return null;+ }++ if (this.filters.eventTypeId) {+ conditions.push({+ OR: [{ eventTypeId: this.filters.eventTypeId }, { eventParentId: this.filters.eventTypeId }],+ });+ }++ if (this.filters.memberUserId) {+ conditions.push({+ userId: this.filters.memberUserId,+ });+ }++ return conditions.length > 0 ? { AND: conditions } : null;+ }++ async buildAuthorizationConditions(): Promise<Prisma.BookingTimeStatusDenormalizedWhereInput> {+ if (!this.options) {+ return NOTHING;+ }+ const isOwnerOrAdmin = await this.isOrgOwnerOrAdmin(this.options.userId, this.options.orgId);+ if (!isOwnerOrAdmin) {+ return NOTHING;+ }++ const conditions: Prisma.BookingTimeStatusDenormalizedWhereInput[] = [];++ if (this.options.scope === "user") {+ conditions.push({+ userId: this.options.userId,+ teamId: null,+ });+ } else if (this.options.scope === "org") {+ conditions.push(await this.buildOrgAuthorizationCondition(this.options));+ } else if (this.options.scope === "team") {+ conditions.push(await this.buildTeamAuthorizationCondition(this.options));+ } else {+ return NOTHING;+ }++ return {+ AND: conditions,+ };+ }++ private async buildOrgAuthorizationCondition(+ options: Extract<InsightsBookingRepositoryOptions, { scope: "org" }>+ ): Promise<Prisma.BookingTimeStatusDenormalizedWhereInput> {+ // Get all teams from the organization+ const teamsFromOrg = await this.prisma.team.findMany({+ where: {+ parentId: options.orgId,+ },+ select: {+ id: true,+ },+ });+ const teamIds = [options.orgId, ...teamsFromOrg.map((t) => t.id)];++ // Get all users from the organization+ const userIdsFromOrg =+ teamsFromOrg.length > 0+ ? (+ await this.prisma.membership.findMany({+ where: {+ team: {+ id: {+ in: teamIds,+ },+ },+ accepted: true,+ },+ select: {+ userId: true,+ },+ })+ ).map((m) => m.userId)+ : [];++ return {+ OR: [+ {+ teamId: {+ in: teamIds,+ },+ isTeamBooking: true,+ },+ ...(userIdsFromOrg.length > 0+ ? [+ {+ userId: {+ in: Array.from(new Set(userIdsFromOrg)),+ },+ isTeamBooking: false,+ },+ ]+ : []),+ ],+ };+ }++ private async buildTeamAuthorizationCondition(+ options: Extract<InsightsBookingRepositoryOptions, { scope: "team" }>+ ): Promise<Prisma.BookingTimeStatusDenormalizedWhereInput> {+ const childTeamOfOrg = await this.prisma.team.findFirst({+ where: {+ id: options.teamId,+ parentId: options.orgId,+ },+ });+ if (!childTeamOfOrg) {+ return NOTHING;+ }++ const usersFromTeam = await this.prisma.membership.findMany({+ where: {+ teamId: options.teamId,+ accepted: true,+ },+ select: {+ userId: true,+ },+ });+ const userIdsFromTeam = usersFromTeam.map((u) => u.userId);++ return {+ OR: [+ {+ teamId: options.teamId,+ isTeamBooking: true,+ },+ {+ userId: {+ in: userIdsFromTeam,+ },+ isTeamBooking: false,+ },+ ],+ };+ }++ private async isOrgOwnerOrAdmin(userId: number, orgId: number): Promise<boolean> {+ // Check if the user is an owner or admin of the organization+ const membershipOrg = await this.prisma.membership.findUnique({+ where: {+ userId_teamId: {+ userId,+ teamId: orgId,+ },+ accepted: true,+ role: {+ in: ["OWNER", "ADMIN"],+ },+ },+ select: {+ id: true,+ },+ });++ return Boolean(membershipOrg);+ }+}