@mandujs/core 0.18.21 → 0.18.22

package/src/contract/define.ts

@@ -28,6 +28,15 @@
  */
 
 import { z, type ZodType, type ZodObject, type ZodRawShape } from 'zod';
+import {
+  getZodTypeName,
+  getZodInnerType,
+  getZodArrayElementType,
+  getZodObjectShape,
+  getZodEnumValues,
+  getZodChecks,
+  isZodRequired,
+} from './zod-utils';
 
 // ============================================================================
 // Types
@@ -58,7 +67,7 @@ export interface EndpointDefinition<
   tags?: string[];
 }
 
-export type ContractDefinition = Record<string, EndpointDefinition<any, any, any>>;
+export type ContractDefinition = Record<string, EndpointDefinition>;
 
 // ============================================================================
 // Contract Metadata
@@ -116,7 +125,7 @@ export function isContract<T extends ContractDefinition>(
   return (
     typeof value === 'object' &&
     value !== null &&
-    (value as ContractMeta<any>).__contract === true
+    (value as ContractMeta<ContractDefinition>).__contract === true
   );
 }
 
@@ -412,8 +421,7 @@ function generateSchemas<T extends ContractDefinition>(
 }
 
 function zodToOpenAPI(schema: ZodType): Record<string, unknown> {
-  const def = (schema as any)._def;
-  const typeName = def.typeName;
+  const typeName = getZodTypeName(schema);
 
   switch (typeName) {
     case 'ZodString':
@@ -422,25 +430,32 @@ function zodToOpenAPI(schema: ZodType): Record<string, unknown> {
       return { type: 'number' };
     case 'ZodBoolean':
       return { type: 'boolean' };
-    case 'ZodArray':
-      return { type: 'array', items: zodToOpenAPI(def.type) };
+    case 'ZodArray': {
+      const elementType = getZodArrayElementType(schema);
+      return { type: 'array', items: elementType ? zodToOpenAPI(elementType) : {} };
+    }
     case 'ZodObject': {
       const properties: Record<string, unknown> = {};
       const required: string[] = [];
-      for (const [key, value] of Object.entries(def.shape())) {
-        properties[key] = zodToOpenAPI(value as ZodType);
-        if (!(value as any).isOptional?.()) {
+      const shape = getZodObjectShape(schema) ?? {};
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToOpenAPI(value);
+        if (isZodRequired(value)) {
           required.push(key);
         }
       }
       return { type: 'object', properties, required };
     }
-    case 'ZodOptional':
-      return zodToOpenAPI(def.innerType);
-    case 'ZodNullable':
-      return { ...zodToOpenAPI(def.innerType), nullable: true };
+    case 'ZodOptional': {
+      const inner = getZodInnerType(schema);
+      return inner ? zodToOpenAPI(inner) : {};
+    }
+    case 'ZodNullable': {
+      const inner = getZodInnerType(schema);
+      return { ...(inner ? zodToOpenAPI(inner) : {}), nullable: true };
+    }
     case 'ZodEnum':
-      return { type: 'string', enum: def.values };
+      return { type: 'string', enum: getZodEnumValues(schema) };
     default:
       return { type: 'object' };
   }

package/src/contract/handler.ts

@@ -5,13 +5,13 @@
  * Elysia 패턴 채택: Contract → Handler 타입 자동 추론
  */
 
-import type { z } from "zod";
-import type {
-  ContractSchema,
-  ContractMethod,
-  MethodRequestSchema,
-} from "./schema";
-import type { InferResponseSchema } from "./types";
+import type { z } from "zod";
+import type {
+  ContractSchema,
+  ContractMethod,
+  MethodRequestSchema,
+} from "./schema";
+import type { InferResponseSchema } from "./types";
 
 /**
  * Typed request context for a handler
@@ -62,9 +62,9 @@ export type HandlerFn<TContext, TResponse> = (
 /**
  * Infer response type union from contract response schema
  */
-type InferResponseUnion<TResponse extends ContractSchema["response"]> = {
-  [K in keyof TResponse]: InferResponseSchema<TResponse[K]>;
-}[keyof TResponse];
+type InferResponseUnion<TResponse extends ContractSchema["response"]> = {
+  [K in keyof TResponse]: InferResponseSchema<TResponse[K]>;
+}[keyof TResponse];
 
 /**
  * Handler definition for all methods in a contract
@@ -96,7 +96,7 @@ type InferResponseUnion<TResponse extends ContractSchema["response"]> = {
  * ```
  */
 export type ContractHandlers<T extends ContractSchema> = {
-  [M in Extract<keyof T["request"], ContractMethod>]?: HandlerFn<
+  [M in ContractMethod as M extends keyof T["request"] ? M : never]?: HandlerFn<
     InferContextFromMethod<
       T["request"][M] extends MethodRequestSchema ? T["request"][M] : undefined
     >,

package/src/contract/normalize.test.ts

@@ -42,7 +42,7 @@ describe("normalizeData", () => {
     const input = { name: "Kim", age: 25, admin: true };
     const result = normalizeData(schema, input, { mode: "passthrough" });
 
-    expect(result).toEqual({ name: "Kim", age: 25, admin: true });
+    expect(result as Record<string, unknown>).toEqual({ name: "Kim", age: 25, admin: true });
   });
 
   test("기본 모드는 strip", () => {

package/src/contract/normalize.ts

@@ -21,6 +21,12 @@
  */
 
 import { z, type ZodTypeAny, type ZodObject, type ZodRawShape } from "zod";
+import {
+  getZodChecks,
+  getZodInnerType,
+  getZodArrayElementType,
+  getZodDefaultValue,
+} from "./zod-utils";
 
 /**
  * 정규화 모드
@@ -249,18 +255,18 @@ function applyCoercion(schema: ZodTypeAny): ZodTypeAny {
   if (schema instanceof z.ZodNumber) {
     let coerced = z.coerce.number();
     // 기존 체크 유지 (min, max 등)
-    const checks = (schema as any)._def.checks || [];
+    const checks = getZodChecks(schema);
     for (const check of checks) {
       switch (check.kind) {
         case "min":
           coerced = check.inclusive
-            ? coerced.gte(check.value)
-            : coerced.gt(check.value);
+            ? coerced.gte(check.value!)
+            : coerced.gt(check.value!);
           break;
         case "max":
           coerced = check.inclusive
-            ? coerced.lte(check.value)
-            : coerced.lt(check.value);
+            ? coerced.lte(check.value!)
+            : coerced.lt(check.value!);
           break;
         case "int":
           coerced = coerced.int();
@@ -294,23 +300,23 @@ function applyCoercion(schema: ZodTypeAny): ZodTypeAny {
 
   // ZodOptional → 내부 스키마에 coercion 적용
   if (schema instanceof z.ZodOptional) {
-    return applyCoercion((schema as any)._def.innerType).optional();
+    return applyCoercion(getZodInnerType(schema)!).optional();
   }
 
   // ZodDefault → 내부 스키마에 coercion 적용
   if (schema instanceof z.ZodDefault) {
-    const inner = applyCoercion((schema as any)._def.innerType);
-    return inner.default((schema as any)._def.defaultValue());
+    const inner = applyCoercion(getZodInnerType(schema)!);
+    return inner.default(getZodDefaultValue(schema));
   }
 
   // ZodNullable → 내부 스키마에 coercion 적용
   if (schema instanceof z.ZodNullable) {
-    return applyCoercion((schema as any)._def.innerType).nullable();
+    return applyCoercion(getZodInnerType(schema)!).nullable();
   }
 
   // ZodArray → 배열 요소에 coercion 적용 (쿼리스트링 배열)
   if (schema instanceof z.ZodArray) {
-    return z.array(applyCoercion((schema as any)._def.type));
+    return z.array(applyCoercion(getZodArrayElementType(schema)!));
   }
 
   // 그 외는 원본 반환

package/src/contract/registry.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from "bun:test";
 import { diffContractRegistry, type ContractRegistry } from "./registry";
 
 describe("Contract registry diff", () => {

package/src/contract/zod-utils.ts

@@ -0,0 +1,155 @@
+/**
+ * Zod Internal Access Utilities
+ *
+ * Zod 스키마의 내부 `_def` 속성에 접근하는 로직을 중앙화합니다.
+ * `as any` 캐스팅은 이 파일 내부에만 존재하며,
+ * 외부에는 타입 안전한 API만 노출합니다.
+ */
+
+import type { ZodTypeAny } from "zod";
+
+// ============================================================================
+// Internal _def access (as any is confined here)
+// ============================================================================
+
+interface ZodDef {
+  typeName: string;
+  innerType?: ZodTypeAny;
+  type?: ZodTypeAny;
+  schema?: ZodTypeAny;
+  shape?: () => Record<string, ZodTypeAny>;
+  checks?: ReadonlyArray<{ kind: string; value?: number; inclusive?: boolean; regex?: RegExp }>;
+  values?: readonly unknown[];
+  options?: readonly ZodTypeAny[];
+  value?: unknown;
+  defaultValue?: () => unknown;
+  description?: string;
+}
+
+/**
+ * Zod 스키마의 내부 _def 속성을 안전하게 추출합니다.
+ */
+function getDef(schema: ZodTypeAny): ZodDef {
+  return (schema as any)._def;
+}
+
+// ============================================================================
+// Type Name
+// ============================================================================
+
+/** Zod 스키마의 typeName을 반환합니다. */
+export function getZodTypeName(schema: ZodTypeAny): string {
+  return getDef(schema).typeName;
+}
+
+// ============================================================================
+// Inner Type Access
+// ============================================================================
+
+/**
+ * ZodOptional, ZodNullable, ZodDefault 등 래퍼 스키마의 내부 타입을 반환합니다.
+ * `_def.innerType`에 해당합니다.
+ */
+export function getZodInnerType(schema: ZodTypeAny): ZodTypeAny | undefined {
+  return getDef(schema).innerType;
+}
+
+/**
+ * ZodArray의 요소 타입을 반환합니다.
+ * `_def.type`에 해당합니다.
+ */
+export function getZodArrayElementType(schema: ZodTypeAny): ZodTypeAny | undefined {
+  return getDef(schema).type;
+}
+
+/**
+ * ZodEffects의 내부 스키마를 반환합니다.
+ * `_def.schema`에 해당합니다.
+ */
+export function getZodEffectsSchema(schema: ZodTypeAny): ZodTypeAny | undefined {
+  return getDef(schema).schema;
+}
+
+// ============================================================================
+// Object Shape
+// ============================================================================
+
+/**
+ * ZodObject의 shape를 반환합니다.
+ * `_def.shape()`에 해당합니다.
+ */
+export function getZodObjectShape(schema: ZodTypeAny): Record<string, ZodTypeAny> | undefined {
+  const def = getDef(schema);
+  return typeof def.shape === "function" ? def.shape() : undefined;
+}
+
+// ============================================================================
+// Checks (validation rules)
+// ============================================================================
+
+interface ZodCheck {
+  kind: string;
+  value?: number;
+  inclusive?: boolean;
+  regex?: RegExp;
+}
+
+/**
+ * ZodString, ZodNumber 등의 validation checks를 반환합니다.
+ * `_def.checks`에 해당합니다.
+ */
+export function getZodChecks(schema: ZodTypeAny): readonly ZodCheck[] {
+  return getDef(schema).checks ?? [];
+}
+
+// ============================================================================
+// Enum / Literal / Union
+// ============================================================================
+
+/** ZodEnum의 values를 반환합니다. */
+export function getZodEnumValues(schema: ZodTypeAny): readonly unknown[] | undefined {
+  return getDef(schema).values;
+}
+
+/** ZodUnion의 options를 반환합니다. */
+export function getZodUnionOptions(schema: ZodTypeAny): readonly ZodTypeAny[] | undefined {
+  return getDef(schema).options;
+}
+
+/** ZodLiteral의 value를 반환합니다. */
+export function getZodLiteralValue(schema: ZodTypeAny): unknown {
+  return getDef(schema).value;
+}
+
+// ============================================================================
+// Default Value
+// ============================================================================
+
+/**
+ * ZodDefault의 기본값을 반환합니다.
+ * `_def.defaultValue()`에 해당합니다.
+ */
+export function getZodDefaultValue(schema: ZodTypeAny): unknown {
+  const fn = getDef(schema).defaultValue;
+  return typeof fn === "function" ? fn() : undefined;
+}
+
+// ============================================================================
+// Type Predicates
+// ============================================================================
+
+/** 스키마가 ZodOptional인지 확인합니다. */
+export function isZodOptional(schema: ZodTypeAny): boolean {
+  return getZodTypeName(schema) === "ZodOptional";
+}
+
+/** 스키마가 ZodDefault인지 확인합니다. */
+export function isZodDefault(schema: ZodTypeAny): boolean {
+  return getZodTypeName(schema) === "ZodDefault";
+}
+
+/** 필드가 required인지 확인합니다 (Optional/Default가 아닌 경우). */
+export function isZodRequired(schema: ZodTypeAny): boolean {
+  const typeName = getZodTypeName(schema);
+  return typeName !== "ZodOptional" && typeName !== "ZodDefault";
+}

package/src/devtools/client/catchers/network-proxy.ts

@@ -158,7 +158,7 @@ export class NetworkProxy {
     const self = this;
     const originalFetch = this.originalFetch;
 
-    (window as any).fetch = async function(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+    const interceptedFetch = async function(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
       const url = typeof input === 'string'
         ? input
         : input instanceof URL
@@ -227,6 +227,10 @@ export class NetworkProxy {
         throw error;
       }
     };
+
+    // Bun's fetch type includes `preconnect`, use Object.assign to preserve it
+    Object.assign(interceptedFetch, { preconnect: window.fetch.preconnect });
+    window.fetch = interceptedFetch as typeof fetch;
   }
 
   // --------------------------------------------------------------------------

package/src/devtools/init.ts

@@ -30,7 +30,7 @@ export interface KitchenInstance {
   /** DevTools 언마운트 및 정리 */
   destroy: () => void;
   /** 상태 관리자 접근 */
-  getState: () => any;
+  getState: () => Record<string, unknown>;
   /** 에러 리포트 */
   reportError: (error: Error | string) => void;
   /** DevTools 열기 */
@@ -213,7 +213,7 @@ function createInstance(): KitchenInstance {
 function createNoopInstance(): KitchenInstance {
   return {
     destroy: () => {},
-    getState: () => ({} as any),
+    getState: () => ({}),
     reportError: () => {},
     open: () => {},
     close: () => {},

package/src/devtools/server/source-context.ts

@@ -235,8 +235,14 @@ export interface SourcemapParseResult {
 /**
  * 간단한 Sourcemap 파서 (Base64 VLQ 디코딩)
  */
+interface RawSourcemap {
+  mappings: string;
+  sources: string[];
+  names?: string[];
+}
+
 export class SourcemapParser {
-  private sourcemap: any;
+  private sourcemap: RawSourcemap;
 
   constructor(sourcemapContent: string) {
     try {
@@ -405,7 +411,7 @@ export function createViteMiddleware(projectRoot: string) {
   const provider = new SourceContextProvider({ projectRoot });
   const handler = provider.createHandler();
 
-  return async (req: any, res: any, next: () => void) => {
+  return async (req: { url?: string }, res: { setHeader: (key: string, value: string) => void; statusCode: number; end: (data: string) => void }, next: () => void) => {
     // __mandu_source__ 엔드포인트만 처리
     if (!req.url?.startsWith('/api/__mandu_source__')) {
       return next();
@@ -435,7 +441,7 @@ export function manduSourceContextPlugin(options?: Partial<SourceContextProvider
   return {
     name: 'mandu-source-context',
 
-    configureServer(server: any) {
+    configureServer(server: { config: { root?: string }; middlewares: { use: (middleware: ReturnType<typeof createViteMiddleware>) => void } }) {
       const projectRoot = options?.projectRoot ?? server.config.root ?? process.cwd();
 
       server.middlewares.use(createViteMiddleware(projectRoot));

package/src/devtools/worker/redaction-worker.ts

@@ -185,12 +185,14 @@ function handleMessage(request: WorkerRequest): WorkerResponse {
         };
       }
 
-      default:
+      default: {
+        const unknownType: string = request.type;
         return {
           id: request.id,
           success: false,
-          error: `Unknown request type: ${(request as any).type}`,
+          error: `Unknown request type: ${unknownType}`,
         };
+      }
     }
   } catch (error) {
     return {
@@ -202,10 +204,15 @@ function handleMessage(request: WorkerRequest): WorkerResponse {
 }
 
 // Worker 컨텍스트에서만 실행
-if (typeof self !== 'undefined' && typeof (self as any).postMessage === 'function') {
-  self.onmessage = (event: MessageEvent<WorkerRequest>) => {
+interface WorkerSelf {
+  postMessage: (message: WorkerResponse) => void;
+  onmessage: ((event: MessageEvent<WorkerRequest>) => void) | null;
+}
+const workerSelf = typeof self !== 'undefined' ? (self as unknown as WorkerSelf) : undefined;
+if (workerSelf && typeof workerSelf.postMessage === 'function') {
+  workerSelf.onmessage = (event: MessageEvent<WorkerRequest>) => {
     const response = handleMessage(event.data);
-    (self as any).postMessage(response);
+    workerSelf.postMessage(response);
   };
 }
 

package/src/error/index.ts

@@ -38,4 +38,4 @@ export {
 
 // Result helpers
 export type { Result } from "./result";
-export { ok, err, statusFromError, errorToResponse } from "./result";
+export { ok, err, isOk, isErr, statusFromError, errorToResponse } from "./result";

package/src/error/result.ts

@@ -12,6 +12,20 @@ export type Result<T> =
 export const ok = <T>(value: T): Result<T> => ({ ok: true, value });
 export const err = (error: ManduError): Result<never> => ({ ok: false, error });
 
+/**
+ * Result가 성공인지 검사하는 type guard
+ */
+export function isOk<T>(result: Result<T>): result is { ok: true; value: T } {
+  return result.ok === true;
+}
+
+/**
+ * Result가 실패인지 검사하는 type guard
+ */
+export function isErr<T>(result: Result<T>): result is { ok: false; error: ManduError } {
+  return result.ok === false;
+}
+
 /**
  * ManduError -> HTTP status 매핑
  */

package/src/filling/deps.ts

@@ -163,7 +163,7 @@ export function createMockDeps(overrides: Partial<FillingDeps> = {}): FillingDep
 
   return {
     db: {
-      query: async () => [] as any,
+      query: async () => [] as never,
       transaction: async (fn) => fn(),
     },
     cache: {

package/src/generator/templates.ts

@@ -304,7 +304,7 @@ interface Props {
 }
 
 function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
-  const serverData = (loaderData || {}) as any;
+  const serverData = (loaderData || {}) as Record<string, unknown>;
   const setupResult = islandModule.definition.setup(serverData);
   return islandModule.definition.render(setupResult) as React.ReactElement;
 }
@@ -333,7 +333,7 @@ interface Props {
 }
 
 export default function ${pageName}Page({ params, loaderData }: Props): React.ReactElement {
-  const serverData = (loaderData || {}) as any;
+  const serverData = (loaderData || {}) as Record<string, unknown>;
   const setupResult = islandModule.definition.setup(serverData);
   return islandModule.definition.render(setupResult) as React.ReactElement;
 }

package/src/guard/contract-guard.test.ts

@@ -78,6 +78,7 @@ describe("Contract Guard", () => {
             pattern: "/",
             kind: "page",
             module: "generated/routes/home.ts",
+            componentModule: "generated/routes/home.tsx",
             slotModule: "spec/slots/home.slot.ts",
             // No contractModule - but that's fine for pages
           },

package/src/guard/file-type.test.ts

@@ -1,4 +1,4 @@
-import { describe, it, expect } from "vitest";
+import { describe, it, expect } from "bun:test";
 import { validateFileAnalysis } from "./validator";
 import { fsdPreset } from "./presets/fsd";
 import type { FileAnalysis, GuardConfig } from "./types";

package/src/guard/negotiation.ts

@@ -988,16 +988,44 @@ export interface ${toPascalCase(name)}Dto {
 export interface ${toPascalCase(name)}ResponseDto {
   // TODO: Define response DTO fields
 }
+`;
+
+    case "controller":
+      return `/**
+ * ${purpose}
+ *
+ * Controller - 요청/응답 처리
+ */
+
+export class ${toPascalCase(name)}Controller {
+  // TODO: Implement controller methods
+}
+`;
+
+    case "hook":
+      return `/**
+ * ${purpose}
+ *
+ * Custom Hook
+ */
+
+export function use${toPascalCase(name)}() {
+  // TODO: Implement hook logic
+}
 `;
 
     case "util":
-    default:
       return `/**
  * ${purpose}
  */
 
 // TODO: Implement utility functions
 `;
+
+    default: {
+      const _exhaustive: never = template;
+      throw new Error(`Unhandled file template: ${_exhaustive}`);
+    }
   }
 }
 

package/src/index.ts

@@ -23,6 +23,7 @@ export * from "./intent";
 export * from "./devtools";
 export * from "./paths";
 export * from "./resource";
+export * from "./types";
 
 // ── Resolve export * ambiguities (TS2308) ──
 // When the same name is exported from multiple submodules via `export *`,