Refresh HiveGrid Cloud reference snapshot

This commit is contained in:
david committed 2026-08-03 15:31:14 +02:00
1 parent 5e99e14772
commit 7f88026f79
5955 files changed
+1177325 -188362

No files matched your search

@@ -0,0 +1,265 @@
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;
}