sonamu 0.10.12 → 0.10.13

package/src/syncer/syncer.ts

@@ -1,12 +1,11 @@
 import assert from "assert";
 import { EventEmitter } from "events";
-import { unlink } from "fs/promises";
 import path from "path";
 
 import { hot } from "@sonamu-kit/hmr-hook";
 import chalk from "chalk";
 import { minimatch } from "minimatch";
-import { group, unique } from "radashi";
+import { unique } from "radashi";
 import { type z } from "zod";
 
 import { registeredApis } from "../api/decorators";
@@ -22,20 +21,36 @@ import { type TemplateOptions } from "../types/types";
 import { mapAsync, reduceAsync } from "../utils/async-utils";
 import { centerText } from "../utils/console-util";
 import { isTest } from "../utils/controller";
-import { exists } from "../utils/fs-utils";
 import { type AbsolutePath } from "../utils/path-utils";
 import { runWithGracefulShutdown } from "../utils/process-utils";
+import { isObjectValue } from "../utils/runtime-value";
 import { findChangedFilesUsingChecksums, renewChecksums } from "./checksum";
 import { generateTemplate, renderTemplate } from "./code-generator";
 import { createEntity, delEntity } from "./entity-operations";
 import { getChecksumPatternGroup, getChecksumPatternGroupInAbsolutePath } from "./file-patterns";
 import { type FileType } from "./file-patterns";
+import { syncerFileExists, syncerFilesystem } from "./filesystem-dependencies";
 import { loadApis, loadModels, loadTypes, loadWorkflows } from "./module-loader";
 import { type LoadedApis, type LoadedModels, type LoadedTypes } from "./module-loader";
 import * as SyncerActions from "./syncer-actions";
 
-type DiffGroups = {
-  [key in FileType]: AbsolutePath[];
+type DiffGroupKey = FileType | "unknown";
+type DiffGroups = Partial<Record<DiffGroupKey, AbsolutePath[]>>;
+
+export interface SyncerDependencies {
+  actionCopySharedToTargetsIfNotExists: typeof SyncerActions.actionCopySharedToTargetsIfNotExists;
+  actionGenerateHttpValidators: typeof SyncerActions.actionGenerateHttpValidators;
+  actionGenerateSsrEntryServerIfNotExists: typeof SyncerActions.actionGenerateSsrEntryServerIfNotExists;
+  findChangedFilesUsingChecksums: typeof findChangedFilesUsingChecksums;
+  renewChecksums: typeof renewChecksums;
+}
+
+const defaultSyncerDependencies: SyncerDependencies = {
+  actionCopySharedToTargetsIfNotExists: SyncerActions.actionCopySharedToTargetsIfNotExists,
+  actionGenerateHttpValidators: SyncerActions.actionGenerateHttpValidators,
+  actionGenerateSsrEntryServerIfNotExists: SyncerActions.actionGenerateSsrEntryServerIfNotExists,
+  findChangedFilesUsingChecksums,
+  renewChecksums,
 };
 
 export class Syncer {
@@ -45,6 +60,8 @@ export class Syncer {
   workflows: Map<string, WorkflowMetadata[]> = new Map();
   eventEmitter: EventEmitter = new EventEmitter();
 
+  constructor(private readonly dependencies: SyncerDependencies = defaultSyncerDependencies) {}
+
   /**
    * 체크섬이 변경된 부분에 대해 싱크를 진행합니다.
    * dev 서버가 처음 떴을 때, sonamu sync 할 때 실행됩니다. 이후에는 hmrAndSync 경로를 타요.
@@ -54,12 +71,15 @@ export class Syncer {
     // 초기 부트스트랩! 얘네들은 idempotent하고 가볍기 때문에 무지성 실행해도 됩니다.
     // 얘네들은 sonamu.lock에 들어가지도 않고 따라서 HMR 경로를 타지도 않는 친구들입니다.
     // 그래서 아무 때나 그냥 돌려주면 되는데, hmrAndSync에서 매번 하는 것은 낭비이니 여기서 한 번만 합니다.
-    await SyncerActions.actionCopySharedToTargetsIfNotExists();
-    await SyncerActions.actionGenerateSsrEntryServerIfNotExists();
+    await this.dependencies.actionCopySharedToTargetsIfNotExists();
+    await this.dependencies.actionGenerateSsrEntryServerIfNotExists();
 
     // 바뀐 것이 없으면 그냥 넘어가요.
-    const changedFiles = await findChangedFilesUsingChecksums();
+    const changedFiles = await this.dependencies.findChangedFilesUsingChecksums();
     if (changedFiles.length === 0) {
+      if (await this.reconcileHttpValidatorRegistry()) {
+        await this.dependencies.renewChecksums();
+      }
       console.log(chalk.black.bgGreen(centerText("All files are synced!")));
       return;
     }
@@ -71,14 +91,31 @@ export class Syncer {
       async () => {
         // 얘가 싱크 작업 수행하는 본체입니다.
         await this.doSyncActions(changedFiles);
+        await this.reconcileHttpValidatorRegistry();
 
         // 싱크 액션이 끝나면 항상 체크섬을 다시 갱신합니다.
-        await renewChecksums();
+        await this.dependencies.renewChecksums();
       },
       { whenThisHappens: "SIGUSR2", waitForUpTo: 20000 },
     );
   }
 
+  private async reconcileHttpValidatorRegistry(): Promise<boolean> {
+    const registryPath = path.join(
+      Sonamu.apiRootPath,
+      "src/application/sonamu.validators.generated.ts",
+    );
+    const policy = Sonamu.config.validation?.zodCompiler;
+    const isAot = isObjectValue(policy) && policy !== null && policy.api === "aot";
+    if (isAot === (await syncerFileExists(registryPath))) {
+      return false;
+    }
+
+    // 변경 목록이 registry 삭제를 놓쳐도 checksum 갱신 전에 정책과 산출물을 다시 맞춥니다.
+    await this.dependencies.actionGenerateHttpValidators();
+    return true;
+  }
+
   /**
    * 강제 풀-싱크: lock을 무시하고 처음부터 다시 싱크합니다.
    *
@@ -88,8 +125,8 @@ export class Syncer {
    */
   async forceSync(): Promise<void> {
     const lockPath = path.join(Sonamu.apiRootPath, "sonamu.lock");
-    if (await exists(lockPath)) {
-      await unlink(lockPath);
+    if (await syncerFileExists(lockPath)) {
+      await syncerFilesystem.unlink(lockPath);
     }
     await this.sync();
   }
@@ -137,6 +174,7 @@ export class Syncer {
     await this.autoloadApis();
     await this.autoloadWorkflows();
     await this.autoloadSsrRoutes();
+    await Sonamu.refreshHttpValidators();
 
     this.eventEmitter.emit("onHMRCompleted");
   }
@@ -182,7 +220,11 @@ export class Syncer {
       // 그러니 안심하고 invalidate 해도 됩니다.
       // 테스트 환경에서는 hot.invalidateFile시 초기 에러가 발생하기 때문에 invalidate 하지 않습니다.
       if (!isTest()) {
-        const invalidatedPaths = (await hot.invalidateFile(diffFilePath, event)) as AbsolutePath[];
+        const invalidatedPaths =
+          /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (await hot.invalidateFile(
+            diffFilePath,
+            event,
+          )) as AbsolutePath[];
 
         if (invalidatedPaths.length > 0) {
           console.log(chalk.bold(`🔄 Invalidated:`));
@@ -271,7 +313,7 @@ export class Syncer {
     clearSSRRoutes();
 
     // ssr 폴더 없으면 스킵
-    if (!(await exists(ssrConfigPath))) {
+    if (!(await syncerFileExists(ssrConfigPath))) {
       return;
     }
 
@@ -302,7 +344,10 @@ export class Syncer {
    */
   async doSyncActions(diffFilePaths: AbsolutePath[]): Promise<{ diffTypes: FileType[] }> {
     const diffGroups = this.calculateDiffGroups(diffFilePaths);
-    const diffTypes = Object.keys(diffGroups) as FileType[];
+    const diffTypes =
+      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(
+        diffGroups,
+      ) as FileType[];
 
     // 여기는 별로 중요한 파트는 아닙니다.
     // 아래의 if 전개를 깔끔하게 하려고 만든 DSL 같은 거라서, 무시하셔도 됩니다.
@@ -324,11 +369,27 @@ export class Syncer {
     }
 
     if (changeMatches("config")) {
-      await this.handleConfigChanges(diffGroups);
+      await this.handleConfigChanges();
     }
 
     if (changeMatches("i18n", "entity" /*레이블*/, "config" /*defaultLocale등*/)) {
-      await this.handleSonamuDictionaryRelatedChanges(diffGroups);
+      await this.handleSonamuDictionaryRelatedChanges();
+    }
+
+    const metadataChanged = diffTypes.some((type) =>
+      ["entity", "types", "model", "frame", "config"].includes(type),
+    );
+    if (changeMatches("httpValidatorsGenerated") && !metadataChanged) {
+      // registry 자체 drift는 최신 in-memory metadata로 즉시 덮어써 lock 갱신 전에 정합성을 복구합니다.
+      await this.dependencies.actionGenerateHttpValidators();
+    }
+
+    if (metadataChanged) {
+      // 모든 생성/복사 액션 뒤 최신 metadata를 다시 읽어 registry를 한 번만 확정합니다.
+      await this.autoloadTypes();
+      await this.autoloadModels();
+      await this.autoloadApis();
+      await this.dependencies.actionGenerateHttpValidators();
     }
 
     if (nothingMatches()) {
@@ -343,22 +404,26 @@ export class Syncer {
     };
   }
 
-  calculateDiffGroups(diffFiles: AbsolutePath[]): DiffGroups {
+  calculateDiffGroups(diffFiles: AbsolutePath[]) {
     const patternGroup = getChecksumPatternGroup();
-    const fileTypes = Object.keys(patternGroup) as FileType[];
-
-    return group(diffFiles, (filePath) => {
-      // 절대 경로 → appRoot 기준 상대 경로 (예: "api/src/...", "web/src/...")
+    const fileTypes =
+      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ Object.keys(
+        patternGroup,
+      ) as FileType[];
+
+    const diffGroups: DiffGroups = {};
+    for (const filePath of diffFiles) {
+      // 절대 경로를 appRoot 기준 상대 경로로 바꿔 체크섬 패턴과 비교한다.
       const relativePath = path.relative(Sonamu.appRootPath, filePath);
-      if (relativePath.startsWith("..")) return "unknown";
-
-      for (const fileType of fileTypes) {
-        if (minimatch(relativePath, patternGroup[fileType])) {
-          return fileType;
-        }
-      }
-      return "unknown";
-    }) as unknown as DiffGroups;
+      const fileType = fileTypes.find((candidate) =>
+        minimatch(relativePath, patternGroup[candidate]),
+      );
+      const groupKey: DiffGroupKey = relativePath.startsWith("..")
+        ? "unknown"
+        : (fileType ?? "unknown");
+      (diffGroups[groupKey] ??= []).push(filePath);
+    }
+    return diffGroups;
   }
 
   private changeMatcher(diffTypes: FileType[], diffGroups: DiffGroups) {
@@ -404,12 +469,13 @@ export class Syncer {
       const entity = EntityManager.get(entityId);
 
       // 프로젝트에 생성되어야 하는 .ts 파일의 경로입니다.
-      const typeFilePath = path.join(
-        Sonamu.apiRootPath,
-        `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,
-      ) as AbsolutePath;
+      const typeFilePath =
+        /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ path.join(
+          Sonamu.apiRootPath,
+          `src/application/${entity.names.fs}/${entity.names.fs}.types.ts`,
+        ) as AbsolutePath;
 
-      if (entity.parentId === undefined && !(await exists(typeFilePath))) {
+      if (entity.parentId === undefined && !(await syncerFileExists(typeFilePath))) {
         // *.types.ts가 만들어집니다.
         const types = await SyncerActions.actionGenerateInitialTypes(entityId);
 
@@ -464,11 +530,15 @@ export class Syncer {
     await SyncerActions.actionSyncFilesToTargets(tsPaths);
   }
 
-  async handleConfigChanges(_: DiffGroups): Promise<void> {
+  async handleConfigChanges(): Promise<void> {
+    if (process.env.HOT === "yes") {
+      const { loadConfig } = await import("../api/config");
+      Sonamu.config = await loadConfig(Sonamu.apiRootPath);
+    }
     await SyncerActions.actionSyncConfig();
   }
 
-  async handleSonamuDictionaryRelatedChanges(_: DiffGroups): Promise<void> {
+  async handleSonamuDictionaryRelatedChanges(): Promise<void> {
     await SyncerActions.actionSyncSonamuDictionary();
   }
 
@@ -508,7 +578,7 @@ export class Syncer {
     return {
       subPath,
       fullPath,
-      isExists: await exists(fullPath),
+      isExists: await syncerFileExists(fullPath),
     };
   }
 
@@ -535,7 +605,7 @@ export class Syncer {
         if (key.startsWith("view_enums")) {
           await mapAsync(enumsKeys, async (componentId) => {
             const { target, path: p } = tpl.getTargetAndPath(names, componentId);
-            result[`${key}__${componentId}`] = await exists(
+            result[`${key}__${componentId}`] = await syncerFileExists(
               path.join(Sonamu.appRootPath, target, p),
             );
           });
@@ -546,17 +616,20 @@ export class Syncer {
         const { targets } = Sonamu.config.sync;
         if (target.includes(":target")) {
           await mapAsync(targets, async (t) => {
-            result[`${key}__${t}`] = await exists(
+            result[`${key}__${t}`] = await syncerFileExists(
               path.join(Sonamu.appRootPath, target.replace(":target", t), p),
             );
           });
         } else {
-          result[key] = await exists(path.join(Sonamu.appRootPath, target, p));
+          result[key] = await syncerFileExists(path.join(Sonamu.appRootPath, target, p));
         }
 
         return result;
       },
-      {} as Record<`${TemplateKey}${string}`, boolean>,
+      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ {} as Record<
+        `${TemplateKey}${string}`,
+        boolean
+      >,
     );
   }
 
@@ -599,6 +672,6 @@ export class Syncer {
    * 하위호환용 프록시 메소드입니다.
    */
   async renewChecksums(): Promise<void> {
-    return await renewChecksums();
+    return await this.dependencies.renewChecksums();
   }
 }

package/src/syncer/watcher.ts

@@ -3,7 +3,7 @@ import { type Stats } from "node:fs";
 import path from "path";
 
 import chalk from "chalk";
-import chokidar, { type FSWatcher } from "chokidar";
+import { type FSWatcher, watch } from "chokidar";
 import { minimatch } from "minimatch";
 
 import { Sonamu } from "../api";
@@ -22,7 +22,7 @@ export async function setupWatcher(
   // api 본인뿐 아니라 sync target들의 src도 봅니다.
   // target 산출물(sonamu.generated, services.generated, i18n copy 등)이 외부에서
   // 변경되는 경우를 drift로 잡아 워닝을 띄우기 위함입니다.
-  const watcher = chokidar.watch(apiAndTargetsSrcPaths(), {
+  const watcher = watch(apiAndTargetsSrcPaths(), {
     ignored: ignoreIfExtensionIsNotOneOf(".ts", ".json", ".http"),
     persistent: true,
     ignoreInitial: true,
@@ -49,7 +49,8 @@ export async function setupWatcher(
   });
 
   watcher.on("all", (event: string, filePath: string) => {
-    const absolutePath = filePath as AbsolutePath;
+    const absolutePath =
+      /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ filePath as AbsolutePath;
     assert(
       absolutePath.startsWith(Sonamu.appRootPath),
       "File path is not within the app root path",
@@ -92,7 +93,10 @@ function apiAndTargetsSrcPaths() {
  * 따라서 "이 확장자만 허용"을 표현하려면 *다른 확장자에 대해 true*를 반환해야 합니다.
  */
 function ignoreIfExtensionIsNotOneOf(...allowedExtensions: `.${string}`[]) {
-  const isAllowed = (ext: string) => (allowedExtensions as string[]).includes(ext);
+  const isAllowed = (ext: string) =>
+    /* SAFETY: TypeScript AST 파싱과 동기화 입력 계약이 이 값의 타입을 보장한다. */ (
+      allowedExtensions as string[]
+    ).includes(ext);
 
   return (p: string, stats?: Stats) => !!stats?.isFile() && !isAllowed(path.extname(p));
 }

package/src/tasks/decorator.ts

@@ -13,18 +13,18 @@ import { type Executable } from "../types/types";
 import { type WorkflowFunction } from "./workflow-manager";
 
 // 워크플로우의 메타데이터 객체
-export interface WorkflowMetadata {
+export interface WorkflowMetadata<RawInput = unknown, Input = unknown, Output = unknown> {
   type: "workflow";
   id: string;
   name: string;
   version: string | null;
-  schema: StandardSchemaV1<unknown, unknown> | undefined;
+  schema: StandardSchemaV1<RawInput, Input> | undefined;
   schedules: {
     name: string;
     expression: string;
-    input: Executable<SchemaInput<unknown, unknown> | undefined>;
+    input: Executable<RawInput | undefined>;
   }[];
-  fn: WorkflowFunction<unknown, unknown>;
+  fn: WorkflowFunction<Input, Output>;
   retryPolicy?: RetryPolicy;
 }
 
@@ -50,22 +50,30 @@ export type DefineWorkflowOptions<
 // 이것들은 syncer에서 한번에 load한 다음, WorkflowManager에서 synchronize를 통해 등록됨.
 export function workflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(
   options: DefineWorkflowOptions<Input, Output, TSchema>,
-): (fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>) => WorkflowMetadata;
+): (
+  fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>,
+) => WorkflowMetadata<SchemaInput<TSchema, Input>, SchemaOutput<TSchema, Input>, Output>;
 export function workflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(
   options: DefineWorkflowOptions<Input, Output, TSchema>,
   fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>,
-): WorkflowMetadata;
+): WorkflowMetadata<SchemaInput<TSchema, Input>, SchemaOutput<TSchema, Input>, Output>;
 export function workflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(
   options: DefineWorkflowOptions<Input, Output, TSchema>,
   fn?: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>,
 ):
-  | WorkflowMetadata
-  | ((fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>) => WorkflowMetadata) {
-  const decorated = (fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>) => {
+  | WorkflowMetadata<SchemaInput<TSchema, Input>, SchemaOutput<TSchema, Input>, Output>
+  | ((
+      fn: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>,
+    ) => WorkflowMetadata<SchemaInput<TSchema, Input>, SchemaOutput<TSchema, Input>, Output>) {
+  const decorated = (workflowFunction: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>) => {
     const id = randomUUID();
-    const workflowName = options.name ?? inflection.underscore(fn.name);
+    const workflowName = options.name ?? inflection.underscore(workflowFunction.name);
 
-    const metadata: WorkflowMetadata = {
+    const metadata: WorkflowMetadata<
+      SchemaInput<TSchema, Input>,
+      SchemaOutput<TSchema, Input>,
+      Output
+    > = {
       type: "workflow" as const,
       id,
       name: workflowName,
@@ -78,7 +86,7 @@ export function workflow<Input, Output, TSchema extends StandardSchemaV1 | undef
           input: schedule.input,
         };
       }),
-      fn: fn as WorkflowFunction<unknown, unknown>,
+      fn: workflowFunction,
       retryPolicy: options.retryPolicy,
     };
 

package/src/tasks/step-wrapper.ts

@@ -6,6 +6,10 @@ export type RunnableStep<TArgs extends unknown[], TResult> = {
   run: StepFunction<TArgs, Promise<TResult>>;
 };
 
+interface StepConfig {
+  name: string;
+}
+
 export type MethodNames<T, TKey extends keyof T> = T[TKey] extends (
   ...args: infer _TArgs
 ) => infer _TResult
@@ -14,7 +18,7 @@ export type MethodNames<T, TKey extends keyof T> = T[TKey] extends (
 
 export type MethodArguments<T, TKey extends keyof T> = T[TKey] extends (
   ...args: infer TArgs
-) => unknown
+) => infer _TResult
   ? TArgs
   : never;
 
@@ -37,7 +41,7 @@ export class StepWrapper {
     TKey extends keyof T,
     TArgs extends MethodArguments<T, TKey>,
     TResult extends MethodReturnType<T, TKey>,
-  >(config: { name: string }, object: T, name: MethodNames<T, TKey>): RunnableStep<TArgs, TResult>;
+  >(config: StepConfig, object: T, name: MethodNames<T, TKey>): RunnableStep<TArgs, TResult>;
   get<
     T,
     TKey extends keyof T,
@@ -50,20 +54,26 @@ export class StepWrapper {
     TArgs extends MethodArguments<T, TKey>,
     TResult extends MethodReturnType<T, TKey>,
   >(
-    ...args: [{ name: string }, T, MethodNames<T, TKey>] | [T, MethodNames<T, TKey>]
+    ...definitionArgs: [StepConfig, T, MethodNames<T, TKey>] | [T, MethodNames<T, TKey>]
   ): RunnableStep<TArgs, TResult> {
-    let config: { name: string };
+    let config: StepConfig;
     let fn: StepFunction<TArgs, Exclude<TResult, never>>;
 
-    if (args.length === 2) {
-      const [rawObject, methodName] = args;
-      const method = rawObject[methodName] as CallableFunction;
+    if (definitionArgs.length === 2) {
+      const [rawObject, methodName] = definitionArgs;
+      const method =
+        /* SAFETY: 작업 데코레이터와 워크플로 정의가 이 값의 타입을 보장한다. */ rawObject[
+          methodName
+        ] as CallableFunction;
       config = { name: inflection.underscore(methodName.toString()) };
 
       fn = (...args: TArgs) => method.bind(rawObject)(...args);
     } else {
-      const [rawConfig, rawObject, name] = args;
-      const method = rawObject[name] as CallableFunction;
+      const [rawConfig, rawObject, name] = definitionArgs;
+      const method =
+        /* SAFETY: 작업 데코레이터와 워크플로 정의가 이 값의 타입을 보장한다. */ rawObject[
+          name
+        ] as CallableFunction;
 
       config = { name: rawConfig.name ?? inflection.underscore(name.toString()) };
       fn = (...args: TArgs) => method.bind(rawObject)(...args);

package/src/tasks/workflow-manager.ts

@@ -25,6 +25,7 @@ import { convertDomainToCategory } from "../logger/category";
 import { Naite } from "../naite/naite";
 import { createMockSSEFactory } from "../stream/sse";
 import { type Executable } from "../types/types";
+import { isFunctionValue } from "../utils/runtime-value";
 import { type WorkflowMetadata } from "./decorator";
 import { StepWrapper } from "./step-wrapper";
 
@@ -126,7 +127,7 @@ export class WorkflowManager {
     await Promise.allSettled(
       Array.from(this.#workflowsMap.entries())
         .filter(([key]) => !workflowMap.has(key))
-        .flatMap(([_, workflows]) =>
+        .flatMap(([, workflows]) =>
           workflows.map((workflow) => {
             return Promise.allSettled([
               ...workflow.schedules.map((schedule) => this.unscheduleTask(schedule.name)),
@@ -140,7 +141,7 @@ export class WorkflowManager {
     await Promise.allSettled(
       Array.from(workflowMap.entries())
         .filter(([key]) => !this.#workflowsMap.has(key))
-        .flatMap(([_, workflows]) =>
+        .flatMap(([, workflows]) =>
           workflows.map((workflow) => {
             this.registerWorkflow({
               id: workflow.id,
@@ -167,7 +168,7 @@ export class WorkflowManager {
           assert(previousWorkflows, "previous workflows not found");
           return [key, [previousWorkflows, newWorkflows]];
         })
-        .map(async ([_, [previousWorkflows, newWorkflows]]) => {
+        .map(async ([, [previousWorkflows, newWorkflows]]) => {
           // 기존 것들을 삭제부터 해야함.
           await Promise.allSettled(
             previousWorkflows
@@ -237,7 +238,7 @@ export class WorkflowManager {
         { name, version }: Pick<WorkflowMetadata, "name" | "version">,
         { input }: WorkflowMetadata["schedules"][number],
       ) => {
-        const inputData = await (typeof input === "function"
+        const inputData = await (isFunctionValue(input)
           ? Promise.resolve(input())
           : Promise.resolve(input));
 
@@ -287,17 +288,22 @@ export class WorkflowManager {
         version: string | null;
       }>,
     ) => {
-      const baseContext = {
+      const baseContext: Context = {
         transport: "http" as const,
-        request: null,
-        reply: null,
+        // 워크플로우에는 HTTP 요청이 없으므로 잘못된 접근을 즉시 드러냅니다.
+        get request(): Context["request"] {
+          throw new Error("HTTP request is unavailable in workflow context");
+        },
+        get reply(): Context["reply"] {
+          throw new Error("HTTP reply is unavailable in workflow context");
+        },
         headers: {},
-        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),
+        createSSE: <T extends ZodObject>(schema: T) => createMockSSEFactory(schema),
         naiteStore: Naite.createStore(),
         locale: "",
         user: null,
         session: null,
-      } as unknown as Context;
+      };
 
       const contextProvider = Sonamu.config.tasks?.contextProvider;
       const context: Context = contextProvider