@beignet/cli 0.0.26 → 0.0.27

package/src/registry-edits.ts

@@ -94,6 +94,53 @@ export function insertAfterImports(source: string, line: string): string {
   return lines.join("\n");
 }
 
+/**
+ * Add a name to an `import { ... } from "<module>";` value import, creating
+ * the import when the module is not imported yet. Names are inserted in
+ * sorted position and single-line versus multiline formatting is preserved.
+ *
+ * Mirrors the `addNamedTypeImport` helper for value imports; type-only
+ * imports (`import type { ... }`) from the same module are left untouched.
+ */
+export function addNamedValueImport(
+  source: string,
+  name: string,
+  moduleName: string,
+): string {
+  const escapedModule = moduleName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const importPattern = new RegExp(
+    `import \\{([^}]*)\\} from "${escapedModule}";`,
+  );
+  const match = importPattern.exec(source);
+  if (!match) {
+    return insertAfterImports(
+      source,
+      `import { ${name} } from "${moduleName}";`,
+    );
+  }
+
+  const names = match[1]
+    .split(",")
+    .map((entry) => entry.trim())
+    .filter(Boolean);
+  if (names.includes(name)) return source;
+
+  const insertIndex = names.findIndex(
+    (existing) => existing.localeCompare(name) > 0,
+  );
+  if (insertIndex === -1) names.push(name);
+  else names.splice(insertIndex, 0, name);
+
+  const indent = match[1].match(/\n([\t ]+)/)?.[1] ?? "\t";
+  const replacement = match[1].includes("\n")
+    ? `import {\n${indent}${names.join(`,\n${indent}`)},\n} from "${moduleName}";`
+    : `import { ${names.join(", ")} } from "${moduleName}";`;
+
+  return `${source.slice(0, match.index)}${replacement}${source.slice(
+    match.index + match[0].length,
+  )}`;
+}
+
 /**
  * Collect every identifier referenced inside an array (or object) expression.
  */

package/src/task.ts

@@ -1,6 +1,6 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
-import type { TaskDef } from "@beignet/core/tasks";
+import type { TaskDef, TaskRunContextArgs } from "@beignet/core/tasks";
 import { createJiti } from "jiti";
 import { loadBeignetConfig, normalizePath } from "./config.js";
 
@@ -11,6 +11,7 @@ export type RunAppTaskOptions = {
   name: string;
   cwd?: string;
   input?: string | Record<string, unknown>;
+  tenant?: string;
   modulePath?: string;
 };
 
@@ -23,20 +24,15 @@ export type RunAppTaskResult = {
   cwd: string;
   modulePath: string;
   input: unknown;
+  tenant?: string;
   output: unknown;
   durationMs: number;
 };
 
-type TaskContextArgs = {
-  task: TaskDef;
-  taskName: string;
-  input: unknown;
-};
-
 type TaskModule = {
   tasks?: readonly unknown[];
-  createTaskContext?: (args: TaskContextArgs) => unknown;
-  stopTaskContext?: (ctx: unknown, args: TaskContextArgs) => unknown;
+  createTaskContext?: (args: TaskRunContextArgs) => unknown;
+  stopTaskContext?: (ctx: unknown, args: TaskRunContextArgs) => unknown;
 };
 
 /**
@@ -56,10 +52,11 @@ export async function runAppTask(
   // `beignet lint`, work without a built @beignet/core.
   const { parseTaskInput } = await import("@beignet/core/tasks");
   const parsedInput = await parseTaskInput(task, rawInput);
-  const contextArgs = {
+  const contextArgs: TaskRunContextArgs = {
     task,
     taskName: task.name,
     input: parsedInput,
+    tenant: options.tenant,
   };
   const ctx = taskModule.createTaskContext
     ? await taskModule.createTaskContext(contextArgs)
@@ -78,6 +75,7 @@ export async function runAppTask(
       cwd,
       modulePath,
       input: parsedInput,
+      ...(options.tenant !== undefined ? { tenant: options.tenant } : {}),
       output,
       durationMs: Math.round(performance.now() - startedAt),
     };

package/src/templates/agents.ts

@@ -118,9 +118,9 @@ skill-loading block.
 ## MCP server
 
 \`.mcp.json\` registers the app-local \`@beignet/cli\` bin at
-\`./node_modules/.bin/beignet mcp\`, which exposes routes/doctor/lint/make as
+\`./node_modules/.bin/beignet mcp\`, which exposes routes/doctor/lint/make/provider_add as
 structured tools named exactly: \`routes\`, \`doctor\`, \`doctor_fix\`,
-\`lint\`, \`make\`. Clients that do not read \`.mcp.json\` can use the same
+\`lint\`, \`make\`, \`provider_add\`. Clients that do not read \`.mcp.json\` can use the same
 command from the app root; use \`${cli} mcp\` only for terminal debugging.
 `;
 }

package/src/templates/server.ts

@@ -296,16 +296,18 @@ export function server(ctx: TemplateContext): string {
 \t\t},`;
 
   return `import "@beignet/core/server-only";
-import { createNextServer } from "@beignet/next";
+import { createNextServer, createNextServerLoader } from "@beignet/next";
 import { createErrorReportingHooks, createIdempotencyHooks } from "@beignet/core/server";
 import type { AppContext } from "@/app-context";
 import { appPorts } from "@/infra/app-ports";
 import { env } from "@/lib/env";
 import { appContext } from "./context";
-import { providers } from "./providers";
 import { routes } from "./routes";
 
-export const server = await createNextServer({
+export const getServer = createNextServerLoader(async () => {
+	const { providers } = await import("./providers");
+
+	return createNextServer({
 	ports: appPorts,
 	providers,
 	providerConfig: {
@@ -333,6 +335,7 @@ ${providerConfigEntries}
 			},
 		};
 	},
+	});
 });
 `;
 }
@@ -557,15 +560,11 @@ function isRecord(value: unknown): value is Record<string, unknown> {
 	return typeof value === "object" && value !== null;
 }
 `,
-  apiCatchAllRoute: `import { server } from "@/server";
-
-export const GET = server.api;
-export const HEAD = server.api;
-export const OPTIONS = server.api;
-export const PATCH = server.api;
-export const POST = server.api;
-export const PUT = server.api;
-export const DELETE = server.api;
+  apiCatchAllRoute: `import { createApiRoute } from "@beignet/next";
+import { getServer } from "@/server";
+
+export const { DELETE, GET, HEAD, OPTIONS, PATCH, POST, PUT } =
+	createApiRoute(getServer);
 `,
   healthRoute: `import { env } from "@/lib/env";
 
@@ -584,12 +583,12 @@ export function GET() {
 	);
 }
 `,
-  readyRoute: `import { createHealthHandler } from "@beignet/core/server";
+  readyRoute: `import { createHealthRoute } from "@beignet/next";
 import { env } from "@/lib/env";
-import { server } from "@/server";
+import { getServer } from "@/server";
 
-const readiness = createHealthHandler(
-	server.ports,
+export const { GET } = createHealthRoute(
+	getServer,
 	{
 		checks: {
 			database: (ports) => ports.db.checkHealth(),
@@ -598,42 +597,50 @@ const readiness = createHealthHandler(
 	},
 	env.NODE_ENV,
 );
-
-export async function GET(request: Request) {
-	const response = await readiness(request);
-
-	return Response.json(response.body, {
-		status: response.status,
-		headers: {
-			...response.headers,
-			"cache-control": "no-store",
-		},
-	});
-}
 `,
   devtoolsRoute: `import { createDevtoolsRoute } from "@beignet/devtools";
 import { env } from "@/lib/env";
-import { server } from "@/server";
+import { getServer } from "@/server";
 
-export const { GET, POST } = createDevtoolsRoute(server.ports.devtools, {
-	basePath: "/api/devtools",
-	enabled: env.DEVTOOLS_ENABLED,
-});
+export const { GET, POST } = createDevtoolsRoute(
+	async () => (await getServer()).ports.devtools,
+	{
+		basePath: "/api/devtools",
+		enabled: env.DEVTOOLS_ENABLED,
+	},
+);
 `,
   openApiRoute: `import { createOpenAPIHandler } from "@beignet/next";
 import { env } from "@/lib/env";
-import { server } from "@/server";
+import { contracts } from "@/server/routes";
 
-export const GET = createOpenAPIHandler(server.contracts, {
+export const GET = createOpenAPIHandler(contracts, {
 	title: "Beignet starter API",
 	version: "0.1.0",
 	servers: [{ url: env.APP_URL }],
 });
 `,
   authRoute: `import { toNextJsHandler } from "better-auth/next-js";
-import { auth } from "@/lib/better-auth";
 
-export const { GET, POST } = toNextJsHandler(auth);
+type AuthRouteMethod = "GET" | "POST";
+
+async function handleAuthRoute(
+	method: AuthRouteMethod,
+	request: Request,
+): Promise<Response> {
+	const { auth } = await import("@/lib/better-auth");
+	const handlers = toNextJsHandler(auth);
+
+	return handlers[method](request);
+}
+
+export function GET(request: Request): Promise<Response> {
+	return handleAuthRoute("GET", request);
+}
+
+export function POST(request: Request): Promise<Response> {
+	return handleAuthRoute("POST", request);
+}
 `,
   // API-only scaffold frontend: a minimal layout and landing page that point
   // at the contract-backed API surface, plus a typed client without React

package/src/templates/shared.ts

@@ -54,7 +54,12 @@ export const externalVersions = {
   pglite: "^0.5.2",
   pino: "^9.7.0",
   resend: "^6.14.0",
+  sentryNode: "^10.58.0",
+  nodemailer: "^8.0.5",
+  openFeatureServerSdk: "^1.22.0",
   typesPg: "^8.11.0",
+  ioredis: "^5.0.0",
+  awsSdkS3: "^3.955.0",
   upstashRateLimit: "^2.0.0",
   upstashRedis: "^1.0.0",
 };

package/src/test-helpers/generated-app.ts

@@ -0,0 +1,168 @@
+import { expect } from "bun:test";
+import { access, mkdir, symlink } from "node:fs/promises";
+import path from "node:path";
+
+/**
+ * Test helpers for typechecking and running generated apps inside the CLI
+ * test suite. Shared by make.test.ts, make-tenancy.test.ts, and
+ * make-inbox.test.ts; excluded from the published build.
+ */
+
+const repoRoot = path.resolve(import.meta.dir, "../../../..");
+
+/**
+ * Symlink the workspace and vendored dependencies a generated app needs for a
+ * real `tsc --noEmit` and `bun test` run, without a package-manager install.
+ * Pass `shell: true` for full-stack apps so the shadcn shell dependencies
+ * (icons, radix, theming) resolve too.
+ */
+export async function linkSmokeDependencies(
+  targetDir: string,
+  options: { shell?: boolean } = {},
+): Promise<void> {
+  const nodeModules = path.join(targetDir, "node_modules");
+  const scopeDir = path.join(nodeModules, "@beignet");
+  await mkdir(scopeDir, { recursive: true });
+
+  const beignetPackages = [
+    "core",
+    "devtools",
+    "next",
+    "provider-auth-better-auth",
+    "provider-db-drizzle",
+    "provider-event-bus-memory",
+    "provider-logger-pino",
+    "provider-mail-resend",
+    "provider-storage-local",
+    "react-hook-form",
+    "react-query",
+    "web",
+  ];
+
+  for (const packageName of beignetPackages) {
+    await linkDependency(
+      path.join(repoRoot, "packages", packageName),
+      path.join(scopeDir, packageName),
+    );
+  }
+
+  const externalSource = path.join(
+    repoRoot,
+    "apps/example-linear-clone/node_modules",
+  );
+  const externalPackages = [
+    "@electric-sql/pglite",
+    "@hookform/resolvers",
+    "@libsql/client",
+    "@tanstack/react-query",
+    "better-auth",
+    "@types/bun",
+    "@types/node",
+    "@types/pg",
+    "@types/react",
+    "@types/react-dom",
+    "drizzle-orm",
+    "mysql2",
+    "next",
+    "pg",
+    "pino",
+    "react",
+    "react-dom",
+    "react-hook-form",
+    "resend",
+    "typescript",
+    "zod",
+  ];
+  if (options.shell) {
+    // Full-stack apps also import the shadcn shell dependencies.
+    externalPackages.push(
+      "class-variance-authority",
+      "clsx",
+      "lucide-react",
+      "next-themes",
+      "radix-ui",
+      "tailwind-merge",
+    );
+  }
+  const externalPackageSources: Record<string, string> = {
+    "@electric-sql/pglite": path.join(
+      repoRoot,
+      "packages/provider-db-drizzle/node_modules/@electric-sql/pglite",
+    ),
+    "@libsql/client": path.join(
+      repoRoot,
+      "packages/provider-db-drizzle/node_modules/@libsql/client",
+    ),
+    "@types/pg": path.join(
+      repoRoot,
+      "packages/provider-db-drizzle/node_modules/@types/pg",
+    ),
+    "drizzle-orm": path.join(
+      repoRoot,
+      "packages/provider-db-drizzle/node_modules/drizzle-orm",
+    ),
+    mysql2: path.join(
+      repoRoot,
+      "packages/provider-db-drizzle/node_modules/mysql2",
+    ),
+    pg: path.join(repoRoot, "packages/provider-db-drizzle/node_modules/pg"),
+    "better-auth": path.join(
+      repoRoot,
+      "packages/provider-auth-better-auth/node_modules/better-auth",
+    ),
+    resend: path.join(
+      repoRoot,
+      "packages/provider-mail-resend/node_modules/resend",
+    ),
+    "next-themes": path.join(
+      repoRoot,
+      "apps/example-ehr/node_modules/next-themes",
+    ),
+  };
+
+  for (const packageName of externalPackages) {
+    await linkDependency(
+      externalPackageSources[packageName] ??
+        path.join(externalSource, packageName),
+      path.join(nodeModules, packageName),
+    );
+  }
+
+  await linkDependency(
+    path.join(
+      repoRoot,
+      "node_modules/.bun/@standard-schema+spec@1.1.0/node_modules/@standard-schema/spec",
+    ),
+    path.join(nodeModules, "@standard-schema/spec"),
+  );
+}
+
+async function linkDependency(
+  source: string,
+  destination: string,
+): Promise<void> {
+  await access(source);
+  await mkdir(path.dirname(destination), { recursive: true });
+  await symlink(source, destination);
+}
+
+/**
+ * Run a command inside a generated app and fail the test with the combined
+ * output when it exits non-zero.
+ */
+export async function expectAppCommand(
+  cwd: string,
+  command: readonly string[],
+): Promise<void> {
+  const proc = Bun.spawnSync(command, {
+    cwd,
+    env: {
+      ...process.env,
+      NEXT_TELEMETRY_DISABLED: "1",
+    },
+    stderr: "pipe",
+    stdout: "pipe",
+  });
+  const output = `${proc.stdout.toString()}${proc.stderr.toString()}`;
+  expect(proc.exitCode, output).toBe(0);
+}