swallowkit 1.0.0-beta.6 → 1.0.0-beta.60

package/src/__tests__/model-parser.test.ts

@@ -0,0 +1,81 @@
+import * as fs from "fs";
+import * as path from "path";
+import { parseModelFile } from "../core/scaffold/model-parser";
+
+describe("parseModelFile", () => {
+  it("preserves array and enum metadata for schemas with defaults", async () => {
+    const tempDir = fs.mkdtempSync(path.join(process.cwd(), ".tmp-model-parser-"));
+    const modelPath = path.join(tempDir, "product.ts");
+
+    try {
+      fs.writeFileSync(
+        modelPath,
+        `import { z } from 'zod/v4';
+
+export const Product = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  price: z.number().min(0),
+  tags: z.array(z.string()).default([]),
+  status: z.enum(['draft', 'active', 'archived']).default('draft'),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type Product = z.infer<typeof Product>;
+`,
+        "utf-8"
+      );
+
+      const model = await parseModelFile(modelPath);
+      expect(model.fields).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            name: "tags",
+            type: "string",
+            isArray: true,
+            isOptional: true,
+          }),
+          expect.objectContaining({
+            name: "status",
+            type: "string",
+            isArray: false,
+            isOptional: true,
+            enumValues: ["draft", "active", "archived"],
+          }),
+        ])
+      );
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  it("distinguishes optional and nullable fields", async () => {
+    const tempDir = fs.mkdtempSync(path.join(process.cwd(), ".tmp-model-parser-"));
+    const modelPath = path.join(tempDir, "coupon.ts");
+
+    try {
+      fs.writeFileSync(
+        modelPath,
+        `import { z } from 'zod/v4';
+
+export const couponSchema = z.object({
+  requiredUserId: z.string(),
+  optionalUserId: z.string().optional(),
+  nullableUserId: z.string().nullable(),
+});
+`,
+        "utf-8"
+      );
+
+      const model = await parseModelFile(modelPath);
+      expect(model.fields).toEqual(expect.arrayContaining([
+        expect.objectContaining({ name: "requiredUserId", isOptional: false, isNullable: false }),
+        expect.objectContaining({ name: "optionalUserId", isOptional: true, isNullable: false }),
+        expect.objectContaining({ name: "nullableUserId", isOptional: false, isNullable: true }),
+      ]));
+    } finally {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+});

package/src/__tests__/multi-auth.test.ts

@@ -0,0 +1,160 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { addAuthCommand } from "../cli/commands/add-auth";
+import { createUIAuthOptions } from "../cli/commands/scaffold";
+import {
+  generateBFFCallFunctionWithMultipleAuth,
+  generateNamedAuthRouterCSharp,
+  generateNamedAuthRouterPython,
+  generateNamedAuthRouterTS,
+} from "../core/scaffold/auth-generator";
+import { normalizeAuthConfig } from "../core/config";
+import { parseAuthPolicy } from "../core/scaffold/model-parser";
+import { createBasicModelInfo } from "./fixtures";
+import { generateCSharpAzureFunctionsCRUD, generateCompactAzureFunctionsCRUD, generatePythonAzureFunctionsCRUD } from "../core/scaffold/functions-generator";
+import { generateAuthLayout, generateNewPage } from "../core/scaffold/ui-generator";
+import { AuthConfig } from "../types";
+
+const namedAuthConfig: AuthConfig = {
+  schemes: {
+    admin: { provider: "swa" },
+    lineUser: { provider: "external-token" },
+  },
+  authorization: {
+    defaultPolicy: "anonymous",
+    policies: {
+      adminOnly: { schemes: ["admin"], roles: ["authenticated"] },
+      lineUserOnly: { schemes: ["lineUser"], roles: ["authenticated"] },
+    },
+  },
+};
+const auth = normalizeAuthConfig(namedAuthConfig)!;
+
+describe("named authentication routers", () => {
+  it("generates deterministic TypeScript policy routing and normalized principals", () => {
+    const code = generateNamedAuthRouterTS(auth);
+    expect(code).toContain("policy.schemes.filter");
+    expect(code).toContain("candidates.length !== 1");
+    expect(code).toContain("subject: value.userId");
+    expect(code).toContain("scheme + ':' + principal.subject");
+    expect(code).toContain("new AuthError(403");
+    expect(code).toContain("new AuthError(503");
+    expect(code).not.toContain("JWT_SECRET");
+  });
+
+  it("generates equivalent C# and Python named guards", () => {
+    const csharp = generateNamedAuthRouterCSharp(auth);
+    const python = generateNamedAuthRouterPython(auth);
+    expect(csharp).toContain("record AuthPrincipal(string Subject, string Scheme, string Issuer");
+    expect(csharp).toContain("candidates.Length != 1");
+    expect(csharp).toContain("HttpStatusCode.Forbidden");
+    expect(python).toContain('principal["scheme"] + ":" + principal["subject"]');
+    expect(python).toContain("len(candidates) != 1");
+    expect(python).toContain("AuthError(503");
+  });
+
+  it("generates valid branch structure for an SWA-only Python router", () => {
+    const swaOnly = normalizeAuthConfig({ schemes: { admin: { provider: "swa", swa: { allowedProviders: ["github"] } } }, authorization: { defaultPolicy: "anonymous", policies: { adminOnly: { schemes: ["admin"] } } } })!;
+    const python = generateNamedAuthRouterPython(swaOnly);
+    expect(python).toContain('        if PROVIDERS[scheme] == "swa":');
+    expect(python).not.toContain('        elif PROVIDERS[scheme] == "swa":');
+    expect(python).toContain("ALLOWED_PROVIDERS");
+    expect(generateNamedAuthRouterCSharp(swaOnly)).toContain("AllowedProviders[scheme]");
+  });
+
+  it("emits Array.Empty<string>() instead of untyped new[] { } for empty C# arrays (CS0826)", () => {
+    const emptyLists = normalizeAuthConfig({
+      schemes: { api: { provider: "external-token" } },
+      authorization: { defaultPolicy: "anonymous", policies: { apiOnly: { schemes: ["api"] } } },
+    })!;
+    const csharp = generateNamedAuthRouterCSharp(emptyLists);
+    expect(csharp).not.toMatch(/new\[\]\s*\{\s*\}/);
+    expect(csharp).toContain("Array.Empty<string>()");
+    // 非空のリストは従来通り new[] リテラル
+    expect(csharp).toContain('new[] { "api" }');
+  });
+
+  it("scaffolds named read/write guards for all Functions languages", () => {
+    const policy = { read: "adminOnly", write: "lineUserOnly" };
+    const model = createBasicModelInfo();
+    const ts = generateCompactAzureFunctionsCRUD(model, "@fixture/shared", policy);
+    const cs = generateCSharpAzureFunctionsCRUD(model, policy);
+    const py = generatePythonAzureFunctionsCRUD(model, policy).blueprint;
+    expect(ts).toContain("./auth/auth-router");
+    expect(ts).toContain('requireAuth(request, "adminOnly")');
+    expect(ts).toContain('requireAuth(request, "lineUserOnly")');
+    expect(cs).toContain('AuthRouter.Authorize(request, "adminOnly")');
+    expect(cs).toContain('AuthRouter.Authorize(request, "lineUserOnly")');
+    expect(py).toContain("from auth.auth_router import");
+    expect(py).toContain('require_auth(req, "adminOnly")');
+    expect(py).toContain('require_auth(req, "lineUserOnly")');
+  });
+
+  it("forwards both credential sources and the Functions host key", () => {
+    const code = generateBFFCallFunctionWithMultipleAuth();
+    expect(code).toContain("fetchHeaders.Authorization");
+    expect(code).toContain("fetchHeaders['x-ms-client-principal']");
+    expect(code).toContain("'x-functions-key'");
+    expect(code).not.toMatch(/console\.log\([^\n]*(authorization|principal|cookie)/i);
+  });
+
+  it("parses model-wide and operation-specific named policies", () => {
+    expect(parseAuthPolicy("export const authPolicy = { policy: 'adminOnly' };"))
+      .toEqual({ policy: "adminOnly" });
+    expect(parseAuthPolicy("export const authPolicy = { read: 'adminOnly', write: 'lineUserOnly' };"))
+      .toEqual({ read: "adminOnly", write: "lineUserOnly" });
+  });
+
+  it("resolves the same named auth context for the model layout and CRUD pages", () => {
+    const model = createBasicModelInfo({ name: "Product", authPolicy: { policy: "adminOnly" } });
+    const options = createUIAuthOptions(model.authPolicy!, namedAuthConfig);
+    const layout = generateAuthLayout(model, options);
+    const page = generateNewPage(model, options);
+
+    expect(options.authContextImport).toBe("@/lib/auth/schemes/admin/auth-context");
+    expect(layout).toContain("AuthProvider } from '@/lib/auth/schemes/admin/auth-context'");
+    expect(page).toContain("useAuth } from '@/lib/auth/schemes/admin/auth-context'");
+  });
+});
+
+describe("add-auth named scheme CLI", () => {
+  const originalCwd = process.cwd();
+  let root: string;
+
+  beforeEach(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-multi-auth-"));
+    fs.writeFileSync(path.join(root, "package.json"), JSON.stringify({ name: "fixture" }));
+    fs.writeFileSync(path.join(root, "swallowkit.config.json"), JSON.stringify({ backend: { language: "typescript" }, auth: { schemes: {}, authorization: { defaultPolicy: "anonymous", policies: {} } } }, null, 2));
+    process.chdir(root);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(root, { recursive: true, force: true });
+  });
+
+  it("adds two schemes without overwriting the first verifier", async () => {
+    await addAuthCommand({ scheme: "admin", provider: "swa" });
+    await addAuthCommand({ scheme: "lineUser", provider: "external-token" });
+    const verifier = path.join(root, "functions", "src", "auth", "schemes", "line-user", "verifier.ts");
+    fs.writeFileSync(verifier, "// user verifier\n", "utf-8");
+    const config = JSON.parse(fs.readFileSync(path.join(root, "swallowkit.config.json"), "utf-8"));
+    expect(config.auth.schemes.admin.provider).toBe("swa");
+    expect(config.auth.schemes.lineUser.provider).toBe("external-token");
+    await expect(addAuthCommand({ scheme: "lineUser", provider: "external-token" })).rejects.toThrow("already exists");
+    expect(fs.readFileSync(verifier, "utf-8")).toBe("// user verifier\n");
+    expect(fs.readFileSync(path.join(root, "lib", "api", "call-function.ts"), "utf-8")).toContain("x-functions-key");
+  });
+
+  it("updates a JavaScript config that already has a trailing comma", async () => {
+    fs.rmSync(path.join(root, "swallowkit.config.json"));
+    fs.writeFileSync(path.join(root, "swallowkit.config.js"), "module.exports = {\n  backend: { language: 'typescript' },\n  api: { endpoint: '/api/test' },\n};\n");
+    await addAuthCommand({ scheme: "admin", provider: "swa" });
+    const content = fs.readFileSync(path.join(root, "swallowkit.config.js"), "utf-8");
+    expect(content).not.toContain(",,");
+    const configModule = { exports: {} as Record<string, unknown> };
+    new Function("module", content)(configModule);
+    expect((configModule.exports as { auth: { schemes: { admin: { provider: string } } } }).auth.schemes.admin.provider).toBe("swa");
+  });
+});

package/src/__tests__/nextjs-generator.test.ts

@@ -0,0 +1,105 @@
+import {
+  generateBFFCallFunction,
+  generateCompactBFFRoutes,
+} from "../core/scaffold/nextjs-generator";
+import { createBasicModelInfo } from "./fixtures";
+
+describe("generateBFFCallFunction", () => {
+  it("generates call function helper code", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toMatchSnapshot();
+  });
+
+  it("includes getFunctionsBaseUrl helper", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toContain("getFunctionsBaseUrl");
+    expect(code).toContain("BACKEND_FUNCTIONS_BASE_URL");
+  });
+
+  it("includes callFunction export", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toContain("export async function callFunction");
+  });
+
+  it("uses a server-side Functions key and fails closed outside localhost", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toContain("BACKEND_FUNCTIONS_KEY");
+    expect(code).toContain("'x-functions-key'");
+    expect(code).toContain("required for non-local Functions calls");
+    expect(code).not.toContain("?code=");
+  });
+
+  it("includes z.ZodSchema typings", () => {
+    const code = generateBFFCallFunction();
+    expect(code).toContain("z.ZodSchema");
+  });
+});
+
+describe("generateCompactBFFRoutes", () => {
+  it("generates list and detail routes", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toMatchSnapshot();
+    expect(routes.detailRoute).toMatchSnapshot();
+  });
+
+  it("imports the correct schema", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain(
+      "import { todoSchema } from '@myapp/shared'"
+    );
+    expect(routes.detailRoute).toContain(
+      "import { todoSchema } from '@myapp/shared'"
+    );
+  });
+
+  it("uses correct API paths (camelCase)", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain("path: '/api/todo'");
+    expect(routes.detailRoute).toContain("/api/todo/");
+  });
+
+  it("list route has GET and POST handlers", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain("export async function GET()");
+    expect(routes.listRoute).toContain("export async function POST(");
+  });
+
+  it("detail route has GET, PUT, and DELETE handlers", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.detailRoute).toContain("export async function GET(");
+    expect(routes.detailRoute).toContain("export async function PUT(");
+    expect(routes.detailRoute).toContain("export async function DELETE(");
+  });
+
+  it("creates InputSchema that omits managed fields", () => {
+    const model = createBasicModelInfo();
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain(
+      "todoSchema.omit({ id: true, createdAt: true, updatedAt: true })"
+    );
+  });
+
+  it("handles multi-word model names", () => {
+    const model = createBasicModelInfo({
+      name: "BlogPost",
+      schemaName: "blogPostSchema",
+    });
+    const routes = generateCompactBFFRoutes(model, "@myapp/shared");
+
+    expect(routes.listRoute).toContain("path: '/api/blogPost'");
+    expect(routes.listRoute).toContain(
+      "import { blogPostSchema } from '@myapp/shared'"
+    );
+  });
+});

package/src/__tests__/openapi-generator.test.ts

@@ -0,0 +1,43 @@
+import { generateOpenApiDocument } from "../core/scaffold/openapi-generator";
+import { createBasicModelInfo } from "./fixtures";
+
+describe("generateOpenApiDocument", () => {
+  it("emits an OpenAPI document for the root model", () => {
+    const model = createBasicModelInfo();
+    const document = JSON.parse(generateOpenApiDocument([model], model));
+
+    expect(document.openapi).toBe("3.0.3");
+    expect(document.components.schemas.Todo.properties.title.type).toBe("string");
+    expect(document.paths["/api/todo"].post.requestBody.content["application/json"].schema.$ref)
+      .toBe("#/components/schemas/Todo");
+  });
+
+  it("emits nested schema references when present", () => {
+    const todo = createBasicModelInfo({
+      fields: [
+        { name: "id", type: "string", isOptional: false, isArray: false },
+        { name: "title", type: "string", isOptional: false, isArray: false },
+        {
+          name: "category",
+          type: "object",
+          isOptional: false,
+          isArray: false,
+          isNestedSchema: true,
+          nestedModelName: "Category",
+        },
+      ],
+    });
+    const category = createBasicModelInfo({
+      name: "Category",
+      schemaName: "categorySchema",
+      fields: [
+        { name: "id", type: "string", isOptional: false, isArray: false },
+        { name: "name", type: "string", isOptional: false, isArray: false },
+      ],
+    });
+
+    const document = JSON.parse(generateOpenApiDocument([todo, category], todo));
+    expect(document.components.schemas.Todo.properties.category.$ref).toBe("#/components/schemas/Category");
+    expect(document.components.schemas.Category.properties.name.type).toBe("string");
+  });
+});

package/src/__tests__/package-manager.test.ts

@@ -0,0 +1,227 @@
+import {
+  detectFromUserAgent,
+  getCommands,
+  getWorkspaceConfig,
+  getCiSetupStep,
+  getCiInstallCommand,
+  getAzurePipelinesSetup,
+  getBuildScript,
+  getSwaAppBuildCommand,
+  getFunctionsPrestart,
+  getFunctionsStartScript,
+  spawnArgs,
+} from "../utils/package-manager";
+
+describe("detectFromUserAgent", () => {
+  it("falls back to npm when pnpm is not installed", () => {
+    expect(detectFromUserAgent(() => false)).toBe("npm");
+  });
+
+  it("prefers pnpm when it is installed", () => {
+    expect(detectFromUserAgent(() => true)).toBe("pnpm");
+  });
+});
+
+describe("getCommands", () => {
+  describe("pnpm", () => {
+    const cmds = getCommands("pnpm");
+
+    it("returns correct name", () => {
+      expect(cmds.name).toBe("pnpm");
+    });
+
+    it("returns correct install command", () => {
+      expect(cmds.install).toBe("pnpm install");
+    });
+
+    it("returns correct ci command", () => {
+      expect(cmds.ci).toBe("pnpm install --frozen-lockfile");
+    });
+
+    it("returns correct add command", () => {
+      expect(cmds.add).toBe("pnpm add");
+    });
+
+    it("returns correct addDev command", () => {
+      expect(cmds.addDev).toBe("pnpm add -D");
+    });
+
+    it("returns correct exec command", () => {
+      expect(cmds.exec).toBe("pnpm exec");
+    });
+
+    it("returns correct dlx command", () => {
+      expect(cmds.dlx).toBe("pnpm dlx");
+    });
+
+    it("returns correct runFilter for workspace", () => {
+      expect(cmds.runFilter("shared")).toBe("pnpm run --filter shared");
+    });
+
+    it("returns --use-pnpm flag for create-next-app", () => {
+      expect(cmds.createNextAppFlag).toBe("--use-pnpm");
+    });
+  });
+
+  describe("npm", () => {
+    const cmds = getCommands("npm");
+
+    it("returns correct name", () => {
+      expect(cmds.name).toBe("npm");
+    });
+
+    it("returns correct install command", () => {
+      expect(cmds.install).toBe("npm install");
+    });
+
+    it("returns correct ci command", () => {
+      expect(cmds.ci).toBe("npm ci");
+    });
+
+    it("returns correct add command", () => {
+      expect(cmds.add).toBe("npm install");
+    });
+
+    it("returns correct addDev command", () => {
+      expect(cmds.addDev).toBe("npm install -D");
+    });
+
+    it("returns correct exec command", () => {
+      expect(cmds.exec).toBe("npx");
+    });
+
+    it("returns correct dlx command", () => {
+      expect(cmds.dlx).toBe("npx");
+    });
+
+    it("returns correct runFilter for workspace", () => {
+      expect(cmds.runFilter("shared")).toBe("npm run --workspace=shared");
+    });
+
+    it("returns null for create-next-app flag", () => {
+      expect(cmds.createNextAppFlag).toBeNull();
+    });
+  });
+});
+
+describe("getWorkspaceConfig", () => {
+  it("returns pnpm-workspace.yaml config for pnpm", () => {
+    const config = getWorkspaceConfig("pnpm", ["packages/*", "apps/*"]);
+    expect(config.type).toBe("file");
+    if (config.type === "file") {
+      expect(config.filename).toBe("pnpm-workspace.yaml");
+      expect(config.content).toContain("packages:");
+      expect(config.content).toContain("  - packages/*");
+      expect(config.content).toContain("  - apps/*");
+    }
+  });
+
+  it("returns packageJson config for npm", () => {
+    const config = getWorkspaceConfig("npm", ["packages/*", "apps/*"]);
+    expect(config.type).toBe("packageJson");
+    if (config.type === "packageJson") {
+      expect(config.field).toBe("workspaces");
+      expect(config.value).toEqual(["packages/*", "apps/*"]);
+    }
+  });
+});
+
+describe("getCiSetupStep", () => {
+  it("returns pnpm setup step for pnpm", () => {
+    const step = getCiSetupStep("pnpm");
+    expect(step).toContain("pnpm/action-setup");
+    expect(step).toContain("version: latest");
+  });
+
+  it("returns empty string for npm", () => {
+    expect(getCiSetupStep("npm")).toBe("");
+  });
+});
+
+describe("getSwaAppBuildCommand", () => {
+  it("returns a pnpm build command for pnpm projects", () => {
+    expect(getSwaAppBuildCommand("pnpm")).toBe("pnpm install --frozen-lockfile && pnpm run build");
+  });
+
+  it("returns an npm build command for npm projects", () => {
+    expect(getSwaAppBuildCommand("npm")).toBe("npm ci && npm run build");
+  });
+
+  it("uses npm ci for pnpm-initialized projects once an npm lockfile is generated", () => {
+    expect(getSwaAppBuildCommand("npm", "pnpm")).toBe("npm ci && npm run build");
+  });
+});
+
+describe("getCiInstallCommand", () => {
+  it("returns npm ci for npm projects", () => {
+    expect(getCiInstallCommand("npm", "npm")).toBe("npm ci");
+  });
+
+  it("returns npm ci for pnpm projects once an npm lockfile is generated", () => {
+    expect(getCiInstallCommand("npm", "pnpm")).toBe("npm ci");
+  });
+});
+
+describe("getAzurePipelinesSetup", () => {
+  it("returns corepack step for pnpm", () => {
+    const step = getAzurePipelinesSetup("pnpm");
+    expect(step).toContain("corepack enable");
+    expect(step).toContain("pnpm");
+  });
+
+  it("returns empty string for npm", () => {
+    expect(getAzurePipelinesSetup("npm")).toBe("");
+  });
+});
+
+describe("getBuildScript", () => {
+  it("uses pnpm run --filter for pnpm", () => {
+    expect(getBuildScript("pnpm")).toContain("pnpm run --filter shared build");
+    expect(getBuildScript("pnpm")).toContain("fs.cpSync");
+  });
+
+  it("uses npm run --workspace for npm", () => {
+    expect(getBuildScript("npm")).toContain("npm run --workspace=shared build");
+    expect(getBuildScript("npm")).toContain("fs.cpSync");
+  });
+});
+
+describe("getFunctionsPrestart", () => {
+  it("uses pnpm run build for pnpm", () => {
+    expect(getFunctionsPrestart("pnpm")).toBe("pnpm run build");
+  });
+
+  it("uses npm run build for npm", () => {
+    expect(getFunctionsPrestart("npm")).toBe("npm run build");
+  });
+});
+
+describe("getFunctionsStartScript", () => {
+  it("uses pnpm start for pnpm", () => {
+    expect(getFunctionsStartScript("pnpm")).toContain("pnpm start");
+  });
+
+  it("uses npm start for npm", () => {
+    expect(getFunctionsStartScript("npm")).toContain("npm start");
+  });
+
+  it("uses func start for csharp backends", () => {
+    expect(getFunctionsStartScript("pnpm", "csharp")).toBe("cd functions && func start");
+  });
+
+  it("uses func start for python backends", () => {
+    expect(getFunctionsStartScript("npm", "python")).toBe("cd functions && func start");
+  });
+});
+
+describe("spawnArgs", () => {
+  it("returns cmd and args for pnpm", () => {
+    const result = spawnArgs("pnpm", ["add", "next@latest"]);
+    expect(result).toEqual({ cmd: "pnpm", args: ["add", "next@latest"] });
+  });
+
+  it("returns cmd and args for npm", () => {
+    const result = spawnArgs("npm", ["install", "next@latest"]);
+    expect(result).toEqual({ cmd: "npm", args: ["install", "next@latest"] });
+  });
+});