swallowkit 1.0.0-beta.11 → 1.0.0-beta.13

package/src/__tests__/config.test.ts

@@ -61,6 +61,147 @@ describe("validateConfig", () => {
     // database is undefined → no connectionString check triggered
     expect(result.errors.filter((e) => e.includes("endpoint"))).toHaveLength(0);
   });
+
+  // ─── Connector Validation ───────────────────────────────────
+
+  it("validates valid RDB connector config", () => {
+    const config: SwallowKitConfig = {
+      connectors: {
+        mysql: {
+          type: "rdb",
+          provider: "mysql",
+          connectionEnvVar: "MYSQL_CONNECTION_STRING",
+        },
+      },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("validates valid API connector config", () => {
+    const config: SwallowKitConfig = {
+      connectors: {
+        backlog: {
+          type: "api",
+          baseUrlEnvVar: "BACKLOG_API_BASE_URL",
+          auth: {
+            type: "apiKey",
+            envVar: "BACKLOG_API_KEY",
+            placement: "query",
+            paramName: "apiKey",
+          },
+        },
+      },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("returns error for invalid connector type", () => {
+    const config = {
+      connectors: {
+        bad: {
+          type: "graphql",
+          baseUrlEnvVar: "GRAPHQL_URL",
+        },
+      },
+    } as unknown as SwallowKitConfig;
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors[0]).toContain("Connector 'bad'");
+    expect(result.errors[0]).toContain("type must be one of");
+  });
+
+  it("returns error for RDB connector without provider", () => {
+    const config: SwallowKitConfig = {
+      connectors: {
+        mydb: {
+          type: "rdb",
+          provider: "" as any,
+          connectionEnvVar: "CONN",
+        },
+      },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toEqual(
+      expect.arrayContaining([expect.stringContaining("provider must be one of")])
+    );
+  });
+
+  it("returns error for RDB connector without connectionEnvVar", () => {
+    const config: SwallowKitConfig = {
+      connectors: {
+        mydb: {
+          type: "rdb",
+          provider: "mysql",
+          connectionEnvVar: "",
+        },
+      },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toEqual(
+      expect.arrayContaining([expect.stringContaining("connectionEnvVar is required")])
+    );
+  });
+
+  it("returns error for API connector without baseUrlEnvVar", () => {
+    const config: SwallowKitConfig = {
+      connectors: {
+        ext: {
+          type: "api",
+          baseUrlEnvVar: "",
+        },
+      },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toEqual(
+      expect.arrayContaining([expect.stringContaining("baseUrlEnvVar is required")])
+    );
+  });
+
+  it("returns error for API connector with invalid auth type", () => {
+    const config: SwallowKitConfig = {
+      connectors: {
+        ext: {
+          type: "api",
+          baseUrlEnvVar: "EXT_URL",
+          auth: {
+            type: "saml" as any,
+            envVar: "KEY",
+          },
+        },
+      },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toEqual(
+      expect.arrayContaining([expect.stringContaining("auth.type must be one of")])
+    );
+  });
+
+  it("validates multiple connectors at once", () => {
+    const config: SwallowKitConfig = {
+      connectors: {
+        mysql: {
+          type: "rdb",
+          provider: "mysql",
+          connectionEnvVar: "MYSQL_CONN",
+        },
+        backlog: {
+          type: "api",
+          baseUrlEnvVar: "BACKLOG_URL",
+        },
+      },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
 });
 
 describe("loadConfigFromEnv", () => {

package/src/__tests__/connector-functions-generator.test.ts

@@ -0,0 +1,288 @@
+/**
+ * コネクタ Functions ジェネレーターのテスト
+ */
+
+import {
+  generateRdbConnectorFunctionTS,
+  generateApiConnectorFunctionTS,
+  generateRdbConnectorFunctionCSharp,
+  generateApiConnectorFunctionCSharp,
+  generateRdbConnectorFunctionPython,
+  generateApiConnectorFunctionPython,
+  isReadOnlyConnector,
+} from "../core/scaffold/connector-functions-generator";
+import {
+  createRdbConnectorModelInfo,
+  createApiConnectorModelInfo,
+} from "./fixtures";
+import {
+  RdbConnectorConfig,
+  ApiConnectorConfig,
+  RdbModelConnectorConfig,
+  ApiModelConnectorConfig,
+} from "../types";
+
+// ─── Shared Test Data ────────────────────────────────────────
+
+const mysqlConnector: RdbConnectorConfig = {
+  type: "rdb",
+  provider: "mysql",
+  connectionEnvVar: "MYSQL_CONNECTION_STRING",
+};
+
+const postgresConnector: RdbConnectorConfig = {
+  type: "rdb",
+  provider: "postgres",
+  connectionEnvVar: "PG_CONNECTION_STRING",
+};
+
+const sqlserverConnector: RdbConnectorConfig = {
+  type: "rdb",
+  provider: "sqlserver",
+  connectionEnvVar: "MSSQL_CONNECTION_STRING",
+};
+
+const backlogConnector: ApiConnectorConfig = {
+  type: "api",
+  baseUrlEnvVar: "BACKLOG_API_BASE_URL",
+  auth: {
+    type: "apiKey",
+    envVar: "BACKLOG_API_KEY",
+    placement: "query",
+    paramName: "apiKey",
+  },
+};
+
+const bearerConnector: ApiConnectorConfig = {
+  type: "api",
+  baseUrlEnvVar: "EXT_API_BASE_URL",
+  auth: {
+    type: "bearer",
+    envVar: "EXT_API_TOKEN",
+  },
+};
+
+// ─── isReadOnlyConnector ────────────────────────────────────
+
+describe("isReadOnlyConnector", () => {
+  it("returns true when only read operations are present", () => {
+    expect(isReadOnlyConnector(["getAll", "getById"])).toBe(true);
+    expect(isReadOnlyConnector(["getAll"])).toBe(true);
+    expect(isReadOnlyConnector(["getById"])).toBe(true);
+  });
+
+  it("returns false when write operations are present", () => {
+    expect(isReadOnlyConnector(["getAll", "getById", "create"])).toBe(false);
+    expect(isReadOnlyConnector(["getAll", "update"])).toBe(false);
+    expect(isReadOnlyConnector(["getAll", "delete"])).toBe(false);
+  });
+});
+
+// ─── TypeScript RDB Connector ───────────────────────────────
+
+describe("generateRdbConnectorFunctionTS", () => {
+  const model = createRdbConnectorModelInfo();
+  const modelConnector = model.connectorConfig as RdbModelConnectorConfig;
+
+  it("generates MySQL read-only functions", () => {
+    const code = generateRdbConnectorFunctionTS(model, "@myapp/shared", mysqlConnector, modelConnector);
+    expect(code).toContain("import mysql from 'mysql2/promise'");
+    expect(code).toContain("MYSQL_CONNECTION_STRING");
+    expect(code).toContain("SELECT * FROM users");
+    expect(code).toContain("user-get-all");
+    expect(code).toContain("user-get-by-id");
+    // Should NOT contain write operations
+    expect(code).not.toContain("user-create");
+    expect(code).not.toContain("user-update");
+    expect(code).not.toContain("user-delete");
+  });
+
+  it("generates PostgreSQL functions", () => {
+    const code = generateRdbConnectorFunctionTS(model, "@myapp/shared", postgresConnector, modelConnector);
+    expect(code).toContain("import pg from 'pg'");
+    expect(code).toContain("PG_CONNECTION_STRING");
+  });
+
+  it("generates SQL Server functions", () => {
+    const code = generateRdbConnectorFunctionTS(model, "@myapp/shared", sqlserverConnector, modelConnector);
+    expect(code).toContain("import sql from 'mssql'");
+    expect(code).toContain("MSSQL_CONNECTION_STRING");
+  });
+
+  it("uses correct table and id column", () => {
+    const code = generateRdbConnectorFunctionTS(model, "@myapp/shared", mysqlConnector, modelConnector);
+    expect(code).toContain("FROM users");
+    expect(code).toContain("WHERE id = ");
+  });
+
+  it("imports schema from shared package", () => {
+    const code = generateRdbConnectorFunctionTS(model, "@myapp/shared", mysqlConnector, modelConnector);
+    expect(code).toContain("from '@myapp/shared'");
+  });
+});
+
+// ─── TypeScript API Connector ───────────────────────────────
+
+describe("generateApiConnectorFunctionTS", () => {
+  const model = createApiConnectorModelInfo();
+  const modelConnector = model.connectorConfig as ApiModelConnectorConfig;
+
+  it("generates read-write functions with apiKey auth", () => {
+    const code = generateApiConnectorFunctionTS(model, "@myapp/shared", backlogConnector, modelConnector);
+    expect(code).toContain("BACKLOG_API_BASE_URL");
+    expect(code).toContain("backlogIssue-get-all");
+    expect(code).toContain("backlogIssue-get-by-id");
+    expect(code).toContain("backlogIssue-create");
+    expect(code).toContain("backlogIssue-update");
+  });
+
+  it("generates bearer auth helper", () => {
+    const code = generateApiConnectorFunctionTS(model, "@myapp/shared", bearerConnector, modelConnector);
+    expect(code).toContain("Authorization");
+    expect(code).toContain("Bearer");
+    expect(code).toContain("EXT_API_TOKEN");
+  });
+
+  it("does not generate delete when not in operations", () => {
+    const code = generateApiConnectorFunctionTS(model, "@myapp/shared", backlogConnector, modelConnector);
+    expect(code).not.toContain("backlogIssue-delete");
+  });
+
+  it("generates read-only API connector when operations are limited", () => {
+    const readOnlyModel = createApiConnectorModelInfo({
+      connectorConfig: {
+        connector: "backlog",
+        operations: ["getAll", "getById"],
+        endpoints: {
+          getAll: "GET /issues",
+          getById: "GET /issues/{id}",
+        },
+      },
+    });
+    const readOnlyConnector = readOnlyModel.connectorConfig as ApiModelConnectorConfig;
+    const code = generateApiConnectorFunctionTS(readOnlyModel, "@myapp/shared", backlogConnector, readOnlyConnector);
+    expect(code).toContain("backlogIssue-get-all");
+    expect(code).not.toContain("backlogIssue-create");
+    expect(code).not.toContain("backlogIssue-update");
+  });
+});
+
+// ─── C# RDB Connector ──────────────────────────────────────
+
+describe("generateRdbConnectorFunctionCSharp", () => {
+  const model = createRdbConnectorModelInfo();
+  const modelConnector = model.connectorConfig as RdbModelConnectorConfig;
+
+  it("generates MySQL C# connector functions", () => {
+    const code = generateRdbConnectorFunctionCSharp(model, mysqlConnector, modelConnector);
+    expect(code).toContain("MySqlConnection");
+    expect(code).toContain("MYSQL_CONNECTION_STRING");
+    expect(code).toContain("UserConnectorFunctions");
+    expect(code).toContain('[Function("userGetAll")]');
+    expect(code).toContain('[Function("userGetById")]');
+    // Should NOT contain write operations
+    expect(code).not.toContain('[Function("userCreate")]');
+    expect(code).not.toContain('[Function("userUpdate")]');
+  });
+
+  it("generates PostgreSQL C# connector", () => {
+    const code = generateRdbConnectorFunctionCSharp(model, postgresConnector, modelConnector);
+    expect(code).toContain("NpgsqlConnection");
+    expect(code).toContain("PG_CONNECTION_STRING");
+  });
+
+  it("generates SQL Server C# connector", () => {
+    const code = generateRdbConnectorFunctionCSharp(model, sqlserverConnector, modelConnector);
+    expect(code).toContain("SqlConnection");
+    expect(code).toContain("MSSQL_CONNECTION_STRING");
+  });
+
+  it("uses Route attribute with correct paths", () => {
+    const code = generateRdbConnectorFunctionCSharp(model, mysqlConnector, modelConnector);
+    expect(code).toContain('Route = "user"');
+    expect(code).toContain('Route = "user/{id}"');
+  });
+});
+
+// ─── C# API Connector ──────────────────────────────────────
+
+describe("generateApiConnectorFunctionCSharp", () => {
+  const model = createApiConnectorModelInfo();
+  const modelConnector = model.connectorConfig as ApiModelConnectorConfig;
+
+  it("generates API connector with CRUD operations", () => {
+    const code = generateApiConnectorFunctionCSharp(model, backlogConnector, modelConnector);
+    expect(code).toContain("BacklogIssueConnectorFunctions");
+    expect(code).toContain("HttpClient");
+    expect(code).toContain("BACKLOG_API_BASE_URL");
+    expect(code).toContain('[Function("backlogIssueGetAll")]');
+    expect(code).toContain('[Function("backlogIssueGetById")]');
+    expect(code).toContain('[Function("backlogIssueCreate")]');
+    expect(code).toContain('[Function("backlogIssueUpdate")]');
+  });
+
+  it("includes auth configuration for apiKey", () => {
+    const code = generateApiConnectorFunctionCSharp(model, backlogConnector, modelConnector);
+    expect(code).toContain("BACKLOG_API_KEY");
+    expect(code).toContain("apiKey");
+  });
+
+  it("generates bearer auth for C#", () => {
+    const code = generateApiConnectorFunctionCSharp(model, bearerConnector, modelConnector);
+    expect(code).toContain("Authorization");
+    expect(code).toContain("Bearer");
+    expect(code).toContain("EXT_API_TOKEN");
+  });
+});
+
+// ─── Python RDB Connector ───────────────────────────────────
+
+describe("generateRdbConnectorFunctionPython", () => {
+  const model = createRdbConnectorModelInfo();
+  const modelConnector = model.connectorConfig as RdbModelConnectorConfig;
+
+  it("generates MySQL Python connector", () => {
+    const result = generateRdbConnectorFunctionPython(model, mysqlConnector, modelConnector);
+    expect(result.registration).toContain("user");
+    expect(result.blueprint).toContain("mysql.connector");
+    expect(result.blueprint).toContain("MYSQL_CONNECTION_STRING");
+    expect(result.blueprint).toContain("SELECT * FROM users");
+    expect(result.blueprint).toContain('route="user"');
+    expect(result.blueprint).toContain('methods=["GET"]');
+  });
+
+  it("returns registration and blueprint as object", () => {
+    const result = generateRdbConnectorFunctionPython(model, mysqlConnector, modelConnector);
+    expect(result).toHaveProperty("registration");
+    expect(result).toHaveProperty("blueprint");
+    expect(typeof result.registration).toBe("string");
+    expect(typeof result.blueprint).toBe("string");
+  });
+});
+
+// ─── Python API Connector ───────────────────────────────────
+
+describe("generateApiConnectorFunctionPython", () => {
+  const model = createApiConnectorModelInfo();
+  const modelConnector = model.connectorConfig as ApiModelConnectorConfig;
+
+  it("generates API Python connector with CRUD", () => {
+    const result = generateApiConnectorFunctionPython(model, backlogConnector, modelConnector);
+    expect(result.blueprint).toContain("BACKLOG_API_BASE_URL");
+    expect(result.blueprint).toContain("requests");
+    expect(result.blueprint).toContain('route="backlogIssue"');
+  });
+
+  it("includes apiKey auth in Python", () => {
+    const result = generateApiConnectorFunctionPython(model, backlogConnector, modelConnector);
+    expect(result.blueprint).toContain("BACKLOG_API_KEY");
+    expect(result.blueprint).toContain("apiKey");
+  });
+
+  it("generates bearer auth for Python", () => {
+    const result = generateApiConnectorFunctionPython(model, bearerConnector, modelConnector);
+    expect(result.blueprint).toContain("Authorization");
+    expect(result.blueprint).toContain("Bearer");
+    expect(result.blueprint).toContain("EXT_API_TOKEN");
+  });
+});

package/src/__tests__/connector-mock-server.test.ts

@@ -0,0 +1,252 @@
+/**
+ * コネクタモックサーバーのテスト
+ */
+
+import * as http from "http";
+import { ConnectorMockServer } from "../core/mock/connector-mock-server";
+import {
+  createRdbConnectorModelInfo,
+  createApiConnectorModelInfo,
+} from "./fixtures";
+
+// ─── Helpers ────────────────────────────────────────────────
+
+function httpRequest(
+  port: number,
+  method: string,
+  path: string,
+  body?: unknown
+): Promise<{ status: number; body: unknown }> {
+  return new Promise((resolve, reject) => {
+    const opts: http.RequestOptions = {
+      hostname: "localhost",
+      port,
+      path,
+      method,
+      headers: { "Content-Type": "application/json" },
+    };
+
+    const req = http.request(opts, (res) => {
+      let data = "";
+      res.on("data", (chunk) => (data += chunk));
+      res.on("end", () => {
+        try {
+          resolve({
+            status: res.statusCode || 0,
+            body: data ? JSON.parse(data) : null,
+          });
+        } catch {
+          resolve({ status: res.statusCode || 0, body: data });
+        }
+      });
+    });
+
+    req.on("error", reject);
+
+    if (body) {
+      req.write(JSON.stringify(body));
+    }
+    req.end();
+  });
+}
+
+// ─── Tests ──────────────────────────────────────────────────
+
+describe("ConnectorMockServer", () => {
+  let server: ConnectorMockServer;
+  const TEST_PORT = 19876; // Unlikely to conflict
+
+  afterEach(async () => {
+    if (server) {
+      await server.stop();
+    }
+  });
+
+  it("starts and stops without errors", async () => {
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createRdbConnectorModelInfo()],
+      mockCount: 2,
+    });
+
+    await server.start();
+    await server.stop();
+  });
+
+  it("serves GET /api/<model> with mock data", async () => {
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createRdbConnectorModelInfo()],
+      mockCount: 3,
+    });
+
+    await server.start();
+
+    const { status, body } = await httpRequest(TEST_PORT, "GET", "/api/user");
+    expect(status).toBe(200);
+    expect(Array.isArray(body)).toBe(true);
+    expect((body as any[]).length).toBe(3);
+    expect((body as any[])[0]).toHaveProperty("id");
+    expect((body as any[])[0]).toHaveProperty("email");
+  });
+
+  it("serves GET /api/<model>/<id> for single item", async () => {
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createRdbConnectorModelInfo()],
+      mockCount: 3,
+    });
+
+    await server.start();
+
+    const { status, body } = await httpRequest(TEST_PORT, "GET", "/api/user/user-001");
+    expect(status).toBe(200);
+    expect((body as any).id).toBe("user-001");
+  });
+
+  it("returns 404 for non-existent item", async () => {
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createRdbConnectorModelInfo()],
+      mockCount: 2,
+    });
+
+    await server.start();
+
+    const { status } = await httpRequest(TEST_PORT, "GET", "/api/user/nonexistent");
+    expect(status).toBe(404);
+  });
+
+  it("returns 405 for write operations on read-only connector", async () => {
+    // RDB connector model has operations: ["getAll", "getById"] (read-only)
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createRdbConnectorModelInfo()],
+      mockCount: 2,
+    });
+
+    await server.start();
+
+    const { status } = await httpRequest(TEST_PORT, "POST", "/api/user", { name: "New" });
+    expect(status).toBe(405);
+  });
+
+  it("supports POST for read-write connector models", async () => {
+    // API connector model has operations: ["getAll", "getById", "create", "update"]
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createApiConnectorModelInfo()],
+      mockCount: 0,
+    });
+
+    await server.start();
+
+    const { status, body } = await httpRequest(TEST_PORT, "POST", "/api/backlogIssue", {
+      summary: "Test issue",
+      projectId: "proj-1",
+      issueKey: "TEST-001",
+    });
+    expect(status).toBe(201);
+    expect((body as any).summary).toBe("Test issue");
+    expect((body as any).id).toBeDefined();
+
+    // Verify it was stored
+    const { body: allBody } = await httpRequest(TEST_PORT, "GET", "/api/backlogIssue");
+    expect((allBody as any[]).length).toBe(1);
+  });
+
+  it("supports PUT for update operations", async () => {
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createApiConnectorModelInfo()],
+      mockCount: 2,
+    });
+
+    await server.start();
+
+    const store = server.getStore("BacklogIssue");
+    const firstId = store[0].id as string;
+
+    const { status, body } = await httpRequest(TEST_PORT, "PUT", `/api/backlogIssue/${firstId}`, {
+      summary: "Updated summary",
+    });
+    expect(status).toBe(200);
+    expect((body as any).summary).toBe("Updated summary");
+    expect((body as any).id).toBe(firstId);
+  });
+
+  it("returns 405 for DELETE when not in operations", async () => {
+    // API connector model doesn't include "delete" in operations
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createApiConnectorModelInfo()],
+      mockCount: 2,
+    });
+
+    await server.start();
+
+    const store = server.getStore("BacklogIssue");
+    const firstId = store[0].id as string;
+
+    const { status } = await httpRequest(TEST_PORT, "DELETE", `/api/backlogIssue/${firstId}`);
+    expect(status).toBe(405);
+  });
+
+  it("proxies non-connector routes to Functions target (returns 502 when Functions not running)", async () => {
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:19877", // No server on this port
+      connectorModels: [createRdbConnectorModelInfo()],
+      mockCount: 1,
+    });
+
+    await server.start();
+
+    // /api/todo is NOT a connector model route, so it should be proxied
+    const { status, body } = await httpRequest(TEST_PORT, "GET", "/api/todo");
+    expect(status).toBe(502);
+    expect((body as any).error).toContain("not available");
+  });
+
+  it("handles multiple connector models simultaneously", async () => {
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createRdbConnectorModelInfo(), createApiConnectorModelInfo()],
+      mockCount: 2,
+    });
+
+    await server.start();
+
+    const usersRes = await httpRequest(TEST_PORT, "GET", "/api/user");
+    expect(usersRes.status).toBe(200);
+    expect((usersRes.body as any[]).length).toBe(2);
+
+    const issuesRes = await httpRequest(TEST_PORT, "GET", "/api/backlogIssue");
+    expect(issuesRes.status).toBe(200);
+    expect((issuesRes.body as any[]).length).toBe(2);
+  });
+
+  it("getStore returns current data for a model", async () => {
+    server = new ConnectorMockServer({
+      port: TEST_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [createRdbConnectorModelInfo()],
+      mockCount: 3,
+    });
+
+    await server.start();
+
+    const store = server.getStore("User");
+    expect(store.length).toBe(3);
+    expect(store[0].id).toBe("user-001");
+  });
+});