@mandujs/core 0.53.0 → 0.53.2

package/src/openapi/openapi.test.ts

@@ -16,9 +16,34 @@ import {
 } from "./generator";
 import type { OpenAPIDocument } from "./generator";
 import type { RoutesManifest } from "../spec/schema";
-import fs from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+async function linkWorkspaceNodeModules(rootDir: string): Promise<void> {
+  const workspaceNodeModules = path.join(process.cwd(), "node_modules");
+  const fixtureNodeModules = path.join(rootDir, "node_modules");
+
+  try {
+    await fs.access(workspaceNodeModules);
+  } catch {
+    return;
+  }
+
+  try {
+    await fs.symlink(
+      workspaceNodeModules,
+      fixtureNodeModules,
+      process.platform === "win32" ? "junction" : "dir"
+    );
+  } catch (error) {
+    try {
+      await fs.access(fixtureNodeModules);
+    } catch {
+      throw error;
+    }
+  }
+}
 
 describe("zodToOpenAPISchema", () => {
   describe("primitive types", () => {
@@ -321,9 +346,10 @@ describe("Real-world contract conversion", () => {
  * exercise the full build pipeline (generate + write + read) without
  * faking the dynamic import path.
  */
-async function buildFixture(): Promise<{ rootDir: string; manifest: RoutesManifest; cleanup: () => Promise<void> }> {
-  const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-openapi-"));
-  const contractPath = "contracts/users.contract.ts";
+async function buildFixture(): Promise<{ rootDir: string; manifest: RoutesManifest; cleanup: () => Promise<void> }> {
+  const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-openapi-"));
+  await linkWorkspaceNodeModules(rootDir);
+  const contractPath = "contracts/users.contract.ts";
   const contractAbs = path.join(rootDir, contractPath);
   await fs.mkdir(path.dirname(contractAbs), { recursive: true });
   await fs.writeFile(
@@ -534,8 +560,9 @@ async function buildSharedSchemaFixture(opts: {
   manifest: RoutesManifest;
   cleanup: () => Promise<void>;
 }> {
-  const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-openapi-hoist-"));
-  const [nameA, nameB] = opts.contractNames ?? ["users", "admins"];
+  const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-openapi-hoist-"));
+  await linkWorkspaceNodeModules(rootDir);
+  const [nameA, nameB] = opts.contractNames ?? ["users", "admins"];
   const bodyB =
     opts.secondBody ??
     `z.object({ name: z.string().min(2), email: z.string().email() })`;
@@ -642,9 +669,10 @@ describe("hoistSharedSchemas", () => {
   });
 
   test("one-off schema stays inline (no hoist, no components.schemas entry for it)", async () => {
-    const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-openapi-oneoff-"));
-    try {
-      await fs.mkdir(path.join(rootDir, "contracts"), { recursive: true });
+    const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-openapi-oneoff-"));
+    try {
+      await linkWorkspaceNodeModules(rootDir);
+      await fs.mkdir(path.join(rootDir, "contracts"), { recursive: true });
       await fs.writeFile(
         path.join(rootDir, "contracts/solo.contract.ts"),
         `import { z } from "zod";
@@ -816,9 +844,10 @@ export default {
   });
 
   test("enum / primitive schemas are never hoisted", async () => {
-    const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-openapi-enum-"));
-    try {
-      await fs.mkdir(path.join(rootDir, "contracts"), { recursive: true });
+    const rootDir = await fs.mkdtemp(path.join(os.tmpdir(), "mandu-openapi-enum-"));
+    try {
+      await linkWorkspaceNodeModules(rootDir);
+      await fs.mkdir(path.join(rootDir, "contracts"), { recursive: true });
       const contractBody = `import { z } from "zod";
 export default {
   name: NAME,

package/src/perf/user-marks.ts

@@ -62,7 +62,7 @@
  */
 
 import { isPerfEnabled } from "./index";
-import { getTracer, getActiveSpan, runWithSpan, type Span } from "../observability/tracing";
+import { getTracer, runWithSpan, type Span } from "../observability/tracing";
 
 // ─── Types ──────────────────────────────────────────────────────────────
 

package/src/plugins/registry.ts

@@ -11,7 +11,6 @@ import type {
   Plugin,
   PluginApi,
   PluginCategory,
-  PluginMeta,
   GuardPresetPlugin,
   BuildPlugin,
   LoggerTransportPlugin,
@@ -22,7 +21,7 @@ import type {
 /**
  * 플러그인 등록 상태
  */
-type PluginState = "pending" | "loaded" | "error" | "unloaded";
+type _PluginState = "pending" | "loaded" | "error" | "unloaded";
 
 /**
  * 등록된 플러그인 정보 (discriminated union by state)

package/src/plugins/types.ts

@@ -7,7 +7,7 @@
  * - 라이프사이클 훅
  */
 
-import type { z, ZodSchema } from "zod";
+import type { ZodSchema } from "zod";
 
 /**
  * 플러그인 카테고리

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

@@ -574,7 +574,7 @@ describe("generateRepoSource — emission shape", () => {
     expect(generateRepoSource(nonPersistent, { enable: false })).toBeNull();
   });
 
-  test("postgres/sqlite emit INSERT ... RETURNING, mysql emits INSERT + SELECT LAST_INSERT_ID", () => {
+  test("postgres/sqlite emit INSERT ... RETURNING, mysql emits INSERT + primary-key re-select", () => {
     // Assert on SQL in the emitted code rather than on comments —
     // comments reference "RETURNING" as prose across all three providers.
     // The discriminator we check is the actual SQL keyword on an insert
@@ -585,20 +585,37 @@ describe("generateRepoSource — emission shape", () => {
     const sqlite = generateRepoSource(persistentResource("user", "sqlite"))!;
     expect(sqlite).toMatch(/INSERT INTO[\s\S]*?RETURNING/);
 
-    const mysql = generateRepoSource(persistentResource("user", "mysql"))!;
-    expect(mysql).not.toMatch(/INSERT INTO[\s\S]*?RETURNING/);
-    expect(mysql).toContain("LAST_INSERT_ID()");
-  });
-
-  test("mysql repo uses backtick identifiers, postgres uses double quotes", () => {
-    const mysql = generateRepoSource(persistentResource("user", "mysql"))!;
-    expect(mysql).toContain("`users`");
-    expect(mysql).not.toContain(`"users"`);
-
-    const pg = generateRepoSource(persistentResource("user", "postgres"))!;
-    expect(pg).toContain(`"users"`);
-    expect(pg).not.toContain("`users`");
-  });
+    const mysql = generateRepoSource(persistentResource("user", "mysql"))!;
+    expect(mysql).not.toMatch(/INSERT INTO[\s\S]*?RETURNING/);
+    expect(mysql).toContain("WHERE \\`id\\` = ${input.id}");
+    expect(mysql).not.toContain("WHERE \\`id\\` = LAST_INSERT_ID()");
+  });
+
+  test("mysql repo escapes backtick identifiers for generated template literals, postgres uses double quotes", () => {
+    const mysql = generateRepoSource(persistentResource("user", "mysql"))!;
+    expect(mysql).toContain("\\`users\\`");
+    expect(mysql).not.toContain(`"users"`);
+
+    const pg = generateRepoSource(persistentResource("user", "postgres"))!;
+    expect(pg).toContain(`"users"`);
+    expect(pg).not.toContain("\\`users\\`");
+  });
+
+  test("create input includes primary key unless the primary key has a DB default", () => {
+    const callerSuppliedPk = generateRepoSource(persistentResource("user", "postgres"))!;
+    expect(callerSuppliedPk).toContain("async create(input: User)");
+    expect(callerSuppliedPk).toContain("${input.id}");
+    expect(callerSuppliedPk).not.toContain('async create(input: Omit<User, "id">)');
+
+    const dbGeneratedPk = persistentResource("token", "postgres");
+    dbGeneratedPk.definition.fields.id = {
+      ...dbGeneratedPk.definition.fields.id,
+      default: "gen_random_uuid()",
+    };
+    const src = generateRepoSource(dbGeneratedPk)!;
+    expect(src).toContain('async create(input: Omit<Token, "id">)');
+    expect(src).not.toMatch(/INSERT INTO[\s\S]*"id"[\s\S]*VALUES/);
+  });
 
   test("shouldEmitRepo returns true only when persistence is declared", () => {
     const persistent = persistentResource("user");

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

@@ -419,6 +419,30 @@ describe("emitChange — add-column", () => {
     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 = {
+      kind: "add-column",
+      resourceName: "users",
+      field: field({ name: "role", type: "string", indexed: true }),
+    };
+
+    expect(emitChange(indexed, "postgres")).toBe(
+      [
+        'ALTER TABLE "users" ADD COLUMN "role" TEXT NOT NULL;',
+        'CREATE INDEX "idx_users_role" ON "users" ("role");',
+      ].join("\n"),
+    );
+  });
+
+  test("indexed:true unique or primary add-column does not create redundant index", () => {
+    const unique: Change = {
+      kind: "add-column",
+      resourceName: "users",
+      field: field({ name: "slug", type: "string", indexed: true, unique: true }),
+    };
+    expect(emitChange(unique, "postgres")).not.toContain("idx_users_slug");
+  });
 });
 
 describe("emitChange — drop-column", () => {

package/src/resource/ddl/diff.ts

@@ -62,7 +62,6 @@ import type { ParsedResource } from "../parser";
 import type {
   Change,
   DdlDefault,
-  DdlFieldDef,
   DdlIndex,
   DdlResource,
   Snapshot,

package/src/resource/ddl/emit.ts

@@ -345,7 +345,18 @@ function emitAddColumn(
 ): string {
   const table = quoteIdent(resourceName, provider);
   const columnDef = emitColumnDef(field, provider);
-  return `ALTER TABLE ${table} ADD COLUMN ${columnDef};`;
+  const addColumn = `ALTER TABLE ${table} ADD COLUMN ${columnDef};`;
+  if (!field.indexed || field.unique || field.primary) return addColumn;
+  return [
+    addColumn,
+    emitCreateIndex(
+      resourceName,
+      autoIndexName(resourceName, field.name),
+      [field.name],
+      false,
+      provider,
+    ),
+  ].join("\n");
 }
 
 /**

package/src/resource/generator-repo.ts

@@ -35,7 +35,7 @@
  *     return {
  *       async findById(id): User | null { ... },
  *       async findMany(limit = 100, offset = 0): User[] { ... },
- *       async create(row): User { ... },   // PG/SQLite: RETURNING *; MySQL: INSERT + SELECT
+ *       async create(row): User { ... },   // PG/SQLite: RETURNING *; MySQL: INSERT + re-select
  *       async update(id, patch): User | null { ... },
  *       async delete(id): boolean { ... },
  *     };
@@ -65,7 +65,7 @@ import type { ParsedResource } from "./parser";
 import type { ResourceField } from "./schema";
 import { quoteIdent } from "./ddl/emit";
 import { toSnakeCase } from "./ddl/snapshot";
-import { asPersistence, type ExtendedResourcePersistence } from "./ddl/persistence-types";
+import { asPersistence, type ExtendedResourcePersistence, type FieldOverride } from "./ddl/persistence-types";
 import type { SqlProvider } from "./ddl/types";
 
 // ============================================
@@ -172,9 +172,10 @@ function renderRepoFile(
   const primaryKeyColumn = columns.find((c) => c.primary)?.column ?? "id";
   const primaryKeyField = columns.find((c) => c.primary)?.field ?? "id";
   const insertColumns = columns.filter((c) => !c.omitOnInsert);
+  const createInputType = createMethodInputType(pascalName, columns);
 
   // Quoted identifiers — precomputed so each builder reads cleanly.
-  const q = (name: string) => quoteIdent(name, provider);
+  const q = (name: string) => escapeSqlTemplateText(quoteIdent(name, provider));
   const qTable = q(table);
 
   // Column list for SELECT: we don't use `*` because aliasing
@@ -194,7 +195,7 @@ function renderRepoFile(
   const body = [
     findByIdMethod(pascalName, qTable, selectList, q, primaryKeyColumn, primaryKeyField),
     findManyMethod(pascalName, qTable, selectList),
-    createMethod(pascalName, table, qTable, selectList, insertColumns, primaryKeyColumn, primaryKeyField, q, provider),
+    createMethod(pascalName, table, qTable, selectList, insertColumns, createInputType, primaryKeyColumn, primaryKeyField, q, provider),
     updateMethod(pascalName, table, qTable, selectList, columns, primaryKeyColumn, primaryKeyField, q, provider),
     deleteMethod(pascalName, qTable, q, primaryKeyColumn, primaryKeyField, provider),
   ].join(",\n\n");
@@ -232,7 +233,7 @@ function renderHeader(
 // - The repo never constructs a Db itself — callers (slots, scripts) pass
 //   in either \`ctx.deps.db\` or a module-level singleton.
 // - Provider-specific SQL (INSERT ... RETURNING * on PG/SQLite vs
-//   INSERT + SELECT LAST_INSERT_ID on MySQL) is resolved at generation
+//   INSERT + re-select on MySQL) is resolved at generation
 //   time; the generated file has one code path per provider.
 `;
 }
@@ -348,6 +349,7 @@ function createMethod(
   qTable: string,
   selectList: string,
   insertColumns: ResolvedColumn[],
+  createInputType: string,
   pkColumn: string,
   pkField: string,
   q: (n: string) => string,
@@ -371,7 +373,7 @@ function createMethod(
      * Insert a new row and return the inserted record. Errors from
      * constraint violations (UNIQUE, NOT NULL, FK) bubble unchanged.
      */
-    async create(input: Omit<${pascalName}, "${pkField}">): Promise<${pascalName}> {
+    async create(input: ${createInputType}): Promise<${pascalName}> {
       const row = await db.one<${pascalName}>\`
         INSERT INTO ${qTable} (${columnList})
         VALUES (${valuePlaceholders})
@@ -382,17 +384,20 @@ function createMethod(
     }`;
   }
 
-  // MySQL: no RETURNING. INSERT then SELECT by LAST_INSERT_ID() OR by the
-  // primary key if caller provided one. For v1 LCD we use a post-INSERT
-  // SELECT that matches on the primary-key the caller supplied; if the
-  // caller omitted it (AUTO_INCREMENT), we fall back to LAST_INSERT_ID().
+  const mysqlLookup = insertColumns.some((c) => c.field === pkField)
+    ? `${q(pkColumn)} = \${input.${pkField}}`
+    : `${q(pkColumn)} = LAST_INSERT_ID()`;
+
+  // MySQL: no RETURNING. INSERT then SELECT by the supplied primary key when
+  // the caller provides it; if the primary key is DB-generated, fall back to
+  // LAST_INSERT_ID().
   return `    /**
      * Insert a new row and return the inserted record via a follow-up SELECT.
      * MySQL lacks RETURNING; the generator uses LAST_INSERT_ID() when the
      * primary key is server-generated, otherwise it re-selects by the
      * provided primary key value.
      */
-    async create(input: Omit<${pascalName}, "${pkField}">): Promise<${pascalName}> {
+    async create(input: ${createInputType}): Promise<${pascalName}> {
       await db\`
         INSERT INTO ${qTable} (${columnList})
         VALUES (${valuePlaceholders})
@@ -400,7 +405,7 @@ function createMethod(
       const row = await db.one<${pascalName}>\`
         SELECT ${selectList}
         FROM ${qTable}
-        WHERE ${q(pkColumn)} = LAST_INSERT_ID()
+        WHERE ${mysqlLookup}
       \`;
       if (!row) throw new Error("${tableName} create: follow-up SELECT returned no row");
       return row;
@@ -541,14 +546,7 @@ function resolveColumns(
     const primary = declaredPkMatch || fieldLevelPk;
     if (primary) pkCount++;
 
-    // Omit PK from INSERT list only when:
-    //   - it's a UUID with a DB-side default (we don't know this at
-    //     generation time for all providers); OR
-    //   - it's an integer and the user didn't explicitly opt in.
-    // Safe default: let the user supply the PK. The generated
-    // `Omit<T, pkField>` on `create` means the caller CAN'T pass it
-    // anyway, so we omit PK from the insert column list unconditionally.
-    const omitOnInsert = primary;
+    const omitOnInsert = primary && hasDbDefault(field, override);
 
     columns.push({ field: fieldKey, column, primary, omitOnInsert });
   }
@@ -575,6 +573,28 @@ function resolveDeclaredPrimaryKey(
   return declared[0];
 }
 
+function createMethodInputType(
+  pascalName: string,
+  columns: ResolvedColumn[],
+): string {
+  const omittedFields = columns
+    .filter((c) => c.omitOnInsert)
+    .map((c) => JSON.stringify(c.field));
+  if (omittedFields.length === 0) return pascalName;
+  return `Omit<${pascalName}, ${omittedFields.join(" | ")}>`;
+}
+
+function hasDbDefault(
+  field: ResourceField,
+  override: FieldOverride | undefined,
+): boolean {
+  return override?.default !== undefined || field.default !== undefined;
+}
+
+function escapeSqlTemplateText(text: string): string {
+  return text.replace(/`/g, "\\`");
+}
+
 function resolveTableName(
   resource: ParsedResource,
   persistence: ExtendedResourcePersistence,

package/src/resource/generator.ts

@@ -74,7 +74,7 @@ async function fileExists(filePath: string): Promise<boolean> {
 async function ensureDir(dirPath: string): Promise<void> {
   try {
     await fs.mkdir(dirPath, { recursive: true });
-  } catch (error) {
+  } catch  {
     // Ignore if exists
   }
 }

package/src/resource/generators/contract.ts

@@ -14,7 +14,7 @@ import { getPluralName, getEnabledEndpoints } from "../schema";
 export function generateResourceContract(definition: ResourceDefinition): string {
   const resourceName = definition.name;
   const pascalName = toPascalCase(resourceName);
-  const pluralName = getPluralName(definition);
+  const _pluralName = getPluralName(definition);
   const endpoints = getEnabledEndpoints(definition);
 
   // Generate schema definitions

package/src/resource/schema.ts

@@ -1,3 +1,4 @@
+import type * as __ManduDdlPersistenceTypesTypes0 from "./ddl/persistence-types";
 /**
  * Resource Schema Definition
  * Resource-Centric Architecture의 핵심 스키마 정의
@@ -100,7 +101,7 @@ export interface ResourceOptions {
    * });
    * ```
    */
-  persistence?: import("./ddl/persistence-types").ExtendedResourcePersistence;
+  persistence?: __ManduDdlPersistenceTypesTypes0.ExtendedResourcePersistence;
 }
 
 // ============================================

package/src/router/fs-routes.ts

@@ -451,12 +451,12 @@ export async function watchFSRoutes(
 
   return {
     close() {
-      if (debounceTimer) {
-        clearTimeout(debounceTimer);
-      }
-      routesWatcher.close();
-      specWatcher.close();
-    },
+      if (debounceTimer) {
+        clearTimeout(debounceTimer);
+      }
+      void routesWatcher.close();
+      void specWatcher.close();
+    },
     async rescan() {
       return triggerRescan();
     },

package/src/router/fs-scanner.ts

@@ -228,7 +228,7 @@ export class FSScanner {
    */
   private async createRouteConfigs(
     files: ScannedFile[],
-    rootDir: string
+    _rootDir: string
   ): Promise<{ routes: FSRouteConfig[]; routeErrors: ScanError[] }> {
     const routes: FSRouteConfig[] = [];
     const routeErrors: ScanError[] = [];

package/src/runtime/env.ts

@@ -93,7 +93,7 @@ function parseEnvFile(content: string): Record<string, string> {
 /**
  * 파일이 존재하는지 확인
  */
-async function fileExists(filePath: string): Promise<boolean> {
+async function _fileExists(filePath: string): Promise<boolean> {
   try {
     const file = Bun.file(filePath);
     return await file.exists();

package/src/runtime/image-handler.ts

@@ -1,3 +1,4 @@
+import type * as __ManduFsTypes0 from "fs";
 /**
  * Mandu Image Handler
  * /_mandu/image?url=...&w=...&q=... 엔드포인트
@@ -76,7 +77,7 @@ export async function handleImageRequest(
   // realpath로 symlink를 해석한 후 allowedBaseDir 내부인지 검증
   let resolvedPath: string;
   try {
-    const realFs = require("fs") as typeof import("fs");
+    const realFs = require("fs") as typeof __ManduFsTypes0;
     resolvedPath = realFs.realpathSync(filePath);
     const resolvedBase = realFs.realpathSync(allowedBaseDir);
     if (!resolvedPath.startsWith(resolvedBase + path.sep) && resolvedPath !== resolvedBase) {

package/src/runtime/middleware.ts

@@ -1,3 +1,4 @@
+import type * as __ManduFsTypes0 from "fs";
 /**
  * Mandu Global Middleware
  * 라우트 매칭 전에 실행되는 글로벌 미들웨어 시스템
@@ -227,7 +228,7 @@ export async function loadMiddleware(
 export function loadMiddlewareSync(
   rootDir: string
 ): { fn: MiddlewareFn; config: MiddlewareConfig | null } | null {
-  const fs = require("fs") as typeof import("fs");
+  const fs = require("fs") as typeof __ManduFsTypes0;
   const possiblePaths = [
     `${rootDir}/middleware.ts`,
     `${rootDir}/middleware.js`,