@beignet/cli 0.0.38 → 0.0.40

package/src/inspect.ts

@@ -105,7 +105,7 @@ type InspectedCatalogErrorRef = {
 export type InspectedRoute = InspectedContract & {
   handlerFile?: string;
   handlerExport?: HttpMethod;
-  handlerSource: "next-route" | "route-local" | "missing";
+  handlerSource: "next-route" | "route-local" | "web-server" | "missing";
 };
 
 /**
@@ -132,11 +132,13 @@ export type InspectFix = {
  * Detected app convention and missing convention files.
  */
 export type InspectConvention = {
-  kind: "standard" | "next" | "custom";
+  kind: "standard" | "next" | "web" | "custom";
   nextLayout: boolean;
+  webLayout: boolean;
   resourceGenerator: boolean;
   configFile?: string;
   missingNextLayout: string[];
+  missingWebLayout: string[];
   missingResourceGenerator: string[];
 };
 
@@ -204,13 +206,12 @@ export async function inspectApp(
     : await loadBeignetConfig(targetDir, files);
   const convention = inspectConvention(files, config);
   const contracts = await readContracts(targetDir, files, config);
-  const routeFiles = files.filter(
-    (file) =>
-      file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
-      file.endsWith("/route.ts"),
+  const matchedRoutes = await inspectRouteSurface(
+    targetDir,
+    files,
+    config,
+    contracts,
   );
-  const routeExports = await readRouteExports(targetDir, routeFiles, config);
-  const matchedRoutes = matchRoutes(contracts, routeExports);
   const diagnostics = await inspectDiagnostics(
     targetDir,
     files,
@@ -246,13 +247,12 @@ export async function applyDoctorFixes(
     : await loadBeignetConfig(targetDir, files);
   const convention = inspectConvention(files, config);
   const contracts = await readContracts(targetDir, files, config);
-  const routeFiles = files.filter(
-    (file) =>
-      file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
-      file.endsWith("/route.ts"),
+  const matchedRoutes = await inspectRouteSurface(
+    targetDir,
+    files,
+    config,
+    contracts,
   );
-  const routeExports = await readRouteExports(targetDir, routeFiles, config);
-  const matchedRoutes = matchRoutes(contracts, routeExports);
   const fixes: InspectFix[] = [];
 
   const packageFix = await fixPackageScripts(targetDir, files, convention);
@@ -318,7 +318,9 @@ export function formatRoutes(result: InspectAppResult): string {
     handler:
       route.handlerSource === "missing"
         ? "missing"
-        : `${route.handlerFile ?? "unknown"}:${route.handlerExport ?? route.method}`,
+        : route.handlerSource === "web-server"
+          ? `${route.handlerFile ?? "unknown"}:registry`
+          : `${route.handlerFile ?? "unknown"}:${route.handlerExport ?? route.method}`,
   }));
 
   return table([
@@ -556,6 +558,10 @@ function inspectConvention(
     `${directoryPath(config.paths.routes)}/`,
     config.paths.server,
   ]);
+  const missingWebLayout = missingRequirements(files, [
+    `${directoryPath(config.paths.contracts)}/`,
+    config.paths.server,
+  ]);
   const missingResourceGenerator = missingRequirements(files, [
     config.paths.appContext,
     config.paths.portWiring,
@@ -564,14 +570,23 @@ function inspectConvention(
     config.paths.useCaseBuilder,
   ]);
   const nextLayout = missingNextLayout.length === 0;
+  const webLayout = missingWebLayout.length === 0;
   const resourceGenerator = missingResourceGenerator.length === 0;
 
   return {
-    kind: resourceGenerator ? "standard" : nextLayout ? "next" : "custom",
+    kind: resourceGenerator
+      ? "standard"
+      : config.framework === "web" && webLayout
+        ? "web"
+        : nextLayout
+          ? "next"
+          : "custom",
     nextLayout,
+    webLayout,
     resourceGenerator,
     configFile: config.configFile,
     missingNextLayout,
+    missingWebLayout,
     missingResourceGenerator,
   };
 }
@@ -1289,6 +1304,73 @@ function matchRoutes(
   };
 }
 
+async function inspectRouteSurface(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+  contracts: InspectedContract[],
+): Promise<MatchedRoutesResult> {
+  if (config.framework === "next") {
+    const routeFiles = files.filter(
+      (file) =>
+        file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
+        file.endsWith("/route.ts"),
+    );
+    const routeExports = await readRouteExports(targetDir, routeFiles, config);
+    return matchRoutes(contracts, routeExports);
+  }
+
+  if (!files.includes(config.paths.server)) {
+    return {
+      routes: contracts.map((contract) => ({
+        ...contract,
+        handlerSource: "missing",
+      })),
+      unmatchedRouteHandlers: [],
+    };
+  }
+
+  const serverSource = await readFile(
+    path.join(targetDir, config.paths.server),
+    "utf8",
+  );
+  const routeGroups = await readFeatureRouteGroups(targetDir, files, config);
+  const registeredGroups = await registeredRouteGroupsForServer(
+    targetDir,
+    files,
+    config,
+    serverSource,
+  );
+  const registeredContracts = contractsForRegisteredRouteGroups(
+    contracts,
+    routeGroups,
+    registeredGroups,
+  );
+  const registeredKeys = new Set(registeredContracts.map(contractKey));
+  const handlerFile =
+    routeRegistryFileFromServerSource(
+      serverSource,
+      config.paths.server,
+      files,
+    ) ?? config.paths.server;
+
+  return {
+    routes: contracts.map((contract) =>
+      registeredKeys.has(contractKey(contract))
+        ? {
+            ...contract,
+            handlerFile,
+            handlerSource: "web-server" as const,
+          }
+        : {
+            ...contract,
+            handlerSource: "missing" as const,
+          },
+    ),
+    unmatchedRouteHandlers: [],
+  };
+}
+
 function findContract(
   contracts: InspectedContract[],
   routeExport: RouteExport,
@@ -1349,28 +1431,53 @@ async function inspectDiagnostics(
   strict: boolean,
 ): Promise<InspectDiagnostic[]> {
   const diagnostics: InspectDiagnostic[] = [];
-
-  if (!convention.nextLayout) {
+  const frameworkLayout =
+    config.framework === "next" ? convention.nextLayout : convention.webLayout;
+  const missingFrameworkLayout =
+    config.framework === "next"
+      ? convention.missingNextLayout
+      : convention.missingWebLayout;
+
+  if (!frameworkLayout) {
+    const expectedLayout =
+      config.framework === "next"
+        ? `${directoryPath(config.paths.contracts)}/, ${directoryPath(config.paths.routes)}/, and ${config.paths.server}`
+        : `${directoryPath(config.paths.contracts)}/ and ${config.paths.server}`;
+    const layoutName =
+      config.framework === "next"
+        ? "standard Beignet app layout"
+        : "standard Beignet web app layout";
     diagnostics.push({
       severity: "warning",
       code: "BEIGNET_APP_LAYOUT_NOT_FOUND",
-      message: `This directory does not match the standard Beignet app layout. CLI inspection expects ${directoryPath(config.paths.contracts)}/, ${directoryPath(config.paths.routes)}/, and ${config.paths.server}. Missing: ${convention.missingNextLayout.join(", ")}. Add the missing app files or configure their paths in beignet.config.ts.`,
+      message: `This directory does not match the ${layoutName}. CLI inspection expects ${expectedLayout}. Missing: ${missingFrameworkLayout.join(", ")}. Add the missing app files or configure their paths in beignet.config.ts.`,
     });
   }
 
-  for (const route of matchedRoutes.routes) {
-    if (route.handlerSource !== "missing") continue;
-    diagnostics.push({
-      severity: "error",
-      code: "BEIGNET_ROUTE_MISSING",
-      file: route.file,
-      contract: route.exportName,
-      message: `${route.exportName} (${route.method} ${route.path}) has no matching Next route handler. Add ${methodArticle(route.method)} ${route.method} export to ${directoryPath(config.paths.routes)}/[[...path]]/route.ts or a matching route file, or remove the unused contract.`,
-    });
+  diagnostics.push(
+    ...(await inspectFrameworkAdapter(targetDir, files, config)),
+  );
+
+  if (config.framework === "next" || !convention.resourceGenerator) {
+    for (const route of matchedRoutes.routes) {
+      if (route.handlerSource !== "missing") continue;
+      diagnostics.push({
+        severity: "error",
+        code: "BEIGNET_ROUTE_MISSING",
+        file: route.file,
+        contract: route.exportName,
+        message:
+          config.framework === "next"
+            ? `${route.exportName} (${route.method} ${route.path}) has no matching Next route handler. Add ${methodArticle(route.method)} ${route.method} export to ${directoryPath(config.paths.routes)}/[[...path]]/route.ts or a matching route file, or remove the unused contract.`
+            : `${route.exportName} (${route.method} ${route.path}) is not registered in the route surface passed to createFetchServer(...). Register the contract through defineRoutes(...) or remove the unused contract.`,
+      });
+    }
   }
 
-  for (const routeHandler of matchedRoutes.unmatchedRouteHandlers) {
-    diagnostics.push(unmatchedRouteDiagnostic(routeHandler));
+  if (config.framework === "next") {
+    for (const routeHandler of matchedRoutes.unmatchedRouteHandlers) {
+      diagnostics.push(unmatchedRouteDiagnostic(routeHandler));
+    }
   }
 
   diagnostics.push(
@@ -1460,6 +1567,39 @@ async function inspectDiagnostics(
   return dedupeDiagnostics(diagnostics);
 }
 
+async function inspectFrameworkAdapter(
+  targetDir: string,
+  files: string[],
+  config: ResolvedBeignetConfig,
+): Promise<InspectDiagnostic[]> {
+  if (!files.includes(config.paths.server)) return [];
+
+  const source = await readFile(
+    path.join(targetDir, config.paths.server),
+    "utf8",
+  );
+  const expectedFactory =
+    config.framework === "next" ? "createNextServer" : "createFetchServer";
+  const otherFactory =
+    config.framework === "next" ? "createFetchServer" : "createNextServer";
+
+  if (
+    containsCallExpression(source, expectedFactory) ||
+    !containsCallExpression(source, otherFactory)
+  ) {
+    return [];
+  }
+
+  return [
+    {
+      severity: "error",
+      code: "BEIGNET_FRAMEWORK_MISMATCH",
+      file: config.paths.server,
+      message: `${config.configFile ?? "beignet.config.*"} selects framework: "${config.framework}", but ${config.paths.server} calls ${otherFactory}(...). Use ${expectedFactory}(...) or update the configured framework profile.`,
+    },
+  ];
+}
+
 async function inspectCanonicalConformance(
   targetDir: string,
   files: string[],
@@ -1626,11 +1766,13 @@ async function inspectCanonicalConformance(
     }
 
     if (!importsAppContext(serverSource, config.paths.server, config, files)) {
+      const serverFactory =
+        config.framework === "next" ? "createNextServer" : "createFetchServer";
       diagnostics.push({
         severity: "warning",
         code: "BEIGNET_SERVER_APP_CONTEXT",
         file: config.paths.server,
-        message: `${config.paths.server} should import type { AppContext } from ${config.paths.appContext} and thread that context through createNextServer and hooks.`,
+        message: `${config.paths.server} should import type { AppContext } from ${config.paths.appContext} and thread that context through ${serverFactory} and hooks.`,
       });
     }
 
@@ -2115,7 +2257,13 @@ async function inspectProductionReadiness(
     if (
       isFeatureUploadDefinition(file, config) &&
       containsCallExpression(source, "defineUpload") &&
-      !/\bmaxSizeBytes\s*:/.test(source)
+      !(await uploadHasExplicitSizeLimit(
+        targetDir,
+        file,
+        source,
+        files,
+        sourceCache,
+      ))
     ) {
       diagnostics.push({
         severity: "warning",
@@ -2327,7 +2475,7 @@ async function inspectProductionReadiness(
   }
 
   if (installedPackages.has("@beignet/provider-auth-better-auth")) {
-    if (!hasBetterAuthRoute(files, config)) {
+    if (config.framework === "next" && !hasBetterAuthRoute(files, config)) {
       diagnostics.push({
         severity: "warning",
         code: "BEIGNET_AUTH_ROUTE_MISSING",
@@ -2373,6 +2521,100 @@ async function inspectProductionReadiness(
   return diagnostics;
 }
 
+async function uploadHasExplicitSizeLimit(
+  targetDir: string,
+  file: string,
+  source: string,
+  files: string[],
+  sourceCache: Map<string, string>,
+): Promise<boolean> {
+  if (/\bmaxSizeBytes\s*:/.test(source)) return true;
+
+  const fileReference = source.match(
+    /\bfile\s*:\s*([A-Za-z_$][A-Za-z0-9_$]*)\b/,
+  )?.[1];
+  if (!fileReference) return false;
+
+  const importPattern = /import\s*\{([\s\S]*?)\}\s*from\s*["']([^"']+)["']/g;
+  for (const match of source.matchAll(importPattern)) {
+    const moduleName = match[2];
+    if (!moduleName?.startsWith(".")) continue;
+
+    const importedName = importedNameForLocalBinding(
+      match[1] ?? "",
+      fileReference,
+    );
+    if (!importedName) continue;
+
+    const importedFile = resolveLocalTypeScriptModule(file, moduleName, files);
+    if (!importedFile) continue;
+
+    const importedSource = await readCachedSource(
+      targetDir,
+      importedFile,
+      sourceCache,
+    );
+    if (
+      exportedObjectHasProperty(importedSource, importedName, "maxSizeBytes")
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function importedNameForLocalBinding(
+  importList: string,
+  localName: string,
+): string | undefined {
+  for (const specifier of importList.split(",")) {
+    const [importedName, aliasedLocalName] = specifier
+      .trim()
+      .replace(/^type\s+/, "")
+      .split(/\s+as\s+/);
+    if (!importedName) continue;
+    if ((aliasedLocalName ?? importedName) === localName) return importedName;
+  }
+
+  return undefined;
+}
+
+function exportedObjectHasProperty(
+  source: string,
+  exportName: string,
+  propertyName: string,
+): boolean {
+  const declaration = new RegExp(
+    `\\bexport\\s+const\\s+${escapeRegExp(exportName)}\\s*=\\s*\\{`,
+  ).exec(source);
+  if (!declaration) return false;
+
+  const openIndex = source.indexOf(
+    "{",
+    declaration.index + declaration[0].length - 1,
+  );
+  const closeIndex = matchingDelimiterIndex(source, openIndex, "{", "}");
+  if (closeIndex < 0) return false;
+
+  const initializer = source.slice(openIndex, closeIndex + 1);
+  return new RegExp(`\\b${escapeRegExp(propertyName)}\\s*:`).test(initializer);
+}
+
+function resolveLocalTypeScriptModule(
+  importer: string,
+  moduleName: string,
+  files: string[],
+): string | undefined {
+  const base = normalizePath(
+    path.posix.normalize(
+      path.posix.join(path.posix.dirname(importer), moduleName),
+    ),
+  );
+  const candidates = [base, `${base}.ts`, `${base}.tsx`, `${base}/index.ts`];
+  return candidates.find((candidate) => files.includes(candidate));
+}
+
 async function hasReadinessCheck(
   targetDir: string,
   files: string[],
@@ -2489,7 +2731,10 @@ async function inspectPaymentsProductionReadiness(
     });
   }
 
-  if (!(await hasPaymentWebhookRoute(targetDir, files, config, sourceCache))) {
+  if (
+    config.framework === "next" &&
+    !(await hasPaymentWebhookRoute(targetDir, files, config, sourceCache))
+  ) {
     diagnostics.push({
       severity: "warning",
       code: "BEIGNET_PAYMENTS_WEBHOOK_ROUTE_MISSING",
@@ -4160,6 +4405,7 @@ async function inspectServerlessFootguns(
     const source = await readFile(path.join(targetDir, file), "utf8");
 
     if (
+      config.framework === "next" &&
       convention.resourceGenerator &&
       isNextRouteFile(file, config) &&
       importsEagerServer(source, file, files, config)
@@ -6361,15 +6607,19 @@ async function registeredRouteGroupsForServer(
   serverSource: string,
 ): Promise<Set<string>> {
   const registeredGroups = registeredRouteGroups(serverSource);
-  const imports = parseNamedImports(serverSource, config, config.paths.server);
+  const imports = parseNamedImportSources(serverSource);
 
   for (const identifier of routeOptionIdentifiers(serverSource)) {
     const imported = imports.get(identifier);
-    if (!imported?.contractFile || !files.includes(imported.contractFile)) {
-      continue;
-    }
+    if (!imported) continue;
+    const importedFile = sourceFileFromImport(
+      imported.sourcePath,
+      config.paths.server,
+      files,
+    );
+    if (!importedFile || !files.includes(importedFile)) continue;
 
-    const source = await readFile(path.join(targetDir, imported.contractFile), {
+    const source = await readFile(path.join(targetDir, importedFile), {
       encoding: "utf8",
     });
     for (const routeGroup of registeredRouteGroups(source)) {
@@ -7358,6 +7608,7 @@ async function inspectResourceSlices(
       );
     }
     if (
+      config.framework === "next" &&
       !hasRequirement(files, routeFile) &&
       !hasRequirement(files, catchAllRouteFile)
     ) {

package/src/lib.ts

@@ -43,4 +43,4 @@ export {
 export { runOutboxDrain } from "./outbox.js";
 export { runAppSchedule } from "./schedule.js";
 export { runAppTask } from "./task.js";
-export type { IntegrationName } from "./templates/index.js";
+export type { StarterProviderName } from "./templates/index.js";

package/src/make/inbox.ts

@@ -160,7 +160,7 @@ export async function makeInbox(
     .map((file) => file.path);
   const files = generatedFiles.map((file) => file.path);
   const dryRun = Boolean(options.dryRun);
-  const inboxSeedNames = seedNames("inbox/demo-inbox");
+  const inboxSeedNames = seedNames("inbox.demo-inbox");
   const seedScript = { "db:seed": `tsx ${seedEntrypointPath(config)}` };
 
   const recordSeedEntrypoint = (result: "created" | "updated" | "skipped") => {
@@ -248,8 +248,8 @@ export async function updateInboxWiring(
     await updatePortsIndex(targetDir, inboxNames, config, {
       ...options,
       generationOptions: {
-        auth: false,
-        tenant: false,
+        authorization: false,
+        tenantScoped: false,
         events: false,
         softDelete: false,
       },

package/src/make/payments.ts

@@ -6,6 +6,7 @@ import {
   type ResolvedBeignetConfig,
   resolveConfig,
 } from "../config.js";
+import { assertNextFramework } from "../framework.js";
 import { appendToNamedArray, insertAfterImports } from "../registry-edits.js";
 import { testSupportTemplateFiles } from "../templates/testing.js";
 import {
@@ -71,6 +72,12 @@ export async function makePayments(
     ? resolveConfig(options.config)
     : await loadBeignetConfig(targetDir);
 
+  assertNextFramework(
+    config,
+    "beignet make payments",
+    "Next.js App Router billing and webhook handlers",
+  );
+
   await assertStandardApp(targetDir, config);
 
   const persistence = await detectResourcePersistence(targetDir, config);
@@ -93,7 +100,7 @@ export async function makePayments(
     force: Boolean(options.force),
   });
   const billingNames = resourceNames("billing");
-  const billingSeedNames = seedNames("billing/demo-billing-account");
+  const billingSeedNames = seedNames("billing.demo-billing-account");
   const plannedBillingUpdates = await updatePaymentsWiring(
     targetDir,
     billingNames,
@@ -241,8 +248,8 @@ export async function updatePaymentsWiring(
     await updatePortsIndex(targetDir, billingNames, config, {
       ...options,
       generationOptions: {
-        auth: false,
-        tenant: false,
+        authorization: false,
+        tenantScoped: false,
         events: false,
         softDelete: false,
       },

package/src/make/shared.ts

@@ -45,8 +45,8 @@ export type ResourceNames = {
 export type ResourceGenerationMode = "feature" | "resource";
 
 export type ResourceGenerationOptions = {
-  auth: boolean;
-  tenant: boolean;
+  authorization: boolean;
+  tenantScoped: boolean;
   events: boolean;
   softDelete: boolean;
 };
@@ -220,6 +220,13 @@ export type UploadNames = FeatureArtifactNames & {
   uploadExportName: string;
   metadataSchemaName: string;
   metadataTypeName: string;
+  fileConstraintsExportName: string;
+  manifestExportName: string;
+  manifestFileName: string;
+  reactUploadsExportName: string;
+  clientFileName: string;
+  componentExportName: string;
+  componentFileName: string;
 };
 
 export type FeatureUiNames = ResourceNames & {
@@ -502,7 +509,7 @@ export function wireListenersProviderSource(
  *
  * Each wiring is independent and skipped silently when its port key already
  * appears in the ports file, so apps that wired their own adapter (or scaffolds
- * whose integrations already contribute the port) are left untouched. All
+ * whose providers already contribute the port) are left untouched. All
  * anchors are computed before any file is written; an anchor miss aborts with a
  * copy-pasteable manual instruction so the generator never leaves partial
  * wiring behind. Callers validate anchors with `dryRun: true` before writing
@@ -529,7 +536,7 @@ export async function wirePortProviders(
   }
 
   // A port key that already appears in the ports file means the app wired its
-  // own adapter or an integration already contributes the port.
+  // own adapter or a provider already contributes the port.
   const active = wirings.filter(
     (wiring) => !new RegExp(`\\b${wiring.portKey}\\b`).test(portsOriginal),
   );
@@ -1179,7 +1186,7 @@ export async function updatePortsIndex(
     next = insertAfterImports(next, importLine);
   }
 
-  if (options.generationOptions?.auth) {
+  if (options.generationOptions?.authorization) {
     const policyPath = path.join(
       config.paths.features,
       names.pluralKebab,
@@ -2911,13 +2918,12 @@ export function artifactNameParts(
 ): [string, string] {
   const parts = input
     .trim()
-    .split("/")
-    .map((part) => part.trim())
-    .filter(Boolean);
+    .split(".")
+    .map((part) => part.trim());
 
-  if (parts.length !== 2) {
+  if (parts.length !== 2 || parts.some((part) => part.length === 0)) {
     throw new Error(
-      `${label} name must use feature/name format, for example posts/published.`,
+      `${label} name must use feature.name format, for example posts.published.`,
     );
   }