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

package/src/__tests__/config.test.ts

@@ -0,0 +1,263 @@
+import { validateConfig, loadConfigFromEnv } from "../core/config";
+import { SwallowKitConfig } from "../types";
+
+describe("validateConfig", () => {
+  it("returns valid for a complete config", () => {
+    const config: SwallowKitConfig = {
+      database: { connectionString: "AccountEndpoint=https://..." },
+      backend: { language: "typescript" },
+      api: { endpoint: "/api/_swallowkit" },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it("returns error when connectionString is missing", () => {
+    const config: SwallowKitConfig = {
+      database: {},
+      backend: { language: "typescript" },
+      api: { endpoint: "/api/_swallowkit" },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("Cosmos DB connection string is required");
+  });
+
+  it("returns error when endpoint does not start with /", () => {
+    const config: SwallowKitConfig = {
+      database: { connectionString: "AccountEndpoint=https://..." },
+      backend: { language: "typescript" },
+      api: { endpoint: "api/_swallowkit" },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("API endpoint must start with '/'");
+  });
+
+  it("returns multiple errors for multiple issues", () => {
+    const config: SwallowKitConfig = {
+      database: {},
+      backend: { language: "typescript" },
+      api: { endpoint: "bad-endpoint" },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toHaveLength(2);
+  });
+
+  it("returns error when backend language is invalid", () => {
+    const config: SwallowKitConfig = {
+      backend: { language: "ruby" as never },
+    };
+    const result = validateConfig(config);
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain("Backend language must be one of: typescript, csharp, python");
+  });
+
+  it("accepts config without database or api (no validation errors for absent sections)", () => {
+    const config: SwallowKitConfig = {};
+    const result = validateConfig(config);
+    // 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", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterAll(() => {
+    process.env = originalEnv;
+  });
+
+  it("returns empty config when no env vars set", () => {
+    delete process.env.SWALLOWKIT_DB_CONNECTION_STRING;
+    delete process.env.SWALLOWKIT_DB_NAME;
+    delete process.env.SWALLOWKIT_API_ENDPOINT;
+
+    const config = loadConfigFromEnv();
+    expect(config.database).toBeUndefined();
+    expect(config.api).toBeUndefined();
+  });
+
+  it("reads database connection string from env", () => {
+    process.env.SWALLOWKIT_DB_CONNECTION_STRING = "AccountEndpoint=https://test.documents.azure.com:443/;AccountKey=xxx;";
+    const config = loadConfigFromEnv();
+    expect(config.database?.connectionString).toBe(
+      "AccountEndpoint=https://test.documents.azure.com:443/;AccountKey=xxx;"
+    );
+  });
+
+  it("reads database name from env", () => {
+    process.env.SWALLOWKIT_DB_NAME = "MyTestDB";
+    const config = loadConfigFromEnv();
+    expect(config.database?.databaseName).toBe("MyTestDB");
+  });
+
+  it("reads API endpoint from env", () => {
+    process.env.SWALLOWKIT_API_ENDPOINT = "/api/custom";
+    const config = loadConfigFromEnv();
+    expect(config.api?.endpoint).toBe("/api/custom");
+  });
+
+  it("reads backend language from env", () => {
+    process.env.SWALLOWKIT_BACKEND_LANGUAGE = "python";
+    const config = loadConfigFromEnv();
+    expect(config.backend?.language).toBe("python");
+  });
+
+  it("reads all env vars together", () => {
+    process.env.SWALLOWKIT_DB_CONNECTION_STRING = "conn";
+    process.env.SWALLOWKIT_DB_NAME = "db";
+    process.env.SWALLOWKIT_API_ENDPOINT = "/api/v2";
+    const config = loadConfigFromEnv();
+    expect(config.database?.connectionString).toBe("conn");
+    expect(config.database?.databaseName).toBe("db");
+    expect(config.api?.endpoint).toBe("/api/v2");
+  });
+});

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");
+  });
+});