@beignet/cli 0.0.52 → 0.0.53

package/dist/inspect.js

@@ -8,7 +8,9 @@ import { contractFactoryBindings, isImportedContractFactoryCall, } from "./analy
 import { canonicalFeatureLayerPath } from "./analysis/layers.js";
 import { analyzePortWiringFiles } from "./analysis/port-wiring.js";
 import { analysisSourceFileExtensions, isAnalysisSourceFile, isAnalysisSourceFileExtension, isJavaScriptSourceFile, javascriptAnalysisSourceFileExtensions, sourceFileScriptKind, stripSourceFileExtension, typescriptAnalysisSourceFileExtensions, } from "./analysis/source-files.js";
-import { exportedVariableDeclarations } from "./analysis/source-index.js";
+import { createSourceIndex, exportedVariableDeclarations, } from "./analysis/source-index.js";
+import { createAnalysisWorkspace, projectPath } from "./analysis/workspace.js";
+import { workspaceRouteContracts } from "./analysis/workspace-routes.js";
 import { createPainter } from "./ansi.js";
 import { clientDirPath, clientFormsPath, clientIndexPath, defaultBeignetConfig, directoryPath, loadBeignetConfig, normalizePath, resolveConfig, } from "./config.js";
 import { renderDatabaseSchema, resolveDatabaseSchemaDialect } from "./db.js";
@@ -24,15 +26,67 @@ import { getCliVersion } from "./version.js";
 export async function inspectApp(options = {}) {
     const targetDir = path.resolve(options.cwd ?? process.cwd());
     await assertDirectory(targetDir);
-    const files = await listFiles(targetDir);
-    const config = options.config
-        ? resolveConfig(options.config)
-        : await loadBeignetConfig(targetDir, files);
-    const convention = inspectConvention(files, config);
+    const workspace = await createAnalysisWorkspace(targetDir, {
+        config: options.config,
+    });
+    const { config } = workspace;
+    const files = workspace.projects[0].files;
     const inspectedContracts = await readContracts(targetDir, files, config);
+    for (const project of workspace.projects.slice(1)) {
+        const shared = await readContracts(project.targetDir, project.files, project.config);
+        inspectedContracts.contracts.push(...shared.contracts.map((contract) => ({
+            ...contract,
+            file: projectPath(project, contract.file),
+        })));
+        inspectedContracts.queryTransportDiagnostics.push(...shared.queryTransportDiagnostics.map((diagnostic) => ({
+            ...diagnostic,
+            ...(diagnostic.file
+                ? { file: projectPath(project, diagnostic.file) }
+                : {}),
+            ...(diagnostic.subject
+                ? {
+                    subject: {
+                        ...diagnostic.subject,
+                        file: projectPath(project, diagnostic.subject.file),
+                    },
+                }
+                : {}),
+        })));
+    }
     const { contracts } = inspectedContracts;
-    const matchedRoutes = await inspectRouteSurface(targetDir, files, config, contracts);
+    contracts.sort(compareContracts);
+    const convention = inspectConvention(files, config, contracts.length > 0 && workspace.projects.length > 1);
+    const matchedRoutes = await inspectRouteSurface(targetDir, files, config, contracts, workspace.projects.length > 1 ? createSourceIndex(workspace) : undefined);
+    let workspaceRoutesUnresolved = false;
+    if (workspace.projects.length > 1) {
+        const registration = await workspaceRouteContracts(workspace);
+        workspaceRoutesUnresolved = registration.unresolved;
+        matchedRoutes.routes = matchedRoutes.routes.map((route) => {
+            if (route.handlerSource === "route-local")
+                return route;
+            if (!registration.contracts.has(`${route.file}#${route.exportName}`))
+                return {
+                    ...route,
+                    handlerFile: undefined,
+                    handlerSource: "missing",
+                };
+            return config.framework === "web"
+                ? {
+                    ...route,
+                    handlerFile: config.paths.server,
+                    handlerSource: "web-server",
+                }
+                : route;
+        });
+    }
     const diagnostics = await inspectDiagnostics(targetDir, files, config, convention, contracts, matchedRoutes, Boolean(options.strict), inspectedContracts.queryTransportDiagnostics);
+    if (workspaceRoutesUnresolved)
+        diagnostics.push({
+            severity: "warning",
+            code: "BEIGNET_WORKSPACE_ROUTES_UNRESOLVED",
+            file: config.paths.server,
+            message: "Could not fully resolve workspace route composition. Use explicit defineRoutes arrays and defineRouteGroup bindings reachable from the server routes option.",
+        });
     return {
         schemaVersion: 1,
         targetDir,
@@ -87,7 +141,10 @@ async function buildDoctorFixPlan(options = {}) {
         : await loadBeignetConfig(targetDir, files);
     const convention = inspectConvention(files, config);
     const { contracts } = await readContracts(targetDir, files, config);
-    const matchedRoutes = await inspectRouteSurface(targetDir, files, config, contracts);
+    const sourceIndex = config.workspace.packages.length
+        ? createSourceIndex(await createAnalysisWorkspace(targetDir, { config }))
+        : undefined;
+    const matchedRoutes = await inspectRouteSurface(targetDir, files, config, contracts, sourceIndex);
     const operations = [];
     const packageFix = await planPackageScripts(targetDir, files, convention);
     if (packageFix)
@@ -441,14 +498,14 @@ async function readContracts(targetDir, files, config) {
         queryTransportDiagnostics,
     };
 }
-function inspectConvention(files, config) {
+function inspectConvention(files, config, sharedContracts = false) {
     const missingNextLayout = missingRequirements(files, [
-        `${directoryPath(config.paths.contracts)}/`,
+        ...(sharedContracts ? [] : [`${directoryPath(config.paths.contracts)}/`]),
         `${directoryPath(config.paths.routes)}/`,
         config.paths.server,
     ]);
     const missingWebLayout = missingRequirements(files, [
-        `${directoryPath(config.paths.contracts)}/`,
+        ...(sharedContracts ? [] : [`${directoryPath(config.paths.contracts)}/`]),
         config.paths.server,
     ]);
     const missingResourceGenerator = missingRequirements(files, [
@@ -930,16 +987,16 @@ function normalizeContractPath(routePath) {
     const segments = routePath.split("/").filter(Boolean);
     return segments.length === 0 ? "/" : `/${segments.join("/")}`;
 }
-async function readRouteExports(targetDir, routeFiles, files, config) {
+async function readRouteExports(targetDir, routeFiles, files, config, sourceIndex) {
     const routeExports = new Map();
     for (const file of routeFiles) {
         const routePath = nextRoutePath(file, config.paths.routes);
         const source = await readFile(path.join(targetDir, file), "utf8");
-        routeExports.set(file, parseRouteExports(source, file, routePath, files, config));
+        routeExports.set(file, await parseRouteExports(source, file, routePath, files, config, sourceIndex));
     }
     return routeExports;
 }
-function parseRouteExports(source, handlerFile, routePath, files, config) {
+async function parseRouteExports(source, handlerFile, routePath, files, config, sourceIndex) {
     const exports = [];
     const sourceFile = ts.createSourceFile(handlerFile, source, ts.ScriptTarget.Latest, true, sourceFileScriptKind(handlerFile));
     const imports = parseRouteNamedImports(sourceFile, config, handlerFile, files);
@@ -977,11 +1034,13 @@ function parseRouteExports(source, handlerFile, routePath, files, config) {
         const localName = routeLocalContractIdentifier(declaration.initializer);
         if (localName) {
             const imported = imports.get(localName);
+            const resolved = await sourceIndex?.resolveValue(handlerFile, ts.factory.createIdentifier(localName));
             exports.push({
                 method,
                 handlerFile,
-                contractRef: imported?.importedName ?? localName,
-                contractFile: imported?.contractFile,
+                contractRef: resolved?.exportName ?? imported?.importedName ?? localName,
+                contractFile: resolved?.file ?? imported?.contractFile,
+                ...(sourceIndex && !resolved ? { contractUnresolved: true } : {}),
                 source: "route-local",
             });
             continue;
@@ -1262,11 +1321,11 @@ function matchRoutes(contracts, routeExports) {
         unmatchedRouteHandlers,
     };
 }
-async function inspectRouteSurface(targetDir, files, config, contracts) {
+async function inspectRouteSurface(targetDir, files, config, contracts, sourceIndex) {
     if (config.framework === "next") {
         const routeFiles = files.filter((file) => file.startsWith(`${directoryPath(config.paths.routes)}/`) &&
             isNextRouteFile(file, config));
-        const routeExports = await readRouteExports(targetDir, routeFiles, files, config);
+        const routeExports = await readRouteExports(targetDir, routeFiles, files, config, sourceIndex);
         return matchRoutes(contracts, routeExports);
     }
     if (!files.includes(config.paths.server)) {
@@ -1303,6 +1362,8 @@ function findContract(contracts, routeExport) {
 }
 function findContracts(contracts, routeExport) {
     if (routeExport.source === "route-local") {
+        if (routeExport.contractUnresolved)
+            return [];
         const contract = contracts.find((contract) => contract.exportName === routeExport.contractRef &&
             (!routeExport.contractFile ||
                 contract.file === routeExport.contractFile ||
@@ -1402,6 +1463,7 @@ async function inspectCanonicalConformance(targetDir, files, config, convention,
         files.some((file) => file.startsWith(`${clientDir}/`)) ||
         [
             "@beignet/react-query",
+            "@beignet/react-form",
             "@beignet/react-hook-form",
             "@beignet/react-uploads",
             "@beignet/nuqs",
@@ -1438,11 +1500,12 @@ async function inspectCanonicalConformance(targetDir, files, config, convention,
             reason: `${clientIndex} should own the typed client and frontend adapter setup.`,
         });
     }
-    if (installedPackages.has("@beignet/react-hook-form") ||
+    if (installedPackages.has("@beignet/react-form") ||
+        installedPackages.has("@beignet/react-hook-form") ||
         files.includes(clientForms)) {
         requiredFiles.push({
             file: clientForms,
-            reason: `${clientForms} should own React Hook Form adapter setup when form helpers are used.`,
+            reason: `${clientForms} should own form adapter setup (createReactForm or createReactHookForm) when form helpers are used.`,
         });
     }
     for (const required of requiredFiles) {
@@ -3956,6 +4019,9 @@ async function inspectPortProviderDrift(targetDir, files, config, convention) {
     const portsSource = files.includes(config.paths.ports)
         ? await readFile(path.join(targetDir, config.paths.ports), "utf8")
         : "";
+    const sharedPorts = config.workspace.packages.length > 0
+        ? await analyzePortWiringFiles({ targetDir, files, config })
+        : undefined;
     const packageJson = files.includes("package.json")
         ? await readPackageJson(targetDir, files)
         : undefined;
@@ -3973,7 +4039,9 @@ async function inspectPortProviderDrift(targetDir, files, config, convention) {
     for (const expected of providerPortRequirements) {
         if (!installedPackages.has(expected.packageName))
             continue;
-        if (portsSource.includes(`${expected.portName}:`))
+        if (sharedPorts
+            ? sharedPorts.declared.has(expected.portName)
+            : portsSource.includes(`${expected.portName}:`))
             continue;
         diagnostics.push({
             severity: "warning",