@mandujs/core 0.54.12 → 0.54.13

package/src/index.ts

@@ -22,34 +22,24 @@ export const __MANDU_CORE_VERSION__: string = (() => {
 })();
 
 export * from "./spec";
-export * from "./agent";
 export * from "./runtime";
-export * from "./generator";
 export * from "./guard";
 export * from "./report";
 export * from "./filling";
-export * from "./change";
 export * from "./errors";
 export * from "./logging";
 export * from "./slot";
-export * from "./bundler";
 export * from "./contract";
 export * from "./openapi";
-export * from "./brain";
-export * from "./watcher";
 export * from "./router";
 export * from "./config";
-export * from "./lockfile";
 export * from "./utils";
 export * from "./seo";
 export * from "./island";
 export * from "./intent";
-export * from "./devtools";
-export * from "./paths";
 export * from "./observability";
 export * from "./resource";
 export * from "./types";
-export * from "./kitchen";
 export { runHook } from "./plugins";
 export type { ManduPlugin, ManduHooks } from "./plugins";
 

package/src/internal/index.ts

@@ -0,0 +1,25 @@
+export * as bundler from "../bundler";
+export * as change from "../change";
+export * as generator from "../generator";
+export * as lockfile from "../lockfile";
+export * as paths from "../paths";
+export * as report from "../report";
+export * as spec from "../spec";
+export * as utils from "../utils";
+export * as watcher from "../watcher";
+
+export * as runtimeCache from "../runtime/cache";
+export * as runtimeRouter from "../runtime/router";
+export * as runtimeServer from "../runtime/server";
+export * as runtimeFastRefreshTypes from "../runtime/fast-refresh-types";
+
+export * as resourceDdlDiff from "../resource/ddl/diff";
+export * as resourceDdlEmit from "../resource/ddl/emit";
+export * as resourceDdlSnapshot from "../resource/ddl/snapshot";
+export * as resourceDdlTypeMap from "../resource/ddl/type-map";
+export * as resourceDdlTypes from "../resource/ddl/types";
+export * as resourceGeneratorRepo from "../resource/generator-repo";
+
+export * as pluginRunner from "../plugins/runner";
+export * as devErrorOverlay from "../dev-error-overlay";
+export * as tsgolintBridge from "../guard/tsgolint-bridge";

package/src/kitchen/api/file-api.ts

@@ -229,17 +229,17 @@ export class FileAPI {
     for (const line of stdout.split("\n")) {
       if (!line.trim()) continue;
 
-      const statusCode = line.substring(0, 2);
-      const gitFilePath = line.substring(3).trim();
-      const filePath = this.getProjectRelativePath(gitFilePath, gitRoot);
-      if (!filePath || filePath === ".") {
-        continue;
-      }
-
-      changes.push({
-        filePath,
-        status: parseGitStatus(statusCode),
-      });
+      const statusCode = line.substring(0, 2);
+      const gitFilePath = line.substring(3).trim();
+      const filePath = this.getProjectRelativePath(gitFilePath, gitRoot);
+      if (!filePath || filePath === ".") {
+        continue;
+      }
+
+      changes.push({
+        filePath,
+        status: parseGitStatus(statusCode),
+      });
     }
 
     return changes;

package/src/report/index.ts

@@ -1 +1 @@
-export * from "./build";
+export * from "./build";

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

@@ -671,12 +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.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"]);
+      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/__tests__/schema.test.ts

@@ -108,20 +108,20 @@ describe("validateResourceDefinition", () => {
 });
 
 describe("getPluralName", () => {
-  test("should add 's' for simple pluralization", () => {
-    const result = getPluralName(userResourceFixture);
-    expect(result).toBe("users");
-  });
-
-  test("should use conservative English pluralization for common resource names", () => {
-    expect(getPluralName({ ...minimalResourceFixture, name: "party" })).toBe("parties");
-    expect(getPluralName({ ...minimalResourceFixture, name: "box" })).toBe("boxes");
-  });
-
-  test("should use custom plural name if provided", () => {
-    const result = getPluralName(productResourceFixture);
-    expect(result).toBe("inventory");
-  });
+  test("should add 's' for simple pluralization", () => {
+    const result = getPluralName(userResourceFixture);
+    expect(result).toBe("users");
+  });
+
+  test("should use conservative English pluralization for common resource names", () => {
+    expect(getPluralName({ ...minimalResourceFixture, name: "party" })).toBe("parties");
+    expect(getPluralName({ ...minimalResourceFixture, name: "box" })).toBe("boxes");
+  });
+
+  test("should use custom plural name if provided", () => {
+    const result = getPluralName(productResourceFixture);
+    expect(result).toBe("inventory");
+  });
 
   test("should respect autoPlural: false", () => {
     const definition = {

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

@@ -415,112 +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("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 = {
+  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 }),
@@ -576,24 +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");
-      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;");
-  });
-});
+  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", () => {
@@ -611,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("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");
-  });
-});
+  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", () => {
@@ -652,35 +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;");
-  });
-
-  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;");
-  });
-});
+      ),
+    ).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", () => {