@mandujs/core 0.18.21 → 0.18.22

package/src/intent/index.ts

@@ -25,6 +25,8 @@
 import { z, type ZodType } from 'zod';
 import { ManduFillingFactory, type ManduFilling } from '../filling/filling';
 import type { ManduContext } from '../filling/context';
+import { getZodTypeName, getZodObjectShape, getZodArrayElementType } from '../contract/zod-utils';
+import type { ZodTypeAny } from 'zod';
 
 // ============================================================================
 // Types
@@ -51,7 +53,7 @@ export interface IntentDefinition<TInput = unknown, TOutput = unknown> {
   guard?: (ctx: ManduContext) => Response | void | Promise<Response | void>;
 }
 
-export type IntentMap = Record<string, IntentDefinition<any, any>>;
+export type IntentMap = Record<string, IntentDefinition<unknown, unknown>>;
 
 export interface IntentMeta {
   __intent: true;
@@ -86,7 +88,7 @@ export function intent(intents: IntentMap): ManduFilling & IntentMeta {
   const docs: IntentDocumentation[] = [];
 
   // 메서드별로 핸들러 그룹화
-  const methodHandlers: Record<HttpMethod, IntentDefinition<any, any>[]> = {
+  const methodHandlers: Record<HttpMethod, IntentDefinition<unknown, unknown>[]> = {
     GET: [],
     POST: [],
     PUT: [],
@@ -115,12 +117,13 @@ export function intent(intents: IntentMap): ManduFilling & IntentMeta {
   }
 
   // 각 메서드에 대해 핸들러 등록
-  const registerMethod = (method: HttpMethod, handlers: IntentDefinition<any, any>[]) => {
+  const registerMethod = (method: HttpMethod, handlers: IntentDefinition<unknown, unknown>[]) => {
     if (handlers.length === 0) return;
 
     const methodLower = method.toLowerCase() as Lowercase<HttpMethod>;
+    const fillingWithMethods = filling as ManduFilling & Record<Lowercase<HttpMethod>, (handler: (ctx: ManduContext) => Response | Promise<Response>) => ManduFilling>;
 
-    (filling as any)[methodLower](async (ctx: ManduContext) => {
+    fillingWithMethods[methodLower](async (ctx: ManduContext) => {
       // 경로 매칭 (path가 있는 경우)
       for (const def of handlers) {
         if (def.path && !matchPath(ctx.url, def.path)) {
@@ -135,11 +138,15 @@ export function intent(intents: IntentMap): ManduFilling & IntentMeta {
           }
         }
 
-        // Input 검증
+        // Input 검증 (ctx.body() throws ValidationError on schema mismatch)
         if (def.input && ['POST', 'PUT', 'PATCH'].includes(method)) {
-          const bodyResult = await ctx.body(def.input);
-          if (!bodyResult.success) {
-            return ctx.error('Validation failed', bodyResult.error);
+          try {
+            await ctx.body(def.input);
+          } catch (validationError) {
+            return ctx.error(
+              'Validation failed',
+              validationError instanceof Error ? validationError : new Error(String(validationError))
+            );
           }
         }
 
@@ -247,26 +254,30 @@ export function generateOpenAPIFromIntent(
  */
 function zodToJsonSchema(schema: ZodType<unknown>): Record<string, unknown> {
   // 실제 구현은 zod-to-json-schema 라이브러리 사용 권장
-  const def = (schema as any)._def;
+  const typeName = getZodTypeName(schema as ZodTypeAny);
 
-  if (def.typeName === 'ZodString') {
+  if (typeName === 'ZodString') {
     return { type: 'string' };
   }
-  if (def.typeName === 'ZodNumber') {
+  if (typeName === 'ZodNumber') {
     return { type: 'number' };
   }
-  if (def.typeName === 'ZodBoolean') {
+  if (typeName === 'ZodBoolean') {
     return { type: 'boolean' };
   }
-  if (def.typeName === 'ZodObject') {
+  if (typeName === 'ZodObject') {
     const properties: Record<string, unknown> = {};
-    for (const [key, value] of Object.entries(def.shape())) {
-      properties[key] = zodToJsonSchema(value as ZodType<unknown>);
+    const shape = getZodObjectShape(schema as ZodTypeAny);
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        properties[key] = zodToJsonSchema(value as ZodType<unknown>);
+      }
     }
     return { type: 'object', properties };
   }
-  if (def.typeName === 'ZodArray') {
-    return { type: 'array', items: zodToJsonSchema(def.type) };
+  if (typeName === 'ZodArray') {
+    const elementType = getZodArrayElementType(schema as ZodTypeAny);
+    return { type: 'array', items: elementType ? zodToJsonSchema(elementType as ZodType<unknown>) : {} };
   }
 
   return { type: 'unknown' };

package/src/island/index.ts

@@ -133,10 +133,10 @@ export function island<P extends Record<string, unknown>>(
 // isIsland() - Island 컴포넌트 체크
 // ============================================================================
 
-export function isIsland(component: unknown): component is IslandComponent<unknown> {
+export function isIsland(component: unknown): component is IslandComponent<any> {
   return (
     typeof component === 'function' &&
-    (component as IslandComponent<unknown>).__island === true
+    (component as IslandComponent<any>).__island === true
   );
 }
 

package/src/openapi/generator.ts

@@ -12,6 +12,19 @@ import type {
   SchemaExamples,
 } from "../contract/schema";
 import path from "path";
+import {
+  getZodTypeName,
+  getZodInnerType,
+  getZodArrayElementType,
+  getZodEffectsSchema,
+  getZodObjectShape,
+  getZodChecks,
+  getZodEnumValues,
+  getZodUnionOptions,
+  getZodLiteralValue,
+  getZodDefaultValue,
+  isZodRequired,
+} from "../contract/zod-utils";
 
 // ============================================
 // OpenAPI Types
@@ -125,50 +138,54 @@ export interface OpenAPIDocument {
  * consider using zod-to-openapi or similar library.
  */
 export function zodToOpenAPISchema(zodSchema: z.ZodTypeAny): OpenAPISchema {
-  const def = zodSchema._def;
+  const typeName = getZodTypeName(zodSchema);
 
   // Handle ZodOptional
-  if (def.typeName === "ZodOptional") {
-    const innerSchema = zodToOpenAPISchema(def.innerType);
+  if (typeName === "ZodOptional") {
+    const inner = getZodInnerType(zodSchema);
+    const innerSchema = inner ? zodToOpenAPISchema(inner) : {};
     return { ...innerSchema, nullable: true };
   }
 
   // Handle ZodDefault
-  if (def.typeName === "ZodDefault") {
-    const innerSchema = zodToOpenAPISchema(def.innerType);
-    return { ...innerSchema, default: def.defaultValue() };
+  if (typeName === "ZodDefault") {
+    const inner = getZodInnerType(zodSchema);
+    const innerSchema = inner ? zodToOpenAPISchema(inner) : {};
+    return { ...innerSchema, default: getZodDefaultValue(zodSchema) };
   }
 
   // Handle ZodNullable
-  if (def.typeName === "ZodNullable") {
-    const innerSchema = zodToOpenAPISchema(def.innerType);
+  if (typeName === "ZodNullable") {
+    const inner = getZodInnerType(zodSchema);
+    const innerSchema = inner ? zodToOpenAPISchema(inner) : {};
     return { ...innerSchema, nullable: true };
   }
 
   // Handle ZodEffects (coerce, transform, etc.)
-  if (def.typeName === "ZodEffects") {
-    return zodToOpenAPISchema(def.schema);
+  if (typeName === "ZodEffects") {
+    const effectsSchema = getZodEffectsSchema(zodSchema);
+    return effectsSchema ? zodToOpenAPISchema(effectsSchema) : {};
   }
 
   // Handle ZodString
-  if (def.typeName === "ZodString") {
+  if (typeName === "ZodString") {
     const schema: OpenAPISchema = { type: "string" };
-    for (const check of def.checks || []) {
+    for (const check of getZodChecks(zodSchema)) {
       if (check.kind === "email") schema.format = "email";
       if (check.kind === "uuid") schema.format = "uuid";
       if (check.kind === "url") schema.format = "uri";
       if (check.kind === "datetime") schema.format = "date-time";
       if (check.kind === "min") schema.minLength = check.value;
       if (check.kind === "max") schema.maxLength = check.value;
-      if (check.kind === "regex") schema.pattern = check.regex.source;
+      if (check.kind === "regex") schema.pattern = check.regex?.source;
     }
     return schema;
   }
 
   // Handle ZodNumber
-  if (def.typeName === "ZodNumber") {
+  if (typeName === "ZodNumber") {
     const schema: OpenAPISchema = { type: "number" };
-    for (const check of def.checks || []) {
+    for (const check of getZodChecks(zodSchema)) {
       if (check.kind === "int") schema.type = "integer";
       if (check.kind === "min") schema.minimum = check.value;
       if (check.kind === "max") schema.maximum = check.value;
@@ -177,30 +194,30 @@ export function zodToOpenAPISchema(zodSchema: z.ZodTypeAny): OpenAPISchema {
   }
 
   // Handle ZodBoolean
-  if (def.typeName === "ZodBoolean") {
+  if (typeName === "ZodBoolean") {
     return { type: "boolean" };
   }
 
   // Handle ZodArray
-  if (def.typeName === "ZodArray") {
+  if (typeName === "ZodArray") {
+    const elementType = getZodArrayElementType(zodSchema);
     return {
       type: "array",
-      items: zodToOpenAPISchema(def.type),
+      items: elementType ? zodToOpenAPISchema(elementType) : {},
     };
   }
 
   // Handle ZodObject
-  if (def.typeName === "ZodObject") {
+  if (typeName === "ZodObject") {
     const properties: Record<string, OpenAPISchema> = {};
     const required: string[] = [];
 
-    const shape = def.shape();
+    const shape = getZodObjectShape(zodSchema) ?? {};
     for (const [key, value] of Object.entries(shape)) {
-      properties[key] = zodToOpenAPISchema(value as z.ZodTypeAny);
+      properties[key] = zodToOpenAPISchema(value);
 
       // Check if field is required
-      const fieldDef = (value as z.ZodTypeAny)._def;
-      if (fieldDef.typeName !== "ZodOptional" && fieldDef.typeName !== "ZodDefault") {
+      if (isZodRequired(value)) {
         required.push(key);
       }
     }
@@ -213,23 +230,24 @@ export function zodToOpenAPISchema(zodSchema: z.ZodTypeAny): OpenAPISchema {
   }
 
   // Handle ZodEnum
-  if (def.typeName === "ZodEnum") {
+  if (typeName === "ZodEnum") {
     return {
       type: "string",
-      enum: def.values,
+      enum: getZodEnumValues(zodSchema) as unknown[],
     };
   }
 
   // Handle ZodUnion
-  if (def.typeName === "ZodUnion") {
+  if (typeName === "ZodUnion") {
+    const options = getZodUnionOptions(zodSchema) ?? [];
     return {
-      oneOf: def.options.map((opt: z.ZodTypeAny) => zodToOpenAPISchema(opt)),
+      oneOf: options.map((opt) => zodToOpenAPISchema(opt)),
     };
   }
 
   // Handle ZodLiteral
-  if (def.typeName === "ZodLiteral") {
-    const value = def.value;
+  if (typeName === "ZodLiteral") {
+    const value = getZodLiteralValue(zodSchema);
     return {
       type: typeof value as string,
       enum: [value],
@@ -237,12 +255,12 @@ export function zodToOpenAPISchema(zodSchema: z.ZodTypeAny): OpenAPISchema {
   }
 
   // Handle ZodVoid/ZodUndefined (no content)
-  if (def.typeName === "ZodVoid" || def.typeName === "ZodUndefined") {
+  if (typeName === "ZodVoid" || typeName === "ZodUndefined") {
     return {};
   }
 
   // Handle ZodAny/ZodUnknown
-  if (def.typeName === "ZodAny" || def.typeName === "ZodUnknown") {
+  if (typeName === "ZodAny" || typeName === "ZodUnknown") {
     return {};
   }
 

package/src/plugins/registry.ts

@@ -25,15 +25,19 @@ import type {
 type PluginState = "pending" | "loaded" | "error" | "unloaded";
 
 /**
- * 등록된 플러그인 정보
+ * 등록된 플러그인 정보 (discriminated union by state)
+ *
+ * state에 따라 접근 가능한 필드가 타입 레벨에서 결정됨:
+ * - pending: plugin, config만 존재
+ * - loaded: plugin, config, loadedAt 존재
+ * - error: plugin, config, error 존재
+ * - unloaded: plugin만 존재
  */
-interface RegisteredPlugin<TConfig = unknown> {
-  plugin: Plugin<TConfig>;
-  state: PluginState;
-  config?: TConfig;
-  error?: Error;
-  loadedAt?: Date;
-}
+type RegisteredPlugin<TConfig = unknown> =
+  | { state: "pending"; plugin: Plugin<TConfig>; config?: TConfig }
+  | { state: "loaded"; plugin: Plugin<TConfig>; config?: TConfig; loadedAt: Date }
+  | { state: "error"; plugin: Plugin<TConfig>; config?: TConfig; error: Error }
+  | { state: "unloaded"; plugin: Plugin<TConfig> };
 
 /**
  * 소유자 정보 포함 리소스
@@ -89,7 +93,7 @@ export class PluginRegistry {
         const error = new Error(
           `Invalid config for plugin "${id}": ${result.error.message}`
         );
-        this.plugins.set(id, { plugin, state: "error", error });
+        this.plugins.set(id, { plugin: plugin as Plugin<unknown>, state: "error", config: validatedConfig, error });
         throw error;
       }
       validatedConfig = result.data;
@@ -97,7 +101,7 @@ export class PluginRegistry {
 
     // 등록
     this.plugins.set(id, {
-      plugin,
+      plugin: plugin as Plugin<unknown>,
       state: "pending",
       config: validatedConfig,
     });
@@ -112,16 +116,23 @@ export class PluginRegistry {
         await plugin.onLoad();
       }
 
-      const entry = this.plugins.get(id)!;
-      entry.state = "loaded";
-      entry.loadedAt = new Date();
+      this.plugins.set(id, {
+        state: "loaded",
+        plugin: plugin as Plugin<unknown>,
+        config: validatedConfig,
+        loadedAt: new Date(),
+      });
 
       this.logger.info(`Plugin loaded: ${id} (v${plugin.meta.version})`);
     } catch (error) {
-      const entry = this.plugins.get(id)!;
-      entry.state = "error";
-      entry.error = error instanceof Error ? error : new Error(String(error));
-      throw entry.error;
+      const pluginError = error instanceof Error ? error : new Error(String(error));
+      this.plugins.set(id, {
+        state: "error",
+        plugin: plugin as Plugin<unknown>,
+        config: validatedConfig,
+        error: pluginError,
+      });
+      throw pluginError;
     }
   }
 
@@ -142,7 +153,6 @@ export class PluginRegistry {
     // 등록된 리소스 정리
     this.removeOwnedResources(id);
 
-    entry.state = "unloaded";
     this.plugins.delete(id);
 
     this.logger.info(`Plugin unloaded: ${id}`);

package/src/resource/__tests__/backward-compat.test.ts

@@ -277,7 +277,7 @@ describe("Backward Compatibility - Error Handling", () => {
       validateResourceDefinition({
         name: "",
         fields: {},
-      } as any);
+      } as unknown as Parameters<typeof validateResourceDefinition>[0]); // intentionally invalid
       expect(false).toBe(true); // Should not reach here
     } catch (error) {
       expect(error).toBeDefined();
@@ -292,7 +292,7 @@ describe("Backward Compatibility - Error Handling", () => {
       validateResourceDefinition({
         name: "test",
         fields: {},
-      } as any);
+      } as unknown as Parameters<typeof validateResourceDefinition>[0]); // intentionally invalid
       expect(false).toBe(true); // Should not reach here
     } catch (error) {
       expect(error).toBeDefined();

package/src/resource/__tests__/edge-cases.test.ts

@@ -10,6 +10,7 @@ import {
   validateResourceDefinition,
   FieldTypes,
   type ResourceDefinition,
+  type ResourceField,
 } from "../schema";
 
 describe("Edge Cases - Resource Names", () => {
@@ -30,7 +31,7 @@ describe("Edge Cases - Resource Names", () => {
       fields: {
         id: { type: "uuid", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Resource name is required/);
   });
@@ -41,7 +42,7 @@ describe("Edge Cases - Resource Names", () => {
       fields: {
         id: { type: "uuid", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid resource name/);
   });
@@ -52,7 +53,7 @@ describe("Edge Cases - Resource Names", () => {
       fields: {
         id: { type: "uuid", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid resource name/);
   });
@@ -63,7 +64,7 @@ describe("Edge Cases - Resource Names", () => {
       fields: {
         id: { type: "uuid", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid resource name/);
   });
@@ -121,7 +122,7 @@ describe("Edge Cases - Field Names", () => {
       fields: {
         _privateField: { type: "string", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     // Field names must start with a letter (not underscore)
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid field name/);
@@ -133,7 +134,7 @@ describe("Edge Cases - Field Names", () => {
       fields: {
         "1field": { type: "string", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid field name/);
   });
@@ -206,7 +207,7 @@ describe("Edge Cases - Field Types", () => {
       fields: {
         id: { type: "unsupported_type", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/Invalid field type/);
   });
@@ -230,7 +231,7 @@ describe("Edge Cases - Field Types", () => {
       fields: {
         tags: { type: "array", required: true },
       },
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(/missing "items" property/);
   });
@@ -433,9 +434,9 @@ describe("Edge Cases - Resource Options", () => {
 
 describe("Edge Cases - Large Schemas", () => {
   test("should handle resource with many fields (50 fields)", () => {
-    const fields: Record<string, any> = {};
+    const fields: Record<string, ResourceField> = {};
     for (let i = 0; i < 50; i++) {
-      fields[`field${i}`] = { type: "string", required: i % 2 === 0 };
+      fields[`field${i}`] = { type: "string" as const, required: i % 2 === 0 };
     }
 
     const definition: ResourceDefinition = {
@@ -483,7 +484,7 @@ describe("Edge Cases - Boundary Conditions", () => {
     const definition = {
       name: "test",
       fields: {},
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(
       /must have at least one field/
@@ -494,7 +495,7 @@ describe("Edge Cases - Boundary Conditions", () => {
     const definition = {
       name: "test",
       fields: null,
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(
       /must have at least one field/
@@ -505,7 +506,7 @@ describe("Edge Cases - Boundary Conditions", () => {
     const definition = {
       name: "test",
       fields: undefined,
-    } as any;
+    } as unknown as ResourceDefinition; // intentionally invalid
 
     expect(() => validateResourceDefinition(definition)).toThrow(
       /must have at least one field/

package/src/resource/__tests__/fixtures.ts

@@ -166,7 +166,7 @@ export const invalidResourceFixtures = {
     fields: {
       id: { type: "uuid", required: true },
     },
-  } as any,
+  } as unknown as ResourceDefinition, // intentionally invalid: missing name
 
   invalidName: {
     name: "123-invalid",
@@ -190,7 +190,7 @@ export const invalidResourceFixtures = {
   invalidFieldType: {
     name: "valid",
     fields: {
-      field: { type: "invalid" as any, required: true },
+      field: { type: "invalid" as unknown as "string", required: true }, // intentionally invalid type
     },
   } as ResourceDefinition,
 

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

@@ -30,7 +30,7 @@ afterAll(async () => {
 /**
  * Create a test parsed resource (no file import needed)
  */
-function createTestParsedResource(resourceName: string, definition: any): ParsedResource {
+function createTestParsedResource(resourceName: string, definition: ParsedResource["definition"]): ParsedResource {
   return {
     definition,
     filePath: path.join(testDir, "spec", "resources", `${resourceName}.resource.ts`),

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

@@ -7,6 +7,8 @@
 import { describe, test, expect, beforeAll, afterAll } from "bun:test";
 import { generateResourceArtifacts } from "../generator";
 import type { ParsedResource } from "../parser";
+import type { ResourceField, ResourceDefinition } from "../schema";
+import { validateResourceDefinition } from "../schema";
 import path from "path";
 import fs from "fs/promises";
 import os from "os";
@@ -29,7 +31,7 @@ afterAll(async () => {
 /**
  * Create a test parsed resource
  */
-function createTestParsedResource(resourceName: string, definition: any): ParsedResource {
+function createTestParsedResource(resourceName: string, definition: ParsedResource["definition"]): ParsedResource {
   return {
     definition,
     filePath: path.join(testDir, "spec", "resources", `${resourceName}.resource.ts`),
@@ -70,10 +72,10 @@ describe("Performance - Resource Generation", () => {
   });
 
   test("should handle resource with 50 fields in < 1000ms", async () => {
-    const fields: Record<string, any> = {};
+    const fields: Record<string, ResourceField> = {};
     for (let i = 0; i < 50; i++) {
       fields[`field${i}`] = {
-        type: i % 5 === 0 ? "number" : "string",
+        type: i % 5 === 0 ? "number" as const : "string" as const,
         required: i % 2 === 0,
         default: i % 3 === 0 ? `value${i}` : undefined,
       };
@@ -169,7 +171,7 @@ describe("Performance - Schema Validation", () => {
   test("should validate complex schema (50 fields) in < 50ms", async () => {
     const { validateResourceDefinition } = await import("../schema");
 
-    const fields: Record<string, any> = {};
+    const fields: Record<string, ResourceField> = {};
     for (let i = 0; i < 50; i++) {
       fields[`field${i}`] = {
         type: (["string", "number", "boolean", "date", "email"] as const)[i % 5],
@@ -177,7 +179,7 @@ describe("Performance - Schema Validation", () => {
       };
     }
 
-    const definition = {
+    const definition: ResourceDefinition = {
       name: "complex",
       fields,
       options: {
@@ -280,7 +282,7 @@ describe("Performance - Comparison Benchmarks", () => {
     );
 
     // Large resource
-    const largeFields: Record<string, any> = {};
+    const largeFields: Record<string, ResourceField> = {};
     for (let i = 0; i < 30; i++) {
       largeFields[`field${i}`] = {
         type: (["string", "number", "boolean"] as const)[i % 3],

package/src/resource/schema.ts

@@ -40,7 +40,7 @@ export interface ResourceField {
   /** 배열 타입인 경우 요소 타입 */
   items?: FieldType;
   /** 커스텀 Zod 스키마 (고급 사용) */
-  schema?: z.ZodType<any>;
+  schema?: z.ZodTypeAny;
 }
 
 // ============================================