266 lines
10 KiB
TypeScript
266 lines
10 KiB
TypeScript
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<AdminFeatureFlagRolloutView | null> {
|
|
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<AdminFeatureFlagRolloutTenant> => {
|
|
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<string, unknown>;
|
|
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<T, U>(items: readonly T[], concurrency: number, operation: (item: T) => Promise<U>): Promise<U[]> {
|
|
const results = new Array<U>(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;
|
|
}
|