FeatureFlag rename to singular and add multiple flags function

matt-aitken · matt-aitken · commit bc768cc16ec7 · 2026-01-29T14:33:23.000Z
diff --git a/apps/webapp/app/presenters/v3/RegionsPresenter.server.ts b/apps/webapp/app/presenters/v3/RegionsPresenter.server.ts
@@ -1,6 +1,6 @@
 import { type Project } from "~/models/project.server";
 import { type User } from "~/models/user.server";
-import { FEATURE_FLAG, makeFlags } from "~/v3/featureFlags.server";
+import { FEATURE_FLAG, makeFlag } from "~/v3/featureFlags.server";
 import { BasePresenter } from "./basePresenter.server";
 import { getCurrentPlan } from "~/services/platform.v3.server";
 
@@ -48,7 +48,7 @@ export class RegionsPresenter extends BasePresenter {
       throw new Error("Project not found");
     }
 
-    const getFlag = makeFlags(this._replica);
+    const getFlag = makeFlag(this._replica);
     const defaultWorkerInstanceGroupId = await getFlag({
       key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
     });
diff --git a/apps/webapp/app/services/runsRepository/runsRepository.server.ts b/apps/webapp/app/services/runsRepository/runsRepository.server.ts
@@ -8,7 +8,7 @@ import parseDuration from "parse-duration";
 import { z } from "zod";
 import { timeFilters } from "~/components/runs/v3/SharedFilters";
 import { type PrismaClient, type PrismaClientOrTransaction } from "~/db.server";
-import { FEATURE_FLAG, makeFlags } from "~/v3/featureFlags.server";
+import { FEATURE_FLAG, makeFlag } from "~/v3/featureFlags.server";
 import { startActiveSpan } from "~/v3/tracer.server";
 import { logger } from "../logger.server";
 import { ClickHouseRunsRepository } from "./clickhouseRunsRepository.server";
@@ -163,7 +163,7 @@ export class RunsRepository implements IRunsRepository {
 
   async #getRepository(): Promise<IRunsRepository> {
     return startActiveSpan("runsRepository.getRepository", async (span) => {
-      const getFlag = makeFlags(this.options.prisma);
+      const getFlag = makeFlag(this.options.prisma);
       const runsListRepository = await getFlag({
         key: FEATURE_FLAG.runsListRepository,
         defaultValue: this.defaultRepository,
diff --git a/apps/webapp/app/v3/eventRepository/index.server.ts b/apps/webapp/app/v3/eventRepository/index.server.ts
@@ -5,9 +5,9 @@ import {
   clickhouseEventRepositoryV2,
 } from "./clickhouseEventRepositoryInstance.server";
 import { IEventRepository, TraceEventOptions } from "./eventRepository.types";
-import {  prisma } from "~/db.server";
+import { prisma } from "~/db.server";
 import { logger } from "~/services/logger.server";
-import { FEATURE_FLAG, flags } from "../featureFlags.server";
+import { FEATURE_FLAG, flag } from "../featureFlags.server";
 import { getTaskEventStore } from "../taskEventStore.server";
 
 export function resolveEventRepositoryForStore(store: string | undefined): IEventRepository {
@@ -24,13 +24,13 @@ export function resolveEventRepositoryForStore(store: string | undefined): IEven
   return eventRepository;
 }
 
- export const EVENT_STORE_TYPES = {
-        POSTGRES: "postgres",
-        CLICKHOUSE: "clickhouse",
-        CLICKHOUSE_V2: "clickhouse_v2",
-      } as const;
+export const EVENT_STORE_TYPES = {
+  POSTGRES: "postgres",
+  CLICKHOUSE: "clickhouse",
+  CLICKHOUSE_V2: "clickhouse_v2",
+} as const;
 
-export type EventStoreType = typeof EVENT_STORE_TYPES[keyof typeof EVENT_STORE_TYPES];
+export type EventStoreType = (typeof EVENT_STORE_TYPES)[keyof typeof EVENT_STORE_TYPES];
 
 export async function getConfiguredEventRepository(
   organizationId: string
@@ -122,7 +122,7 @@ export async function getV3EventRepository(
 async function resolveTaskEventRepositoryFlag(
   featureFlags: Record<string, unknown> | undefined
 ): Promise<"clickhouse" | "clickhouse_v2" | "postgres"> {
-  const flag = await flags({
+  const flag = await flag({
     key: FEATURE_FLAG.taskEventRepository,
     defaultValue: env.EVENT_REPOSITORY_DEFAULT_STORE,
     overrides: featureFlags,
diff --git a/apps/webapp/app/v3/featureFlags.server.ts b/apps/webapp/app/v3/featureFlags.server.ts
@@ -25,14 +25,14 @@ export type FlagsOptions<T extends FeatureFlagKey> = {
   overrides?: Record<string, unknown>;
 };
 
-export function makeFlags(_prisma: PrismaClientOrTransaction = prisma) {
-  function flags<T extends FeatureFlagKey>(
+export function makeFlag(_prisma: PrismaClientOrTransaction = prisma) {
+  function flag<T extends FeatureFlagKey>(
     opts: FlagsOptions<T> & { defaultValue: z.infer<(typeof FeatureFlagCatalog)[T]> }
   ): Promise<z.infer<(typeof FeatureFlagCatalog)[T]>>;
-  function flags<T extends FeatureFlagKey>(
+  function flag<T extends FeatureFlagKey>(
     opts: FlagsOptions<T>
   ): Promise<z.infer<(typeof FeatureFlagCatalog)[T]> | undefined>;
-  async function flags<T extends FeatureFlagKey>(
+  async function flag<T extends FeatureFlagKey>(
     opts: FlagsOptions<T>
   ): Promise<z.infer<(typeof FeatureFlagCatalog)[T]> | undefined> {
     const value = await _prisma.featureFlag.findUnique({
@@ -60,11 +60,11 @@ export function makeFlags(_prisma: PrismaClientOrTransaction = prisma) {
     return parsed.data;
   }
 
-  return flags;
+  return flag;
 }
 
-export function makeSetFlags(_prisma: PrismaClientOrTransaction = prisma) {
-  return async function setFlags<T extends FeatureFlagKey>(
+export function makeSetFlag(_prisma: PrismaClientOrTransaction = prisma) {
+  return async function setFlag<T extends FeatureFlagKey>(
     opts: FlagsOptions<T> & { value: z.infer<(typeof FeatureFlagCatalog)[T]> }
   ): Promise<void> {
     await _prisma.featureFlag.upsert({
@@ -82,8 +82,59 @@ export function makeSetFlags(_prisma: PrismaClientOrTransaction = prisma) {
   };
 }
 
+export type AllFlagsOptions = {
+  defaultValues?: Partial<FeatureFlagCatalog>;
+  overrides?: Record<string, unknown>;
+};
+
+export function makeFlags(_prisma: PrismaClientOrTransaction = prisma) {
+  return async function flags(options?: AllFlagsOptions): Promise<Partial<FeatureFlagCatalog>> {
+    const rows = await _prisma.featureFlag.findMany();
+
+    // Build a map of key -> value from database
+    const dbValues = new Map<string, unknown>();
+    for (const row of rows) {
+      dbValues.set(row.key, row.value);
+    }
+
+    const result: Partial<FeatureFlagCatalog> = {};
+
+    // Process each flag in the catalog
+    for (const key of Object.keys(FeatureFlagCatalog) as FeatureFlagKey[]) {
+      const schema = FeatureFlagCatalog[key];
+
+      // Priority: overrides > database > defaultValues
+      if (options?.overrides?.[key] !== undefined) {
+        const parsed = schema.safeParse(options.overrides[key]);
+        if (parsed.success) {
+          (result as any)[key] = parsed.data;
+          continue;
+        }
+      }
+
+      if (dbValues.has(key)) {
+        const parsed = schema.safeParse(dbValues.get(key));
+        if (parsed.success) {
+          (result as any)[key] = parsed.data;
+          continue;
+        }
+      }
+
+      if (options?.defaultValues?.[key] !== undefined) {
+        const parsed = schema.safeParse(options.defaultValues[key]);
+        if (parsed.success) {
+          (result as any)[key] = parsed.data;
+        }
+      }
+    }
+
+    return result;
+  };
+}
+
+export const flag = makeFlag();
 export const flags = makeFlags();
-export const setFlags = makeSetFlags();
+export const setFlag = makeSetFlag();
 
 // Create a Zod schema from the existing catalog
 export const FeatureFlagCatalogSchema = z.object(FeatureFlagCatalog);
@@ -112,7 +163,7 @@ export function makeSetMultipleFlags(_prisma: PrismaClientOrTransaction = prisma
   return async function setMultipleFlags(
     flags: Partial<z.infer<typeof FeatureFlagCatalogSchema>>
   ): Promise<{ key: string; value: any }[]> {
-    const setFlag = makeSetFlags(_prisma);
+    const setFlag = makeSetFlag(_prisma);
     const updatedFlags: { key: string; value: any }[] = [];
 
     for (const [key, value] of Object.entries(flags)) {
diff --git a/apps/webapp/app/v3/services/worker/workerGroupService.server.ts b/apps/webapp/app/v3/services/worker/workerGroupService.server.ts
@@ -2,7 +2,7 @@ import { WorkerInstanceGroup, WorkerInstanceGroupType } from "@trigger.dev/datab
 import { WithRunEngine } from "../baseService.server";
 import { WorkerGroupTokenService } from "./workerGroupTokenService.server";
 import { logger } from "~/services/logger.server";
-import { FEATURE_FLAG, makeFlags, makeSetFlags } from "~/v3/featureFlags.server";
+import { FEATURE_FLAG, makeFlag, makeSetFlag } from "~/v3/featureFlags.server";
 
 export class WorkerGroupService extends WithRunEngine {
   private readonly defaultNamePrefix = "worker_group";
@@ -47,14 +47,14 @@ export class WorkerGroupService extends WithRunEngine {
         },
       });
 
-      const getFlag = makeFlags(this._prisma);
+      const getFlag = makeFlag(this._prisma);
       const defaultWorkerInstanceGroupId = await getFlag({
         key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
       });
 
       // If there's no global default yet we should set it to the new worker group
       if (!defaultWorkerInstanceGroupId) {
-        const setFlag = makeSetFlags(this._prisma);
+        const setFlag = makeSetFlag(this._prisma);
         await setFlag({
           key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
           value: workerGroup.id,
@@ -166,7 +166,7 @@ export class WorkerGroupService extends WithRunEngine {
   }
 
   async getGlobalDefaultWorkerGroup() {
-    const flags = makeFlags(this._prisma);
+    const flags = makeFlag(this._prisma);
 
     const defaultWorkerInstanceGroupId = await flags({
       key: FEATURE_FLAG.defaultWorkerInstanceGroupId,
