@beignet/cli 0.0.21 → 0.0.23

package/src/inspect.ts

@@ -1894,6 +1894,23 @@ type ProviderPackageMetadataSource = {
   metadata: unknown;
 };
 
+const readinessRelevantProviderPackages = new Set([
+  "@beignet/provider-auth-better-auth",
+  "@beignet/provider-db-drizzle",
+  "@beignet/provider-error-reporting-sentry",
+  "@beignet/provider-flags-openfeature",
+  "@beignet/provider-jobs-bullmq",
+  "@beignet/provider-jobs-inngest",
+  "@beignet/provider-locks-redis",
+  "@beignet/provider-mail-resend",
+  "@beignet/provider-mail-smtp",
+  "@beignet/provider-payments-stripe",
+  "@beignet/provider-rate-limit-upstash",
+  "@beignet/provider-redis",
+  "@beignet/provider-search-meilisearch",
+  "@beignet/provider-storage-s3",
+]);
+
 async function inspectProductionReadiness(
   targetDir: string,
   files: string[],
@@ -2074,9 +2091,53 @@ async function inspectProductionReadiness(
     }
   }
 
+  const installedReadinessProviders = [...installedPackages].filter(
+    (packageName) => readinessRelevantProviderPackages.has(packageName),
+  );
+  if (
+    installedReadinessProviders.length > 0 &&
+    !(await hasReadinessCheck(targetDir, files, config, sourceCache))
+  ) {
+    diagnostics.push({
+      severity: "hint",
+      code: "BEIGNET_READINESS_ROUTE_MISSING",
+      file: directoryPath(config.paths.routes),
+      message: `${installedReadinessProviders.join(", ")} ${installedReadinessProviders.length === 1 ? "is" : "are"} installed, but no app-owned readiness route or dependency health checks were found. Consider exposing /api/ready with bounded dependency checks before deploying provider-backed infrastructure.`,
+    });
+  }
+
   return diagnostics;
 }
 
+async function hasReadinessCheck(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+  sourceCache: Map<string, string>,
+): Promise<boolean> {
+  const routesDir = directoryPath(config.paths.routes);
+  if (files.includes(`${routesDir}/ready/route.ts`)) return true;
+
+  for (const file of files) {
+    if (!file.endsWith(".ts") || file.endsWith(".test.ts")) continue;
+    if (!isRouteServerOrInfraFile(file, config)) continue;
+
+    const source = await readCachedSource(targetDir, file, sourceCache);
+    if (containsReadinessCheck(source)) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function containsReadinessCheck(source: string): boolean {
+  if (containsCallExpression(source, "runHealthChecks")) return true;
+  if (!containsCallExpression(source, "createHealthHandler")) return false;
+
+  return /\bchecks\s*:/.test(source) || /\.checkHealth\s*\(/.test(source);
+}
+
 async function inspectEntitlementsProductionReadiness(
   targetDir: string,
   files: string[],
@@ -4030,6 +4091,7 @@ async function inspectDatabaseLifecycleDrift(
   if (!convention.resourceGenerator) return [];
 
   const diagnostics: InspectDiagnostic[] = [];
+  const sourceCache = new Map<string, string>();
   const resources = await collectResourceNames(targetDir, files, config);
   const infrastructurePath = directoryPath(
     path.dirname(config.paths.infrastructurePorts),
@@ -4088,6 +4150,17 @@ async function inspectDatabaseLifecycleDrift(
         message: `This app has Drizzle database artifacts, but package.json does not define "${script}". Add an app-owned ${script} script so beignet db ${script.replace("db:", "")} can run the database lifecycle command.`,
       });
     }
+
+    diagnostics.push(
+      ...(await inspectDurableDrizzleTableDrift(
+        targetDir,
+        files,
+        config,
+        infrastructurePath,
+        schemaDir,
+        sourceCache,
+      )),
+    );
   }
 
   const schemaFilePath = `${infrastructurePath}/db/schema.ts`;
@@ -4244,6 +4317,199 @@ async function inspectDatabaseLifecycleDrift(
   return diagnostics;
 }
 
+type DurableDrizzleTableRequirement = {
+  capability: string;
+  defaultTableName: string;
+  code: string;
+  factoryPattern: string;
+  setupPattern?: string;
+};
+
+const durableDrizzleTableRequirements: readonly DurableDrizzleTableRequirement[] =
+  [
+    {
+      capability: "idempotency",
+      defaultTableName: "idempotency_records",
+      code: "BEIGNET_IDEMPOTENCY_TABLE_MISSING",
+      factoryPattern: "createDrizzle[A-Za-z]+IdempotencyPort",
+      setupPattern: "createDrizzle[A-Za-z]+IdempotencySetupStatements",
+    },
+    {
+      capability: "outbox",
+      defaultTableName: "outbox_messages",
+      code: "BEIGNET_OUTBOX_TABLE_MISSING",
+      factoryPattern: "createDrizzle[A-Za-z]+OutboxPort",
+      setupPattern: "createDrizzle[A-Za-z]+OutboxSetupStatements",
+    },
+    {
+      capability: "audit",
+      defaultTableName: "audit_log",
+      code: "BEIGNET_AUDIT_TABLE_MISSING",
+      factoryPattern: "createDrizzle(?:[A-Za-z]+AuditLogPort|AuditLog)",
+      setupPattern: "createDrizzle[A-Za-z]+AuditLogSetupStatements",
+    },
+  ];
+
+async function inspectDurableDrizzleTableDrift(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+  infrastructurePath: string,
+  schemaDir: string,
+  sourceCache: Map<string, string>,
+): Promise<InspectDiagnostic[]> {
+  const diagnostics: InspectDiagnostic[] = [];
+  const usageFiles = durableDrizzleUsageFiles(files, config);
+
+  for (const requirement of durableDrizzleTableRequirements) {
+    const tableNames = await configuredDurableDrizzleTableNames(
+      targetDir,
+      usageFiles,
+      requirement,
+      sourceCache,
+    );
+    if (tableNames.size === 0) continue;
+
+    for (const tableName of tableNames) {
+      if (
+        await durableDrizzleTableExists(
+          targetDir,
+          files,
+          infrastructurePath,
+          schemaDir,
+          requirement,
+          tableName,
+          sourceCache,
+        )
+      ) {
+        continue;
+      }
+
+      diagnostics.push({
+        severity: "warning",
+        code: requirement.code,
+        file: schemaDir,
+        message: `This app wires a Drizzle-backed ${requirement.capability} port, but no ${tableName} table setup was found in ${schemaDir}/, drizzle/, or app database setup files. Add the table to your Drizzle schema/migrations, call the provider setup statements, or remove the stale ${requirement.capability} wiring before deployment.`,
+      });
+    }
+  }
+
+  return diagnostics;
+}
+
+function durableDrizzleUsageFiles(
+  files: string[],
+  config: ResolvedBeignetConfig,
+): string[] {
+  return files.filter(
+    (file) =>
+      /\.(?:ts|tsx|mts|cts)$/.test(file) &&
+      !isTestSourceFile(file) &&
+      isInfraOrServerFile(file, config),
+  );
+}
+
+async function configuredDurableDrizzleTableNames(
+  targetDir: string,
+  files: string[],
+  requirement: DurableDrizzleTableRequirement,
+  sourceCache: Map<string, string>,
+): Promise<Set<string>> {
+  const tableNames = new Set<string>();
+
+  for (const file of files) {
+    const source = await readCachedSource(targetDir, file, sourceCache);
+    for (const tableName of tableNamesFromCalls(
+      source,
+      requirement.factoryPattern,
+      requirement.defaultTableName,
+    )) {
+      tableNames.add(tableName);
+    }
+  }
+
+  return tableNames;
+}
+
+async function durableDrizzleTableExists(
+  targetDir: string,
+  files: string[],
+  infrastructurePath: string,
+  schemaDir: string,
+  requirement: DurableDrizzleTableRequirement,
+  tableName: string,
+  sourceCache: Map<string, string>,
+): Promise<boolean> {
+  const schemaFiles = files.filter(
+    (file) =>
+      file.startsWith(`${schemaDir}/`) &&
+      /\.(?:ts|mts|cts)$/.test(file) &&
+      !isTestSourceFile(file),
+  );
+  for (const file of schemaFiles) {
+    const source = await readCachedSource(targetDir, file, sourceCache);
+    if (source.includes(tableName)) return true;
+  }
+
+  const setupFiles = files.filter(
+    (file) =>
+      !isTestSourceFile(file) &&
+      (file.startsWith("drizzle/") ||
+        file.startsWith(`${infrastructurePath}/db/`)) &&
+      /\.(?:ts|js|mts|mjs|cts|cjs|sql)$/.test(file),
+  );
+  for (const file of setupFiles) {
+    const source = await readCachedSource(targetDir, file, sourceCache);
+    if (sourceCreatesTable(source, tableName)) return true;
+
+    if (!requirement.setupPattern) continue;
+    if (
+      tableNamesFromCalls(
+        source,
+        requirement.setupPattern,
+        requirement.defaultTableName,
+      ).has(tableName)
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function sourceCreatesTable(source: string, tableName: string): boolean {
+  return new RegExp(
+    `\\bCREATE\\s+TABLE\\b[\\s\\S]{0,200}${escapeRegExp(tableName)}\\b`,
+    "i",
+  ).test(source);
+}
+
+function tableNamesFromCalls(
+  source: string,
+  calleePattern: string,
+  defaultTableName: string,
+): Set<string> {
+  const tableNames = new Set<string>();
+  const callPattern = new RegExp(
+    `\\b${calleePattern}\\s*\\(([\\s\\S]{0,800}?)\\)`,
+    "g",
+  );
+
+  for (const match of source.matchAll(callPattern)) {
+    const matchIndex = match.index ?? 0;
+    const prefix = source.slice(Math.max(0, matchIndex - 32), matchIndex);
+    if (/\bfunction\s+$/.test(prefix)) continue;
+
+    const argsSource = match[1] ?? "";
+    const tableName = /\btableName\s*:\s*["'`]([^"'`]+)["'`]/.exec(
+      argsSource,
+    )?.[1];
+    tableNames.add(tableName ?? defaultTableName);
+  }
+
+  return tableNames;
+}
+
 function hasRepositoryAdapterFile(
   files: string[],
   infrastructureDir: string,

package/src/lib.ts

@@ -18,7 +18,7 @@ export {
   inspectApp,
 } from "./inspect.js";
 export { formatLint, formatLintGithub, lintApp } from "./lint.js";
-export type { MakeFeatureAddon } from "./make.js";
+export type { MakeFeatureAddon, MakeFeatureRecipe } from "./make.js";
 export {
   makeAdapter,
   makeContract,
@@ -26,6 +26,7 @@ export {
   makeFactory,
   makeFeature,
   makeFeatureAddonChoices,
+  makeFeatureRecipeChoices,
   makeJob,
   makeListener,
   makeNotification,