import { buildFeatureFlagRolloutPreview, type FeatureFlagRolloutCriteria, type FeatureFlagRolloutFilter, type FeatureFlagRolloutPreview, type FeatureFlagRolloutTenant, type FeatureFlagTenantSize, } from "@hivegrid/feature-flags"; import type { AuditEventWriterClient } from "@hivegrid/db/audit-events.server"; import type { Prisma } from "@hivegrid/db/prisma-browser"; import { runWithRlsContext } from "@hivegrid/db/rls-context.server"; import { assertAdminActionReason, recordAdminAction } from "~/services/admin/admin-action-audit.server"; import { db } from "~/utils/db.server"; const MAX_BULK_OVERRIDE_TENANTS = 500; const ROLLOUT_PREVIEW_TENANT_CONCURRENCY = 4; export type AdminFeatureFlagRolloutTenant = FeatureFlagRolloutTenant & { readonly name: string; readonly slug: string; }; export type AdminFeatureFlagRolloutView = { readonly flag: { readonly id: string; readonly key: string; readonly label: string; readonly defaultValue: boolean; readonly lifecycleStage: "beta" | "rollout" | "ga" | "deprecated"; }; readonly tenants: readonly AdminFeatureFlagRolloutTenant[]; readonly preview: FeatureFlagRolloutPreview; }; export type AdminFeatureFlagBulkOverrideInput = { readonly flagKey: string; readonly tenantIds: readonly string[]; readonly value: boolean; readonly note?: string | null; readonly expiresAt?: Date | null; readonly actorAdminUserId: string; readonly reason: string; readonly request?: Request; }; export async function getAdminFeatureFlagRolloutView(flagKey: string, now = new Date()): Promise { const normalizedKey = normalizeKey(flagKey); const flag = await db.featureFlag.findFirst({ where: { OR: [{ key: normalizedKey }, { name: normalizedKey }], archivedAt: null }, include: { filters: { orderBy: [{ priority: "desc" }, { createdAt: "asc" }, { id: "asc" }] }, tenantOverrides: true, }, }); if (!flag) return null; const tenantRows = await db.tenant.findMany({ select: { id: true, name: true, slug: true, createdAt: true, active: true }, orderBy: { id: "asc" }, }); const tenants = await mapWithConcurrency(tenantRows, ROLLOUT_PREVIEW_TENANT_CONCURRENCY, async (tenant): Promise => { const details = await runWithRlsContext({ tenantId: tenant.id }, async () => { const [memberCount, subscription] = await Promise.all([ db.tenantUser.count({ where: { tenantId: tenant.id } }), db.tenantSubscription.findUnique({ where: { tenantId: tenant.id }, select: { status: true, products: { where: { cancelledAt: null }, select: { subscriptionProductId: true } }, }, }), ]); return { memberCount, subscription }; }); return { id: tenant.id, name: tenant.name, slug: tenant.slug, createdAt: tenant.createdAt.toISOString(), size: toTenantSize(details.memberCount), industry: null, status: details.subscription?.status ?? (tenant.active ? "active" : "inactive"), subscriptionProductIds: details.subscription?.products.map((product) => product.subscriptionProductId) ?? [], }; }); const filters: FeatureFlagRolloutFilter[] = flag.filters .filter((filter) => filter.resultValue !== null) .map((filter) => ({ id: filter.id, name: filter.name, priority: filter.priority, value: filter.resultValue ?? false, active: filter.active, createdAt: filter.createdAt.toISOString(), criteria: normalizeCriteria(filter.criteria), })); const overrides = flag.tenantOverrides.map((override) => ({ tenantId: override.tenantId, value: override.value, expiresAt: override.expiresAt?.toISOString() ?? null, })); return { flag: { id: flag.id, key: flag.key ?? flag.name, label: flag.description, defaultValue: flag.defaultValue ?? flag.enabled, lifecycleStage: flag.lifecycleStage, }, tenants, preview: buildFeatureFlagRolloutPreview({ tenants, defaultValue: flag.defaultValue ?? flag.enabled, filters, overrides, now, }), }; } export async function applyAdminFeatureFlagBulkOverride(input: AdminFeatureFlagBulkOverrideInput): Promise<{ updated: number }> { const reason = assertAdminActionReason(input.reason); const flagKey = normalizeKey(input.flagKey); const actorAdminUserId = normalizeIdentifier(input.actorAdminUserId, "actorAdminUserId"); const tenantIds = normalizeTenantIds(input.tenantIds); const note = normalizeOptionalText(input.note, 1_000); const expiresAt = normalizeExpiry(input.expiresAt); return db.$transaction(async (transaction) => { const flag = await transaction.featureFlag.findFirst({ where: { OR: [{ key: flagKey }, { name: flagKey }], archivedAt: null }, select: { id: true, key: true, name: true }, }); if (!flag) throw new AdminFeatureFlagRolloutError("FLAG_NOT_FOUND"); const tenants = await transaction.tenant.findMany({ where: { id: { in: tenantIds } }, select: { id: true } }); if (tenants.length !== tenantIds.length) throw new AdminFeatureFlagRolloutError("TENANT_NOT_FOUND"); const now = new Date(); for (const tenantId of tenantIds) { await transaction.adminFeatureFlagOverride.upsert({ where: { admin_feature_flag_override_flag_tenant_key: { featureFlagId: flag.id, tenantId } }, create: { featureFlagId: flag.id, tenantId, value: input.value, note, expiresAt, setByAdminUserId: actorAdminUserId }, update: { value: input.value, note, expiresAt, setByAdminUserId: actorAdminUserId }, }); } await transaction.featureFlagAudit.create({ data: { flagId: flag.id, actorUserId: actorAdminUserId, actorType: "admin", action: "bulk_override", newValue: { value: input.value, tenantCount: tenantIds.length, expiresAt: expiresAt?.toISOString() ?? null }, metadata: { reason, tenantIds }, createdAt: now, }, }); await recordAdminAction( { action: "featureFlag.bulkOverride", actorUserId: actorAdminUserId, targetKind: "FeatureFlag", targetId: flag.id, reason, request: input.request, after: { value: input.value, tenantCount: tenantIds.length, expiresAt: expiresAt?.toISOString() ?? null }, }, transaction as unknown as AuditEventWriterClient ); return { updated: tenantIds.length }; }); } export class AdminFeatureFlagRolloutError extends Error { public override readonly name = "AdminFeatureFlagRolloutError"; public constructor(public readonly code: "FLAG_NOT_FOUND" | "TENANT_NOT_FOUND" | "INVALID_INPUT") { super(code); } } export function normalizeTenantIds(values: readonly string[]): string[] { const normalized = [...new Set(values.map((value) => normalizeIdentifier(value, "tenantId")))].sort(); if (normalized.length === 0 || normalized.length > MAX_BULK_OVERRIDE_TENANTS) { throw new AdminFeatureFlagRolloutError("INVALID_INPUT"); } return normalized; } function normalizeCriteria(value: Prisma.JsonValue | null): FeatureFlagRolloutCriteria { if (!value || typeof value !== "object" || Array.isArray(value)) return {}; const criteria = value as Record; return { ...(isTenantSize(criteria.tenantSize) ? { tenantSize: criteria.tenantSize } : {}), ...(typeof criteria.tenantIndustry === "string" ? { tenantIndustry: criteria.tenantIndustry } : {}), ...(typeof criteria.tenantStatus === "string" ? { tenantStatus: criteria.tenantStatus } : {}), ...(typeof criteria.subscriptionProductId === "string" ? { subscriptionProductId: criteria.subscriptionProductId } : {}), ...(typeof criteria.tenantCreatedAfter === "string" ? { tenantCreatedAfter: criteria.tenantCreatedAfter } : {}), ...(typeof criteria.tenantCreatedBefore === "string" ? { tenantCreatedBefore: criteria.tenantCreatedBefore } : {}), ...(isStringArray(criteria.tenantIdIn) ? { tenantIdIn: criteria.tenantIdIn } : {}), ...(isStringArray(criteria.tenantIdNotIn) ? { tenantIdNotIn: criteria.tenantIdNotIn } : {}), }; } function toTenantSize(count: number): FeatureFlagTenantSize { if (count <= 10) return "1-10"; if (count <= 25) return "11-25"; if (count <= 50) return "26-50"; if (count <= 100) return "51-100"; return "100+"; } function isTenantSize(value: unknown): value is FeatureFlagTenantSize { return value === "1-10" || value === "11-25" || value === "26-50" || value === "51-100" || value === "100+"; } function isStringArray(value: unknown): value is string[] { return Array.isArray(value) && value.every((entry) => typeof entry === "string"); } function normalizeKey(value: string): string { const normalized = value.trim(); if (!/^[A-Za-z0-9_.-]{1,191}$/u.test(normalized)) throw new AdminFeatureFlagRolloutError("INVALID_INPUT"); return normalized; } function normalizeIdentifier(value: string, name: string): string { const normalized = value.trim(); if (!normalized || normalized.length > 191 || normalized.includes("\u0000")) { throw new AdminFeatureFlagRolloutError("INVALID_INPUT"); } void name; return normalized; } function normalizeOptionalText(value: string | null | undefined, maxLength: number): string | null { if (value === null || value === undefined) return null; const normalized = value.trim(); if (!normalized) return null; if (normalized.length > maxLength) throw new AdminFeatureFlagRolloutError("INVALID_INPUT"); return normalized; } function normalizeExpiry(value: Date | null | undefined): Date | null { if (value === null || value === undefined) return null; if (!Number.isFinite(value.getTime())) throw new AdminFeatureFlagRolloutError("INVALID_INPUT"); return value; } async function mapWithConcurrency(items: readonly T[], concurrency: number, operation: (item: T) => Promise): Promise { const results = new Array(items.length); let cursor = 0; await Promise.all( Array.from({ length: Math.min(concurrency, items.length) }, async () => { while (cursor < items.length) { const index = cursor++; results[index] = await operation(items[index]!); } }) ); return results; }