@beignet/cli 0.0.47 → 0.0.49

package/src/provider-audit.ts

@@ -18,6 +18,7 @@ export type ProviderPackageJson = {
   dependencies?: Record<string, string>;
   devDependencies?: Record<string, string>;
   peerDependencies?: Record<string, string>;
+  scripts?: Record<string, string>;
 };
 
 export type ProviderDoctorVariantRule = {
@@ -25,6 +26,7 @@ export type ProviderDoctorVariantRule = {
   displayName: string;
   tokens: readonly string[];
   requiredEnv: readonly string[];
+  requiredEnvAlternatives: readonly (readonly string[])[];
   requiredTables: readonly string[];
   registrationSeverity?: "warning" | "hint";
 };
@@ -35,6 +37,7 @@ export type ProviderDoctorRule = {
   tokens: readonly string[];
   appPorts?: readonly { name: string; type: string }[];
   requiredEnv?: readonly string[];
+  requiredEnvAlternatives?: readonly (readonly string[])[];
   requiredTables?: readonly string[];
   watchers?: readonly string[];
   registrationSeverity?: "warning" | "hint";
@@ -94,6 +97,14 @@ export type ProviderRequirementAudit = {
   status: ProviderAuditStatus;
   required: string[];
   missing: string[];
+  alternatives?: string[][];
+  alternativeGroups?: Array<{
+    name: string;
+    displayName: string;
+    status: "present" | "missing";
+    alternatives: string[][];
+    missing: string[];
+  }>;
 };
 
 export type ProviderAppPortsAudit = {
@@ -282,6 +293,36 @@ export async function providerDoctorRulesForInstalledPackages(
   return rules.filter((rule): rule is ProviderDoctorRule => Boolean(rule));
 }
 
+export async function detectedProviderVariantsForRules(
+  targetDir: string,
+  rules: readonly ProviderDoctorRule[],
+): Promise<Map<string, ProviderDoctorVariantRule[]>> {
+  const variantRules = rules.filter(
+    (
+      rule,
+    ): rule is ProviderDoctorRule & {
+      variants: readonly ProviderDoctorVariantRule[];
+    } => rule.variants !== undefined,
+  );
+  if (variantRules.length === 0) return new Map();
+
+  const files = await listFiles(targetDir);
+  const config = await loadBeignetConfig(targetDir, files);
+  const providerEntries = await readProviderListEntries(
+    targetDir,
+    files,
+    config,
+    new Map(),
+  );
+
+  return new Map(
+    variantRules.map((rule) => [
+      rule.packageName,
+      detectedProviderVariants(rule.variants, providerEntries),
+    ]),
+  );
+}
+
 export async function readProviderPackageMetadataSource(
   targetDir: string,
   packageName: string,
@@ -314,6 +355,7 @@ export function providerDoctorRuleFromMetadata(
     tokens: registration?.tokens ?? [],
     appPorts: metadata.appPorts ?? [],
     requiredEnv: metadata.requiredEnv ?? [],
+    requiredEnvAlternatives: metadata.requiredEnvAlternatives ?? [],
     requiredTables: metadata.requiredTables ?? [],
     watchers: metadata.watchers ?? [],
     registrationSeverity: registrationSeverityFromMetadata(registration),
@@ -322,6 +364,7 @@ export function providerDoctorRuleFromMetadata(
       displayName: variant.displayName ?? variant.name,
       tokens: variant.registration?.tokens ?? [],
       requiredEnv: variant.requiredEnv ?? [],
+      requiredEnvAlternatives: variant.requiredEnvAlternatives ?? [],
       requiredTables: variant.requiredTables ?? [],
       registrationSeverity: registrationSeverityFromMetadata(
         variant.registration,
@@ -1061,6 +1104,15 @@ function configuredProviderRequiredEnv(
   return envVars.filter((envVar) => !ignored.has(envVar));
 }
 
+function configuredProviderRequiredEnvAlternatives(
+  alternatives: readonly (readonly string[])[],
+  config: ResolvedBeignetConfig,
+): string[][] {
+  return alternatives.map((alternative) =>
+    configuredProviderRequiredEnv(alternative, config),
+  );
+}
+
 function configuredProviderRequiredTables(
   tableNames: readonly string[],
   config: ResolvedBeignetConfig,
@@ -1187,19 +1239,23 @@ async function providerAuditEntryForRule(options: {
   const requiredEnv =
     options.rule.variants !== undefined
       ? aggregateVariantRequirement(variants, "requiredEnv")
-      : await requirementAudit(
-          configuredProviderRequiredEnv(
+      : await providerEnvRequirementAudit({
+          required: configuredProviderRequiredEnv(
             options.rule.requiredEnv ?? [],
             options.config,
           ),
-          (envVar) =>
+          alternatives: configuredProviderRequiredEnvAlternatives(
+            options.rule.requiredEnvAlternatives ?? [],
+            options.config,
+          ),
+          exists: (envVar) =>
             providerRequiredEnvExists(
               options.targetDir,
               options.configFiles,
               envVar,
               options.sourceCache,
             ),
-        );
+        });
 
   const requiredTables =
     options.rule.variants !== undefined
@@ -1288,12 +1344,19 @@ async function providerVariantAudit(options: {
     options.variant.requiredEnv,
     options.config,
   );
+  const requiredEnvAlternatives = configuredProviderRequiredEnvAlternatives(
+    options.variant.requiredEnvAlternatives,
+    options.config,
+  );
   if (!options.registered) {
     return {
       name: options.variant.name,
       displayName: options.variant.displayName,
       registration: "inactive",
-      requiredEnv: inactiveRequirement(requiredEnv),
+      requiredEnv:
+        requiredEnvAlternatives.length > 0
+          ? inactiveAlternativeRequirement(requiredEnvAlternatives)
+          : inactiveRequirement(requiredEnv),
       requiredTables: inactiveRequirement(options.variant.requiredTables),
     };
   }
@@ -1306,14 +1369,17 @@ async function providerVariantAudit(options: {
       options.variant.registrationSeverity,
       options.providerEntries,
     ),
-    requiredEnv: await requirementAudit(requiredEnv, (envVar) =>
-      providerRequiredEnvExists(
-        options.targetDir,
-        options.configFiles,
-        envVar,
-        options.sourceCache,
-      ),
-    ),
+    requiredEnv: await providerEnvRequirementAudit({
+      required: requiredEnv,
+      alternatives: requiredEnvAlternatives,
+      exists: (envVar) =>
+        providerRequiredEnvExists(
+          options.targetDir,
+          options.configFiles,
+          envVar,
+          options.sourceCache,
+        ),
+    }),
     requiredTables: await requirementAudit(
       configuredProviderRequiredTables(
         options.variant.requiredTables,
@@ -1448,6 +1514,34 @@ async function requirementAudit(
   };
 }
 
+async function providerEnvRequirementAudit(options: {
+  required: readonly string[];
+  alternatives: readonly (readonly string[])[];
+  exists: (requirement: string) => Promise<boolean>;
+}): Promise<ProviderRequirementAudit> {
+  if (options.alternatives.length === 0) {
+    return requirementAudit(options.required, options.exists);
+  }
+
+  const missingAlternatives: string[][] = [];
+  for (const alternative of options.alternatives) {
+    const missing: string[] = [];
+    for (const requirement of alternative) {
+      if (await options.exists(requirement)) continue;
+      missing.push(requirement);
+    }
+    missingAlternatives.push(missing);
+  }
+
+  const present = missingAlternatives.some((missing) => missing.length === 0);
+  return {
+    status: present ? "present" : "missing",
+    required: unique(options.alternatives.flat()),
+    missing: present ? [] : unique(missingAlternatives.flat()),
+    alternatives: options.alternatives.map((alternative) => [...alternative]),
+  };
+}
+
 function inactiveRequirement(
   required: readonly string[],
 ): ProviderRequirementAudit {
@@ -1458,6 +1552,17 @@ function inactiveRequirement(
   };
 }
 
+function inactiveAlternativeRequirement(
+  alternatives: readonly (readonly string[])[],
+): ProviderRequirementAudit {
+  return {
+    status: "inactive",
+    required: unique(alternatives.flat()),
+    missing: [],
+    alternatives: alternatives.map((alternative) => [...alternative]),
+  };
+}
+
 function emptyRequirement(): ProviderRequirementAudit {
   return { status: "none", required: [], missing: [] };
 }
@@ -1467,21 +1572,57 @@ function aggregateVariantRequirement(
   key: "requiredEnv" | "requiredTables",
 ): ProviderRequirementAudit {
   const active = variants
-    .map((variant) => variant[key])
-    .filter((requirement) => requirement.status !== "inactive");
+    .map((variant) => ({ variant, requirement: variant[key] }))
+    .filter(({ requirement }) => requirement.status !== "inactive");
   if (active.length === 0)
     return { status: "inactive", required: [], missing: [] };
 
   const required = unique(
-    active.flatMap((requirement) => requirement.required),
+    active.flatMap(({ requirement }) => requirement.required),
+  );
+  const missing = unique(
+    active.flatMap(({ requirement }) => requirement.missing),
   );
-  const missing = unique(active.flatMap((requirement) => requirement.missing));
   if (required.length === 0) return emptyRequirement();
 
+  const hasAlternativeRequirements = active.some(
+    ({ requirement }) =>
+      requirement.alternatives !== undefined ||
+      requirement.alternativeGroups !== undefined,
+  );
+  const alternativeGroups = hasAlternativeRequirements
+    ? active.flatMap(({ variant, requirement }) => {
+        if (requirement.status === "none") return [];
+        if (
+          requirement.status !== "present" &&
+          requirement.status !== "missing"
+        ) {
+          return [];
+        }
+
+        return [
+          {
+            name: variant.name,
+            displayName: variant.displayName,
+            status: requirement.status,
+            alternatives: (
+              requirement.alternatives ?? [requirement.required]
+            ).map((alternative) => [...alternative]),
+            missing: [...requirement.missing],
+          },
+        ];
+      })
+    : [];
+
   return {
     status: missing.length === 0 ? "present" : "missing",
     required,
     missing,
+    ...(alternativeGroups.length === 1
+      ? { alternatives: alternativeGroups[0]?.alternatives ?? [] }
+      : alternativeGroups.length > 0
+        ? { alternativeGroups }
+        : {}),
   };
 }
 
@@ -1520,7 +1661,17 @@ function providerAuditNotes(input: {
     notes.push("optional provider not registered");
   }
   if (input.requiredEnv.missing.length > 0) {
-    notes.push(`missing env: ${input.requiredEnv.missing.join(", ")}`);
+    notes.push(
+      input.requiredEnv.alternativeGroups
+        ? `missing env configuration groups: ${formatProviderEnvAlternativeGroups(
+            input.requiredEnv.alternativeGroups,
+          )}`
+        : input.requiredEnv.alternatives
+          ? `missing env alternative: ${formatProviderEnvAlternatives(
+              input.requiredEnv.alternatives,
+            )}`
+          : `missing env: ${input.requiredEnv.missing.join(", ")}`,
+    );
   }
   if (input.requiredTables.missing.length > 0) {
     notes.push(`missing tables: ${input.requiredTables.missing.join(", ")}`);
@@ -1863,6 +2014,21 @@ function escapeRegExp(value: string): string {
 function requirementSummary(requirement: ProviderRequirementAudit): string {
   if (requirement.status === "none") return "none";
   if (requirement.status === "inactive") return "inactive";
+  if (requirement.alternativeGroups) {
+    const count = requirement.alternativeGroups.length;
+    const missing = requirement.alternativeGroups.filter(
+      (group) => group.status === "missing",
+    ).length;
+    return requirement.status === "present"
+      ? `${count} variant groups ok`
+      : `${missing}/${count} variant groups incomplete`;
+  }
+  if (requirement.alternatives) {
+    if (requirement.status === "present") {
+      return "alternative ok";
+    }
+    return `${requirement.alternatives.length} alternatives missing`;
+  }
   if (requirement.status === "present") {
     return `${requirement.required.length} ok`;
   }
@@ -1879,6 +2045,32 @@ function unique(values: readonly string[]): string[] {
   return [...new Set(values)];
 }
 
+export function formatProviderEnvAlternatives(
+  alternatives: readonly (readonly string[])[],
+): string {
+  return alternatives
+    .map((alternative) =>
+      alternative.length === 1
+        ? alternative[0]
+        : `(${alternative.join(" + ")})`,
+    )
+    .join(" or ");
+}
+
+function formatProviderEnvAlternativeGroups(
+  groups: NonNullable<ProviderRequirementAudit["alternativeGroups"]>,
+): string {
+  return groups
+    .filter((group) => group.status === "missing")
+    .map(
+      (group) =>
+        `${group.displayName}: ${formatProviderEnvAlternatives(
+          group.alternatives,
+        )}`,
+    )
+    .join(" and ");
+}
+
 function table(rows: string[][]): string {
   const widths = rows[0].map((_, columnIndex) =>
     Math.max(...rows.map((row) => row[columnIndex].length)),