@mandujs/core 0.54.5 → 0.54.7

package/src/bundler/__tests__/build-runner.ts

@@ -80,24 +80,42 @@ const manifest: RoutesManifest = mode === "server-page-client-module"
         },
       ],
     }
-  : {
-  version: 1,
-  routes: [
-    {
-      id: "demo",
-      kind: "page",
-      pattern: "/",
-      module: "app/page.tsx",
-      componentModule: "app/page.tsx",
-      clientModule: "app/demo.client.tsx",
-      hydration: {
-        strategy: "island",
-        priority: "visible",
-        preload: false,
-      },
-    },
-  ],
-};
+  : mode === "hydration-no-client-module"
+    ? {
+        version: 1,
+        routes: [
+          {
+            id: "login",
+            kind: "page",
+            pattern: "/login",
+            module: "app/login/page.tsx",
+            componentModule: "app/login/page.tsx",
+            hydration: {
+              strategy: "full",
+              priority: "immediate",
+              preload: false,
+            },
+          },
+        ],
+      }
+    : {
+        version: 1,
+        routes: [
+          {
+            id: "demo",
+            kind: "page",
+            pattern: "/",
+            module: "app/page.tsx",
+            componentModule: "app/page.tsx",
+            clientModule: "app/demo.client.tsx",
+            hydration: {
+              strategy: "island",
+              priority: "visible",
+              preload: false,
+            },
+          },
+        ],
+      };
 
 try {
   const result = await buildClientBundles(manifest, rootDir, {

package/src/bundler/__tests__/cold-start.test.ts

@@ -28,11 +28,12 @@ import { describe, it, expect, beforeEach, afterEach } from "bun:test";
 import { mkdtempSync, writeFileSync, mkdirSync, rmSync } from "fs";
 import { tmpdir } from "os";
 import path from "path";
-import type { RouteSpec } from "../../spec/schema";
+import type { RouteSpec, RoutesManifest } from "../../spec/schema";
 import {
   _testOnly_scanIslandFiles,
   _testOnly_scanPartialFiles,
   _testOnly_getHydratedRoutes,
+  _testOnly_getHydrationRoutesMissingClientModule,
 } from "../build";
 import { HMR_PERF } from "../../perf/hmr-markers";
 import {
@@ -504,6 +505,29 @@ describe("Phase 7.1 R1 Agent C — per-island scan skips non-hydrated routes", (
   });
 });
 
+describe("hydration route validation", () => {
+  it("finds pages that request hydration without a client module", () => {
+    const manifest = {
+      version: 1,
+      routes: [
+        {
+          id: "login",
+          pattern: "/login",
+          kind: "page",
+          module: "app/login/page.tsx",
+          componentModule: "app/login/page.tsx",
+          hydration: { strategy: "full", priority: "immediate", preload: false },
+        },
+        pureSsrRoute("about", "/about", "app/about"),
+        pageRoute("dashboard", "/dashboard", "app/dashboard"),
+      ],
+    } as RoutesManifest;
+
+    const missing = _testOnly_getHydrationRoutesMissingClientModule(manifest);
+    expect(missing.map((route) => route.id)).toEqual(["login"]);
+  });
+});
+
 describe("partial bundle scan", () => {
   let project: ReturnType<typeof createProject>;
 

package/src/bundler/build.test.ts

@@ -218,4 +218,39 @@ describe("buildClientBundles vendor shims", () => {
       await rm(staleRoot, { recursive: true, force: true });
     }
   });
+
+  test("fails when hydration is enabled but no clientModule can be resolved", async () => {
+    const missingRoot = await mkdtemp(path.join(import.meta.dir, ".tmp-hydration-no-client-"));
+    try {
+      await mkdir(path.join(missingRoot, "app", "login"), { recursive: true });
+      await mkdir(path.join(missingRoot, "src", "client", "widgets", "login-form"), { recursive: true });
+      await writeFile(
+        path.join(missingRoot, "package.json"),
+        JSON.stringify({ name: "mandu-hydration-no-client-test", type: "module" }, null, 2),
+        "utf-8",
+      );
+      await writeFile(
+        path.join(missingRoot, "app", "login", "page.tsx"),
+        'import { LoginForm } from "../../src/client/widgets/login-form/LoginForm.client";\n' +
+          "export default function LoginPage() {\n" +
+          "  return <main><LoginForm /></main>;\n" +
+          "}\n",
+        "utf-8",
+      );
+      await writeFile(
+        path.join(missingRoot, "src", "client", "widgets", "login-form", "LoginForm.client.tsx"),
+        "export function LoginForm() { return <form />; }\n",
+        "utf-8",
+      );
+
+      const noClientResult = await runBuildInSubprocess(missingRoot, "hydration-no-client-module");
+      const errors = noClientResult.errors.join("\n");
+      expect(noClientResult.success).toBe(false);
+      expect(errors).toContain("no clientModule could be resolved");
+      expect(errors).toContain("LoginForm.client");
+      expect(errors).toContain("partial({ component }).Render");
+    } finally {
+      await rm(missingRoot, { recursive: true, force: true });
+    }
+  });
 });

package/src/bundler/build.ts

@@ -23,7 +23,10 @@ import type { BunPlugin } from "bun";
 import { mark, measure } from "../perf";
 import { HMR_PERF } from "../perf/hmr-markers";
 import { runOnBundleComplete } from "../plugins/runner";
-import { validateClientModuleForBrowserBundle } from "../router/client-entry";
+import {
+  describeMissingHydrationClientModule,
+  validateClientModuleForBrowserBundle,
+} from "../router/client-entry";
 import {
   readVendorCache,
   writeVendorCache,
@@ -236,7 +239,9 @@ export const _testOnly_scanPartialFiles = scanPartialFiles;
  *
  * @internal
  */
-export const _testOnly_getHydratedRoutes = getHydratedRoutes;
+export const _testOnly_getHydratedRoutes = getHydratedRoutes;
+export const _testOnly_getHydrationRoutesMissingClientModule =
+  getHydrationRoutesMissingClientModule;
 
 /**
  * Issue #240 Phase 2 — collect every file the React Compiler plugin
@@ -402,14 +407,23 @@ function createEmptyManifest(env: "development" | "production"): BundleManifest
 /**
  * Hydration이 필요한 라우트 필터링
  */
-function getHydratedRoutes(manifest: RoutesManifest): RouteSpec[] {
-  return manifest.routes.filter(
-    (route) =>
-      route.kind === "page" &&
-      route.clientModule &&
-      needsHydration(route)
-  );
-}
+function getHydratedRoutes(manifest: RoutesManifest): RouteSpec[] {
+  return manifest.routes.filter(
+    (route) =>
+      route.kind === "page" &&
+      route.clientModule &&
+      needsHydration(route)
+  );
+}
+
+function getHydrationRoutesMissingClientModule(manifest: RoutesManifest): RouteSpec[] {
+  return manifest.routes.filter(
+    (route) =>
+      route.kind === "page" &&
+      !route.clientModule &&
+      needsHydration(route)
+  );
+}
 
 const REACT_SHIM_EXPORTS = [
   "Activity",
@@ -2120,10 +2134,24 @@ export async function buildClientBundles(
       errors.push(`onBundleComplete[${e.source}]: ${e.error.message}`);
     }
   };
-  const env = resolveBundlerMode(options);
-
+  const env = resolveBundlerMode(options);
+
   // 1. Hydration이 필요한 라우트 필터링
   const invalidClientRouteIds = new Set<string>();
+  const runtimeRoutes = manifest.routes.filter((route) => route.kind === "page" && needsHydration(route));
+  const partialFiles = runtimeRoutes.length > 0 ? await scanPartialFiles(rootDir) : [];
+  const routesMissingClientModule = getHydrationRoutesMissingClientModule(manifest);
+  if (routesMissingClientModule.length > 0) {
+    const missingClientErrors = await Promise.all(
+      routesMissingClientModule.map((route) =>
+        describeMissingHydrationClientModule(route, rootDir, {
+          allowPartialOnly: partialFiles.length > 0,
+        })
+      )
+    );
+    errors.push(...missingClientErrors.filter((error): error is string => error !== null));
+  }
+
   let hydratedRoutes = getHydratedRoutes(manifest);
   if (hydratedRoutes.length > 0) {
     const validRoutes: RouteSpec[] = [];
@@ -2138,10 +2166,7 @@ export async function buildClientBundles(
     }
     hydratedRoutes = validRoutes;
   }
-  const runtimeRoutes = manifest.routes.filter((route) => route.kind === "page" && needsHydration(route));
-  const partialFiles = runtimeRoutes.length > 0 ? await scanPartialFiles(rootDir) : [];
-
-  // 2. 출력 디렉토리 생성 (항상 필요 - 매니페스트 저장용)
+  // 2. 출력 디렉토리 생성 (항상 필요 - 매니페스트 저장용)
   const outDir = resolveClientOutDir(rootDir, options.outDir);
   await fs.mkdir(outDir, { recursive: true });
 

package/src/generator/generate.ts

@@ -99,17 +99,25 @@ export interface GeneratedMap {
   frameworkPaths: string[];
 }
 
-async function ensureDir(dirPath: string): Promise<void> {
-  try {
-    await fs.mkdir(dirPath, { recursive: true });
-  } catch  {
-    // ignore if exists
-  }
-}
-
-async function getExistingFiles(dir: string): Promise<string[]> {
-  try {
-    const files = await fs.readdir(dir);
+async function ensureDir(dirPath: string): Promise<void> {
+  try {
+    await fs.mkdir(dirPath, { recursive: true });
+  } catch  {
+    // ignore if exists
+  }
+}
+
+function touchGenerateStamp(rootDir: string): void {
+  const stampDir = path.join(rootDir, ".mandu");
+  if (!fsSync.existsSync(stampDir)) {
+    fsSync.mkdirSync(stampDir, { recursive: true });
+  }
+  fsSync.writeFileSync(path.join(stampDir, "generate.stamp"), Date.now().toString());
+}
+
+async function getExistingFiles(dir: string): Promise<string[]> {
+  try {
+    const files = await fs.readdir(dir);
     return files.filter((f) => f.endsWith(".route.ts") || f.endsWith(".route.tsx"));
   } catch {
     return [];
@@ -138,9 +146,10 @@ export async function generateRoutes(
     warnings: [],
   };
 
-  // Suppress watcher during generation to avoid false positives
-  const watcher = getWatcher();
-  watcher?.suppress();
+  // Suppress watcher during generation to avoid false positives
+  const watcher = getWatcher();
+  watcher?.suppress();
+  touchGenerateStamp(rootDir);
 
   const generatedPaths = resolveGeneratedPaths(rootDir);
   const serverRoutesDir = generatedPaths.serverRoutesDir;
@@ -354,14 +363,10 @@ export async function generateRoutes(
   const mapPath = path.join(mapDir, "generated.map.json");
   await Bun.write(mapPath, JSON.stringify(generatedMap, null, 2));
 
-  // Resume watcher after generation
-  watcher?.resume();
-  // Cross-process timestamp: watcher skips warnings if generate finished recently
-  const stampDir = path.join(rootDir, ".mandu");
-  if (!fsSync.existsSync(stampDir)) {
-    fsSync.mkdirSync(stampDir, { recursive: true });
-  }
-  fsSync.writeFileSync(path.join(stampDir, "generate.stamp"), Date.now().toString());
-
-  return result;
-}
+  // Cross-process timestamp: watcher skips warnings if generate finished recently
+  touchGenerateStamp(rootDir);
+  // Resume watcher after the stamp is visible.
+  watcher?.resume();
+
+  return result;
+}

package/src/resource/__tests__/generator.test.ts

@@ -671,10 +671,12 @@ describe("generateSchemaArtifacts — diff + migration orchestration", () => {
       const result = await computeSchemaGeneration(resources, rootDir);
       expect(result.changes.length).toBe(2);
       expect(result.changes.every((c) => c.kind === "create-table")).toBe(true);
-      expect(result.migrationFilename).not.toBeNull();
-      expect(result.migrationSql).toContain("CREATE TABLE");
-      expect(result.desiredSchema).toContain("CREATE TABLE");
-      expect(Object.keys(result.desiredSchemaByTable).sort()).toEqual(["products", "users"]);
+      expect(result.migrationFilename).not.toBeNull();
+      expect(result.migrationSql).toContain("CREATE TABLE");
+      expect(result.migrationSql).not.toMatch(/\bBEGIN\b/i);
+      expect(result.migrationSql).not.toMatch(/\bCOMMIT\b/i);
+      expect(result.desiredSchema).toContain("CREATE TABLE");
+      expect(Object.keys(result.desiredSchemaByTable).sort()).toEqual(["products", "users"]);
     } finally {
       await fs.rm(rootDir, { recursive: true, force: true });
     }

package/src/resource/ddl/__tests__/emit.test.ts

@@ -415,13 +415,112 @@ describe("emitChange — add-column", () => {
     expect(emitChange(change, "mysql"))
       .toBe("ALTER TABLE `users` ADD COLUMN `age` DOUBLE;");
   });
-  test("sqlite", () => {
-    expect(emitChange(change, "sqlite"))
-      .toBe('ALTER TABLE "users" ADD COLUMN "age" REAL;');
-  });
-
-  test("indexed:true field emits ADD COLUMN plus auto CREATE INDEX", () => {
-    const indexed: Change = {
+  test("sqlite", () => {
+    expect(emitChange(change, "sqlite"))
+      .toBe('ALTER TABLE "users" ADD COLUMN "age" REAL;');
+  });
+
+  test("sqlite refuses required add-column without a non-NULL constant default (#294)", () => {
+    const required: Change = {
+      kind: "add-column",
+      resourceName: "votes",
+      field: field({ name: "created_at", type: "date" }),
+    };
+
+    expect(() => emitChange(required, "sqlite")).toThrow(
+      /SQLite cannot add required column "created_at"/,
+    );
+  });
+
+  test("sqlite allows required add-column when a scalar literal default is present", () => {
+    const requiredWithDefault: Change = {
+      kind: "add-column",
+      resourceName: "votes",
+      field: field({
+        name: "created_at",
+        type: "date",
+        default: { kind: "literal", value: "1970-01-01T00:00:00.000Z" },
+      }),
+    };
+
+    expect(emitChange(requiredWithDefault, "sqlite")).toBe(
+      'ALTER TABLE "votes" ADD COLUMN "created_at" TEXT NOT NULL DEFAULT \'1970-01-01T00:00:00.000Z\';',
+    );
+  });
+
+  test("sqlite refuses default: now on add-column because SQLite requires a constant default", () => {
+    const nowDefault: Change = {
+      kind: "add-column",
+      resourceName: "votes",
+      field: field({
+        name: "created_at",
+        type: "date",
+        nullable: true,
+        default: { kind: "now" },
+      }),
+    };
+
+    expect(() => emitChange(nowDefault, "sqlite")).toThrow(
+      /CURRENT_TIMESTAMP, which SQLite rejects/,
+    );
+  });
+
+  test("sqlite refuses UNIQUE add-column because SQLite cannot add the constraint in place", () => {
+    const unique: Change = {
+      kind: "add-column",
+      resourceName: "votes",
+      field: field({ name: "slug", type: "string", nullable: true, unique: true }),
+    };
+
+    expect(() => emitChange(unique, "sqlite")).toThrow(/cannot add UNIQUE column/);
+  });
+
+  test("sqlite refuses PRIMARY KEY add-column because SQLite cannot add the constraint in place", () => {
+    const primary: Change = {
+      kind: "add-column",
+      resourceName: "votes",
+      field: field({ name: "other_id", type: "uuid", primary: true }),
+    };
+
+    expect(() => emitChange(primary, "sqlite")).toThrow(/cannot add PRIMARY KEY column/);
+  });
+
+  test("sqlite refuses raw function defaults on add-column", () => {
+    const rawFunction: Change = {
+      kind: "add-column",
+      resourceName: "votes",
+      field: field({
+        name: "created_at",
+        type: "date",
+        nullable: true,
+        default: { kind: "sql", expr: "datetime('now')" },
+      }),
+    };
+
+    expect(() => emitChange(rawFunction, "sqlite")).toThrow(
+      /non-constant function defaults/,
+    );
+  });
+
+  test("sqlite refuses raw expression defaults on add-column", () => {
+    const rawExpression: Change = {
+      kind: "add-column",
+      resourceName: "votes",
+      field: field({
+        name: "score",
+        type: "number",
+        nullable: true,
+        default: { kind: "sql", expr: "(1+2)" },
+      }),
+    };
+
+    expect(() => emitChange(rawExpression, "sqlite")).toThrow(
+      /only accepts literal constant defaults/,
+    );
+  });
+
+  test("indexed:true field emits ADD COLUMN plus auto CREATE INDEX", () => {
+    const indexed: Change = {
       kind: "add-column",
       resourceName: "users",
       field: field({ name: "role", type: "string", indexed: true }),
@@ -477,22 +576,24 @@ describe("emitChange — alter-column-type stub", () => {
     stub: true,
   };
 
-  test("emits comment block with required TODO text", () => {
-    for (const p of PROVIDERS) {
-      const sql = emitChange(change, p);
-      expect(sql).toContain("-- TODO: Mandu does not auto-generate ALTER COLUMN TYPE in v1.");
-      expect(sql).toContain("mandu db apply");
-      expect(sql).toContain("Column type change detected: users.age");
-      expect(sql).toContain("from: number");
-      expect(sql).toContain("to:   string");
-    }
-  });
-
-  test("includes SELECT 1 no-op statement", () => {
-    const sql = emitChange(change, "postgres");
-    expect(sql).toContain("SELECT 1;");
-  });
-});
+  test("emits comment block with required TODO text", () => {
+    for (const p of PROVIDERS) {
+      const sql = emitChange(change, p);
+      expect(sql).toContain("-- TODO: Mandu does not auto-generate ALTER COLUMN TYPE in v1.");
+      expect(sql).toContain("mandu db apply");
+      expect(sql).toContain("Column type change detected: users.age");
+      expect(sql).toContain("from: number");
+      expect(sql).toContain("to:   string");
+      expect(sql).toContain("mandu_manual_migration_required");
+    }
+  });
+
+  test("includes a deliberate failing manual-migration sentinel", () => {
+    const sql = emitChange(change, "postgres");
+    expect(sql).toContain("SELECT mandu_manual_migration_required");
+    expect(sql).not.toContain("SELECT 1;");
+  });
+});
 
 describe("emitChange — alter-column-nullable", () => {
   test("postgres SET NOT NULL / DROP NOT NULL", () => {
@@ -510,24 +611,24 @@ describe("emitChange — alter-column-nullable", () => {
     ).toBe('ALTER TABLE "users" ALTER COLUMN "email" DROP NOT NULL;');
   });
 
-  test("sqlite emits a stub (cannot toggle NOT NULL in place)", () => {
-    const sql = emitChange(
-      { kind: "alter-column-nullable", resourceName: "users", fieldName: "email", nullable: true },
-      "sqlite",
-    );
-    expect(sql).toContain("TODO: SQLite cannot toggle NOT NULL in place");
-    expect(sql).toContain("SELECT 1;");
-  });
-
-  test("mysql emits a stub (MODIFY COLUMN needs full type)", () => {
-    const sql = emitChange(
-      { kind: "alter-column-nullable", resourceName: "users", fieldName: "email", nullable: false },
-      "mysql",
-    );
-    expect(sql).toContain("MySQL MODIFY COLUMN requires");
-    expect(sql).toContain("SELECT 1;");
-  });
-});
+  test("sqlite emits a stub (cannot toggle NOT NULL in place)", () => {
+    const sql = emitChange(
+      { kind: "alter-column-nullable", resourceName: "users", fieldName: "email", nullable: true },
+      "sqlite",
+    );
+    expect(sql).toContain("TODO: SQLite cannot toggle NOT NULL in place");
+    expect(sql).toContain("mandu_manual_migration_required");
+  });
+
+  test("mysql emits a stub (MODIFY COLUMN needs full type)", () => {
+    const sql = emitChange(
+      { kind: "alter-column-nullable", resourceName: "users", fieldName: "email", nullable: false },
+      "mysql",
+    );
+    expect(sql).toContain("MySQL MODIFY COLUMN requires");
+    expect(sql).toContain("mandu_manual_migration_required");
+  });
+});
 
 describe("emitChange — alter-column-default", () => {
   test("postgres SET DEFAULT", () => {
@@ -551,20 +652,35 @@ describe("emitChange — alter-column-default", () => {
     expect(sql).toBe('ALTER TABLE "users" ALTER COLUMN "status" DROP DEFAULT;');
   });
 
-  test("mysql supports SET/DROP DEFAULT directly", () => {
-    expect(
-      emitChange(
-        {
+  test("mysql supports SET/DROP DEFAULT directly", () => {
+    expect(
+      emitChange(
+        {
           kind: "alter-column-default",
           resourceName: "u",
           fieldName: "f",
           default: { kind: "literal", value: 1 },
         },
         "mysql",
-      ),
-    ).toBe("ALTER TABLE `u` ALTER COLUMN `f` SET DEFAULT 1;");
-  });
-});
+      ),
+    ).toBe("ALTER TABLE `u` ALTER COLUMN `f` SET DEFAULT 1;");
+  });
+
+  test("sqlite emits a failing manual stub for default changes", () => {
+    const sql = emitChange(
+      {
+        kind: "alter-column-default",
+        resourceName: "users",
+        fieldName: "status",
+        default: { kind: "literal", value: "active" },
+      },
+      "sqlite",
+    );
+    expect(sql).toContain("TODO: SQLite cannot ALTER DEFAULT in place");
+    expect(sql).toContain("mandu_manual_migration_required");
+    expect(sql).not.toContain("SELECT 1;");
+  });
+});
 
 describe("emitChange — indexes", () => {
   test("add-index single column, non-unique", () => {