-
-
{t("common.title")}
-
{t("common.surveys")}
-
{t("common.updated")}
-
{t("common.created")}
+ <>
+
+
+
+ {table.getHeaderGroups().map((headerGroup) => (
+
+ {headerGroup.headers.map((header, index) => {
+ const isFirstHeader = index === 0;
+ const isLastHeader = index === headerGroup.headers.length - 1;
+ const getHeaderClass = () => {
+ if (isFirstHeader) {
+ return "rounded-tl-lg";
+ }
+
+ if (isLastHeader) {
+ return "rounded-tr-lg";
+ }
+
+ return "";
+ };
+
+ return (
+
+ {getHeader(header)}
+
+ );
+ })}
+
+ ))}
+
+
+ {table.getRowModel().rows?.length ? (
+ table.getRowModel().rows.map((row, rowIndex) => {
+ const isLastRow = rowIndex === table.getRowModel().rows.length - 1;
+ return (
+ setEditingSegment(row.original)}
+ className={`cursor-pointer hover:bg-slate-50 ${isLastRow ? "rounded-b-lg" : ""}`}>
+ {row.getVisibleCells().map((cell, cellIndex) => {
+ const isFirstCell = cellIndex === 0;
+ const isLastCell = cellIndex === row.getVisibleCells().length - 1;
+ const getCellClass = () => {
+ if (!isLastRow) {
+ return "";
+ }
+
+ if (isFirstCell) {
+ return "rounded-bl-lg";
+ }
+
+ if (isLastCell) {
+ return "rounded-br-lg";
+ }
+
+ return "";
+ };
+
+ return (
+
+ {typeof cell.column.columnDef.cell === "function"
+ ? cell.column.columnDef.cell(cell.getContext())
+ : cell.column.columnDef.cell}
+
+ );
+ })}
+
+ );
+ })
+ ) : (
+
+
+ {t("environments.segments.create_your_first_segment")}
+
+
+ )}
+
+
- {segments.length === 0 ? (
-
- {t("environments.segments.create_your_first_segment")}
-
- ) : (
- <>
- {segments.map((segment) => (
-
- ))}
-
+
+ {editingSegment && (
+
!open && setEditingSegment(null)}
+ currentSegment={editingSegment}
+ contactAttributeKeys={contactAttributeKeys}
+ segments={segments}
+ isContactsEnabled={isContactsEnabled}
+ isReadOnly={isReadOnly}
+ />
)}
-
+
);
-};
+}
diff --git a/apps/web/modules/ee/contacts/segments/components/targeting-card.tsx b/apps/web/modules/ee/contacts/segments/components/targeting-card.tsx
index 549de03e36..c0207abc4b 100644
--- a/apps/web/modules/ee/contacts/segments/components/targeting-card.tsx
+++ b/apps/web/modules/ee/contacts/segments/components/targeting-card.tsx
@@ -17,6 +17,7 @@ import type {
import type { TSurvey } from "@formbricks/types/surveys/types";
import { cn } from "@/lib/cn";
import { structuredClone } from "@/lib/pollyfills/structuredClone";
+import { getFormattedErrorMessage } from "@/lib/utils/helper";
import {
cloneSegmentAction,
createSegmentAction,
@@ -135,7 +136,11 @@ export function TargetingCard({
const handleSaveSegment = async (data: TSegmentUpdateInput) => {
try {
if (!segment) throw new Error(t("environments.segments.invalid_segment"));
- await updateSegmentAction({ segmentId: segment.id, environmentId, data });
+ const result = await updateSegmentAction({ segmentId: segment.id, environmentId, data });
+ if (result?.serverError) {
+ toast.error(getFormattedErrorMessage(result));
+ return;
+ }
toast.success(t("environments.segments.segment_saved_successfully"));
setIsSegmentEditorOpen(false);
diff --git a/apps/web/modules/ee/contacts/segments/lib/date-utils.test.ts b/apps/web/modules/ee/contacts/segments/lib/date-utils.test.ts
new file mode 100644
index 0000000000..c7826b0aba
--- /dev/null
+++ b/apps/web/modules/ee/contacts/segments/lib/date-utils.test.ts
@@ -0,0 +1,114 @@
+import { describe, expect, test } from "vitest";
+import { addTimeUnit, endOfDay, isSameDay, startOfDay, subtractTimeUnit } from "./date-utils";
+
+describe("date-utils", () => {
+ describe("subtractTimeUnit", () => {
+ test("subtracts days correctly", () => {
+ const date = new Date("2024-01-15T12:00:00Z");
+ const result = subtractTimeUnit(date, 5, "days");
+ expect(result.getDate()).toBe(10);
+ expect(result.getMonth()).toBe(0); // January
+ });
+
+ test("subtracts weeks correctly", () => {
+ const date = new Date("2024-01-15T12:00:00Z");
+ const result = subtractTimeUnit(date, 2, "weeks");
+ expect(result.getDate()).toBe(1);
+ });
+
+ test("subtracts months correctly", () => {
+ const date = new Date("2024-03-15T12:00:00Z");
+ const result = subtractTimeUnit(date, 2, "months");
+ expect(result.getMonth()).toBe(0); // January
+ });
+
+ test("subtracts years correctly", () => {
+ const date = new Date("2024-01-15T12:00:00Z");
+ const result = subtractTimeUnit(date, 1, "years");
+ expect(result.getFullYear()).toBe(2023);
+ });
+
+ test("does not modify original date", () => {
+ const date = new Date("2024-01-15T12:00:00Z");
+ const original = date.getTime();
+ subtractTimeUnit(date, 5, "days");
+ expect(date.getTime()).toBe(original);
+ });
+ });
+
+ describe("addTimeUnit", () => {
+ test("adds days correctly", () => {
+ const date = new Date("2024-01-15T12:00:00Z");
+ const result = addTimeUnit(date, 5, "days");
+ expect(result.getDate()).toBe(20);
+ });
+
+ test("adds weeks correctly", () => {
+ const date = new Date("2024-01-15T12:00:00Z");
+ const result = addTimeUnit(date, 2, "weeks");
+ expect(result.getDate()).toBe(29);
+ });
+
+ test("adds months correctly", () => {
+ const date = new Date("2024-01-15T12:00:00Z");
+ const result = addTimeUnit(date, 2, "months");
+ expect(result.getMonth()).toBe(2); // March
+ });
+
+ test("adds years correctly", () => {
+ const date = new Date("2024-01-15T12:00:00Z");
+ const result = addTimeUnit(date, 1, "years");
+ expect(result.getFullYear()).toBe(2025);
+ });
+ });
+
+ describe("startOfDay", () => {
+ test("sets time to 00:00:00.000 UTC", () => {
+ const date = new Date("2024-01-15T14:30:45.123Z");
+ const result = startOfDay(date);
+ expect(result.getUTCHours()).toBe(0);
+ expect(result.getUTCMinutes()).toBe(0);
+ expect(result.getUTCSeconds()).toBe(0);
+ expect(result.getUTCMilliseconds()).toBe(0);
+ expect(result.getUTCDate()).toBe(date.getUTCDate());
+ });
+ });
+
+ describe("endOfDay", () => {
+ test("sets time to 23:59:59.999 UTC", () => {
+ const date = new Date("2024-01-15T14:30:45.123Z");
+ const result = endOfDay(date);
+ expect(result.getUTCHours()).toBe(23);
+ expect(result.getUTCMinutes()).toBe(59);
+ expect(result.getUTCSeconds()).toBe(59);
+ expect(result.getUTCMilliseconds()).toBe(999);
+ expect(result.getUTCDate()).toBe(date.getUTCDate());
+ });
+ });
+
+ describe("isSameDay", () => {
+ test("returns true for dates on the same day", () => {
+ const date1 = new Date("2024-01-15T10:00:00Z");
+ const date2 = new Date("2024-01-15T22:00:00Z");
+ expect(isSameDay(date1, date2)).toBe(true);
+ });
+
+ test("returns false for dates on different days", () => {
+ const date1 = new Date("2024-01-15T23:59:59Z");
+ const date2 = new Date("2024-01-16T00:00:01Z");
+ expect(isSameDay(date1, date2)).toBe(false);
+ });
+
+ test("returns false for dates in different months", () => {
+ const date1 = new Date("2024-01-31T12:00:00Z");
+ const date2 = new Date("2024-02-01T12:00:00Z");
+ expect(isSameDay(date1, date2)).toBe(false);
+ });
+
+ test("returns false for dates in different years", () => {
+ const date1 = new Date("2023-12-31T12:00:00Z");
+ const date2 = new Date("2024-01-01T12:00:00Z");
+ expect(isSameDay(date1, date2)).toBe(false);
+ });
+ });
+});
diff --git a/apps/web/modules/ee/contacts/segments/lib/date-utils.ts b/apps/web/modules/ee/contacts/segments/lib/date-utils.ts
new file mode 100644
index 0000000000..dcc9303a34
--- /dev/null
+++ b/apps/web/modules/ee/contacts/segments/lib/date-utils.ts
@@ -0,0 +1,105 @@
+import { TTimeUnit } from "@formbricks/types/segment";
+
+/**
+ * Subtracts a time unit from a date
+ * @param date - The date to subtract from
+ * @param amount - The amount of time units to subtract
+ * @param unit - The time unit (days, weeks, months, years)
+ * @returns A new Date object with the time subtracted
+ */
+export const subtractTimeUnit = (date: Date, amount: number, unit: TTimeUnit): Date => {
+ const result = new Date(date);
+
+ switch (unit) {
+ case "days":
+ result.setDate(result.getDate() - amount);
+ break;
+ case "weeks":
+ result.setDate(result.getDate() - amount * 7);
+ break;
+ case "months":
+ result.setMonth(result.getMonth() - amount);
+ break;
+ case "years":
+ result.setFullYear(result.getFullYear() - amount);
+ break;
+ }
+
+ return result;
+};
+
+/**
+ * Adds a time unit to a date
+ * @param date - The date to add to
+ * @param amount - The amount of time units to add
+ * @param unit - The time unit (days, weeks, months, years)
+ * @returns A new Date object with the time added
+ */
+export const addTimeUnit = (date: Date, amount: number, unit: TTimeUnit): Date => {
+ const result = new Date(date);
+
+ switch (unit) {
+ case "days":
+ result.setDate(result.getDate() + amount);
+ break;
+ case "weeks":
+ result.setDate(result.getDate() + amount * 7);
+ break;
+ case "months":
+ result.setMonth(result.getMonth() + amount);
+ break;
+ case "years":
+ result.setFullYear(result.getFullYear() + amount);
+ break;
+ }
+
+ return result;
+};
+
+/**
+ * Gets the start of a day in UTC (00:00:00.000 UTC)
+ * @param date - The date to get the start of
+ * @returns A new Date object at the start of the day in UTC
+ */
+export const startOfDay = (date: Date): Date => {
+ const result = new Date(date);
+ result.setUTCHours(0, 0, 0, 0);
+ return result;
+};
+
+/**
+ * Gets the end of a day in UTC (23:59:59.999 UTC)
+ * @param date - The date to get the end of
+ * @returns A new Date object at the end of the day in UTC
+ */
+export const endOfDay = (date: Date): Date => {
+ const result = new Date(date);
+ result.setUTCHours(23, 59, 59, 999);
+ return result;
+};
+
+/**
+ * Checks if two dates are on the same day in UTC (ignoring time)
+ * @param date1 - The first date
+ * @param date2 - The second date
+ * @returns True if the dates are on the same UTC day
+ */
+export const isSameDay = (date1: Date, date2: Date): boolean => {
+ return (
+ date1.getUTCFullYear() === date2.getUTCFullYear() &&
+ date1.getUTCMonth() === date2.getUTCMonth() &&
+ date1.getUTCDate() === date2.getUTCDate()
+ );
+};
+
+/**
+ * Converts a date-only string (YYYY-MM-DD) to an ISO string at midnight UTC.
+ * This avoids timezone issues where local timezone conversion can shift the day.
+ * @param dateString - The date string in YYYY-MM-DD format
+ * @returns An ISO string at midnight UTC, or empty string if input is empty
+ */
+export const toUTCDateString = (dateString: string): string => {
+ if (!dateString) return "";
+ const [year, month, day] = dateString.split("-").map(Number);
+ return new Date(Date.UTC(year, month - 1, day)).toISOString();
+};
diff --git a/apps/web/modules/ee/contacts/segments/lib/filter/prisma-query.test.ts b/apps/web/modules/ee/contacts/segments/lib/filter/prisma-query.test.ts
index 98755954f3..c013f66e02 100644
--- a/apps/web/modules/ee/contacts/segments/lib/filter/prisma-query.test.ts
+++ b/apps/web/modules/ee/contacts/segments/lib/filter/prisma-query.test.ts
@@ -1,8 +1,17 @@
+import { Prisma } from "@prisma/client";
import { afterEach, beforeEach, describe, expect, test, vi } from "vitest";
-import { TBaseFilters, TSegment } from "@formbricks/types/segment";
+import { TBaseFilters, TSegmentWithSurveyNames } from "@formbricks/types/segment";
import { getSegment } from "../segments";
import { segmentFilterToPrismaQuery } from "./prisma-query";
+const mockQueryRawUnsafe = vi.fn();
+
+vi.mock("@formbricks/database", () => ({
+ prisma: {
+ $queryRawUnsafe: (...args: unknown[]) => mockQueryRawUnsafe(...args),
+ },
+}));
+
vi.mock("../segments", () => ({
getSegment: vi.fn(),
}));
@@ -17,6 +26,8 @@ describe("segmentFilterToPrismaQuery", () => {
beforeEach(() => {
vi.clearAllMocks();
+ // Default mock: number filter raw SQL returns one matching contact
+ mockQueryRawUnsafe.mockResolvedValue([{ contactId: "mock-contact-1" }]);
});
afterEach(() => {
@@ -134,16 +145,7 @@ describe("segmentFilterToPrismaQuery", () => {
},
},
],
- OR: [
- {
- attributes: {
- some: {
- attributeKey: { key: "age" },
- value: { gt: "30" },
- },
- },
- },
- ],
+ OR: [{ id: { in: ["mock-contact-1"] } }],
});
}
});
@@ -206,8 +208,8 @@ describe("segmentFilterToPrismaQuery", () => {
const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
if (result.ok) {
- const nestedConditionsAnd = result.data.whereClause.AND?.[1].AND?.[0].AND;
- const nestedConditionsOr = result.data.whereClause.AND?.[1].AND?.[0].OR;
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput as any;
+ const nestedConditionsAnd = whereClause.AND?.[1].AND?.[0].AND;
expect(nestedConditionsAnd).toContainEqual({
attributes: {
some: {
@@ -226,14 +228,9 @@ describe("segmentFilterToPrismaQuery", () => {
},
});
- expect(nestedConditionsOr).toContainEqual({
- attributes: {
- some: {
- attributeKey: { key: "device" },
- value: { equals: "phone", mode: "insensitive" },
- },
- },
- });
+ // Note: Device filters are evaluated at runtime (from User-Agent), not as database queries.
+ // When no deviceType is provided to segmentFilterToPrismaQuery, device filters return empty constraint.
+ // The OR clause will be empty or not present since device filter returns {}.
}
});
@@ -258,7 +255,7 @@ describe("segmentFilterToPrismaQuery", () => {
];
// Mock the getSegment function to return a segment with filters
- const mockSegment: Partial
= {
+ const mockSegment: TSegmentWithSurveyNames = {
id: nestedSegmentId,
filters: nestedFilters,
environmentId: mockEnvironmentId,
@@ -268,9 +265,11 @@ describe("segmentFilterToPrismaQuery", () => {
createdAt: new Date(),
updatedAt: new Date(),
surveys: [],
+ activeSurveys: [],
+ inactiveSurveys: [],
};
- vi.mocked(getSegment).mockResolvedValue(mockSegment as TSegment);
+ vi.mocked(getSegment).mockResolvedValue(mockSegment);
const filters: TBaseFilters = [
{
@@ -321,8 +320,8 @@ describe("segmentFilterToPrismaQuery", () => {
];
// Mock getSegment to return null for the non-existent segment
- vi.mocked(getSegment).mockResolvedValueOnce(mockSegment as TSegment);
- vi.mocked(getSegment).mockResolvedValueOnce(null as unknown as TSegment);
+ vi.mocked(getSegment).mockResolvedValueOnce(mockSegment);
+ vi.mocked(getSegment).mockResolvedValueOnce(null as unknown as TSegmentWithSurveyNames);
const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
@@ -412,7 +411,7 @@ describe("segmentFilterToPrismaQuery", () => {
];
// Mock the getSegment function to return a segment with filters
- const mockSegment: Partial = {
+ const mockSegment: TSegmentWithSurveyNames = {
id: nestedSegmentId,
filters: nestedFilters,
environmentId: mockEnvironmentId,
@@ -422,9 +421,11 @@ describe("segmentFilterToPrismaQuery", () => {
createdAt: new Date(),
updatedAt: new Date(),
surveys: [],
+ activeSurveys: [],
+ inactiveSurveys: [],
};
- vi.mocked(getSegment).mockResolvedValue(mockSegment as TSegment);
+ vi.mocked(getSegment).mockResolvedValue(mockSegment);
const filters: TBaseFilters = [
{
@@ -474,7 +475,7 @@ describe("segmentFilterToPrismaQuery", () => {
test("handle circular references in segment filters", async () => {
// Mock getSegment to simulate a circular reference
- const circularSegment: Partial = {
+ const circularSegment: TSegmentWithSurveyNames = {
id: mockSegmentId, // Same ID creates the circular reference
filters: [
{
@@ -500,9 +501,11 @@ describe("segmentFilterToPrismaQuery", () => {
createdAt: new Date(),
updatedAt: new Date(),
surveys: [],
+ activeSurveys: [],
+ inactiveSurveys: [],
};
- vi.mocked(getSegment).mockResolvedValue(circularSegment as TSegment);
+ vi.mocked(getSegment).mockResolvedValue(circularSegment);
const filters: TBaseFilters = [
{
@@ -532,7 +535,7 @@ describe("segmentFilterToPrismaQuery", () => {
test("handle missing segments in segment filters", async () => {
const nestedSegmentId = "segment-missing-123";
- vi.mocked(getSegment).mockResolvedValue(null as unknown as TSegment);
+ vi.mocked(getSegment).mockResolvedValue(null as unknown as TSegmentWithSurveyNames);
const filters: TBaseFilters = [
{
@@ -581,7 +584,7 @@ describe("segmentFilterToPrismaQuery", () => {
];
// Mock the nested segment
- const mockNestedSegment: TSegment = {
+ const mockNestedSegment: TSegmentWithSurveyNames = {
id: nestedSegmentId,
filters: nestedFilters,
environmentId: mockEnvironmentId,
@@ -591,6 +594,8 @@ describe("segmentFilterToPrismaQuery", () => {
createdAt: new Date(),
updatedAt: new Date(),
surveys: [],
+ activeSurveys: [],
+ inactiveSurveys: [],
};
vi.mocked(getSegment).mockResolvedValue(mockNestedSegment);
@@ -727,7 +732,7 @@ describe("segmentFilterToPrismaQuery", () => {
expect(result.ok).toBe(true);
if (result.ok) {
- const whereClause = result.data.whereClause.AND?.[1];
+ const whereClause = (result.data.whereClause as Prisma.ContactWhereInput).AND?.[1] as any;
expect(whereClause).toBeDefined();
// First group (AND conditions)
@@ -752,12 +757,7 @@ describe("segmentFilterToPrismaQuery", () => {
});
expect(subgroup.AND[0].AND[2]).toStrictEqual({
- attributes: {
- some: {
- attributeKey: { key: "age" },
- value: { gte: "18" },
- },
- },
+ id: { in: ["mock-contact-1"] },
});
// Segment inclusion
@@ -770,18 +770,12 @@ describe("segmentFilterToPrismaQuery", () => {
},
});
- // Device filter (OR condition)
- expect(whereClause.AND[0].OR[0]).toStrictEqual({
- attributes: {
- some: {
- attributeKey: { key: "device" },
- value: { not: "desktop", mode: "insensitive" },
- },
- },
- });
+ // Note: Device filters are evaluated at runtime (from User-Agent), not as database queries.
+ // When no deviceType is provided to segmentFilterToPrismaQuery, device filters return empty constraint.
+ // So we check the person filter which should be in OR[0] since device filter is skipped.
- // Person filter (OR condition)
- expect(whereClause.AND[0].OR[1]).toStrictEqual({
+ // Person filter (OR condition) - device filter returns {} so person filter is at OR[0]
+ expect(whereClause.AND[0].OR[0]).toStrictEqual({
attributes: {
some: {
attributeKey: { key: "userId" },
@@ -874,7 +868,7 @@ describe("segmentFilterToPrismaQuery", () => {
];
// Set up the mocks
- const mockCircularSegment: TSegment = {
+ const mockCircularSegment: TSegmentWithSurveyNames = {
id: circularSegmentId,
filters: circularFilters,
environmentId: mockEnvironmentId,
@@ -884,9 +878,11 @@ describe("segmentFilterToPrismaQuery", () => {
createdAt: new Date(),
updatedAt: new Date(),
surveys: [],
+ activeSurveys: [],
+ inactiveSurveys: [],
};
- const mockSecondSegment: TSegment = {
+ const mockSecondSegment: TSegmentWithSurveyNames = {
id: secondSegmentId,
filters: secondFilters,
environmentId: mockEnvironmentId,
@@ -896,13 +892,15 @@ describe("segmentFilterToPrismaQuery", () => {
createdAt: new Date(),
updatedAt: new Date(),
surveys: [],
+ activeSurveys: [],
+ inactiveSurveys: [],
};
// Set up the sequence of mock calls for different segments
vi.mocked(getSegment)
.mockResolvedValueOnce(mockCircularSegment) // First call for circularSegmentId
.mockResolvedValueOnce(mockSecondSegment) // Third call for secondSegmentId
- .mockResolvedValueOnce(null as unknown as TSegment); // Fourth call for non-existent-segment
+ .mockResolvedValueOnce(null as unknown as TSegmentWithSurveyNames); // Fourth call for non-existent-segment
// Complex filters with mixed error conditions
const filters: TBaseFilters = [
@@ -957,8 +955,9 @@ describe("segmentFilterToPrismaQuery", () => {
expect(result.ok).toBe(true);
if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput as any;
// The circularSegmentId should be detected as circular and return an empty object
- expect(result.data.whereClause.AND?.[1].AND[0].AND).toContainEqual({
+ expect(whereClause.AND?.[1].AND[0].AND).toContainEqual({
attributes: {
some: {
attributeKey: {
@@ -969,15 +968,8 @@ describe("segmentFilterToPrismaQuery", () => {
},
});
- // The device filter should still work
- expect(result.data.whereClause.AND?.[1].AND[2]).toStrictEqual({
- attributes: {
- some: {
- attributeKey: { key: "device" },
- value: { equals: "unknownValue", mode: "insensitive" },
- },
- },
- });
+ // Note: Device filters are evaluated at runtime (from User-Agent), not as database queries.
+ // When no deviceType is provided to segmentFilterToPrismaQuery, device filters return empty constraint.
}
});
@@ -1136,7 +1128,7 @@ describe("segmentFilterToPrismaQuery", () => {
expect(result.ok).toBe(true);
if (result.ok) {
- const whereClause = result.data.whereClause.AND?.[1];
+ const whereClause = (result.data.whereClause as Prisma.ContactWhereInput as any).AND?.[1];
// First subgroup (text operators)
const firstSubgroup = whereClause.AND?.[0];
@@ -1166,24 +1158,10 @@ describe("segmentFilterToPrismaQuery", () => {
},
});
- // Second subgroup (numeric operators)
+ // Second subgroup (numeric operators - now use raw SQL subquery returning contact IDs)
const secondSubgroup = whereClause.AND?.[0];
expect(secondSubgroup.AND[1].AND).toContainEqual({
- attributes: {
- some: {
- attributeKey: { key: "loginCount" },
- value: { gt: "5" },
- },
- },
- });
-
- expect(secondSubgroup.AND[1].AND).toContainEqual({
- attributes: {
- some: {
- attributeKey: { key: "purchaseAmount" },
- value: { lte: "1000" },
- },
- },
+ id: { in: ["mock-contact-1"] },
});
// Third subgroup (negation operators in OR clause)
@@ -1217,4 +1195,455 @@ describe("segmentFilterToPrismaQuery", () => {
});
}
});
+
+ // ==========================================
+ // DATE FILTER TESTS
+ // ==========================================
+
+ describe("date attribute filters", () => {
+ test("handle isBefore date operator", async () => {
+ const targetDate = "2024-06-15";
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "purchaseDate",
+ },
+ value: targetDate,
+ qualifier: {
+ operator: "isBefore",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ expect(filterClause).toEqual({
+ AND: [
+ {
+ attributes: {
+ some: {
+ attributeKey: { key: "purchaseDate" },
+ OR: [
+ { valueDate: { lt: new Date(targetDate) } },
+ { valueDate: null, value: { lt: new Date(targetDate).toISOString() } },
+ ],
+ },
+ },
+ },
+ ],
+ });
+ }
+ });
+
+ test("handle isAfter date operator", async () => {
+ const targetDate = "2024-01-01";
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "signupDate",
+ },
+ value: targetDate,
+ qualifier: {
+ operator: "isAfter",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ expect(filterClause).toEqual({
+ AND: [
+ {
+ attributes: {
+ some: {
+ attributeKey: { key: "signupDate" },
+ OR: [
+ { valueDate: { gt: new Date(targetDate) } },
+ { valueDate: null, value: { gt: new Date(targetDate).toISOString() } },
+ ],
+ },
+ },
+ },
+ ],
+ });
+ }
+ });
+
+ test("handle isBetween date operator", async () => {
+ const startDate = "2024-01-01";
+ const endDate = "2024-12-31";
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "lastActivityDate",
+ },
+ value: [startDate, endDate],
+ qualifier: {
+ operator: "isBetween",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ expect(filterClause).toEqual({
+ AND: [
+ {
+ attributes: {
+ some: {
+ attributeKey: { key: "lastActivityDate" },
+ OR: [
+ { valueDate: { gte: new Date(startDate), lte: new Date(endDate) } },
+ {
+ valueDate: null,
+ value: {
+ gte: new Date(startDate).toISOString(),
+ lte: new Date(endDate).toISOString(),
+ },
+ },
+ ],
+ },
+ },
+ },
+ ],
+ });
+ }
+ });
+
+ test("handle isSameDay date operator", async () => {
+ const targetDate = "2024-07-04";
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "eventDate",
+ },
+ value: targetDate,
+ qualifier: {
+ operator: "isSameDay",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ // isSameDay should generate OR with valueDate and string fallback
+ const dateAttr = (filterClause as unknown as any)?.AND?.[0]?.attributes;
+ expect(dateAttr).toBeDefined();
+ const orConditions = dateAttr?.some?.OR;
+ expect(orConditions).toHaveLength(2);
+ const valueDate = orConditions?.[0]?.valueDate;
+ expect(valueDate).toHaveProperty("gte");
+ expect(valueDate).toHaveProperty("lte");
+ // Verify the date range is for the same day
+ const gteDate = valueDate.gte as Date;
+ const lteDate = valueDate.lte as Date;
+ expect(gteDate.getUTCFullYear()).toBe(2024);
+ expect(gteDate.getUTCMonth()).toBe(6); // July is month 6 (0-indexed)
+ expect(gteDate.getUTCDate()).toBe(4);
+ expect(gteDate.getUTCHours()).toBe(0);
+ expect(gteDate.getUTCMinutes()).toBe(0);
+ expect(lteDate.getUTCFullYear()).toBe(2024);
+ expect(lteDate.getUTCMonth()).toBe(6);
+ expect(lteDate.getUTCDate()).toBe(4);
+ expect(lteDate.getUTCHours()).toBe(23);
+ expect(lteDate.getUTCMinutes()).toBe(59);
+ }
+ });
+
+ test("handle isOlderThan date operator with days unit", async () => {
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "accountCreatedAt",
+ },
+ value: { amount: 30, unit: "days" },
+ qualifier: {
+ operator: "isOlderThan",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ const dateAttr = (filterClause as unknown as any)?.AND?.[0]?.attributes;
+ expect(dateAttr).toBeDefined();
+ const orConditions = dateAttr?.some?.OR;
+ expect(orConditions).toHaveLength(2);
+ const valueDate = orConditions?.[0]?.valueDate;
+ expect(valueDate).toHaveProperty("lt");
+ // The threshold should be approximately 30 days ago
+ const threshold = valueDate.lt as Date;
+ const now = new Date();
+ const diffMs = now.getTime() - threshold.getTime();
+ const diffDays = diffMs / (1000 * 60 * 60 * 24);
+ // Allow some tolerance for test execution time
+ expect(diffDays).toBeGreaterThanOrEqual(29.9);
+ expect(diffDays).toBeLessThanOrEqual(30.1);
+ }
+ });
+
+ test("handle isNewerThan date operator with weeks unit", async () => {
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "lastPurchaseDate",
+ },
+ value: { amount: 2, unit: "weeks" },
+ qualifier: {
+ operator: "isNewerThan",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ const dateAttr = (filterClause as unknown as any)?.AND?.[0]?.attributes;
+ expect(dateAttr).toBeDefined();
+ const orConditions = dateAttr?.some?.OR;
+ expect(orConditions).toHaveLength(2);
+ const valueDate = orConditions?.[0]?.valueDate;
+ expect(valueDate).toHaveProperty("gte");
+ // The threshold should be approximately 2 weeks (14 days) ago
+ const threshold = valueDate.gte as Date;
+ const now = new Date();
+ const diffMs = now.getTime() - threshold.getTime();
+ const diffDays = diffMs / (1000 * 60 * 60 * 24);
+ expect(diffDays).toBeGreaterThanOrEqual(13.9);
+ expect(diffDays).toBeLessThanOrEqual(14.1);
+ }
+ });
+
+ test("handle isOlderThan date operator with months unit", async () => {
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "subscriptionStartDate",
+ },
+ value: { amount: 6, unit: "months" },
+ qualifier: {
+ operator: "isOlderThan",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ const dateAttr = (filterClause as unknown as any)?.AND?.[0]?.attributes;
+ expect(dateAttr).toBeDefined();
+ const orConditions = dateAttr?.some?.OR;
+ expect(orConditions).toHaveLength(2);
+ const valueDate = orConditions?.[0]?.valueDate;
+ expect(valueDate).toHaveProperty("lt");
+ // The threshold should be approximately 6 months ago
+ const threshold = valueDate.lt as Date;
+ const now = new Date();
+ // Calculate expected threshold (approximately 6 months ago)
+ const expectedThreshold = new Date(now);
+ expectedThreshold.setMonth(expectedThreshold.getMonth() - 6);
+ // Allow 2 day tolerance for month boundary differences
+ const diffMs = Math.abs(threshold.getTime() - expectedThreshold.getTime());
+ const diffDays = diffMs / (1000 * 60 * 60 * 24);
+ expect(diffDays).toBeLessThanOrEqual(2);
+ }
+ });
+
+ test("handle multiple date filters with AND connector", async () => {
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "signupDate",
+ },
+ value: "2024-01-01",
+ qualifier: {
+ operator: "isAfter",
+ },
+ },
+ },
+ {
+ id: "filter_2",
+ connector: "and",
+ resource: {
+ id: "attr_2",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "lastActivityDate",
+ },
+ value: { amount: 7, unit: "days" },
+ qualifier: {
+ operator: "isNewerThan",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ const andConditions = (filterClause as unknown as any).AND as Prisma.ContactWhereInput[];
+ expect(andConditions).toHaveLength(2);
+
+ // First filter: isAfter (with OR fallback for transition)
+ const firstFilter = andConditions[0] as unknown as any;
+ expect(firstFilter.attributes.some.attributeKey.key).toBe("signupDate");
+ expect(firstFilter.attributes.some.OR[0].valueDate.gt).toEqual(new Date("2024-01-01"));
+ expect(firstFilter.attributes.some.OR[1].valueDate).toBeNull();
+ expect(firstFilter.attributes.some.OR[1].value.gt).toBe(new Date("2024-01-01").toISOString());
+
+ // Second filter: isNewerThan (with OR fallback for transition)
+ const secondFilter = andConditions[1] as unknown as any;
+ expect(secondFilter.attributes.some.attributeKey.key).toBe("lastActivityDate");
+ expect(secondFilter.attributes.some.OR[0].valueDate).toHaveProperty("gte");
+ }
+ });
+
+ test("handle date filter combined with string and number filters", async () => {
+ const filters: TBaseFilters = [
+ {
+ id: "filter_1",
+ connector: null,
+ resource: {
+ id: "attr_1",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "plan",
+ },
+ value: "premium",
+ qualifier: {
+ operator: "equals",
+ },
+ },
+ },
+ {
+ id: "filter_2",
+ connector: "and",
+ resource: {
+ id: "attr_2",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "purchaseCount",
+ },
+ value: 5,
+ qualifier: {
+ operator: "greaterThan",
+ },
+ },
+ },
+ {
+ id: "filter_3",
+ connector: "and",
+ resource: {
+ id: "attr_3",
+ root: {
+ type: "attribute" as const,
+ contactAttributeKey: "lastPurchaseDate",
+ },
+ value: { amount: 30, unit: "days" },
+ qualifier: {
+ operator: "isNewerThan",
+ },
+ },
+ },
+ ];
+
+ const result = await segmentFilterToPrismaQuery(mockSegmentId, filters, mockEnvironmentId);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ const whereClause = result.data.whereClause as Prisma.ContactWhereInput;
+ const filterClause = (whereClause.AND as Prisma.ContactWhereInput[])?.[1];
+ const andConditions = (filterClause as unknown as any).AND as Prisma.ContactWhereInput[];
+ expect(andConditions).toHaveLength(3);
+
+ // String filter uses 'value'
+ expect((andConditions[0] as unknown as any).attributes.some.value).toEqual({
+ equals: "premium",
+ mode: "insensitive",
+ });
+
+ // Number filter uses raw SQL subquery (transition code) returning contact IDs
+ expect(andConditions[1]).toEqual({ id: { in: ["mock-contact-1"] } });
+
+ // Date filter uses OR fallback with 'valueDate' and string 'value'
+ expect((andConditions[2] as unknown as any).attributes.some.OR[0].valueDate).toHaveProperty("gte");
+ }
+ });
+ });
});
diff --git a/apps/web/modules/ee/contacts/segments/lib/filter/prisma-query.ts b/apps/web/modules/ee/contacts/segments/lib/filter/prisma-query.ts
index ba3ffa4c1e..c825aab4e9 100644
--- a/apps/web/modules/ee/contacts/segments/lib/filter/prisma-query.ts
+++ b/apps/web/modules/ee/contacts/segments/lib/filter/prisma-query.ts
@@ -1,27 +1,175 @@
import { Prisma } from "@prisma/client";
import { cache as reactCache } from "react";
+import { prisma } from "@formbricks/database";
import { logger } from "@formbricks/logger";
import { err, ok } from "@formbricks/types/error-handlers";
import {
+ DATE_OPERATORS,
TBaseFilters,
+ TDateOperator,
+ TRelativeDateValue,
TSegmentAttributeFilter,
TSegmentDeviceFilter,
TSegmentFilter,
+ TSegmentFilterValue,
TSegmentPersonFilter,
TSegmentSegmentFilter,
+ ZRelativeDateValue,
} from "@formbricks/types/segment";
import { isResourceFilter } from "@/modules/ee/contacts/segments/lib/utils";
+import { endOfDay, startOfDay, subtractTimeUnit } from "../date-utils";
import { getSegment } from "../segments";
+// SQL operator mapping for number filters
+const SQL_OPERATORS: Record = {
+ greaterThan: ">",
+ greaterEqual: ">=",
+ lessThan: "<",
+ lessEqual: "<=",
+};
+
+// Regex pattern for validating numeric strings in SQL
+const NUMBER_PATTERN_SQL = "^-?[0-9]+(\\.[0-9]+)?$";
+
// Type for the result of the segment filter to prisma query generation
export type SegmentFilterQueryResult = {
whereClause: Prisma.ContactWhereInput;
};
+const valueIsRelativeDateValue = (value: TSegmentFilterValue): value is TRelativeDateValue => {
+ return ZRelativeDateValue.safeParse(value).success;
+};
+
+/**
+ * Builds a Prisma where clause for date attribute filters.
+ * Uses an OR fallback to handle both migrated rows (valueDate populated)
+ * and un-migrated rows (valueDate NULL, value contains ISO string).
+ * ISO 8601 strings sort lexicographically correctly, so string gt/lt works.
+ */
+const buildDateAttributeFilterWhereClause = (filter: TSegmentAttributeFilter): Prisma.ContactWhereInput => {
+ const { root, qualifier, value } = filter;
+ const { contactAttributeKey } = root;
+ const { operator } = qualifier as { operator: TDateOperator };
+ const now = new Date();
+
+ let dateCondition: Prisma.DateTimeNullableFilter = {};
+ let stringDateCondition: Prisma.StringFilter = {};
+
+ switch (operator) {
+ case "isOlderThan": {
+ if (valueIsRelativeDateValue(value)) {
+ const threshold = subtractTimeUnit(now, value.amount, value.unit);
+ dateCondition = { lt: threshold };
+ stringDateCondition = { lt: threshold.toISOString() };
+ }
+ break;
+ }
+ case "isNewerThan": {
+ if (valueIsRelativeDateValue(value)) {
+ const threshold = subtractTimeUnit(now, value.amount, value.unit);
+ dateCondition = { gte: threshold };
+ stringDateCondition = { gte: threshold.toISOString() };
+ }
+ break;
+ }
+ case "isBefore":
+ if (typeof value === "string") {
+ dateCondition = { lt: new Date(value) };
+ stringDateCondition = { lt: new Date(value).toISOString() };
+ }
+ break;
+ case "isAfter":
+ if (typeof value === "string") {
+ dateCondition = { gt: new Date(value) };
+ stringDateCondition = { gt: new Date(value).toISOString() };
+ }
+ break;
+ case "isBetween":
+ if (Array.isArray(value) && value.length === 2) {
+ dateCondition = { gte: new Date(value[0]), lte: new Date(value[1]) };
+ stringDateCondition = {
+ gte: new Date(value[0]).toISOString(),
+ lte: new Date(value[1]).toISOString(),
+ };
+ }
+ break;
+ case "isSameDay": {
+ if (typeof value === "string") {
+ const dayStart = startOfDay(new Date(value));
+ const dayEnd = endOfDay(new Date(value));
+ dateCondition = { gte: dayStart, lte: dayEnd };
+ stringDateCondition = { gte: dayStart.toISOString(), lte: dayEnd.toISOString() };
+ }
+ break;
+ }
+ }
+
+ return {
+ attributes: {
+ some: {
+ attributeKey: { key: contactAttributeKey },
+ OR: [{ valueDate: dateCondition }, { valueDate: null, value: stringDateCondition }],
+ },
+ },
+ };
+};
+
+/**
+ * Builds a Prisma where clause for number attribute filters.
+ * Uses a raw SQL subquery to handle both migrated rows (valueNumber populated)
+ * and un-migrated rows (valueNumber NULL, value contains numeric string).
+ * This is transition code for the deferred value backfill.
+ *
+ * TODO: After the backfill script has been run and all valueNumber columns are populated,
+ * revert this to the clean Prisma-only version that queries valueNumber directly.
+ */
+const buildNumberAttributeFilterWhereClause = async (
+ filter: TSegmentAttributeFilter
+): Promise => {
+ const { root, qualifier, value } = filter;
+ const { contactAttributeKey } = root;
+ const { operator } = qualifier;
+
+ const numericValue = typeof value === "number" ? value : Number(value);
+ const sqlOp = SQL_OPERATORS[operator];
+
+ if (!sqlOp) {
+ return {};
+ }
+
+ const matchingContactIds = await prisma.$queryRawUnsafe<{ contactId: string }[]>(
+ `
+ SELECT DISTINCT ca."contactId"
+ FROM "ContactAttribute" ca
+ JOIN "ContactAttributeKey" cak ON ca."attributeKeyId" = cak.id
+ WHERE cak.key = $1
+ AND (
+ (ca."valueNumber" IS NOT NULL AND ca."valueNumber" ${sqlOp} $2)
+ OR
+ (ca."valueNumber" IS NULL AND ca.value ~ $3 AND ca.value::double precision ${sqlOp} $2)
+ )
+ `,
+ contactAttributeKey,
+ numericValue,
+ NUMBER_PATTERN_SQL
+ );
+
+ const contactIds = matchingContactIds.map((r) => r.contactId);
+
+ if (contactIds.length === 0) {
+ // Return an impossible condition so the filter correctly excludes all contacts
+ return { id: "__NUMBER_FILTER_NO_MATCH__" };
+ }
+
+ return { id: { in: contactIds } };
+};
+
/**
* Builds a Prisma where clause from a segment attribute filter
*/
-const buildAttributeFilterWhereClause = (filter: TSegmentAttributeFilter): Prisma.ContactWhereInput => {
+const buildAttributeFilterWhereClause = async (
+ filter: TSegmentAttributeFilter
+): Promise => {
const { root, qualifier, value } = filter;
const { contactAttributeKey } = root;
const { operator } = qualifier;
@@ -60,40 +208,42 @@ const buildAttributeFilterWhereClause = (filter: TSegmentAttributeFilter): Prism
},
} satisfies Prisma.ContactWhereInput;
+ // Handle date operators
+ if (DATE_OPERATORS.includes(operator as TDateOperator)) {
+ return buildDateAttributeFilterWhereClause(filter);
+ }
+
+ // Handle number operators
+ if (["greaterThan", "greaterEqual", "lessThan", "lessEqual"].includes(operator)) {
+ return await buildNumberAttributeFilterWhereClause(filter);
+ }
+
+ // For string operators, ensure value is a primitive (not an object or array)
+ // This handles cases where value might be { amount, unit } or [start, end] from date/range filters
+ const stringValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+
// Apply the appropriate operator to the attribute value
switch (operator) {
case "equals":
- valueQuery.attributes.some.value = { equals: String(value), mode: "insensitive" };
+ valueQuery.attributes.some.value = { equals: stringValue, mode: "insensitive" };
break;
case "notEquals":
- valueQuery.attributes.some.value = { not: String(value), mode: "insensitive" };
+ valueQuery.attributes.some.value = { not: stringValue, mode: "insensitive" };
break;
case "contains":
- valueQuery.attributes.some.value = { contains: String(value), mode: "insensitive" };
+ valueQuery.attributes.some.value = { contains: stringValue, mode: "insensitive" };
break;
case "doesNotContain":
- valueQuery.attributes.some.value = { not: { contains: String(value) }, mode: "insensitive" };
+ valueQuery.attributes.some.value = { not: { contains: stringValue }, mode: "insensitive" };
break;
case "startsWith":
- valueQuery.attributes.some.value = { startsWith: String(value), mode: "insensitive" };
+ valueQuery.attributes.some.value = { startsWith: stringValue, mode: "insensitive" };
break;
case "endsWith":
- valueQuery.attributes.some.value = { endsWith: String(value), mode: "insensitive" };
- break;
- case "greaterThan":
- valueQuery.attributes.some.value = { gt: String(value) };
- break;
- case "greaterEqual":
- valueQuery.attributes.some.value = { gte: String(value) };
- break;
- case "lessThan":
- valueQuery.attributes.some.value = { lt: String(value) };
- break;
- case "lessEqual":
- valueQuery.attributes.some.value = { lte: String(value) };
+ valueQuery.attributes.some.value = { endsWith: stringValue, mode: "insensitive" };
break;
default:
- valueQuery.attributes.some.value = String(value);
+ valueQuery.attributes.some.value = stringValue;
}
return valueQuery;
@@ -102,7 +252,9 @@ const buildAttributeFilterWhereClause = (filter: TSegmentAttributeFilter): Prism
/**
* Builds a Prisma where clause from a person filter
*/
-const buildPersonFilterWhereClause = (filter: TSegmentPersonFilter): Prisma.ContactWhereInput => {
+const buildPersonFilterWhereClause = async (
+ filter: TSegmentPersonFilter
+): Promise => {
const { personIdentifier } = filter.root;
if (personIdentifier === "userId") {
@@ -113,7 +265,7 @@ const buildPersonFilterWhereClause = (filter: TSegmentPersonFilter): Prisma.Cont
contactAttributeKey: personIdentifier,
},
};
- return buildAttributeFilterWhereClause(personFilter);
+ return await buildAttributeFilterWhereClause(personFilter);
}
return {};
@@ -121,30 +273,39 @@ const buildPersonFilterWhereClause = (filter: TSegmentPersonFilter): Prisma.Cont
/**
* Builds a Prisma where clause from a device filter
+ * Since device type is a runtime property (from User-Agent), we evaluate it immediately
+ * and return either no constraint (match) or an impossible condition (no match)
*/
-const buildDeviceFilterWhereClause = (filter: TSegmentDeviceFilter): Prisma.ContactWhereInput => {
- const { root, qualifier, value } = filter;
- const { type } = root;
- const { operator } = qualifier;
-
- const baseQuery = {
- attributes: {
- some: {
- attributeKey: {
- key: type,
- },
- value: {},
- },
- },
- } satisfies Prisma.ContactWhereInput;
-
- if (operator === "equals") {
- baseQuery.attributes.some.value = { equals: String(value), mode: "insensitive" };
- } else if (operator === "notEquals") {
- baseQuery.attributes.some.value = { not: String(value), mode: "insensitive" };
+const buildDeviceFilterWhereClause = (
+ filter: TSegmentDeviceFilter,
+ deviceType?: "phone" | "desktop"
+): Prisma.ContactWhereInput => {
+ // If no device type provided, skip device filter (return no constraint)
+ if (!deviceType) {
+ return {};
}
- return baseQuery;
+ const { qualifier, value } = filter;
+ const { operator } = qualifier;
+
+ // Evaluate device filter immediately since it's a runtime property
+ let matches: boolean;
+ if (operator === "equals") {
+ matches = deviceType === value;
+ } else if (operator === "notEquals") {
+ matches = deviceType !== value;
+ } else {
+ matches = false;
+ }
+
+ if (matches) {
+ // Device matches - return empty constraint (effectively "true")
+ return {};
+ } else {
+ // Device doesn't match - return impossible condition (effectively "false")
+ // This ensures the query won't match any contacts
+ return { id: "__DEVICE_FILTER_NO_MATCH__" };
+ }
};
/**
@@ -152,7 +313,8 @@ const buildDeviceFilterWhereClause = (filter: TSegmentDeviceFilter): Prisma.Cont
*/
const buildSegmentFilterWhereClause = async (
filter: TSegmentSegmentFilter,
- segmentPath: Set
+ segmentPath: Set,
+ deviceType?: "phone" | "desktop"
): Promise => {
const { root } = filter;
const { segmentId } = root;
@@ -175,7 +337,7 @@ const buildSegmentFilterWhereClause = async (
const newPath = new Set(segmentPath);
newPath.add(segmentId);
- return processFilters(segment.filters, newPath);
+ return processFilters(segment.filters, newPath, deviceType);
};
/**
@@ -183,19 +345,20 @@ const buildSegmentFilterWhereClause = async (
*/
const processSingleFilter = async (
filter: TSegmentFilter,
- segmentPath: Set
+ segmentPath: Set,
+ deviceType?: "phone" | "desktop"
): Promise => {
const { root } = filter;
switch (root.type) {
case "attribute":
- return buildAttributeFilterWhereClause(filter as TSegmentAttributeFilter);
+ return await buildAttributeFilterWhereClause(filter as TSegmentAttributeFilter);
case "person":
- return buildPersonFilterWhereClause(filter as TSegmentPersonFilter);
+ return await buildPersonFilterWhereClause(filter as TSegmentPersonFilter);
case "device":
- return buildDeviceFilterWhereClause(filter as TSegmentDeviceFilter);
+ return buildDeviceFilterWhereClause(filter as TSegmentDeviceFilter, deviceType);
case "segment":
- return await buildSegmentFilterWhereClause(filter as TSegmentSegmentFilter, segmentPath);
+ return await buildSegmentFilterWhereClause(filter as TSegmentSegmentFilter, segmentPath, deviceType);
default:
return {};
}
@@ -206,7 +369,8 @@ const processSingleFilter = async (
*/
const processFilters = async (
filters: TBaseFilters,
- segmentPath: Set
+ segmentPath: Set,
+ deviceType?: "phone" | "desktop"
): Promise => {
if (filters.length === 0) return {};
@@ -222,10 +386,10 @@ const processFilters = async (
// Process the resource based on its type
if (isResourceFilter(resource)) {
// If it's a single filter, process it directly
- whereClause = await processSingleFilter(resource, segmentPath);
+ whereClause = await processSingleFilter(resource, segmentPath, deviceType);
} else {
// If it's a group of filters, process it recursively
- whereClause = await processFilters(resource, segmentPath);
+ whereClause = await processFilters(resource, segmentPath, deviceType);
}
if (Object.keys(whereClause).length === 0) continue;
@@ -249,9 +413,18 @@ const processFilters = async (
/**
* Transforms a segment filter into a Prisma query for contacts
+ * @param segmentId - The segment ID being evaluated
+ * @param filters - The segment filters
+ * @param environmentId - The environment ID
+ * @param deviceType - Optional device type for runtime device filter evaluation
*/
export const segmentFilterToPrismaQuery = reactCache(
- async (segmentId: string, filters: TBaseFilters, environmentId: string) => {
+ async (
+ segmentId: string,
+ filters: TBaseFilters,
+ environmentId: string,
+ deviceType?: "phone" | "desktop"
+ ) => {
try {
const baseWhereClause = {
environmentId,
@@ -259,7 +432,7 @@ export const segmentFilterToPrismaQuery = reactCache(
// Initialize an empty stack for tracking the current evaluation path
const segmentPath = new Set([segmentId]);
- const filtersWhereClause = await processFilters(filters, segmentPath);
+ const filtersWhereClause = await processFilters(filters, segmentPath, deviceType);
const whereClause = {
AND: [baseWhereClause, filtersWhereClause],
diff --git a/apps/web/modules/ee/contacts/segments/lib/segments.test.ts b/apps/web/modules/ee/contacts/segments/lib/segments.test.ts
index f1ed2792e6..acf5c6b57c 100644
--- a/apps/web/modules/ee/contacts/segments/lib/segments.test.ts
+++ b/apps/web/modules/ee/contacts/segments/lib/segments.test.ts
@@ -1,23 +1,15 @@
import { createId } from "@paralleldrive/cuid2";
-import { Prisma } from "@prisma/client";
import { beforeEach, describe, expect, test, vi } from "vitest";
import { prisma } from "@formbricks/database";
import { logger } from "@formbricks/logger";
-import {
- OperationNotAllowedError,
- ResourceNotFoundError,
- // Ensure ResourceNotFoundError is imported
- ValidationError,
-} from "@formbricks/types/errors";
+import { OperationNotAllowedError, ResourceNotFoundError, ValidationError } from "@formbricks/types/errors";
import {
TBaseFilters,
TEvaluateSegmentUserData,
- TSegment,
TSegmentCreateInput,
TSegmentUpdateInput,
+ TSegmentWithSurveyNames,
} from "@formbricks/types/segment";
-import { TSegmentFilter } from "@formbricks/types/segment";
-import { getEnvironment } from "@/lib/environment/service";
import { getSurvey } from "@/lib/survey/service";
import { validateInputs } from "@/lib/utils/validate";
import {
@@ -86,9 +78,11 @@ const mockSegmentPrisma = {
surveys: [{ id: surveyId, name: "Test Survey", status: "inProgress" }],
};
-const mockSegment: TSegment = {
+const mockSegment: TSegmentWithSurveyNames = {
...mockSegmentPrisma,
surveys: [surveyId],
+ activeSurveys: ["Test Survey"],
+ inactiveSurveys: [],
};
const mockSegmentCreateInput = {
@@ -108,7 +102,7 @@ const mockSurvey = {
describe("Segment Service Tests", () => {
describe("transformPrismaSegment", () => {
test("should transform Prisma segment to TSegment", () => {
- const transformed = transformPrismaSegment(mockSegmentPrisma);
+ const transformed = transformPrismaSegment(mockSegmentPrisma as unknown as PrismaSegment);
expect(transformed).toEqual(mockSegment);
});
});
@@ -221,7 +215,13 @@ describe("Segment Service Tests", () => {
id: clonedSegmentId,
title: "Copy of Test Segment (1)",
};
- const clonedSegment = { ...mockSegment, id: clonedSegmentId, title: "Copy of Test Segment (1)" };
+ const clonedSegment = {
+ ...mockSegment,
+ id: clonedSegmentId,
+ title: "Copy of Test Segment (1)",
+ activeSurveys: ["Test Survey"],
+ inactiveSurveys: [],
+ };
beforeEach(() => {
vi.mocked(prisma.segment.findUnique).mockResolvedValue(mockSegmentPrisma);
@@ -256,7 +256,12 @@ describe("Segment Service Tests", () => {
test("should clone a segment successfully with incremented suffix", async () => {
const existingCopyPrisma = { ...mockSegmentPrisma, id: "copy-1", title: "Copy of Test Segment (1)" };
const clonedSegmentPrisma2 = { ...clonedSegmentPrisma, title: "Copy of Test Segment (2)" };
- const clonedSegment2 = { ...clonedSegment, title: "Copy of Test Segment (2)" };
+ const clonedSegment2 = {
+ ...clonedSegment,
+ title: "Copy of Test Segment (2)",
+ activeSurveys: ["Test Survey"],
+ inactiveSurveys: [],
+ };
vi.mocked(prisma.segment.findMany).mockResolvedValue([mockSegmentPrisma, existingCopyPrisma]);
vi.mocked(prisma.segment.create).mockResolvedValue(clonedSegmentPrisma2);
@@ -289,7 +294,7 @@ describe("Segment Service Tests", () => {
describe("deleteSegment", () => {
const segmentToDeletePrisma = { ...mockSegmentPrisma, surveys: [] };
- const segmentToDelete = { ...mockSegment, surveys: [] };
+ const segmentToDelete = { ...mockSegment, surveys: [], activeSurveys: [], inactiveSurveys: [] };
beforeEach(() => {
vi.mocked(prisma.segment.findUnique).mockResolvedValue(segmentToDeletePrisma);
@@ -342,6 +347,8 @@ describe("Segment Service Tests", () => {
title: surveyId,
isPrivate: true,
filters: [],
+ activeSurveys: ["Test Survey"],
+ inactiveSurveys: [],
};
beforeEach(() => {
@@ -409,7 +416,12 @@ describe("Segment Service Tests", () => {
describe("updateSegment", () => {
const updatedSegmentPrisma = { ...mockSegmentPrisma, title: "Updated Segment" };
- const updatedSegment = { ...mockSegment, title: "Updated Segment" };
+ const updatedSegment = {
+ ...mockSegment,
+ title: "Updated Segment",
+ activeSurveys: ["Test Survey"],
+ inactiveSurveys: [],
+ };
const updateData: TSegmentUpdateInput = { title: "Updated Segment" };
beforeEach(() => {
@@ -447,7 +459,12 @@ describe("Segment Service Tests", () => {
...updatedSegmentPrisma,
surveys: [{ id: newSurveyId, name: "New Survey", status: "draft" }],
};
- const updatedSegmentWithSurvey = { ...updatedSegment, surveys: [newSurveyId] };
+ const updatedSegmentWithSurvey = {
+ ...updatedSegment,
+ surveys: [newSurveyId],
+ activeSurveys: [],
+ inactiveSurveys: ["New Survey"],
+ };
vi.mocked(prisma.segment.update).mockResolvedValue(updatedSegmentPrismaWithSurvey);
diff --git a/apps/web/modules/ee/contacts/segments/lib/segments.ts b/apps/web/modules/ee/contacts/segments/lib/segments.ts
index dc3990226a..30a8f9d9d1 100644
--- a/apps/web/modules/ee/contacts/segments/lib/segments.ts
+++ b/apps/web/modules/ee/contacts/segments/lib/segments.ts
@@ -10,8 +10,10 @@ import {
ValidationError,
} from "@formbricks/types/errors";
import {
+ DATE_OPERATORS,
TAllOperators,
TBaseFilters,
+ TDateOperator,
TEvaluateSegmentUserAttributeData,
TEvaluateSegmentUserData,
TSegment,
@@ -19,9 +21,12 @@ import {
TSegmentConnector,
TSegmentCreateInput,
TSegmentDeviceFilter,
+ TSegmentFilterValue,
TSegmentPersonFilter,
TSegmentSegmentFilter,
TSegmentUpdateInput,
+ TSegmentWithSurveyNames,
+ ZRelativeDateValue,
ZSegmentCreateInput,
ZSegmentFilters,
ZSegmentUpdateInput,
@@ -29,12 +34,15 @@ import {
import { getSurvey } from "@/lib/survey/service";
import { validateInputs } from "@/lib/utils/validate";
import { isResourceFilter, searchForAttributeKeyInSegment } from "@/modules/ee/contacts/segments/lib/utils";
+import { isSameDay, subtractTimeUnit } from "./date-utils";
export type PrismaSegment = Prisma.SegmentGetPayload<{
include: {
surveys: {
select: {
id: true;
+ name: true;
+ status: true;
};
};
};
@@ -58,14 +66,24 @@ export const selectSegment = {
},
} satisfies Prisma.SegmentSelect;
-export const transformPrismaSegment = (segment: PrismaSegment): TSegment => {
+export const transformPrismaSegment = (segment: PrismaSegment): TSegmentWithSurveyNames => {
+ const activeSurveys = segment.surveys
+ .filter((survey) => survey.status === "inProgress")
+ .map((survey) => survey.name);
+
+ const inactiveSurveys = segment.surveys
+ .filter((survey) => survey.status !== "inProgress")
+ .map((survey) => survey.name);
+
return {
...segment,
surveys: segment.surveys.map((survey) => survey.id),
+ activeSurveys,
+ inactiveSurveys,
};
};
-export const getSegment = reactCache(async (segmentId: string): Promise => {
+export const getSegment = reactCache(async (segmentId: string): Promise => {
validateInputs([segmentId, ZId]);
try {
const segment = await prisma.segment.findUnique({
@@ -89,7 +107,7 @@ export const getSegment = reactCache(async (segmentId: string): Promise => {
+export const getSegments = reactCache(async (environmentId: string): Promise => {
validateInputs([environmentId, ZId]);
try {
const segments = await prisma.segment.findMany({
@@ -381,13 +399,34 @@ const evaluateAttributeFilter = (
): boolean => {
const { value, qualifier, root } = filter;
const { contactAttributeKey } = root;
+ const { operator } = qualifier;
const attributeValue = attributes[contactAttributeKey];
- if (!attributeValue) {
+
+ // Handle isSet and isNotSet operators first - they have special logic
+ if (operator === "isSet") {
+ // Return true if the attribute exists and has a truthy value
+ return attributeValue !== undefined && attributeValue !== null && attributeValue !== "";
+ }
+
+ if (operator === "isNotSet") {
+ // Return true if the attribute doesn't exist or has a falsy value
+ return attributeValue === undefined || attributeValue === null || attributeValue === "";
+ }
+
+ // For all other operators, if the attribute doesn't exist, return false
+ if (attributeValue === undefined || attributeValue === null) {
return false;
}
- const attResult = compareValues(attributeValue, value, qualifier.operator);
+ // Check if this is a date operator
+ if (isDateOperator(operator)) {
+ return evaluateDateFilter(String(attributeValue), value, operator);
+ }
+
+ // Use standard comparison for non-date operators
+ // For non-date operators, value is always string | number
+ const attResult = compareValues(attributeValue, value as string | number, operator);
return attResult;
};
@@ -396,7 +435,8 @@ const evaluatePersonFilter = (userId: string, filter: TSegmentPersonFilter): boo
const { personIdentifier } = root;
if (personIdentifier === "userId") {
- const attResult = compareValues(userId, value, qualifier.operator);
+ // For userId comparison, value is always string | number
+ const attResult = compareValues(userId, value as string | number, qualifier.operator);
return attResult;
}
@@ -437,7 +477,62 @@ const evaluateSegmentFilter = async (
const evaluateDeviceFilter = (device: "phone" | "desktop", filter: TSegmentDeviceFilter): boolean => {
const { value, qualifier } = filter;
- return compareValues(device, value, qualifier.operator);
+ // For device comparison, value is always string | number
+ return compareValues(device, value as string | number, qualifier.operator);
+};
+
+/**
+ * Checks if an operator is a date-specific operator
+ */
+const isDateOperator = (operator: TAllOperators): operator is TDateOperator => {
+ return DATE_OPERATORS.includes(operator as TDateOperator);
+};
+
+/**
+ * Evaluates a date filter against an attribute value
+ */
+const evaluateDateFilter = (
+ attributeValue: string,
+ filterValue: TSegmentFilterValue,
+ operator: TDateOperator
+): boolean => {
+ // Parse the attribute value as a date
+ const attrDate = new Date(attributeValue);
+
+ // Validate the attribute value is a valid date
+ if (Number.isNaN(attrDate.getTime())) {
+ return false;
+ }
+
+ // Check if filterValue is a relative date value (e.g., { amount: 30, unit: "days" })
+ const relativeDateParsed = ZRelativeDateValue.safeParse(filterValue);
+
+ if (relativeDateParsed.success) {
+ const now = new Date();
+ const threshold = subtractTimeUnit(now, relativeDateParsed.data.amount, relativeDateParsed.data.unit);
+ return operator === "isOlderThan" ? attrDate < threshold : attrDate >= threshold;
+ }
+
+ // Handle absolute date operators
+ switch (operator) {
+ case "isBefore":
+ case "isAfter":
+ case "isSameDay": {
+ if (typeof filterValue !== "string") return false;
+ const compareDate = new Date(filterValue);
+ if (operator === "isBefore") return attrDate < compareDate;
+ if (operator === "isAfter") return attrDate > compareDate;
+ return isSameDay(attrDate, compareDate);
+ }
+ case "isBetween": {
+ if (!Array.isArray(filterValue) || filterValue.length !== 2) return false;
+ const startDate = new Date(filterValue[0]);
+ const endDate = new Date(filterValue[1]);
+ return attrDate >= startDate && attrDate <= endDate;
+ }
+ default:
+ return false;
+ }
};
export const compareValues = (
diff --git a/apps/web/modules/ee/contacts/segments/lib/utils.test.ts b/apps/web/modules/ee/contacts/segments/lib/utils.test.ts
index 36cbb1d46e..b786decabd 100644
--- a/apps/web/modules/ee/contacts/segments/lib/utils.test.ts
+++ b/apps/web/modules/ee/contacts/segments/lib/utils.test.ts
@@ -92,41 +92,56 @@ describe("Segment Utils", () => {
});
test("convertOperatorToText", () => {
- expect(convertOperatorToText("equals")).toBe("=");
- expect(convertOperatorToText("notEquals")).toBe("!=");
- expect(convertOperatorToText("lessThan")).toBe("<");
- expect(convertOperatorToText("lessEqual")).toBe("<=");
- expect(convertOperatorToText("greaterThan")).toBe(">");
- expect(convertOperatorToText("greaterEqual")).toBe(">=");
- expect(convertOperatorToText("isSet")).toBe("is set");
- expect(convertOperatorToText("isNotSet")).toBe("is not set");
- expect(convertOperatorToText("contains")).toBe("contains ");
- expect(convertOperatorToText("doesNotContain")).toBe("does not contain");
- expect(convertOperatorToText("startsWith")).toBe("starts with");
- expect(convertOperatorToText("endsWith")).toBe("ends with");
- expect(convertOperatorToText("userIsIn")).toBe("User is in");
- expect(convertOperatorToText("userIsNotIn")).toBe("User is not in");
+ // Mock t() that returns the i18n key for verification
+ const t = (key: string) => key;
+
+ expect(convertOperatorToText("equals", t)).toBe("=");
+ expect(convertOperatorToText("notEquals", t)).toBe("!=");
+ expect(convertOperatorToText("lessThan", t)).toBe("<");
+ expect(convertOperatorToText("lessEqual", t)).toBe("<=");
+ expect(convertOperatorToText("greaterThan", t)).toBe(">");
+ expect(convertOperatorToText("greaterEqual", t)).toBe(">=");
+ expect(convertOperatorToText("isSet", t)).toBe("environments.segments.operator_is_set");
+ expect(convertOperatorToText("isNotSet", t)).toBe("environments.segments.operator_is_not_set");
+ expect(convertOperatorToText("contains", t)).toBe("environments.segments.operator_contains");
+ expect(convertOperatorToText("doesNotContain", t)).toBe(
+ "environments.segments.operator_does_not_contain"
+ );
+ expect(convertOperatorToText("startsWith", t)).toBe("environments.segments.operator_starts_with");
+ expect(convertOperatorToText("endsWith", t)).toBe("environments.segments.operator_ends_with");
+ expect(convertOperatorToText("userIsIn", t)).toBe("environments.segments.operator_user_is_in");
+ expect(convertOperatorToText("userIsNotIn", t)).toBe("environments.segments.operator_user_is_not_in");
// @ts-expect-error - testing default case
- expect(convertOperatorToText("unknown")).toBe("unknown");
+ expect(convertOperatorToText("unknown", t)).toBe("unknown");
});
test("convertOperatorToTitle", () => {
- expect(convertOperatorToTitle("equals")).toBe("Equals");
- expect(convertOperatorToTitle("notEquals")).toBe("Not equals to");
- expect(convertOperatorToTitle("lessThan")).toBe("Less than");
- expect(convertOperatorToTitle("lessEqual")).toBe("Less than or equal to");
- expect(convertOperatorToTitle("greaterThan")).toBe("Greater than");
- expect(convertOperatorToTitle("greaterEqual")).toBe("Greater than or equal to");
- expect(convertOperatorToTitle("isSet")).toBe("Is set");
- expect(convertOperatorToTitle("isNotSet")).toBe("Is not set");
- expect(convertOperatorToTitle("contains")).toBe("Contains");
- expect(convertOperatorToTitle("doesNotContain")).toBe("Does not contain");
- expect(convertOperatorToTitle("startsWith")).toBe("Starts with");
- expect(convertOperatorToTitle("endsWith")).toBe("Ends with");
- expect(convertOperatorToTitle("userIsIn")).toBe("User is in");
- expect(convertOperatorToTitle("userIsNotIn")).toBe("User is not in");
+ const t = (key: string) => key;
+
+ expect(convertOperatorToTitle("equals", t)).toBe("environments.segments.operator_title_equals");
+ expect(convertOperatorToTitle("notEquals", t)).toBe("environments.segments.operator_title_not_equals");
+ expect(convertOperatorToTitle("lessThan", t)).toBe("environments.segments.operator_title_less_than");
+ expect(convertOperatorToTitle("lessEqual", t)).toBe("environments.segments.operator_title_less_equal");
+ expect(convertOperatorToTitle("greaterThan", t)).toBe(
+ "environments.segments.operator_title_greater_than"
+ );
+ expect(convertOperatorToTitle("greaterEqual", t)).toBe(
+ "environments.segments.operator_title_greater_equal"
+ );
+ expect(convertOperatorToTitle("isSet", t)).toBe("environments.segments.operator_title_is_set");
+ expect(convertOperatorToTitle("isNotSet", t)).toBe("environments.segments.operator_title_is_not_set");
+ expect(convertOperatorToTitle("contains", t)).toBe("environments.segments.operator_title_contains");
+ expect(convertOperatorToTitle("doesNotContain", t)).toBe(
+ "environments.segments.operator_title_does_not_contain"
+ );
+ expect(convertOperatorToTitle("startsWith", t)).toBe("environments.segments.operator_title_starts_with");
+ expect(convertOperatorToTitle("endsWith", t)).toBe("environments.segments.operator_title_ends_with");
+ expect(convertOperatorToTitle("userIsIn", t)).toBe("environments.segments.operator_title_user_is_in");
+ expect(convertOperatorToTitle("userIsNotIn", t)).toBe(
+ "environments.segments.operator_title_user_is_not_in"
+ );
// @ts-expect-error - testing default case
- expect(convertOperatorToTitle("unknown")).toBe("unknown");
+ expect(convertOperatorToTitle("unknown", t)).toBe("unknown");
});
test("addFilterBelow", () => {
diff --git a/apps/web/modules/ee/contacts/segments/lib/utils.ts b/apps/web/modules/ee/contacts/segments/lib/utils.ts
index 59cb65dc94..0582b8adef 100644
--- a/apps/web/modules/ee/contacts/segments/lib/utils.ts
+++ b/apps/web/modules/ee/contacts/segments/lib/utils.ts
@@ -1,4 +1,5 @@
import { createId } from "@paralleldrive/cuid2";
+import { TFunction } from "i18next";
import {
TAllOperators,
TAttributeOperator,
@@ -10,6 +11,7 @@ import {
TSegmentConnector,
TSegmentDeviceFilter,
TSegmentFilter,
+ TSegmentFilterValue,
TSegmentOperator,
TSegmentPersonFilter,
TSegmentSegmentFilter,
@@ -20,7 +22,7 @@ export const isResourceFilter = (resource: TSegmentFilter | TBaseFilters): resou
return (resource as TSegmentFilter).root !== undefined;
};
-export const convertOperatorToText = (operator: TAllOperators) => {
+export const convertOperatorToText = (operator: TAllOperators, t: TFunction) => {
switch (operator) {
case "equals":
return "=";
@@ -35,56 +37,80 @@ export const convertOperatorToText = (operator: TAllOperators) => {
case "greaterEqual":
return ">=";
case "isSet":
- return "is set";
+ return t("environments.segments.operator_is_set");
case "isNotSet":
- return "is not set";
+ return t("environments.segments.operator_is_not_set");
case "contains":
- return "contains ";
+ return t("environments.segments.operator_contains");
case "doesNotContain":
- return "does not contain";
+ return t("environments.segments.operator_does_not_contain");
case "startsWith":
- return "starts with";
+ return t("environments.segments.operator_starts_with");
case "endsWith":
- return "ends with";
+ return t("environments.segments.operator_ends_with");
case "userIsIn":
- return "User is in";
+ return t("environments.segments.operator_user_is_in");
case "userIsNotIn":
- return "User is not in";
+ return t("environments.segments.operator_user_is_not_in");
+ case "isOlderThan":
+ return t("environments.segments.operator_is_older_than");
+ case "isNewerThan":
+ return t("environments.segments.operator_is_newer_than");
+ case "isBefore":
+ return t("environments.segments.operator_is_before");
+ case "isAfter":
+ return t("environments.segments.operator_is_after");
+ case "isBetween":
+ return t("environments.segments.operator_is_between");
+ case "isSameDay":
+ return t("environments.segments.operator_is_same_day");
default:
return operator;
}
};
-export const convertOperatorToTitle = (operator: TAllOperators) => {
+export const convertOperatorToTitle = (operator: TAllOperators, t: TFunction) => {
switch (operator) {
case "equals":
- return "Equals";
+ return t("environments.segments.operator_title_equals");
case "notEquals":
- return "Not equals to";
+ return t("environments.segments.operator_title_not_equals");
case "lessThan":
- return "Less than";
+ return t("environments.segments.operator_title_less_than");
case "lessEqual":
- return "Less than or equal to";
+ return t("environments.segments.operator_title_less_equal");
case "greaterThan":
- return "Greater than";
+ return t("environments.segments.operator_title_greater_than");
case "greaterEqual":
- return "Greater than or equal to";
+ return t("environments.segments.operator_title_greater_equal");
case "isSet":
- return "Is set";
+ return t("environments.segments.operator_title_is_set");
case "isNotSet":
- return "Is not set";
+ return t("environments.segments.operator_title_is_not_set");
case "contains":
- return "Contains";
+ return t("environments.segments.operator_title_contains");
case "doesNotContain":
- return "Does not contain";
+ return t("environments.segments.operator_title_does_not_contain");
case "startsWith":
- return "Starts with";
+ return t("environments.segments.operator_title_starts_with");
case "endsWith":
- return "Ends with";
+ return t("environments.segments.operator_title_ends_with");
case "userIsIn":
- return "User is in";
+ return t("environments.segments.operator_title_user_is_in");
case "userIsNotIn":
- return "User is not in";
+ return t("environments.segments.operator_title_user_is_not_in");
+ case "isOlderThan":
+ return t("environments.segments.operator_title_is_older_than");
+ case "isNewerThan":
+ return t("environments.segments.operator_title_is_newer_than");
+ case "isBefore":
+ return t("environments.segments.operator_title_is_before");
+ case "isAfter":
+ return t("environments.segments.operator_title_is_after");
+ case "isBetween":
+ return t("environments.segments.operator_title_is_between");
+ case "isSameDay":
+ return t("environments.segments.operator_title_is_same_day");
default:
return operator;
}
@@ -398,7 +424,7 @@ export const updateSegmentIdInFilter = (group: TBaseFilters, filterId: string, n
}
};
-export const updateFilterValue = (group: TBaseFilters, filterId: string, newValue: string | number) => {
+export const updateFilterValue = (group: TBaseFilters, filterId: string, newValue: TSegmentFilterValue) => {
for (let i = 0; i < group.length; i++) {
const { resource } = group[i];
diff --git a/apps/web/modules/ee/contacts/types/contact.test.ts b/apps/web/modules/ee/contacts/types/contact.test.ts
index 92e3debd1d..7e9cc52cba 100644
--- a/apps/web/modules/ee/contacts/types/contact.test.ts
+++ b/apps/web/modules/ee/contacts/types/contact.test.ts
@@ -49,6 +49,7 @@ describe("ZContactTableData", () => {
key: "attr1",
name: "Attribute 1",
value: "value1",
+ dataType: "string",
},
],
};
@@ -68,6 +69,7 @@ describe("ZContactTableData", () => {
key: "attr1",
name: null,
value: null,
+ dataType: "string",
},
],
};
diff --git a/apps/web/modules/ee/contacts/types/contact.ts b/apps/web/modules/ee/contacts/types/contact.ts
index 0b9aebfcac..4a70145bb8 100644
--- a/apps/web/modules/ee/contacts/types/contact.ts
+++ b/apps/web/modules/ee/contacts/types/contact.ts
@@ -1,4 +1,9 @@
import { z } from "zod";
+import {
+ TContactAttributeDataType,
+ TContactAttributeKey,
+ ZContactAttributeDataType,
+} from "@formbricks/types/contact-attribute-key";
export const ZContact = z.object({
id: z.string().cuid2(),
@@ -11,6 +16,7 @@ const ZContactTableAttributeData = z.object({
key: z.string(),
name: z.string().nullable(),
value: z.string().nullable(),
+ dataType: ZContactAttributeDataType,
});
export const ZContactTableData = z.object({
@@ -37,9 +43,12 @@ export type TTransformPersonInput = {
environmentId: string;
attributes: {
value: string;
+ valueNumber: number | null;
+ valueDate: Date | null;
attributeKey: {
key: string;
name: string | null;
+ dataType: TContactAttributeDataType;
};
}[];
createdAt: Date;
@@ -379,3 +388,67 @@ export const ZEditContactAttributesForm = z.object({
});
export type TEditContactAttributesForm = z.infer;
+
+/**
+ * Creates a dynamic schema for editing contact attributes with data type validation.
+ * This extends the base ZEditContactAttributesForm with additional validation based on attribute data types.
+ *
+ * @param attributeKeys - Array of contact attribute keys with their data types
+ * @param t - Translation function for error messages
+ * @returns Zod schema with type-specific validation
+ */
+export const createEditContactAttributesSchema = (
+ attributeKeys: TContactAttributeKey[],
+ t: (key: string) => string
+) => {
+ return ZEditContactAttributesForm.superRefine((data, ctx) => {
+ // Validate data types for each attribute
+ data.attributes.forEach((attr, index) => {
+ if (!attr.key) return;
+
+ const attributeKey = attributeKeys.find((ak) => ak.key === attr.key);
+ if (!attributeKey) return;
+
+ const { dataType } = attributeKey;
+ const hasValue = attr.value && attr.value.trim() !== "";
+
+ // For typed fields (date/number), require a value - use delete button to remove
+ if (dataType === "date") {
+ if (!hasValue) {
+ ctx.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: t("environments.contacts.date_value_required"),
+ path: ["attributes", index, "value"],
+ });
+ return;
+ }
+ // Validate date format
+ const date = new Date(attr.value);
+ if (Number.isNaN(date.getTime())) {
+ ctx.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: t("environments.contacts.invalid_date_format"),
+ path: ["attributes", index, "value"],
+ });
+ }
+ } else if (dataType === "number") {
+ if (!hasValue) {
+ ctx.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: t("environments.contacts.number_value_required"),
+ path: ["attributes", index, "value"],
+ });
+ return;
+ }
+ // Validate number format
+ if (Number.isNaN(Number(attr.value))) {
+ ctx.addIssue({
+ code: z.ZodIssueCode.custom,
+ message: t("environments.contacts.invalid_number_format"),
+ path: ["attributes", index, "value"],
+ });
+ }
+ }
+ });
+ });
+};
diff --git a/apps/web/modules/ee/contacts/utils.tsx b/apps/web/modules/ee/contacts/utils.tsx
new file mode 100644
index 0000000000..3c47d852b6
--- /dev/null
+++ b/apps/web/modules/ee/contacts/utils.tsx
@@ -0,0 +1,30 @@
+import { TFunction } from "i18next";
+import { Calendar1Icon, HashIcon, TagIcon } from "lucide-react";
+import { TContactAttributeDataType } from "@formbricks/types/contact-attribute-key";
+
+export const getContactAttributeDataTypeIcon = (dataType: TContactAttributeDataType) => {
+ switch (dataType) {
+ case "date":
+ return ;
+ case "number":
+ return ;
+ case "string":
+ default:
+ return ;
+ }
+};
+
+export const getContactAttributeDataTypeLabel = (
+ dataType: TContactAttributeDataType,
+ t: TFunction
+): string => {
+ switch (dataType) {
+ case "date":
+ return t("common.date");
+ case "number":
+ return t("common.number");
+ case "string":
+ default:
+ return t("common.text");
+ }
+};
diff --git a/apps/web/modules/ee/license-check/actions.ts b/apps/web/modules/ee/license-check/actions.ts
new file mode 100644
index 0000000000..70de3373c7
--- /dev/null
+++ b/apps/web/modules/ee/license-check/actions.ts
@@ -0,0 +1,100 @@
+"use server";
+
+import { z } from "zod";
+import { ZId } from "@formbricks/types/common";
+import {
+ AuthenticationError,
+ OperationNotAllowedError,
+ ResourceNotFoundError,
+} from "@formbricks/types/errors";
+import { cache } from "@/lib/cache";
+import { IS_FORMBRICKS_CLOUD } from "@/lib/constants";
+import { getMembershipByUserIdOrganizationId } from "@/lib/membership/service";
+import { getOrganizationByEnvironmentId } from "@/lib/organization/service";
+import { authenticatedActionClient } from "@/lib/utils/action-client";
+import { AuthenticatedActionClientCtx } from "@/lib/utils/action-client/types/context";
+import { applyRateLimit } from "@/modules/core/rate-limit/helpers";
+import { rateLimitConfigs } from "@/modules/core/rate-limit/rate-limit-configs";
+import {
+ FAILED_FETCH_TTL_MS,
+ FETCH_LICENSE_TTL_MS,
+ LicenseApiError,
+ clearLicenseCache,
+ computeFreshLicenseState,
+ fetchLicenseFresh,
+ getCacheKeys,
+} from "./lib/license";
+
+const ZRecheckLicenseAction = z.object({
+ environmentId: ZId,
+});
+
+export type TRecheckLicenseAction = z.infer;
+
+export const recheckLicenseAction = authenticatedActionClient
+ .schema(ZRecheckLicenseAction)
+ .action(
+ async ({
+ ctx,
+ parsedInput,
+ }: {
+ ctx: AuthenticatedActionClientCtx;
+ parsedInput: TRecheckLicenseAction;
+ }) => {
+ // Rate limit: 5 rechecks per minute per user
+ await applyRateLimit(rateLimitConfigs.actions.licenseRecheck, ctx.user.id);
+
+ // Only allow on self-hosted instances
+ if (IS_FORMBRICKS_CLOUD) {
+ throw new OperationNotAllowedError("License recheck is only available on self-hosted instances");
+ }
+
+ // Get organization from environment
+ const organization = await getOrganizationByEnvironmentId(parsedInput.environmentId);
+ if (!organization) {
+ throw new ResourceNotFoundError("Organization", null);
+ }
+
+ // Check user is owner or manager (not member)
+ const currentUserMembership = await getMembershipByUserIdOrganizationId(ctx.user.id, organization.id);
+ if (!currentUserMembership) {
+ throw new AuthenticationError("User not a member of this organization");
+ }
+
+ if (currentUserMembership.role === "member") {
+ throw new OperationNotAllowedError("Only owners and managers can recheck license");
+ }
+
+ // Clear main license cache (preserves previous result cache for grace period)
+ // This prevents instant downgrade if the license server is temporarily unreachable
+ await clearLicenseCache();
+
+ const cacheKeys = getCacheKeys();
+ let freshLicense: Awaited>;
+
+ try {
+ freshLicense = await fetchLicenseFresh();
+ } catch (error) {
+ // 400 = invalid license key — return directly so the UI shows the correct message
+ if (error instanceof LicenseApiError && error.status === 400) {
+ return { active: false, status: "invalid_license" as const };
+ }
+ throw error;
+ }
+
+ // Cache the fresh result (or null if failed) so getEnterpriseLicense can use it.
+ // Wrapped in { value: ... } so fetchLicense can distinguish cache miss from cached null.
+ if (freshLicense) {
+ await cache.set(cacheKeys.FETCH_LICENSE_CACHE_KEY, { value: freshLicense }, FETCH_LICENSE_TTL_MS);
+ } else {
+ await cache.set(cacheKeys.FETCH_LICENSE_CACHE_KEY, { value: null }, FAILED_FETCH_TTL_MS);
+ }
+
+ const licenseState = await computeFreshLicenseState(freshLicense);
+
+ return {
+ active: licenseState.active,
+ status: licenseState.status,
+ };
+ }
+ );
diff --git a/apps/web/modules/ee/license-check/lib/license.test.ts b/apps/web/modules/ee/license-check/lib/license.test.ts
index ff9259de93..da335d0df0 100644
--- a/apps/web/modules/ee/license-check/lib/license.test.ts
+++ b/apps/web/modules/ee/license-check/lib/license.test.ts
@@ -24,6 +24,7 @@ const mockCache = {
set: vi.fn(),
del: vi.fn(),
exists: vi.fn(),
+ tryLock: vi.fn(),
withCache: vi.fn(),
getRedisClient: vi.fn(),
};
@@ -38,6 +39,7 @@ vi.mock("@formbricks/cache", () => ({
license: {
status: (identifier: string) => `fb:license:${identifier}:status`,
previous_result: (identifier: string) => `fb:license:${identifier}:previous_result`,
+ fetch_lock: (identifier: string) => `fb:license:${identifier}:fetch_lock`,
},
custom: (namespace: string, identifier: string, subResource?: string) => {
const base = `fb:${namespace}:${identifier}`;
@@ -98,6 +100,8 @@ describe("License Core Logic", () => {
mockCache.get.mockReset();
mockCache.set.mockReset();
mockCache.del.mockReset();
+ mockCache.exists.mockReset();
+ mockCache.tryLock.mockReset();
mockCache.withCache.mockReset();
mockLogger.error.mockReset();
mockLogger.warn.mockReset();
@@ -105,9 +109,11 @@ describe("License Core Logic", () => {
mockLogger.debug.mockReset();
// Set up default mock implementations for Result types
+ // fetchLicense uses get with TCachedFetchResult wrapper + distributed lock; getPreviousResult uses get with :previous_result key
mockCache.get.mockResolvedValue({ ok: true, data: null });
+ mockCache.exists.mockResolvedValue({ ok: true, data: false }); // default: cache miss
+ mockCache.tryLock.mockResolvedValue({ ok: true, data: true }); // default: lock acquired
mockCache.set.mockResolvedValue({ ok: true });
- mockCache.withCache.mockImplementation(async (fn) => await fn());
vi.mocked(prisma.response.count).mockResolvedValue(100);
vi.mocked(prisma.organization.findFirst).mockResolvedValue({
@@ -157,22 +163,29 @@ describe("License Core Logic", () => {
lastChecked: expect.any(Date),
isPendingDowngrade: false,
fallbackLevel: "live" as const,
+ status: "active" as const,
};
test("should return cached license from FETCH_LICENSE_CACHE_KEY if available and valid", async () => {
const { getEnterpriseLicense } = await import("./license");
const fetch = (await import("node-fetch")).default as Mock;
- // Mock cache.withCache to return cached license details (simulating cache hit)
- mockCache.withCache.mockResolvedValue(mockFetchedLicenseDetails);
+ // Mock cache hit: get returns wrapped license for status key
+ mockCache.get.mockImplementation(async (key: string) => {
+ if (key.includes(":previous_result")) {
+ return { ok: true, data: null };
+ }
+ if (key.includes(":status")) {
+ return { ok: true, data: { value: mockFetchedLicenseDetails } };
+ }
+ return { ok: true, data: null };
+ });
const license = await getEnterpriseLicense();
expect(license).toEqual(expectedActiveLicenseState);
- expect(mockCache.withCache).toHaveBeenCalledWith(
- expect.any(Function),
- expect.stringContaining("fb:license:"),
- expect.any(Number)
- );
+ expect(mockCache.get).toHaveBeenCalledWith(expect.stringContaining("fb:license:"));
+ // Should have checked cache but NOT acquired lock or called fetch
+ expect(mockCache.tryLock).not.toHaveBeenCalled();
expect(fetch).not.toHaveBeenCalled();
});
@@ -180,9 +193,7 @@ describe("License Core Logic", () => {
const { getEnterpriseLicense } = await import("./license");
const fetch = (await import("node-fetch")).default as Mock;
- // Mock cache.withCache to execute the function (simulating cache miss)
- mockCache.withCache.mockImplementation(async (fn) => await fn());
-
+ // Default mocks give cache miss (get returns null)
fetch.mockResolvedValueOnce({
ok: true,
json: async () => ({ data: mockFetchedLicenseDetails }),
@@ -191,11 +202,10 @@ describe("License Core Logic", () => {
const license = await getEnterpriseLicense();
expect(fetch).toHaveBeenCalledTimes(1);
- expect(mockCache.withCache).toHaveBeenCalledWith(
- expect.any(Function),
- expect.stringContaining("fb:license:"),
- expect.any(Number)
- );
+ expect(mockCache.get).toHaveBeenCalledWith(expect.stringContaining("fb:license:"));
+ // Should have tried to acquire lock and set the cache
+ expect(mockCache.tryLock).toHaveBeenCalled();
+ expect(mockCache.set).toHaveBeenCalled();
expect(license).toEqual(expectedActiveLicenseState);
});
@@ -211,11 +221,9 @@ describe("License Core Logic", () => {
version: 1,
};
- // Mock cache.withCache to return null (simulating fetch failure)
- mockCache.withCache.mockResolvedValue(null);
-
- // Mock cache.get to return previous result when requested
- mockCache.get.mockImplementation(async (key) => {
+ // Cache miss for fetch (get null, exists false) -> fetch fails -> null
+ // getPreviousResult returns previous result for :previous_result key
+ mockCache.get.mockImplementation(async (key: string) => {
if (key.includes(":previous_result")) {
return { ok: true, data: mockPreviousResult };
}
@@ -226,13 +234,14 @@ describe("License Core Logic", () => {
const license = await getEnterpriseLicense();
- expect(mockCache.withCache).toHaveBeenCalled();
+ expect(mockCache.get).toHaveBeenCalled();
expect(license).toEqual({
active: true,
features: mockPreviousResult.features,
lastChecked: previousTime,
isPendingDowngrade: true,
fallbackLevel: "grace" as const,
+ status: "unreachable" as const,
});
});
@@ -248,11 +257,8 @@ describe("License Core Logic", () => {
version: 1,
};
- // Mock cache.withCache to return null (simulating fetch failure)
- mockCache.withCache.mockResolvedValue(null);
-
- // Mock cache.get to return previous result when requested
- mockCache.get.mockImplementation(async (key) => {
+ // Cache miss -> fetch fails -> null; getPreviousResult returns old previous result
+ mockCache.get.mockImplementation(async (key: string) => {
if (key.includes(":previous_result")) {
return { ok: true, data: mockPreviousResult };
}
@@ -263,7 +269,7 @@ describe("License Core Logic", () => {
const license = await getEnterpriseLicense();
- expect(mockCache.withCache).toHaveBeenCalled();
+ expect(mockCache.get).toHaveBeenCalled();
expect(mockCache.set).toHaveBeenCalledWith(
expect.stringContaining("fb:license:"),
{
@@ -309,6 +315,7 @@ describe("License Core Logic", () => {
lastChecked: expect.any(Date),
isPendingDowngrade: false,
fallbackLevel: "default" as const,
+ status: "unreachable" as const,
});
});
@@ -316,12 +323,7 @@ describe("License Core Logic", () => {
const { getEnterpriseLicense } = await import("./license");
const fetch = (await import("node-fetch")).default as Mock;
- // Mock cache.withCache to return null (simulating fetch failure)
- mockCache.withCache.mockResolvedValue(null);
-
- // Mock cache.get to return no previous result
- mockCache.get.mockResolvedValue({ ok: true, data: null });
-
+ // Cache miss -> fetch fails; no previous result (default get returns null)
fetch.mockRejectedValueOnce(new Error("Network error"));
const license = await getEnterpriseLicense();
@@ -356,6 +358,7 @@ describe("License Core Logic", () => {
lastChecked: expect.any(Date),
isPendingDowngrade: false,
fallbackLevel: "default" as const,
+ status: "unreachable" as const,
});
});
@@ -389,51 +392,362 @@ describe("License Core Logic", () => {
lastChecked: expect.any(Date),
isPendingDowngrade: false,
fallbackLevel: "default" as const,
+ status: "no-license" as const,
});
expect(mockCache.get).not.toHaveBeenCalled();
expect(mockCache.set).not.toHaveBeenCalled();
- expect(mockCache.withCache).not.toHaveBeenCalled();
+ expect(mockCache.exists).not.toHaveBeenCalled();
+ expect(mockCache.tryLock).not.toHaveBeenCalled();
});
test("should handle fetch throwing an error and use grace period or return inactive", async () => {
- const { getEnterpriseLicense } = await import("./license");
- const fetch = (await import("node-fetch")).default as Mock;
-
- // Mock cache.withCache to return null (simulating fetch failure)
- mockCache.withCache.mockResolvedValue(null);
-
- // Mock cache.get to return no previous result
- mockCache.get.mockResolvedValue({ ok: true, data: null });
-
- fetch.mockRejectedValueOnce(new Error("Network error"));
-
- const license = await getEnterpriseLicense();
- expect(license).toEqual({
- active: false,
- features: null,
- lastChecked: expect.any(Date),
- isPendingDowngrade: false,
- fallbackLevel: "default" as const,
- });
- });
- });
-
- describe("getLicenseFeatures", () => {
- test("should return features if license is active", async () => {
- // Set up environment before import
- vi.stubGlobal("window", undefined);
+ // Runs after "no-license" test which uses vi.doMock; env may have empty key
+ vi.resetModules();
vi.doMock("@/lib/env", () => ({
env: {
ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
VERCEL_URL: "some.vercel.url",
FORMBRICKS_COM_URL: "https://app.formbricks.com",
HTTPS_PROXY: undefined,
HTTP_PROXY: undefined,
},
}));
- // Mock cache.withCache to return license details
- mockCache.withCache.mockResolvedValue({
+
+ const { getEnterpriseLicense } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ // Cache miss -> fetch throws -> no previous result -> handleInitialFailure
+ fetch.mockRejectedValueOnce(new Error("Network error"));
+
+ const license = await getEnterpriseLicense();
+ expect(license).toEqual({
+ active: false,
+ features: expect.objectContaining({
+ isMultiOrgEnabled: false,
+ projects: 3,
+ removeBranding: false,
+ }),
+ lastChecked: expect.any(Date),
+ isPendingDowngrade: false,
+ fallbackLevel: "default" as const,
+ status: "unreachable" as const,
+ });
+ });
+
+ test("should return invalid_license when API returns 400 (bad license key)", async () => {
+ vi.resetModules();
+ vi.doMock("@/lib/env", () => ({
+ env: {
+ ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
+ VERCEL_URL: "some.vercel.url",
+ FORMBRICKS_COM_URL: "https://app.formbricks.com",
+ HTTPS_PROXY: undefined,
+ HTTP_PROXY: undefined,
+ },
+ }));
+
+ const { getEnterpriseLicense } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+ fetch.mockResolvedValueOnce({ ok: false, status: 400 } as any);
+
+ const license = await getEnterpriseLicense();
+
+ expect(license).toEqual({
+ active: false,
+ features: expect.objectContaining({ projects: 3 }),
+ lastChecked: expect.any(Date),
+ isPendingDowngrade: false,
+ fallbackLevel: "default" as const,
+ status: "invalid_license" as const,
+ });
+ });
+
+ test("should skip polling and fetch directly when Redis is unavailable (tryLock error)", async () => {
+ vi.resetModules();
+ vi.doMock("@/lib/env", () => ({
+ env: {
+ ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
+ VERCEL_URL: "some.vercel.url",
+ FORMBRICKS_COM_URL: "https://app.formbricks.com",
+ HTTPS_PROXY: undefined,
+ HTTP_PROXY: undefined,
+ },
+ }));
+
+ const { getEnterpriseLicense } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ const mockLicense: TEnterpriseLicenseDetails = {
status: "active",
+ features: {
+ isMultiOrgEnabled: true,
+ contacts: true,
+ projects: 10,
+ whitelabel: true,
+ removeBranding: true,
+ twoFactorAuth: true,
+ sso: true,
+ saml: true,
+ spamProtection: true,
+ ai: false,
+ auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
+ },
+ };
+
+ // Redis is down: cache.get returns error, tryLock returns error
+ mockCache.get.mockResolvedValue({ ok: false, error: { code: "redis_connection_error" } });
+ mockCache.tryLock.mockResolvedValue({ ok: false, error: { code: "redis_connection_error" } });
+
+ fetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({ data: mockLicense }),
+ } as any);
+
+ const startTime = Date.now();
+ const license = await getEnterpriseLicense();
+ const elapsed = Date.now() - startTime;
+
+ // Should NOT have waited for polling — should complete quickly
+ expect(elapsed).toBeLessThan(5000);
+ expect(fetch).toHaveBeenCalledTimes(1);
+ expect(mockLogger.warn).toHaveBeenCalledWith(
+ "Redis unavailable during license fetch lock; skipping poll and fetching directly"
+ );
+ expect(license).toEqual({
+ active: true,
+ features: mockLicense.features,
+ lastChecked: expect.any(Date),
+ isPendingDowngrade: false,
+ fallbackLevel: "live" as const,
+ status: "active" as const,
+ });
+ });
+
+ test("should poll and return cached value when another process holds the lock", async () => {
+ vi.resetModules();
+ vi.doMock("@/lib/env", () => ({
+ env: {
+ ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
+ VERCEL_URL: "some.vercel.url",
+ FORMBRICKS_COM_URL: "https://app.formbricks.com",
+ HTTPS_PROXY: undefined,
+ HTTP_PROXY: undefined,
+ },
+ }));
+
+ const { fetchLicense } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ const mockLicense: TEnterpriseLicenseDetails = {
+ status: "active",
+ features: {
+ isMultiOrgEnabled: true,
+ contacts: true,
+ projects: 10,
+ whitelabel: true,
+ removeBranding: true,
+ twoFactorAuth: true,
+ sso: true,
+ saml: true,
+ spamProtection: true,
+ ai: false,
+ auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
+ },
+ };
+
+ // Lock held by another process (ok: true, data: false)
+ mockCache.tryLock.mockResolvedValue({ ok: true, data: false });
+
+ // First get returns cache miss, subsequent gets return the populated license
+ let getCalls = 0;
+ mockCache.get.mockImplementation(async (key: string) => {
+ if (key.includes(":status")) {
+ getCalls++;
+ if (getCalls <= 1) return { ok: true, data: null };
+ return { ok: true, data: { value: mockLicense } };
+ }
+ return { ok: true, data: null };
+ });
+
+ const result = await fetchLicense();
+
+ expect(fetch).not.toHaveBeenCalled();
+ expect(result).toEqual(mockLicense);
+ });
+
+ test("should fall back to direct fetch after poll timeout when lock is held", async () => {
+ vi.resetModules();
+ vi.doMock("@/lib/env", () => ({
+ env: {
+ ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
+ VERCEL_URL: "some.vercel.url",
+ FORMBRICKS_COM_URL: "https://app.formbricks.com",
+ HTTPS_PROXY: undefined,
+ HTTP_PROXY: undefined,
+ },
+ }));
+
+ const { fetchLicense } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ const mockLicense: TEnterpriseLicenseDetails = {
+ status: "active",
+ features: {
+ isMultiOrgEnabled: true,
+ contacts: true,
+ projects: 10,
+ whitelabel: true,
+ removeBranding: true,
+ twoFactorAuth: true,
+ sso: true,
+ saml: true,
+ spamProtection: true,
+ ai: false,
+ auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
+ },
+ };
+
+ // Lock held, cache never gets populated
+ mockCache.tryLock.mockResolvedValue({ ok: true, data: false });
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+ mockCache.set.mockResolvedValue({ ok: true });
+
+ fetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({ data: mockLicense }),
+ } as any);
+
+ const result = await fetchLicense();
+
+ expect(fetch).toHaveBeenCalledTimes(1);
+ expect(mockLogger.warn).toHaveBeenCalledWith(
+ expect.objectContaining({ pollMs: expect.any(Number) }),
+ "License cache not populated by holder within poll window; fetching in this process"
+ );
+ expect(result).toEqual(mockLicense);
+ });
+
+ test("should log warning and use short TTL when lock acquired but fetch returns null", async () => {
+ vi.resetModules();
+ vi.doMock("@/lib/env", () => ({
+ env: {
+ ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
+ VERCEL_URL: "some.vercel.url",
+ FORMBRICKS_COM_URL: "https://app.formbricks.com",
+ HTTPS_PROXY: undefined,
+ HTTP_PROXY: undefined,
+ },
+ }));
+
+ const { fetchLicense } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+ mockCache.tryLock.mockResolvedValue({ ok: true, data: true });
+ mockCache.set.mockResolvedValue({ ok: true });
+
+ fetch.mockResolvedValueOnce({ ok: false, status: 500 } as any);
+
+ const result = await fetchLicense();
+
+ expect(result).toBeNull();
+ expect(mockLogger.warn).toHaveBeenCalledWith(
+ expect.objectContaining({
+ ttlMinutes: expect.any(Number),
+ timestamp: expect.any(String),
+ }),
+ "License fetch failed, caching null result with short TTL for faster retry"
+ );
+ expect(mockCache.set).toHaveBeenCalledWith(
+ expect.stringContaining("fb:license:"),
+ { value: null },
+ 10 * 60 * 1000
+ );
+ });
+
+ test("should return null during build time (NEXT_PHASE = phase-production-build)", async () => {
+ vi.resetModules();
+ vi.doMock("@/lib/env", () => ({
+ env: {
+ ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
+ VERCEL_URL: "some.vercel.url",
+ FORMBRICKS_COM_URL: "https://app.formbricks.com",
+ HTTPS_PROXY: undefined,
+ HTTP_PROXY: undefined,
+ },
+ }));
+
+ // eslint-disable-next-line turbo/no-undeclared-env-vars -- NEXT_PHASE is a Next.js env variable
+ process.env.NEXT_PHASE = "phase-production-build";
+
+ const { fetchLicense } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ const result = await fetchLicense();
+
+ expect(result).toBeNull();
+ expect(fetch).not.toHaveBeenCalled();
+ expect(mockCache.get).not.toHaveBeenCalled();
+ });
+
+ test("should return null after poll timeout when fallback fetch also fails", async () => {
+ vi.resetModules();
+ vi.doMock("@/lib/env", () => ({
+ env: {
+ ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
+ VERCEL_URL: "some.vercel.url",
+ FORMBRICKS_COM_URL: "https://app.formbricks.com",
+ HTTPS_PROXY: undefined,
+ HTTP_PROXY: undefined,
+ },
+ }));
+
+ const { fetchLicense } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ mockCache.tryLock.mockResolvedValue({ ok: true, data: false });
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+ mockCache.set.mockResolvedValue({ ok: true });
+
+ fetch.mockResolvedValueOnce({ ok: false, status: 500 } as any);
+
+ const result = await fetchLicense();
+
+ expect(result).toBeNull();
+ expect(mockCache.set).toHaveBeenCalledWith(
+ expect.stringContaining("fb:license:"),
+ { value: null },
+ 10 * 60 * 1000
+ );
+ });
+ });
+
+ describe("getLicenseFeatures", () => {
+ test("should return features if license is active", async () => {
+ vi.resetModules();
+ vi.stubGlobal("window", undefined);
+ // Mock cache hit for fetchLicense (get returns wrapped license)
+ const activeLicenseDetails = {
+ status: "active" as const,
features: {
isMultiOrgEnabled: true,
contacts: true,
@@ -446,9 +760,21 @@ describe("License Core Logic", () => {
spamProtection: true,
ai: true,
auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
},
+ };
+ mockCache.get.mockImplementation(async (key: string) => {
+ if (key.includes(":previous_result")) {
+ return { ok: true, data: null };
+ }
+ if (key.includes(":status")) {
+ return { ok: true, data: { value: activeLicenseDetails } };
+ }
+ return { ok: true, data: null };
});
- // Import after env and mocks are set
+
const { getLicenseFeatures } = await import("./license");
const features = await getLicenseFeatures();
expect(features).toEqual({
@@ -463,14 +789,48 @@ describe("License Core Logic", () => {
spamProtection: true,
ai: true,
auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
});
});
test("should return null if license is inactive", async () => {
const { getLicenseFeatures } = await import("./license");
- // Mock cache.withCache to return expired license
- mockCache.withCache.mockResolvedValue({ status: "expired", features: null });
+ // Mock cache hit with expired license wrapped in { value: ... }
+ mockCache.get.mockImplementation(async (key: string) => {
+ if (key.includes(":previous_result")) {
+ return { ok: true, data: null };
+ }
+ if (key.includes(":status")) {
+ return {
+ ok: true,
+ data: {
+ value: {
+ status: "expired",
+ features: {
+ isMultiOrgEnabled: false,
+ projects: 3,
+ twoFactorAuth: false,
+ sso: false,
+ whitelabel: false,
+ removeBranding: false,
+ contacts: false,
+ ai: false,
+ saml: false,
+ spamProtection: false,
+ auditLogs: false,
+ multiLanguageSurveys: false,
+ accessControl: false,
+ quotas: false,
+ },
+ },
+ },
+ };
+ }
+ return { ok: true, data: null };
+ });
const features = await getLicenseFeatures();
expect(features).toBeNull();
@@ -479,8 +839,8 @@ describe("License Core Logic", () => {
test("should return null if getEnterpriseLicense throws", async () => {
const { getLicenseFeatures } = await import("./license");
- // Mock cache.withCache to throw an error
- mockCache.withCache.mockRejectedValue(new Error("Cache error"));
+ // Mock cache.get to throw so getEnterpriseLicense fails
+ mockCache.get.mockRejectedValue(new Error("Cache error"));
const features = await getLicenseFeatures();
expect(features).toBeNull();
@@ -493,23 +853,57 @@ describe("License Core Logic", () => {
mockCache.get.mockReset();
mockCache.set.mockReset();
mockCache.del.mockReset();
- mockCache.withCache.mockReset();
+ mockCache.exists.mockReset();
vi.resetModules();
});
test("should use 'browser' as cache key in browser environment", async () => {
vi.stubGlobal("window", {});
- // Set up default mock for cache.withCache
- mockCache.withCache.mockImplementation(async (fn) => await fn());
+ // Ensure env has license key (previous "no-license" test may have poisoned env)
+ vi.doMock("@/lib/env", () => ({
+ env: {
+ ENTERPRISE_LICENSE_KEY: "test-license-key",
+ ENVIRONMENT: "production",
+ VERCEL_URL: "some.vercel.url",
+ FORMBRICKS_COM_URL: "https://app.formbricks.com",
+ HTTPS_PROXY: undefined,
+ HTTP_PROXY: undefined,
+ },
+ }));
+
+ // Cache miss so fetch runs; mock get for cache check
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+
+ const fetch = (await import("node-fetch")).default as Mock;
+ fetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({
+ data: {
+ status: "active",
+ features: {
+ isMultiOrgEnabled: true,
+ projects: 5,
+ twoFactorAuth: true,
+ sso: true,
+ whitelabel: true,
+ removeBranding: true,
+ contacts: true,
+ ai: true,
+ saml: true,
+ spamProtection: true,
+ auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
+ },
+ },
+ }),
+ } as any);
const { getEnterpriseLicense } = await import("./license");
await getEnterpriseLicense();
- expect(mockCache.withCache).toHaveBeenCalledWith(
- expect.any(Function),
- expect.stringContaining("fb:license:browser:status"),
- expect.any(Number)
- );
+ expect(mockCache.get).toHaveBeenCalledWith(expect.stringContaining("fb:license:browser:status"));
});
test("should use 'no-license' as cache key when ENTERPRISE_LICENSE_KEY is not set", async () => {
@@ -528,16 +922,19 @@ describe("License Core Logic", () => {
await getEnterpriseLicense();
// The cache should NOT be accessed if there is no license key
expect(mockCache.get).not.toHaveBeenCalled();
- expect(mockCache.withCache).not.toHaveBeenCalled();
+ expect(mockCache.exists).not.toHaveBeenCalled();
});
test("should use hashed license key as cache key when ENTERPRISE_LICENSE_KEY is set", async () => {
vi.resetModules();
const testLicenseKey = "test-license-key";
vi.stubGlobal("window", undefined);
+
+ // Ensure env has license key (restore after "no-license" test)
vi.doMock("@/lib/env", () => ({
env: {
ENTERPRISE_LICENSE_KEY: testLicenseKey,
+ ENVIRONMENT: "production",
VERCEL_URL: "some.vercel.url",
FORMBRICKS_COM_URL: "https://app.formbricks.com",
HTTPS_PROXY: undefined,
@@ -545,22 +942,49 @@ describe("License Core Logic", () => {
},
}));
- // Set up default mock for cache.withCache
- mockCache.withCache.mockImplementation(async (fn) => await fn());
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+
+ const fetch = (await import("node-fetch")).default as Mock;
+ fetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({
+ data: {
+ status: "active",
+ features: {
+ isMultiOrgEnabled: true,
+ projects: 5,
+ twoFactorAuth: true,
+ sso: true,
+ whitelabel: true,
+ removeBranding: true,
+ contacts: true,
+ ai: true,
+ saml: true,
+ spamProtection: true,
+ auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
+ },
+ },
+ }),
+ } as any);
const { hashString } = await import("@/lib/hash-string");
const expectedHash = hashString(testLicenseKey);
const { getEnterpriseLicense } = await import("./license");
await getEnterpriseLicense();
- expect(mockCache.withCache).toHaveBeenCalledWith(
- expect.any(Function),
- expect.stringContaining(`fb:license:${expectedHash}:status`),
- expect.any(Number)
+ expect(mockCache.get).toHaveBeenCalledWith(
+ expect.stringContaining(`fb:license:${expectedHash}:status`)
);
});
});
describe("Error and Warning Logging", () => {
+ beforeEach(() => {
+ vi.resetModules();
+ });
+
test("should log warning when setPreviousResult cache.set fails (line 176-178)", async () => {
const { getEnterpriseLicense } = await import("./license");
const fetch = (await import("node-fetch")).default as Mock;
@@ -585,10 +1009,18 @@ describe("License Core Logic", () => {
},
};
- // Mock successful fetch from API
- mockCache.withCache.mockResolvedValue(mockFetchedLicenseDetails);
+ // Cache hit - fetchLicense returns wrapped cached license
+ mockCache.get.mockImplementation(async (key: string) => {
+ if (key.includes(":previous_result")) {
+ return { ok: true, data: null };
+ }
+ if (key.includes(":status")) {
+ return { ok: true, data: { value: mockFetchedLicenseDetails } };
+ }
+ return { ok: true, data: null };
+ });
- // Mock cache.set to fail when saving previous result
+ // cache.set fails when setPreviousResult tries to save (called for previous_result key)
mockCache.set.mockResolvedValue({
ok: false,
error: new Error("Redis connection failed"),
@@ -596,7 +1028,6 @@ describe("License Core Logic", () => {
await getEnterpriseLicense();
- // Verify that the warning was logged
expect(mockLogger.warn).toHaveBeenCalledWith(
{ error: new Error("Redis connection failed") },
"Failed to cache previous result"
@@ -607,10 +1038,7 @@ describe("License Core Logic", () => {
const { getEnterpriseLicense } = await import("./license");
const fetch = (await import("node-fetch")).default as Mock;
- // Mock cache.withCache to execute the function (simulating cache miss)
- mockCache.withCache.mockImplementation(async (fn) => await fn());
-
- // Mock API response with 500 status
+ // Cache miss -> fetch returns 500
const mockStatus = 500;
fetch.mockResolvedValueOnce({
ok: false,
@@ -620,7 +1048,6 @@ describe("License Core Logic", () => {
await getEnterpriseLicense();
- // Verify that the API error was logged with correct structure
expect(mockLogger.error).toHaveBeenCalledWith(
expect.objectContaining({
status: mockStatus,
@@ -635,8 +1062,7 @@ describe("License Core Logic", () => {
const { getEnterpriseLicense } = await import("./license");
const fetch = (await import("node-fetch")).default as Mock;
- // Test with 403 Forbidden
- mockCache.withCache.mockImplementation(async (fn) => await fn());
+ // Cache miss -> fetch returns 403
const mockStatus = 403;
fetch.mockResolvedValueOnce({
ok: false,
@@ -646,7 +1072,6 @@ describe("License Core Logic", () => {
await getEnterpriseLicense();
- // Verify that the API error was logged with correct structure
expect(mockLogger.error).toHaveBeenCalledWith(
expect.objectContaining({
status: mockStatus,
@@ -669,8 +1094,7 @@ describe("License Core Logic", () => {
version: 1,
};
- mockCache.withCache.mockResolvedValue(null);
- mockCache.get.mockImplementation(async (key) => {
+ mockCache.get.mockImplementation(async (key: string) => {
if (key.includes(":previous_result")) {
return { ok: true, data: mockPreviousResult };
}
@@ -681,7 +1105,6 @@ describe("License Core Logic", () => {
await getEnterpriseLicense();
- // Verify that the fallback info was logged
expect(mockLogger.info).toHaveBeenCalledWith(
expect.objectContaining({
fallbackLevel: "grace",
@@ -692,6 +1115,222 @@ describe("License Core Logic", () => {
});
});
+ describe("computeFreshLicenseState", () => {
+ const mockActiveLicenseDetails: TEnterpriseLicenseDetails = {
+ status: "active",
+ features: {
+ isMultiOrgEnabled: true,
+ contacts: true,
+ projects: 10,
+ whitelabel: true,
+ removeBranding: true,
+ twoFactorAuth: true,
+ sso: true,
+ saml: true,
+ spamProtection: true,
+ ai: false,
+ auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
+ },
+ };
+
+ beforeEach(() => {
+ vi.resetModules();
+ vi.resetAllMocks();
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+ mockCache.exists.mockResolvedValue({ ok: true, data: false });
+ mockCache.set.mockResolvedValue({ ok: true });
+ });
+
+ test("should return active license state from pre-fetched active license without calling fetch", async () => {
+ const { computeFreshLicenseState } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ const result = await computeFreshLicenseState(mockActiveLicenseDetails);
+
+ expect(result).toEqual({
+ active: true,
+ features: mockActiveLicenseDetails.features,
+ lastChecked: expect.any(Date),
+ isPendingDowngrade: false,
+ fallbackLevel: "live",
+ status: "active",
+ });
+ // Must not call the license API — the data was passed in directly
+ expect(fetch).not.toHaveBeenCalled();
+ });
+
+ test("should apply grace period fallback when freshLicense is null and previous result exists within grace", async () => {
+ const previousTime = new Date(Date.now() - 1 * 24 * 60 * 60 * 1000); // 1 day ago
+ const mockPreviousResult = {
+ active: true,
+ features: { removeBranding: true, projects: 5 },
+ lastChecked: previousTime,
+ };
+
+ mockCache.get.mockImplementation(async (key: string) => {
+ if (key.includes(":previous_result")) {
+ return { ok: true, data: mockPreviousResult };
+ }
+ return { ok: true, data: null };
+ });
+
+ const { computeFreshLicenseState } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ const result = await computeFreshLicenseState(null);
+
+ expect(result).toEqual({
+ active: true,
+ features: mockPreviousResult.features,
+ lastChecked: previousTime,
+ isPendingDowngrade: true,
+ fallbackLevel: "grace",
+ status: "unreachable",
+ });
+ expect(fetch).not.toHaveBeenCalled();
+ });
+
+ test("should return inactive default when freshLicense is null and no previous result", async () => {
+ const { computeFreshLicenseState } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ const result = await computeFreshLicenseState(null);
+
+ expect(result).toEqual({
+ active: false,
+ features: expect.objectContaining({
+ isMultiOrgEnabled: false,
+ projects: 3,
+ }),
+ lastChecked: expect.any(Date),
+ isPendingDowngrade: false,
+ fallbackLevel: "default",
+ status: "unreachable",
+ });
+ expect(fetch).not.toHaveBeenCalled();
+ });
+
+ test("should return expired state when freshLicense has expired status", async () => {
+ const expiredLicense: TEnterpriseLicenseDetails = {
+ status: "expired",
+ features: mockActiveLicenseDetails.features,
+ };
+
+ const { computeFreshLicenseState } = await import("./license");
+
+ const result = await computeFreshLicenseState(expiredLicense);
+
+ expect(result).toEqual({
+ active: false,
+ features: expect.objectContaining({
+ isMultiOrgEnabled: false,
+ projects: 3,
+ }),
+ lastChecked: expect.any(Date),
+ isPendingDowngrade: false,
+ fallbackLevel: "default",
+ status: "expired",
+ });
+ });
+ });
+
+ describe("clearLicenseCache", () => {
+ test("should clear memory cache and delete FETCH_LICENSE_CACHE_KEY", async () => {
+ const { clearLicenseCache, getEnterpriseLicense } = await import("./license");
+ const activeLicense = {
+ status: "active" as const,
+ features: {
+ isMultiOrgEnabled: true,
+ projects: 5,
+ twoFactorAuth: true,
+ sso: true,
+ whitelabel: true,
+ removeBranding: true,
+ contacts: true,
+ ai: true,
+ saml: true,
+ spamProtection: true,
+ auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
+ },
+ };
+ mockCache.get.mockImplementation(async (key: string) => {
+ if (key.includes(":previous_result")) return { ok: true, data: null };
+ if (key.includes(":status")) return { ok: true, data: { value: activeLicense } };
+ return { ok: true, data: null };
+ });
+ mockCache.del.mockResolvedValue({ ok: true });
+
+ await getEnterpriseLicense();
+ await clearLicenseCache();
+
+ expect(mockCache.del).toHaveBeenCalledWith(
+ expect.arrayContaining([expect.stringContaining("fb:license:")])
+ );
+ });
+
+ test("should log warning when cache.del fails", async () => {
+ const { clearLicenseCache } = await import("./license");
+ mockCache.del.mockResolvedValue({ ok: false, error: new Error("Redis error") });
+
+ await clearLicenseCache();
+
+ expect(mockLogger.warn).toHaveBeenCalledWith(
+ { error: new Error("Redis error") },
+ "Failed to delete license cache"
+ );
+ });
+ });
+
+ describe("fetchLicenseFresh", () => {
+ test("should fetch directly from server without using cache", async () => {
+ const { fetchLicenseFresh } = await import("./license");
+ const fetch = (await import("node-fetch")).default as Mock;
+
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+ fetch.mockResolvedValueOnce({
+ ok: true,
+ json: async () => ({
+ data: {
+ status: "active",
+ features: {
+ isMultiOrgEnabled: true,
+ projects: 5,
+ twoFactorAuth: true,
+ sso: true,
+ whitelabel: true,
+ removeBranding: true,
+ contacts: true,
+ ai: true,
+ saml: true,
+ spamProtection: true,
+ auditLogs: true,
+ multiLanguageSurveys: true,
+ accessControl: true,
+ quotas: true,
+ },
+ },
+ }),
+ } as any);
+
+ const result = await fetchLicenseFresh();
+
+ expect(result).toEqual(
+ expect.objectContaining({
+ status: "active",
+ features: expect.objectContaining({ projects: 5 }),
+ })
+ );
+ expect(fetch).toHaveBeenCalled();
+ expect(mockCache.get).not.toHaveBeenCalled();
+ });
+ });
+
describe("Environment-based endpoint selection", () => {
test("should use staging endpoint when ENVIRONMENT is staging", async () => {
vi.resetModules();
@@ -706,8 +1345,9 @@ describe("License Core Logic", () => {
const fetch = (await import("node-fetch")).default as Mock;
- // Mock cache.withCache to execute the function (simulating cache miss)
- mockCache.withCache.mockImplementation(async (fn) => await fn());
+ // Cache miss so fetchLicense fetches from server
+ mockCache.get.mockResolvedValue({ ok: true, data: null });
+ mockCache.exists.mockResolvedValue({ ok: true, data: false });
fetch.mockResolvedValueOnce({
ok: true,
diff --git a/apps/web/modules/ee/license-check/lib/license.ts b/apps/web/modules/ee/license-check/lib/license.ts
index f3ba1cb154..673cd398ed 100644
--- a/apps/web/modules/ee/license-check/lib/license.ts
+++ b/apps/web/modules/ee/license-check/lib/license.ts
@@ -14,12 +14,14 @@ import { getInstanceId } from "@/lib/instance";
import {
TEnterpriseLicenseDetails,
TEnterpriseLicenseFeatures,
+ TEnterpriseLicenseStatusReturn,
} from "@/modules/ee/license-check/types/enterprise-license";
// Configuration
const CONFIG = {
CACHE: {
FETCH_LICENSE_TTL_MS: 24 * 60 * 60 * 1000, // 24 hours
+ FAILED_FETCH_TTL_MS: 10 * 60 * 1000, // 10 minutes for failed/null results
PREVIOUS_RESULT_TTL_MS: 4 * 24 * 60 * 60 * 1000, // 4 days
GRACE_PERIOD_MS: 3 * 24 * 60 * 60 * 1000, // 3 days
MAX_RETRIES: 3,
@@ -30,20 +32,42 @@ const CONFIG = {
env.ENVIRONMENT === "staging"
? "https://staging.ee.formbricks.com/api/licenses/check"
: "https://ee.formbricks.com/api/licenses/check",
- // ENDPOINT: "https://localhost:8080/api/licenses/check",
TIMEOUT_MS: 5000,
},
} as const;
+export const GRACE_PERIOD_MS = CONFIG.CACHE.GRACE_PERIOD_MS;
+
+/** TTL in ms for successful license fetch results (24h). Re-export for use in actions. */
+export const FETCH_LICENSE_TTL_MS = CONFIG.CACHE.FETCH_LICENSE_TTL_MS;
+/** TTL in ms for failed license fetch results (10 min). Re-export for use in actions. */
+export const FAILED_FETCH_TTL_MS = CONFIG.CACHE.FAILED_FETCH_TTL_MS;
+
// Types
type FallbackLevel = "live" | "cached" | "grace" | "default";
+type TEnterpriseLicenseResult = {
+ active: boolean;
+ features: TEnterpriseLicenseFeatures | null;
+ lastChecked: Date;
+ isPendingDowngrade: boolean;
+ fallbackLevel: FallbackLevel;
+ status: TEnterpriseLicenseStatusReturn;
+};
+
type TPreviousResult = {
active: boolean;
lastChecked: Date;
features: TEnterpriseLicenseFeatures | null;
};
+// Wrapper type for cached license fetch results.
+// Storing { value: } instead of directly lets us distinguish
+// "key not in cache" (get returns null) from "key exists with a null value"
+// ({ value: null }) in a single cache.get call, eliminating the TOCTOU race
+// that existed between separate get + exists calls.
+type TCachedFetchResult = { value: TEnterpriseLicenseDetails | null };
+
// Validation schemas
const LicenseFeaturesSchema = z.object({
isMultiOrgEnabled: z.boolean(),
@@ -78,7 +102,7 @@ class LicenseError extends Error {
}
}
-class LicenseApiError extends LicenseError {
+export class LicenseApiError extends LicenseError {
constructor(
message: string,
public readonly status: number
@@ -90,7 +114,7 @@ class LicenseApiError extends LicenseError {
// Cache keys using enterprise-grade hierarchical patterns
const getCacheIdentifier = () => {
- if (typeof window !== "undefined") {
+ if (globalThis.window !== undefined) {
return "browser"; // Browser environment
}
if (!env.ENTERPRISE_LICENSE_KEY) {
@@ -99,11 +123,16 @@ const getCacheIdentifier = () => {
return hashString(env.ENTERPRISE_LICENSE_KEY); // Valid license key
};
+const LICENSE_FETCH_LOCK_TTL_MS = 90 * 1000; // 90s lock so only one process fetches when cache is cold
+const LICENSE_FETCH_POLL_MS = 2 * 1000; // Wait up to 2s for another process to populate cache
+const LICENSE_FETCH_POLL_INTERVAL_MS = 400;
+
export const getCacheKeys = () => {
const identifier = getCacheIdentifier();
return {
FETCH_LICENSE_CACHE_KEY: createCacheKey.license.status(identifier),
PREVIOUS_RESULT_CACHE_KEY: createCacheKey.license.previous_result(identifier),
+ FETCH_LOCK_CACHE_KEY: createCacheKey.license.fetch_lock(identifier),
};
};
@@ -142,36 +171,50 @@ const validateConfig = () => {
};
// Cache functions with async pattern
+let getPreviousResultPromise: Promise | null = null;
+
const getPreviousResult = async (): Promise => {
- if (typeof window !== "undefined") {
+ if (getPreviousResultPromise) return getPreviousResultPromise;
+
+ getPreviousResultPromise = (async () => {
+ if (globalThis.window !== undefined) {
+ return {
+ active: false,
+ lastChecked: new Date(0),
+ features: DEFAULT_FEATURES,
+ };
+ }
+
+ try {
+ const result = await cache.get(getCacheKeys().PREVIOUS_RESULT_CACHE_KEY);
+ if (result.ok && result.data) {
+ return {
+ ...result.data,
+ lastChecked: new Date(result.data.lastChecked),
+ };
+ }
+ } catch (error) {
+ logger.error({ error }, "Failed to get previous result from cache");
+ }
+
return {
active: false,
lastChecked: new Date(0),
features: DEFAULT_FEATURES,
};
- }
+ })();
- try {
- const result = await cache.get(getCacheKeys().PREVIOUS_RESULT_CACHE_KEY);
- if (result.ok && result.data) {
- return {
- ...result.data,
- lastChecked: new Date(result.data.lastChecked),
- };
- }
- } catch (error) {
- logger.error({ error }, "Failed to get previous result from cache");
- }
+ getPreviousResultPromise
+ .finally(() => {
+ getPreviousResultPromise = null;
+ })
+ .catch(() => {});
- return {
- active: false,
- lastChecked: new Date(0),
- features: DEFAULT_FEATURES,
- };
+ return getPreviousResultPromise;
};
const setPreviousResult = async (previousResult: TPreviousResult) => {
- if (typeof window !== "undefined") return;
+ if (globalThis.window !== undefined) return;
try {
const result = await cache.set(
@@ -221,12 +264,21 @@ const validateLicenseDetails = (data: unknown): TEnterpriseLicenseDetails => {
};
// Fallback functions
+let memoryCache: {
+ data: TEnterpriseLicenseResult;
+ timestamp: number;
+} | null = null;
+
+const MEMORY_CACHE_TTL_MS = 60 * 1000; // 1 minute memory cache to avoid stampedes and reduce load when Redis is slow
+
+let getEnterpriseLicensePromise: Promise | null = null;
+
const getFallbackLevel = (
liveLicense: TEnterpriseLicenseDetails | null,
previousResult: TPreviousResult,
currentTime: Date
): FallbackLevel => {
- if (liveLicense) return "live";
+ if (liveLicense?.status === "active") return "live";
if (previousResult.active) {
const elapsedTime = currentTime.getTime() - previousResult.lastChecked.getTime();
return elapsedTime < CONFIG.CACHE.GRACE_PERIOD_MS ? "grace" : "default";
@@ -234,7 +286,7 @@ const getFallbackLevel = (
return "default";
};
-const handleInitialFailure = async (currentTime: Date) => {
+const handleInitialFailure = async (currentTime: Date): Promise => {
const initialFailResult: TPreviousResult = {
active: false,
features: DEFAULT_FEATURES,
@@ -247,10 +299,26 @@ const handleInitialFailure = async (currentTime: Date) => {
lastChecked: currentTime,
isPendingDowngrade: false,
fallbackLevel: "default" as const,
+ status: "unreachable" as const,
};
};
+/**
+ * Try to read cached license from Redis. Returns undefined on miss or error.
+ */
+const getCachedLicense = async (): Promise => {
+ const keys = getCacheKeys();
+ const result = await cache.get(keys.FETCH_LICENSE_CACHE_KEY);
+ if (!result.ok) return undefined;
+ if (result.data !== null && result.data !== undefined && "value" in result.data) {
+ return result.data.value;
+ }
+ return undefined;
+};
+
// API functions
+let fetchLicensePromise: Promise | null = null;
+
const fetchLicenseFromServerInternal = async (retryCount = 0): Promise => {
if (!env.ENTERPRISE_LICENSE_KEY) return null;
@@ -266,6 +334,7 @@ const fetchLicenseFromServerInternal = async (retryCount = 0): Promise current year is fully included
const startOfNextYear = new Date(now.getFullYear() + 1, 0, 1);
+ const startTime = Date.now();
const [instanceId, responseCount] = await Promise.all([
// Skip instance ID during E2E tests to avoid license key conflicts
// as the instance ID changes with each test run
@@ -279,6 +348,11 @@ const fetchLicenseFromServerInternal = async (retryCount = 0): Promise 1000) {
+ logger.warn({ duration, responseCount }, "Slow license check prerequisite data fetching (DB count)");
+ }
// No organization exists, cannot perform license check
// (skip this check during E2E tests as we intentionally use null)
@@ -311,7 +385,19 @@ const fetchLicenseFromServerInternal = async (retryCount = 0): Promise
return null;
}
- return await cache.withCache(
- async () => {
+ if (fetchLicensePromise) {
+ return fetchLicensePromise;
+ }
+
+ fetchLicensePromise = (async () => {
+ const keys = getCacheKeys();
+ const cached = await getCachedLicense();
+ if (cached !== undefined) return cached;
+
+ const lockResult = await cache.tryLock(keys.FETCH_LOCK_CACHE_KEY, "1", LICENSE_FETCH_LOCK_TTL_MS);
+ const acquired = lockResult.ok && lockResult.data === true;
+ const redisError = !lockResult.ok;
+
+ if (acquired) {
+ try {
+ const fresh = await fetchLicenseFromServerInternal();
+ const ttl = fresh ? CONFIG.CACHE.FETCH_LICENSE_TTL_MS : CONFIG.CACHE.FAILED_FETCH_TTL_MS;
+
+ if (!fresh) {
+ logger.warn(
+ {
+ ttlMinutes: Math.floor(ttl / 60000),
+ timestamp: new Date().toISOString(),
+ },
+ "License fetch failed, caching null result with short TTL for faster retry"
+ );
+ }
+
+ await cache.set(keys.FETCH_LICENSE_CACHE_KEY, { value: fresh }, ttl);
+ return fresh;
+ } finally {
+ // Lock expires automatically; no need to release
+ }
+ }
+
+ // If Redis itself is down, skip the polling loop (it would just fail repeatedly)
+ // and go directly to fetching from the server.
+ if (redisError) {
+ logger.warn("Redis unavailable during license fetch lock; skipping poll and fetching directly");
return await fetchLicenseFromServerInternal();
- },
- getCacheKeys().FETCH_LICENSE_CACHE_KEY,
- CONFIG.CACHE.FETCH_LICENSE_TTL_MS
- );
+ }
+
+ // Another process holds the lock — poll until the cache is populated or timeout
+ const deadline = Date.now() + LICENSE_FETCH_POLL_MS;
+ while (Date.now() < deadline) {
+ await sleep(LICENSE_FETCH_POLL_INTERVAL_MS);
+ const value = await getCachedLicense();
+ if (value !== undefined) return value;
+ }
+
+ logger.warn(
+ { pollMs: LICENSE_FETCH_POLL_MS },
+ "License cache not populated by holder within poll window; fetching in this process"
+ );
+ const fallback = await fetchLicenseFromServerInternal();
+ const fallbackTtl = fallback ? CONFIG.CACHE.FETCH_LICENSE_TTL_MS : CONFIG.CACHE.FAILED_FETCH_TTL_MS;
+ await cache.set(keys.FETCH_LICENSE_CACHE_KEY, { value: fallback }, fallbackTtl);
+ return fallback;
+ })();
+
+ fetchLicensePromise
+ .finally(() => {
+ fetchLicensePromise = null;
+ })
+ .catch(() => {});
+
+ return fetchLicensePromise;
};
-export const getEnterpriseLicense = reactCache(
- async (): Promise<{
- active: boolean;
- features: TEnterpriseLicenseFeatures | null;
- lastChecked: Date;
- isPendingDowngrade: boolean;
- fallbackLevel: FallbackLevel;
- }> => {
- validateConfig();
+/**
+ * Core license state evaluation logic.
+ * Accepts pre-fetched license details and applies fallback / grace-period rules.
+ * Sets the in-process memoryCache as a side effect so subsequent requests benefit.
+ */
+const computeLicenseState = async (
+ liveLicenseDetails: TEnterpriseLicenseDetails | null
+): Promise => {
+ validateConfig();
- if (!env.ENTERPRISE_LICENSE_KEY || env.ENTERPRISE_LICENSE_KEY.length === 0) {
- return {
- active: false,
- features: null,
- lastChecked: new Date(),
- isPendingDowngrade: false,
- fallbackLevel: "default" as const,
+ if (!env.ENTERPRISE_LICENSE_KEY || env.ENTERPRISE_LICENSE_KEY.length === 0) {
+ return {
+ active: false,
+ features: null,
+ lastChecked: new Date(),
+ isPendingDowngrade: false,
+ fallbackLevel: "default" as const,
+ status: "no-license" as const,
+ };
+ }
+
+ const currentTime = new Date();
+ const previousResult = await getPreviousResult();
+ const fallbackLevel = getFallbackLevel(liveLicenseDetails, previousResult, currentTime);
+ trackFallbackUsage(fallbackLevel);
+
+ let currentLicenseState: TPreviousResult | undefined;
+
+ switch (fallbackLevel) {
+ case "live": {
+ if (!liveLicenseDetails) throw new Error("Invalid state: live license expected");
+ currentLicenseState = {
+ active: liveLicenseDetails.status === "active",
+ features: liveLicenseDetails.features,
+ lastChecked: currentTime,
};
+
+ // Only update previous result if it's actually different or if it's old (1 hour)
+ // This prevents hammering Redis on every request when the license is active
+ if (
+ !previousResult.active ||
+ previousResult.active !== currentLicenseState.active ||
+ currentTime.getTime() - previousResult.lastChecked.getTime() > 60 * 60 * 1000
+ ) {
+ await setPreviousResult(currentLicenseState);
+ }
+
+ const liveResult: TEnterpriseLicenseResult = {
+ active: currentLicenseState.active,
+ features: currentLicenseState.features,
+ lastChecked: currentTime,
+ isPendingDowngrade: false,
+ fallbackLevel: "live" as const,
+ status: liveLicenseDetails.status,
+ };
+ memoryCache = { data: liveResult, timestamp: Date.now() };
+ return liveResult;
}
- const currentTime = new Date();
- const liveLicenseDetails = await fetchLicense();
- const previousResult = await getPreviousResult();
- const fallbackLevel = getFallbackLevel(liveLicenseDetails, previousResult, currentTime);
+ case "grace": {
+ if (!validateFallback(previousResult)) {
+ return await handleInitialFailure(currentTime);
+ }
+ logger.warn(
+ {
+ lastChecked: previousResult.lastChecked.toISOString(),
+ gracePeriodEnds: new Date(
+ previousResult.lastChecked.getTime() + CONFIG.CACHE.GRACE_PERIOD_MS
+ ).toISOString(),
+ timestamp: new Date().toISOString(),
+ },
+ "License server unreachable, using grace period. Will retry in ~10 minutes."
+ );
+ const graceResult: TEnterpriseLicenseResult = {
+ active: previousResult.active,
+ features: previousResult.features,
+ lastChecked: previousResult.lastChecked,
+ isPendingDowngrade: true,
+ fallbackLevel: "grace" as const,
+ status: (liveLicenseDetails?.status as TEnterpriseLicenseStatusReturn) ?? "unreachable",
+ };
+ memoryCache = { data: graceResult, timestamp: Date.now() };
+ return graceResult;
+ }
- trackFallbackUsage(fallbackLevel);
-
- let currentLicenseState: TPreviousResult | undefined;
-
- switch (fallbackLevel) {
- case "live":
- if (!liveLicenseDetails) throw new Error("Invalid state: live license expected");
- currentLicenseState = {
- active: liveLicenseDetails.status === "active",
- features: liveLicenseDetails.features,
- lastChecked: currentTime,
- };
- await setPreviousResult(currentLicenseState);
- return {
- active: currentLicenseState.active,
- features: currentLicenseState.features,
+ case "default": {
+ if (liveLicenseDetails?.status === "expired") {
+ const expiredResult: TEnterpriseLicenseResult = {
+ active: false,
+ features: DEFAULT_FEATURES,
lastChecked: currentTime,
isPendingDowngrade: false,
- fallbackLevel: "live" as const,
+ fallbackLevel: "default" as const,
+ status: "expired" as const,
};
+ memoryCache = { data: expiredResult, timestamp: Date.now() };
+ return expiredResult;
+ }
+ const failResult = await handleInitialFailure(currentTime);
+ memoryCache = { data: failResult, timestamp: Date.now() };
+ return failResult;
+ }
+ }
- case "grace":
- if (!validateFallback(previousResult)) {
- return handleInitialFailure(currentTime);
- }
- return {
- active: previousResult.active,
- features: previousResult.features,
- lastChecked: previousResult.lastChecked,
- isPendingDowngrade: true,
- fallbackLevel: "grace" as const,
+ const finalFailResult = await handleInitialFailure(currentTime);
+ memoryCache = { data: finalFailResult, timestamp: Date.now() };
+ return finalFailResult;
+};
+
+export const getEnterpriseLicense = reactCache(async (): Promise => {
+ if (
+ process.env.NODE_ENV !== "test" &&
+ memoryCache &&
+ Date.now() - memoryCache.timestamp < MEMORY_CACHE_TTL_MS
+ ) {
+ return memoryCache.data;
+ }
+
+ if (getEnterpriseLicensePromise) return getEnterpriseLicensePromise;
+
+ getEnterpriseLicensePromise = (async () => {
+ let liveLicenseDetails: TEnterpriseLicenseDetails | null = null;
+
+ try {
+ liveLicenseDetails = await fetchLicense();
+ } catch (error) {
+ if (error instanceof LicenseApiError && error.status === 400) {
+ const invalidResult: TEnterpriseLicenseResult = {
+ active: false,
+ features: DEFAULT_FEATURES,
+ lastChecked: new Date(),
+ isPendingDowngrade: false,
+ fallbackLevel: "default" as const,
+ status: "invalid_license" as const,
};
-
- case "default":
- return handleInitialFailure(currentTime);
+ memoryCache = { data: invalidResult, timestamp: Date.now() };
+ return invalidResult;
+ }
+ // Other errors: liveLicenseDetails stays null (treated as unreachable)
}
- return handleInitialFailure(currentTime);
- }
-);
+ return computeLicenseState(liveLicenseDetails);
+ })();
+
+ getEnterpriseLicensePromise
+ .finally(() => {
+ getEnterpriseLicensePromise = null;
+ })
+ .catch(() => {});
+
+ return getEnterpriseLicensePromise;
+});
export const getLicenseFeatures = async (): Promise => {
try {
@@ -427,4 +671,55 @@ export const getLicenseFeatures = async (): Promise => {
+ memoryCache = null;
+ const cacheKeys = getCacheKeys();
+ // Only clear the main fetch cache, NOT the previous result cache
+ // This preserves the grace period fallback if the server is unreachable
+ const delResult = await cache.del([cacheKeys.FETCH_LICENSE_CACHE_KEY]);
+ if (!delResult.ok) {
+ logger.warn({ error: delResult.error }, "Failed to delete license cache");
+ }
+};
+
+/**
+ * Fetch license directly from server without using cache.
+ * Used by the recheck license action for a fresh check.
+ * Concurrent callers share a single in-flight request to avoid
+ * hammering the license server (e.g. multiple managers rechecking).
+ */
+let fetchLicenseFreshPromise: Promise | null = null;
+
+export const fetchLicenseFresh = async (): Promise => {
+ if (fetchLicenseFreshPromise) return fetchLicenseFreshPromise;
+
+ fetchLicenseFreshPromise = fetchLicenseFromServerInternal();
+
+ fetchLicenseFreshPromise
+ .finally(() => {
+ fetchLicenseFreshPromise = null;
+ })
+ .catch(() => {});
+
+ return fetchLicenseFreshPromise;
+};
+
+/**
+ * Compute license state from pre-fetched license data, bypassing React cache
+ * and the in-process memory cache. Used by the recheck action to guarantee
+ * fresh evaluation after clearing caches and fetching new data.
+ * Refreshes the in-process memory cache as a side effect so subsequent
+ * requests benefit from the fresh result.
+ */
+export const computeFreshLicenseState = async (
+ freshLicense: TEnterpriseLicenseDetails | null
+): Promise => {
+ memoryCache = null;
+ return computeLicenseState(freshLicense);
+};
+
// All permission checking functions and their helpers have been moved to utils.ts
diff --git a/apps/web/modules/ee/license-check/types/enterprise-license.ts b/apps/web/modules/ee/license-check/types/enterprise-license.ts
index 8144692e22..6901de6482 100644
--- a/apps/web/modules/ee/license-check/types/enterprise-license.ts
+++ b/apps/web/modules/ee/license-check/types/enterprise-license.ts
@@ -29,3 +29,10 @@ export const ZEnterpriseLicenseDetails = z.object({
});
export type TEnterpriseLicenseDetails = z.infer;
+
+export type TEnterpriseLicenseStatusReturn =
+ | "active"
+ | "expired"
+ | "unreachable"
+ | "invalid_license"
+ | "no-license";
diff --git a/apps/web/modules/ee/multi-language-surveys/components/edit-language.tsx b/apps/web/modules/ee/multi-language-surveys/components/edit-language.tsx
index cf37396e09..8895229487 100644
--- a/apps/web/modules/ee/multi-language-surveys/components/edit-language.tsx
+++ b/apps/web/modules/ee/multi-language-surveys/components/edit-language.tsx
@@ -154,7 +154,12 @@ export function EditLanguage({
const performLanguageDeletion = async (languageId: string) => {
try {
- await deleteLanguageAction({ languageId, projectId: project.id });
+ const result = await deleteLanguageAction({ languageId, projectId: project.id });
+ if (result?.serverError) {
+ toast.error(getFormattedErrorMessage(result));
+ setConfirmationModal((prev) => ({ ...prev, isOpen: false }));
+ return;
+ }
setLanguages((prev) => prev.filter((lang) => lang.id !== languageId));
toast.success(t("environments.workspace.languages.language_deleted_successfully"));
// Close the modal after deletion
@@ -187,7 +192,7 @@ export function EditLanguage({
const handleSaveChanges = async () => {
if (!validateLanguages(languages, t)) return;
- await Promise.all(
+ const results = await Promise.all(
languages.map((lang) => {
return lang.id === "new"
? createLanguageAction({
@@ -201,6 +206,11 @@ export function EditLanguage({
});
})
);
+ const errorResult = results.find((result) => result?.serverError);
+ if (errorResult) {
+ toast.error(getFormattedErrorMessage(errorResult));
+ return;
+ }
toast.success(t("environments.workspace.languages.languages_updated_successfully"));
router.refresh();
setIsEditing(false);
@@ -239,7 +249,7 @@ export function EditLanguage({
))}
) : (
-
+
{t("environments.workspace.languages.no_language_found")}
)}
diff --git a/apps/web/modules/ee/multi-language-surveys/components/language-select.tsx b/apps/web/modules/ee/multi-language-surveys/components/language-select.tsx
index 143a06d4e1..c795ffb628 100644
--- a/apps/web/modules/ee/multi-language-surveys/components/language-select.tsx
+++ b/apps/web/modules/ee/multi-language-surveys/components/language-select.tsx
@@ -21,7 +21,7 @@ export function LanguageSelect({ language, onLanguageChange, disabled, locale }:
const { t } = useTranslation();
const [isOpen, setIsOpen] = useState(false);
const [searchTerm, setSearchTerm] = useState("");
- const [selectedOption, setSelectedOption] = useState(
+ const [selectedOption, setSelectedOption] = useState(
iso639Languages.find((isoLang) => isoLang.code === language.code)
);
const items = iso639Languages;
@@ -72,7 +72,7 @@ export function LanguageSelect({ language, onLanguageChange, disabled, locale }:
+ className={`absolute right-0 z-30 mt-2 space-y-1 rounded-md bg-white p-1 shadow-lg ring-1 ring-black ring-opacity-5 ${isOpen ? "" : "hidden"}`}>
{
diff --git a/apps/web/modules/ee/multi-language-surveys/components/localized-editor.tsx b/apps/web/modules/ee/multi-language-surveys/components/localized-editor.tsx
index 98e3be3a1b..1b03f87f64 100644
--- a/apps/web/modules/ee/multi-language-surveys/components/localized-editor.tsx
+++ b/apps/web/modules/ee/multi-language-surveys/components/localized-editor.tsx
@@ -1,7 +1,7 @@
"use client";
+import { useMemo, useTransition } from "react";
import type { Dispatch, SetStateAction } from "react";
-import { useMemo } from "react";
import { useTranslation } from "react-i18next";
import type { TI18nString } from "@formbricks/types/i18n";
import type { TSurvey, TSurveyLanguage } from "@formbricks/types/surveys/types";
@@ -74,6 +74,8 @@ export function LocalizedEditor({
[id, isInvalid, localSurvey.languages, value]
);
+ const [, startTransition] = useTransition();
+
return (
]*>(.*?)<\/a>/gi, "$1");
}
- // Check if the elements still exists before updating
const currentElement = elements[elementIdx];
- // if this is a card, we wanna check if the card exists in the localSurvey
- if (isCard) {
- const isWelcomeCard = elementIdx === -1;
- const isEndingCard = elementIdx >= elements.length;
+ startTransition(() => {
+ // if this is a card, we wanna check if the card exists in the localSurvey
+ if (isCard) {
+ const isWelcomeCard = elementIdx === -1;
+ const isEndingCard = elementIdx >= elements.length;
- // For ending cards, check if the field exists before updating
- if (isEndingCard) {
- const ending = localSurvey.endings.find((ending) => ending.id === elementId);
- // If the field doesn't exist on the ending card, don't create it
- if (!ending || ending[id] === undefined) {
+ // For ending cards, check if the field exists before updating
+ if (isEndingCard) {
+ const ending = localSurvey.endings.find((ending) => ending.id === elementId);
+ // If the field doesn't exist on the ending card, don't create it
+ if (!ending || ending[id] === undefined) {
+ return;
+ }
+ }
+
+ // For welcome cards, check if it exists
+ if (isWelcomeCard && !localSurvey.welcomeCard) {
return;
}
- }
- // For welcome cards, check if it exists
- if (isWelcomeCard && !localSurvey.welcomeCard) {
+ const translatedContent = {
+ ...value,
+ [selectedLanguageCode]: sanitizedContent,
+ };
+ updateElement({ [id]: translatedContent });
return;
}
- const translatedContent = {
- ...value,
- [selectedLanguageCode]: sanitizedContent,
- };
- updateElement({ [id]: translatedContent });
- return;
- }
-
- // Check if the field exists on the element (not just if it's not undefined)
- if (currentElement && id in currentElement && currentElement[id] !== undefined) {
- const translatedContent = {
- ...value,
- [selectedLanguageCode]: sanitizedContent,
- };
- updateElement(elementIdx, { [id]: translatedContent });
- }
+ // Check if the field exists on the element (not just if it's not undefined)
+ if (currentElement && id in currentElement && currentElement[id] !== undefined) {
+ const translatedContent = {
+ ...value,
+ [selectedLanguageCode]: sanitizedContent,
+ };
+ updateElement(elementIdx, { [id]: translatedContent });
+ }
+ });
}}
localSurvey={localSurvey}
elementId={elementId}
diff --git a/apps/web/modules/ee/teams/team-list/components/team-settings/delete-team.tsx b/apps/web/modules/ee/teams/team-list/components/team-settings/delete-team.tsx
index a34d33382e..efb37bae81 100644
--- a/apps/web/modules/ee/teams/team-list/components/team-settings/delete-team.tsx
+++ b/apps/web/modules/ee/teams/team-list/components/team-settings/delete-team.tsx
@@ -4,6 +4,7 @@ import { useRouter } from "next/navigation";
import { useState } from "react";
import toast from "react-hot-toast";
import { useTranslation } from "react-i18next";
+import { getFormattedErrorMessage } from "@/lib/utils/helper";
import { deleteTeamAction } from "@/modules/ee/teams/team-list/actions";
import { TTeam } from "@/modules/ee/teams/team-list/types/team";
import { Button } from "@/modules/ui/components/button";
@@ -27,6 +28,12 @@ export const DeleteTeam = ({ teamId, onDelete, isOwnerOrManager }: DeleteTeamPro
setIsDeleting(true);
const deleteTeamActionResponse = await deleteTeamAction({ teamId });
+ if (deleteTeamActionResponse?.serverError) {
+ toast.error(getFormattedErrorMessage(deleteTeamActionResponse));
+ setIsDeleteDialogOpen(false);
+ setIsDeleting(false);
+ return;
+ }
if (deleteTeamActionResponse?.data) {
toast.success(t("environments.settings.teams.team_deleted_successfully"));
onDelete?.();
diff --git a/apps/web/modules/ee/teams/team-list/components/team-settings/member-row.tsx b/apps/web/modules/ee/teams/team-list/components/team-settings/member-row.tsx
new file mode 100644
index 0000000000..09c6013666
--- /dev/null
+++ b/apps/web/modules/ee/teams/team-list/components/team-settings/member-row.tsx
@@ -0,0 +1,137 @@
+"use client";
+
+import { XIcon } from "lucide-react";
+import { Control } from "react-hook-form";
+import { useTranslation } from "react-i18next";
+import {
+ TOrganizationMember,
+ TTeamRole,
+ TTeamSettingsFormSchema,
+ ZTeamRole,
+} from "@/modules/ee/teams/team-list/types/team";
+import { Button } from "@/modules/ui/components/button";
+import { FormError, FormField, FormItem } from "@/modules/ui/components/form";
+import { InputCombobox } from "@/modules/ui/components/input-combo-box";
+import { TooltipRenderer } from "@/modules/ui/components/tooltip";
+
+export interface MemberRowProps {
+ index: number;
+ member: { userId: string; role: TTeamRole };
+ memberOpts: { value: string; label: string }[];
+ control: Control;
+ orgMembers: TOrganizationMember[];
+ watchMembers: { userId: string; role: TTeamRole }[];
+ initialMemberIds: Set;
+ isOwnerOrManager: boolean;
+ isTeamAdminMember: boolean;
+ isTeamContributorMember: boolean;
+ currentUserId: string;
+ onMemberSelectionChange: (index: number, userId: string) => void;
+ onRemoveMember: (index: number) => void;
+ memberCount: number;
+}
+
+export function MemberRow(props: Readonly) {
+ const {
+ index,
+ member,
+ memberOpts,
+ control,
+ orgMembers,
+ watchMembers,
+ initialMemberIds,
+ isOwnerOrManager,
+ isTeamAdminMember,
+ isTeamContributorMember,
+ currentUserId,
+ onMemberSelectionChange,
+ onRemoveMember,
+ memberCount,
+ } = props;
+ const { t } = useTranslation();
+ const chosenMember = orgMembers.find((m) => m.id === watchMembers[index]?.userId);
+ const canEditWhenNoMember = isOwnerOrManager || isTeamAdminMember;
+ const isRoleSelectDisabled =
+ chosenMember === undefined
+ ? !canEditWhenNoMember
+ : chosenMember.role === "owner" ||
+ chosenMember.role === "manager" ||
+ isTeamContributorMember ||
+ chosenMember.id === currentUserId;
+
+ return (
+
+
{
+ const isExistingMember = member.userId && initialMemberIds.has(member.userId);
+ const isSelectDisabled = isExistingMember || (!isOwnerOrManager && !isTeamAdminMember);
+
+ return (
+
+
+ {
+ const value = typeof val === "string" ? val : "";
+ field.onChange(value);
+ onMemberSelectionChange(index, value);
+ }}
+ showSearch
+ searchPlaceholder={t("common.search")}
+ comboboxClasses="flex-1 min-w-0 w-full"
+ emptyDropdownText={t("environments.surveys.edit.no_option_found")}
+ />
+
+ {error?.message && {error.message}}
+
+ );
+ }}
+ />
+ {
+ const roleOptions = [
+ { value: ZTeamRole.enum.admin, label: t("environments.settings.teams.team_admin") },
+ {
+ value: ZTeamRole.enum.contributor,
+ label: t("environments.settings.teams.contributor"),
+ },
+ ];
+
+ return (
+
+
+ field.onChange(val)}
+ showSearch={false}
+ comboboxClasses="flex-1 min-w-0 w-full"
+ />
+
+
+ );
+ }}
+ />
+ {memberCount > 1 && (
+
+
+
+ )}
+
- {watchMembers.map((member, index) => {
- const memberOpts = getMemberOptionsForIndex(index);
- return (
-
- {
- // Disable user select for existing members (can only remove or change role)
- const isExistingMember =
- member.userId && initialMemberIds.has(member.userId);
- const isSelectDisabled =
- isExistingMember || (!isOwnerOrManager && !isTeamAdminMember);
-
- return (
-
-
- {error?.message && (
- {error.message}
- )}
-
- );
- }}
- />
-
- (
-
-
-
- )}
- />
-
- {/* Delete Button for Member */}
- {watchMembers.length > 1 && (
-
-
-
- )}
-
- );
- })}
+ {watchMembers.map((member, index) => (
+
+ ))}
- {watchProjects.map((project, index) => {
- const projectOpts = getProjectOptionsForIndex(index);
- return (
-
- {
- // Disable project select for existing projects (can only remove or change permission)
- const isExistingProject =
- project.projectId && initialProjectIds.has(project.projectId);
- const isSelectDisabled = isExistingProject || !isOwnerOrManager;
-
- return (
-
-
- {error?.message && (
- {error.message}
- )}
-
- );
- }}
- />
-
- (
-
-
-
- )}
- />
- {watchProjects.length > 1 && (
-
- )}
-
- );
- })}
+ {watchProjects.map((project, index) => (
+
+ ))}
+
{
+ const isExistingProject = project.projectId && initialProjectIds.has(project.projectId);
+ const isSelectDisabled = isExistingProject || !isOwnerOrManager;
+
+ return (
+
+
+ {
+ const value = typeof val === "string" ? val : "";
+ field.onChange(value);
+ }}
+ showSearch
+ searchPlaceholder={t("common.search")}
+ comboboxClasses="flex-1 min-w-0 w-full"
+ emptyDropdownText={t("environments.surveys.edit.no_option_found")}
+ />
+
+ {error?.message && {error.message}}
+
+ );
+ }}
+ />
+ {
+ const permissionOptions = [
+ {
+ value: ZTeamPermission.enum.read,
+ label: t("environments.settings.teams.read"),
+ },
+ {
+ value: ZTeamPermission.enum.readWrite,
+ label: t("environments.settings.teams.read_write"),
+ },
+ {
+ value: ZTeamPermission.enum.manage,
+ label: t("environments.settings.teams.manage"),
+ },
+ ];
+
+ return (
+
+
+ field.onChange(val)}
+ showSearch={false}
+ comboboxClasses="flex-1 min-w-0 w-full"
+ />
+
+
+ );
+ }}
+ />
+ {projectCount > 1 && (
+
+ )}
+ 
) : (
-
+ })
)
)}
@@ -360,11 +361,11 @@ export async function PreviewEmailTemplate({
-
+
{firstQuestion.columns.map((column) => {
return (
{getLocalizedValue(column.label, "default")}
@@ -376,7 +377,7 @@ export async function PreviewEmailTemplate({
-
+
{getLocalizedValue(row.label, "default")}
{firstQuestion.columns.map((column) => {
diff --git a/apps/web/modules/email/index.tsx b/apps/web/modules/email/index.tsx
index 93111b4775..d90be82b12 100644
--- a/apps/web/modules/email/index.tsx
+++ b/apps/web/modules/email/index.tsx
@@ -17,6 +17,7 @@ import { logger } from "@formbricks/logger";
import type { TLinkSurveyEmailData } from "@formbricks/types/email";
import { InvalidInputError } from "@formbricks/types/errors";
import type { TResponse } from "@formbricks/types/responses";
+import { TSurveyElementTypeEnum } from "@formbricks/types/surveys/elements";
import type { TSurvey } from "@formbricks/types/surveys/types";
import { TUserEmail, TUserLocale } from "@formbricks/types/user";
import {
@@ -41,6 +42,7 @@ import { createEmailChangeToken, createInviteToken, createToken, createTokenForL
import { getOrganizationByEnvironmentId } from "@/lib/organization/service";
import { getElementResponseMapping } from "@/lib/responses";
import { getTranslate } from "@/lingodotdev/server";
+import { resolveStorageUrl } from "@/modules/storage/utils";
export const IS_SMTP_CONFIGURED = Boolean(SMTP_HOST && SMTP_PORT);
@@ -241,6 +243,22 @@ export const sendResponseFinishedEmail = async (
// Pre-process the element response mapping before passing to email
const elements = getElementResponseMapping(survey, response);
+ // Resolve relative storage URLs to absolute URLs for email rendering
+ const elementsWithResolvedUrls = elements.map((element) => {
+ if (
+ (element.type === TSurveyElementTypeEnum.PictureSelection ||
+ element.type === TSurveyElementTypeEnum.FileUpload) &&
+ Array.isArray(element.response)
+ ) {
+ return {
+ ...element,
+ response: element.response.map((url) => resolveStorageUrl(url)),
+ };
+ }
+
+ return element;
+ });
+
const html = await renderResponseFinishedEmail({
survey,
responseCount,
@@ -248,7 +266,7 @@ export const sendResponseFinishedEmail = async (
WEBAPP_URL,
environmentId,
organization,
- elements,
+ elements: elementsWithResolvedUrls,
t,
...legalProps,
});
@@ -276,10 +294,12 @@ export const sendEmbedSurveyPreviewEmail = async (
logoUrl?: string
): Promise => {
const t = await getTranslate(locale);
+ // Resolve relative storage URLs to absolute URLs for email rendering
+ const resolvedLogoUrl = logoUrl ? resolveStorageUrl(logoUrl) : undefined;
const html = await renderEmbedSurveyPreviewEmail({
html: innerHtml,
environmentId,
- logoUrl,
+ logoUrl: resolvedLogoUrl,
t,
...legalProps,
});
@@ -297,9 +317,11 @@ export const sendEmailCustomizationPreviewEmail = async (
logoUrl?: string
): Promise => {
const t = await getTranslate(locale);
+ // Resolve relative storage URLs to absolute URLs for email rendering
+ const resolvedLogoUrl = logoUrl ? resolveStorageUrl(logoUrl) : undefined;
const emailHtmlBody = await renderEmailCustomizationPreviewEmail({
userName,
- logoUrl,
+ logoUrl: resolvedLogoUrl,
t,
...legalProps,
});
@@ -316,7 +338,8 @@ export const sendLinkSurveyToVerifiedEmail = async (data: TLinkSurveyEmailData):
const email = data.email;
const surveyName = data.surveyName;
const singleUseId = data.suId;
- const logoUrl = data.logoUrl || "";
+ // Resolve relative storage URLs to absolute URLs for email rendering
+ const logoUrl = data.logoUrl ? resolveStorageUrl(data.logoUrl) : "";
const token = createTokenForLinkSurvey(surveyId, email);
const t = await getTranslate(data.locale);
const getSurveyLink = (): string => {
diff --git a/apps/web/modules/environments/lib/utils.test.ts b/apps/web/modules/environments/lib/utils.test.ts
index cef718ccbb..6dd64f7eca 100644
--- a/apps/web/modules/environments/lib/utils.test.ts
+++ b/apps/web/modules/environments/lib/utils.test.ts
@@ -177,9 +177,9 @@ describe("utils.ts", () => {
await expect(getEnvironmentAuth("env123")).rejects.toThrow("common.organization_not_found");
});
- test("throws error if membership not found", async () => {
+ test("throws AuthorizationError if membership not found", async () => {
vi.mocked(getMembershipByUserIdOrganizationId).mockResolvedValueOnce(null);
- await expect(getEnvironmentAuth("env123")).rejects.toThrow("common.membership_not_found");
+ await expect(getEnvironmentAuth("env123")).rejects.toThrow(AuthorizationError);
});
});
@@ -241,7 +241,7 @@ describe("utils.ts", () => {
config: {},
placement: "bottomRight" as const,
clickOutsideClose: true,
- darkOverlay: false,
+ overlay: "none",
styling: {},
logo: null,
environments: [
@@ -389,7 +389,7 @@ describe("utils.ts", () => {
config: {},
placement: "bottomRight",
clickOutsideClose: true,
- darkOverlay: false,
+ overlay: "none",
styling: {},
logo: null,
environments: [
@@ -481,7 +481,7 @@ describe("utils.ts", () => {
await expect(getEnvironmentLayoutData("env123", "user123")).rejects.toThrow(AuthorizationError);
});
- test("throws error if membership not found", async () => {
+ test("throws AuthorizationError if membership not found", async () => {
vi.mocked(prisma.environment.findUnique).mockResolvedValueOnce({
id: "env123",
createdAt: new Date(),
@@ -502,7 +502,7 @@ describe("utils.ts", () => {
config: {},
placement: "bottomRight",
clickOutsideClose: true,
- darkOverlay: false,
+ overlay: "none",
styling: {},
logo: null,
environments: [],
@@ -519,9 +519,7 @@ describe("utils.ts", () => {
},
} as any);
- await expect(getEnvironmentLayoutData("env123", "user123")).rejects.toThrow(
- "common.membership_not_found"
- );
+ await expect(getEnvironmentLayoutData("env123", "user123")).rejects.toThrow(AuthorizationError);
});
test("fetches user before auth check, then environment data after authorization", async () => {
@@ -588,7 +586,7 @@ describe("utils.ts", () => {
config: {},
placement: "bottomRight",
clickOutsideClose: true,
- darkOverlay: false,
+ overlay: "none",
styling: {},
logo: null,
environments: [],
@@ -627,7 +625,7 @@ describe("utils.ts", () => {
config: {},
placement: "bottomRight",
clickOutsideClose: true,
- darkOverlay: false,
+ overlay: "none",
styling: {},
logo: null,
environments: [],
diff --git a/apps/web/modules/environments/lib/utils.ts b/apps/web/modules/environments/lib/utils.ts
index 6b9bd09f3b..d60705dcdb 100644
--- a/apps/web/modules/environments/lib/utils.ts
+++ b/apps/web/modules/environments/lib/utils.ts
@@ -61,7 +61,7 @@ export const getEnvironmentAuth = reactCache(async (environmentId: string): Prom
const currentUserMembership = await getMembershipByUserIdOrganizationId(session?.user.id, organization.id);
if (!currentUserMembership) {
- throw new Error(t("common.membership_not_found"));
+ throw new AuthorizationError(t("common.membership_not_found"));
}
const { isMember, isOwner, isManager, isBilling } = getAccessFlags(currentUserMembership?.role);
@@ -150,7 +150,7 @@ export const getEnvironmentWithRelations = reactCache(async (environmentId: stri
config: true,
placement: true,
clickOutsideClose: true,
- darkOverlay: true,
+ overlay: true,
styling: true,
logo: true,
customHeadScripts: true,
@@ -220,7 +220,7 @@ export const getEnvironmentWithRelations = reactCache(async (environmentId: stri
config: data.project.config,
placement: data.project.placement,
clickOutsideClose: data.project.clickOutsideClose,
- darkOverlay: data.project.darkOverlay,
+ overlay: data.project.overlay,
styling: data.project.styling,
logo: data.project.logo,
customHeadScripts: data.project.customHeadScripts,
@@ -293,7 +293,7 @@ export const getEnvironmentLayoutData = reactCache(
// Validate user's membership was found
if (!membership) {
- throw new Error(t("common.membership_not_found"));
+ throw new AuthorizationError(t("common.membership_not_found"));
}
// Fetch remaining data in parallel
diff --git a/apps/web/modules/environments/types/environment-auth.ts b/apps/web/modules/environments/types/environment-auth.ts
index fd96a658f7..4b2891c5b3 100644
--- a/apps/web/modules/environments/types/environment-auth.ts
+++ b/apps/web/modules/environments/types/environment-auth.ts
@@ -15,6 +15,7 @@ type TEnterpriseLicense = {
lastChecked: Date;
isPendingDowngrade: boolean;
fallbackLevel: string;
+ status: "active" | "expired" | "unreachable" | "no-license" | "invalid_license";
};
export const ZEnvironmentAuth = z.object({
diff --git a/apps/web/modules/organization/settings/teams/actions.ts b/apps/web/modules/organization/settings/teams/actions.ts
index 8a726a8368..4d723a6991 100644
--- a/apps/web/modules/organization/settings/teams/actions.ts
+++ b/apps/web/modules/organization/settings/teams/actions.ts
@@ -2,6 +2,7 @@
import { OrganizationRole } from "@prisma/client";
import { z } from "zod";
+import { prisma } from "@formbricks/database";
import { ZId, ZUuid } from "@formbricks/types/common";
import { AuthenticationError, OperationNotAllowedError, ValidationError } from "@formbricks/types/errors";
import { TOrganizationRole, ZOrganizationRole } from "@formbricks/types/memberships";
@@ -23,7 +24,7 @@ import {
getMembershipsByUserId,
getOrganizationOwnerCount,
} from "@/modules/organization/settings/teams/lib/membership";
-import { deleteInvite, getInvite, inviteUser, resendInvite } from "./lib/invite";
+import { deleteInvite, getInvite, inviteUser, refreshInviteExpiration, resendInvite } from "./lib/invite";
const ZDeleteInviteAction = z.object({
inviteId: ZUuid,
@@ -57,30 +58,57 @@ const ZCreateInviteTokenAction = z.object({
inviteId: ZUuid,
});
-export const createInviteTokenAction = authenticatedActionClient
- .schema(ZCreateInviteTokenAction)
- .action(async ({ parsedInput, ctx }) => {
- await checkAuthorizationUpdated({
- userId: ctx.user.id,
- organizationId: await getOrganizationIdFromInviteId(parsedInput.inviteId),
- access: [
- {
- type: "organization",
- roles: ["owner", "manager"],
- },
- ],
- });
+export const createInviteTokenAction = authenticatedActionClient.schema(ZCreateInviteTokenAction).action(
+ withAuditLogging(
+ "updated",
+ "invite",
+ async ({
+ parsedInput,
+ ctx,
+ }: {
+ ctx: AuthenticatedActionClientCtx;
+ parsedInput: z.infer;
+ }) => {
+ const organizationId = await getOrganizationIdFromInviteId(parsedInput.inviteId);
- const invite = await getInvite(parsedInput.inviteId);
- if (!invite) {
- throw new ValidationError("Invite not found");
+ await checkAuthorizationUpdated({
+ userId: ctx.user.id,
+ organizationId,
+ access: [
+ {
+ type: "organization",
+ roles: ["owner", "manager"],
+ },
+ ],
+ });
+
+ // Get old expiresAt for audit logging before update
+ const oldInvite = await prisma.invite.findUnique({
+ where: { id: parsedInput.inviteId },
+ select: { email: true, expiresAt: true },
+ });
+
+ if (!oldInvite) {
+ throw new ValidationError("Invite not found");
+ }
+
+ // Refresh the invitation expiration
+ const updatedInvite = await refreshInviteExpiration(parsedInput.inviteId);
+
+ // Set audit context
+ ctx.auditLoggingCtx.organizationId = organizationId;
+ ctx.auditLoggingCtx.inviteId = parsedInput.inviteId;
+ ctx.auditLoggingCtx.oldObject = { expiresAt: oldInvite.expiresAt };
+ ctx.auditLoggingCtx.newObject = { expiresAt: updatedInvite.expiresAt };
+
+ const inviteToken = createInviteToken(parsedInput.inviteId, updatedInvite.email, {
+ expiresIn: "7d",
+ });
+
+ return { inviteToken: encodeURIComponent(inviteToken) };
}
- const inviteToken = createInviteToken(parsedInput.inviteId, invite.email, {
- expiresIn: "7d",
- });
-
- return { inviteToken: encodeURIComponent(inviteToken) };
- });
+ )
+);
const ZDeleteMembershipAction = z.object({
userId: ZId,
@@ -191,6 +219,7 @@ export const resendInviteAction = authenticatedActionClient.schema(ZResendInvite
invite?.creator?.name ?? "",
updatedInvite.name ?? ""
);
+
return updatedInvite;
}
)
diff --git a/apps/web/modules/organization/settings/teams/components/edit-memberships/edit-memberships.tsx b/apps/web/modules/organization/settings/teams/components/edit-memberships/edit-memberships.tsx
index 3fc9f49c6c..604fd6e798 100644
--- a/apps/web/modules/organization/settings/teams/components/edit-memberships/edit-memberships.tsx
+++ b/apps/web/modules/organization/settings/teams/components/edit-memberships/edit-memberships.tsx
@@ -28,18 +28,16 @@ export const EditMemberships = async ({
return (
-
-
{t("common.full_name")}
-
{t("common.email")}
+
+
{t("common.full_name")}
+
{t("common.email")}
- {isAccessControlAllowed && (
-
{t("common.role")}
- )}
+ {isAccessControlAllowed &&
{t("common.role")}
}
-
{t("common.status")}
+
{t("common.status")}
{!isUserManagementDisabledFromUi && (
-
{t("common.actions")}
+
{t("common.actions")}
)}
diff --git a/apps/web/modules/organization/settings/teams/components/edit-memberships/member-actions.tsx b/apps/web/modules/organization/settings/teams/components/edit-memberships/member-actions.tsx
index 3477b7bf15..9f40b78134 100644
--- a/apps/web/modules/organization/settings/teams/components/edit-memberships/member-actions.tsx
+++ b/apps/web/modules/organization/settings/teams/components/edit-memberships/member-actions.tsx
@@ -33,7 +33,6 @@ export const MemberActions = ({ organization, member, invite, showDeleteButton }
const [isDeleteMemberModalOpen, setDeleteMemberModalOpen] = useState(false);
const [isDeleting, setIsDeleting] = useState(false);
const [showShareInviteModal, setShowShareInviteModal] = useState(false);
-
const [shareInviteToken, setShareInviteToken] = useState("");
const handleDeleteMember = async () => {
@@ -42,14 +41,27 @@ export const MemberActions = ({ organization, member, invite, showDeleteButton }
if (!member && invite) {
// This is an invite
- await deleteInviteAction({ inviteId: invite?.id, organizationId: organization.id });
+ const result = await deleteInviteAction({ inviteId: invite?.id, organizationId: organization.id });
+ if (result?.serverError) {
+ toast.error(getFormattedErrorMessage(result));
+ setIsDeleting(false);
+ return;
+ }
toast.success(t("environments.settings.general.invite_deleted_successfully"));
}
if (member && !invite) {
// This is a member
- await deleteMembershipAction({ userId: member.userId, organizationId: organization.id });
+ const result = await deleteMembershipAction({
+ userId: member.userId,
+ organizationId: organization.id,
+ });
+ if (result?.serverError) {
+ toast.error(getFormattedErrorMessage(result));
+ setIsDeleting(false);
+ return;
+ }
toast.success(t("environments.settings.general.member_deleted_successfully"));
}
@@ -80,6 +92,7 @@ export const MemberActions = ({ organization, member, invite, showDeleteButton }
if (createInviteTokenResponse?.data) {
setShareInviteToken(createInviteTokenResponse.data.inviteToken);
setShowShareInviteModal(true);
+ router.refresh();
} else {
const errorMessage = getFormattedErrorMessage(createInviteTokenResponse);
toast.error(errorMessage);
@@ -99,6 +112,7 @@ export const MemberActions = ({ organization, member, invite, showDeleteButton }
});
if (resendInviteResponse?.data) {
toast.success(t("environments.settings.general.invitation_sent_once_more"));
+ router.refresh();
} else {
const errorMessage = getFormattedErrorMessage(resendInviteResponse);
toast.error(errorMessage);
@@ -109,7 +123,7 @@ export const MemberActions = ({ organization, member, invite, showDeleteButton }
};
return (
-
+
) : (
@@ -96,17 +96,17 @@ export const MembersInfo = ({
{allMembers.map((member) => (
-
+
-
+
{isAccessControlAllowed && allMembers?.length > 0 && (
-
+
)}
-
{getMembershipBadge(member)}
+
{getMembershipBadge(member)}
{!isUserManagementDisabledFromUi && (
-
+
+
+
)}
))}
diff --git a/apps/web/modules/organization/settings/teams/components/edit-memberships/organization-actions.tsx b/apps/web/modules/organization/settings/teams/components/edit-memberships/organization-actions.tsx
index d919af059a..6d1d19cb00 100644
--- a/apps/web/modules/organization/settings/teams/components/edit-memberships/organization-actions.tsx
+++ b/apps/web/modules/organization/settings/teams/components/edit-memberships/organization-actions.tsx
@@ -71,7 +71,12 @@ export const OrganizationActions = ({
const handleLeaveOrganization = async () => {
setLoading(true);
try {
- await leaveOrganizationAction({ organizationId: organization.id });
+ const result = await leaveOrganizationAction({ organizationId: organization.id });
+ if (result?.serverError) {
+ toast.error(getFormattedErrorMessage(result));
+ setLoading(false);
+ return;
+ }
toast.success(t("environments.settings.general.member_deleted_successfully"));
router.refresh();
setLoading(false);
diff --git a/apps/web/modules/organization/settings/teams/lib/invite.test.ts b/apps/web/modules/organization/settings/teams/lib/invite.test.ts
index 1ca6cd7281..6d12b81622 100644
--- a/apps/web/modules/organization/settings/teams/lib/invite.test.ts
+++ b/apps/web/modules/organization/settings/teams/lib/invite.test.ts
@@ -9,7 +9,14 @@ import {
} from "@formbricks/types/errors";
import { getMembershipByUserIdOrganizationId } from "@/lib/membership/service";
import { TInvitee } from "../types/invites";
-import { deleteInvite, getInvite, getInvitesByOrganizationId, inviteUser, resendInvite } from "./invite";
+import {
+ deleteInvite,
+ getInvite,
+ getInvitesByOrganizationId,
+ inviteUser,
+ refreshInviteExpiration,
+ resendInvite,
+} from "./invite";
vi.mock("@formbricks/database", () => ({
prisma: {
@@ -46,32 +53,129 @@ const mockInvite: Invite = {
teamIds: [],
};
-describe("resendInvite", () => {
+describe("refreshInviteExpiration", () => {
beforeEach(() => {
vi.clearAllMocks();
});
- test("returns email and name if invite exists", async () => {
- vi.mocked(prisma.invite.findUnique).mockResolvedValue({ ...mockInvite, creator: {} });
- vi.mocked(prisma.invite.update).mockResolvedValue({ ...mockInvite, organizationId: "org-1" });
- const result = await resendInvite("invite-1");
- expect(result).toEqual({ email: mockInvite.email, name: mockInvite.name });
+
+ test("updates expiresAt to approximately 7 days from now", async () => {
+ const now = Date.now();
+ const expectedExpiresAt = new Date(now + 1000 * 60 * 60 * 24 * 7);
+
+ vi.mocked(prisma.invite.update).mockResolvedValue({
+ ...mockInvite,
+ expiresAt: expectedExpiresAt,
+ });
+
+ const result = await refreshInviteExpiration("invite-1");
+
+ expect(prisma.invite.update).toHaveBeenCalledWith({
+ where: { id: "invite-1" },
+ data: {
+ expiresAt: expect.any(Date),
+ },
+ });
+
+ expect(result.expiresAt.getTime()).toBeGreaterThanOrEqual(now + 1000 * 60 * 60 * 24 * 7 - 1000);
+ expect(result.expiresAt.getTime()).toBeLessThanOrEqual(now + 1000 * 60 * 60 * 24 * 7 + 1000);
});
- test("throws ResourceNotFoundError if invite not found", async () => {
- vi.mocked(prisma.invite.findUnique).mockResolvedValue(null);
- await expect(resendInvite("invite-1")).rejects.toThrow(ResourceNotFoundError);
+
+ test("throws ResourceNotFoundError if invite not found (P2025)", async () => {
+ const prismaError = new Prisma.PrismaClientKnownRequestError("Record not found", {
+ code: "P2025",
+ clientVersion: "1.0.0",
+ });
+ vi.mocked(prisma.invite.update).mockRejectedValue(prismaError);
+ await expect(refreshInviteExpiration("invite-1")).rejects.toThrow(ResourceNotFoundError);
});
- test("throws DatabaseError on prisma error", async () => {
+
+ test("throws DatabaseError on other prisma errors", async () => {
const prismaError = new Prisma.PrismaClientKnownRequestError("db", {
code: "P2002",
clientVersion: "1.0.0",
});
- vi.mocked(prisma.invite.findUnique).mockRejectedValue(prismaError);
+ vi.mocked(prisma.invite.update).mockRejectedValue(prismaError);
+ await expect(refreshInviteExpiration("invite-1")).rejects.toThrow(DatabaseError);
+ });
+
+ test("throws error if non-prisma error", async () => {
+ const error = new Error("db");
+ vi.mocked(prisma.invite.update).mockRejectedValue(error);
+ await expect(refreshInviteExpiration("invite-1")).rejects.toThrow("db");
+ });
+
+ test("returns full invite object with all fields", async () => {
+ const updatedInvite = {
+ ...mockInvite,
+ expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
+ };
+ vi.mocked(prisma.invite.update).mockResolvedValue(updatedInvite);
+
+ const result = await refreshInviteExpiration("invite-1");
+
+ expect(result).toEqual(updatedInvite);
+ expect(result.id).toBe("invite-1");
+ expect(result.email).toBe("test@example.com");
+ expect(result.name).toBe("Test User");
+ });
+});
+
+describe("resendInvite", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ test("returns email and name after updating expiration", async () => {
+ const updatedInvite = {
+ ...mockInvite,
+ expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
+ };
+ vi.mocked(prisma.invite.update).mockResolvedValue(updatedInvite);
+
+ const result = await resendInvite("invite-1");
+
+ expect(result).toEqual({ email: mockInvite.email, name: mockInvite.name });
+ expect(prisma.invite.update).toHaveBeenCalledWith({
+ where: { id: "invite-1" },
+ data: {
+ expiresAt: expect.any(Date),
+ },
+ });
+ });
+
+ test("calls refreshInviteExpiration helper", async () => {
+ const updatedInvite = {
+ ...mockInvite,
+ expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
+ };
+ vi.mocked(prisma.invite.update).mockResolvedValue(updatedInvite);
+
+ await resendInvite("invite-1");
+
+ expect(prisma.invite.update).toHaveBeenCalledTimes(1);
+ });
+
+ test("throws ResourceNotFoundError if invite not found", async () => {
+ const prismaError = new Prisma.PrismaClientKnownRequestError("Record not found", {
+ code: "P2025",
+ clientVersion: "1.0.0",
+ });
+ vi.mocked(prisma.invite.update).mockRejectedValue(prismaError);
+ await expect(resendInvite("invite-1")).rejects.toThrow(ResourceNotFoundError);
+ });
+
+ test("throws DatabaseError on other prisma errors", async () => {
+ const prismaError = new Prisma.PrismaClientKnownRequestError("db", {
+ code: "P2002",
+ clientVersion: "1.0.0",
+ });
+ vi.mocked(prisma.invite.update).mockRejectedValue(prismaError);
await expect(resendInvite("invite-1")).rejects.toThrow(DatabaseError);
});
- test("throws error if prisma error", async () => {
+ test("throws error if non-prisma error", async () => {
const error = new Error("db");
- vi.mocked(prisma.invite.findUnique).mockRejectedValue(error);
+ vi.mocked(prisma.invite.update).mockRejectedValue(error);
await expect(resendInvite("invite-1")).rejects.toThrow("db");
});
});
diff --git a/apps/web/modules/organization/settings/teams/lib/invite.ts b/apps/web/modules/organization/settings/teams/lib/invite.ts
index 0f06e9fa23..546ae7e25d 100644
--- a/apps/web/modules/organization/settings/teams/lib/invite.ts
+++ b/apps/web/modules/organization/settings/teams/lib/invite.ts
@@ -13,44 +13,21 @@ import { getMembershipByUserIdOrganizationId } from "@/lib/membership/service";
import { validateInputs } from "@/lib/utils/validate";
import { type InviteWithCreator, type TInvite, type TInvitee } from "../types/invites";
-export const resendInvite = async (inviteId: string): Promise
> => {
+export const refreshInviteExpiration = async (inviteId: string): Promise => {
try {
- const invite = await prisma.invite.findUnique({
- where: {
- id: inviteId,
- },
- select: {
- email: true,
- name: true,
- creator: true,
- },
- });
-
- if (!invite) {
- throw new ResourceNotFoundError("Invite", inviteId);
- }
-
const updatedInvite = await prisma.invite.update({
- where: {
- id: inviteId,
- },
+ where: { id: inviteId },
data: {
- expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7),
- },
- select: {
- id: true,
- email: true,
- name: true,
- organizationId: true,
+ expiresAt: new Date(Date.now() + 1000 * 60 * 60 * 24 * 7), // 7 days
},
});
- return {
- email: updatedInvite.email,
- name: updatedInvite.name,
- };
+ return updatedInvite;
} catch (error) {
if (error instanceof Prisma.PrismaClientKnownRequestError) {
+ if (error.code === "P2025") {
+ throw new ResourceNotFoundError("Invite", inviteId);
+ }
throw new DatabaseError(error.message);
}
@@ -58,6 +35,16 @@ export const resendInvite = async (inviteId: string): Promise> => {
+ // Refresh expiration and return the updated invite (single query)
+ const updatedInvite = await refreshInviteExpiration(inviteId);
+
+ return {
+ email: updatedInvite.email,
+ name: updatedInvite.name,
+ };
+};
+
export const getInvitesByOrganizationId = reactCache(
async (organizationId: string, page?: number): Promise => {
validateInputs([organizationId, z.string()], [page, z.number().optional()]);
diff --git a/apps/web/modules/projects/settings/(setup)/components/ActionSettingsTab.tsx b/apps/web/modules/projects/settings/(setup)/components/ActionSettingsTab.tsx
index 51e3953da8..fb00d33cdf 100644
--- a/apps/web/modules/projects/settings/(setup)/components/ActionSettingsTab.tsx
+++ b/apps/web/modules/projects/settings/(setup)/components/ActionSettingsTab.tsx
@@ -8,6 +8,7 @@ import { FormProvider, useForm } from "react-hook-form";
import { toast } from "react-hot-toast";
import { useTranslation } from "react-i18next";
import { TActionClass, TActionClassInput } from "@formbricks/types/action-classes";
+import { getFormattedErrorMessage } from "@/lib/utils/helper";
import {
deleteActionClassAction,
updateActionClassAction,
@@ -92,10 +93,14 @@ export const ActionSettingsTab = ({
validatePermissions(isReadOnly, t);
const updatedAction = buildActionObject(data, actionClass.environmentId, t);
- await updateActionClassAction({
+ const result = await updateActionClassAction({
actionClassId: actionClass.id,
updatedAction: updatedAction,
});
+ if (result?.serverError) {
+ toast.error(getFormattedErrorMessage(result));
+ return;
+ }
setOpen(false);
router.refresh();
toast.success(t("environments.actions.action_updated_successfully"));
@@ -109,7 +114,11 @@ export const ActionSettingsTab = ({
const handleDeleteAction = async () => {
try {
setIsDeletingAction(true);
- await deleteActionClassAction({ actionClassId: actionClass.id });
+ const result = await deleteActionClassAction({ actionClassId: actionClass.id });
+ if (result?.serverError) {
+ toast.error(getFormattedErrorMessage(result));
+ return;
+ }
router.refresh();
toast.success(t("environments.actions.action_deleted_successfully"));
setOpen(false);
diff --git a/apps/web/modules/projects/settings/lib/project.test.ts b/apps/web/modules/projects/settings/lib/project.test.ts
index 8ceb946010..334920f2ac 100644
--- a/apps/web/modules/projects/settings/lib/project.test.ts
+++ b/apps/web/modules/projects/settings/lib/project.test.ts
@@ -23,7 +23,7 @@ const baseProject = {
config: { channel: null, industry: null },
placement: "bottomRight",
clickOutsideClose: false,
- darkOverlay: false,
+ overlay: "none",
environments: [
{
id: "cmi2sra0j000004l73fvh7lhe",
diff --git a/apps/web/modules/projects/settings/lib/project.ts b/apps/web/modules/projects/settings/lib/project.ts
index 8515ea034c..2410f5ea50 100644
--- a/apps/web/modules/projects/settings/lib/project.ts
+++ b/apps/web/modules/projects/settings/lib/project.ts
@@ -24,7 +24,7 @@ const selectProject = {
config: true,
placement: true,
clickOutsideClose: true,
- darkOverlay: true,
+ overlay: true,
environments: true,
styling: true,
logo: true,
diff --git a/apps/web/modules/projects/settings/look/components/edit-placement-form.tsx b/apps/web/modules/projects/settings/look/components/edit-placement-form.tsx
index 563d2913c7..c17fd7a560 100644
--- a/apps/web/modules/projects/settings/look/components/edit-placement-form.tsx
+++ b/apps/web/modules/projects/settings/look/components/edit-placement-form.tsx
@@ -15,6 +15,7 @@ import { FormControl, FormField, FormItem, FormLabel, FormProvider } from "@/mod
import { Label } from "@/modules/ui/components/label";
import { getPlacementStyle } from "@/modules/ui/components/preview-survey/lib/utils";
import { RadioGroup, RadioGroupItem } from "@/modules/ui/components/radio-group";
+import { StylingTabs } from "@/modules/ui/components/styling-tabs";
interface EditPlacementProps {
project: Project;
@@ -24,7 +25,7 @@ interface EditPlacementProps {
const ZProjectPlacementInput = z.object({
placement: z.enum(["bottomRight", "topRight", "topLeft", "bottomLeft", "center"]),
- darkOverlay: z.boolean(),
+ overlay: z.enum(["none", "light", "dark"]),
clickOutsideClose: z.boolean(),
});
@@ -40,28 +41,35 @@ export const EditPlacementForm = ({ project, isReadOnly }: EditPlacementProps) =
{ name: t("common.bottom_left"), value: "bottomLeft", disabled: false },
{ name: t("common.centered_modal"), value: "center", disabled: false },
];
+
const form = useForm({
defaultValues: {
placement: project.placement,
- darkOverlay: project.darkOverlay ?? false,
+ overlay: project.overlay ?? "none",
clickOutsideClose: project.clickOutsideClose ?? false,
},
resolver: zodResolver(ZProjectPlacementInput),
});
const currentPlacement = form.watch("placement");
- const darkOverlay = form.watch("darkOverlay");
+ const overlay = form.watch("overlay");
const clickOutsideClose = form.watch("clickOutsideClose");
const isSubmitting = form.formState.isSubmitting;
- const overlayStyle = currentPlacement === "center" && darkOverlay ? "bg-slate-700/80" : "bg-slate-200";
+ const hasOverlay = overlay !== "none";
+
+ const getOverlayStyle = () => {
+ if (overlay === "dark") return "bg-slate-700/80";
+ if (overlay === "light") return "bg-slate-400/50";
+ return "bg-slate-200";
+ };
const onSubmit: SubmitHandler = async (data) => {
const updatedProjectResponse = await updateProjectAction({
projectId: project.id,
data: {
placement: data.placement,
- darkOverlay: data.darkOverlay,
+ overlay: data.overlay,
clickOutsideClose: data.clickOutsideClose,
},
});
@@ -113,9 +121,9 @@ export const EditPlacementForm = ({ project, isReadOnly }: EditPlacementProps) =
/>
- {currentPlacement === "center" && (
- <>
-
-
(
-
-
- {t("environments.workspace.look.centered_modal_overlay_color")}
-
-
- {
- field.onChange(value === "darkOverlay");
- }}
- disabled={isReadOnly}
- className="flex space-x-4">
-
-
-
-
-
-
-
-
-
-
-
- )}
- />
-
-
-
(
-
-
- {t("common.allow_users_to_exit_by_clicking_outside_the_survey")}
-
-
- {
- field.onChange(value === "allow");
- }}
- className="flex space-x-4">
-
-
-
-
-
-
-
-
-
-
-
- )}
- />
-
-
+
+ (
+
+
+ field.onChange(value)}
+ label={t("common.overlay_color")}
+ />
+
+
+ )}
+ />
+
+
+ {hasOverlay && (
+
+
(
+
+
+ {t("common.allow_users_to_exit_by_clicking_outside_the_survey")}
+
+
+ {
+ field.onChange(value === "allow");
+ }}
+ className="flex space-x-4">
+
+
+
+
+
+
+
+
+
+
+
+ )}
+ />
+
)}
-
+
+
+
(
+
+ {t("environments.surveys.edit.brand_color")}
+
+ {t("environments.surveys.edit.brand_color_description")}
+
+
+ field.onChange(color)}
+ containerClass="w-full"
+ />
+
+
+ )}
+ />
+
+
+
+
+
+ {/* Confirm reset styling modal */}
+
setConfirmSuggestColorsOpen(false)}
+ />
+
{/* Confirm reset styling modal */}
{
test("should handle successful file upload with presigned fields", async () => {
const file = createMockFile("test.jpg", "image/jpeg", 1000);
- // Mock successful API response
+ // Mock successful API response - now returns relative path
mockFetch.mockResolvedValueOnce({
ok: true,
json: async () => ({
data: {
signedUrl: "https://s3.example.com/upload",
- fileUrl: "https://s3.example.com/file.jpg",
+ fileUrl: "/storage/test-env/public/file.jpg",
presignedFields: {
key: "value",
},
@@ -98,18 +98,18 @@ describe("fileUpload", () => {
const result = await fileUploadModule.handleFileUpload(file, "test-env");
expect(result.error).toBeUndefined();
- expect(result.url).toBe("https://s3.example.com/file.jpg");
+ expect(result.url).toBe("/storage/test-env/public/file.jpg");
});
test("should handle upload error with presigned fields", async () => {
const file = createMockFile("test.jpg", "image/jpeg", 1000);
- // Mock successful API response
+ // Mock successful API response - now returns relative path
mockFetch.mockResolvedValueOnce({
ok: true,
json: async () => ({
data: {
signedUrl: "https://s3.example.com/upload",
- fileUrl: "https://s3.example.com/file.jpg",
+ fileUrl: "/storage/test-env/public/file.jpg",
presignedFields: {
key: "value",
},
@@ -134,13 +134,13 @@ describe("fileUpload", () => {
test("should handle upload error", async () => {
const file = createMockFile("test.jpg", "image/jpeg", 1000);
- // Mock successful API response
+ // Mock successful API response - now returns relative path
mockFetch.mockResolvedValueOnce({
ok: true,
json: async () => ({
data: {
signedUrl: "https://s3.example.com/upload",
- fileUrl: "https://s3.example.com/file.jpg",
+ fileUrl: "/storage/test-env/public/file.jpg",
presignedFields: {
key: "value",
},
diff --git a/apps/web/modules/storage/service.test.ts b/apps/web/modules/storage/service.test.ts
index 9d77f3d10c..280a6545e5 100644
--- a/apps/web/modules/storage/service.test.ts
+++ b/apps/web/modules/storage/service.test.ts
@@ -5,7 +5,7 @@ import { TAccessType } from "@formbricks/types/storage";
import {
deleteFile,
deleteFilesByEnvironmentId,
- getSignedUrlForDownload,
+ getFileStreamForDownload,
getSignedUrlForUpload,
} from "./service";
@@ -14,14 +14,6 @@ vi.mock("crypto", () => ({
randomUUID: vi.fn(),
}));
-vi.mock("@/lib/constants", () => ({
- WEBAPP_URL: "https://webapp.example.com",
-}));
-
-vi.mock("@/lib/getPublicUrl", () => ({
- getPublicDomain: vi.fn(),
-}));
-
vi.mock("@formbricks/logger", () => ({
logger: {
error: vi.fn(),
@@ -38,22 +30,22 @@ vi.mock("@formbricks/storage", () => ({
},
deleteFile: vi.fn(),
deleteFilesByPrefix: vi.fn(),
+ getFileStream: vi.fn(),
getSignedDownloadUrl: vi.fn(),
getSignedUploadUrl: vi.fn(),
}));
// Import mocked dependencies
const { logger } = await import("@formbricks/logger");
-const { getPublicDomain } = await import("@/lib/getPublicUrl");
+const storageModule = await import("@formbricks/storage");
const {
deleteFile: deleteFileFromS3,
deleteFilesByPrefix,
- getSignedDownloadUrl,
getSignedUploadUrl,
-} = await import("@formbricks/storage");
-
+ getFileStream,
+} = storageModule;
type MockedSignedUploadReturn = Awaited>;
-type MockedSignedDownloadReturn = Awaited>;
+type MockedFileStreamReturn = Awaited>;
type MockedDeleteFileReturn = Awaited>;
type MockedDeleteFilesByPrefixReturn = Awaited>;
@@ -63,7 +55,6 @@ describe("storage service", () => {
beforeEach(() => {
vi.clearAllMocks();
vi.mocked(randomUUID).mockReturnValue(mockUUID);
- vi.mocked(getPublicDomain).mockReturnValue("https://public.example.com");
});
describe("getSignedUrlForUpload", () => {
@@ -90,7 +81,7 @@ describe("storage service", () => {
expect(result.data).toEqual({
signedUrl: "https://s3.example.com/upload",
presignedFields: { key: "value" },
- fileUrl: `https://public.example.com/storage/env-123/public/test-image--fid--${mockUUID}.jpg`,
+ fileUrl: `/storage/env-123/public/test-image--fid--${mockUUID}.jpg`,
});
}
@@ -102,7 +93,7 @@ describe("storage service", () => {
);
});
- test("should use WEBAPP_URL for private files", async () => {
+ test("should return relative URL for private files", async () => {
const mockSignedUrlResponse = {
ok: true,
data: {
@@ -122,9 +113,7 @@ describe("storage service", () => {
expect(result.ok).toBe(true);
if (result.ok) {
- expect(result.data.fileUrl).toBe(
- `https://webapp.example.com/storage/env-123/private/test-doc--fid--${mockUUID}.pdf`
- );
+ expect(result.data.fileUrl).toBe(`/storage/env-123/private/test-doc--fid--${mockUUID}.pdf`);
}
});
@@ -149,9 +138,7 @@ describe("storage service", () => {
expect(result.ok).toBe(true);
if (result.ok) {
// The filename should be URL-encoded to prevent # from being treated as a URL fragment
- expect(result.data.fileUrl).toBe(
- `https://public.example.com/storage/env-123/public/testfile--fid--${mockUUID}.txt`
- );
+ expect(result.data.fileUrl).toBe(`/storage/env-123/public/testfile--fid--${mockUUID}.txt`);
}
expect(getSignedUploadUrl).toHaveBeenCalledWith(
@@ -276,86 +263,6 @@ describe("storage service", () => {
});
});
- describe("getSignedUrlForDownload", () => {
- test("should generate signed URL for download", async () => {
- const mockSignedUrlResponse = {
- ok: true,
- data: "https://s3.example.com/download?signature=abc123",
- } as MockedSignedDownloadReturn;
-
- vi.mocked(getSignedDownloadUrl).mockResolvedValue(mockSignedUrlResponse);
-
- const result = await getSignedUrlForDownload("test-file.jpg", "env-123", "public" as TAccessType);
-
- expect(result.ok).toBe(true);
- if (result.ok) {
- expect(result.data).toBe("https://s3.example.com/download?signature=abc123");
- }
- expect(getSignedDownloadUrl).toHaveBeenCalledWith("env-123/public/test-file.jpg");
- });
-
- test("should decode URI-encoded filename", async () => {
- const mockSignedUrlResponse = {
- ok: true,
- data: "https://s3.example.com/download?signature=abc123",
- } as MockedSignedDownloadReturn;
-
- vi.mocked(getSignedDownloadUrl).mockResolvedValue(mockSignedUrlResponse);
-
- const encodedFileName = encodeURIComponent("file with spaces.jpg");
- await getSignedUrlForDownload(encodedFileName, "env-123", "private" as TAccessType);
-
- expect(getSignedDownloadUrl).toHaveBeenCalledWith("env-123/private/file with spaces.jpg");
- });
-
- test("should return error when getSignedDownloadUrl fails", async () => {
- const mockErrorResponse = {
- ok: false,
- error: {
- code: StorageErrorCode.S3ClientError,
- },
- } as MockedSignedDownloadReturn;
-
- vi.mocked(getSignedDownloadUrl).mockResolvedValue(mockErrorResponse);
-
- const result = await getSignedUrlForDownload("missing-file.jpg", "env-123", "public" as TAccessType);
-
- expect(result.ok).toBe(false);
- if (!result.ok) {
- expect(result.error.code).toBe(StorageErrorCode.S3ClientError);
- }
- });
-
- test("should handle unexpected errors and return unknown error", async () => {
- vi.mocked(getSignedDownloadUrl).mockRejectedValue(new Error("Network error"));
-
- const result = await getSignedUrlForDownload("test-file.jpg", "env-123", "public" as TAccessType);
-
- expect(result.ok).toBe(false);
- if (!result.ok) {
- expect(result.error.code).toBe(StorageErrorCode.Unknown);
- }
- expect(logger.error).toHaveBeenCalledWith(
- { error: expect.any(Error) },
- "Error getting signed url for download"
- );
- });
-
- test("should handle files with special characters", async () => {
- const mockSignedUrlResponse = {
- ok: true,
- data: "https://s3.example.com/download?signature=abc123",
- } as MockedSignedDownloadReturn;
-
- vi.mocked(getSignedDownloadUrl).mockResolvedValue(mockSignedUrlResponse);
-
- const specialFileName = "file%20with%20%26%20symbols.jpg";
- await getSignedUrlForDownload(specialFileName, "env-123", "public" as TAccessType);
-
- expect(getSignedDownloadUrl).toHaveBeenCalledWith("env-123/public/file with & symbols.jpg");
- });
- });
-
describe("deleteFile", () => {
test("should call deleteFileFromS3 with correct file key", async () => {
const mockSuccessResult = {
@@ -433,4 +340,147 @@ describe("storage service", () => {
expect(deleteFilesByPrefix).toHaveBeenCalledWith("env-123");
});
});
+
+ describe("getFileStreamForDownload", () => {
+ test("should return file stream for public file", async () => {
+ const mockStream = new ReadableStream();
+ const mockStreamResult = {
+ ok: true,
+ data: {
+ body: mockStream,
+ contentType: "image/jpeg",
+ contentLength: 12345,
+ },
+ } as MockedFileStreamReturn;
+
+ vi.mocked(getFileStream).mockResolvedValue(mockStreamResult);
+
+ const result = await getFileStreamForDownload("test-image.jpg", "env-123", "public" as TAccessType);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ expect(result.data.body).toBe(mockStream);
+ expect(result.data.contentType).toBe("image/jpeg");
+ expect(result.data.contentLength).toBe(12345);
+ }
+ expect(getFileStream).toHaveBeenCalledWith("env-123/public/test-image.jpg");
+ });
+
+ test("should return file stream for private file", async () => {
+ const mockStream = new ReadableStream();
+ const mockStreamResult = {
+ ok: true,
+ data: {
+ body: mockStream,
+ contentType: "application/pdf",
+ contentLength: 54321,
+ },
+ } as MockedFileStreamReturn;
+
+ vi.mocked(getFileStream).mockResolvedValue(mockStreamResult);
+
+ const result = await getFileStreamForDownload("document.pdf", "env-456", "private" as TAccessType);
+
+ expect(result.ok).toBe(true);
+ if (result.ok) {
+ expect(result.data.contentType).toBe("application/pdf");
+ }
+ expect(getFileStream).toHaveBeenCalledWith("env-456/private/document.pdf");
+ });
+
+ test("should decode URL-encoded filename", async () => {
+ const mockStream = new ReadableStream();
+ const mockStreamResult = {
+ ok: true,
+ data: {
+ body: mockStream,
+ contentType: "image/png",
+ contentLength: 1000,
+ },
+ } as MockedFileStreamReturn;
+
+ vi.mocked(getFileStream).mockResolvedValue(mockStreamResult);
+
+ // URL-encoded filename with spaces: "my file.png" -> "my%20file.png"
+ const result = await getFileStreamForDownload("my%20file.png", "env-123", "public" as TAccessType);
+
+ expect(result.ok).toBe(true);
+ // Should decode %20 to space before passing to getFileStream
+ expect(getFileStream).toHaveBeenCalledWith("env-123/public/my file.png");
+ });
+
+ test("should return error when getFileStream fails with FileNotFoundError", async () => {
+ const mockErrorResult = {
+ ok: false,
+ error: {
+ code: StorageErrorCode.FileNotFoundError,
+ },
+ } as MockedFileStreamReturn;
+
+ vi.mocked(getFileStream).mockResolvedValue(mockErrorResult);
+
+ const result = await getFileStreamForDownload("missing-file.jpg", "env-123", "public" as TAccessType);
+
+ expect(result.ok).toBe(false);
+ if (!result.ok) {
+ expect(result.error.code).toBe(StorageErrorCode.FileNotFoundError);
+ }
+ });
+
+ test("should return error when getFileStream fails with S3ClientError", async () => {
+ const mockErrorResult = {
+ ok: false,
+ error: {
+ code: StorageErrorCode.S3ClientError,
+ },
+ } as MockedFileStreamReturn;
+
+ vi.mocked(getFileStream).mockResolvedValue(mockErrorResult);
+
+ const result = await getFileStreamForDownload("some-file.jpg", "env-123", "public" as TAccessType);
+
+ expect(result.ok).toBe(false);
+ if (!result.ok) {
+ expect(result.error.code).toBe(StorageErrorCode.S3ClientError);
+ }
+ });
+
+ test("should handle unexpected errors and return unknown error", async () => {
+ vi.mocked(getFileStream).mockRejectedValue(new Error("Unexpected S3 error"));
+
+ const result = await getFileStreamForDownload("test-file.jpg", "env-123", "public" as TAccessType);
+
+ expect(result.ok).toBe(false);
+ if (!result.ok) {
+ expect(result.error.code).toBe(StorageErrorCode.Unknown);
+ }
+ expect(logger.error).toHaveBeenCalledWith(
+ { error: expect.any(Error) },
+ "Error getting file stream for download"
+ );
+ });
+
+ test("should handle filename with fid pattern", async () => {
+ const mockStream = new ReadableStream();
+ const mockStreamResult = {
+ ok: true,
+ data: {
+ body: mockStream,
+ contentType: "image/jpeg",
+ contentLength: 5000,
+ },
+ } as MockedFileStreamReturn;
+
+ vi.mocked(getFileStream).mockResolvedValue(mockStreamResult);
+
+ const result = await getFileStreamForDownload(
+ "photo--fid--abc123-def456.jpg",
+ "env-123",
+ "public" as TAccessType
+ );
+
+ expect(result.ok).toBe(true);
+ expect(getFileStream).toHaveBeenCalledWith("env-123/public/photo--fid--abc123-def456.jpg");
+ });
+ });
});
diff --git a/apps/web/modules/storage/service.ts b/apps/web/modules/storage/service.ts
index bcfaf2d311..2a7bd990c3 100644
--- a/apps/web/modules/storage/service.ts
+++ b/apps/web/modules/storage/service.ts
@@ -1,17 +1,16 @@
import { randomUUID } from "crypto";
import { logger } from "@formbricks/logger";
import {
+ type FileStreamResult,
type StorageError,
StorageErrorCode,
deleteFile as deleteFileFromS3,
deleteFilesByPrefix,
- getSignedDownloadUrl,
+ getFileStream,
getSignedUploadUrl,
} from "@formbricks/storage";
import { Result, err, ok } from "@formbricks/types/error-handlers";
import { TAccessType } from "@formbricks/types/storage";
-import { WEBAPP_URL } from "@/lib/constants";
-import { getPublicDomain } from "@/lib/getPublicUrl";
import { sanitizeFileName } from "./utils";
export const getSignedUrlForUpload = async (
@@ -51,15 +50,11 @@ export const getSignedUrlForUpload = async (
return signedUrlResult;
}
- // Use PUBLIC_URL for public files, WEBAPP_URL for private files
- const baseUrl = accessType === "public" ? getPublicDomain() : WEBAPP_URL;
-
+ // Return relative path - can be resolved to absolute URL at runtime when needed
return ok({
signedUrl: signedUrlResult.data.signedUrl,
presignedFields: signedUrlResult.data.presignedFields,
- fileUrl: new URL(
- `${baseUrl}/storage/${environmentId}/${accessType}/${encodeURIComponent(updatedFileName)}`
- ).href,
+ fileUrl: `/storage/${environmentId}/${accessType}/${encodeURIComponent(updatedFileName)}`,
});
} catch (error) {
logger.error({ error }, "Error getting signed url for upload");
@@ -70,24 +65,28 @@ export const getSignedUrlForUpload = async (
}
};
-export const getSignedUrlForDownload = async (
+/**
+ * Get a file stream for downloading/streaming files directly
+ * Use this instead of signed URL redirect for Next.js Image component compatibility
+ */
+export const getFileStreamForDownload = async (
fileName: string,
environmentId: string,
accessType: TAccessType
-): Promise> => {
+): Promise> => {
try {
const fileNameDecoded = decodeURIComponent(fileName);
const fileKey = `${environmentId}/${accessType}/${fileNameDecoded}`;
- const signedUrlResult = await getSignedDownloadUrl(fileKey);
+ const streamResult = await getFileStream(fileKey);
- if (!signedUrlResult.ok) {
- return signedUrlResult;
+ if (!streamResult.ok) {
+ return streamResult;
}
- return signedUrlResult;
+ return streamResult;
} catch (error) {
- logger.error({ error }, "Error getting signed url for download");
+ logger.error({ error }, "Error getting file stream for download");
return err({
code: StorageErrorCode.Unknown,
diff --git a/apps/web/modules/storage/url-helpers.ts b/apps/web/modules/storage/url-helpers.ts
new file mode 100644
index 0000000000..0537bb5aa3
--- /dev/null
+++ b/apps/web/modules/storage/url-helpers.ts
@@ -0,0 +1,30 @@
+/**
+ * Client-safe URL helper utilities for storage files.
+ * These functions can be used in both server and client components.
+ */
+
+/**
+ * Extracts the original file name from a storage URL.
+ * Handles both relative paths (/storage/...) and absolute URLs.
+ * @param fileURL The storage URL to parse
+ * @returns The original file name, or empty string if parsing fails
+ */
+export const getOriginalFileNameFromUrl = (fileURL: string): string => {
+ try {
+ const lastSegment = fileURL.startsWith("/storage/")
+ ? (fileURL.split("/").pop() ?? "")
+ : (new URL(fileURL).pathname.split("/").pop() ?? "");
+ const fileNameFromURL = lastSegment.split(/[?#]/)[0];
+
+ const [namePart, fidPart] = fileNameFromURL.split("--fid--");
+ if (!fidPart) return namePart ? decodeURIComponent(namePart) : "";
+
+ const dotIdx = fileNameFromURL.lastIndexOf(".");
+ const hasExt = dotIdx > fileNameFromURL.indexOf("--fid--");
+ const ext = hasExt ? fileNameFromURL.slice(dotIdx + 1) : "";
+
+ return decodeURIComponent(ext ? `${namePart}.${ext}` : namePart);
+ } catch {
+ return "";
+ }
+};
diff --git a/apps/web/modules/storage/utils.test.ts b/apps/web/modules/storage/utils.test.ts
index e8c96869aa..bbaeb26fc1 100644
--- a/apps/web/modules/storage/utils.test.ts
+++ b/apps/web/modules/storage/utils.test.ts
@@ -7,6 +7,7 @@ import {
isAllowedFileExtension,
isValidFileTypeForExtension,
isValidImageFile,
+ resolveStorageUrl,
sanitizeFileName,
validateFileUploads,
validateSingleFile,
@@ -145,7 +146,8 @@ describe("storage utils", () => {
const { getOriginalFileNameFromUrl } =
await vi.importActual("@/modules/storage/utils");
const path = "/storage/env/public/Document%20Name.pdf";
- expect(getOriginalFileNameFromUrl(path)).toBe("/storage/env/public/Document Name.pdf");
+ // Function extracts filename, not full path
+ expect(getOriginalFileNameFromUrl(path)).toBe("Document Name.pdf");
});
test("returns empty string on invalid URL input", async () => {
@@ -396,4 +398,38 @@ describe("storage utils", () => {
expect(isValidImageFile("https://example.com/image.JPG")).toBe(true);
});
});
+
+ describe("resolveStorageUrl", () => {
+ test("should return empty string for null or undefined input", () => {
+ expect(resolveStorageUrl(null)).toBe("");
+ expect(resolveStorageUrl(undefined)).toBe("");
+ expect(resolveStorageUrl("")).toBe("");
+ });
+
+ test("should return absolute URL unchanged (backward compatibility)", () => {
+ const httpsUrl = "https://example.com/storage/env-123/public/image.jpg";
+ const httpUrl = "http://example.com/storage/env-123/public/image.jpg";
+
+ expect(resolveStorageUrl(httpsUrl)).toBe(httpsUrl);
+ expect(resolveStorageUrl(httpUrl)).toBe(httpUrl);
+ });
+
+ test("should resolve relative /storage/ path to absolute URL", async () => {
+ // Use actual implementation with mocked dependencies
+ const { resolveStorageUrl: actualResolveStorageUrl } =
+ await vi.importActual("@/modules/storage/utils");
+
+ const relativePath = "/storage/env-123/public/image.jpg";
+ const result = actualResolveStorageUrl(relativePath);
+
+ // Should prepend the base URL (from mocked WEBAPP_URL or getPublicDomain)
+ expect(result).toContain("/storage/env-123/public/image.jpg");
+ expect(result.startsWith("http")).toBe(true);
+ });
+
+ test("should return non-storage paths unchanged", () => {
+ expect(resolveStorageUrl("/some/other/path")).toBe("/some/other/path");
+ expect(resolveStorageUrl("relative/path.jpg")).toBe("relative/path.jpg");
+ });
+ });
});
diff --git a/apps/web/modules/storage/utils.ts b/apps/web/modules/storage/utils.ts
index 3fd1611db0..083c0aca69 100644
--- a/apps/web/modules/storage/utils.ts
+++ b/apps/web/modules/storage/utils.ts
@@ -1,30 +1,15 @@
-import { logger } from "@formbricks/logger";
+import "server-only";
import { StorageError, StorageErrorCode } from "@formbricks/storage";
import { TResponseData } from "@formbricks/types/responses";
import { TAllowedFileExtension, ZAllowedFileExtension, mimeTypes } from "@formbricks/types/storage";
import { TSurveyQuestion, TSurveyQuestionTypeEnum } from "@formbricks/types/surveys/types";
import { responses } from "@/app/lib/api/response";
+import { WEBAPP_URL } from "@/lib/constants";
+import { getPublicDomain } from "@/lib/getPublicUrl";
+import { getOriginalFileNameFromUrl } from "./url-helpers";
-export const getOriginalFileNameFromUrl = (fileURL: string) => {
- try {
- const lastSegment = fileURL.startsWith("/storage/")
- ? fileURL
- : (new URL(fileURL).pathname.split("/").pop() ?? "");
- const fileNameFromURL = lastSegment.split(/[?#]/)[0];
-
- const [namePart, fidPart] = fileNameFromURL.split("--fid--");
- if (!fidPart) return namePart ? decodeURIComponent(namePart) : "";
-
- const dotIdx = fileNameFromURL.lastIndexOf(".");
- const hasExt = dotIdx > fileNameFromURL.indexOf("--fid--");
- const ext = hasExt ? fileNameFromURL.slice(dotIdx + 1) : "";
-
- return decodeURIComponent(ext ? `${namePart}.${ext}` : namePart);
- } catch (error) {
- logger.error({ error, fileURL }, "Error parsing file URL");
- return "";
- }
-};
+// Re-export for backward compatibility with server-side code
+export { getOriginalFileNameFromUrl } from "./url-helpers";
/**
* Sanitize a provided file name to a safe subset.
@@ -163,3 +148,31 @@ export const getErrorResponseFromStorageError = (
}
}
};
+
+/**
+ * Resolves a storage URL to an absolute URL.
+ * - If already absolute, returns as-is (backward compatibility for old data)
+ * - If relative (/storage/...), prepends the appropriate base URL
+ * @param url The storage URL (relative or absolute)
+ * @param accessType The access type to determine which base URL to use (defaults to "public")
+ * @returns The resolved absolute URL, or empty string if url is falsy
+ */
+export const resolveStorageUrl = (
+ url: string | undefined | null,
+ accessType: "public" | "private" = "public"
+): string => {
+ if (!url) return "";
+
+ // Already absolute URL - return as-is (backward compatibility for old data)
+ if (url.startsWith("http://") || url.startsWith("https://")) {
+ return url;
+ }
+
+ // Relative path - resolve with base URL
+ if (url.startsWith("/storage/")) {
+ const baseUrl = accessType === "public" ? getPublicDomain() : WEBAPP_URL;
+ return `${baseUrl}${url}`;
+ }
+
+ return url;
+};
diff --git a/apps/web/modules/survey/editor/components/edit-welcome-card.tsx b/apps/web/modules/survey/editor/components/edit-welcome-card.tsx
index 57a0f207c8..bdc4fcaadb 100644
--- a/apps/web/modules/survey/editor/components/edit-welcome-card.tsx
+++ b/apps/web/modules/survey/editor/components/edit-welcome-card.tsx
@@ -67,7 +67,7 @@ export const EditWelcomeCard = ({
@@ -101,7 +101,11 @@ export const EditWelcomeCard = ({
checked={localSurvey?.welcomeCard?.enabled}
onClick={(e) => {
e.stopPropagation();
- updateSurvey({ enabled: !localSurvey.welcomeCard?.enabled });
+ const newEnabledState = !localSurvey.welcomeCard?.enabled;
+ updateSurvey({ enabled: newEnabledState });
+ if (newEnabledState && !open) {
+ setActiveElementId("start");
+ }
}}
/>
diff --git a/apps/web/modules/survey/editor/components/elements-view.tsx b/apps/web/modules/survey/editor/components/elements-view.tsx
index a5a7936a11..add3715ce4 100644
--- a/apps/web/modules/survey/editor/components/elements-view.tsx
+++ b/apps/web/modules/survey/editor/components/elements-view.tsx
@@ -54,7 +54,7 @@ import {
} from "@/modules/survey/editor/lib/utils";
import { getElementsFromBlocks } from "@/modules/survey/lib/client-utils";
import { ConfirmationModal } from "@/modules/ui/components/confirmation-modal";
-import { isEndingCardValid, isWelcomeCardValid, validateSurveyElementsInBatch } from "../lib/validation";
+import { isEndingCardValid, isWelcomeCardValid, validateElement } from "../lib/validation";
interface ElementsViewProps {
localSurvey: TSurvey;
@@ -211,35 +211,6 @@ export const ElementsView = ({
};
};
- useEffect(() => {
- if (!invalidElements) return;
- let updatedInvalidElements: string[] = [...invalidElements];
-
- // Check welcome card
- if (localSurvey.welcomeCard.enabled && !isWelcomeCardValid(localSurvey.welcomeCard, surveyLanguages)) {
- if (!updatedInvalidElements.includes("start")) {
- updatedInvalidElements = [...updatedInvalidElements, "start"];
- }
- } else {
- updatedInvalidElements = updatedInvalidElements.filter((elementId) => elementId !== "start");
- }
-
- // Check thank you card
- localSurvey.endings.forEach((ending) => {
- if (!isEndingCardValid(ending, surveyLanguages)) {
- if (!updatedInvalidElements.includes(ending.id)) {
- updatedInvalidElements = [...updatedInvalidElements, ending.id];
- }
- } else {
- updatedInvalidElements = updatedInvalidElements.filter((elementId) => elementId !== ending.id);
- }
- });
-
- if (JSON.stringify(updatedInvalidElements) !== JSON.stringify(invalidElements)) {
- setInvalidElements(updatedInvalidElements);
- }
- }, [localSurvey.welcomeCard, localSurvey.endings, surveyLanguages, invalidElements, setInvalidElements]);
-
const updateElement = (elementIdx: number, updatedAttributes: any) => {
// Get element ID from current elements array (for validation)
const element = elements[elementIdx];
@@ -250,7 +221,6 @@ export const ElementsView = ({
// Track side effects that need to happen after state update
let newActiveElementId: string | null = null;
- let invalidElementsUpdate: string[] | null = null;
// Use functional update to ensure we work with the latest state
setLocalSurvey((prevSurvey) => {
@@ -296,13 +266,6 @@ export const ElementsView = ({
const initialElementId = elementId;
updatedSurvey = handleElementLogicChange(updatedSurvey, initialElementId, elementLevelAttributes.id);
- // Track side effects to apply after state update
- if (invalidElements?.includes(initialElementId)) {
- invalidElementsUpdate = invalidElements.map((id) =>
- id === initialElementId ? elementLevelAttributes.id : id
- );
- }
-
// Track new active element ID
newActiveElementId = elementLevelAttributes.id;
@@ -344,9 +307,6 @@ export const ElementsView = ({
});
// Apply side effects after state update is queued
- if (invalidElementsUpdate) {
- setInvalidElements(invalidElementsUpdate);
- }
if (newActiveElementId) {
setActiveElementId(newActiveElementId);
}
@@ -764,23 +724,67 @@ export const ElementsView = ({
setLocalSurvey(result.data);
};
- //useEffect to validate survey when changes are made to languages
- useEffect(() => {
- if (!invalidElements) return;
- let updatedInvalidElements: string[] = invalidElements;
- // Validate each element
- elements.forEach((element) => {
- updatedInvalidElements = validateSurveyElementsInBatch(
- element,
- updatedInvalidElements,
- surveyLanguages
- );
- });
+ // Validate survey when changes are made to languages or elements
+ // using set for O(1) lookup
+ useEffect(
+ () => {
+ if (!invalidElements) return;
- if (JSON.stringify(updatedInvalidElements) !== JSON.stringify(invalidElements)) {
- setInvalidElements(updatedInvalidElements);
- }
- }, [elements, surveyLanguages, invalidElements, setInvalidElements]);
+ const currentInvalidSet = new Set(invalidElements);
+ let hasChanges = false;
+
+ // Validate each element
+ elements.forEach((element) => {
+ const isValid = validateElement(element, surveyLanguages);
+ if (isValid) {
+ if (currentInvalidSet.has(element.id)) {
+ currentInvalidSet.delete(element.id);
+ hasChanges = true;
+ }
+ } else if (!currentInvalidSet.has(element.id)) {
+ currentInvalidSet.add(element.id);
+ hasChanges = true;
+ }
+ });
+
+ // Check welcome card
+ if (localSurvey.welcomeCard.enabled && !isWelcomeCardValid(localSurvey.welcomeCard, surveyLanguages)) {
+ if (!currentInvalidSet.has("start")) {
+ currentInvalidSet.add("start");
+ hasChanges = true;
+ }
+ } else if (currentInvalidSet.has("start")) {
+ currentInvalidSet.delete("start");
+ hasChanges = true;
+ }
+
+ // Check thank you card
+ localSurvey.endings.forEach((ending) => {
+ if (!isEndingCardValid(ending, surveyLanguages)) {
+ if (!currentInvalidSet.has(ending.id)) {
+ currentInvalidSet.add(ending.id);
+ hasChanges = true;
+ }
+ } else if (currentInvalidSet.has(ending.id)) {
+ currentInvalidSet.delete(ending.id);
+ hasChanges = true;
+ }
+ });
+
+ if (hasChanges) {
+ setInvalidElements(Array.from(currentInvalidSet));
+ }
+ },
+ // eslint-disable-next-line react-hooks/exhaustive-deps
+ [
+ elements,
+ surveyLanguages,
+ invalidElements,
+ setInvalidElements,
+ localSurvey.welcomeCard,
+ localSurvey.endings,
+ ]
+ );
useEffect(() => {
const elementWithEmptyFallback = checkForEmptyFallBackValue(localSurvey, selectedLanguageCode);
@@ -791,7 +795,7 @@ export const ElementsView = ({
}
}
// eslint-disable-next-line react-hooks/exhaustive-deps
- }, [activeElementId, setActiveElementId]);
+ }, [activeElementId, setActiveElementId, localSurvey, selectedLanguageCode]);
const sensors = useSensors(
useSensor(PointerSensor, {
diff --git a/apps/web/modules/survey/editor/components/end-screen-form.tsx b/apps/web/modules/survey/editor/components/end-screen-form.tsx
index e1c5e612e9..d9cb2daf5c 100644
--- a/apps/web/modules/survey/editor/components/end-screen-form.tsx
+++ b/apps/web/modules/survey/editor/components/end-screen-form.tsx
@@ -69,6 +69,7 @@ export const EndScreenForm = ({
locale={locale}
isStorageConfigured={isStorageConfigured}
autoFocus={!endingCard.headline?.default || endingCard.headline.default.trim() === ""}
+ isExternalUrlsAllowed={isExternalUrlsAllowed}
/>
{endingCard.subheader !== undefined && (
@@ -87,6 +88,7 @@ export const EndScreenForm = ({
locale={locale}
isStorageConfigured={isStorageConfigured}
autoFocus={!endingCard.subheader?.default || endingCard.subheader.default.trim() === ""}
+ isExternalUrlsAllowed={isExternalUrlsAllowed}
/>
{showEndingCardCTA && (
-
+
{/* The highlight container is absolutely positioned behind the input */}
{highlightedJSX}
diff --git a/apps/web/modules/survey/editor/components/form-styling-settings.tsx b/apps/web/modules/survey/editor/components/form-styling-settings.tsx
index 95776067d9..7e4577d101 100644
--- a/apps/web/modules/survey/editor/components/form-styling-settings.tsx
+++ b/apps/web/modules/survey/editor/components/form-styling-settings.tsx
@@ -2,18 +2,20 @@
import { useAutoAnimate } from "@formkit/auto-animate/react";
import * as Collapsible from "@radix-ui/react-collapsible";
-import { CheckIcon, SparklesIcon } from "lucide-react";
-import React from "react";
+import { CheckIcon } from "lucide-react";
+import React, { useState } from "react";
import { UseFormReturn } from "react-hook-form";
import { useTranslation } from "react-i18next";
import { TProjectStyling } from "@formbricks/types/project";
import { TSurveyStyling } from "@formbricks/types/surveys/types";
import { cn } from "@/lib/cn";
-import { COLOR_DEFAULTS } from "@/lib/styling/constants";
-import { mixColor } from "@/lib/utils/colors";
-import { Button } from "@/modules/ui/components/button";
-import { ColorPicker } from "@/modules/ui/components/color-picker";
-import { FormControl, FormDescription, FormField, FormItem, FormLabel } from "@/modules/ui/components/form";
+import {
+ ColorField,
+ DimensionInput,
+ NumberField,
+ StylingSection,
+ TextField,
+} from "@/modules/ui/components/styling-fields";
type FormStylingSettingsProps = {
open: boolean;
@@ -31,45 +33,12 @@ export const FormStylingSettings = ({
form,
}: FormStylingSettingsProps) => {
const { t } = useTranslation();
- const brandColor = form.watch("brandColor.light") || COLOR_DEFAULTS.brandColor;
- const background = form.watch("background");
- const highlightBorderColor = form.watch("highlightBorderColor");
-
- const setQuestionColor = (color: string) => form.setValue("questionColor.light", color);
- const setInputColor = (color: string) => form.setValue("inputColor.light", color);
- const setInputBorderColor = (color: string) => form.setValue("inputBorderColor.light", color);
- const setCardBackgroundColor = (color: string) => form.setValue("cardBackgroundColor.light", color);
- const setCardBorderColor = (color: string) => form.setValue("cardBorderColor.light", color);
-
- const setBackgroundColor = (color: string) => {
- form.setValue("background", {
- bg: color,
- bgType: "color",
- });
- };
- const setHighlightBorderColor = (color: string) => {
- form.setValue("highlightBorderColor", { light: mixColor(color, "#ffffff", 0.25) });
- };
-
- const suggestColors = () => {
- // mix the brand color with different weights of white and set the result as the other colors
- setQuestionColor(mixColor(brandColor, "#000000", 0.35));
- setInputColor(mixColor(brandColor, "#ffffff", 0.92));
- setInputBorderColor(mixColor(brandColor, "#ffffff", 0.6));
-
- setCardBackgroundColor(mixColor(brandColor, "#ffffff", 0.97));
- setCardBorderColor(mixColor(brandColor, "#ffffff", 0.8));
-
- if (!background || background?.bgType === "color") {
- setBackgroundColor(mixColor(brandColor, "#ffffff", 0.855));
- }
-
- if (highlightBorderColor) {
- setHighlightBorderColor(brandColor);
- }
- };
const [parent] = useAutoAnimate();
+ const [headlinesOpen, setHeadlinesOpen] = useState(false);
+ const [inputsOpen, setInputsOpen] = useState(false);
+ const [buttonsOpen, setButtonsOpen] = useState(false);
+ const [optionsOpen, setOptionsOpen] = useState(false);
return (
-
-
-
(
-
-
- {t("environments.surveys.edit.brand_color")}
-
- {t("environments.surveys.edit.change_the_brand_color_of_the_survey")}
-
-
+
+ {/* Headlines & Descriptions */}
+
+
+
+
+
+
+
+
+
+
+
+
+
-
- field.onChange(color)}
- containerClass="max-w-xs"
- />
-
-
- )}
- />
+ {/* Inputs */}
+
+
+
+
+
+
{/* Spacer if needed, or remove for auto flow */}
+
+
+
+
+
+
+
+
-
-
+
+
+
+
+
+
+
+
+
+
- (
-
-
- {t("environments.surveys.edit.question_color")}
-
- {t("environments.surveys.edit.change_the_question_color_of_the_survey")}
-
-
-
-
- field.onChange(color)}
- containerClass="max-w-xs"
- />
-
-
- )}
- />
-
- (
-
-
- {t("environments.surveys.edit.input_color")}
-
- {t("environments.surveys.edit.change_the_background_color_of_the_input_fields")}
-
-
-
-
- field.onChange(color)}
- containerClass="max-w-xs"
- />
-
-
- )}
- />
-
- (
-
-
- {t("environments.surveys.edit.input_border_color")}
-
- {t("environments.surveys.edit.change_the_border_color_of_the_input_fields")}
-
-
-
-
- field.onChange(color)}
- containerClass="max-w-xs"
- />
-
-
- )}
- />
+ {/* Options */}
+
+
+
+
+
+
+
+
+
+
diff --git a/apps/web/modules/survey/editor/components/multiple-choice-element-form.tsx b/apps/web/modules/survey/editor/components/multiple-choice-element-form.tsx
index bd481c3fef..ccb7c389da 100644
--- a/apps/web/modules/survey/editor/components/multiple-choice-element-form.tsx
+++ b/apps/web/modules/survey/editor/components/multiple-choice-element-form.tsx
@@ -10,7 +10,11 @@ import toast from "react-hot-toast";
import { useTranslation } from "react-i18next";
import { getLanguageLabel } from "@formbricks/i18n-utils/src/utils";
import { TI18nString } from "@formbricks/types/i18n";
-import { TSurveyElementTypeEnum, TSurveyMultipleChoiceElement } from "@formbricks/types/surveys/elements";
+import {
+ TMultipleChoiceOptionDisplayType,
+ TSurveyElementTypeEnum,
+ TSurveyMultipleChoiceElement,
+} from "@formbricks/types/surveys/elements";
import { TShuffleOption, TSurvey } from "@formbricks/types/surveys/types";
import { TUserLocale } from "@formbricks/types/user";
import { createI18nString, extractLanguageCodes } from "@/lib/i18n/utils";
@@ -21,6 +25,7 @@ import { ValidationRulesEditor } from "@/modules/survey/editor/components/valida
import { findOptionUsedInLogic } from "@/modules/survey/editor/lib/utils";
import { Button } from "@/modules/ui/components/button";
import { Label } from "@/modules/ui/components/label";
+import { OptionsSwitch } from "@/modules/ui/components/options-switch";
import { ShuffleOptionSelect } from "@/modules/ui/components/shuffle-option-select";
interface MultipleChoiceElementFormProps {
@@ -75,6 +80,11 @@ export const MultipleChoiceElementForm = ({
},
};
+ const multipleChoiceOptionDisplayTypeOptions = [
+ { value: "list", label: t("environments.surveys.edit.list") },
+ { value: "dropdown", label: t("environments.surveys.edit.dropdown") },
+ ];
+
const updateChoice = (choiceIdx: number, updatedAttributes: { label: TI18nString }) => {
let newChoices: any[] = [];
if (element.choices) {
@@ -382,6 +392,20 @@ export const MultipleChoiceElementForm = ({
+
+
+
+
+
+ updateElement(elementIdx, { displayType: value })
+ }
+ />
+
+
+
setIsBulkEditOpen(false)}
diff --git a/apps/web/modules/survey/editor/components/picture-selection-form.tsx b/apps/web/modules/survey/editor/components/picture-selection-form.tsx
index dbd5329e46..47dbe5160f 100644
--- a/apps/web/modules/survey/editor/components/picture-selection-form.tsx
+++ b/apps/web/modules/survey/editor/components/picture-selection-form.tsx
@@ -27,6 +27,7 @@ interface PictureSelectionFormProps {
isInvalid: boolean;
locale: TUserLocale;
isStorageConfigured: boolean;
+ isExternalUrlsAllowed?: boolean;
}
export const PictureSelectionForm = ({
@@ -39,6 +40,7 @@ export const PictureSelectionForm = ({
isInvalid,
locale,
isStorageConfigured = true,
+ isExternalUrlsAllowed,
}: PictureSelectionFormProps): JSX.Element => {
const environmentId = localSurvey.environmentId;
const surveyLanguageCodes = extractLanguageCodes(localSurvey.languages);
@@ -88,6 +90,7 @@ export const PictureSelectionForm = ({
setSelectedLanguageCode={setSelectedLanguageCode}
locale={locale}
isStorageConfigured={isStorageConfigured}
+ isExternalUrlsAllowed={isExternalUrlsAllowed}
autoFocus={!element.headline?.default || element.headline.default.trim() === ""}
/>
@@ -106,6 +109,7 @@ export const PictureSelectionForm = ({
setSelectedLanguageCode={setSelectedLanguageCode}
locale={locale}
isStorageConfigured={isStorageConfigured}
+ isExternalUrlsAllowed={isExternalUrlsAllowed}
autoFocus={!element.subheader?.default || element.subheader.default.trim() === ""}
/>
diff --git a/apps/web/modules/survey/editor/components/placement.tsx b/apps/web/modules/survey/editor/components/placement.tsx
index 06d8a9e051..be64db2c12 100644
--- a/apps/web/modules/survey/editor/components/placement.tsx
+++ b/apps/web/modules/survey/editor/components/placement.tsx
@@ -1,17 +1,18 @@
"use client";
import { useTranslation } from "react-i18next";
-import { TPlacement } from "@formbricks/types/common";
+import { TOverlay, TPlacement } from "@formbricks/types/common";
import { cn } from "@/lib/cn";
import { Label } from "@/modules/ui/components/label";
import { getPlacementStyle } from "@/modules/ui/components/preview-survey/lib/utils";
import { RadioGroup, RadioGroupItem } from "@/modules/ui/components/radio-group";
+import { StylingTabs } from "@/modules/ui/components/styling-tabs";
interface TPlacementProps {
currentPlacement: TPlacement;
setCurrentPlacement: (placement: TPlacement) => void;
- setOverlay: (overlay: string) => void;
- overlay: string;
+ setOverlay: (overlay: TOverlay) => void;
+ overlay: TOverlay;
setClickOutsideClose: (clickOutside: boolean) => void;
clickOutsideClose: boolean;
}
@@ -32,8 +33,15 @@ export const Placement = ({
{ name: t("common.bottom_left"), value: "bottomLeft", disabled: false },
{ name: t("common.centered_modal"), value: "center", disabled: false },
];
- const overlayStyle =
- currentPlacement === "center" && overlay === "dark" ? "bg-slate-700/80" : "bg-slate-200";
+
+ const hasOverlay = overlay !== "none";
+
+ const getOverlayStyle = () => {
+ if (overlay === "dark") return "bg-slate-700/80";
+ if (overlay === "light") return "bg-slate-400/50";
+ return "bg-slate-200";
+ };
+
return (
<>
@@ -50,9 +58,9 @@ export const Placement = ({
-
-
setOverlay(overlay)}
- value={overlay}
- className="flex space-x-4">
-
-
-
-
-
-
-
-
-
-
-
-
setClickOutsideClose(value === "allow")}
- value={clickOutsideClose ? "allow" : "disallow"}
- className="flex space-x-4">
-
-
-
-
-
-
-
-
-
-
+ setOverlay(value)}
+ label={t("common.overlay_color")}
+ activeTabClassName="bg-slate-200"
+ inactiveTabClassName="bg-transparent"
+ />
+
+
+ {hasOverlay && (
+
+
+
setClickOutsideClose(value === "allow")}
+ value={clickOutsideClose ? "allow" : "disallow"}
+ className="flex space-x-4">
+
+
+
+
+
+
+
+
+
+
)}
+ {overwriteThemeStyling && (
+
+ (
+
+ {t("environments.surveys.edit.brand_color")}
+
+ {t("environments.surveys.edit.brand_color_description")}
+
+
+ field.onChange(color)}
+ containerClass="w-full"
+ />
+
+
+ )}
+ />
+
+
+ )}
+
setConfirmResetStylingModalOpen(false)}
onConfirm={onResetThemeStyling}
/>
+
+ setConfirmSuggestColorsOpen(false)}
+ />
diff --git a/apps/web/modules/survey/editor/components/survey-editor.tsx b/apps/web/modules/survey/editor/components/survey-editor.tsx
index 249b4e74ce..b168a6106e 100644
--- a/apps/web/modules/survey/editor/components/survey-editor.tsx
+++ b/apps/web/modules/survey/editor/components/survey-editor.tsx
@@ -86,6 +86,7 @@ export const SurveyEditor = ({
const [activeElementId, setActiveElementId] = useState
(null);
const [localSurvey, setLocalSurvey] = useState(() => structuredClone(survey));
const [invalidElements, setInvalidElements] = useState(null);
+
const [selectedLanguageCode, setSelectedLanguageCode] = useState("default");
const surveyEditorRef = useRef(null);
const [localProject, setLocalProject] = useState(project);
diff --git a/apps/web/modules/survey/editor/components/survey-placement-card.tsx b/apps/web/modules/survey/editor/components/survey-placement-card.tsx
index 45c9262f47..8e83e76162 100644
--- a/apps/web/modules/survey/editor/components/survey-placement-card.tsx
+++ b/apps/web/modules/survey/editor/components/survey-placement-card.tsx
@@ -6,7 +6,7 @@ import { CheckIcon } from "lucide-react";
import Link from "next/link";
import { useState } from "react";
import { useTranslation } from "react-i18next";
-import { TPlacement } from "@formbricks/types/common";
+import { TOverlay, TPlacement } from "@formbricks/types/common";
import { TSurvey, TSurveyProjectOverwrites } from "@formbricks/types/surveys/types";
import { Placement } from "@/modules/survey/editor/components/placement";
import { Label } from "@/modules/ui/components/label";
@@ -27,7 +27,7 @@ export const SurveyPlacementCard = ({
const [open, setOpen] = useState(false);
const { projectOverwrites } = localSurvey ?? {};
- const { placement, clickOutsideClose, darkOverlay } = projectOverwrites ?? {};
+ const { placement, clickOutsideClose, overlay } = projectOverwrites ?? {};
const setProjectOverwrites = (projectOverwrites: TSurveyProjectOverwrites | null) => {
setLocalSurvey({ ...localSurvey, projectOverwrites: projectOverwrites });
@@ -41,7 +41,7 @@ export const SurveyPlacementCard = ({
setProjectOverwrites({
placement: "bottomRight",
clickOutsideClose: false,
- darkOverlay: false,
+ overlay: "none",
});
}
}
@@ -56,13 +56,11 @@ export const SurveyPlacementCard = ({
}
};
- const handleOverlay = (overlayType: string) => {
- const darkOverlay = overlayType === "dark";
-
+ const handleOverlay = (overlayValue: TOverlay) => {
if (setProjectOverwrites) {
setProjectOverwrites({
...projectOverwrites,
- darkOverlay,
+ overlay: overlayValue,
});
}
};
@@ -91,7 +89,7 @@ export const SurveyPlacementCard = ({
asChild
className="h-full w-full cursor-pointer rounded-lg hover:bg-slate-50">
-
+
diff --git a/apps/web/modules/survey/follow-ups/components/follow-up-modal.tsx b/apps/web/modules/survey/follow-ups/components/follow-up-modal.tsx
index bc4e4d1ab3..0f44aff04b 100644
--- a/apps/web/modules/survey/follow-ups/components/follow-up-modal.tsx
+++ b/apps/web/modules/survey/follow-ups/components/follow-up-modal.tsx
@@ -188,6 +188,8 @@ export const FollowUpModal = ({
subject: defaultValues?.subject ?? t("environments.surveys.edit.follow_ups_modal_action_subject"),
body: defaultValues?.body ?? getSurveyFollowUpActionDefaultBody(t),
attachResponseData: defaultValues?.attachResponseData ?? false,
+ includeVariables: defaultValues?.includeVariables ?? false,
+ includeHiddenFields: defaultValues?.includeHiddenFields ?? false,
},
resolver: zodResolver(ZCreateSurveyFollowUpFormSchema),
mode: "onChange",
diff --git a/apps/web/modules/survey/follow-ups/lib/email.ts b/apps/web/modules/survey/follow-ups/lib/email.ts
index 317d0f0b29..45532ab4b7 100644
--- a/apps/web/modules/survey/follow-ups/lib/email.ts
+++ b/apps/web/modules/survey/follow-ups/lib/email.ts
@@ -7,12 +7,14 @@ import {
renderFollowUpEmail,
} from "@formbricks/email";
import { TResponse } from "@formbricks/types/responses";
+import { TSurveyElementTypeEnum } from "@formbricks/types/surveys/elements";
import { TSurvey } from "@formbricks/types/surveys/types";
import { IMPRINT_ADDRESS, IMPRINT_URL, PRIVACY_URL, TERMS_URL } from "@/lib/constants";
import { getElementResponseMapping } from "@/lib/responses";
import { parseRecallInfo } from "@/lib/utils/recall";
import { getTranslate } from "@/lingodotdev/server";
import { sendEmail } from "@/modules/email";
+import { resolveStorageUrl } from "@/modules/storage/utils";
export const sendFollowUpEmail = async ({
followUp,
@@ -57,12 +59,27 @@ export const sendFollowUpEmail = async ({
});
// Process response data
+ // Resolve relative storage URLs to absolute URLs for email rendering
const responseData: ProcessedResponseElement[] = attachResponseData
- ? getElementResponseMapping(survey, response).map((e) => ({
- element: e.element,
- response: e.response,
- type: e.type,
- }))
+ ? getElementResponseMapping(survey, response).map((e) => {
+ // Resolve URLs for picture selection and file upload responses
+ if (
+ (e.type === TSurveyElementTypeEnum.PictureSelection ||
+ e.type === TSurveyElementTypeEnum.FileUpload) &&
+ Array.isArray(e.response)
+ ) {
+ return {
+ element: e.element,
+ response: e.response.map((url) => resolveStorageUrl(url)),
+ type: e.type,
+ };
+ }
+ return {
+ element: e.element,
+ response: e.response,
+ type: e.type,
+ };
+ })
: [];
// Process variables
diff --git a/apps/web/modules/survey/lib/project.test.ts b/apps/web/modules/survey/lib/project.test.ts
index db0cce75b1..7b7980c53e 100644
--- a/apps/web/modules/survey/lib/project.test.ts
+++ b/apps/web/modules/survey/lib/project.test.ts
@@ -47,7 +47,7 @@ const mockProjectPrisma = {
linkSurveyBranding: false,
placement: "bottomRight",
clickOutsideClose: false,
- darkOverlay: false,
+ overlay: "none",
segment: null,
surveyClosedMessage: null,
singleUseId: null,
diff --git a/apps/web/modules/survey/link/lib/utils.ts b/apps/web/modules/survey/link/lib/utils.ts
index 3b2f64af75..7735df451d 100644
--- a/apps/web/modules/survey/link/lib/utils.ts
+++ b/apps/web/modules/survey/link/lib/utils.ts
@@ -68,6 +68,7 @@ export const getWebAppLocale = (languageCode: string, survey: TSurvey): string =
"pt-BR": "pt-BR",
"pt-PT": "pt-PT",
fr: "fr-FR",
+ hu: "hu-HU",
nl: "nl-NL",
zh: "zh-Hans-CN", // Default to Simplified Chinese
"zh-Hans": "zh-Hans-CN",
diff --git a/apps/web/modules/survey/list/components/survey-dropdown-menu.tsx b/apps/web/modules/survey/list/components/survey-dropdown-menu.tsx
index 0502306bfd..614546e380 100644
--- a/apps/web/modules/survey/list/components/survey-dropdown-menu.tsx
+++ b/apps/web/modules/survey/list/components/survey-dropdown-menu.tsx
@@ -69,7 +69,11 @@ export const SurveyDropDownMenu = ({
const handleDeleteSurvey = async (surveyId: string) => {
setLoading(true);
try {
- await deleteSurveyAction({ surveyId });
+ const result = await deleteSurveyAction({ surveyId });
+ if (result?.serverError) {
+ toast.error(getFormattedErrorMessage(result));
+ return;
+ }
deleteSurvey(surveyId);
toast.success(t("environments.surveys.survey_deleted_successfully"));
} catch (error) {
diff --git a/apps/web/modules/ui/components/card-arrangement-tabs/index.tsx b/apps/web/modules/ui/components/card-arrangement-tabs/index.tsx
index ec10a9e1b4..c2f7908324 100644
--- a/apps/web/modules/ui/components/card-arrangement-tabs/index.tsx
+++ b/apps/web/modules/ui/components/card-arrangement-tabs/index.tsx
@@ -47,9 +47,9 @@ export const CardArrangementTabs = ({
}}
options={[
{
- value: "casual",
- label: t("environments.surveys.edit.casual"),
- icon: getCardArrangementIcon("casual"),
+ value: "simple",
+ label: t("environments.surveys.edit.simple"),
+ icon: getCardArrangementIcon("simple"),
},
{
value: "straight",
@@ -57,9 +57,9 @@ export const CardArrangementTabs = ({
icon: getCardArrangementIcon("straight"),
},
{
- value: "simple",
- label: t("environments.surveys.edit.simple"),
- icon: getCardArrangementIcon("simple"),
+ value: "casual",
+ label: t("environments.surveys.edit.casual"),
+ icon: getCardArrangementIcon("casual"),
},
]}
defaultSelected={activeCardArrangement}
diff --git a/apps/web/modules/ui/components/card-styling-settings/index.tsx b/apps/web/modules/ui/components/card-styling-settings/index.tsx
index 9951c06e6e..6a87b19e88 100644
--- a/apps/web/modules/ui/components/card-styling-settings/index.tsx
+++ b/apps/web/modules/ui/components/card-styling-settings/index.tsx
@@ -9,11 +9,11 @@ import { useTranslation } from "react-i18next";
import { TProjectStyling } from "@formbricks/types/project";
import { TSurveyStyling, TSurveyType } from "@formbricks/types/surveys/types";
import { cn } from "@/lib/cn";
-import { COLOR_DEFAULTS } from "@/lib/styling/constants";
+import { STYLE_DEFAULTS } from "@/lib/styling/constants";
import { CardArrangementTabs } from "@/modules/ui/components/card-arrangement-tabs";
import { ColorPicker } from "@/modules/ui/components/color-picker";
import { FormControl, FormDescription, FormField, FormItem, FormLabel } from "@/modules/ui/components/form";
-import { Slider } from "@/modules/ui/components/slider";
+import { ColorField, DimensionInput } from "@/modules/ui/components/styling-fields";
import { Switch } from "@/modules/ui/components/switch";
type CardStylingSettingsProps = {
@@ -39,9 +39,10 @@ export const CardStylingSettings = ({
const linkCardArrangement = form.watch("cardArrangement.linkSurveys") ?? "straight";
const appCardArrangement = form.watch("cardArrangement.appSurveys") ?? "straight";
- const roundness = form.watch("roundness") ?? 8;
+ const hideProgressBar = form.watch("hideProgressBar");
const [parent] = useAutoAnimate();
+
return (
-
-
-
(
-
-
- {t("environments.surveys.edit.roundness")}
-
- {t("environments.surveys.edit.change_the_border_radius_of_the_card_and_the_inputs")}
-
-
-
-
-
- {
- form.setValue("roundness", value[0]);
- }}
- />
-
-
-
- )}
- />
-
+
+ {/* Roundness */}
+
(
-
-
- {t("environments.surveys.edit.card_background_color")}
-
- {t("environments.surveys.edit.change_the_background_color_of_the_card")}
-
-
+
+ {t("environments.surveys.edit.card_background_color")}
+
+ {t("environments.surveys.edit.card_background_color_description")}
+
field.onChange(color)}
containerClass="max-w-xs"
/>
@@ -138,17 +116,15 @@ export const CardStylingSettings = ({
control={form.control}
name="cardBorderColor.light"
render={({ field }) => (
-
-
- {t("environments.surveys.edit.card_border_color")}
-
- {t("environments.surveys.edit.change_the_border_color_of_the_card")}
-
-
+
+ {t("environments.surveys.edit.card_border_color")}
+
+ {t("environments.surveys.edit.card_border_color_description")}
+
field.onChange(color)}
containerClass="max-w-xs"
/>
@@ -157,66 +133,6 @@ export const CardStylingSettings = ({
)}
/>
- (
-
-
-
- {t("environments.surveys.edit.card_arrangement_for_survey_type_derived", {
- surveyTypeDerived: surveyTypeDerived,
- })}
-
-
- {t(
- "environments.surveys.edit.how_funky_do_you_want_your_cards_in_survey_type_derived_surveys",
- {
- surveyTypeDerived: surveyTypeDerived,
- }
- )}
-
-
-
- {
- type === "app"
- ? form.setValue("cardArrangement.appSurveys", value)
- : form.setValue("cardArrangement.linkSurveys", value);
- }}
- />
-
-
- )}
- />
-
-
(
-
-
- field.onChange(checked)}
- />
-
-
-
- {t("environments.surveys.edit.hide_progress_bar")}
-
- {t("environments.surveys.edit.disable_the_visibility_of_survey_progress")}
-
-
-
- )}
- />
-
@@ -237,7 +153,7 @@ export const CardStylingSettings = ({
}
field.onChange({
- light: COLOR_DEFAULTS.highlightBorderColor,
+ light: STYLE_DEFAULTS.highlightBorderColor?.light,
});
}}
/>
@@ -245,16 +161,13 @@ export const CardStylingSettings = ({
{t("environments.surveys.edit.add_highlight_border")}
-
- {t("environments.surveys.edit.add_highlight_border_description")}
-
{!!field.value && (
field.onChange({
...field.value,
@@ -271,6 +184,93 @@ export const CardStylingSettings = ({
)}
+
+
(
+
+
+
+ {t("environments.surveys.edit.card_arrangement_for_survey_type_derived", {
+ surveyTypeDerived: surveyTypeDerived,
+ })}
+
+
+
+ {
+ type === "app"
+ ? form.setValue("cardArrangement.appSurveys", value)
+ : form.setValue("cardArrangement.linkSurveys", value);
+ }}
+ />
+
+
+ )}
+ />
+
+
+
+
+
(
+
+
+ field.onChange(checked)}
+ />
+
+
+
+
+ {t("environments.surveys.edit.hide_progress_bar")}
+
+
+ {t("environments.surveys.edit.disable_the_visibility_of_survey_progress")}
+
+
+
+ )}
+ />
+
+ {!hideProgressBar && (
+
+
+
+
+
+ )}
+
diff --git a/apps/web/modules/ui/components/color-picker/index.tsx b/apps/web/modules/ui/components/color-picker/index.tsx
index e0d0a88993..6d00ac001a 100644
--- a/apps/web/modules/ui/components/color-picker/index.tsx
+++ b/apps/web/modules/ui/components/color-picker/index.tsx
@@ -12,12 +12,12 @@ interface ColorPickerProps {
}
export const ColorPicker = ({ color, onChange, containerClass, disabled = false }: ColorPickerProps) => {
return (
-
-
+
+
#
({
"border-r": showColumnDividers && !header.column.getIsLastColumn(),
"border-l": showColumnDividers && !header.column.getIsFirstColumn(),
})}>
-
-
- {header.isPlaceholder ? null : flexRender(header.column.columnDef.header, header.getContext())}
-
-
+
{header.column.id !== "select" && header.column.id !== "createdAt" && (
-
-
-
-
+
+
)}
+
+ {header.isPlaceholder ? null : flexRender(header.column.columnDef.header, header.getContext())}
+
+
{/* Resize handle */}
diff --git a/apps/web/modules/ui/components/data-table/components/data-table-toolbar.tsx b/apps/web/modules/ui/components/data-table/components/data-table-toolbar.tsx
index 2e114d7f68..2ff3226758 100644
--- a/apps/web/modules/ui/components/data-table/components/data-table-toolbar.tsx
+++ b/apps/web/modules/ui/components/data-table/components/data-table-toolbar.tsx
@@ -38,7 +38,7 @@ export const DataTableToolbar =
({
const { t } = useTranslation();
return (
-
+
{table.getFilteredSelectedRowModel().rows.length > 0 ? (
> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/angry-bird-rage-icon.tsx b/apps/web/modules/ui/components/icons/angry-bird-rage-icon.tsx
deleted file mode 100644
index d61ff6597c..0000000000
--- a/apps/web/modules/ui/components/icons/angry-bird-rage-icon.tsx
+++ /dev/null
@@ -1,142 +0,0 @@
-export const AngryBirdRageIcon: React.FC> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/app-pie-chart-icon.tsx b/apps/web/modules/ui/components/icons/app-pie-chart-icon.tsx
deleted file mode 100644
index 578f9ce371..0000000000
--- a/apps/web/modules/ui/components/icons/app-pie-chart-icon.tsx
+++ /dev/null
@@ -1,114 +0,0 @@
-export const AppPieChartIcon: React.FC> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/archive-icon.tsx b/apps/web/modules/ui/components/icons/archive-icon.tsx
deleted file mode 100644
index a24ac79d36..0000000000
--- a/apps/web/modules/ui/components/icons/archive-icon.tsx
+++ /dev/null
@@ -1,53 +0,0 @@
-export const ArchiveIcon: React.FC> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/arrow-right-circle-icon.tsx b/apps/web/modules/ui/components/icons/arrow-right-circle-icon.tsx
deleted file mode 100644
index 2d359b93aa..0000000000
--- a/apps/web/modules/ui/components/icons/arrow-right-circle-icon.tsx
+++ /dev/null
@@ -1,32 +0,0 @@
-export const ArrowRightCircleIcon: React.FC> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/arrow-up-right-icon.tsx b/apps/web/modules/ui/components/icons/arrow-up-right-icon.tsx
deleted file mode 100644
index b81d6b9683..0000000000
--- a/apps/web/modules/ui/components/icons/arrow-up-right-icon.tsx
+++ /dev/null
@@ -1,22 +0,0 @@
-export const ArrowUpRightIcon: React.FC> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/back-icon.tsx b/apps/web/modules/ui/components/icons/back-icon.tsx
deleted file mode 100644
index debc8526fe..0000000000
--- a/apps/web/modules/ui/components/icons/back-icon.tsx
+++ /dev/null
@@ -1,24 +0,0 @@
-export const BackIcon: React.FC> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/baseball-icon.tsx b/apps/web/modules/ui/components/icons/baseball-icon.tsx
deleted file mode 100644
index 5d0e728ab2..0000000000
--- a/apps/web/modules/ui/components/icons/baseball-icon.tsx
+++ /dev/null
@@ -1,50 +0,0 @@
-export const BaseballIcon: React.FC> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/bell-icon.tsx b/apps/web/modules/ui/components/icons/bell-icon.tsx
deleted file mode 100644
index 6c02d8e034..0000000000
--- a/apps/web/modules/ui/components/icons/bell-icon.tsx
+++ /dev/null
@@ -1,26 +0,0 @@
-export const BellIcon: React.FC> = (props) => {
- return (
-
- );
-};
diff --git a/apps/web/modules/ui/components/icons/brain-icon.tsx b/apps/web/modules/ui/components/icons/brain-icon.tsx
deleted file mode 100644
index ff7baec91f..0000000000
--- a/apps/web/modules/ui/components/icons/brain-icon.tsx
+++ /dev/null
@@ -1,89 +0,0 @@
-export const BrainIcon: React.FC> = (props) => {
- return (
-