Track HiveGrid Cloud planning reference

This commit is contained in:
david committed 2026-06-26 20:48:01 +02:00
1 parent b3d5ea6764
commit e341c5938a
5784 files changed
+1104929 -3

No files matched your search

@@ -0,0 +1,207 @@
import { describe, expect, it, vi } from "vitest";
import { DefaultFeatures } from "~/application/dtos/shared/DefaultFeatures";
import {
evaluateDashboardModuleGates,
getDashboardModuleDiagnostics,
getVisibleDashboardModules,
type DashboardModuleGateDiagnostic,
} from "./gating.server";
import { dashboardRegistryEvidence, getDashboardModuleDefinitions, type DashboardModuleDefinition } from "./registry.server";
const request = new Request("https://app.example.com/acme/dashboard?tenantId=tenant_123&token=secret-token");
const params = { tenant: "acme", tenantId: "tenant_123" };
const summaryModule = {
id: "summary-stats",
titleKey: "app.dashboard.modules.summaryStats.title",
descriptionKey: "app.dashboard.modules.summaryStats.description",
} as const satisfies DashboardModuleDefinition;
const featureModule = {
id: "subscription-health",
titleKey: "app.dashboard.modules.subscriptionHealth.title",
descriptionKey: "app.dashboard.modules.subscriptionHealth.description",
featureFlagKey: "tenant.subscription.active",
} as const satisfies DashboardModuleDefinition;
const planModule = {
id: "priority-insights",
titleKey: "app.dashboard.modules.priorityInsights.title",
descriptionKey: "app.dashboard.modules.priorityInsights.description",
planFeatureKey: DefaultFeatures.PrioritySupport,
} as const satisfies DashboardModuleDefinition;
function entitlementService(allowed: boolean) {
return vi.fn(() => ({
allowed,
reason: allowed ? ("included" as const) : ("missing-subscription" as const),
featureKey: DefaultFeatures.PrioritySupport,
}));
}
const sensitiveSamples = [
"tenant_123",
"secret-token",
"user_456",
"subscription_789",
"provider_api_key_live",
"raw-feature-input=tenant.subscription.active",
"DATABASE_URL",
"bearer jwt-token",
] as const;
function expectSafeStaticPayload(payload: unknown) {
const serialized = JSON.stringify(payload);
for (const sample of sensitiveSamples) {
expect(serialized).not.toContain(sample);
}
expect(serialized).not.toMatch(/user[_-]?\d+|subscription[_-]?\d+|provider[_-]?api[_-]?key|bearer\s+jwt|jwt-token|secret-token/i);
}
function expectDiagnosticsRedacted(diagnostics: readonly DashboardModuleGateDiagnostic[]) {
expectSafeStaticPayload(diagnostics);
}
describe("dashboard module registry", () => {
it("defines stable module contracts for summary, plan-gated, and feature-gated modules", () => {
expect(getDashboardModuleDefinitions()).toEqual(
expect.arrayContaining([
expect.objectContaining({ id: "summary-stats" }),
expect.objectContaining({ id: "priority-insights", planFeatureKey: DefaultFeatures.PrioritySupport }),
expect.objectContaining({ id: "subscription-health", featureFlagKey: "tenant.subscription.active" }),
]),
);
});
it("exports source-backed registry evidence with stable IDs and gate coverage", () => {
const definitions = getDashboardModuleDefinitions();
expect(dashboardRegistryEvidence.registryName).toBe("Tenant/Workspace Dashboard");
expect(dashboardRegistryEvidence.registryScope).toBe("tenant-workspace-dashboard-modules");
expect(dashboardRegistryEvidence.expectedModuleIds).toEqual(definitions.map((module) => module.id));
expect(dashboardRegistryEvidence.expectedModuleIds).toEqual(["summary-stats", "priority-insights", "subscription-health"]);
expect(dashboardRegistryEvidence.gatingSourcesRepresented).toEqual(["feature-flag", "plan"]);
expect(definitions.find((module) => module.id === "summary-stats")).toEqual(expect.not.objectContaining({ featureFlagKey: expect.any(String) }));
expect(definitions.find((module) => module.id === "summary-stats")).toEqual(expect.not.objectContaining({ planFeatureKey: expect.any(String) }));
expect(definitions.find((module) => module.id === "priority-insights")).toEqual(
expect.objectContaining({ planFeatureKey: DefaultFeatures.PrioritySupport }),
);
expect(definitions.find((module) => module.id === "subscription-health")).toEqual(
expect.objectContaining({ featureFlagKey: "tenant.subscription.active" }),
);
});
it("keeps registry evidence limited to safe static metadata", () => {
expect(dashboardRegistryEvidence.redactionGuarantee).toContain("static source metadata only");
expect(dashboardRegistryEvidence.redactionGuarantee).toContain("excludes request, tenant, subscription, user, token, environment, and raw feature input values");
expect(dashboardRegistryEvidence.expectedModuleIds.length).toBe(getDashboardModuleDefinitions().length);
expectSafeStaticPayload(dashboardRegistryEvidence);
});
});
describe("evaluateDashboardModuleGates", () => {
it("returns visible modules when all gates allow access", async () => {
const decisions = await evaluateDashboardModuleGates({
request,
params,
definitions: [summaryModule, featureModule, planModule],
services: {
hasFeatureFlag: vi.fn(async () => true),
evaluateSubscriptionEntitlement: entitlementService(true),
},
});
expect(getVisibleDashboardModules(decisions).map((module) => module.id)).toEqual(["summary-stats", "subscription-health", "priority-insights"]);
expect(getDashboardModuleDiagnostics(decisions)).toEqual([]);
});
it("denies only a disabled feature-flagged module", async () => {
const decisions = await evaluateDashboardModuleGates({
request,
params,
definitions: [summaryModule, featureModule, planModule],
services: {
hasFeatureFlag: vi.fn(async () => false),
evaluateSubscriptionEntitlement: entitlementService(true),
},
});
expect(getVisibleDashboardModules(decisions).map((module) => module.id)).toEqual(["summary-stats", "priority-insights"]);
expect(getDashboardModuleDiagnostics(decisions)).toEqual([
{
moduleId: "subscription-health",
source: "feature-flag",
reason: "feature-disabled",
redirectPath: "/feature-disabled",
},
]);
});
it("denies only the gated module when feature flag lookup fails", async () => {
const decisions = await evaluateDashboardModuleGates({
request,
params,
definitions: [summaryModule, featureModule],
services: {
hasFeatureFlag: vi.fn(async () => {
throw new Error("backend unavailable for tenant_123 with token secret-token");
}),
},
});
expect(getVisibleDashboardModules(decisions).map((module) => module.id)).toEqual(["summary-stats"]);
expect(getDashboardModuleDiagnostics(decisions)).toEqual([
{
moduleId: "subscription-health",
source: "feature-flag",
reason: "feature-check-failed",
redirectPath: "/feature-disabled",
},
]);
});
it("denies missing plan entitlement with plan-required diagnostics", async () => {
const decisions = await evaluateDashboardModuleGates({
request,
params,
definitions: [summaryModule, planModule],
subscription: { products: [] },
services: {
evaluateSubscriptionEntitlement: entitlementService(false),
},
});
expect(getVisibleDashboardModules(decisions).map((module) => module.id)).toEqual(["summary-stats"]);
expect(getDashboardModuleDiagnostics(decisions)).toEqual([
{
moduleId: "priority-insights",
source: "plan",
reason: "plan-required",
redirectPath: "plan-required",
},
]);
});
it("keeps denied diagnostics redacted from tenant, subscription, user, and token inputs", async () => {
const decisions = await evaluateDashboardModuleGates({
request,
params,
definitions: [featureModule, planModule],
subscription: { products: [] },
services: {
hasFeatureFlag: vi.fn(async () => false),
evaluateSubscriptionEntitlement: entitlementService(false),
},
redirectPaths: {
"feature-flag": "/feature-disabled",
plan: "plan-required",
},
});
expect(getDashboardModuleDiagnostics(decisions)).toEqual([
expect.objectContaining({ moduleId: "subscription-health", source: "feature-flag", reason: "feature-disabled" }),
expect.objectContaining({ moduleId: "priority-insights", source: "plan", reason: "plan-required" }),
]);
expectDiagnosticsRedacted(getDashboardModuleDiagnostics(decisions));
});
});
@@ -0,0 +1,198 @@
import type { Params } from "react-router";
import type { EntitlementDecision } from "@toolctrl/entitlements";
import type {
SubscriptionEntitlementSubscription,
SubscriptionEntitlementTrialState,
} from "~/utils/entitlements/.server/subscriptionEntitlements.server";
import { evaluateSubscriptionEntitlement as defaultEvaluateSubscriptionEntitlement } from "~/utils/entitlements/.server/subscriptionEntitlements.server";
import { isFeatureFlagEnabled } from "~/utils/services/.server/featureFlagsRequest.server";
import { getDashboardModuleDefinitions, type DashboardModuleDefinition, type DashboardModuleId } from "./registry.server";
export type DashboardModuleGateSource = "feature-flag" | "plan";
export type DashboardModuleGateReason = "feature-disabled" | "feature-check-failed" | "plan-required";
export interface DashboardModuleGateDiagnostic {
readonly moduleId: DashboardModuleId;
readonly source: DashboardModuleGateSource;
readonly reason: DashboardModuleGateReason;
readonly redirectPath?: string;
}
export interface DashboardModuleGateDecision {
readonly module: DashboardModuleDefinition;
readonly allowed: boolean;
readonly diagnostic?: DashboardModuleGateDiagnostic;
}
export interface EvaluateDashboardModuleGatesInput {
readonly request: Request;
readonly params: Params;
readonly subscription?: SubscriptionEntitlementSubscription | null;
readonly trial?: SubscriptionEntitlementTrialState | null;
readonly definitions?: readonly DashboardModuleDefinition[];
readonly redirectPaths?: Partial<Record<DashboardModuleGateSource, string>>;
readonly services?: DashboardModuleGateServices;
readonly serviceLoaders?: DashboardModuleGateServiceLoaders;
}
export interface DashboardModuleGateServices {
/**
* Boolean feature-flag check shimmed against the v2 evaluator
* (`isFeatureFlagEnabled`). Tests inject a stub; production wiring
* resolves the request + tenant context inside the v2 helper.
*/
readonly hasFeatureFlag?: (input: { request: Request; params: Params; flagName: string }) => Promise<boolean>;
readonly evaluateSubscriptionEntitlement?: (input: {
featureKey: string;
subscription?: SubscriptionEntitlementSubscription | null;
trial?: SubscriptionEntitlementTrialState | null;
}) => EntitlementDecision;
}
export interface DashboardModuleGateServiceLoaders {
readonly featureFlags?: () => Promise<Pick<Required<DashboardModuleGateServices>, "hasFeatureFlag">>;
readonly entitlements?: () => Promise<Pick<Required<DashboardModuleGateServices>, "evaluateSubscriptionEntitlement">>;
}
const defaultRedirectPaths = Object.freeze({
"feature-flag": "/feature-disabled",
plan: "plan-required",
} satisfies Record<DashboardModuleGateSource, string>);
function diagnostic(input: {
moduleId: DashboardModuleId;
source: DashboardModuleGateSource;
reason: DashboardModuleGateReason;
redirectPath?: string;
}): DashboardModuleGateDiagnostic {
return {
moduleId: input.moduleId,
source: input.source,
reason: input.reason,
...(input.redirectPath ? { redirectPath: input.redirectPath } : {}),
};
}
async function evaluateDashboardModuleGate({
module,
request,
params,
subscription,
trial,
redirectPaths,
services,
serviceLoaders,
}: Omit<EvaluateDashboardModuleGatesInput, "definitions"> & { module: DashboardModuleDefinition }): Promise<DashboardModuleGateDecision> {
if (module.featureFlagKey) {
try {
if (!services?.hasFeatureFlag) {
const featureFlagService = serviceLoaders?.featureFlags
? await serviceLoaders.featureFlags()
: { hasFeatureFlag: ({ request: req, params: p, flagName }: { request: Request; params: Params; flagName: string }) => isFeatureFlagEnabled(flagName, { request: req, params: p }) };
services = { ...services, hasFeatureFlag: featureFlagService.hasFeatureFlag };
}
const hasFeatureFlag = services.hasFeatureFlag;
if (!hasFeatureFlag) {
throw new Error("Dashboard feature flag service unavailable");
}
const enabled = await hasFeatureFlag({
request,
params,
flagName: module.featureFlagKey,
});
if (!enabled) {
return {
module,
allowed: false,
diagnostic: diagnostic({
moduleId: module.id,
source: "feature-flag",
reason: "feature-disabled",
redirectPath: redirectPaths?.["feature-flag"] ?? defaultRedirectPaths["feature-flag"],
}),
};
}
} catch {
return {
module,
allowed: false,
diagnostic: diagnostic({
moduleId: module.id,
source: "feature-flag",
reason: "feature-check-failed",
redirectPath: redirectPaths?.["feature-flag"] ?? defaultRedirectPaths["feature-flag"],
}),
};
}
}
if (module.planFeatureKey) {
if (!services?.evaluateSubscriptionEntitlement) {
const entitlementService = serviceLoaders?.entitlements
? await serviceLoaders.entitlements()
: { evaluateSubscriptionEntitlement: defaultEvaluateSubscriptionEntitlement };
services = { ...services, evaluateSubscriptionEntitlement: entitlementService.evaluateSubscriptionEntitlement };
}
const evaluateSubscriptionEntitlement = services.evaluateSubscriptionEntitlement;
if (!evaluateSubscriptionEntitlement) {
throw new Error("Dashboard entitlement service unavailable");
}
const entitlement = evaluateSubscriptionEntitlement({
featureKey: module.planFeatureKey,
subscription,
trial,
});
if (!entitlement.allowed) {
return {
module,
allowed: false,
diagnostic: diagnostic({
moduleId: module.id,
source: "plan",
reason: "plan-required",
redirectPath: redirectPaths?.plan ?? defaultRedirectPaths.plan,
}),
};
}
}
return { module, allowed: true };
}
export async function evaluateDashboardModuleGates({
request,
params,
subscription,
trial,
definitions = getDashboardModuleDefinitions(),
redirectPaths,
services,
serviceLoaders,
}: EvaluateDashboardModuleGatesInput): Promise<DashboardModuleGateDecision[]> {
return Promise.all(
definitions.map((module) =>
evaluateDashboardModuleGate({
module,
request,
params,
subscription,
trial,
redirectPaths,
services,
serviceLoaders,
}),
),
);
}
export function getVisibleDashboardModules(decisions: readonly DashboardModuleGateDecision[]): DashboardModuleDefinition[] {
return decisions.filter((decision) => decision.allowed).map((decision) => decision.module);
}
export function getDashboardModuleDiagnostics(decisions: readonly DashboardModuleGateDecision[]): DashboardModuleGateDiagnostic[] {
return decisions.flatMap((decision) => (decision.diagnostic ? [decision.diagnostic] : []));
}
@@ -0,0 +1,48 @@
import { DefaultFeatures } from "~/application/dtos/shared/DefaultFeatures";
import type { FeatureFlagsFilterType } from "~/modules/featureFlags/dtos/FeatureFlagsFilterTypes";
export type DashboardModuleId = "summary-stats" | "priority-insights" | "subscription-health";
export interface DashboardModuleDefinition {
readonly id: DashboardModuleId;
readonly titleKey: string;
readonly descriptionKey: string;
readonly featureFlagKey?: FeatureFlagsFilterType;
readonly planFeatureKey?: DefaultFeatures | string;
}
export const dashboardModuleRegistry = Object.freeze([
{
id: "summary-stats",
titleKey: "app.dashboard.modules.summaryStats.title",
descriptionKey: "app.dashboard.modules.summaryStats.description",
},
{
id: "priority-insights",
titleKey: "app.dashboard.modules.priorityInsights.title",
descriptionKey: "app.dashboard.modules.priorityInsights.description",
planFeatureKey: DefaultFeatures.PrioritySupport,
},
{
id: "subscription-health",
titleKey: "app.dashboard.modules.subscriptionHealth.title",
descriptionKey: "app.dashboard.modules.subscriptionHealth.description",
featureFlagKey: "tenant.subscription.active",
},
] as const satisfies readonly DashboardModuleDefinition[]);
const dashboardModuleIds = dashboardModuleRegistry.map((module) => module.id) as readonly DashboardModuleId[];
const dashboardGateSources = Object.freeze(["feature-flag", "plan"] as const);
export const dashboardRegistryEvidence = Object.freeze({
registryName: "Tenant/Workspace Dashboard",
registryScope: "tenant-workspace-dashboard-modules",
expectedModuleIds: dashboardModuleIds,
gatingSourcesRepresented: dashboardGateSources,
redactionGuarantee:
"Dashboard registry evidence is static source metadata only and excludes request, tenant, subscription, user, token, environment, and raw feature input values.",
} as const);
export function getDashboardModuleDefinitions(): readonly DashboardModuleDefinition[] {
return dashboardModuleRegistry;
}