swallowkit 1.0.0-beta.2 → 1.0.0-beta.20

package/src/__tests__/init.test.ts

@@ -0,0 +1,80 @@
+import {
+  buildGeneratedProjectDependencies,
+  buildCSharpFunctionsProgramSource,
+  buildCSharpFunctionsProjectSource,
+  buildSwallowKitConfigSource,
+  injectSwallowKitNextConfig,
+} from "../cli/commands/init";
+
+describe("injectSwallowKitNextConfig", () => {
+  it("adds standalone settings without deprecated experimental options", () => {
+    const original = `import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  /* config options here */
+};
+
+export default nextConfig;
+`;
+
+    const updated = injectSwallowKitNextConfig(original, "sample-app");
+
+    expect(updated).toContain("output: 'standalone'");
+    expect(updated).toContain("transpilePackages: ['@sample-app/shared']");
+    expect(updated).toContain("serverExternalPackages: ['applicationinsights', 'diagnostic-channel-publishers']");
+    expect(updated).not.toContain("turbopackUseSystemTlsCerts");
+    expect(updated).not.toContain("experimental:");
+  });
+
+  it("supports JavaScript next.config format", () => {
+    const original = `const nextConfig = {
+  /* config options here */
+};
+
+module.exports = nextConfig;
+`;
+
+    const updated = injectSwallowKitNextConfig(original, "sample-app");
+
+    expect(updated).toContain("transpilePackages: ['@sample-app/shared']");
+    expect(updated).toContain("module.exports = nextConfig;");
+  });
+
+  it("generates a C# Program.cs compatible with the current worker packages", () => {
+    const source = buildCSharpFunctionsProgramSource();
+
+    expect(source).toContain("new HostBuilder()");
+    expect(source).toContain(".ConfigureFunctionsWorkerDefaults()");
+    expect(source).toContain("services.AddApplicationInsightsTelemetryWorkerService()");
+    expect(source).not.toContain("Microsoft.Azure.Functions.Worker.Builder");
+    expect(source).not.toContain("FunctionsApplication.CreateBuilder");
+    expect(source).not.toContain("ConfigureFunctionsApplicationInsights");
+  });
+
+  it("excludes nested generated bin and obj files from the C# Functions project", () => {
+    const source = buildCSharpFunctionsProjectSource();
+
+    expect(source).toContain('<Compile Remove="generated\\**\\bin\\**\\*.cs;generated\\**\\obj\\**\\*.cs" />');
+    expect(source).toContain('<EmbeddedResource Remove="generated\\**\\bin\\**;generated\\**\\obj\\**" />');
+    expect(source).toContain('<None Remove="generated\\**\\bin\\**;generated\\**\\obj\\**" />');
+  });
+
+  it("builds swallowkit.config.js without a local swallowkit package type import", () => {
+    const source = buildSwallowKitConfigSource("typescript");
+
+    expect(source).toContain("language: 'typescript'");
+    expect(source).toContain("baseUrl: process.env.BACKEND_FUNCTIONS_BASE_URL");
+    expect(source).not.toContain("import('swallowkit').SwallowKitConfig");
+  });
+
+  it("does not add swallowkit as a generated project dependency", () => {
+    const dependencies = buildGeneratedProjectDependencies("sample-app");
+
+    expect(dependencies).toEqual({
+      "@azure/cosmos": "^4.0.0",
+      applicationinsights: "^3.3.0",
+      "@sample-app/shared": "*",
+    });
+    expect(dependencies).not.toHaveProperty("swallowkit");
+  });
+});

package/src/__tests__/machine.test.ts

@@ -0,0 +1,212 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { runMachineCli } from "../machine";
+
+const repoRoot = process.cwd();
+
+function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf-8");
+}
+
+function createModelSource(name: string): string {
+  return `import { z } from 'zod/v4';
+
+export const ${name} = z.object({
+  id: z.string(),
+  name: z.string().min(1),
+  createdAt: z.string().optional(),
+  updatedAt: z.string().optional(),
+});
+
+export type ${name} = z.infer<typeof ${name}>;
+
+export const displayName = '${name}';
+`;
+}
+
+function createProjectFixture(rootDir: string, options: { includeGeneratedArtifacts?: boolean; forbiddenBffDependency?: boolean } = {}): void {
+  writeFile(path.join(rootDir, "package.json"), JSON.stringify({ name: "sample-app" }, null, 2));
+  writeFile(
+    path.join(rootDir, "swallowkit.config.js"),
+    `module.exports = {
+  database: {
+    connectionString: 'AccountEndpoint=https://example.local;',
+  },
+  backend: {
+    language: 'typescript',
+  },
+  api: {
+    endpoint: '/api/_swallowkit',
+  },
+};
+`
+  );
+  writeFile(path.join(rootDir, "shared", "package.json"), JSON.stringify({ name: "@sample-app/shared" }, null, 2));
+  writeFile(path.join(rootDir, "shared", "index.ts"), "export {};\n");
+  writeFile(path.join(rootDir, "shared", "models", "todo.ts"), createModelSource("Todo"));
+  fs.mkdirSync(path.join(rootDir, "node_modules"), { recursive: true });
+  fs.symlinkSync(
+    path.join(repoRoot, "node_modules", "zod"),
+    path.join(rootDir, "node_modules", "zod"),
+    "junction"
+  );
+
+  if (options.includeGeneratedArtifacts) {
+    writeFile(path.join(rootDir, "lib", "api", "call-function.ts"), "export function callFunction() {}\n");
+    writeFile(path.join(rootDir, "functions", "src", "todo.ts"), "export {};\n");
+    writeFile(path.join(rootDir, "app", "api", "todo", "route.ts"), "export async function GET() { return Response.json([]); }\n");
+    writeFile(path.join(rootDir, "app", "api", "todo", "[id]", "route.ts"), "export async function GET() { return Response.json({}); }\n");
+  }
+
+  if (options.forbiddenBffDependency) {
+    writeFile(
+      path.join(rootDir, "app", "api", "forbidden", "route.ts"),
+      "import { CosmosClient } from '@azure/cosmos';\nexport async function GET() { return Response.json({ ok: Boolean(CosmosClient) }); }\n"
+    );
+  }
+}
+
+async function runMachine(argv: string[]): Promise<{ response: any; exitCode: number }> {
+  const writes: string[] = [];
+  const originalWrite = process.stdout.write.bind(process.stdout);
+  const originalExitCode = process.exitCode;
+
+  (process.stdout.write as unknown as (chunk: string | Uint8Array) => boolean) = ((chunk: string | Uint8Array) => {
+    writes.push(typeof chunk === "string" ? chunk : Buffer.from(chunk).toString("utf-8"));
+    return true;
+  }) as typeof process.stdout.write;
+
+  process.exitCode = 0;
+
+  try {
+    await runMachineCli(argv);
+    return {
+      response: JSON.parse(writes.join("")),
+      exitCode: process.exitCode || 0,
+    };
+  } finally {
+    process.stdout.write = originalWrite;
+    process.exitCode = originalExitCode;
+  }
+}
+
+describe("machine CLI", () => {
+  const originalCwd = process.cwd();
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "swallowkit-machine-"));
+    process.chdir(tempDir);
+  });
+
+  afterEach(() => {
+    process.chdir(originalCwd);
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it("inspects SwallowKit project metadata as JSON", async () => {
+    createProjectFixture(tempDir, { includeGeneratedArtifacts: true });
+
+    const { response, exitCode } = await runMachine(["node", "swallowkit", "machine", "inspect", "project"]);
+
+    expect(exitCode).toBe(0);
+    expect(response.ok).toBe(true);
+    expect(response.command).toBe("inspect-project");
+    expect(response.data.manifest.entities[0].name).toBe("Todo");
+    expect(response.data.manifest.routes).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          name: "Todo-bff-list",
+          publicPath: "/api/todo",
+          exists: true,
+        }),
+      ])
+    );
+  });
+
+  it("validates forbidden BFF dependencies", async () => {
+    createProjectFixture(tempDir, {
+      includeGeneratedArtifacts: true,
+      forbiddenBffDependency: true,
+    });
+
+    const { response, exitCode } = await runMachine(["node", "swallowkit", "machine", "validate", "project"]);
+
+    expect(exitCode).toBe(0);
+    expect(response.ok).toBe(true);
+    expect(response.command).toBe("validate-project");
+    expect(response.data.violations).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({
+          code: "forbidden-bff-dependency",
+          severity: "error",
+        }),
+      ])
+    );
+  });
+
+  it("generates model templates through the machine interface", async () => {
+    writeFile(path.join(tempDir, "package.json"), JSON.stringify({ name: "sample-app" }, null, 2));
+    writeFile(
+      path.join(tempDir, "swallowkit.config.js"),
+      `module.exports = {
+  backend: { language: 'typescript' },
+  api: { endpoint: '/api/_swallowkit' },
+};
+`
+    );
+    fs.mkdirSync(path.join(tempDir, "node_modules"), { recursive: true });
+    fs.symlinkSync(
+      path.join(repoRoot, "node_modules", "zod"),
+      path.join(tempDir, "node_modules", "zod"),
+      "junction"
+    );
+    writeFile(path.join(tempDir, "shared", "index.ts"), "export {};\n");
+
+    const { response, exitCode } = await runMachine([
+      "node",
+      "swallowkit",
+      "machine",
+      "generate",
+      "model",
+      "Task",
+      "--overwrite",
+      "never",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(response.ok).toBe(true);
+    expect(response.command).toBe("generate-model");
+    expect(response.data.createdFiles).toContain("shared/models/task.ts");
+    expect(fs.existsSync(path.join(tempDir, ".swallowkit", "project.json"))).toBe(true);
+  });
+
+  it("generates scaffold artifacts through the machine interface", async () => {
+    createProjectFixture(tempDir);
+
+    const { response, exitCode } = await runMachine([
+      "node",
+      "swallowkit",
+      "machine",
+      "generate",
+      "scaffold",
+      "todo",
+      "--api-only",
+    ]);
+
+    expect(exitCode).toBe(0);
+    expect(response.ok).toBe(true);
+    expect(response.command).toBe("generate-scaffold");
+    expect(response.data.createdFiles).toEqual(
+      expect.arrayContaining([
+        "app/api/todo/route.ts",
+        "app/api/todo/[id]/route.ts",
+        "functions/src/todo.ts",
+        "lib/api/call-function.ts",
+      ])
+    );
+    expect(fs.existsSync(path.join(tempDir, ".swallowkit", "project.json"))).toBe(true);
+  });
+});

package/src/__tests__/mcp.test.ts

@@ -0,0 +1,56 @@
+import { buildSwallowKitToolDefinitions } from "../mcp";
+
+describe("SwallowKit MCP tool definitions", () => {
+  it("delegates inspect_project to the machine CLI", async () => {
+    const runner = jest.fn().mockResolvedValue({
+      stdout: JSON.stringify({
+        ok: true,
+        command: "inspect-project",
+        data: { manifestSource: "file" },
+      }),
+      stderr: "",
+      exitCode: 0,
+    });
+
+    const tool = buildSwallowKitToolDefinitions(runner).find((candidate) => candidate.name === "swallowkit_inspect_project");
+    expect(tool).toBeDefined();
+
+    const result = await tool!.handler({});
+    expect(runner).toHaveBeenCalledWith(["inspect", "project"]);
+    expect(JSON.parse(result.content[0].text)).toEqual({ manifestSource: "file" });
+  });
+
+  it("delegates scaffold_model with explicit args", async () => {
+    const runner = jest.fn().mockResolvedValue({
+      stdout: JSON.stringify({
+        ok: true,
+        command: "generate-scaffold",
+        data: { createdFiles: ["functions/src/todo.ts"] },
+      }),
+      stderr: "",
+      exitCode: 0,
+    });
+
+    const tool = buildSwallowKitToolDefinitions(runner).find((candidate) => candidate.name === "swallowkit_scaffold_model");
+    expect(tool).toBeDefined();
+
+    const result = await tool!.handler({
+      model: "todo",
+      functionsDir: "functions",
+      apiDir: "app/api",
+      apiOnly: true,
+    });
+
+    expect(runner).toHaveBeenCalledWith([
+      "generate",
+      "scaffold",
+      "todo",
+      "--functions-dir",
+      "functions",
+      "--api-dir",
+      "app/api",
+      "--api-only",
+    ]);
+    expect(JSON.parse(result.content[0].text)).toEqual({ createdFiles: ["functions/src/todo.ts"] });
+  });
+});

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

@@ -0,0 +1,72 @@
+import { parsePartitionKey } from "../core/scaffold/model-parser";
+
+describe("parsePartitionKey", () => {
+  it("returns default '/id' when no partitionKey export exists", () => {
+    const content = `
+import { z } from 'zod/v4';
+
+export const Todo = z.object({
+  id: z.string(),
+  title: z.string(),
+});
+export type Todo = z.infer<typeof Todo>;
+`;
+    expect(parsePartitionKey(content)).toBe("/id");
+  });
+
+  it("extracts explicit partitionKey with single quotes", () => {
+    const content = `
+import { z } from 'zod/v4';
+
+export const Order = z.object({
+  id: z.string(),
+  tenantId: z.string(),
+  items: z.array(z.string()),
+});
+export type Order = z.infer<typeof Order>;
+export const partitionKey = '/tenantId';
+`;
+    expect(parsePartitionKey(content)).toBe("/tenantId");
+  });
+
+  it("extracts explicit partitionKey with double quotes", () => {
+    const content = `
+export const User = z.object({ id: z.string(), email: z.string() });
+export const partitionKey = "/email";
+`;
+    expect(parsePartitionKey(content)).toBe("/email");
+  });
+
+  it("extracts /id as explicit partitionKey", () => {
+    const content = `
+export const Todo = z.object({ id: z.string() });
+export const partitionKey = '/id';
+`;
+    expect(parsePartitionKey(content)).toBe("/id");
+  });
+
+  it("handles nested/hierarchical partition key paths", () => {
+    const content = `
+export const partitionKey = '/address/city';
+`;
+    expect(parsePartitionKey(content)).toBe("/address/city");
+  });
+
+  it("ignores commented-out partitionKey", () => {
+    const content = `
+// export const partitionKey = '/tenantId';
+export const Todo = z.object({ id: z.string() });
+`;
+    // The regex matches inside comments too — this is acceptable since
+    // the pattern follows the same approach as parseConnectorConfig/parseAuthPolicy
+    // In practice, commented-out exports are rare in model files
+    expect(parsePartitionKey(content)).toBe("/tenantId");
+  });
+
+  it("handles extra spaces around equals sign", () => {
+    const content = `
+export const partitionKey   =   '/customerId';
+`;
+    expect(parsePartitionKey(content)).toBe("/customerId");
+  });
+});

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

@@ -0,0 +1,97 @@
+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("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");
+  });
+});