swallowkit 1.0.0-beta.14 → 1.0.0-beta.16

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

@@ -260,23 +260,65 @@ describe("ConnectorMockServer - Auth Endpoints", () => {
   const AUTH_PORT = 19877;
   const JWT_SECRET = "test-jwt-secret-for-mock-auth-tests";
 
+  // Auth-compatible User model (has loginId, password, roles fields)
+  const authUserModel = createRdbConnectorModelInfo({
+    name: "User",
+    displayName: "User",
+    schemaName: "userSchema",
+    filePath: "/models/user.ts",
+    fields: [
+      { name: "id", type: "string", isOptional: false, isArray: false },
+      { name: "loginId", type: "string", isOptional: false, isArray: false },
+      { name: "password", type: "string", isOptional: false, isArray: false },
+      { name: "name", type: "string", isOptional: false, isArray: false },
+      { name: "email", type: "string", isOptional: false, isArray: false },
+      { name: "roles", type: "string", isOptional: false, isArray: true },
+    ],
+    connectorConfig: {
+      connector: "mysql",
+      operations: ["getAll", "getById"],
+      table: "users",
+      idColumn: "id",
+    },
+  });
+
+  const testUsers = [
+    { id: "1", loginId: "admin", password: "password123", name: "Admin User", email: "admin@example.com", roles: ["admin"] },
+    { id: "2", loginId: "user", password: "password123", name: "Test User", email: "user@example.com", roles: ["user"] },
+  ];
+
   afterEach(async () => {
     if (server) {
       await server.stop();
     }
   });
 
-  it("handles POST /api/auth/login with default mock users", async () => {
+  /** Start mock server with auth-compatible User model and seed data */
+  async function startAuthServer() {
     server = new ConnectorMockServer({
       port: AUTH_PORT,
       functionsTarget: "localhost:7071",
-      connectorModels: [],
+      connectorModels: [authUserModel],
+      mockCount: 0,
       authConfig: {
         jwtSecret: JWT_SECRET,
         tokenExpiry: "1h",
+        customJwt: {
+          userTable: "users",
+          loginIdColumn: "loginId",
+          passwordHashColumn: "password",
+          rolesColumn: "roles",
+        },
       },
     });
     await server.start();
+    // Populate user store with known test data
+    const store = server.getStore("User");
+    store.push(...testUsers);
+  }
+
+  it("handles POST /api/auth/login with users from RDB mock store", async () => {
+    await startAuthServer();
 
     const res = await httpRequest(AUTH_PORT, "POST", "/api/auth/login", {
       loginId: "admin",
@@ -294,13 +336,7 @@ describe("ConnectorMockServer - Auth Endpoints", () => {
   });
 
   it("returns 401 for invalid credentials", async () => {
-    server = new ConnectorMockServer({
-      port: AUTH_PORT,
-      functionsTarget: "localhost:7071",
-      connectorModels: [],
-      authConfig: { jwtSecret: JWT_SECRET },
-    });
-    await server.start();
+    await startAuthServer();
 
     const res = await httpRequest(AUTH_PORT, "POST", "/api/auth/login", {
       loginId: "admin",
@@ -311,13 +347,7 @@ describe("ConnectorMockServer - Auth Endpoints", () => {
   });
 
   it("returns 401 for non-existent user", async () => {
-    server = new ConnectorMockServer({
-      port: AUTH_PORT,
-      functionsTarget: "localhost:7071",
-      connectorModels: [],
-      authConfig: { jwtSecret: JWT_SECRET },
-    });
-    await server.start();
+    await startAuthServer();
 
     const res = await httpRequest(AUTH_PORT, "POST", "/api/auth/login", {
       loginId: "nobody",
@@ -328,13 +358,7 @@ describe("ConnectorMockServer - Auth Endpoints", () => {
   });
 
   it("handles GET /api/auth/me with valid JWT", async () => {
-    server = new ConnectorMockServer({
-      port: AUTH_PORT,
-      functionsTarget: "localhost:7071",
-      connectorModels: [],
-      authConfig: { jwtSecret: JWT_SECRET },
-    });
-    await server.start();
+    await startAuthServer();
 
     // Login first
     const loginRes = await httpRequest(AUTH_PORT, "POST", "/api/auth/login", {
@@ -355,26 +379,14 @@ describe("ConnectorMockServer - Auth Endpoints", () => {
   });
 
   it("returns 401 for /api/auth/me without token", async () => {
-    server = new ConnectorMockServer({
-      port: AUTH_PORT,
-      functionsTarget: "localhost:7071",
-      connectorModels: [],
-      authConfig: { jwtSecret: JWT_SECRET },
-    });
-    await server.start();
+    await startAuthServer();
 
     const res = await httpRequest(AUTH_PORT, "GET", "/api/auth/me");
     expect(res.status).toBe(401);
   });
 
   it("handles POST /api/auth/logout", async () => {
-    server = new ConnectorMockServer({
-      port: AUTH_PORT,
-      functionsTarget: "localhost:7071",
-      connectorModels: [],
-      authConfig: { jwtSecret: JWT_SECRET },
-    });
-    await server.start();
+    await startAuthServer();
 
     const res = await httpRequest(AUTH_PORT, "POST", "/api/auth/logout");
     expect(res.status).toBe(200);
@@ -398,4 +410,30 @@ describe("ConnectorMockServer - Auth Endpoints", () => {
     // Should get 502 (proxy error) since auth is not handled by mock
     expect(res.status).toBe(502);
   });
+
+  it("returns 500 when no user model matches the configured userTable", async () => {
+    server = new ConnectorMockServer({
+      port: AUTH_PORT,
+      functionsTarget: "localhost:7071",
+      connectorModels: [], // no models at all
+      authConfig: {
+        jwtSecret: JWT_SECRET,
+        customJwt: {
+          userTable: "users",
+          loginIdColumn: "loginId",
+          passwordHashColumn: "password",
+          rolesColumn: "roles",
+        },
+      },
+    });
+    await server.start();
+
+    const res = await httpRequest(AUTH_PORT, "POST", "/api/auth/login", {
+      loginId: "admin",
+      password: "password123",
+    });
+
+    expect(res.status).toBe(500);
+    expect((res.body as any).error).toContain("No user model found");
+  });
 });

package/src/cli/commands/add-auth.ts

@@ -18,7 +18,7 @@ import {
   generateBFFAuthLoginRoute,
   generateBFFAuthLogoutRoute,
   generateBFFAuthMeRoute,
-  generateMiddleware,
+  generateProxy,
   generateLoginPage,
   generateAuthContext,
   generateBFFCallFunctionWithAuth,
@@ -76,6 +76,9 @@ export async function addAuthCommand(options: AddAuthOptions) {
   fs.writeFileSync(authModelPath, generateAuthModels(), "utf-8");
   console.log(` Created: shared/models/auth.ts`);
 
+  // Ensure shared package has build infrastructure (tsconfig, build script)
+  ensureSharedBuildInfrastructure(cwd);
+
   // Update shared/index.ts to re-export auth
   updateSharedIndex(cwd);
 
@@ -91,11 +94,11 @@ export async function addAuthCommand(options: AddAuthOptions) {
   console.log("\n Generating BFF auth routes...");
   generateBFFAuth(cwd, projectName, sharedPackageName);
 
-  // 4. Generate middleware
-  console.log("\n  Generating middleware...");
-  const middlewarePath = path.join(cwd, "middleware.ts");
-  fs.writeFileSync(middlewarePath, generateMiddleware(projectName), "utf-8");
-  console.log(` Created: middleware.ts`);
+  // 4. Generate proxy
+  console.log("\n  Generating proxy...");
+  const proxyPath = path.join(cwd, "proxy.ts");
+  fs.writeFileSync(proxyPath, generateProxy(projectName), "utf-8");
+  console.log(` Created: proxy.ts`);
 
   // 5. Generate login page
   console.log("\n Generating login page...");
@@ -143,6 +146,73 @@ export async function addAuthCommand(options: AddAuthOptions) {
   console.log(`  5. Run scaffold to regenerate functions with auth guards`);
 }
 
+/**
+ * Ensure the shared package has proper build infrastructure
+ * (tsconfig.json, build script, typescript devDependency).
+ * Required for `dev` command which runs `npm run --workspace=shared build`.
+ */
+function ensureSharedBuildInfrastructure(cwd: string): void {
+  const sharedDir = path.join(cwd, "shared");
+  const pkgPath = path.join(sharedDir, "package.json");
+  if (!fs.existsSync(pkgPath)) return;
+
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+  let updated = false;
+
+  // Ensure scripts.build exists
+  if (!pkg.scripts?.build) {
+    if (!pkg.scripts) pkg.scripts = {};
+    pkg.scripts.build = "tsc";
+    pkg.scripts.watch = "tsc --watch";
+    updated = true;
+  }
+
+  // Ensure main points to compiled output
+  if (!pkg.main || pkg.main === "index.ts") {
+    pkg.main = "dist/index.js";
+    pkg.types = "dist/index.d.ts";
+    updated = true;
+  }
+
+  // Ensure typescript devDependency
+  if (!pkg.devDependencies?.typescript) {
+    if (!pkg.devDependencies) pkg.devDependencies = {};
+    pkg.devDependencies.typescript = "^5.0.0";
+    updated = true;
+  }
+
+  if (updated) {
+    fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2), "utf-8");
+    console.log(` Updated: shared/package.json (added build infrastructure)`);
+  }
+
+  // Ensure tsconfig.json exists
+  const tsconfigPath = path.join(sharedDir, "tsconfig.json");
+  if (!fs.existsSync(tsconfigPath)) {
+    const tsconfig = {
+      compilerOptions: {
+        target: "ES2020",
+        module: "commonjs",
+        moduleResolution: "node",
+        lib: ["ES2020"],
+        outDir: "dist",
+        rootDir: ".",
+        declaration: true,
+        declarationMap: true,
+        sourceMap: true,
+        strict: true,
+        esModuleInterop: true,
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+      },
+      include: ["index.ts", "models/**/*"],
+      exclude: ["node_modules", "dist"],
+    };
+    fs.writeFileSync(tsconfigPath, JSON.stringify(tsconfig, null, 2), "utf-8");
+    console.log(` Created: shared/tsconfig.json`);
+  }
+}
+
 function updateSharedIndex(cwd: string): void {
   const indexPath = path.join(cwd, "shared", "index.ts");
   if (fs.existsSync(indexPath)) {
@@ -226,6 +296,25 @@ function generateFunctionsAuth(
 
     // __init__.py
     fs.writeFileSync(path.join(authDir, "__init__.py"), "", "utf-8");
+
+    // Register auth blueprint in function_app.py
+    const functionAppPath = path.join(functionsDir, "function_app.py");
+    if (fs.existsSync(functionAppPath)) {
+      const content = fs.readFileSync(functionAppPath, "utf-8");
+      const authImport = "from blueprints.auth import bp as auth_bp";
+      const authRegister = "app.register_blueprint(auth_bp)";
+      if (!content.includes(authImport)) {
+        const marker = "# SwallowKit scaffold registrations";
+        if (content.includes(marker)) {
+          const updated = content.replace(
+            marker,
+            `${authImport}\n${authRegister}\n${marker}`
+          );
+          fs.writeFileSync(functionAppPath, updated, "utf-8");
+          console.log(` Updated: functions/function_app.py (registered auth blueprint)`);
+        }
+      }
+    }
   }
 }
 

package/src/cli/commands/create-model.ts

@@ -45,7 +45,7 @@ export const displayName = '${pascalName}';
 function generateConnectorModelTemplate(modelName: string, connectorName: string, connectorType: 'rdb' | 'api'): string {
   const pascalName = toPascalCase(modelName);
   const kebabName = modelName.toLowerCase().replace(/[^a-z0-9]+/g, '-');
-  const pluralName = kebabName + 's';
+  const pluralName = kebabName.endsWith('s') ? kebabName : kebabName + 's';
 
   const schema = `import { z } from 'zod/v4';
 

package/src/cli/commands/dev-seeds.ts

@@ -30,7 +30,7 @@ interface LoadedSeedFile {
 }
 
 export function getContainerNameForModel(model: Pick<ModelInfo, "name">): string {
-  return `${model.name}s`;
+  return model.name.endsWith('s') ? model.name : `${model.name}s`;
 }
 
 export function getSeedEnvironmentDir(environment: string, seedsDir: string = "dev-seeds"): string {

package/src/cli/commands/dev.ts

@@ -458,10 +458,28 @@ async function startDevEnvironment(options: DevOptions) {
   const processes: ChildProcess[] = [];
   let functionsEnv: NodeJS.ProcessEnv = process.env;
   let mockServer: ConnectorMockServer | null = null;
+  let envLocalPath = '';
+  let envLocalDefaultUrl = ''; // default Functions URL to restore on shutdown
 
   // Cleanup processes on Ctrl+C
   process.on('SIGINT', async () => {
     console.log('\n🛑 Stopping development servers...');
+    // Restore .env.local to default Functions port on shutdown
+    if (envLocalPath && envLocalDefaultUrl) {
+      try {
+        if (fs.existsSync(envLocalPath)) {
+          const content = fs.readFileSync(envLocalPath, 'utf-8');
+          if (content.includes('BACKEND_FUNCTIONS_BASE_URL=') &&
+              !content.includes(`BACKEND_FUNCTIONS_BASE_URL=${envLocalDefaultUrl}`)) {
+            const restored = content.replace(
+              /^BACKEND_FUNCTIONS_BASE_URL=.*/m,
+              `BACKEND_FUNCTIONS_BASE_URL=${envLocalDefaultUrl}`
+            );
+            fs.writeFileSync(envLocalPath, restored, 'utf-8');
+          }
+        }
+      } catch { /* ignore */ }
+    }
     if (mockServer) {
       await mockServer.stop();
     }
@@ -604,28 +622,34 @@ async function startDevEnvironment(options: DevOptions) {
     if (hasFunctions && !options.noFunctions) {
       // Build shared package before starting Functions
       const sharedDir = path.join(process.cwd(), 'shared');
-      if (fs.existsSync(sharedDir) && fs.existsSync(path.join(sharedDir, 'package.json'))) {
-        console.log('📦 Building shared package...');
-        const filterArgs = pm === 'pnpm'
-          ? ['run', '--filter', 'shared', 'build']
-          : ['run', '--workspace=shared', 'build'];
-        const sharedBuild = spawn(pm, filterArgs, {
-          cwd: process.cwd(),
-          shell: true,
-          stdio: 'inherit',
-        });
+      const sharedPkgPath = path.join(sharedDir, 'package.json');
+      if (fs.existsSync(sharedDir) && fs.existsSync(sharedPkgPath)) {
+        const sharedPkg = JSON.parse(fs.readFileSync(sharedPkgPath, 'utf-8'));
+        if (sharedPkg.scripts?.build) {
+          console.log('📦 Building shared package...');
+          const filterArgs = pm === 'pnpm'
+            ? ['run', '--filter', 'shared', 'build']
+            : ['run', '--workspace=shared', 'build'];
+          const sharedBuild = spawn(pm, filterArgs, {
+            cwd: process.cwd(),
+            shell: true,
+            stdio: 'inherit',
+          });
 
-        await new Promise<void>((resolve, reject) => {
-          sharedBuild.on('close', (code) => {
-            if (code === 0) {
-              console.log('✅ Shared package built successfully');
-              resolve();
-            } else {
-              reject(new Error(`Shared package build failed with code ${code}`));
-            }
+          await new Promise<void>((resolve, reject) => {
+            sharedBuild.on('close', (code) => {
+              if (code === 0) {
+                console.log('✅ Shared package built successfully');
+                resolve();
+              } else {
+                reject(new Error(`Shared package build failed with code ${code}`));
+              }
+            });
+            sharedBuild.on('error', reject);
           });
-          sharedBuild.on('error', reject);
-        });
+        } else {
+          console.log('⚠️  Shared package has no build script — skipping build. Run "swallowkit add-auth" to fix.');
+        }
       }
 
       // Azure Functions を起動
@@ -711,7 +735,7 @@ async function startDevEnvironment(options: DevOptions) {
 
       // Resolve auth config — auth functions use RDB connectors, mocked alongside other models
       const authConfig = getAuthConfig();
-      let mockAuthConfig: { jwtSecret: string; tokenExpiry?: string; customJwt?: { loginIdColumn: string; passwordHashColumn: string; rolesColumn: string }; defaultPolicy?: "authenticated" | "anonymous" } | undefined;
+      let mockAuthConfig: { jwtSecret: string; tokenExpiry?: string; customJwt?: { userTable: string; loginIdColumn: string; passwordHashColumn: string; rolesColumn: string }; defaultPolicy?: "authenticated" | "anonymous" } | undefined;
       if (authConfig?.provider === 'custom-jwt' && authConfig.customJwt) {
         const fullConfig = getFullConfig();
         // Read JWT_SECRET from functions/local.settings.json if available
@@ -727,6 +751,7 @@ async function startDevEnvironment(options: DevOptions) {
           jwtSecret,
           tokenExpiry: authConfig.customJwt.tokenExpiry,
           customJwt: {
+            userTable: authConfig.customJwt.userTable,
             loginIdColumn: authConfig.customJwt.loginIdColumn,
             passwordHashColumn: authConfig.customJwt.passwordHashColumn,
             rolesColumn: authConfig.customJwt.rolesColumn,
@@ -782,6 +807,26 @@ async function startDevEnvironment(options: DevOptions) {
       }, 3000);
     }
 
+    // Ensure .env.local points to bffTargetPort so Next.js reads the correct backend URL.
+    // When --mock-connectors is active, bffTargetPort = mock port (7072); otherwise = Functions port (7071).
+    // Next.js may load .env.local values that override spawn env vars, so we must keep them in sync.
+    envLocalPath = path.join(process.cwd(), '.env.local');
+    envLocalDefaultUrl = `http://${options.host || 'localhost'}:${functionsPort}`;
+    const bffTargetUrl = `http://${options.host || 'localhost'}:${bffTargetPort}`;
+    try {
+      if (fs.existsSync(envLocalPath)) {
+        const envContent = fs.readFileSync(envLocalPath, 'utf-8');
+        if (envContent.includes('BACKEND_FUNCTIONS_BASE_URL=') &&
+            !envContent.includes(`BACKEND_FUNCTIONS_BASE_URL=${bffTargetUrl}`)) {
+          const updated = envContent.replace(
+            /^BACKEND_FUNCTIONS_BASE_URL=.*/m,
+            `BACKEND_FUNCTIONS_BASE_URL=${bffTargetUrl}`
+          );
+          fs.writeFileSync(envLocalPath, updated, 'utf-8');
+        }
+      }
+    } catch { /* ignore */ }
+
     const nextEnv: NodeJS.ProcessEnv = {
       ...process.env,
       BACKEND_FUNCTIONS_BASE_URL: `http://${options.host || 'localhost'}:${bffTargetPort}`,

package/src/cli/commands/scaffold.ts

@@ -328,14 +328,18 @@ async function generateFunctionsCode(
   }
 
   if (backendLanguage === "csharp") {
-    const functionFilePath = path.join(
-      process.cwd(),
-      functionsDir,
-      "Crud",
-      `${modelInfo.name}Functions.cs`
-    );
-    fs.mkdirSync(path.dirname(functionFilePath), { recursive: true });
-    fs.writeFileSync(functionFilePath, generateCSharpAzureFunctionsCRUD(modelInfo), "utf-8");
+    const crudDir = path.join(process.cwd(), functionsDir, "Crud");
+    const functionFilePath = path.join(crudDir, `${modelInfo.name}Functions.cs`);
+    fs.mkdirSync(crudDir, { recursive: true });
+
+    // Remove init-generated template (singular) to avoid route conflicts
+    const templatePath = path.join(crudDir, `${modelInfo.name}Function.cs`);
+    if (fs.existsSync(templatePath)) {
+      fs.unlinkSync(templatePath);
+      console.log(`🗑️  Removed template: ${templatePath}`);
+    }
+
+    fs.writeFileSync(functionFilePath, generateCSharpAzureFunctionsCRUD(modelInfo, authPolicy), "utf-8");
     console.log(`✅ Created: ${functionFilePath}`);
     return;
   }
@@ -344,7 +348,7 @@ async function generateFunctionsCode(
   const blueprintPath = path.join(blueprintsDir, `${modelKebab.replace(/-/g, "_")}.py`);
   fs.mkdirSync(blueprintsDir, { recursive: true });
 
-  const { blueprint, registration } = generatePythonAzureFunctionsCRUD(modelInfo);
+  const { blueprint, registration } = generatePythonAzureFunctionsCRUD(modelInfo, authPolicy);
   fs.writeFileSync(blueprintPath, blueprint, "utf-8");
   updatePythonFunctionRegistrations(path.join(process.cwd(), functionsDir, "function_app.py"), registration);
   console.log(`✅ Created: ${blueprintPath}`);
@@ -767,6 +771,14 @@ function pruneGeneratedCSharpArtifacts(outputDir: string): void {
 
   const clientDir = path.join(outputDir, "src", "SwallowKitBackendModels", "Client");
   if (!fs.existsSync(clientDir)) {
+    // --global-property models ではClient/が生成されないため、
+    // モデルが依存する最小限の Option<T> を自前で作成する
+    fs.mkdirSync(clientDir, { recursive: true });
+    fs.writeFileSync(
+      path.join(clientDir, "Option.cs"),
+      generateMinimalOptionCs(),
+      "utf-8"
+    );
     return;
   }
 
@@ -779,12 +791,59 @@ function pruneGeneratedCSharpArtifacts(outputDir: string): void {
   }
 }
 
+/**
+ * OpenAPI Generator の csharp テンプレートが生成するモデルは Option<T> に依存するが、
+ * supportingFiles を除外しているため Client/Option.cs が生成されない。
+ * Polly 等の不要な依存を避けつつモデルをコンパイル可能にするため、最小限の Option<T> を提供する。
+ */
+function generateMinimalOptionCs(): string {
+  return `// <auto-generated>
+// Minimal Option<T> for OpenAPI Generator model compatibility.
+// Full client supporting files are excluded to avoid Polly version conflicts.
+// </auto-generated>
+
+#nullable enable
+
+namespace SwallowKitBackendModels.Client
+{
+    /// <summary>
+    /// A wrapper for nullable/optional properties generated by OpenAPI Generator.
+    /// Tracks whether a value has been explicitly set (distinguishing null from absent).
+    /// </summary>
+    public readonly struct Option<TValue>
+    {
+        /// <summary>Whether this option has been explicitly set.</summary>
+        public bool IsSet { get; }
+
+        /// <summary>The contained value (may be default if not set).</summary>
+        public TValue Value { get; }
+
+        /// <summary>Create an Option with an explicit value.</summary>
+        public Option(TValue value)
+        {
+            IsSet = true;
+            Value = value;
+        }
+
+        /// <summary>Implicit conversion from Option to its inner value.</summary>
+        public static implicit operator TValue(Option<TValue> option) => option.Value;
+    }
+}
+`;
+}
+
 function updatePythonFunctionRegistrations(functionAppPath: string, registration: string): void {
   if (!fs.existsSync(functionAppPath)) {
     throw new Error(`Python Functions entrypoint not found: ${functionAppPath}`);
   }
 
   const content = fs.readFileSync(functionAppPath, "utf-8");
+
+  // Check if import line already exists (handles init-generated layout)
+  const importLine = registration.split("\n").find((l) => l.startsWith("from ") || l.startsWith("import "));
+  if (importLine && content.includes(importLine)) {
+    return;
+  }
   if (content.includes(registration)) {
     return;
   }

package/src/core/mock/connector-mock-server.ts

@@ -4,9 +4,7 @@
  * - その他のリクエスト → 実Azure Functions へプロキシ
  */
 
-import * as fs from "fs";
 import * as http from "http";
-import * as path from "path";
 import { ModelInfo, toCamelCase } from "../scaffold/model-parser";
 import { generateMockDocuments } from "./zod-mock-generator";
 import { loadDevSeedFiles } from "../../cli/commands/dev-seeds";
@@ -36,6 +34,8 @@ export interface ConnectorMockServerOptions {
     tokenExpiry?: string;
     /** Custom JWT config from swallowkit.config.js */
     customJwt?: {
+      /** RDB table name that holds user records (e.g., "users") */
+      userTable: string;
       loginIdColumn: string;
       passwordHashColumn: string;
       rolesColumn: string;
@@ -54,7 +54,6 @@ export class ConnectorMockServer {
   private server: http.Server | null = null;
   private stores = new Map<string, MockDocument[]>();
   private routeMap = new Map<string, ModelInfo>(); // route → model
-  private authUsers: MockDocument[] = [];
   private options: ConnectorMockServerOptions;
 
   constructor(options: ConnectorMockServerOptions) {
@@ -141,29 +140,6 @@ export class ConnectorMockServer {
         console.warn(`⚠️  Failed to load dev-seeds for connectors: ${(err as Error).message}`);
       }
     }
-
-    // Load auth users from dev-seeds/_auth-users.json (auth uses RDB connector, same mock approach)
-    if (this.options.seedEnv && this.options.authConfig) {
-      const seedsDir = this.options.seedsDir || path.join(process.cwd(), "dev-seeds");
-      const authUsersPath = path.join(seedsDir, this.options.seedEnv, "_auth-users.json");
-      if (fs.existsSync(authUsersPath)) {
-        try {
-          this.authUsers = JSON.parse(fs.readFileSync(authUsersPath, "utf-8"));
-          console.log(`  📂 Loaded ${this.authUsers.length} auth user seed(s) from _auth-users.json`);
-        } catch (err) {
-          console.warn(`⚠️  Failed to load _auth-users.json: ${(err as Error).message}`);
-        }
-      }
-    }
-
-    // Fallback: default auth user seeds when no seed file exists
-    if (this.options.authConfig && this.authUsers.length === 0) {
-      this.authUsers = [
-        { id: "1", loginId: "admin", password: "password123", name: "Admin User", email: "admin@example.com", roles: ["admin"] },
-        { id: "2", loginId: "user", password: "password123", name: "Test User", email: "user@example.com", roles: ["user"] },
-      ];
-      console.log("  📂 Using default auth user seeds (admin/password123, user/password123)");
-    }
   }
 
   private handleRequest(req: http.IncomingMessage, res: http.ServerResponse) {
@@ -353,11 +329,18 @@ export class ConnectorMockServer {
         return this.sendJson(res, 400, { error: "loginId and password are required" });
       }
 
+      const users = this.resolveUserStore();
+      if (!users) {
+        return this.sendJson(res, 500, {
+          error: "No user model found — ensure a connector model with the configured userTable exists",
+        });
+      }
+
       const loginField = this.options.authConfig?.customJwt?.loginIdColumn || "loginId";
       const passwordField = this.options.authConfig?.customJwt?.passwordHashColumn || "password";
       const rolesField = this.options.authConfig?.customJwt?.rolesColumn || "roles";
 
-      const user = this.authUsers.find(
+      const user = users.find(
         (u) => (u[loginField] || u.loginId) === loginId
       );
 
@@ -442,6 +425,23 @@ export class ConnectorMockServer {
 
   // ─── Utilities ────────────────────────────────────────────
 
+  /**
+   * authConfig.customJwt.userTable に対応するモデルのストアを返す。
+   * ユーザーテーブルが見つからない場合は null を返す。
+   */
+  private resolveUserStore(): MockDocument[] | null {
+    const userTable = this.options.authConfig?.customJwt?.userTable;
+    if (!userTable) return null;
+
+    for (const model of this.options.connectorModels) {
+      const cfg = model.connectorConfig;
+      if (cfg && "table" in cfg && cfg.table === userTable) {
+        return this.stores.get(toCamelCase(model.name)) || null;
+      }
+    }
+    return null;
+  }
+
   /**
    * JWT を検証し、ペイロード（roles 含む）を返す。
    * 認証不要な場合は null を返す。401/403 の場合はレスポンスを送信して 'error' を返す。