@ankhorage/doctor 0.8.0 → 0.9.0

package/src/authReadinessTargetFallback.ts

@@ -0,0 +1,38 @@
+import { createAuthReadinessDiagnostic } from './authReadinessDiagnostic.js';
+import type { AuthReadinessTargetResolution } from './authReadinessTargetResolution.js';
+
+export function resolveAuthReadinessTargetFallback(
+  deploy: unknown,
+  manifestPath: string,
+): AuthReadinessTargetResolution {
+  if (deploy === undefined) {
+    return {
+      diagnostics: [
+        createAuthReadinessDiagnostic({
+          code: 'field-missing',
+          message:
+            'deploy.targets is missing; Doctor evaluates legacy Web-only readiness until canonical targets are persisted.',
+          path: manifestPath,
+          ruleId: 'manifest.deploy.targets.legacy-web',
+          severity: 'warning',
+        }),
+      ],
+      enabledTargets: ['web'],
+      targets: { web: { enabled: true } },
+    };
+  }
+
+  return {
+    diagnostics: [
+      createAuthReadinessDiagnostic({
+        code: 'field-invalid',
+        message: 'manifest.deploy must match the canonical Contracts deploy target model.',
+        path: manifestPath,
+        ruleId: 'manifest.deploy.valid-shape',
+        severity: 'error',
+      }),
+    ],
+    enabledTargets: [],
+    targets: null,
+  };
+}

package/src/authReadinessTargetResolution.ts

@@ -0,0 +1,9 @@
+import type { AppDeployTargetId, AppDeployTargets } from '@ankhorage/contracts/deploy';
+
+import type { DoctorDiagnostic } from './diagnostics.js';
+
+export interface AuthReadinessTargetResolution {
+  readonly diagnostics: readonly DoctorDiagnostic[];
+  readonly enabledTargets: readonly AppDeployTargetId[];
+  readonly targets: AppDeployTargets | null;
+}

package/src/authReadinessTargets.ts

@@ -0,0 +1,35 @@
+import { APP_DEPLOY_TARGET_IDS, isAppDeployManifest } from '@ankhorage/contracts/deploy';
+
+import { createAuthReadinessDiagnostic } from './authReadinessDiagnostic.js';
+import { resolveAuthReadinessTargetFallback } from './authReadinessTargetFallback.js';
+import type { AuthReadinessTargetResolution } from './authReadinessTargetResolution.js';
+
+export function resolveAuthReadinessTargets(
+  deploy: unknown,
+  manifestPath: string,
+): AuthReadinessTargetResolution {
+  if (!isAppDeployManifest(deploy)) {
+    return resolveAuthReadinessTargetFallback(deploy, manifestPath);
+  }
+
+  const enabledTargets = APP_DEPLOY_TARGET_IDS.filter(
+    (target) => deploy.targets[target]?.enabled === true,
+  );
+  if (enabledTargets.length > 0) {
+    return { diagnostics: [], enabledTargets, targets: deploy.targets };
+  }
+
+  return {
+    diagnostics: [
+      createAuthReadinessDiagnostic({
+        code: 'field-missing',
+        message: 'manifest.deploy.targets must enable at least one application target.',
+        path: manifestPath,
+        ruleId: 'manifest.deploy.targets.enabled',
+        severity: 'error',
+      }),
+    ],
+    enabledTargets,
+    targets: deploy.targets,
+  };
+}

package/src/authReadinessUnsupported.ts

@@ -0,0 +1,34 @@
+import type { AppDeployEnvironmentId, AppDeployTargetId } from '@ankhorage/contracts/deploy';
+
+import { createAuthReadinessDiagnostic } from './authReadinessDiagnostic.js';
+import type { DoctorDiagnostic } from './diagnostics.js';
+import type { DoctorReadiness } from './readiness.js';
+
+export function createUnsupportedAuthReadiness(input: {
+  readonly environment: AppDeployEnvironmentId;
+  readonly provider: string;
+  readonly targets: readonly AppDeployTargetId[];
+}): DoctorReadiness[] {
+  return input.targets.map((target) => ({
+    category: 'auth-oauth',
+    environment: input.environment,
+    message: 'The selected backend/provider/transport combination has no setup capability.',
+    provider: input.provider,
+    status: 'unsupported',
+    target,
+    transport: 'brokeredRedirect',
+  }));
+}
+
+export function createUnsupportedAuthDiagnostic(input: {
+  readonly message: string;
+  readonly path: string;
+}): DoctorDiagnostic {
+  return createAuthReadinessDiagnostic({
+    code: 'field-invalid',
+    message: input.message,
+    path: input.path,
+    ruleId: 'manifest.auth.oauth.setup.supported',
+    severity: 'error',
+  });
+}

package/src/authReadinessUnsupportedBackend.ts

@@ -0,0 +1,34 @@
+import type { AppDeployTargetId } from '@ankhorage/contracts/deploy';
+import { APP_DEPLOY_ENVIRONMENT_IDS } from '@ankhorage/contracts/deploy';
+
+import {
+  createUnsupportedAuthDiagnostic,
+  createUnsupportedAuthReadiness,
+} from './authReadinessUnsupported.js';
+import type { DoctorDiagnostic } from './diagnostics.js';
+import type { DoctorReadiness } from './readiness.js';
+
+export function analyzeUnsupportedAuthBackend(input: {
+  readonly enabledTargets: readonly AppDeployTargetId[];
+  readonly manifestPath: string;
+  readonly provider: string;
+}): {
+  readonly diagnostics: readonly DoctorDiagnostic[];
+  readonly readiness: readonly DoctorReadiness[];
+} {
+  return {
+    diagnostics: [
+      createUnsupportedAuthDiagnostic({
+        message: 'Configured OAuth backend has no Doctor setup resolver.',
+        path: input.manifestPath,
+      }),
+    ],
+    readiness: APP_DEPLOY_ENVIRONMENT_IDS.flatMap((environment) =>
+      createUnsupportedAuthReadiness({
+        environment,
+        provider: input.provider,
+        targets: input.enabledTargets,
+      }),
+    ),
+  };
+}

package/src/commands.ts

@@ -9,6 +9,7 @@ import {
   type DoctorDiagnostic,
 } from './diagnostics.js';
 import { DOCTOR_CAPABILITIES, DOCTOR_COMMAND_CATEGORY } from './packageMetadata.js';
+import type { DoctorReadiness } from './readiness.js';
 
 type DoctorCommandName = 'fix' | 'package' | 'repo' | 'validate';
 
@@ -289,6 +290,17 @@ function renderAnalysisReport(
     }
   }
 
+  const readiness = result.readiness ?? [];
+  lines.push('');
+  lines.push('Readiness:');
+  if (readiness.length === 0) {
+    lines.push('  none');
+  } else {
+    for (const item of readiness) {
+      lines.push(renderReadinessLine(item));
+    }
+  }
+
   if (commandName === 'fix') {
     lines.push('');
     lines.push('Planned changes:');
@@ -316,6 +328,10 @@ function renderDiagnosticLine(diagnostic: DoctorDiagnostic): string {
   return `  - ${diagnostic.severity.toUpperCase()} ${diagnostic.ruleId} (${diagnostic.code}): ${diagnostic.message}`;
 }
 
+function renderReadinessLine(item: DoctorReadiness): string {
+  return `  - ${item.target} ${item.environment} ${item.provider} ${item.transport}: ${item.status} — ${item.message}`;
+}
+
 function renderPlannedChangeLine(change: DoctorPlannedChange): string {
   return `  - ${change.ruleId} [${change.kind}]: ${change.description}`;
 }

package/src/diagnostics.ts

@@ -30,13 +30,18 @@ export type DoctorRuleId =
   | 'manifest.auth.flow.unauthorized-route.valid'
   | 'manifest.auth.flow.valid-shape'
   | 'manifest.auth.oauth.callback-route.valid'
+  | 'manifest.auth.oauth.callback-target.configured'
   | 'manifest.auth.oauth.provider.credentials-ref.required'
   | 'manifest.auth.oauth.provider.credentials-ref.valid'
   | 'manifest.auth.oauth.provider.duplicate'
   | 'manifest.auth.oauth.provider.inline-secret.disallowed'
   | 'manifest.auth.oauth.providers.valid'
+  | 'manifest.auth.oauth.setup.supported'
   | 'manifest.auth.oauth.valid-shape'
   | 'manifest.auth.valid-shape'
+  | 'manifest.deploy.targets.enabled'
+  | 'manifest.deploy.targets.legacy-web'
+  | 'manifest.deploy.valid-shape'
   | 'manifest.infra.valid-shape'
   | 'manifest.json.readable'
   | 'manifest.json.valid'

package/src/index.ts

@@ -7,6 +7,8 @@ export type {
   DoctorTargetCheck,
   DoctorTargetMode,
 } from './analysis.js';
+export { analyzeAuthReadiness, type DoctorAuthReadinessAnalysis } from './authReadinessAnalysis.js';
+export { analyzeAuthReadinessFile } from './authReadinessFileAnalysis.js';
 export {
   createDoctorRuntimeProvider,
   type CreateDoctorRuntimeProviderOptions,
@@ -37,3 +39,4 @@ export {
   DOCTOR_PACKAGE_NAME,
   DOCTOR_PACKAGE_VERSION,
 } from './packageMetadata.js';
+export type { DoctorReadiness, DoctorReadinessStatus } from './readiness.js';

package/src/manifestAnalysis.ts

@@ -10,6 +10,7 @@ import type {
   DoctorFixPlan,
   DoctorPlannedChange,
 } from './analysis.js';
+import { analyzeAuthReadinessFile } from './authReadinessFileAnalysis.js';
 import type {
   DoctorDiagnostic,
   DoctorDiagnosticCode,
@@ -52,7 +53,8 @@ export async function analyzeAppManifestTarget(
     return null;
   }
 
-  const diagnostics = await analyzeAppManifestFile(targetPath);
+  const authReadiness = await analyzeAuthReadinessFile(targetPath);
+  const diagnostics = [...(await analyzeAppManifestFile(targetPath)), ...authReadiness.diagnostics];
   const plannedChanges: DoctorPlannedChange[] = [];
   const fixPlan: DoctorFixPlan | null =
     request.mode === 'fix'
@@ -71,6 +73,7 @@ export async function analyzeAppManifestTarget(
     hasPackageJson: false,
     plannedChanges,
     profile: MANIFEST_PROFILE,
+    readiness: authReadiness.readiness,
     repoMarkers: [],
     targetPath,
   };

package/src/readiness.ts

@@ -0,0 +1,14 @@
+import type { AuthOAuthProviderId, AuthOAuthTransportId } from '@ankhorage/contracts/auth';
+import type { AppDeployEnvironmentId, AppDeployTargetId } from '@ankhorage/contracts/deploy';
+
+export type DoctorReadinessStatus = 'missing' | 'ready' | 'unsupported';
+
+export interface DoctorReadiness {
+  readonly category: 'auth-oauth';
+  readonly environment: AppDeployEnvironmentId;
+  readonly message: string;
+  readonly provider: AuthOAuthProviderId;
+  readonly status: DoctorReadinessStatus;
+  readonly target: AppDeployTargetId;
+  readonly transport: AuthOAuthTransportId;
+}