Scheduling infrastructure for absolutely everyone.
feat: implement FeatureOptInService (#25805)
Eunjae Leef4248bf20df5
diff --git a/apps/api/v2/src/modules/organizations/roles/organizations-roles.controller.e2e-spec.ts b/apps/api/v2/src/modules/organizations/roles/organizations-roles.controller.e2e-spec.tsindex 229761957fb..5c6a2363742 100644--- a/apps/api/v2/src/modules/organizations/roles/organizations-roles.controller.e2e-spec.ts+++ b/apps/api/v2/src/modules/organizations/roles/organizations-roles.controller.e2e-spec.ts@@ -112,7 +112,11 @@ describe("Organizations Roles Endpoints", () => {});await featuresRepositoryFixture.create({ slug: "pbac", enabled: true });- await featuresRepositoryFixture.setTeamFeatureState(pbacEnabledOrganization.id, "pbac", "enabled");+ await featuresRepositoryFixture.setTeamFeatureState({+ teamId: pbacEnabledOrganization.id,+ featureId: "pbac",+ state: "enabled",+ });// Create membershipsawait membershipRepositoryFixture.create({diff --git a/apps/api/v2/src/modules/organizations/roles/permissions/organizations-roles-permissions.controller.e2e-spec.ts b/apps/api/v2/src/modules/organizations/roles/permissions/organizations-roles-permissions.controller.e2e-spec.tsindex bc04ac3d3a9..382d8aa3ea5 100644--- a/apps/api/v2/src/modules/organizations/roles/permissions/organizations-roles-permissions.controller.e2e-spec.ts+++ b/apps/api/v2/src/modules/organizations/roles/permissions/organizations-roles-permissions.controller.e2e-spec.ts@@ -58,7 +58,11 @@ describe("Organizations Roles Permissions Endpoints", () => {});await featuresRepositoryFixture.create({ slug: "pbac", enabled: true });- await featuresRepositoryFixture.setTeamFeatureState(pbacEnabledOrganization.id, "pbac", "enabled");+ await featuresRepositoryFixture.setTeamFeatureState({+ teamId: pbacEnabledOrganization.id,+ featureId: "pbac",+ state: "enabled",+ });// Create user + membership in orgpbacOrgUserWithRolePermission = await userRepositoryFixture.create({diff --git a/apps/api/v2/src/modules/organizations/teams/roles/organizations-teams-roles.controller.e2e-spec.ts b/apps/api/v2/src/modules/organizations/teams/roles/organizations-teams-roles.controller.e2e-spec.tsindex 9aa1f9f42ae..64bb8ba9509 100644--- a/apps/api/v2/src/modules/organizations/teams/roles/organizations-teams-roles.controller.e2e-spec.ts+++ b/apps/api/v2/src/modules/organizations/teams/roles/organizations-teams-roles.controller.e2e-spec.ts@@ -126,7 +126,11 @@ describe("Organizations Roles Endpoints", () => {});await featuresRepositoryFixture.create({ slug: "pbac", enabled: true });- await featuresRepositoryFixture.setTeamFeatureState(pbacEnabledTeam.id, "pbac", "enabled");+ await featuresRepositoryFixture.setTeamFeatureState({+ teamId: pbacEnabledTeam.id,+ featureId: "pbac",+ state: "enabled",+ });// Create membershipsawait membershipRepositoryFixture.create({diff --git a/apps/api/v2/src/modules/organizations/teams/roles/permissions/organizations-teams-roles-permissions.controller.e2e-spec.ts b/apps/api/v2/src/modules/organizations/teams/roles/permissions/organizations-teams-roles-permissions.controller.e2e-spec.tsindex 637bcf10a1a..a3d6774715f 100644--- a/apps/api/v2/src/modules/organizations/teams/roles/permissions/organizations-teams-roles-permissions.controller.e2e-spec.ts+++ b/apps/api/v2/src/modules/organizations/teams/roles/permissions/organizations-teams-roles-permissions.controller.e2e-spec.ts@@ -67,7 +67,11 @@ describe("Organizations Teams Roles Permissions Endpoints", () => {});await featuresRepositoryFixture.create({ slug: "pbac", enabled: true });- await featuresRepositoryFixture.setTeamFeatureState(pbacEnabledTeam.id, "pbac", "enabled");+ await featuresRepositoryFixture.setTeamFeatureState({+ teamId: pbacEnabledTeam.id,+ featureId: "pbac",+ state: "enabled",+ });// Create user + membership in orgpbacOrgUserWithRolePermission = await userRepositoryFixture.create({diff --git a/apps/api/v2/test/fixtures/repository/features.repository.fixture.ts b/apps/api/v2/test/fixtures/repository/features.repository.fixture.tsindex b5b964d44d8..e024532da40 100644--- a/apps/api/v2/test/fixtures/repository/features.repository.fixture.ts+++ b/apps/api/v2/test/fixtures/repository/features.repository.fixture.ts@@ -2,15 +2,19 @@ import { PrismaReadService } from "@/modules/prisma/prisma-read.service";import { PrismaWriteService } from "@/modules/prisma/prisma-write.service";import { TestingModule } from "@nestjs/testing";+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import type { Prisma } from "@calcom/prisma/client";export class FeaturesRepositoryFixture {private prismaReadClient: PrismaReadService["prisma"];private prismaWriteClient: PrismaWriteService["prisma"];+ private featuresRepository: FeaturesRepository;constructor(module: TestingModule) {this.prismaReadClient = module.get(PrismaReadService).prisma;this.prismaWriteClient = module.get(PrismaWriteService).prisma;+ this.featuresRepository = new FeaturesRepository(this.prismaWriteClient);}async create(data: Prisma.FeatureCreateInput) {// note(Lauris): upserting because this create function is called in multiple tests in parallel and otherwise would lead to unique@@ -22,52 +26,32 @@ export class FeaturesRepositoryFixture {});}- async createTeamFeature(data: Prisma.TeamFeaturesCreateInput) {- return await this.prismaWriteClient.teamFeatures.create({- data,- });- }-async setTeamFeatureState(- teamId: number,- featureId: string,- state: "enabled" | "disabled" | "inherit",- assignedBy = "test"+ input:+ | { teamId: number; featureId: string; state: "enabled" | "disabled"; assignedBy?: string }+ | { teamId: number; featureId: string; state: "inherit" }) {- if (state === "enabled" || state === "disabled") {- await this.prismaWriteClient.teamFeatures.upsert({- where: {- teamId_featureId: {- teamId,- featureId,- },- },- create: {- teamId,- featureId,- assignedBy,- enabled: state === "enabled",- },- update: {- enabled: state === "enabled",- },+ if (input.state === "inherit") {+ await this.featuresRepository.setTeamFeatureState({+ teamId: input.teamId,+ featureId: input.featureId as FeatureId,+ state: input.state,});- } else if (state === "inherit") {- await this.prismaWriteClient.teamFeatures.deleteMany({- where: {- teamId,- featureId,- },+ } else {+ await this.featuresRepository.setTeamFeatureState({+ teamId: input.teamId,+ featureId: input.featureId as FeatureId,+ state: input.state,+ assignedBy: input.assignedBy ?? "test",});}}async disableFeatureForTeam(teamId: number, featureSlug: string) {- return await this.prismaWriteClient.teamFeatures.deleteMany({- where: {- teamId,- featureId: featureSlug,- },+ await this.featuresRepository.setTeamFeatureState({+ teamId,+ featureId: featureSlug as FeatureId,+ state: "inherit",});}@@ -78,11 +62,10 @@ export class FeaturesRepositoryFixture {}async deleteTeamFeature(teamId: number, featureSlug: string) {- return await this.prismaWriteClient.teamFeatures.deleteMany({- where: {- teamId,- featureId: featureSlug,- },+ await this.featuresRepository.setTeamFeatureState({+ teamId,+ featureId: featureSlug as FeatureId,+ state: "inherit",});}}diff --git a/apps/web/playwright/fixtures/users.ts b/apps/web/playwright/fixtures/users.tsindex 012a2ff44a1..ae3c69ec0e0 100644--- a/apps/web/playwright/fixtures/users.ts+++ b/apps/web/playwright/fixtures/users.ts@@ -6,7 +6,8 @@ import { v4 } from "uuid";import updateChildrenEventTypes from "@calcom/features/ee/managed-event-types/lib/handleChildrenEventTypes";import stripe from "@calcom/features/ee/payments/server/stripe";-import type { AppFlags } from "@calcom/features/flags/config";+import type { AppFlags, FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import { ProfileRepository } from "@calcom/features/profile/repositories/ProfileRepository";import { DEFAULT_SCHEDULE, getAvailabilityFromSchedule } from "@calcom/lib/availability";import { WEBAPP_URL } from "@calcom/lib/constants";@@ -253,15 +254,17 @@ const createTeamAndAddUser = async (// Enable feature flags for the team if specifiedif (teamFeatureFlags && teamFeatureFlags.length > 0) {- await prisma.teamFeatures.createMany({- data: teamFeatureFlags.map((featureFlag) => ({- teamId: team.id,- featureId: featureFlag,- assignedBy: "e2e-fixture",- assignedAt: new Date(),- enabled: true,- })),- });+ const featuresRepository = new FeaturesRepository(prisma);+ await Promise.all(+ teamFeatureFlags.map((featureFlag) =>+ featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: featureFlag as FeatureId,+ state: "enabled",+ assignedBy: "e2e-fixture",+ })+ )+ );}return team;@@ -423,15 +426,17 @@ export const createUsersFixture = (// Default to DEFAULT_USER_FEATURE_FLAGS if not specifiedconst userFeatureFlags = opts?.userFeatureFlags ?? DEFAULT_USER_FEATURE_FLAGS;if (userFeatureFlags.length > 0) {- await prisma.userFeatures.createMany({- data: userFeatureFlags.map((featureFlag) => ({- userId: user.id,- featureId: featureFlag,- assignedBy: "e2e-fixture",- assignedAt: new Date(),- enabled: true,- })),- });+ const featuresRepository = new FeaturesRepository(prisma);+ await Promise.all(+ userFeatureFlags.map((featureFlag) =>+ featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: featureFlag as FeatureId,+ state: "enabled",+ assignedBy: "e2e-fixture",+ })+ )+ );}if (scenario.hasTeam) {diff --git a/apps/web/playwright/lib/test-helpers/pbac.ts b/apps/web/playwright/lib/test-helpers/pbac.tsindex 0535fcf64dc..1c166d43d28 100644--- a/apps/web/playwright/lib/test-helpers/pbac.ts+++ b/apps/web/playwright/lib/test-helpers/pbac.ts@@ -1,3 +1,5 @@+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import { PERMISSION_REGISTRY } from "@calcom/features/pbac/domain/types/permission-registry";import { prisma } from "@calcom/prisma";@@ -18,13 +20,11 @@ export const createAllPermissionsArray = () => {};export const enablePBACForTeam = async (teamId: number) => {- await prisma.teamFeatures.create({- data: {- featureId: "pbac",- teamId: teamId,- assignedBy: "e2e",- assignedAt: new Date(),- enabled: true,- },+ const featuresRepository = new FeaturesRepository(prisma);+ await featuresRepository.setTeamFeatureState({+ teamId,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "e2e",});};diff --git a/packages/app-store/delegationCredential.test.ts b/packages/app-store/delegationCredential.test.tsindex 0198402b233..256caced3fb 100644--- a/packages/app-store/delegationCredential.test.ts+++ b/packages/app-store/delegationCredential.test.ts@@ -1,3 +1,5 @@+import { organizationRepositoryMock } from "@calcom/features/ee/organizations/__mocks__/organizationMock";+import { setupAndTeardown } from "@calcom/web/test/utils/bookingScenario/setupAndTeardown";import { describe, it, expect, beforeEach, vi } from "vitest";@@ -6,7 +8,6 @@ import { metadata as googleCalendarMetadata } from "@calcom/app-store/googlecaleimport { metadata as googleMeetMetadata } from "@calcom/app-store/googlevideo/_metadata";import type { ServiceAccountKey } from "@calcom/features/delegation-credentials/repositories/DelegationCredentialRepository";import { DelegationCredentialRepository } from "@calcom/features/delegation-credentials/repositories/DelegationCredentialRepository";-import { organizationRepositoryMock } from "@calcom/features/ee/organizations/__mocks__/organizationMock";import { SMSLockState, RRTimestampBasis } from "@calcom/prisma/enums";import type { CredentialForCalendarService, CredentialPayload } from "@calcom/types/Credential";@@ -105,6 +106,7 @@ const mockOrganization = {hideTeamProfileLink: false,rrResetInterval: null,rrTimestampBasis: RRTimestampBasis.CREATED_AT,+ autoOptInFeatures: false,};// Credential Buildersdiff --git a/packages/features/booking-audit/lib/service/booking-audit.integration-test.ts b/packages/features/booking-audit/lib/service/booking-audit.integration-test.tsindex ecaa8835228..e4d8ad355bd 100644--- a/packages/features/booking-audit/lib/service/booking-audit.integration-test.ts+++ b/packages/features/booking-audit/lib/service/booking-audit.integration-test.ts@@ -1,5 +1,7 @@import { describe, expect, it, beforeEach, afterEach } from "vitest";+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import { prisma } from "@calcom/prisma";import { BookingStatus, MembershipRole } from "@calcom/prisma/enums";@@ -8,6 +10,8 @@ import type { BookingAuditViewerService } from "./BookingAuditViewerService";import { makeUserActor } from "../makeActor";import { getBookingAuditTaskConsumer } from "../../di/BookingAuditTaskConsumer.container";import { getBookingAuditViewerService } from "../../di/BookingAuditViewerService.container";+import type { BookingAuditTaskConsumer } from "./BookingAuditTaskConsumer";+import type { BookingAuditViewerService } from "./BookingAuditViewerService";const generateUniqueId = () => {const timestamp = Date.now();@@ -15,7 +19,11 @@ const generateUniqueId = () => {return `${timestamp}-${randomSuffix}`;};-const createTestUser = async (overrides?: { email?: string; username?: string; name?: string }) => {+const createTestUser = async (overrides?: {+ email?: string;+ username?: string;+ name?: string;+}) => {const uniqueId = generateUniqueId();return prisma.user.create({data: {@@ -26,7 +34,10 @@ const createTestUser = async (overrides?: { email?: string; username?: string; n});};-const createTestOrganization = async (overrides?: { name?: string; slug?: string }) => {+const createTestOrganization = async (overrides?: {+ name?: string;+ slug?: string;+}) => {const uniqueId = generateUniqueId();return prisma.team.create({data: {@@ -81,7 +92,8 @@ const createTestBooking = async () => {const uniqueId = generateUniqueId();const startTime = overrides?.startTime || new Date();- const endTime = overrides?.endTime || new Date(startTime.getTime() + 60 * 60 * 1000);+ const endTime =+ overrides?.endTime || new Date(startTime.getTime() + 60 * 60 * 1000);return prisma.booking.create({data: {@@ -99,7 +111,10 @@ const createTestBooking = async (});};-const enableFeatureForOrganization = async (organizationId: number, featureSlug: string) => {+const enableFeatureForOrganization = async (+ organizationId: number,+ featureSlug: string+) => {await prisma.feature.upsert({where: { slug: featureSlug },create: {@@ -112,22 +127,12 @@ const enableFeatureForOrganization = async (organizationId: number, featureSlug:},});- await prisma.teamFeatures.upsert({- where: {- teamId_featureId: {- teamId: organizationId,- featureId: featureSlug,- },- },- create: {- teamId: organizationId,- featureId: featureSlug,- assignedBy: "test-system",- enabled: true,- },- update: {- enabled: true,- },+ const featuresRepository = new FeaturesRepository(prisma);+ await featuresRepository.setTeamFeatureState({+ teamId: organizationId,+ featureId: featureSlug as FeatureId,+ state: "enabled",+ assignedBy: "test-system",});};@@ -177,11 +182,11 @@ const cleanupTestData = async (testData: {if (testData.organizationId) {if (testData.featureSlug) {- await prisma.teamFeatures.deleteMany({- where: {- teamId: testData.organizationId,- featureId: testData.featureSlug,- },+ const featuresRepository = new FeaturesRepository(prisma);+ await featuresRepository.setTeamFeatureState({+ teamId: testData.organizationId,+ featureId: testData.featureSlug as FeatureId,+ state: "inherit",});}await prisma.membership.deleteMany({@@ -208,7 +213,12 @@ describe("Booking Audit Integration", () => {attendee: { id: number; email: string };organization: { id: number };eventType: { id: number };- booking: { uid: string; startTime: Date; endTime: Date; status: BookingStatus };+ booking: {+ uid: string;+ startTime: Date;+ endTime: Date;+ status: BookingStatus;+ };};beforeEach(async () => {@@ -255,7 +265,9 @@ describe("Booking Audit Integration", () => {attendeeEmails: testData.attendee?.email ? [testData.attendee.email] : [],eventTypeId: testData.eventType?.id,organizationId: testData.organization?.id,- userIds: [testData.owner?.id, testData.attendee?.id].filter((id): id is number => id !== undefined),+ userIds: [testData.owner?.id, testData.attendee?.id].filter(+ (id): id is number => id !== undefined+ ),featureSlug: "booking-audit",});});@@ -298,11 +310,15 @@ describe("Booking Audit Integration", () => {expect(displayData).toBeDefined();expect(displayData.startTime).toBeDefined();expect(typeof displayData.startTime).toBe("string");- expect(displayData.startTime).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);+ expect(displayData.startTime).toMatch(+ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/+ );expect(displayData.endTime).toBeDefined();expect(typeof displayData.endTime).toBe("string");- expect(displayData.endTime).toMatch(/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/);+ expect(displayData.endTime).toMatch(+ /^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/+ );expect(displayData.status).toBe(testData.booking.status);});@@ -397,13 +413,14 @@ describe("Booking Audit Integration", () => {timestamp: Date.now(),});- const ownerResult = await bookingAuditViewerService.getAuditLogsForBooking({- bookingUid: testData.booking.uid,- userId: testData.owner.id,- userEmail: testData.owner.email,- userTimeZone: "UTC",- organizationId: testData.organization.id,- });+ const ownerResult =+ await bookingAuditViewerService.getAuditLogsForBooking({+ bookingUid: testData.booking.uid,+ userId: testData.owner.id,+ userEmail: testData.owner.email,+ userTimeZone: "UTC",+ organizationId: testData.organization.id,+ });expect(ownerResult.auditLogs).toHaveLength(1);const unauthorizedUserId = 999999;@@ -423,25 +440,33 @@ describe("Booking Audit Integration", () => {describe("when multiple bookings are created in bulk", () => {it("should create audit records for all bookings with same operation ID", async () => {- const booking2 = await createTestBooking(testData.owner.id, testData.eventType.id, {- attendees: [- {- email: testData.attendee.email,- name: "Test Attendee",- timeZone: "UTC",- },- ],- });+ const booking2 = await createTestBooking(+ testData.owner.id,+ testData.eventType.id,+ {+ attendees: [+ {+ email: testData.attendee.email,+ name: "Test Attendee",+ timeZone: "UTC",+ },+ ],+ }+ );- const booking3 = await createTestBooking(testData.owner.id, testData.eventType.id, {- attendees: [- {- email: testData.attendee.email,- name: "Test Attendee",- timeZone: "UTC",- },- ],- });+ const booking3 = await createTestBooking(+ testData.owner.id,+ testData.eventType.id,+ {+ attendees: [+ {+ email: testData.attendee.email,+ name: "Test Attendee",+ timeZone: "UTC",+ },+ ],+ }+ );const actor = makeUserActor(testData.owner.uuid);const operationId = `bulk-op-${Date.now()}`;@@ -532,4 +557,3 @@ describe("Booking Audit Integration", () => {});});});-diff --git a/packages/features/feature-opt-in/config.ts b/packages/features/feature-opt-in/config.tsnew file mode 100644index 00000000000..61436bfe3e2--- /dev/null+++ b/packages/features/feature-opt-in/config.ts@@ -0,0 +1,35 @@+import type { FeatureId } from "@calcom/features/flags/config";++export interface OptInFeatureConfig {+ slug: FeatureId;+ titleI18nKey: string;+ descriptionI18nKey: string;+}++/**+ * Features that appear in opt-in settings.+ * Add new features here to make them available for user/team opt-in.+ */+export const OPT_IN_FEATURES: OptInFeatureConfig[] = [+ // Example - to be populated with actual features+ // {+ // slug: "bookings-v3",+ // titleI18nKey: "bookings_v3_title",+ // descriptionI18nKey: "bookings_v3_description",+ // },+];++/**+ * Get the configuration for a specific opt-in feature by slug.+ */+export function getOptInFeatureConfig(slug: string): OptInFeatureConfig | undefined {+ return OPT_IN_FEATURES.find((f) => f.slug === slug);+}++/**+ * Check if a feature slug is in the opt-in allowlist.+ * Acts as a type guard, narrowing the slug to FeatureId when true.+ */+export function isOptInFeature(slug: string): slug is FeatureId {+ return OPT_IN_FEATURES.some((f) => f.slug === slug);+}diff --git a/packages/features/feature-opt-in/lib/applyAutoOptIn.test.ts b/packages/features/feature-opt-in/lib/applyAutoOptIn.test.tsnew file mode 100644index 00000000000..ceb86c30bf6--- /dev/null+++ b/packages/features/feature-opt-in/lib/applyAutoOptIn.test.ts@@ -0,0 +1,188 @@+import { describe, it, expect } from "vitest";++import { applyAutoOptIn } from "./applyAutoOptIn";++describe("applyAutoOptIn", () => {+ describe("org state transformation", () => {+ it("transforms org state from inherit to enabled when orgAutoOptIn is true", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: [],+ userState: "inherit",+ orgAutoOptIn: true,+ teamAutoOptIns: [],+ userAutoOptIn: false,+ });++ expect(result.effectiveOrgState).toBe("enabled");+ });++ it("keeps org state as inherit when orgAutoOptIn is false", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: [],+ userState: "inherit",+ orgAutoOptIn: false,+ teamAutoOptIns: [],+ userAutoOptIn: false,+ });++ expect(result.effectiveOrgState).toBe("inherit");+ });++ it("does not transform org state when it is explicitly enabled", () => {+ const result = applyAutoOptIn({+ orgState: "enabled",+ teamStates: [],+ userState: "inherit",+ orgAutoOptIn: true,+ teamAutoOptIns: [],+ userAutoOptIn: false,+ });++ expect(result.effectiveOrgState).toBe("enabled");+ });++ it("does not transform org state when it is explicitly disabled", () => {+ const result = applyAutoOptIn({+ orgState: "disabled",+ teamStates: [],+ userState: "inherit",+ orgAutoOptIn: true,+ teamAutoOptIns: [],+ userAutoOptIn: false,+ });++ expect(result.effectiveOrgState).toBe("disabled");+ });+ });++ describe("team states transformation", () => {+ it("transforms team states from inherit to enabled when corresponding autoOptIn is true", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: ["inherit", "inherit", "inherit"],+ userState: "inherit",+ orgAutoOptIn: false,+ teamAutoOptIns: [true, false, true],+ userAutoOptIn: false,+ });++ expect(result.effectiveTeamStates).toEqual(["enabled", "inherit", "enabled"]);+ });++ it("does not transform team states when they are explicitly set", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: ["enabled", "disabled", "inherit"],+ userState: "inherit",+ orgAutoOptIn: false,+ teamAutoOptIns: [true, true, false],+ userAutoOptIn: false,+ });++ expect(result.effectiveTeamStates).toEqual(["enabled", "disabled", "inherit"]);+ });+ });++ describe("user state transformation", () => {+ it("transforms user state from inherit to enabled when userAutoOptIn is true", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: [],+ userState: "inherit",+ orgAutoOptIn: false,+ teamAutoOptIns: [],+ userAutoOptIn: true,+ });++ expect(result.effectiveUserState).toBe("enabled");+ });++ it("keeps user state as inherit when userAutoOptIn is false", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: [],+ userState: "inherit",+ orgAutoOptIn: false,+ teamAutoOptIns: [],+ userAutoOptIn: false,+ });++ expect(result.effectiveUserState).toBe("inherit");+ });++ it("does not transform user state when it is explicitly enabled", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: [],+ userState: "enabled",+ orgAutoOptIn: false,+ teamAutoOptIns: [],+ userAutoOptIn: true,+ });++ expect(result.effectiveUserState).toBe("enabled");+ });++ it("does not transform user state when it is explicitly disabled", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: [],+ userState: "disabled",+ orgAutoOptIn: false,+ teamAutoOptIns: [],+ userAutoOptIn: true,+ });++ expect(result.effectiveUserState).toBe("disabled");+ });+ });++ describe("combined transformations", () => {+ it("transforms all levels independently when autoOptIn is true", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: ["inherit", "inherit"],+ userState: "inherit",+ orgAutoOptIn: true,+ teamAutoOptIns: [true, true],+ userAutoOptIn: true,+ });++ expect(result.effectiveOrgState).toBe("enabled");+ expect(result.effectiveTeamStates).toEqual(["enabled", "enabled"]);+ expect(result.effectiveUserState).toBe("enabled");+ });++ it("only transforms levels with autoOptIn enabled", () => {+ const result = applyAutoOptIn({+ orgState: "inherit",+ teamStates: ["inherit", "inherit"],+ userState: "inherit",+ orgAutoOptIn: false,+ teamAutoOptIns: [true, false],+ userAutoOptIn: true,+ });++ expect(result.effectiveOrgState).toBe("inherit");+ expect(result.effectiveTeamStates).toEqual(["enabled", "inherit"]);+ expect(result.effectiveUserState).toBe("enabled");+ });++ it("respects explicit states even when autoOptIn is true", () => {+ const result = applyAutoOptIn({+ orgState: "disabled",+ teamStates: ["enabled", "disabled"],+ userState: "enabled",+ orgAutoOptIn: true,+ teamAutoOptIns: [true, true],+ userAutoOptIn: true,+ });++ expect(result.effectiveOrgState).toBe("disabled");+ expect(result.effectiveTeamStates).toEqual(["enabled", "disabled"]);+ expect(result.effectiveUserState).toBe("enabled");+ });+ });+});diff --git a/packages/features/feature-opt-in/lib/applyAutoOptIn.ts b/packages/features/feature-opt-in/lib/applyAutoOptIn.tsnew file mode 100644index 00000000000..6bb7a558067--- /dev/null+++ b/packages/features/feature-opt-in/lib/applyAutoOptIn.ts@@ -0,0 +1,42 @@+import type { FeatureState } from "@calcom/features/flags/config";++/**+ * Applies auto-opt-in transformation to feature states.+ *+ * If a level has autoOptIn enabled AND the state is "inherit", the state is transformed to "enabled".+ * This allows entities to automatically opt into new features without explicit configuration.+ */+export function applyAutoOptIn({+ orgState,+ teamStates,+ userState,+ orgAutoOptIn,+ teamAutoOptIns,+ userAutoOptIn,+}: {+ orgState: FeatureState;+ teamStates: FeatureState[];+ userState: FeatureState;+ orgAutoOptIn: boolean;+ teamAutoOptIns: boolean[];+ userAutoOptIn: boolean;+}): {+ effectiveOrgState: FeatureState;+ effectiveTeamStates: FeatureState[];+ effectiveUserState: FeatureState;+} {+ const effectiveOrgState: FeatureState = orgState === "inherit" && orgAutoOptIn ? "enabled" : orgState;++ const effectiveTeamStates: FeatureState[] = teamStates.map((state, index) => {+ const autoOptIn = teamAutoOptIns[index];+ return state === "inherit" && autoOptIn ? "enabled" : state;+ });++ const effectiveUserState: FeatureState = userState === "inherit" && userAutoOptIn ? "enabled" : userState;++ return {+ effectiveOrgState,+ effectiveTeamStates,+ effectiveUserState,+ };+}diff --git a/packages/features/feature-opt-in/lib/computeEffectiveState.test.ts b/packages/features/feature-opt-in/lib/computeEffectiveState.test.tsnew file mode 100644index 00000000000..94e1e02571f--- /dev/null+++ b/packages/features/feature-opt-in/lib/computeEffectiveState.test.ts@@ -0,0 +1,352 @@+import { describe, it, expect } from "vitest";++import { computeEffectiveStateAcrossTeams } from "./computeEffectiveState";++describe("computeEffectiveStateAcrossTeams", () => {+ describe("when global is disabled", () => {+ it("returns false regardless of other states", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: false,+ orgState: "enabled",+ teamStates: ["enabled"],+ userState: "enabled",+ })+ ).toBe(false);+ });+ });++ describe("when org is disabled", () => {+ it("returns false regardless of team and user state", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "disabled",+ teamStates: ["enabled"],+ userState: "enabled",+ })+ ).toBe(false);+ });+ });++ describe("when org is enabled", () => {+ describe("when all teams are disabled", () => {+ it("returns false regardless of user state", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["disabled", "disabled"],+ userState: "enabled",+ })+ ).toBe(false);+ });+ });++ describe("when at least one team is enabled", () => {+ it("returns true when user is enabled", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["enabled", "disabled"],+ userState: "enabled",+ })+ ).toBe(true);+ });++ it("returns false when user is disabled", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["enabled", "disabled"],+ userState: "disabled",+ })+ ).toBe(false);+ });++ it("returns true when user inherits", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["enabled", "disabled"],+ userState: "inherit",+ })+ ).toBe(true);+ });+ });++ describe("when teams inherit from enabled org", () => {+ it("returns true when user is enabled or inherits", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["inherit"],+ userState: "enabled",+ })+ ).toBe(true);++ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["inherit"],+ userState: "inherit",+ })+ ).toBe(true);+ });+ });+ });++ describe("when org inherits (or no org)", () => {+ describe("when all teams are disabled", () => {+ it("returns false regardless of user state", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["disabled"],+ userState: "enabled",+ })+ ).toBe(false);+ });+ });++ describe("when at least one team is enabled", () => {+ it("returns true when user is enabled or inherits", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["enabled", "disabled"],+ userState: "enabled",+ })+ ).toBe(true);++ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["enabled"],+ userState: "inherit",+ })+ ).toBe(true);+ });++ it("returns false when user is disabled", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["enabled"],+ userState: "disabled",+ })+ ).toBe(false);+ });+ });++ describe("when teams only inherit (no org enabled)", () => {+ it("returns true when user explicitly opts in", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["inherit"],+ userState: "enabled",+ })+ ).toBe(true);+ });++ it("returns false when user inherits because no explicit enablement above", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["inherit"],+ userState: "inherit",+ })+ ).toBe(false);+ });+ });+ });++ describe("when user has no teams", () => {+ it("returns true when org is enabled and user is enabled/inherits", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: [],+ userState: "enabled",+ })+ ).toBe(true);++ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: [],+ userState: "inherit",+ })+ ).toBe(true);+ });++ it("returns false when org inherits and user has no explicit enablement", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: [],+ userState: "inherit",+ })+ ).toBe(false); // No explicit enablement in chain, feature should be disabled+ });++ it("returns true when org inherits but user explicitly enables", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: [],+ userState: "enabled",+ })+ ).toBe(true); // User explicit enablement is sufficient+ });+ });++ describe("user opt-in behavior", () => {+ it("allows user to opt-in regardless of org/team inheritance state", () => {+ // User can opt-in even when org and all teams are just inheriting+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["inherit", "inherit"],+ userState: "enabled",+ })+ ).toBe(true);+ });++ it("blocks user opt-in when all teams have explicitly disabled", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["disabled", "disabled"],+ userState: "enabled",+ })+ ).toBe(false);+ });++ it("blocks user opt-in when org has explicitly disabled", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "disabled",+ teamStates: ["inherit"],+ userState: "enabled",+ })+ ).toBe(false);+ });+ });++ describe("truth table from design doc", () => {+ it("org disabled, any teams, any user → false", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "disabled",+ teamStates: ["enabled"],+ userState: "enabled",+ })+ ).toBe(false);+ });++ it("org enabled, all teams disabled, any user → false", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["disabled", "disabled"],+ userState: "enabled",+ })+ ).toBe(false);+ });++ it("org enabled, at least one team enabled/inherit, user disabled → false", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["enabled"],+ userState: "disabled",+ })+ ).toBe(false);+ });++ it("org enabled, at least one team enabled/inherit, user enabled/inherit → true", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["enabled"],+ userState: "enabled",+ })+ ).toBe(true);++ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "enabled",+ teamStates: ["inherit"],+ userState: "inherit",+ })+ ).toBe(true);+ });++ it("org inherit/null, all teams disabled, any user → false", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["disabled"],+ userState: "enabled",+ })+ ).toBe(false);+ });++ it("org inherit/null, at least one team enabled, user disabled → false", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["enabled"],+ userState: "disabled",+ })+ ).toBe(false);+ });++ it("org inherit/null, at least one team enabled, user enabled/inherit → true", () => {+ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["enabled"],+ userState: "enabled",+ })+ ).toBe(true);++ expect(+ computeEffectiveStateAcrossTeams({+ globalEnabled: true,+ orgState: "inherit",+ teamStates: ["enabled"],+ userState: "inherit",+ })+ ).toBe(true);+ });+ });+});diff --git a/packages/features/feature-opt-in/lib/computeEffectiveState.ts b/packages/features/feature-opt-in/lib/computeEffectiveState.tsnew file mode 100644index 00000000000..8ac9c2af0cb--- /dev/null+++ b/packages/features/feature-opt-in/lib/computeEffectiveState.ts@@ -0,0 +1,48 @@+import type { FeatureState } from "@calcom/features/flags/config";++/**+ * Computes the effective enabled state based on global, org, teams, and user settings.+ *+ * The logic follows these rules:+ * - Any level set to "disabled" blocks the feature (org blocks all, team blocks that team's users, user blocks self)+ * - User can explicitly opt-in to enable the feature for themselves+ * - "enabled" at org/team level provides enablement that users can inherit from+ * - "inherit" passes through to the level above+ */+export function computeEffectiveStateAcrossTeams({+ globalEnabled,+ orgState,+ teamStates,+ userState,+}: {+ /**+ * Acts as a global kill switch. When false, the feature is disabled for everyone.+ * When true, the feature is NOT necessarily enabled - enablement still depends on+ * the org, team, and user state hierarchy.+ */+ globalEnabled: boolean;+ orgState: FeatureState;+ teamStates: FeatureState[];+ userState: FeatureState;+}): boolean {+ // Derive all conditions upfront+ const orgEnabled = orgState === "enabled";+ const orgDisabled = orgState === "disabled";+ const anyTeamEnabled = teamStates.some((s) => s === "enabled");+ const allTeamsDisabled = teamStates.length > 0 && teamStates.every((s) => s === "disabled");+ const userEnabled = userState === "enabled";+ const userDisabled = userState === "disabled";++ // Explicit enablement exists above user level+ const hasExplicitEnablementAboveUser = orgEnabled || anyTeamEnabled;++ // Define when feature is enabled (whitelist approach)+ const isEnabled =+ globalEnabled &&+ !userDisabled &&+ !orgDisabled &&+ !allTeamsDisabled &&+ (userEnabled || hasExplicitEnablementAboveUser); // User can opt-in directly, or inherit from org/team++ return isEnabled;+}diff --git a/packages/features/feature-opt-in/services/FeatureOptInService.integration-test.ts b/packages/features/feature-opt-in/services/FeatureOptInService.integration-test.tsnew file mode 100644index 00000000000..cad5c0bac31--- /dev/null+++ b/packages/features/feature-opt-in/services/FeatureOptInService.integration-test.ts@@ -0,0 +1,908 @@+import { afterEach, describe, expect, it } from "vitest";++import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";+import { prisma } from "@calcom/prisma";++import { FeatureOptInService } from "./FeatureOptInService";++// Helper to generate unique identifiers per test+const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;++// Store cleanup functions to ensure they run even if tests fail+const cleanupFunctions: Array<() => Promise<void>> = [];++afterEach(async () => {+ for (const cleanup of cleanupFunctions) {+ await cleanup();+ }+ cleanupFunctions.length = 0;+});++// Access private clearCache method through type assertion+const clearFeaturesCache = (repo: FeaturesRepository) => {+ (repo as unknown as { clearCache: () => void }).clearCache();+};++interface TestEntities {+ user: { id: number };+ org: { id: number };+ team: { id: number };+ team2: { id: number };+ featuresRepository: FeaturesRepository;+ service: FeatureOptInService;+ createdFeatures: string[];+ setupFeature: (enabled?: boolean) => Promise<FeatureId>;+}++/**+ * Creates isolated test entities (user, org, teams) and returns them along with a cleanup function.+ * Each test gets its own entities, ensuring complete isolation even when tests run in parallel.+ */+async function setup(): Promise<TestEntities> {+ const id = uniqueId();+ const createdFeatures: string[] = [];++ // Create test user+ const user = await prisma.user.create({+ data: {+ email: `test-opt-in-${id}@example.com`,+ username: `test-opt-in-${id}`,+ },+ });++ // Create test org+ const org = await prisma.team.create({+ data: {+ name: `Test OptIn Org ${id}`,+ slug: `test-opt-in-org-${id}`,+ isOrganization: true,+ },+ });++ // Create test teams+ const team = await prisma.team.create({+ data: {+ name: `Test OptIn Team ${id}`,+ slug: `test-opt-in-team-${id}`,+ parentId: org.id,+ },+ });++ const team2 = await prisma.team.create({+ data: {+ name: `Test OptIn Team 2 ${id}`,+ slug: `test-opt-in-team-2-${id}`,+ parentId: org.id,+ },+ });++ const featuresRepository = new FeaturesRepository(prisma);+ const service = new FeatureOptInService(featuresRepository);++ // Helper to create a feature for a test and track it for cleanup+ const setupFeature = async (enabled = true): Promise<FeatureId> => {+ const featureSlug = `test-opt-in-feature-${uniqueId()}` as FeatureId;+ createdFeatures.push(featureSlug);+ await prisma.feature.create({+ data: {+ slug: featureSlug,+ enabled,+ type: "EXPERIMENT",+ },+ });+ // Clear cache after creating feature so getAllFeatures() returns fresh data+ clearFeaturesCache(featuresRepository);+ return featureSlug;+ };++ // Cleanup function - automatically registered with afterEach+ const cleanup = async () => {+ // Clean up in correct order to respect foreign key constraints+ await prisma.userFeatures.deleteMany({+ where: { userId: user.id },+ });+ await prisma.teamFeatures.deleteMany({+ where: { teamId: { in: [team.id, team2.id, org.id] } },+ });+ await prisma.feature.deleteMany({+ where: { slug: { in: createdFeatures } },+ });+ await prisma.membership.deleteMany({+ where: { userId: user.id },+ });+ await prisma.team.deleteMany({+ where: { id: { in: [team.id, team2.id] } },+ });+ await prisma.team.deleteMany({+ where: { id: org.id },+ });+ await prisma.user.delete({+ where: { id: user.id },+ });+ };++ // Register cleanup to run automatically after each test+ cleanupFunctions.push(cleanup);++ return {+ user,+ org,+ team,+ team2,+ featuresRepository,+ service,+ createdFeatures,+ setupFeature,+ };+}++describe("FeatureOptInService Integration Tests", () => {+ describe("resolveFeatureStatesAcrossTeams", () => {+ describe("global feature disabled", () => {+ it("should return effectiveEnabled=false regardless of other states", async () => {+ const { user, org, team, service, setupFeature } = await setup();+ const testFeature = await setupFeature(false);++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.effectiveEnabled).toBe(false);+ });+ });++ describe("org disabled", () => {+ it("should return effectiveEnabled=false regardless of team and user states", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Org explicitly disables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ });++ // Team enables+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // User enables+ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("disabled");+ expect(status.effectiveEnabled).toBe(false);+ });+ });++ describe("org enabled", () => {+ it("should return effectiveEnabled=false when all teams are disabled", async () => {+ const { user, org, team, team2, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Org enables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Both teams disable+ await Promise.all([+ featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ }),+ featuresRepository.setTeamFeatureState({+ teamId: team2.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ }),+ ]);++ // User enables+ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id, team2.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("enabled");+ expect(status.teamStates).toEqual(["disabled", "disabled"]);+ expect(status.effectiveEnabled).toBe(false);+ });++ it("should return effectiveEnabled=true when at least one team is enabled and user inherits", async () => {+ const { user, org, team, team2, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Org enables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // One team enables, one disables+ await Promise.all([+ featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ }),+ featuresRepository.setTeamFeatureState({+ teamId: team2.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ }),+ ]);++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id, team2.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("enabled");+ expect(status.userState).toBe("inherit");+ expect(status.effectiveEnabled).toBe(true);+ });++ it("should return effectiveEnabled=false when user explicitly disables", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Org enables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Team enables+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // User disables+ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.userState).toBe("disabled");+ expect(status.effectiveEnabled).toBe(false);+ });++ it("should return effectiveEnabled=true when teams inherit from enabled org", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Org enables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Teams inherit (no rows)++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("enabled");+ expect(status.teamStates).toEqual(["inherit"]);+ expect(status.effectiveEnabled).toBe(true);+ });+ });++ describe("org inherits (or no org)", () => {+ it("should return effectiveEnabled=false when all teams are disabled", async () => {+ const { user, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Team disables+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: null,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("inherit");+ expect(status.teamStates).toEqual(["disabled"]);+ expect(status.effectiveEnabled).toBe(false);+ });++ it("should return effectiveEnabled=true when at least one team is enabled", async () => {+ const { user, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // One team enables+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: null,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.teamStates).toEqual(["enabled"]);+ expect(status.effectiveEnabled).toBe(true);+ });++ it("should return effectiveEnabled=false when teams only inherit (no explicit enablement)", async () => {+ const { user, team, service, setupFeature } = await setup();+ const testFeature = await setupFeature(true);++ // No org, team inherits (no row)+ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: null,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("inherit");+ expect(status.teamStates).toEqual(["inherit"]);+ expect(status.effectiveEnabled).toBe(false);+ });+ });++ describe("no teams", () => {+ it("should return effectiveEnabled=true when org is enabled and user inherits", async () => {+ const { user, org, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Org enables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("enabled");+ expect(status.teamStates).toEqual([]);+ expect(status.effectiveEnabled).toBe(true);+ });+ });+ });++ describe("setUserFeatureState", () => {+ it("should delete the row when state is 'inherit'", async () => {+ const { user, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // First create a row+ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Set to inherit (should delete)+ await service.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "inherit",+ });++ const row = await prisma.userFeatures.findFirst({+ where: {+ userId: user.id,+ featureId: testFeature,+ },+ });++ expect(row).toBeNull();+ });++ it("should upsert with enabled=true when state is 'enabled'", async () => {+ const { user, service, setupFeature } = await setup();+ const testFeature = await setupFeature(true);++ await service.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: user.id,+ });++ const row = await prisma.userFeatures.findFirst({+ where: {+ userId: user.id,+ featureId: testFeature,+ },+ });++ expect(row).not.toBeNull();+ expect(row?.enabled).toBe(true);+ });++ it("should upsert with enabled=false when state is 'disabled'", async () => {+ const { user, service, setupFeature } = await setup();+ const testFeature = await setupFeature(true);++ await service.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: user.id,+ });++ const row = await prisma.userFeatures.findFirst({+ where: {+ userId: user.id,+ featureId: testFeature,+ },+ });++ expect(row).not.toBeNull();+ expect(row?.enabled).toBe(false);+ });+ });++ describe("setTeamFeatureState", () => {+ it("should delete the row when state is 'inherit'", async () => {+ const { team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // First create a row+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Set to inherit (should delete)+ await service.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "inherit",+ });++ const row = await prisma.teamFeatures.findUnique({+ where: {+ teamId_featureId: {+ teamId: team.id,+ featureId: testFeature,+ },+ },+ });++ expect(row).toBeNull();+ });++ it("should upsert with enabled=true when state is 'enabled'", async () => {+ const { user, team, service, setupFeature } = await setup();+ const testFeature = await setupFeature(true);++ await service.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: user.id,+ });++ const row = await prisma.teamFeatures.findUnique({+ where: {+ teamId_featureId: {+ teamId: team.id,+ featureId: testFeature,+ },+ },+ });++ expect(row).not.toBeNull();+ expect(row?.enabled).toBe(true);+ });++ it("should upsert with enabled=false when state is 'disabled'", async () => {+ const { user, team, service, setupFeature } = await setup();+ const testFeature = await setupFeature(true);++ await service.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: user.id,+ });++ const row = await prisma.teamFeatures.findUnique({+ where: {+ teamId_featureId: {+ teamId: team.id,+ featureId: testFeature,+ },+ },+ });++ expect(row).not.toBeNull();+ expect(row?.enabled).toBe(false);+ });+ });++ describe("auto-opt-in scenarios", () => {+ describe("user autoOptInFeatures", () => {+ it("should transform user state from 'inherit' to 'enabled' when user has autoOptInFeatures=true", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Enable auto-opt-in for user+ await prisma.user.update({+ where: { id: user.id },+ data: { autoOptInFeatures: true },+ });++ // Org enables (to allow team level)+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Team enables (to allow user level)+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // User has no explicit state (inherit), but autoOptInFeatures=true should enable+ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.userState).toBe("inherit"); // Raw state is still inherit+ expect(status.userAutoOptIn).toBe(true);+ expect(status.effectiveEnabled).toBe(true); // But effective is true due to auto-opt-in+ });++ it("should NOT transform explicit 'disabled' state when user has autoOptInFeatures=true", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Enable auto-opt-in for user+ await prisma.user.update({+ where: { id: user.id },+ data: { autoOptInFeatures: true },+ });++ // Org enables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Team enables+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // User explicitly disables+ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.userState).toBe("disabled");+ expect(status.userAutoOptIn).toBe(true);+ expect(status.effectiveEnabled).toBe(false); // Explicit disabled takes precedence+ });+ });++ describe("team autoOptInFeatures", () => {+ it("should transform team state from 'inherit' to 'enabled' when team has autoOptInFeatures=true", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Enable auto-opt-in for team+ await prisma.team.update({+ where: { id: team.id },+ data: { autoOptInFeatures: true },+ });++ // Org enables (to allow team level)+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Team has no explicit state (inherit), but autoOptInFeatures=true should enable+ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.teamStates).toEqual(["inherit"]); // Raw state is still inherit+ expect(status.teamAutoOptIns).toEqual([true]);+ expect(status.effectiveEnabled).toBe(true); // Effective is true due to team auto-opt-in+ });++ it("should NOT transform explicit 'disabled' state when team has autoOptInFeatures=true", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Enable auto-opt-in for team+ await prisma.team.update({+ where: { id: team.id },+ data: { autoOptInFeatures: true },+ });++ // Org enables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test",+ });++ // Team explicitly disables+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.teamStates).toEqual(["disabled"]);+ expect(status.teamAutoOptIns).toEqual([true]);+ expect(status.effectiveEnabled).toBe(false); // Explicit disabled takes precedence+ });+ });++ describe("org autoOptInFeatures", () => {+ it("should transform org state from 'inherit' to 'enabled' when org has autoOptInFeatures=true", async () => {+ const { user, org, team, service, setupFeature } = await setup();+ const testFeature = await setupFeature(true);++ // Enable auto-opt-in for org+ await prisma.team.update({+ where: { id: org.id },+ data: { autoOptInFeatures: true },+ });++ // Org has no explicit state (inherit), but autoOptInFeatures=true should enable+ // Team inherits from org+ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("inherit"); // Raw state is still inherit+ expect(status.orgAutoOptIn).toBe(true);+ expect(status.effectiveEnabled).toBe(true); // Effective is true due to org auto-opt-in+ });++ it("should NOT transform explicit 'disabled' state when org has autoOptInFeatures=true", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Enable auto-opt-in for org+ await prisma.team.update({+ where: { id: org.id },+ data: { autoOptInFeatures: true },+ });++ // Org explicitly disables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("disabled");+ expect(status.orgAutoOptIn).toBe(true);+ expect(status.effectiveEnabled).toBe(false); // Explicit disabled takes precedence+ });+ });++ describe("auto-opt-in with org disabled blocking", () => {+ it("should return effectiveEnabled=false when user auto-opts-in but org is disabled", async () => {+ const { user, org, team, service, setupFeature, featuresRepository } = await setup();+ const testFeature = await setupFeature(true);++ // Enable auto-opt-in for user+ await prisma.user.update({+ where: { id: user.id },+ data: { autoOptInFeatures: true },+ });++ // Org explicitly disables+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test",+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.orgState).toBe("disabled");+ expect(status.userState).toBe("inherit");+ expect(status.userAutoOptIn).toBe(true);+ expect(status.effectiveEnabled).toBe(false); // Org disabled blocks everything+ });+ });++ describe("auto-opt-in flags in response", () => {+ it("should return correct auto-opt-in flags for all levels", async () => {+ const { user, org, team, team2, service, setupFeature } = await setup();+ const testFeature = await setupFeature(true);++ // Set up different auto-opt-in states+ await prisma.user.update({+ where: { id: user.id },+ data: { autoOptInFeatures: true },+ });++ await prisma.team.update({+ where: { id: org.id },+ data: { autoOptInFeatures: false },+ });++ await prisma.team.update({+ where: { id: team.id },+ data: { autoOptInFeatures: true },+ });++ await prisma.team.update({+ where: { id: team2.id },+ data: { autoOptInFeatures: false },+ });++ const statusMap = await service.resolveFeatureStatesAcrossTeams({+ userId: user.id,+ orgId: org.id,+ teamIds: [team.id, team2.id],+ featureIds: [testFeature],+ });+ const status = statusMap[testFeature];++ expect(status.userAutoOptIn).toBe(true);+ expect(status.orgAutoOptIn).toBe(false);+ expect(status.teamAutoOptIns).toEqual([true, false]);+ });+ });+ });+});diff --git a/packages/features/feature-opt-in/services/FeatureOptInService.ts b/packages/features/feature-opt-in/services/FeatureOptInService.tsnew file mode 100644index 00000000000..bcc8f593793--- /dev/null+++ b/packages/features/feature-opt-in/services/FeatureOptInService.ts@@ -0,0 +1,232 @@+import type { FeatureId, FeatureState } from "@calcom/features/flags/config";+import type { FeaturesRepository } from "@calcom/features/flags/features.repository";++import { OPT_IN_FEATURES } from "../config";+import { applyAutoOptIn } from "../lib/applyAutoOptIn";+import { computeEffectiveStateAcrossTeams } from "../lib/computeEffectiveState";++type ResolvedFeatureState = {+ featureId: FeatureId;+ globalEnabled: boolean;+ orgState: FeatureState; // Raw state (before auto-opt-in transform)+ teamStates: FeatureState[]; // Raw states+ userState: FeatureState | undefined; // Raw state+ effectiveEnabled: boolean;+ // Auto-opt-in flags for UI to show checkbox state+ orgAutoOptIn: boolean;+ teamAutoOptIns: boolean[];+ userAutoOptIn: boolean;+};++/**+ * Service class for managing feature opt-in logic.+ * Computes effective states based on global, org, team, and user settings.+ */+export class FeatureOptInService {+ constructor(private featuresRepository: FeaturesRepository) {}++ /**+ * Core method: Resolve feature states for a user across all their teams.+ *+ * Precedence rules:+ * 1. Global disabled → false (stop)+ * 2. Org explicitly disabled → false (stop)+ * 3. Org explicitly enabled → allowed at org level, continue to teams+ * 4. Org inherits (or no org) → check teams+ * 5. All teams explicitly disabled → false (stop)+ * 6. At least one team enabled OR inherits → allowed at team level, continue to user+ * 7. User explicitly disabled → false+ * 8. User explicitly enabled OR inherits → true+ *+ * Auto-opt-in transformation:+ * - If autoOptInFeatures=true at a level AND state is "inherit", transform to "enabled"+ * - This transformation happens before computing effectiveEnabled+ */+ async resolveFeatureStatesAcrossTeams({+ userId,+ orgId,+ teamIds,+ featureIds,+ }: {+ userId: number;+ orgId: number | null;+ teamIds: number[];+ featureIds: FeatureId[];+ }): Promise<Record<string, ResolvedFeatureState>> {+ // Get org and team states in a single query+ // Include orgId in the query if it exists+ const allTeamIds = orgId !== null ? [orgId, ...teamIds] : teamIds;++ const [allFeatures, allTeamStates, userStates, userAutoOptIn, teamsAutoOptIn] = await Promise.all([+ this.featuresRepository.getAllFeatures(),+ this.featuresRepository.getTeamsFeatureStates({+ teamIds: allTeamIds,+ featureIds,+ }),+ this.featuresRepository.getUserFeatureStates({+ userId,+ featureIds,+ }),+ this.featuresRepository.getUserAutoOptIn(userId),+ this.featuresRepository.getTeamsAutoOptIn(allTeamIds),+ ]);++ const globalEnabledMap = new Map(allFeatures.map((feature) => [feature.slug, feature.enabled ?? false]));++ const resolvedStates: Record<string, ResolvedFeatureState> = {};++ for (const featureId of featureIds) {+ const globalEnabled = globalEnabledMap.get(featureId) ?? false;+ const teamStatesById = allTeamStates[featureId] ?? {};++ // Extract raw org state from the combined result+ const orgState: FeatureState = orgId !== null ? teamStatesById[orgId] ?? "inherit" : "inherit";++ // Extract raw team states from the combined result+ const teamStates = teamIds.map((teamId) => teamStatesById[teamId] ?? "inherit");++ const userState = userStates[featureId] ?? "inherit";++ // Get auto-opt-in flags for this feature's hierarchy+ const orgAutoOptIn = orgId !== null ? teamsAutoOptIn[orgId] ?? false : false;+ const teamAutoOptIns = teamIds.map((teamId) => teamsAutoOptIn[teamId] ?? false);++ // Apply auto-opt-in transformation+ const { effectiveOrgState, effectiveTeamStates, effectiveUserState } = applyAutoOptIn({+ orgState,+ teamStates,+ userState,+ orgAutoOptIn,+ teamAutoOptIns,+ userAutoOptIn,+ });++ // Compute effective state with transformed states+ const effectiveEnabled = computeEffectiveStateAcrossTeams({+ globalEnabled,+ orgState: effectiveOrgState,+ teamStates: effectiveTeamStates,+ userState: effectiveUserState,+ });++ resolvedStates[featureId] = {+ featureId,+ globalEnabled,+ orgState, // Raw state (before auto-opt-in transform)+ teamStates, // Raw states+ userState, // Raw state+ effectiveEnabled,+ // Auto-opt-in flags for UI+ orgAutoOptIn,+ teamAutoOptIns,+ userAutoOptIn,+ };+ }++ return resolvedStates;+ }++ /**+ * List all opt-in features with their states for a user across teams.+ * Only returns features that are in the allowlist and globally enabled.+ */+ async listFeaturesForUser(input: { userId: number; orgId: number | null; teamIds: number[] }) {+ const { userId, orgId, teamIds } = input;+ const featureIds = OPT_IN_FEATURES.map((config) => config.slug);++ const resolvedStates = await this.resolveFeatureStatesAcrossTeams({+ userId,+ orgId,+ teamIds,+ featureIds,+ });++ return featureIds.map((featureId) => resolvedStates[featureId]).filter((state) => state.globalEnabled);+ }++ /**+ * List all opt-in features with their raw states for a team.+ * Used for team admin settings page to configure feature opt-in.+ * Only returns features that are in the allowlist and globally enabled.+ */+ async listFeaturesForTeam(input: { teamId: number }) {+ const { teamId } = input;++ const [allFeatures, teamStates] = await Promise.all([+ this.featuresRepository.getAllFeatures(),+ // Get all team feature states in a single query+ this.featuresRepository.getTeamsFeatureStates({+ teamIds: [teamId],+ featureIds: OPT_IN_FEATURES.map((config) => config.slug),+ }),+ ]);++ const results = OPT_IN_FEATURES.map((config) => {+ const globalFeature = allFeatures.find((f) => f.slug === config.slug);+ const globalEnabled = globalFeature?.enabled ?? false;+ const teamState = teamStates[config.slug]?.[teamId] ?? "inherit";++ return {+ featureId: config.slug,+ globalEnabled,+ teamState,+ };+ });++ return results.filter((result) => result.globalEnabled);+ }++ /**+ * Set user's feature state.+ * Delegates to FeaturesRepository.setUserFeatureState.+ */+ async setUserFeatureState(+ input:+ | { userId: number; featureId: FeatureId; state: "enabled" | "disabled"; assignedBy: number }+ | { userId: number; featureId: FeatureId; state: "inherit" }+ ) {+ const { userId, featureId, state } = input;+ if (state === "inherit") {+ await this.featuresRepository.setUserFeatureState({+ userId,+ featureId,+ state,+ });+ } else {+ const { assignedBy } = input;+ await this.featuresRepository.setUserFeatureState({+ userId,+ featureId,+ state,+ assignedBy: `user-${assignedBy}`,+ });+ }+ }++ /**+ * Set team's feature state.+ * Delegates to FeaturesRepository.setTeamFeatureState.+ */+ async setTeamFeatureState(+ input:+ | { teamId: number; featureId: FeatureId; state: "enabled" | "disabled"; assignedBy: number }+ | { teamId: number; featureId: FeatureId; state: "inherit" }+ ) {+ const { teamId, featureId, state } = input;+ if (state === "inherit") {+ await this.featuresRepository.setTeamFeatureState({+ teamId,+ featureId,+ state,+ });+ } else {+ const { assignedBy } = input;+ await this.featuresRepository.setTeamFeatureState({+ teamId,+ featureId,+ state,+ assignedBy: `user-${assignedBy}`,+ });+ }+ }+}diff --git a/packages/features/flags/config.ts b/packages/features/flags/config.tsindex 43d0e2033ad..2b20975c91b 100644--- a/packages/features/flags/config.ts+++ b/packages/features/flags/config.ts@@ -38,4 +38,12 @@ export type AppFlags = {export type TeamFeatures = Record<keyof AppFlags, boolean>;+/**+ * Explicit state for API/UI layer.+ * - "enabled": row with enabled = true+ * - "disabled": row with enabled = false+ * - "inherit": no row+ */export type FeatureState = "enabled" | "disabled" | "inherit";++export type FeatureId = keyof AppFlags;diff --git a/packages/features/flags/features.repository.integration-test.ts b/packages/features/flags/features.repository.integration-test.tsindex 9c340744c93..6a41bc732e5 100644--- a/packages/features/flags/features.repository.integration-test.ts+++ b/packages/features/flags/features.repository.integration-test.ts@@ -1,94 +1,102 @@-import { describe, expect, beforeAll, afterAll, beforeEach, it } from "vitest";+import { afterEach, describe, expect, it } from "vitest";import { prisma } from "@calcom/prisma";-import type { AppFlags } from "./config";+import type { FeatureId } from "./config";import { FeaturesRepository } from "./features.repository";-const featuresRepository = new FeaturesRepository(prisma);+// Helper to generate unique identifiers per test+const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;-// Access private clearCache method through type assertion-const clearCache = () => {- (featuresRepository as unknown as { clearCache: () => void }).clearCache();-};+// Store cleanup functions to ensure they run even if tests fail+const cleanupFunctions: Array<() => Promise<void>> = [];-describe("FeaturesRepository Integration Tests", () => {- let testUser: { id: number };- let testTeam: { id: number };- const testFeature = "teams" as keyof AppFlags;-- beforeAll(async () => {- // Create test user- testUser = await prisma.user.create({- data: {- email: `test-${Date.now()}@example.com`,- username: `test-${Date.now()}`,- },- });-- // Create test team- testTeam = await prisma.team.create({- data: {- name: `Test Team ${Date.now()}`,- slug: `test-team-${Date.now()}`,- },- });+afterEach(async () => {+ for (const cleanup of cleanupFunctions) {+ await cleanup();+ }+ cleanupFunctions.length = 0;+});++interface TestEntities {+ user: { id: number };+ team: { id: number };+ testFeature: FeatureId;+ featuresRepository: FeaturesRepository;+ clearCache: () => void;+}++/**+ * Creates isolated test entities (user, team) and returns them along with a cleanup function.+ * Each test gets its own entities, ensuring complete isolation even when tests run in parallel.+ */+async function setup(): Promise<TestEntities> {+ const id = uniqueId();+ const testFeature = `test-feature-${id}` as FeatureId;++ // Create test user+ const user = await prisma.user.create({+ data: {+ email: `test-${id}@example.com`,+ username: `test-${id}`,+ },});- afterAll(async () => {- // Clean up test data in correct order to respect foreign key constraints+ // Create test team+ const team = await prisma.team.create({+ data: {+ name: `Test Team ${id}`,+ slug: `test-team-${id}`,+ },+ });++ const featuresRepository = new FeaturesRepository(prisma);++ // Access private clearCache method through type assertion+ const clearCache = () => {+ (featuresRepository as unknown as { clearCache: () => void }).clearCache();+ };++ // Cleanup function - automatically registered with afterEach+ const cleanup = async () => {+ // Clean up in correct order to respect foreign key constraintsawait prisma.userFeatures.deleteMany({- where: { userId: testUser.id },+ where: { userId: user.id },});await prisma.teamFeatures.deleteMany({- where: { teamId: testTeam.id },+ where: { teamId: team.id },});await prisma.feature.deleteMany({where: { slug: testFeature },});await prisma.membership.deleteMany({- where: { userId: testUser.id },+ where: { userId: user.id },});await prisma.team.deleteMany({- where: { id: testTeam.id },+ where: { id: team.id },});await prisma.user.delete({- where: { id: testUser.id },+ where: { id: user.id },});- });+ };- beforeEach(async () => {- // Reset feature state before each test- await prisma.feature.deleteMany({- where: { slug: testFeature },- });- await prisma.userFeatures.deleteMany({- where: { userId: testUser.id },- });- await prisma.teamFeatures.deleteMany({- where: { teamId: testTeam.id },- });- await prisma.membership.deleteMany({- where: { teamId: testTeam.id },- });- await prisma.team.deleteMany({- where: { id: testTeam.id },- });-- // Recreate test team- testTeam = await prisma.team.create({- data: {- name: `Test Team ${Date.now()}`,- slug: `test-team-${Date.now()}`,- },- });+ // Register cleanup to run automatically after each test+ cleanupFunctions.push(cleanup);- // Clear the feature flag cache- clearCache();- });+ return {+ user,+ team,+ testFeature,+ featuresRepository,+ clearCache,+ };+}+describe("FeaturesRepository Integration Tests", () => {describe("checkIfFeatureIsEnabledGlobally", () => {it("should return false when feature is not enabled globally", async () => {+ const { testFeature, featuresRepository } = await setup();+// Verify database stateconst dbFeature = await prisma.feature.findUnique({where: { slug: testFeature },@@ -103,6 +111,8 @@ describe("FeaturesRepository Integration Tests", () => {});it("should return true when feature is enabled globally", async () => {+ const { testFeature, featuresRepository, clearCache } = await setup();+// Create the feature with enabled set to trueawait prisma.feature.create({data: {@@ -132,11 +142,15 @@ describe("FeaturesRepository Integration Tests", () => {describe("checkIfUserHasFeature", () => {it("should return false when user does not have feature", async () => {- const result = await featuresRepository.checkIfUserHasFeature(testUser.id, testFeature);+ const { user, testFeature, featuresRepository } = await setup();++ const result = await featuresRepository.checkIfUserHasFeature(user.id, testFeature);expect(result).toBe(false);});it("should return false when no UserFeatures row and no TeamFeatures row exist (tri-state inheritance)", async () => {+ const { user, team, testFeature, featuresRepository } = await setup();+// Create the feature globallyawait prisma.feature.create({data: {@@ -149,19 +163,21 @@ describe("FeaturesRepository Integration Tests", () => {// User is a member of a teamawait prisma.membership.create({data: {- teamId: testTeam.id,- userId: testUser.id,+ teamId: team.id,+ userId: user.id,role: "MEMBER",accepted: true,},});// No UserFeatures row, no TeamFeatures row - should return false- const result = await featuresRepository.checkIfUserHasFeature(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeature(user.id, testFeature);expect(result).toBe(false);});it("should return true when user has feature directly assigned", async () => {+ const { user, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -172,18 +188,20 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.userFeatures.create({data: {- userId: testUser.id,+ userId: user.id,featureId: testFeature,assignedBy: "test",enabled: true,},});- const result = await featuresRepository.checkIfUserHasFeature(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeature(user.id, testFeature);expect(result).toBe(true);});it("should return false when user has feature with enabled=false (tri-state)", async () => {+ const { user, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -194,18 +212,20 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.userFeatures.create({data: {- userId: testUser.id,+ userId: user.id,featureId: testFeature,enabled: false,assignedBy: "test",},});- const result = await featuresRepository.checkIfUserHasFeature(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeature(user.id, testFeature);expect(result).toBe(false);});it("should return false when user has enabled=false even if team has feature (tri-state blocks inheritance)", async () => {+ const { user, team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -217,7 +237,7 @@ describe("FeaturesRepository Integration Tests", () => {// Team has the feature enabledawait prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: true,assignedBy: "test",@@ -227,8 +247,8 @@ describe("FeaturesRepository Integration Tests", () => {// User is a member of the teamawait prisma.membership.create({data: {- teamId: testTeam.id,- userId: testUser.id,+ teamId: team.id,+ userId: user.id,role: "MEMBER",accepted: true,},@@ -237,18 +257,20 @@ describe("FeaturesRepository Integration Tests", () => {// But user has explicitly disabled the featureawait prisma.userFeatures.create({data: {- userId: testUser.id,+ userId: user.id,featureId: testFeature,enabled: false,assignedBy: "test",},});- const result = await featuresRepository.checkIfUserHasFeature(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeature(user.id, testFeature);expect(result).toBe(false);});it("should return true when user belongs to team with feature", async () => {+ const { user, team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -259,7 +281,7 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,assignedBy: "test",enabled: true,@@ -268,18 +290,20 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.membership.create({data: {- teamId: testTeam.id,- userId: testUser.id,+ teamId: team.id,+ userId: user.id,role: "MEMBER",accepted: true,},});- const result = await featuresRepository.checkIfUserHasFeature(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeature(user.id, testFeature);expect(result).toBe(true);});it("should return false when user belongs to team with feature disabled (tri-state)", async () => {+ const { user, team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -291,7 +315,7 @@ describe("FeaturesRepository Integration Tests", () => {// Team has the feature explicitly disabledawait prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: false,assignedBy: "test",@@ -300,30 +324,32 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.membership.create({data: {- teamId: testTeam.id,- userId: testUser.id,+ teamId: team.id,+ userId: user.id,role: "MEMBER",accepted: true,},});- const result = await featuresRepository.checkIfUserHasFeature(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeature(user.id, testFeature);expect(result).toBe(false);});it("should return true when user belongs to team where parent team has feature", async () => {+ const { user, team, testFeature, featuresRepository, clearCache } = await setup();+// Create an organizationconst org = await prisma.team.create({data: {- name: `Test Org ${Date.now()}`,- slug: `test-org-${Date.now()}`,+ name: `Test Org ${uniqueId()}`,+ slug: `test-org-${uniqueId()}`,isOrganization: true,},});// Make the test team part of the organizationawait prisma.team.update({- where: { id: testTeam.id },+ where: { id: team.id },data: { parentId: org.id },});@@ -349,33 +375,27 @@ describe("FeaturesRepository Integration Tests", () => {},});- // Check if user is already a member of the team- const existingMembership = await prisma.membership.findFirst({- where: {- teamId: testTeam.id,- userId: testUser.id,+ // Create membership+ await prisma.membership.create({+ data: {+ teamId: team.id,+ userId: user.id,+ role: "MEMBER",+ accepted: true,},});- // Only create membership if it doesn't exist- if (!existingMembership) {- await prisma.membership.create({- data: {- teamId: testTeam.id,- userId: testUser.id,- role: "MEMBER",- accepted: true,- },- });- }-- const result = await featuresRepository.checkIfUserHasFeature(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeature(user.id, testFeature);expect(result).toBe(true);// Clean up organizationawait prisma.teamFeatures.deleteMany({where: { teamId: org.id },});+ await prisma.team.update({+ where: { id: team.id },+ data: { parentId: null },+ });await prisma.team.delete({where: { id: org.id },});@@ -384,11 +404,15 @@ describe("FeaturesRepository Integration Tests", () => {describe("checkIfTeamHasFeature", () => {it("should return false when team does not have feature", async () => {- const result = await featuresRepository.checkIfTeamHasFeature(testTeam.id, testFeature);+ const { team, testFeature, featuresRepository } = await setup();++ const result = await featuresRepository.checkIfTeamHasFeature(team.id, testFeature);expect(result).toBe(false);});it("should return true when team has feature directly assigned", async () => {+ const { team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -399,18 +423,20 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,assignedBy: "test",enabled: true,},});- const result = await featuresRepository.checkIfTeamHasFeature(testTeam.id, testFeature);+ const result = await featuresRepository.checkIfTeamHasFeature(team.id, testFeature);expect(result).toBe(true);});it("should return false when team has feature with enabled=false (tri-state)", async () => {+ const { team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -421,27 +447,29 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: false,assignedBy: "test",},});- const result = await featuresRepository.checkIfTeamHasFeature(testTeam.id, testFeature);+ const result = await featuresRepository.checkIfTeamHasFeature(team.id, testFeature);expect(result).toBe(false);});it("should return true when parent team has feature", async () => {+ const { team, testFeature, featuresRepository } = await setup();+const parentTeam = await prisma.team.create({data: {- name: `Parent Team ${Date.now()}`,- slug: `parent-team-${Date.now()}`,+ name: `Parent Team ${uniqueId()}`,+ slug: `parent-team-${uniqueId()}`,},});await prisma.team.update({- where: { id: testTeam.id },+ where: { id: team.id },data: { parentId: parentTeam.id },});@@ -462,28 +490,34 @@ describe("FeaturesRepository Integration Tests", () => {},});- const result = await featuresRepository.checkIfTeamHasFeature(testTeam.id, testFeature);+ const result = await featuresRepository.checkIfTeamHasFeature(team.id, testFeature);expect(result).toBe(true);// Clean up parent teamawait prisma.teamFeatures.deleteMany({where: { teamId: parentTeam.id },});+ await prisma.team.update({+ where: { id: team.id },+ data: { parentId: null },+ });await prisma.team.delete({where: { id: parentTeam.id },});});it("should return false when parent has feature with enabled=false (tri-state)", async () => {+ const { team, testFeature, featuresRepository } = await setup();+const parentTeam = await prisma.team.create({data: {- name: `Parent Team ${Date.now()}`,- slug: `parent-team-${Date.now()}`,+ name: `Parent Team ${uniqueId()}`,+ slug: `parent-team-${uniqueId()}`,},});await prisma.team.update({- where: { id: testTeam.id },+ where: { id: team.id },data: { parentId: parentTeam.id },});@@ -505,13 +539,17 @@ describe("FeaturesRepository Integration Tests", () => {},});- const result = await featuresRepository.checkIfTeamHasFeature(testTeam.id, testFeature);+ const result = await featuresRepository.checkIfTeamHasFeature(team.id, testFeature);expect(result).toBe(false);// Clean up parent teamawait prisma.teamFeatures.deleteMany({where: { teamId: parentTeam.id },});+ await prisma.team.update({+ where: { id: team.id },+ data: { parentId: null },+ });await prisma.team.delete({where: { id: parentTeam.id },});@@ -520,11 +558,15 @@ describe("FeaturesRepository Integration Tests", () => {describe("checkIfUserHasFeatureNonHierarchical", () => {it("should return false when user does not have feature", async () => {- const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(testUser.id, testFeature);+ const { user, testFeature, featuresRepository } = await setup();++ const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(user.id, testFeature);expect(result).toBe(false);});it("should return true when user has feature directly assigned", async () => {+ const { user, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -535,18 +577,20 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.userFeatures.create({data: {- userId: testUser.id,+ userId: user.id,featureId: testFeature,enabled: true,assignedBy: "test",},});- const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(user.id, testFeature);expect(result).toBe(true);});it("should return false when user has feature with enabled=false (tri-state)", async () => {+ const { user, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -557,18 +601,20 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.userFeatures.create({data: {- userId: testUser.id,+ userId: user.id,featureId: testFeature,enabled: false,assignedBy: "test",},});- const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(user.id, testFeature);expect(result).toBe(false);});it("should return true when user belongs to direct team with feature (non-hierarchical)", async () => {+ const { user, team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -579,7 +625,7 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: true,assignedBy: "test",@@ -588,18 +634,20 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.membership.create({data: {- teamId: testTeam.id,- userId: testUser.id,+ teamId: team.id,+ userId: user.id,role: "MEMBER",accepted: true,},});- const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(user.id, testFeature);expect(result).toBe(true);});it("should return false when user belongs to direct team with feature disabled (tri-state)", async () => {+ const { user, team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -610,7 +658,7 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: false,assignedBy: "test",@@ -619,20 +667,22 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.membership.create({data: {- teamId: testTeam.id,- userId: testUser.id,+ teamId: team.id,+ userId: user.id,role: "MEMBER",accepted: true,},});- const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(testUser.id, testFeature);+ const result = await featuresRepository.checkIfUserHasFeatureNonHierarchical(user.id, testFeature);expect(result).toBe(false);});});describe("setTeamFeatureState", () => {it("should create a new TeamFeatures row with enabled=true", async () => {+ const { team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -641,12 +691,17 @@ describe("FeaturesRepository Integration Tests", () => {},});- await featuresRepository.setTeamFeatureState(testTeam.id, testFeature, "enabled", "test-assigner");+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test-assigner",+ });const teamFeature = await prisma.teamFeatures.findUnique({where: {teamId_featureId: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,},},@@ -658,6 +713,8 @@ describe("FeaturesRepository Integration Tests", () => {});it("should update existing TeamFeatures row to enabled=true", async () => {+ const { team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -669,7 +726,7 @@ describe("FeaturesRepository Integration Tests", () => {// Create with enabled=false firstawait prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: false,assignedBy: "original-assigner",@@ -677,12 +734,17 @@ describe("FeaturesRepository Integration Tests", () => {});// Now enable the feature- await featuresRepository.setTeamFeatureState(testTeam.id, testFeature, "enabled", "new-assigner");+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "new-assigner",+ });const teamFeature = await prisma.teamFeatures.findUnique({where: {teamId_featureId: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,},},@@ -694,6 +756,8 @@ describe("FeaturesRepository Integration Tests", () => {});it("should create a new TeamFeatures row with enabled=false", async () => {+ const { team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -702,12 +766,17 @@ describe("FeaturesRepository Integration Tests", () => {},});- await featuresRepository.setTeamFeatureState(testTeam.id, testFeature, "disabled", "test-assigner");+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test-assigner",+ });const teamFeature = await prisma.teamFeatures.findUnique({where: {teamId_featureId: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,},},@@ -719,6 +788,8 @@ describe("FeaturesRepository Integration Tests", () => {});it("should update existing TeamFeatures row to enabled=false", async () => {+ const { team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -730,7 +801,7 @@ describe("FeaturesRepository Integration Tests", () => {// Create with enabled=true firstawait prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: true,assignedBy: "original-assigner",@@ -738,12 +809,17 @@ describe("FeaturesRepository Integration Tests", () => {});// Now disable the feature- await featuresRepository.setTeamFeatureState(testTeam.id, testFeature, "disabled", "new-assigner");+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "new-assigner",+ });const teamFeature = await prisma.teamFeatures.findUnique({where: {teamId_featureId: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,},},@@ -755,6 +831,8 @@ describe("FeaturesRepository Integration Tests", () => {});it("should delete TeamFeatures row when state is inherit", async () => {+ const { team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -766,7 +844,7 @@ describe("FeaturesRepository Integration Tests", () => {// Create a TeamFeatures row firstawait prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: true,assignedBy: "original-assigner",@@ -777,7 +855,7 @@ describe("FeaturesRepository Integration Tests", () => {const beforeDelete = await prisma.teamFeatures.findUnique({where: {teamId_featureId: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,},},@@ -785,12 +863,16 @@ describe("FeaturesRepository Integration Tests", () => {expect(beforeDelete).not.toBeNull();// Now set to inherit - should delete the row- await featuresRepository.setTeamFeatureState(testTeam.id, testFeature, "inherit", "test-assigner");+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "inherit",+ });const teamFeature = await prisma.teamFeatures.findUnique({where: {teamId_featureId: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,},},@@ -800,6 +882,8 @@ describe("FeaturesRepository Integration Tests", () => {});it("should handle inherit state when no TeamFeatures row exists", async () => {+ const { team, testFeature, featuresRepository } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -809,12 +893,16 @@ describe("FeaturesRepository Integration Tests", () => {});// Call inherit without any existing row - should not throw- await featuresRepository.setTeamFeatureState(testTeam.id, testFeature, "inherit", "test-assigner");+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: testFeature,+ state: "inherit",+ });const teamFeature = await prisma.teamFeatures.findUnique({where: {teamId_featureId: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,},},@@ -826,6 +914,8 @@ describe("FeaturesRepository Integration Tests", () => {describe("getTeamsWithFeatureEnabled", () => {it("should return empty array when no teams have the feature", async () => {+ const { testFeature, featuresRepository, clearCache } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -841,6 +931,8 @@ describe("FeaturesRepository Integration Tests", () => {});it("should return teams with enabled=true only", async () => {+ const { team, testFeature, featuresRepository, clearCache } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -852,15 +944,15 @@ describe("FeaturesRepository Integration Tests", () => {// Create a second teamconst secondTeam = await prisma.team.create({data: {- name: `Second Team ${Date.now()}`,- slug: `second-team-${Date.now()}`,+ name: `Second Team ${uniqueId()}`,+ slug: `second-team-${uniqueId()}`,},});- // testTeam has feature enabled+ // team has feature enabledawait prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: true,assignedBy: "test",@@ -880,7 +972,7 @@ describe("FeaturesRepository Integration Tests", () => {clearCache();const result = await featuresRepository.getTeamsWithFeatureEnabled(testFeature);- expect(result).toContain(testTeam.id);+ expect(result).toContain(team.id);expect(result).not.toContain(secondTeam.id);// Clean up second team@@ -893,6 +985,8 @@ describe("FeaturesRepository Integration Tests", () => {});it("should return empty array when feature is not globally enabled", async () => {+ const { team, testFeature, featuresRepository, clearCache } = await setup();+await prisma.feature.create({data: {slug: testFeature,@@ -903,7 +997,7 @@ describe("FeaturesRepository Integration Tests", () => {await prisma.teamFeatures.create({data: {- teamId: testTeam.id,+ teamId: team.id,featureId: testFeature,enabled: true,assignedBy: "test",@@ -916,4 +1010,574 @@ describe("FeaturesRepository Integration Tests", () => {expect(result).toEqual([]);});});++ describe("setUserFeatureState", () => {+ it("should create a new UserFeatures row with enabled=true when state is 'enabled'", async () => {+ const { user, testFeature, featuresRepository } = await setup();++ await prisma.feature.create({+ data: {+ slug: testFeature,+ enabled: true,+ type: "OPERATIONAL",+ },+ });++ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "test-assigner",+ });++ const userFeature = await prisma.userFeatures.findFirst({+ where: {+ userId: user.id,+ featureId: testFeature,+ },+ });++ expect(userFeature).not.toBeNull();+ expect(userFeature?.enabled).toBe(true);+ expect(userFeature?.assignedBy).toBe("test-assigner");+ });++ it("should create a new UserFeatures row with enabled=false when state is 'disabled'", async () => {+ const { user, testFeature, featuresRepository } = await setup();++ await prisma.feature.create({+ data: {+ slug: testFeature,+ enabled: true,+ type: "OPERATIONAL",+ },+ });++ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "disabled",+ assignedBy: "test-assigner",+ });++ const userFeature = await prisma.userFeatures.findFirst({+ where: {+ userId: user.id,+ featureId: testFeature,+ },+ });++ expect(userFeature).not.toBeNull();+ expect(userFeature?.enabled).toBe(false);+ expect(userFeature?.assignedBy).toBe("test-assigner");+ });++ it("should update existing UserFeatures row", async () => {+ const { user, testFeature, featuresRepository } = await setup();++ await prisma.feature.create({+ data: {+ slug: testFeature,+ enabled: true,+ type: "OPERATIONAL",+ },+ });++ // Create with enabled=false first+ await prisma.userFeatures.create({+ data: {+ userId: user.id,+ featureId: testFeature,+ enabled: false,+ assignedBy: "original-assigner",+ },+ });++ // Now enable the feature+ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "enabled",+ assignedBy: "new-assigner",+ });++ const userFeature = await prisma.userFeatures.findFirst({+ where: {+ userId: user.id,+ featureId: testFeature,+ },+ });++ expect(userFeature).not.toBeNull();+ expect(userFeature?.enabled).toBe(true);+ expect(userFeature?.assignedBy).toBe("new-assigner");+ });++ it("should delete the row when state is 'inherit'", async () => {+ const { user, testFeature, featuresRepository } = await setup();++ await prisma.feature.create({+ data: {+ slug: testFeature,+ enabled: true,+ type: "OPERATIONAL",+ },+ });++ // Create a row first+ await prisma.userFeatures.create({+ data: {+ userId: user.id,+ featureId: testFeature,+ enabled: true,+ assignedBy: "test",+ },+ });++ // Set to inherit (should delete)+ await featuresRepository.setUserFeatureState({+ userId: user.id,+ featureId: testFeature,+ state: "inherit",+ });++ const userFeature = await prisma.userFeatures.findFirst({+ where: {+ userId: user.id,+ featureId: testFeature,+ },+ });++ expect(userFeature).toBeNull();+ });+ });++ describe("getUserFeatureStates", () => {+ it("should return 'inherit' when user has no feature row", async () => {+ const { user, testFeature, featuresRepository } = await setup();++ const result = await featuresRepository.getUserFeatureStates({+ userId: user.id,+ featureIds: [testFeature],+ });++ expect(result[testFeature]).toBe("inherit");+ });++ it("should return 'enabled' when user has feature enabled", async () => {+ const { user, testFeature, featuresRepository } = await setup();++ await prisma.feature.create({+ data: {+ slug: testFeature,+ enabled: true,+ type: "OPERATIONAL",+ },+ });++ await prisma.userFeatures.create({+ data: {+ userId: user.id,+ featureId: testFeature,+ enabled: true,+ assignedBy: "test",+ },+ });++ const result = await featuresRepository.getUserFeatureStates({+ userId: user.id,+ featureIds: [testFeature],+ });++ expect(result[testFeature]).toBe("enabled");+ });++ it("should return 'disabled' when user has feature disabled", async () => {+ const { user, testFeature, featuresRepository } = await setup();++ await prisma.feature.create({+ data: {+ slug: testFeature,+ enabled: true,+ type: "OPERATIONAL",+ },+ });++ await prisma.userFeatures.create({+ data: {+ userId: user.id,+ featureId: testFeature,+ enabled: false,+ assignedBy: "test",+ },+ });++ const result = await featuresRepository.getUserFeatureStates({+ userId: user.id,+ featureIds: [testFeature],+ });++ expect(result[testFeature]).toBe("disabled");+ });++ it("should return states for multiple features in a single query", async () => {+ const { user, testFeature, featuresRepository } = await setup();+ const testFeature2 = `${testFeature}-2` as FeatureId;++ await prisma.feature.createMany({+ data: [+ { slug: testFeature, enabled: true, type: "OPERATIONAL" },+ { slug: testFeature2, enabled: true, type: "OPERATIONAL" },+ ],+ });++ await prisma.userFeatures.createMany({+ data: [+ { userId: user.id, featureId: testFeature, enabled: true, assignedBy: "test" },+ { userId: user.id, featureId: testFeature2, enabled: false, assignedBy: "test" },+ ],+ });++ const result = await featuresRepository.getUserFeatureStates({+ userId: user.id,+ featureIds: [testFeature, testFeature2],+ });++ expect(result[testFeature]).toBe("enabled");+ expect(result[testFeature2]).toBe("disabled");++ // Clean up extra feature+ await prisma.userFeatures.deleteMany({+ where: { userId: user.id, featureId: testFeature2 },+ });+ await prisma.feature.deleteMany({+ where: { slug: testFeature2 },+ });+ });+ });++ describe("getTeamsFeatureStates", () => {+ it("should return empty object for empty teamIds array", async () => {+ const { testFeature, featuresRepository } = await setup();++ const result = await featuresRepository.getTeamsFeatureStates({+ teamIds: [],+ featureIds: [testFeature],+ });++ expect(result).toEqual({});+ });++ it("should return inherit (missing key) when team has no feature row", async () => {+ const { team, testFeature, featuresRepository } = await setup();++ const result = await featuresRepository.getTeamsFeatureStates({+ teamIds: [team.id],+ featureIds: [testFeature],+ });++ // Teams without explicit state are not in the result (caller should default to 'inherit')+ expect(result[testFeature]?.[team.id]).toBeUndefined();+ });++ it("should return 'enabled' when team has feature enabled", async () => {+ const { team, testFeature, featuresRepository } = await setup();++ await prisma.feature.create({+ data: { slug: testFeature, enabled: true, type: "OPERATIONAL" },+ });++ await prisma.teamFeatures.create({+ data: {+ teamId: team.id,+ featureId: testFeature,+ enabled: true,+ assignedBy: "test",+ },+ });++ const result = await featuresRepository.getTeamsFeatureStates({+ teamIds: [team.id],+ featureIds: [testFeature],+ });++ expect(result[testFeature]?.[team.id]).toBe("enabled");+ });++ it("should return 'disabled' when team has feature disabled", async () => {+ const { team, testFeature, featuresRepository } = await setup();++ await prisma.feature.create({+ data: { slug: testFeature, enabled: true, type: "OPERATIONAL" },+ });++ await prisma.teamFeatures.create({+ data: {+ teamId: team.id,+ featureId: testFeature,+ enabled: false,+ assignedBy: "test",+ },+ });++ const result = await featuresRepository.getTeamsFeatureStates({+ teamIds: [team.id],+ featureIds: [testFeature],+ });++ expect(result[testFeature]?.[team.id]).toBe("disabled");+ });++ it("should return states for multiple teams in a single query", async () => {+ const { team, testFeature, featuresRepository } = await setup();++ const secondTeam = await prisma.team.create({+ data: { name: `Second Test Team ${uniqueId()}`, slug: `second-test-team-${uniqueId()}` },+ });++ await prisma.feature.create({+ data: { slug: testFeature, enabled: true, type: "OPERATIONAL" },+ });++ await prisma.teamFeatures.createMany({+ data: [+ { teamId: team.id, featureId: testFeature, enabled: true, assignedBy: "test" },+ { teamId: secondTeam.id, featureId: testFeature, enabled: false, assignedBy: "test" },+ ],+ });++ const result = await featuresRepository.getTeamsFeatureStates({+ teamIds: [team.id, secondTeam.id],+ featureIds: [testFeature],+ });++ expect(result[testFeature]?.[team.id]).toBe("enabled");+ expect(result[testFeature]?.[secondTeam.id]).toBe("disabled");++ // Clean up+ await prisma.teamFeatures.deleteMany({+ where: { teamId: secondTeam.id },+ });+ await prisma.team.delete({+ where: { id: secondTeam.id },+ });+ });++ it("should only return teams with explicit state, not all requested teams", async () => {+ const { team, testFeature, featuresRepository } = await setup();++ const secondTeam = await prisma.team.create({+ data: { name: `Second Test Team ${uniqueId()}`, slug: `second-test-team-${uniqueId()}` },+ });++ await prisma.feature.create({+ data: { slug: testFeature, enabled: true, type: "OPERATIONAL" },+ });++ // Only set feature for team, not secondTeam+ await prisma.teamFeatures.create({+ data: {+ teamId: team.id,+ featureId: testFeature,+ enabled: true,+ assignedBy: "test",+ },+ });++ const result = await featuresRepository.getTeamsFeatureStates({+ teamIds: [team.id, secondTeam.id],+ featureIds: [testFeature],+ });++ expect(result[testFeature]?.[team.id]).toBe("enabled");+ expect(result[testFeature]?.[secondTeam.id]).toBeUndefined(); // Not in result, caller defaults to 'inherit'++ // Clean up+ await prisma.team.delete({+ where: { id: secondTeam.id },+ });+ });++ it("should return states for multiple features across teams", async () => {+ const { team, testFeature, featuresRepository } = await setup();+ const secondFeature = `${testFeature}-two` as FeatureId;++ await prisma.feature.createMany({+ data: [+ { slug: testFeature, enabled: true, type: "OPERATIONAL" },+ { slug: secondFeature, enabled: true, type: "OPERATIONAL" },+ ],+ });++ await prisma.teamFeatures.createMany({+ data: [+ { teamId: team.id, featureId: testFeature, enabled: true, assignedBy: "test" },+ { teamId: team.id, featureId: secondFeature, enabled: false, assignedBy: "test" },+ ],+ });++ const result = await featuresRepository.getTeamsFeatureStates({+ teamIds: [team.id],+ featureIds: [testFeature, secondFeature],+ });++ expect(result[testFeature]?.[team.id]).toBe("enabled");+ expect(result[secondFeature]?.[team.id]).toBe("disabled");++ await prisma.teamFeatures.deleteMany({+ where: { teamId: team.id, featureId: { in: [testFeature, secondFeature] } },+ });+ await prisma.feature.deleteMany({+ where: { slug: secondFeature },+ });+ });+ });++ describe("getUserAutoOptIn", () => {+ it("should return false when user has autoOptInFeatures=false (default)", async () => {+ const { user, featuresRepository } = await setup();++ const result = await featuresRepository.getUserAutoOptIn(user.id);+ expect(result).toBe(false);+ });++ it("should return true when user has autoOptInFeatures=true", async () => {+ const { user, featuresRepository } = await setup();++ await prisma.user.update({+ where: { id: user.id },+ data: { autoOptInFeatures: true },+ });++ const result = await featuresRepository.getUserAutoOptIn(user.id);+ expect(result).toBe(true);+ });++ it("should return false for non-existent user", async () => {+ const { featuresRepository } = await setup();++ const result = await featuresRepository.getUserAutoOptIn(999999);+ expect(result).toBe(false);+ });+ });++ describe("getTeamsAutoOptIn", () => {+ it("should return empty object for empty teamIds array", async () => {+ const { featuresRepository } = await setup();++ const result = await featuresRepository.getTeamsAutoOptIn([]);+ expect(result).toEqual({});+ });++ it("should return false for team with autoOptInFeatures=false (default)", async () => {+ const { team, featuresRepository } = await setup();++ const result = await featuresRepository.getTeamsAutoOptIn([team.id]);+ expect(result[team.id]).toBe(false);+ });++ it("should return true for team with autoOptInFeatures=true", async () => {+ const { team, featuresRepository } = await setup();++ await prisma.team.update({+ where: { id: team.id },+ data: { autoOptInFeatures: true },+ });++ const result = await featuresRepository.getTeamsAutoOptIn([team.id]);+ expect(result[team.id]).toBe(true);+ });++ it("should return values for multiple teams in a single query", async () => {+ const { team, featuresRepository } = await setup();++ const secondTeam = await prisma.team.create({+ data: {+ name: `Second Team ${uniqueId()}`,+ slug: `second-team-auto-opt-in-${uniqueId()}`,+ autoOptInFeatures: true,+ },+ });++ // team has autoOptInFeatures=false (default)+ // secondTeam has autoOptInFeatures=true++ const result = await featuresRepository.getTeamsAutoOptIn([team.id, secondTeam.id]);+ expect(result[team.id]).toBe(false);+ expect(result[secondTeam.id]).toBe(true);++ // Clean up+ await prisma.team.delete({+ where: { id: secondTeam.id },+ });+ });++ it("should not include non-existent teams in result", async () => {+ const { team, featuresRepository } = await setup();++ const result = await featuresRepository.getTeamsAutoOptIn([team.id, 999999]);+ expect(result[team.id]).toBe(false);+ expect(result[999999]).toBeUndefined();+ });+ });++ describe("setUserAutoOptIn", () => {+ it("should set autoOptInFeatures to true", async () => {+ const { user, featuresRepository } = await setup();++ // Ensure user starts with false+ const before = await featuresRepository.getUserAutoOptIn(user.id);+ expect(before).toBe(false);++ await featuresRepository.setUserAutoOptIn(user.id, true);++ const after = await featuresRepository.getUserAutoOptIn(user.id);+ expect(after).toBe(true);+ });++ it("should set autoOptInFeatures to false", async () => {+ const { user, featuresRepository } = await setup();++ // First set to true+ await featuresRepository.setUserAutoOptIn(user.id, true);+ const before = await featuresRepository.getUserAutoOptIn(user.id);+ expect(before).toBe(true);++ // Now set to false+ await featuresRepository.setUserAutoOptIn(user.id, false);++ const after = await featuresRepository.getUserAutoOptIn(user.id);+ expect(after).toBe(false);+ });+ });++ describe("setTeamAutoOptIn", () => {+ it("should set autoOptInFeatures to true", async () => {+ const { team, featuresRepository } = await setup();++ // Ensure team starts with false+ const before = await featuresRepository.getTeamsAutoOptIn([team.id]);+ expect(before[team.id]).toBe(false);++ await featuresRepository.setTeamAutoOptIn(team.id, true);++ const after = await featuresRepository.getTeamsAutoOptIn([team.id]);+ expect(after[team.id]).toBe(true);+ });++ it("should set autoOptInFeatures to false", async () => {+ const { team, featuresRepository } = await setup();++ // First set to true+ await featuresRepository.setTeamAutoOptIn(team.id, true);+ const before = await featuresRepository.getTeamsAutoOptIn([team.id]);+ expect(before[team.id]).toBe(true);++ // Now set to false+ await featuresRepository.setTeamAutoOptIn(team.id, false);++ const after = await featuresRepository.getTeamsAutoOptIn([team.id]);+ expect(after[team.id]).toBe(false);+ });+ });});diff --git a/packages/features/flags/features.repository.interface.ts b/packages/features/flags/features.repository.interface.tsindex 9a18dc0a7b1..7f0db8eb5ac 100644--- a/packages/features/flags/features.repository.interface.ts+++ b/packages/features/flags/features.repository.interface.ts@@ -1,20 +1,59 @@-import type { AppFlags, FeatureState } from "./config";+import type { FeatureId, FeatureState } from "./config";/*** Interface for the core FeaturesRepository.* This interface defines methods for checking feature flags and team feature access.*/export interface IFeaturesRepository {- checkIfFeatureIsEnabledGlobally(slug: keyof AppFlags): Promise<boolean>;+ checkIfFeatureIsEnabledGlobally(slug: FeatureId): Promise<boolean>;checkIfUserHasFeature(userId: number, slug: string): Promise<boolean>;getUserFeaturesStatus(userId: number, slugs: string[]): Promise<Record<string, boolean>>;checkIfUserHasFeatureNonHierarchical(userId: number, slug: string): Promise<boolean>;- checkIfTeamHasFeature(teamId: number, slug: keyof AppFlags): Promise<boolean>;- getTeamsWithFeatureEnabled(slug: keyof AppFlags): Promise<number[]>;+ checkIfTeamHasFeature(teamId: number, slug: FeatureId): Promise<boolean>;+ getTeamsWithFeatureEnabled(slug: FeatureId): Promise<number[]>;+ setUserFeatureState(+ input:+ | { userId: number; featureId: FeatureId; state: "enabled" | "disabled"; assignedBy: string }+ | { userId: number; featureId: FeatureId; state: "inherit" }+ ): Promise<void>;setTeamFeatureState(- teamId: number,- featureId: keyof AppFlags,- state: FeatureState,- assignedBy: string+ input:+ | { teamId: number; featureId: FeatureId; state: "enabled" | "disabled"; assignedBy: string }+ | { teamId: number; featureId: FeatureId; state: "inherit" }): Promise<void>;+ /**+ * Get user's feature states for multiple features.+ * @returns Record<featureId, 'enabled' | 'disabled' | 'inherit'>+ */+ getUserFeatureStates(input: {+ userId: number;+ featureIds: FeatureId[];+ }): Promise<Record<string, FeatureState>>;+ /**+ * Get multiple features' states across multiple teams.+ * Optimized for querying many teams for many features.+ * @returns Record<featureId, Record<teamId, 'enabled' | 'disabled' | 'inherit'>>+ */+ getTeamsFeatureStates(input: {+ teamIds: number[];+ featureIds: FeatureId[];+ }): Promise<Record<string, Record<number, FeatureState>>>;+ /**+ * Get user's autoOptInFeatures flag.+ * @returns Promise<boolean> - True if user has auto opt-in enabled+ */+ getUserAutoOptIn(userId: number): Promise<boolean>;+ /**+ * Get autoOptInFeatures for multiple teams (batch).+ * @returns Promise<Record<number, boolean>> - Map of teamId to autoOptInFeatures value+ */+ getTeamsAutoOptIn(teamIds: number[]): Promise<Record<number, boolean>>;+ /**+ * Set user's autoOptInFeatures flag.+ */+ setUserAutoOptIn(userId: number, enabled: boolean): Promise<void>;+ /**+ * Set team's autoOptInFeatures flag.+ */+ setTeamAutoOptIn(teamId: number, enabled: boolean): Promise<void>;}diff --git a/packages/features/flags/features.repository.mock.ts b/packages/features/flags/features.repository.mock.tsindex eb08314ab27..4db074a4ab8 100644--- a/packages/features/flags/features.repository.mock.ts+++ b/packages/features/flags/features.repository.mock.ts@@ -1,37 +1,99 @@-import type { AppFlags, FeatureState } from "./config";+import type { FeatureId, FeatureState } from "./config";import type { IFeaturesRepository } from "./features.repository.interface";export class MockFeaturesRepository implements IFeaturesRepository {- async checkIfUserHasFeature(userId: number, slug: string) {+ async checkIfUserHasFeature(_userId: number, slug: string) {return slug === "mock-feature";}- async getUserFeaturesStatus(userId: number, slugs: string[]): Promise<Record<string, boolean>> {- return Object.fromEntries(slugs.map((slug) => [slug, slug === "mock-feature"]));+ async getUserFeaturesStatus(+ _userId: number,+ slugs: string[]+ ): Promise<Record<string, boolean>> {+ return Object.fromEntries(+ slugs.map((slug) => [slug, slug === "mock-feature"])+ );}- async checkIfUserHasFeatureNonHierarchical(userId: number, slug: string) {+ async checkIfUserHasFeatureNonHierarchical(_userId: number, slug: string) {return slug === "mock-feature";}- async checkIfTeamHasFeature(teamId: number, slug: keyof AppFlags) {+ async checkIfTeamHasFeature(_teamId: number, slug: FeatureId) {return slug === "mock-feature";}- async checkIfFeatureIsEnabledGlobally(_slug: keyof AppFlags) {+ async checkIfFeatureIsEnabledGlobally(_slug: FeatureId) {return true;}- async getTeamsWithFeatureEnabled(_slug: keyof AppFlags): Promise<number[]> {+ async getTeamsWithFeatureEnabled(_slug: FeatureId): Promise<number[]> {return [];}+ async setUserFeatureState(+ _input:+ | {+ userId: number;+ featureId: FeatureId;+ state: "enabled" | "disabled";+ assignedBy: string;+ }+ | { userId: number; featureId: FeatureId; state: "inherit" }+ ): Promise<void> {+ // Mock implementation - do nothing+ }+async setTeamFeatureState(- _teamId: number,- _featureId: keyof AppFlags,- _state: FeatureState,- _assignedBy: string+ _input:+ | {+ teamId: number;+ featureId: FeatureId;+ state: "enabled" | "disabled";+ assignedBy: string;+ }+ | { teamId: number; featureId: FeatureId; state: "inherit" }): Promise<void> {// Mock implementation - do nothing}++ async getUserFeatureStates(_input: {+ userId: number;+ featureIds: FeatureId[];+ }): Promise<Record<string, FeatureState>> {+ // Mock implementation - return inherit for all features+ const result: Record<string, FeatureState> = {};+ for (const featureId of _input.featureIds) {+ result[featureId] = "inherit";+ }+ return result;+ }++ async getTeamsFeatureStates(_input: {+ teamIds: number[];+ featureIds: FeatureId[];+ }): Promise<Record<string, Record<number, FeatureState>>> {+ // Mock implementation - return empty (all teams inherit)+ return {};+ }++ async getUserAutoOptIn(_userId: number): Promise<boolean> {+ // Mock implementation - default to false+ return false;+ }++ async getTeamsAutoOptIn(+ _teamIds: number[]+ ): Promise<Record<number, boolean>> {+ // Mock implementation - return empty (all teams default to false)+ return {};+ }++ async setUserAutoOptIn(_userId: number, _enabled: boolean): Promise<void> {+ // Mock implementation - do nothing+ }++ async setTeamAutoOptIn(_teamId: number, _enabled: boolean): Promise<void> {+ // Mock implementation - do nothing+ }}diff --git a/packages/features/flags/features.repository.ts b/packages/features/flags/features.repository.tsindex 76f3651cf8b..46fb3700df7 100644--- a/packages/features/flags/features.repository.ts+++ b/packages/features/flags/features.repository.ts@@ -3,7 +3,7 @@ import { captureException } from "@sentry/nextjs";import type { PrismaClient } from "@calcom/prisma";import { Prisma } from "@calcom/prisma/client";-import type { AppFlags, FeatureState, TeamFeatures } from "./config";+import type { AppFlags, FeatureId, FeatureState, TeamFeatures } from "./config";import type { IFeaturesRepository } from "./features.repository.interface";interface CacheOptions {@@ -55,7 +55,7 @@ export class FeaturesRepository implements IFeaturesRepository {public async getFeatureFlagMap() {const flags = await this.getAllFeatures();return flags.reduce((acc, flag) => {- acc[flag.slug as keyof AppFlags] = flag.enabled;+ acc[flag.slug as FeatureId] = flag.enabled;return acc;}, {} as AppFlags);}@@ -96,7 +96,7 @@ export class FeaturesRepository implements IFeaturesRepository {* @throws Error if the feature flag check fails*/async checkIfFeatureIsEnabledGlobally(- slug: keyof AppFlags,+ slug: FeatureId,_options: CacheOptions = { ttl: 5 * 60 * 1000 }): Promise<boolean> {try {@@ -333,24 +333,80 @@ export class FeaturesRepository implements IFeaturesRepository {}}+ /**+ * Updates a feature status for a specific user.+ * Uses tri-state semantics:+ * - 'enabled': creates/updates a row with enabled=true+ * - 'disabled': creates/updates a row with enabled=false+ * - 'inherit': deletes the row to inherit from team/org level+ *+ * @param input.userId - The ID of the user to update the feature for+ * @param input.featureId - The feature identifier to update+ * @param input.state - 'enabled' | 'disabled' | 'inherit'+ * @param input.assignedBy - The user or what assigned the feature (required for enabled/disabled, not used for inherit)+ * @returns Promise<void>+ * @throws Error if the feature update fails+ */+ async setUserFeatureState(+ input:+ | { userId: number; featureId: FeatureId; state: "enabled" | "disabled"; assignedBy: string }+ | { userId: number; featureId: FeatureId; state: "inherit" }+ ): Promise<void> {+ const { userId, featureId, state } = input;+ try {+ if (state === "enabled" || state === "disabled") {+ const { assignedBy } = input;+ await this.prismaClient.userFeatures.upsert({+ where: {+ userId_featureId: {+ userId,+ featureId,+ },+ },+ create: {+ userId,+ featureId,+ enabled: state === "enabled",+ assignedBy,+ },+ update: {+ enabled: state === "enabled",+ assignedBy,+ },+ });+ } else if (state === "inherit") {+ await this.prismaClient.userFeatures.deleteMany({+ where: {+ userId,+ featureId,+ },+ });+ }+ } catch (err) {+ captureException(err);+ throw err;+ }+ }+/*** Updates a feature status for a specific team.* Uses tri-state semantics: creates/updates a row with enabled=true.- * @param teamId - The ID of the team to enable the feature for- * @param featureId - The feature identifier to enable- * @param state - 'enabled' | 'disabled' | 'inherit'- * @param assignedBy - The user or what assigned the feature+ * @param input.teamId - The ID of the team to enable the feature for+ * @param input.featureId - The feature identifier to enable+ * @param input.state - 'enabled' | 'disabled' | 'inherit'+ * @param input.assignedBy - The user or what assigned the feature (required for enabled/disabled, not used for inherit)* @returns Promise<void>* @throws Error if the feature enabling fails*/async setTeamFeatureState(- teamId: number,- featureId: keyof AppFlags,- state: FeatureState,- assignedBy: string+ input:+ | { teamId: number; featureId: FeatureId; state: "enabled" | "disabled"; assignedBy: string }+ | { teamId: number; featureId: FeatureId; state: "inherit" }): Promise<void> {+ const { teamId, featureId, state } = input;try {if (state === "enabled" || state === "disabled") {+ const { assignedBy } = input;await this.prismaClient.teamFeatures.upsert({where: {teamId_featureId: {@@ -377,8 +433,6 @@ export class FeaturesRepository implements IFeaturesRepository {},});}- // Clear cache when features are modified- this.clearCache();} catch (err) {captureException(err);throw err;@@ -395,7 +449,7 @@ export class FeaturesRepository implements IFeaturesRepository {* @returns Promise<boolean> - True if the team or any ancestor has the feature enabled, false otherwise* @throws Error if the database query fails*/- async checkIfTeamHasFeature(teamId: number, featureId: keyof AppFlags): Promise<boolean> {+ async checkIfTeamHasFeature(teamId: number, featureId: FeatureId): Promise<boolean> {try {// Early return if team has feature directly assigned with enabled=trueconst teamFeature = await this.prismaClient.teamFeatures.findUnique({@@ -450,7 +504,7 @@ export class FeaturesRepository implements IFeaturesRepository {}}- async getTeamsWithFeatureEnabled(slug: keyof AppFlags): Promise<number[]> {+ async getTeamsWithFeatureEnabled(slug: FeatureId): Promise<number[]> {try {// If globally disabled, treat as effectively disabled everywhereconst isGloballyEnabled = await this.checkIfFeatureIsEnabledGlobally(slug);@@ -472,4 +526,180 @@ export class FeaturesRepository implements IFeaturesRepository {throw err;}}++ /**+ * Get user's feature states for multiple features.+ * Uses tri-state semantics:+ * - Row with enabled=true → 'enabled'+ * - Row with enabled=false → 'disabled'+ * - No row → 'inherit' from team/org level+ *+ * @param input - Object containing userId and featureIds array+ * @returns Record<featureId, 'enabled' | 'disabled' | 'inherit'>+ */+ async getUserFeatureStates(input: {+ userId: number;+ featureIds: FeatureId[];+ }): Promise<Partial<Record<FeatureId, FeatureState>>> {+ const { userId, featureIds } = input;++ try {+ // Initialize result with all features set to 'inherit'+ const result: Partial<Record<FeatureId, FeatureState>> = {};+ for (const featureId of featureIds) {+ result[featureId] = "inherit";+ }++ // Query all user features in a single call+ const userFeatures = await this.prismaClient.userFeatures.findMany({+ where: {+ userId,+ featureId: { in: featureIds },+ },+ select: { featureId: true, enabled: true },+ });++ // Update result with actual values from database+ for (const userFeature of userFeatures) {+ result[userFeature.featureId as FeatureId] = userFeature.enabled ? "enabled" : "disabled";+ }++ return result;+ } catch (err) {+ captureException(err);+ throw err;+ }+ }++ /**+ * Get multiple features' states across multiple teams.+ * Optimized for querying many teams for many features in one call.+ * Uses tri-state semantics:+ * - Row with enabled=true → 'enabled'+ * - Row with enabled=false → 'disabled'+ * - No row → 'inherit' from parent team/org level+ *+ * @param input - Object containing teamIds array and featureIds array+ * @returns Record<featureId, Record<teamId, 'enabled' | 'disabled' | 'inherit'>>+ */+ async getTeamsFeatureStates(input: {+ teamIds: number[];+ featureIds: FeatureId[];+ }): Promise<Partial<Record<FeatureId, Record<number, FeatureState>>>> {+ const { teamIds, featureIds } = input;++ if (teamIds.length === 0 || featureIds.length === 0) {+ return {} as Partial<Record<FeatureId, Record<number, FeatureState>>>;+ }++ try {+ // Initialize result with all features present to avoid undefined feature keys+ const result: Partial<Record<FeatureId, Record<number, FeatureState>>> = {};+ for (const featureId of featureIds) {+ result[featureId] = {};+ }++ // Query all team features in a single call+ const teamFeatures = await this.prismaClient.teamFeatures.findMany({+ where: {+ teamId: { in: teamIds },+ featureId: { in: featureIds },+ },+ select: { teamId: true, featureId: true, enabled: true },+ });++ // Build result map - teams not in the result will default to 'inherit'+ for (const teamFeature of teamFeatures) {+ const featureStates = result[teamFeature.featureId as FeatureId] ?? {};+ featureStates[teamFeature.teamId] = teamFeature.enabled ? "enabled" : "disabled";+ result[teamFeature.featureId as FeatureId] = featureStates;+ }++ return result;+ } catch (err) {+ captureException(err);+ throw err;+ }+ }++ /**+ * Get user's autoOptInFeatures flag.+ * @param userId - The ID of the user+ * @returns Promise<boolean> - True if user has auto opt-in enabled, false otherwise+ */+ async getUserAutoOptIn(userId: number): Promise<boolean> {+ try {+ const user = await this.prismaClient.user.findUnique({+ where: { id: userId },+ select: { autoOptInFeatures: true },+ });+ return user?.autoOptInFeatures ?? false;+ } catch (err) {+ captureException(err);+ throw err;+ }+ }++ /**+ * Get autoOptInFeatures for multiple teams (batch).+ * @param teamIds - Array of team IDs to query+ * @returns Promise<Record<number, boolean>> - Map of teamId to autoOptInFeatures value+ */+ async getTeamsAutoOptIn(teamIds: number[]): Promise<Record<number, boolean>> {+ if (teamIds.length === 0) {+ return {};+ }++ try {+ const teams = await this.prismaClient.team.findMany({+ where: { id: { in: teamIds } },+ select: { id: true, autoOptInFeatures: true },+ });++ const result: Record<number, boolean> = {};+ for (const team of teams) {+ result[team.id] = team.autoOptInFeatures;+ }+ return result;+ } catch (err) {+ captureException(err);+ throw err;+ }+ }++ /**+ * Set user's autoOptInFeatures flag.+ * @param userId - The ID of the user+ * @param enabled - Whether to enable auto opt-in for all features+ * @returns Promise<void>+ */+ async setUserAutoOptIn(userId: number, enabled: boolean): Promise<void> {+ try {+ await this.prismaClient.user.update({+ where: { id: userId },+ data: { autoOptInFeatures: enabled },+ });+ } catch (err) {+ captureException(err);+ throw err;+ }+ }++ /**+ * Set team's autoOptInFeatures flag.+ * @param teamId - The ID of the team+ * @param enabled - Whether to enable auto opt-in for all features+ * @returns Promise<void>+ */+ async setTeamAutoOptIn(teamId: number, enabled: boolean): Promise<void> {+ try {+ await this.prismaClient.team.update({+ where: { id: teamId },+ data: { autoOptInFeatures: enabled },+ });+ } catch (err) {+ captureException(err);+ throw err;+ }+ }}diff --git a/packages/features/flags/operations/check-if-user-has-feature.controller.test.ts b/packages/features/flags/operations/check-if-user-has-feature.controller.test.tsindex 2e631394e16..225667dd83a 100644--- a/packages/features/flags/operations/check-if-user-has-feature.controller.test.ts+++ b/packages/features/flags/operations/check-if-user-has-feature.controller.test.ts@@ -2,6 +2,9 @@ import prismock from "../../../../tests/libs/__mocks__/prisma";import { expect, it } from "vitest";+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";+import { checkIfUserHasFeatureController } from "./check-if-user-has-feature.controller";/**@@ -9,15 +12,13 @@ import { checkIfUserHasFeatureController } from "./check-if-user-has-feature.con* this test is identical to the test in the use case.*/it("checks if user has access to feature", async () => {+ const featuresRepository = new FeaturesRepository(prismock);const userId = 1;- await prismock.userFeatures.create({- data: {- userId,- featureId: "mock-feature",- assignedBy: "1",- updatedAt: new Date(),- enabled: true,- },+ await featuresRepository.setUserFeatureState({+ userId,+ featureId: "mock-feature" as FeatureId,+ state: "enabled",+ assignedBy: "1",});await expect(checkIfUserHasFeatureController(userId, "nonexistent-feature")).resolves.toBe(false);await expect(checkIfUserHasFeatureController(userId, "mock-feature")).resolves.toBe(true);diff --git a/packages/features/flags/operations/check-if-user-has-feature.use-case.test.ts b/packages/features/flags/operations/check-if-user-has-feature.use-case.test.tsindex 29d55ef045a..78feb312f53 100644--- a/packages/features/flags/operations/check-if-user-has-feature.use-case.test.ts+++ b/packages/features/flags/operations/check-if-user-has-feature.use-case.test.ts@@ -2,20 +2,21 @@ import prismock from "../../../../tests/libs/__mocks__/prisma";import { expect, it } from "vitest";+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";+import { checkIfUserHasFeatureUseCase } from "./check-if-user-has-feature.use-case";// This is identical to the test in the controller since the controller currently// doesn't run any authentication checks or input validation.it("returns if user has access to feature", async () => {+ const featuresRepository = new FeaturesRepository(prismock);const userId = 1;- await prismock.userFeatures.create({- data: {- userId,- featureId: "mock-feature",- assignedBy: "1",- updatedAt: new Date(),- enabled: true,- },+ await featuresRepository.setUserFeatureState({+ userId,+ featureId: "mock-feature" as FeatureId,+ state: "enabled",+ assignedBy: "1",});await expect(checkIfUserHasFeatureUseCase(userId, "nonexistent-feature")).resolves.toBe(false);await expect(checkIfUserHasFeatureUseCase(userId, "mock-feature")).resolves.toBe(true);diff --git a/packages/features/membership/repositories/MembershipRepository.ts b/packages/features/membership/repositories/MembershipRepository.tsindex 0fea70bd5f1..b5c8b82272b 100644--- a/packages/features/membership/repositories/MembershipRepository.ts+++ b/packages/features/membership/repositories/MembershipRepository.ts@@ -531,6 +531,7 @@ export class MembershipRepository {select: {id: true,parentId: true,+ isOrganization: true,},},},diff --git a/packages/features/pbac/infrastructure/repositories/__tests__/PermissionRepository.integration-test.ts b/packages/features/pbac/infrastructure/repositories/__tests__/PermissionRepository.integration-test.tsindex 20dde1cd96b..fd1bb8e2739 100644--- a/packages/features/pbac/infrastructure/repositories/__tests__/PermissionRepository.integration-test.ts+++ b/packages/features/pbac/infrastructure/repositories/__tests__/PermissionRepository.integration-test.ts@@ -1,5 +1,7 @@import { describe, it, expect, beforeEach, afterEach, beforeAll } from "vitest";+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import { prisma } from "@calcom/prisma";import { MembershipRole } from "@calcom/prisma/enums";@@ -8,12 +10,14 @@ import { PermissionRepository } from "../PermissionRepository";describe("PermissionRepository - Integration Tests", () => {let repository: PermissionRepository;+ let featuresRepository: FeaturesRepository;let testRoleId: string;let testUserId: number;let testTeamId: number;beforeAll(async () => {repository = new PermissionRepository(prisma);+ featuresRepository = new FeaturesRepository(prisma);});beforeEach(async () => {@@ -58,8 +62,10 @@ describe("PermissionRepository - Integration Tests", () => {await prisma.role.deleteMany({where: { id: testRoleId },});- await prisma.teamFeatures.deleteMany({- where: { teamId: testTeamId },+ await featuresRepository.setTeamFeatureState({+ teamId: testTeamId,+ featureId: "pbac" as FeatureId,+ state: "inherit",});await prisma.team.deleteMany({where: { id: testTeamId },@@ -340,13 +346,11 @@ describe("PermissionRepository - Integration Tests", () => {it("should return team IDs for PBAC-enabled team with matching permissions", async () => {// Enable PBAC for the team- await prisma.teamFeatures.create({- data: {- teamId: testTeamId,- featureId: "pbac",- assignedBy: "test",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: testTeamId,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",});// Create membership with custom role@@ -386,13 +390,11 @@ describe("PermissionRepository - Integration Tests", () => {it("should not return team IDs when permissions do not match", async () => {// Enable PBAC for the team- await prisma.teamFeatures.create({- data: {- teamId: testTeamId,- featureId: "pbac",- assignedBy: "test",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: testTeamId,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",});// Create membership with custom role@@ -484,13 +486,11 @@ describe("PermissionRepository - Integration Tests", () => {});// Enable PBAC for org- await prisma.teamFeatures.create({- data: {- teamId: org.id,- featureId: "pbac",- assignedBy: "test",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",});// Create org role@@ -547,7 +547,11 @@ describe("PermissionRepository - Integration Tests", () => {await prisma.rolePermission.deleteMany({ where: { roleId: orgRole.id } });await prisma.membership.deleteMany({ where: { userId: testUserId } });await prisma.role.deleteMany({ where: { id: orgRole.id } });- await prisma.teamFeatures.deleteMany({ where: { teamId: org.id } });+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: "pbac" as FeatureId,+ state: "inherit",+ });await prisma.team.deleteMany({ where: { id: { in: [org.id, childTeam.id] } } });});@@ -599,13 +603,11 @@ describe("PermissionRepository - Integration Tests", () => {it("should handle wildcard permissions for PBAC teams", async () => {// Enable PBAC for the team- await prisma.teamFeatures.create({- data: {- teamId: testTeamId,- featureId: "pbac",- assignedBy: "test",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: testTeamId,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",});// Create membership with custom role@@ -645,13 +647,11 @@ describe("PermissionRepository - Integration Tests", () => {it("should require all permissions to match (not just some)", async () => {// Enable PBAC for the team- await prisma.teamFeatures.create({- data: {- teamId: testTeamId,- featureId: "pbac",- assignedBy: "test",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: testTeamId,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",});// Create membership with custom role@@ -685,13 +685,11 @@ describe("PermissionRepository - Integration Tests", () => {it("should not return teams for non-accepted memberships", async () => {// Enable PBAC for the team- await prisma.teamFeatures.create({- data: {- teamId: testTeamId,- featureId: "pbac",- assignedBy: "test",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: testTeamId,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",});// Create membership with accepted: false@@ -755,12 +753,20 @@ describe("PermissionRepository - Integration Tests", () => {});// Enable PBAC for both teams- await prisma.teamFeatures.createMany({- data: [- { teamId: team1.id, featureId: "pbac", assignedBy: "test", enabled: true },- { teamId: team2.id, featureId: "pbac", assignedBy: "test", enabled: true },- ],- });+ await Promise.all([+ featuresRepository.setTeamFeatureState({+ teamId: team1.id,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",+ }),+ featuresRepository.setTeamFeatureState({+ teamId: team2.id,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",+ }),+ ]);// Create memberships for both teamsconst membership1 = await prisma.membership.create({@@ -825,7 +831,18 @@ describe("PermissionRepository - Integration Tests", () => {await prisma.rolePermission.deleteMany({ where: { roleId: { in: [role1.id, role2.id] } } });await prisma.membership.deleteMany({ where: { userId: testUserId } });await prisma.role.deleteMany({ where: { id: { in: [role1.id, role2.id] } } });- await prisma.teamFeatures.deleteMany({ where: { teamId: { in: [team1.id, team2.id] } } });+ await Promise.all([+ featuresRepository.setTeamFeatureState({+ teamId: team1.id,+ featureId: "pbac" as FeatureId,+ state: "inherit",+ }),+ featuresRepository.setTeamFeatureState({+ teamId: team2.id,+ featureId: "pbac" as FeatureId,+ state: "inherit",+ }),+ ]);await prisma.team.deleteMany({ where: { id: { in: [team1.id, team2.id] } } });});@@ -855,13 +872,11 @@ describe("PermissionRepository - Integration Tests", () => {});// Enable PBAC for first team only- await prisma.teamFeatures.create({- data: {- teamId: team1.id,- featureId: "pbac",- assignedBy: "test",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: team1.id,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "test",});// Create PBAC membership@@ -914,7 +929,11 @@ describe("PermissionRepository - Integration Tests", () => {await prisma.rolePermission.deleteMany({ where: { roleId: role1.id } });await prisma.membership.deleteMany({ where: { userId: testUserId } });await prisma.role.deleteMany({ where: { id: role1.id } });- await prisma.teamFeatures.deleteMany({ where: { teamId: team1.id } });+ await featuresRepository.setTeamFeatureState({+ teamId: team1.id,+ featureId: "pbac" as FeatureId,+ state: "inherit",+ });await prisma.team.deleteMany({ where: { id: { in: [team1.id, team2.id] } } });});diff --git a/packages/lib/server/repository/selectedCalendar.test.ts b/packages/lib/server/repository/selectedCalendar.test.tsindex 03e81f3241e..e356e4dd072 100644--- a/packages/lib/server/repository/selectedCalendar.test.ts+++ b/packages/lib/server/repository/selectedCalendar.test.ts@@ -2,6 +2,8 @@ import prismock from "../../../../tests/libs/__mocks__/prisma";import { describe, expect, it, beforeEach } from "vitest";+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import prisma from "@calcom/prisma";import { MembershipRole } from "@calcom/prisma/enums";@@ -37,13 +39,12 @@ describe("SelectedCalendarRepository", () => {},});- await prisma.teamFeatures.create({- data: {- teamId: team.id,- featureId: "calendar-cache",- enabled: false,- assignedBy: "test",- },+ const featuresRepository = new FeaturesRepository(prismock);+ await featuresRepository.setTeamFeatureState({+ teamId: team.id,+ featureId: "calendar-cache" as FeatureId,+ state: "disabled",+ assignedBy: "test",});await prisma.selectedCalendar.create({diff --git a/packages/prisma/migrations/20251217155117_add_auto_opt_in_features/migration.sql b/packages/prisma/migrations/20251217155117_add_auto_opt_in_features/migration.sqlnew file mode 100644index 00000000000..12fe20966ea--- /dev/null+++ b/packages/prisma/migrations/20251217155117_add_auto_opt_in_features/migration.sql@@ -0,0 +1,5 @@+-- AlterTable+ALTER TABLE "public"."Team" ADD COLUMN "autoOptInFeatures" BOOLEAN NOT NULL DEFAULT false;++-- AlterTable+ALTER TABLE "public"."users" ADD COLUMN "autoOptInFeatures" BOOLEAN NOT NULL DEFAULT false;diff --git a/packages/prisma/schema.prisma b/packages/prisma/schema.prismaindex 5a27213308b..a355345d15b 100644--- a/packages/prisma/schema.prisma+++ b/packages/prisma/schema.prisma@@ -484,6 +484,8 @@ model User {agents Agent[]holidaySettings UserHolidaySettings?+ autoOptInFeatures Boolean @default(false)+@@unique([email])@@unique([email, username])@@unique([username, organizationId])@@ -615,6 +617,8 @@ model Team {teamBilling TeamBilling? @relation("TeamBilling")organizationBilling OrganizationBilling? @relation("OrganizationBilling")+ autoOptInFeatures Boolean @default(false)+@@unique([slug, parentId])@@index([parentId])}diff --git a/packages/trpc/server/routers/viewer/_router.tsx b/packages/trpc/server/routers/viewer/_router.tsxindex aab6ef7f86e..14fda5a5cfc 100644--- a/packages/trpc/server/routers/viewer/_router.tsx+++ b/packages/trpc/server/routers/viewer/_router.tsx@@ -22,6 +22,7 @@ import { deploymentSetupRouter } from "./deploymentSetup/_router";import { dsyncRouter } from "./dsync/_router";import { eventTypesRouter } from "./eventTypes/_router";import { eventTypesRouter as heavyEventTypesRouter } from "./eventTypes/heavy/_router";+import { featureOptInRouter } from "./featureOptIn/_router";import { filterSegmentsRouter } from "./filterSegments/_router";import { googleWorkspaceRouter } from "./googleWorkspace/_router";import { holidaysRouter } from "./holidays/_router";@@ -76,6 +77,7 @@ export const viewerRouter = router({// After that there would just one merge call here for all the apps.appRoutingForms: app_RoutingForms,features: featureFlagRouter,+ featureOptIn: featureOptInRouter,users: userAdminRouter,oAuth: oAuthRouter,googleWorkspace: googleWorkspaceRouter,diff --git a/packages/trpc/server/routers/viewer/admin/assignFeatureToTeam.handler.ts b/packages/trpc/server/routers/viewer/admin/assignFeatureToTeam.handler.tsindex e9755566e63..c2f660fbaee 100644--- a/packages/trpc/server/routers/viewer/admin/assignFeatureToTeam.handler.ts+++ b/packages/trpc/server/routers/viewer/admin/assignFeatureToTeam.handler.ts@@ -1,3 +1,5 @@+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import type { PrismaClient } from "@calcom/prisma";import type { TrpcSessionUser } from "../../../types";@@ -15,22 +17,12 @@ export const assignFeatureToTeamHandler = async ({ ctx, input }: AssignFeatureOpconst { prisma, user } = ctx;const { teamId, featureId } = input;- await prisma.teamFeatures.upsert({- where: {- teamId_featureId: {- teamId,- featureId,- },- },- create: {- teamId,- featureId,- assignedBy: `user:${user.id}`,- enabled: true,- },- update: {- enabled: true,- },+ const featuresRepository = new FeaturesRepository(prisma);+ await featuresRepository.setTeamFeatureState({+ teamId,+ featureId: featureId as FeatureId,+ state: "enabled",+ assignedBy: `user:${user.id}`,});return { success: true };diff --git a/packages/trpc/server/routers/viewer/admin/unassignFeatureFromTeam.handler.ts b/packages/trpc/server/routers/viewer/admin/unassignFeatureFromTeam.handler.tsindex 5b4eeb802dc..d04c6c9691a 100644--- a/packages/trpc/server/routers/viewer/admin/unassignFeatureFromTeam.handler.ts+++ b/packages/trpc/server/routers/viewer/admin/unassignFeatureFromTeam.handler.ts@@ -1,3 +1,5 @@+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import type { PrismaClient } from "@calcom/prisma";import type { TrpcSessionUser } from "../../../types";@@ -15,13 +17,11 @@ export const unassignFeatureFromTeamHandler = async ({ ctx, input }: UnassignFeaconst { prisma } = ctx;const { teamId, featureId } = input;- await prisma.teamFeatures.delete({- where: {- teamId_featureId: {- teamId,- featureId,- },- },+ const featuresRepository = new FeaturesRepository(prisma);+ await featuresRepository.setTeamFeatureState({+ teamId,+ featureId: featureId as FeatureId,+ state: "inherit",});return { success: true };diff --git a/packages/trpc/server/routers/viewer/featureOptIn/_router.ts b/packages/trpc/server/routers/viewer/featureOptIn/_router.tsnew file mode 100644index 00000000000..6ce702528d5--- /dev/null+++ b/packages/trpc/server/routers/viewer/featureOptIn/_router.ts@@ -0,0 +1,248 @@+import { z } from "zod";++import { isOptInFeature } from "@calcom/features/feature-opt-in/config";+import { FeatureOptInService } from "@calcom/features/feature-opt-in/services/FeatureOptInService";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";+import { MembershipRepository } from "@calcom/features/membership/repositories/MembershipRepository";+import { PermissionCheckService } from "@calcom/features/pbac/services/permission-check.service";+import { prisma } from "@calcom/prisma";+import { MembershipRole } from "@calcom/prisma/enums";++import { TRPCError } from "@trpc/server";++import authedProcedure from "../../../procedures/authedProcedure";+import { router } from "../../../trpc";++const featureStateSchema = z.enum(["enabled", "disabled", "inherit"]);++const featuresRepository = new FeaturesRepository(prisma);+const featureOptInService = new FeatureOptInService(featuresRepository);++/**+ * Helper to get user's org and team IDs from their memberships.+ * Returns orgId (if user belongs to an org) and teamIds (non-org teams).+ */+async function getUserOrgAndTeamIds(userId: number): Promise<{ orgId: number | null; teamIds: number[] }> {+ const memberships = await MembershipRepository.findAllByUserId({+ userId,+ filters: { accepted: true },+ });++ let orgId: number | null = null;+ const teamIds: number[] = [];++ for (const membership of memberships) {+ if (membership.team.isOrganization) {+ orgId = membership.teamId;+ } else {+ teamIds.push(membership.teamId);+ }+ }++ return { orgId, teamIds };+}++export const featureOptInRouter = router({+ /**+ * Get all opt-in features with states for current user.+ * This considers all teams/orgs the user belongs to.+ */+ listForUser: authedProcedure.query(async ({ ctx }) => {+ const { orgId, teamIds } = await getUserOrgAndTeamIds(ctx.user.id);++ return featureOptInService.listFeaturesForUser({+ userId: ctx.user.id,+ orgId,+ teamIds,+ });+ }),++ /**+ * Get all opt-in features with states for a team settings page.+ * Used by team admins to configure feature opt-in for their team.+ */+ listForTeam: authedProcedure+ .input(+ z.object({+ teamId: z.number(),+ })+ )+ .query(async ({ ctx, input }) => {+ const permissionCheckService = new PermissionCheckService();+ const hasPermission = await permissionCheckService.checkPermission({+ userId: ctx.user.id,+ teamId: input.teamId,+ permission: "team.read",+ fallbackRoles: [MembershipRole.OWNER, MembershipRole.ADMIN],+ });++ if (!hasPermission) {+ throw new TRPCError({+ code: "FORBIDDEN",+ message: "You do not have permission to view team feature settings.",+ });+ }++ return featureOptInService.listFeaturesForTeam({ teamId: input.teamId });+ }),++ /**+ * Get all opt-in features with states for organization settings page.+ * Used by org admins to configure feature opt-in for their organization.+ * Uses the organization from the current user's context.+ */+ listForOrganization: authedProcedure.query(async ({ ctx }) => {+ const organizationId = ctx.user.organizationId;++ if (!organizationId) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: "You are not a member of any organization.",+ });+ }++ const permissionCheckService = new PermissionCheckService();+ const hasPermission = await permissionCheckService.checkPermission({+ userId: ctx.user.id,+ teamId: organizationId,+ permission: "organization.read",+ fallbackRoles: [MembershipRole.OWNER, MembershipRole.ADMIN],+ });++ if (!hasPermission) {+ throw new TRPCError({+ code: "FORBIDDEN",+ message: "You do not have permission to view organization feature settings.",+ });+ }++ // Organizations use the same listFeaturesForTeam since they're stored in TeamFeatures+ return featureOptInService.listFeaturesForTeam({ teamId: organizationId });+ }),++ /**+ * Set user's feature state.+ */+ setUserState: authedProcedure+ .input(+ z.object({+ featureId: z.string(),+ state: featureStateSchema,+ })+ )+ .mutation(async ({ ctx, input }) => {+ if (!isOptInFeature(input.featureId)) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: "Invalid featureId. This feature is not opt-in configurable.",+ });+ }++ await featureOptInService.setUserFeatureState({+ userId: ctx.user.id,+ featureId: input.featureId,+ state: input.state,+ assignedBy: ctx.user.id,+ });++ return { success: true };+ }),++ /**+ * Set team's feature state (requires team admin).+ */+ setTeamState: authedProcedure+ .input(+ z.object({+ teamId: z.number(),+ featureId: z.string(),+ state: featureStateSchema,+ })+ )+ .mutation(async ({ ctx, input }) => {+ if (!isOptInFeature(input.featureId)) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: "Invalid featureId. This feature is not opt-in configurable.",+ });+ }++ const permissionCheckService = new PermissionCheckService();+ const hasPermission = await permissionCheckService.checkPermission({+ userId: ctx.user.id,+ teamId: input.teamId,+ permission: "team.update",+ fallbackRoles: [MembershipRole.OWNER, MembershipRole.ADMIN],+ });++ if (!hasPermission) {+ throw new TRPCError({+ code: "FORBIDDEN",+ message: "You do not have permission to update team feature settings.",+ });+ }++ await featureOptInService.setTeamFeatureState({+ teamId: input.teamId,+ featureId: input.featureId,+ state: input.state,+ assignedBy: ctx.user.id,+ });++ return { success: true };+ }),++ /**+ * Set organization's feature state (requires org admin).+ * Uses the organization from the current user's context.+ */+ setOrganizationState: authedProcedure+ .input(+ z.object({+ featureId: z.string(),+ state: featureStateSchema,+ })+ )+ .mutation(async ({ ctx, input }) => {+ if (!isOptInFeature(input.featureId)) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: "Invalid featureId. This feature is not opt-in configurable.",+ });+ }++ const organizationId = ctx.user.organizationId;++ if (!organizationId) {+ throw new TRPCError({+ code: "BAD_REQUEST",+ message: "You are not a member of any organization.",+ });+ }++ const permissionCheckService = new PermissionCheckService();+ const hasPermission = await permissionCheckService.checkPermission({+ userId: ctx.user.id,+ teamId: organizationId,+ permission: "organization.update",+ fallbackRoles: [MembershipRole.OWNER, MembershipRole.ADMIN],+ });++ if (!hasPermission) {+ throw new TRPCError({+ code: "FORBIDDEN",+ message: "You do not have permission to update organization feature settings.",+ });+ }++ // Organizations use the same TeamFeatures table+ await featureOptInService.setTeamFeatureState({+ teamId: organizationId,+ featureId: input.featureId,+ state: input.state,+ assignedBy: ctx.user.id,+ });++ return { success: true };+ }),+});diff --git a/packages/trpc/server/routers/viewer/pbac/_router.tsx b/packages/trpc/server/routers/viewer/pbac/_router.tsxindex f6731aa8c02..1f9da6e4f78 100644--- a/packages/trpc/server/routers/viewer/pbac/_router.tsx+++ b/packages/trpc/server/routers/viewer/pbac/_router.tsx@@ -249,7 +249,12 @@ export const permissionsRouter = router({}// Enable PBAC feature for the organization- await featureRepo.setTeamFeatureState(orgId, "pbac", "enabled", "opt-in by user: " + ctx.user.id);+ await featureRepo.setTeamFeatureState({+ teamId: orgId,+ featureId: "pbac",+ state: "enabled",+ assignedBy: "opt-in by user: " + ctx.user.id,+ });return { success: true, message: "PBAC enabled successfully" };}),diff --git a/scripts/prepare-local-for-delegation-credentials-testing.js b/scripts/prepare-local-for-delegation-credentials-testing.jsindex 7c569e2d011..5977f1304c5 100644--- a/scripts/prepare-local-for-delegation-credentials-testing.js+++ b/scripts/prepare-local-for-delegation-credentials-testing.js@@ -7,6 +7,9 @@ const { PrismaClient } = require("@prisma/client");const prisma = new PrismaClient();async function main() {+ // Dynamic import for ES module+ const { FeaturesRepository } = await import("@calcom/features/flags/features.repository");+ const featuresRepository = new FeaturesRepository(prisma);// Parse newEmail from argsconst newEmail = process.argv[2] || "[email protected]";console.log(`Using newEmail: ${newEmail}`);@@ -59,14 +62,11 @@ async function main() {},});if (!delegationFeature) {- await prisma.teamFeatures.create({- data: {- teamId: org.id,- featureId: "delegation-credential",- assignedAt: new Date(),- assignedBy: "prepare-local-script",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: "delegation-credential",+ state: "enabled",+ assignedBy: "prepare-local-script",});console.log("Created TeamFeatures: delegation-credential");} else {@@ -84,14 +84,11 @@ async function main() {},});if (!calendarCacheFeature) {- await prisma.teamFeatures.create({- data: {- teamId: org.id,- featureId: "calendar-cache",- assignedAt: new Date(),- assignedBy: "prepare-local-script",- enabled: true,- },+ await featuresRepository.setTeamFeatureState({+ teamId: org.id,+ featureId: "calendar-cache",+ state: "enabled",+ assignedBy: "prepare-local-script",});console.log("Created TeamFeatures: calendar-cache");} else {diff --git a/scripts/seed-pbac-organization.ts b/scripts/seed-pbac-organization.tsindex 427e484d0e8..35237b7f549 100644--- a/scripts/seed-pbac-organization.ts+++ b/scripts/seed-pbac-organization.ts@@ -1,5 +1,7 @@import { uuid } from "short-uuid";+import type { FeatureId } from "@calcom/features/flags/config";+import { FeaturesRepository } from "@calcom/features/flags/features.repository";import { hashPassword } from "@calcom/lib/auth/hashPassword";import { DEFAULT_SCHEDULE, getAvailabilityFromSchedule } from "@calcom/lib/availability";import prisma from "@calcom/prisma";@@ -51,14 +53,12 @@ export async function createPBACOrganization() {});// Add the feature flag- await prisma.teamFeatures.create({- data: {- featureId: "pbac",- teamId: organization.id,- assignedBy: "system (Seed script)",- assignedAt: new Date(),- enabled: true,- },+ const featuresRepository = new FeaturesRepository(prisma);+ await featuresRepository.setTeamFeatureState({+ teamId: organization.id,+ featureId: "pbac" as FeatureId,+ state: "enabled",+ assignedBy: "system (Seed script)",});console.log(`✅ Created organization: ${organization.name} (ID: ${organization.id})`);