sonamu 0.8.26 → 0.9.0

package/dist/tasks/workflow-manager.js

@@ -1,225 +1,196 @@
+import { __esmMin } from "../_virtual/rolldown_runtime.js";
+import { convertDomainToCategory, init_category } from "../logger/category.js";
+import { createMockSSEFactory, init_sse } from "../stream/sse.js";
+import { Sonamu, init_sonamu } from "../api/sonamu.js";
+import { Naite, init_naite } from "../naite/naite.js";
+import { StepWrapper, init_step_wrapper } from "./step-wrapper.js";
 import { getLogger } from "@logtape/logtape";
+import assert from "assert";
 import { BackendPostgres, OpenWorkflow } from "@sonamu-kit/tasks";
 import { serializeRetryPolicy } from "@sonamu-kit/tasks/internal";
-import assert from "assert";
-import { schedule as cronSchedule } from "node-cron";
-import { Sonamu } from "../api/sonamu.js";
-import { convertDomainToCategory } from "../logger/category.js";
-import { Naite } from "../naite/naite.js";
-import { createMockSSEFactory } from "../stream/sse.js";
-import { StepWrapper } from "./step-wrapper.js";
-export class WorkflowManager {
-    // backend 인스턴스
-    #backend;
-    // OpenWorkflow 인스턴스
-    #ow;
-    // Worker 인스턴스 (없을 수 있으며, 이 때는 분산된 서버 환경에서 DB에 publish만 한다고 가정함)
-    #worker;
-    // 파일 경로 -> 파일에 정의된 워크플로우 메타데이터 목록
-    #workflowsMap;
-    // Task 이름 -> Task 정보 및 Input 값, Workflow ID
-    #scheduledTasks;
-    // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.
-    constructor(dbConf, runMigrations = true){
-        const backend = new BackendPostgres(dbConf, {
-            runMigrations
-        });
-        this.#backend = backend;
-        this.#ow = new OpenWorkflow({
-            backend
-        });
-        this.#worker = null;
-        this.#workflowsMap = new Map();
-        this.#scheduledTasks = new Map();
-    }
-    // Sonamu UI API에서 워크플로우 실행 목록 조회, 취소 등에 사용합니다.
-    get backend() {
-        return this.#backend;
-    }
-    get workflowDefinitions() {
-        return Array.from(this.#workflowsMap.values()).flat().map((wf)=>({
-                id: wf.id,
-                name: wf.name,
-                version: wf.version,
-                schedules: wf.schedules.map((s)=>({
-                        name: s.name,
-                        expression: s.expression
-                    })),
-                retryPolicy: wf.retryPolicy ? serializeRetryPolicy(wf.retryPolicy) : undefined
-            }));
-    }
-    /**
-   * 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.
-   */ async synchronize(workflowMap) {
-        // 1. 삭제된 파일은 일괄 삭제
-        await Promise.allSettled(Array.from(this.#workflowsMap.entries()).filter(([key])=>!workflowMap.has(key)).flatMap(([_, workflows])=>workflows.map((workflow)=>{
-                return Promise.allSettled([
-                    ...workflow.schedules.map((schedule)=>this.unscheduleTask(schedule.name)),
-                    this.unregisterWorkflow(workflow)
-                ]);
-            })));
-        // 2. 새로 추가된 파일은 일괄 등록
-        await Promise.allSettled(Array.from(workflowMap.entries()).filter(([key])=>!this.#workflowsMap.has(key)).flatMap(([_, workflows])=>workflows.map((workflow)=>{
-                this.registerWorkflow({
-                    id: workflow.id,
-                    name: workflow.name,
-                    version: workflow.version ?? null,
-                    schema: workflow.schema,
-                    function: workflow.fn,
-                    retryPolicy: workflow.retryPolicy
-                });
-                return Promise.allSettled(workflow.schedules.map((schedule)=>this.scheduleTask(workflow, schedule)));
-            })));
-        // 3. 기존과 다른 것을 diff친 다음, 삭제 후 재등록
-        await Promise.allSettled(Array.from(workflowMap.entries()).filter(([key])=>this.#workflowsMap.has(key)).map(([key, newWorkflows])=>{
-            const previousWorkflows = this.#workflowsMap.get(key);
-            assert(previousWorkflows, "previous workflows not found");
-            return [
-                key,
-                [
-                    previousWorkflows,
-                    newWorkflows
-                ]
-            ];
-        }).map(async ([_, [previousWorkflows, newWorkflows]])=>{
-            // 기존 것들을 삭제부터 해야함.
-            await Promise.allSettled(previousWorkflows.filter((prevItem)=>!newWorkflows.some((newItem)=>newItem.id === prevItem.id)).map((prevItem)=>{
-                return Promise.allSettled([
-                    ...prevItem.schedules.map((schedule)=>this.unscheduleTask(schedule.name)),
-                    this.unregisterWorkflow(prevItem)
-                ]);
-            }));
-            // 새로 추가된 것들을 등록
-            await Promise.allSettled(newWorkflows.filter((newItem)=>!previousWorkflows.some((prevItem)=>prevItem.id === newItem.id)).map(async (newItem)=>{
-                this.registerWorkflow({
-                    id: newItem.id,
-                    name: newItem.name,
-                    version: newItem.version ?? null,
-                    schema: newItem.schema,
-                    function: newItem.fn,
-                    retryPolicy: newItem.retryPolicy
-                });
-                return Promise.allSettled(newItem.schedules.map((schedule)=>this.scheduleTask(newItem, schedule)));
-            }));
-        }));
-        this.#workflowsMap = workflowMap;
-    }
-    // 워크플로우를 실행
-    run(options, input) {
-        return this.#ow.runWorkflow({
-            name: options.name,
-            version: options.version ?? undefined
-        }, input);
-    }
-    // cron task를 등록
-    async scheduleTask(workflow, schedule) {
-        // Worker가 활성화된 노드에서만 처리
-        if (!this.#worker) {
-            return;
-        }
-        const task = cronSchedule(schedule.expression, (async ({ name, version }, { input })=>{
-            const inputData = await (typeof input === "function" ? Promise.resolve(input()) : Promise.resolve(input));
-            return this.run({
-                name,
-                version: version ?? null
-            }, inputData);
-        }).bind(this, workflow, schedule), {
-            name: schedule.name,
-            timezone: Sonamu.config.api.timezone,
-            noOverlap: false
-        });
-        this.#scheduledTasks.set(schedule.name, {
-            task,
-            inputFn: schedule.input,
-            workflowId: workflow.id
-        });
-        await task.start();
-    }
-    // cron task를 중지
-    async unscheduleTask(name) {
-        // Worker가 활성화된 노드에서만 처리
-        if (!this.#worker) {
-            return;
-        }
-        const taskItem = this.#scheduledTasks.get(name);
-        if (!taskItem) {
-            console.error("scheduled task not found", name);
-            return;
-        }
-        this.#scheduledTasks.delete(name);
-        await taskItem.task.stop();
-        await taskItem.task.destroy();
-    }
-    // 워크플로우를 등록, 관련된 스케줄은 별도로 등록해야 함.
-    registerWorkflow(options) {
-        const fn = async (params)=>{
-            const baseContext = {
-                request: null,
-                reply: null,
-                headers: {},
-                createSSE: (schema)=>createMockSSEFactory(schema),
-                naiteStore: Naite.createStore(),
-                user: null,
-                passport: {
-                    login: async ()=>{},
-                    logout: ()=>{}
-                }
-            };
-            const contextProvider = Sonamu.config.tasks?.contextProvider;
-            const context = contextProvider ? await Promise.resolve(contextProvider(baseContext)) : baseContext;
-            const step = new StepWrapper(params.step);
-            return Sonamu.asyncLocalStorage.run({
-                context
-            }, ()=>options.function({
-                    input: params.input,
-                    step,
-                    version: params.version,
-                    logger: getLogger(convertDomainToCategory(options.name, "workflow"))
-                }));
-        };
-        const workflow = this.#ow.defineWorkflow({
-            name: options.name,
-            version: options.version ?? undefined,
-            schema: options.schema,
-            retryPolicy: options.retryPolicy
-        }, fn);
-        return workflow;
-    }
-    // 워크플로우를 등록 해제, 관련된 스케줄은 별도로 해제해야 함.
-    async unregisterWorkflow(workflow) {
-        this.#ow.unregisterWorkflow(workflow.name, workflow.version ?? null);
-    }
-    // Worker를 설정 후 시작
-    setupWorker(options) {
-        this.#worker = this.#ow.newWorker(options);
-    }
-    // Worker가 있으면 Worker까지 초기화, 아니면 백엔드만 초기화
-    async startWorker() {
-        await this.#backend.initialize();
-        await this.#worker?.start();
-    }
-    // Worker를 중지
-    async stopWorker() {
-        await this.#worker?.stop();
-    }
-    // cron task들을 모두 중지
-    async stopSchedules() {
-        await Promise.allSettled(Array.from(this.#scheduledTasks.values()).map(({ task })=>Promise.resolve(task.stop())));
-    }
-    // cron task들을 모두 정리
-    async destroySchedules() {
-        await Promise.allSettled(Array.from(this.#scheduledTasks.values()).map(({ task })=>Promise.resolve(task.destroy())));
-        this.#scheduledTasks.clear();
-    }
-    async destroy() {
-        await this.stopSchedules();
-        await this.stopWorker();
-        await this.destroySchedules();
-        await this.#backend.stop();
-    }
-    [Symbol.asyncDispose]() {
-        return this.destroy();
-    }
-}
+import { schedule } from "node-cron";
+
+//#region src/tasks/workflow-manager.ts
+var WorkflowManager;
+var init_workflow_manager = __esmMin((() => {
+	init_sonamu();
+	init_category();
+	init_naite();
+	init_sse();
+	init_step_wrapper();
+	WorkflowManager = class {
+		#backend;
+		#ow;
+		#worker;
+		#workflowsMap;
+		#scheduledTasks;
+		constructor(dbConf, runMigrations = true) {
+			const backend = new BackendPostgres(dbConf, { runMigrations });
+			this.#backend = backend;
+			this.#ow = new OpenWorkflow({ backend });
+			this.#worker = null;
+			this.#workflowsMap = new Map();
+			this.#scheduledTasks = new Map();
+		}
+		get backend() {
+			return this.#backend;
+		}
+		get workflowDefinitions() {
+			return Array.from(this.#workflowsMap.values()).flat().map((wf) => ({
+				id: wf.id,
+				name: wf.name,
+				version: wf.version,
+				schedules: wf.schedules.map((s) => ({
+					name: s.name,
+					expression: s.expression
+				})),
+				retryPolicy: wf.retryPolicy ? serializeRetryPolicy(wf.retryPolicy) : undefined
+			}));
+		}
+		/**
+		* 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.
+		*/
+		async synchronize(workflowMap) {
+			await Promise.allSettled(Array.from(this.#workflowsMap.entries()).filter(([key]) => !workflowMap.has(key)).flatMap(([_, workflows]) => workflows.map((workflow) => {
+				return Promise.allSettled([...workflow.schedules.map((schedule$1) => this.unscheduleTask(schedule$1.name)), this.unregisterWorkflow(workflow)]);
+			})));
+			await Promise.allSettled(Array.from(workflowMap.entries()).filter(([key]) => !this.#workflowsMap.has(key)).flatMap(([_, workflows]) => workflows.map((workflow) => {
+				this.registerWorkflow({
+					id: workflow.id,
+					name: workflow.name,
+					version: workflow.version ?? null,
+					schema: workflow.schema,
+					function: workflow.fn,
+					retryPolicy: workflow.retryPolicy
+				});
+				return Promise.allSettled(workflow.schedules.map((schedule$1) => this.scheduleTask(workflow, schedule$1)));
+			})));
+			await Promise.allSettled(Array.from(workflowMap.entries()).filter(([key]) => this.#workflowsMap.has(key)).map(([key, newWorkflows]) => {
+				const previousWorkflows = this.#workflowsMap.get(key);
+				assert(previousWorkflows, "previous workflows not found");
+				return [key, [previousWorkflows, newWorkflows]];
+			}).map(async ([_, [previousWorkflows, newWorkflows]]) => {
+				await Promise.allSettled(previousWorkflows.filter((prevItem) => !newWorkflows.some((newItem) => newItem.id === prevItem.id)).map((prevItem) => {
+					return Promise.allSettled([...prevItem.schedules.map((schedule$1) => this.unscheduleTask(schedule$1.name)), this.unregisterWorkflow(prevItem)]);
+				}));
+				await Promise.allSettled(newWorkflows.filter((newItem) => !previousWorkflows.some((prevItem) => prevItem.id === newItem.id)).map(async (newItem) => {
+					this.registerWorkflow({
+						id: newItem.id,
+						name: newItem.name,
+						version: newItem.version ?? null,
+						schema: newItem.schema,
+						function: newItem.fn,
+						retryPolicy: newItem.retryPolicy
+					});
+					return Promise.allSettled(newItem.schedules.map((schedule$1) => this.scheduleTask(newItem, schedule$1)));
+				}));
+			}));
+			this.#workflowsMap = workflowMap;
+		}
+		run(options, input) {
+			return this.#ow.runWorkflow({
+				name: options.name,
+				version: options.version ?? undefined
+			}, input);
+		}
+		async scheduleTask(workflow, schedule$1) {
+			if (!this.#worker) {
+				return;
+			}
+			const task = schedule(schedule$1.expression, (async ({ name, version }, { input }) => {
+				const inputData = await (typeof input === "function" ? Promise.resolve(input()) : Promise.resolve(input));
+				return this.run({
+					name,
+					version: version ?? null
+				}, inputData);
+			}).bind(this, workflow, schedule$1), {
+				name: schedule$1.name,
+				timezone: Sonamu.config.api.timezone,
+				noOverlap: false
+			});
+			this.#scheduledTasks.set(schedule$1.name, {
+				task,
+				inputFn: schedule$1.input,
+				workflowId: workflow.id
+			});
+			await task.start();
+		}
+		async unscheduleTask(name) {
+			if (!this.#worker) {
+				return;
+			}
+			const taskItem = this.#scheduledTasks.get(name);
+			if (!taskItem) {
+				console.error("scheduled task not found", name);
+				return;
+			}
+			this.#scheduledTasks.delete(name);
+			await taskItem.task.stop();
+			await taskItem.task.destroy();
+		}
+		registerWorkflow(options) {
+			const fn = async (params) => {
+				const baseContext = {
+					request: null,
+					reply: null,
+					headers: {},
+					createSSE: (schema) => createMockSSEFactory(schema),
+					naiteStore: Naite.createStore(),
+					locale: "",
+					user: null,
+					session: null
+				};
+				const contextProvider = Sonamu.config.tasks?.contextProvider;
+				const context = contextProvider ? await Promise.resolve(contextProvider(baseContext)) : baseContext;
+				const step = new StepWrapper(params.step);
+				return Sonamu.asyncLocalStorage.run({ context }, () => options.function({
+					input: params.input,
+					step,
+					version: params.version,
+					logger: getLogger(convertDomainToCategory(options.name, "workflow"))
+				}));
+			};
+			const workflow = this.#ow.defineWorkflow({
+				name: options.name,
+				version: options.version ?? undefined,
+				schema: options.schema,
+				retryPolicy: options.retryPolicy
+			}, fn);
+			return workflow;
+		}
+		async unregisterWorkflow(workflow) {
+			this.#ow.unregisterWorkflow(workflow.name, workflow.version ?? null);
+		}
+		setupWorker(options) {
+			this.#worker = this.#ow.newWorker(options);
+		}
+		async startWorker() {
+			await this.#backend.initialize();
+			await this.#worker?.start();
+		}
+		async stopWorker() {
+			await this.#worker?.stop();
+		}
+		async stopSchedules() {
+			await Promise.allSettled(Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.stop())));
+		}
+		async destroySchedules() {
+			await Promise.allSettled(Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.destroy())));
+			this.#scheduledTasks.clear();
+		}
+		async destroy() {
+			await this.stopSchedules();
+			await this.stopWorker();
+			await this.destroySchedules();
+			await this.#backend.stop();
+		}
+		[Symbol.asyncDispose]() {
+			return this.destroy();
+		}
+	};
+}));
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/tasks/workflow-manager.ts"],"sourcesContent":["import { getLogger, type Logger } from \"@logtape/logtape\";\nimport { BackendPostgres, OpenWorkflow, type Worker } from \"@sonamu-kit/tasks\";\nimport {\n  type RunnableWorkflow,\n  type SchemaInput,\n  type SchemaOutput,\n  type StandardSchemaV1,\n  type StepApi,\n  serializeRetryPolicy,\n  type WorkflowRunHandle,\n  type WorkflowSpec,\n} from \"@sonamu-kit/tasks/internal\";\nimport assert from \"assert\";\nimport type { Knex } from \"knex\";\nimport { schedule as cronSchedule, type ScheduledTask } from \"node-cron\";\nimport type { ZodObject } from \"zod\";\nimport type { Context } from \"../api/context\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { convertDomainToCategory } from \"../logger/category\";\nimport { Naite } from \"../naite/naite\";\nimport { createMockSSEFactory } from \"../stream/sse\";\nimport type { Executable } from \"../types/types\";\nimport type { WorkflowMetadata } from \"./decorator\";\nimport { StepWrapper } from \"./step-wrapper\";\n\nexport interface WorkflowOptions {\n  // worker에서 동시 실행할 태스크 수, 기본은 CPU 코어 수 - 1개\n  concurrency?: number;\n\n  // worker에서 사용할 pub/sub 여부, 기본은 true\n  usePubSub?: boolean;\n\n  // pub/sub으로 태스크를 수신했을 때 워크플로우 실행까지 지연 시간, 기본은 500ms\n  listenDelay?: number;\n}\n\n// Workflow 함수의 타입, @sonamu-kit/tasks와 다른 점은 step을 한번 감싼 형태.\nexport type WorkflowFunction<Input, Output> = (\n  params: Readonly<{\n    logger: Logger;\n    input: Input;\n    step: StepWrapper;\n    version: string | null;\n  }>,\n) => Promise<Output> | Output;\n\n// Workflow를 등록할 때를 위한 타입\nexport type WorkflowCreateOptions<\n  Input,\n  Output,\n  TSchema extends StandardSchemaV1 | undefined = undefined,\n> = Omit<\n  WorkflowSpec<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>>,\n  \"version\"\n> & {\n  id: string;\n  version: string | null;\n  function: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>;\n};\n\nexport class WorkflowManager {\n  // backend 인스턴스\n  readonly #backend: BackendPostgres;\n\n  // OpenWorkflow 인스턴스\n  readonly #ow: OpenWorkflow;\n\n  // Worker 인스턴스 (없을 수 있으며, 이 때는 분산된 서버 환경에서 DB에 publish만 한다고 가정함)\n  #worker: Worker | null;\n\n  // 파일 경로 -> 파일에 정의된 워크플로우 메타데이터 목록\n  #workflowsMap: Map<string, WorkflowMetadata[]>;\n\n  // Task 이름 -> Task 정보 및 Input 값, Workflow ID\n  #scheduledTasks: Map<\n    string,\n    {\n      task: ScheduledTask;\n      inputFn: Executable<SchemaInput<unknown, unknown>>;\n      workflowId: string;\n    }\n  >;\n\n  // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.\n  constructor(dbConf: Knex.Config, runMigrations: boolean = true) {\n    const backend = new BackendPostgres(dbConf, { runMigrations });\n\n    this.#backend = backend;\n    this.#ow = new OpenWorkflow({ backend });\n    this.#worker = null;\n\n    this.#workflowsMap = new Map();\n    this.#scheduledTasks = new Map();\n  }\n\n  // Sonamu UI API에서 워크플로우 실행 목록 조회, 취소 등에 사용합니다.\n  get backend(): BackendPostgres {\n    return this.#backend;\n  }\n\n  get workflowDefinitions() {\n    return Array.from(this.#workflowsMap.values())\n      .flat()\n      .map((wf) => ({\n        id: wf.id,\n        name: wf.name,\n        version: wf.version,\n        schedules: wf.schedules.map((s) => ({\n          name: s.name,\n          expression: s.expression,\n        })),\n        retryPolicy: wf.retryPolicy ? serializeRetryPolicy(wf.retryPolicy) : undefined,\n      }));\n  }\n\n  /**\n   * 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.\n   */\n  async synchronize(workflowMap: Map<string, WorkflowMetadata[]>) {\n    // 1. 삭제된 파일은 일괄 삭제\n    await Promise.allSettled(\n      Array.from(this.#workflowsMap.entries())\n        .filter(([key]) => !workflowMap.has(key))\n        .flatMap(([_, workflows]) =>\n          workflows.map((workflow) => {\n            return Promise.allSettled([\n              ...workflow.schedules.map((schedule) => this.unscheduleTask(schedule.name)),\n              this.unregisterWorkflow(workflow),\n            ]);\n          }),\n        ),\n    );\n\n    // 2. 새로 추가된 파일은 일괄 등록\n    await Promise.allSettled(\n      Array.from(workflowMap.entries())\n        .filter(([key]) => !this.#workflowsMap.has(key))\n        .flatMap(([_, workflows]) =>\n          workflows.map((workflow) => {\n            this.registerWorkflow({\n              id: workflow.id,\n              name: workflow.name,\n              version: workflow.version ?? null,\n              schema: workflow.schema,\n              function: workflow.fn,\n              retryPolicy: workflow.retryPolicy,\n            });\n\n            return Promise.allSettled(\n              workflow.schedules.map((schedule) => this.scheduleTask(workflow, schedule)),\n            );\n          }),\n        ),\n    );\n\n    // 3. 기존과 다른 것을 diff친 다음, 삭제 후 재등록\n    await Promise.allSettled(\n      Array.from(workflowMap.entries())\n        .filter(([key]) => this.#workflowsMap.has(key))\n        .map<[string, [WorkflowMetadata[], WorkflowMetadata[]]]>(([key, newWorkflows]) => {\n          const previousWorkflows = this.#workflowsMap.get(key);\n          assert(previousWorkflows, \"previous workflows not found\");\n          return [key, [previousWorkflows, newWorkflows]];\n        })\n        .map(async ([_, [previousWorkflows, newWorkflows]]) => {\n          // 기존 것들을 삭제부터 해야함.\n          await Promise.allSettled(\n            previousWorkflows\n              .filter((prevItem) => !newWorkflows.some((newItem) => newItem.id === prevItem.id))\n              .map((prevItem) => {\n                return Promise.allSettled([\n                  ...prevItem.schedules.map((schedule) => this.unscheduleTask(schedule.name)),\n                  this.unregisterWorkflow(prevItem),\n                ]);\n              }),\n          );\n\n          // 새로 추가된 것들을 등록\n          await Promise.allSettled(\n            newWorkflows\n              .filter(\n                (newItem) => !previousWorkflows.some((prevItem) => prevItem.id === newItem.id),\n              )\n              .map(async (newItem) => {\n                this.registerWorkflow({\n                  id: newItem.id,\n                  name: newItem.name,\n                  version: newItem.version ?? null,\n                  schema: newItem.schema,\n                  function: newItem.fn,\n                  retryPolicy: newItem.retryPolicy,\n                });\n\n                return Promise.allSettled(\n                  newItem.schedules.map((schedule) => this.scheduleTask(newItem, schedule)),\n                );\n              }),\n          );\n        }),\n    );\n\n    this.#workflowsMap = workflowMap;\n  }\n\n  // 워크플로우를 실행\n  run<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    options: Omit<WorkflowCreateOptions<Input, Output, TSchema>, \"function\" | \"schema\" | \"id\">,\n    input: SchemaInput<TSchema, Input>,\n  ): Promise<WorkflowRunHandle<Output>> {\n    return this.#ow.runWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n      },\n      input,\n    );\n  }\n\n  // cron task를 등록\n  async scheduleTask(\n    workflow: Pick<WorkflowMetadata, \"id\" | \"name\" | \"version\">,\n    schedule: WorkflowMetadata[\"schedules\"][number],\n  ) {\n    // Worker가 활성화된 노드에서만 처리\n    if (!this.#worker) {\n      return;\n    }\n\n    const task = cronSchedule(\n      schedule.expression,\n      (async (\n        { name, version }: Pick<WorkflowMetadata, \"name\" | \"version\">,\n        { input }: WorkflowMetadata[\"schedules\"][number],\n      ) => {\n        const inputData = await (typeof input === \"function\"\n          ? Promise.resolve(input())\n          : Promise.resolve(input));\n\n        return this.run({ name, version: version ?? null }, inputData);\n      }).bind(this, workflow, schedule),\n      {\n        name: schedule.name,\n        timezone: Sonamu.config.api.timezone,\n        noOverlap: false,\n      },\n    );\n\n    this.#scheduledTasks.set(schedule.name, {\n      task,\n      inputFn: schedule.input,\n      workflowId: workflow.id,\n    });\n    await task.start();\n  }\n\n  // cron task를 중지\n  async unscheduleTask(name: string) {\n    // Worker가 활성화된 노드에서만 처리\n    if (!this.#worker) {\n      return;\n    }\n\n    const taskItem = this.#scheduledTasks.get(name);\n    if (!taskItem) {\n      console.error(\"scheduled task not found\", name);\n      return;\n    }\n\n    this.#scheduledTasks.delete(name);\n    await taskItem.task.stop();\n    await taskItem.task.destroy();\n  }\n\n  // 워크플로우를 등록, 관련된 스케줄은 별도로 등록해야 함.\n  registerWorkflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    options: WorkflowCreateOptions<Input, Output, TSchema>,\n  ): RunnableWorkflow<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>> {\n    const fn = async (\n      params: Readonly<{\n        input: SchemaOutput<TSchema, Input>;\n        step: StepApi;\n        version: string | null;\n      }>,\n    ) => {\n      const baseContext = {\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        naiteStore: Naite.createStore(),\n        user: null,\n        passport: {\n          login: async () => {},\n          logout: () => {},\n        },\n      } as unknown as Context;\n\n      const contextProvider = Sonamu.config.tasks?.contextProvider;\n      const context: Context = contextProvider\n        ? await Promise.resolve(contextProvider(baseContext))\n        : baseContext;\n\n      const step = new StepWrapper(params.step);\n      return Sonamu.asyncLocalStorage.run({ context }, () =>\n        options.function({\n          input: params.input,\n          step,\n          version: params.version,\n          logger: getLogger(convertDomainToCategory(options.name, \"workflow\")),\n        }),\n      );\n    };\n\n    const workflow = this.#ow.defineWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n        schema: options.schema,\n        retryPolicy: options.retryPolicy,\n      },\n      fn,\n    );\n    return workflow;\n  }\n\n  // 워크플로우를 등록 해제, 관련된 스케줄은 별도로 해제해야 함.\n  async unregisterWorkflow(workflow: Pick<WorkflowMetadata, \"name\" | \"version\" | \"id\">) {\n    this.#ow.unregisterWorkflow(workflow.name, workflow.version ?? null);\n  }\n\n  // Worker를 설정 후 시작\n  setupWorker(options: WorkflowOptions) {\n    this.#worker = this.#ow.newWorker(options);\n  }\n\n  // Worker가 있으면 Worker까지 초기화, 아니면 백엔드만 초기화\n  async startWorker() {\n    await this.#backend.initialize();\n    await this.#worker?.start();\n  }\n\n  // Worker를 중지\n  async stopWorker() {\n    await this.#worker?.stop();\n  }\n\n  // cron task들을 모두 중지\n  async stopSchedules() {\n    await Promise.allSettled(\n      Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.stop())),\n    );\n  }\n\n  // cron task들을 모두 정리\n  async destroySchedules() {\n    await Promise.allSettled(\n      Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.destroy())),\n    );\n    this.#scheduledTasks.clear();\n  }\n\n  async destroy() {\n    await this.stopSchedules();\n    await this.stopWorker();\n    await this.destroySchedules();\n    await this.#backend.stop();\n  }\n\n  [Symbol.asyncDispose]() {\n    return this.destroy();\n  }\n}\n"],"names":["getLogger","BackendPostgres","OpenWorkflow","serializeRetryPolicy","assert","schedule","cronSchedule","Sonamu","convertDomainToCategory","Naite","createMockSSEFactory","StepWrapper","WorkflowManager","dbConf","runMigrations","backend","Map","workflowDefinitions","Array","from","values","flat","map","wf","id","name","version","schedules","s","expression","retryPolicy","undefined","synchronize","workflowMap","Promise","allSettled","entries","filter","key","has","flatMap","_","workflows","workflow","unscheduleTask","unregisterWorkflow","registerWorkflow","schema","function","fn","scheduleTask","newWorkflows","previousWorkflows","get","prevItem","some","newItem","run","options","input","runWorkflow","task","inputData","resolve","bind","timezone","config","api","noOverlap","set","inputFn","workflowId","start","taskItem","console","error","delete","stop","destroy","params","baseContext","request","reply","headers","createSSE","naiteStore","createStore","user","passport","login","logout","contextProvider","tasks","context","step","asyncLocalStorage","logger","defineWorkflow","setupWorker","newWorker","startWorker","initialize","stopWorker","stopSchedules","destroySchedules","clear","Symbol","asyncDispose"],"mappings":"AAAA,SAASA,SAAS,QAAqB,mBAAmB;AAC1D,SAASC,eAAe,EAAEC,YAAY,QAAqB,oBAAoB;AAC/E,SAMEC,oBAAoB,QAGf,6BAA6B;AACpC,OAAOC,YAAY,SAAS;AAE5B,SAASC,YAAYC,YAAY,QAA4B,YAAY;AAGzE,SAASC,MAAM,QAAQ,mBAAgB;AACvC,SAASC,uBAAuB,QAAQ,wBAAqB;AAC7D,SAASC,KAAK,QAAQ,oBAAiB;AACvC,SAASC,oBAAoB,QAAQ,mBAAgB;AAGrD,SAASC,WAAW,QAAQ,oBAAiB;AAqC7C,OAAO,MAAMC;IACX,eAAe;IACN,CAAA,OAAQ,CAAkB;IAEnC,oBAAoB;IACX,CAAA,EAAG,CAAe;IAE3B,gEAAgE;IAChE,CAAA,MAAO,CAAgB;IAEvB,kCAAkC;IAClC,CAAA,YAAa,CAAkC;IAE/C,4CAA4C;IAC5C,CAAA,cAAe,CAOb;IAEF,2DAA2D;IAC3D,YAAYC,MAAmB,EAAEC,gBAAyB,IAAI,CAAE;QAC9D,MAAMC,UAAU,IAAId,gBAAgBY,QAAQ;YAAEC;QAAc;QAE5D,IAAI,CAAC,CAAA,OAAQ,GAAGC;QAChB,IAAI,CAAC,CAAA,EAAG,GAAG,IAAIb,aAAa;YAAEa;QAAQ;QACtC,IAAI,CAAC,CAAA,MAAO,GAAG;QAEf,IAAI,CAAC,CAAA,YAAa,GAAG,IAAIC;QACzB,IAAI,CAAC,CAAA,cAAe,GAAG,IAAIA;IAC7B;IAEA,+CAA+C;IAC/C,IAAID,UAA2B;QAC7B,OAAO,IAAI,CAAC,CAAA,OAAQ;IACtB;IAEA,IAAIE,sBAAsB;QACxB,OAAOC,MAAMC,IAAI,CAAC,IAAI,CAAC,CAAA,YAAa,CAACC,MAAM,IACxCC,IAAI,GACJC,GAAG,CAAC,CAACC,KAAQ,CAAA;gBACZC,IAAID,GAAGC,EAAE;gBACTC,MAAMF,GAAGE,IAAI;gBACbC,SAASH,GAAGG,OAAO;gBACnBC,WAAWJ,GAAGI,SAAS,CAACL,GAAG,CAAC,CAACM,IAAO,CAAA;wBAClCH,MAAMG,EAAEH,IAAI;wBACZI,YAAYD,EAAEC,UAAU;oBAC1B,CAAA;gBACAC,aAAaP,GAAGO,WAAW,GAAG3B,qBAAqBoB,GAAGO,WAAW,IAAIC;YACvE,CAAA;IACJ;IAEA;;GAEC,GACD,MAAMC,YAAYC,WAA4C,EAAE;QAC9D,mBAAmB;QACnB,MAAMC,QAAQC,UAAU,CACtBjB,MAAMC,IAAI,CAAC,IAAI,CAAC,CAAA,YAAa,CAACiB,OAAO,IAClCC,MAAM,CAAC,CAAC,CAACC,IAAI,GAAK,CAACL,YAAYM,GAAG,CAACD,MACnCE,OAAO,CAAC,CAAC,CAACC,GAAGC,UAAU,GACtBA,UAAUpB,GAAG,CAAC,CAACqB;gBACb,OAAOT,QAAQC,UAAU,CAAC;uBACrBQ,SAAShB,SAAS,CAACL,GAAG,CAAC,CAACjB,WAAa,IAAI,CAACuC,cAAc,CAACvC,SAASoB,IAAI;oBACzE,IAAI,CAACoB,kBAAkB,CAACF;iBACzB;YACH;QAIN,sBAAsB;QACtB,MAAMT,QAAQC,UAAU,CACtBjB,MAAMC,IAAI,CAACc,YAAYG,OAAO,IAC3BC,MAAM,CAAC,CAAC,CAACC,IAAI,GAAK,CAAC,IAAI,CAAC,CAAA,YAAa,CAACC,GAAG,CAACD,MAC1CE,OAAO,CAAC,CAAC,CAACC,GAAGC,UAAU,GACtBA,UAAUpB,GAAG,CAAC,CAACqB;gBACb,IAAI,CAACG,gBAAgB,CAAC;oBACpBtB,IAAImB,SAASnB,EAAE;oBACfC,MAAMkB,SAASlB,IAAI;oBACnBC,SAASiB,SAASjB,OAAO,IAAI;oBAC7BqB,QAAQJ,SAASI,MAAM;oBACvBC,UAAUL,SAASM,EAAE;oBACrBnB,aAAaa,SAASb,WAAW;gBACnC;gBAEA,OAAOI,QAAQC,UAAU,CACvBQ,SAAShB,SAAS,CAACL,GAAG,CAAC,CAACjB,WAAa,IAAI,CAAC6C,YAAY,CAACP,UAAUtC;YAErE;QAIN,kCAAkC;QAClC,MAAM6B,QAAQC,UAAU,CACtBjB,MAAMC,IAAI,CAACc,YAAYG,OAAO,IAC3BC,MAAM,CAAC,CAAC,CAACC,IAAI,GAAK,IAAI,CAAC,CAAA,YAAa,CAACC,GAAG,CAACD,MACzChB,GAAG,CAAqD,CAAC,CAACgB,KAAKa,aAAa;YAC3E,MAAMC,oBAAoB,IAAI,CAAC,CAAA,YAAa,CAACC,GAAG,CAACf;YACjDlC,OAAOgD,mBAAmB;YAC1B,OAAO;gBAACd;gBAAK;oBAACc;oBAAmBD;iBAAa;aAAC;QACjD,GACC7B,GAAG,CAAC,OAAO,CAACmB,GAAG,CAACW,mBAAmBD,aAAa,CAAC;YAChD,mBAAmB;YACnB,MAAMjB,QAAQC,UAAU,CACtBiB,kBACGf,MAAM,CAAC,CAACiB,WAAa,CAACH,aAAaI,IAAI,CAAC,CAACC,UAAYA,QAAQhC,EAAE,KAAK8B,SAAS9B,EAAE,GAC/EF,GAAG,CAAC,CAACgC;gBACJ,OAAOpB,QAAQC,UAAU,CAAC;uBACrBmB,SAAS3B,SAAS,CAACL,GAAG,CAAC,CAACjB,WAAa,IAAI,CAACuC,cAAc,CAACvC,SAASoB,IAAI;oBACzE,IAAI,CAACoB,kBAAkB,CAACS;iBACzB;YACH;YAGJ,gBAAgB;YAChB,MAAMpB,QAAQC,UAAU,CACtBgB,aACGd,MAAM,CACL,CAACmB,UAAY,CAACJ,kBAAkBG,IAAI,CAAC,CAACD,WAAaA,SAAS9B,EAAE,KAAKgC,QAAQhC,EAAE,GAE9EF,GAAG,CAAC,OAAOkC;gBACV,IAAI,CAACV,gBAAgB,CAAC;oBACpBtB,IAAIgC,QAAQhC,EAAE;oBACdC,MAAM+B,QAAQ/B,IAAI;oBAClBC,SAAS8B,QAAQ9B,OAAO,IAAI;oBAC5BqB,QAAQS,QAAQT,MAAM;oBACtBC,UAAUQ,QAAQP,EAAE;oBACpBnB,aAAa0B,QAAQ1B,WAAW;gBAClC;gBAEA,OAAOI,QAAQC,UAAU,CACvBqB,QAAQ7B,SAAS,CAACL,GAAG,CAAC,CAACjB,WAAa,IAAI,CAAC6C,YAAY,CAACM,SAASnD;YAEnE;QAEN;QAGJ,IAAI,CAAC,CAAA,YAAa,GAAG4B;IACvB;IAEA,YAAY;IACZwB,IACEC,OAA0F,EAC1FC,KAAkC,EACE;QACpC,OAAO,IAAI,CAAC,CAAA,EAAG,CAACC,WAAW,CACzB;YACEnC,MAAMiC,QAAQjC,IAAI;YAClBC,SAASgC,QAAQhC,OAAO,IAAIK;QAC9B,GACA4B;IAEJ;IAEA,gBAAgB;IAChB,MAAMT,aACJP,QAA2D,EAC3DtC,QAA+C,EAC/C;QACA,wBAAwB;QACxB,IAAI,CAAC,IAAI,CAAC,CAAA,MAAO,EAAE;YACjB;QACF;QAEA,MAAMwD,OAAOvD,aACXD,SAASwB,UAAU,EACnB,AAAC,CAAA,OACC,EAAEJ,IAAI,EAAEC,OAAO,EAA8C,EAC7D,EAAEiC,KAAK,EAAyC;YAEhD,MAAMG,YAAY,MAAO,CAAA,OAAOH,UAAU,aACtCzB,QAAQ6B,OAAO,CAACJ,WAChBzB,QAAQ6B,OAAO,CAACJ,MAAK;YAEzB,OAAO,IAAI,CAACF,GAAG,CAAC;gBAAEhC;gBAAMC,SAASA,WAAW;YAAK,GAAGoC;QACtD,CAAA,EAAGE,IAAI,CAAC,IAAI,EAAErB,UAAUtC,WACxB;YACEoB,MAAMpB,SAASoB,IAAI;YACnBwC,UAAU1D,OAAO2D,MAAM,CAACC,GAAG,CAACF,QAAQ;YACpCG,WAAW;QACb;QAGF,IAAI,CAAC,CAAA,cAAe,CAACC,GAAG,CAAChE,SAASoB,IAAI,EAAE;YACtCoC;YACAS,SAASjE,SAASsD,KAAK;YACvBY,YAAY5B,SAASnB,EAAE;QACzB;QACA,MAAMqC,KAAKW,KAAK;IAClB;IAEA,gBAAgB;IAChB,MAAM5B,eAAenB,IAAY,EAAE;QACjC,wBAAwB;QACxB,IAAI,CAAC,IAAI,CAAC,CAAA,MAAO,EAAE;YACjB;QACF;QAEA,MAAMgD,WAAW,IAAI,CAAC,CAAA,cAAe,CAACpB,GAAG,CAAC5B;QAC1C,IAAI,CAACgD,UAAU;YACbC,QAAQC,KAAK,CAAC,4BAA4BlD;YAC1C;QACF;QAEA,IAAI,CAAC,CAAA,cAAe,CAACmD,MAAM,CAACnD;QAC5B,MAAMgD,SAASZ,IAAI,CAACgB,IAAI;QACxB,MAAMJ,SAASZ,IAAI,CAACiB,OAAO;IAC7B;IAEA,kCAAkC;IAClChC,iBACEY,OAAsD,EAC+B;QACrF,MAAMT,KAAK,OACT8B;YAMA,MAAMC,cAAc;gBAClBC,SAAS;gBACTC,OAAO;gBACPC,SAAS,CAAC;gBACVC,WAAW,CAACrC,SAAsBrC,qBAAqBqC;gBACvDsC,YAAY5E,MAAM6E,WAAW;gBAC7BC,MAAM;gBACNC,UAAU;oBACRC,OAAO,WAAa;oBACpBC,QAAQ,KAAO;gBACjB;YACF;YAEA,MAAMC,kBAAkBpF,OAAO2D,MAAM,CAAC0B,KAAK,EAAED;YAC7C,MAAME,UAAmBF,kBACrB,MAAMzD,QAAQ6B,OAAO,CAAC4B,gBAAgBX,gBACtCA;YAEJ,MAAMc,OAAO,IAAInF,YAAYoE,OAAOe,IAAI;YACxC,OAAOvF,OAAOwF,iBAAiB,CAACtC,GAAG,CAAC;gBAAEoC;YAAQ,GAAG,IAC/CnC,QAAQV,QAAQ,CAAC;oBACfW,OAAOoB,OAAOpB,KAAK;oBACnBmC;oBACApE,SAASqD,OAAOrD,OAAO;oBACvBsE,QAAQhG,UAAUQ,wBAAwBkD,QAAQjC,IAAI,EAAE;gBAC1D;QAEJ;QAEA,MAAMkB,WAAW,IAAI,CAAC,CAAA,EAAG,CAACsD,cAAc,CACtC;YACExE,MAAMiC,QAAQjC,IAAI;YAClBC,SAASgC,QAAQhC,OAAO,IAAIK;YAC5BgB,QAAQW,QAAQX,MAAM;YACtBjB,aAAa4B,QAAQ5B,WAAW;QAClC,GACAmB;QAEF,OAAON;IACT;IAEA,qCAAqC;IACrC,MAAME,mBAAmBF,QAA2D,EAAE;QACpF,IAAI,CAAC,CAAA,EAAG,CAACE,kBAAkB,CAACF,SAASlB,IAAI,EAAEkB,SAASjB,OAAO,IAAI;IACjE;IAEA,kBAAkB;IAClBwE,YAAYxC,OAAwB,EAAE;QACpC,IAAI,CAAC,CAAA,MAAO,GAAG,IAAI,CAAC,CAAA,EAAG,CAACyC,SAAS,CAACzC;IACpC;IAEA,yCAAyC;IACzC,MAAM0C,cAAc;QAClB,MAAM,IAAI,CAAC,CAAA,OAAQ,CAACC,UAAU;QAC9B,MAAM,IAAI,CAAC,CAAA,MAAO,EAAE7B;IACtB;IAEA,aAAa;IACb,MAAM8B,aAAa;QACjB,MAAM,IAAI,CAAC,CAAA,MAAO,EAAEzB;IACtB;IAEA,oBAAoB;IACpB,MAAM0B,gBAAgB;QACpB,MAAMrE,QAAQC,UAAU,CACtBjB,MAAMC,IAAI,CAAC,IAAI,CAAC,CAAA,cAAe,CAACC,MAAM,IAAIE,GAAG,CAAC,CAAC,EAAEuC,IAAI,EAAE,GAAK3B,QAAQ6B,OAAO,CAACF,KAAKgB,IAAI;IAEzF;IAEA,oBAAoB;IACpB,MAAM2B,mBAAmB;QACvB,MAAMtE,QAAQC,UAAU,CACtBjB,MAAMC,IAAI,CAAC,IAAI,CAAC,CAAA,cAAe,CAACC,MAAM,IAAIE,GAAG,CAAC,CAAC,EAAEuC,IAAI,EAAE,GAAK3B,QAAQ6B,OAAO,CAACF,KAAKiB,OAAO;QAE1F,IAAI,CAAC,CAAA,cAAe,CAAC2B,KAAK;IAC5B;IAEA,MAAM3B,UAAU;QACd,MAAM,IAAI,CAACyB,aAAa;QACxB,MAAM,IAAI,CAACD,UAAU;QACrB,MAAM,IAAI,CAACE,gBAAgB;QAC3B,MAAM,IAAI,CAAC,CAAA,OAAQ,CAAC3B,IAAI;IAC1B;IAEA,CAAC6B,OAAOC,YAAY,CAAC,GAAG;QACtB,OAAO,IAAI,CAAC7B,OAAO;IACrB;AACF"}
+//#endregion
+init_workflow_manager();
+export { WorkflowManager };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"file":"workflow-manager.js","names":["#backend","#ow","#worker","#workflowsMap","#scheduledTasks","schedule","cronSchedule","context: Context"],"sources":["../../src/tasks/workflow-manager.ts"],"sourcesContent":["import assert from \"assert\";\n\nimport { getLogger } from \"@logtape/logtape\";\nimport { type Logger } from \"@logtape/logtape\";\nimport { BackendPostgres, OpenWorkflow } from \"@sonamu-kit/tasks\";\nimport { type Worker } from \"@sonamu-kit/tasks\";\nimport { serializeRetryPolicy } from \"@sonamu-kit/tasks/internal\";\nimport {\n  type RunnableWorkflow,\n  type SchemaInput,\n  type SchemaOutput,\n  type StandardSchemaV1,\n  type StepApi,\n  type WorkflowRunHandle,\n  type WorkflowSpec,\n} from \"@sonamu-kit/tasks/internal\";\nimport { type Knex } from \"knex\";\nimport { schedule as cronSchedule } from \"node-cron\";\nimport { type ScheduledTask } from \"node-cron\";\nimport { type ZodObject } from \"zod\";\n\nimport { type Context } from \"../api/context\";\nimport { Sonamu } from \"../api/sonamu\";\nimport { convertDomainToCategory } from \"../logger/category\";\nimport { Naite } from \"../naite/naite\";\nimport { createMockSSEFactory } from \"../stream/sse\";\nimport { type Executable } from \"../types/types\";\nimport { type WorkflowMetadata } from \"./decorator\";\nimport { StepWrapper } from \"./step-wrapper\";\n\nexport interface WorkflowOptions {\n  // worker에서 동시 실행할 태스크 수, 기본은 1\n  concurrency?: number;\n\n  // worker에서 사용할 pub/sub 여부, 기본은 true\n  usePubSub?: boolean;\n\n  // pub/sub으로 태스크를 수신했을 때 워크플로우 실행까지 지연 시간, 기본은 500ms\n  listenDelay?: number;\n}\n\n// Workflow 함수의 타입, @sonamu-kit/tasks와 다른 점은 step을 한번 감싼 형태.\nexport type WorkflowFunction<Input, Output> = (\n  params: Readonly<{\n    logger: Logger;\n    input: Input;\n    step: StepWrapper;\n    version: string | null;\n  }>,\n) => Promise<Output> | Output;\n\n// Workflow를 등록할 때를 위한 타입\nexport type WorkflowCreateOptions<\n  Input,\n  Output,\n  TSchema extends StandardSchemaV1 | undefined = undefined,\n> = Omit<\n  WorkflowSpec<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>>,\n  \"version\"\n> & {\n  id: string;\n  version: string | null;\n  function: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>;\n};\n\nexport class WorkflowManager {\n  // backend 인스턴스\n  readonly #backend: BackendPostgres;\n\n  // OpenWorkflow 인스턴스\n  readonly #ow: OpenWorkflow;\n\n  // Worker 인스턴스 (없을 수 있으며, 이 때는 분산된 서버 환경에서 DB에 publish만 한다고 가정함)\n  #worker: Worker | null;\n\n  // 파일 경로 -> 파일에 정의된 워크플로우 메타데이터 목록\n  #workflowsMap: Map<string, WorkflowMetadata[]>;\n\n  // Task 이름 -> Task 정보 및 Input 값, Workflow ID\n  #scheduledTasks: Map<\n    string,\n    {\n      task: ScheduledTask;\n      inputFn: Executable<SchemaInput<unknown, unknown>>;\n      workflowId: string;\n    }\n  >;\n\n  // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.\n  constructor(dbConf: Knex.Config, runMigrations: boolean = true) {\n    const backend = new BackendPostgres(dbConf, { runMigrations });\n\n    this.#backend = backend;\n    this.#ow = new OpenWorkflow({ backend });\n    this.#worker = null;\n\n    this.#workflowsMap = new Map();\n    this.#scheduledTasks = new Map();\n  }\n\n  // Sonamu UI API에서 워크플로우 실행 목록 조회, 취소 등에 사용합니다.\n  get backend(): BackendPostgres {\n    return this.#backend;\n  }\n\n  get workflowDefinitions() {\n    return Array.from(this.#workflowsMap.values())\n      .flat()\n      .map((wf) => ({\n        id: wf.id,\n        name: wf.name,\n        version: wf.version,\n        schedules: wf.schedules.map((s) => ({\n          name: s.name,\n          expression: s.expression,\n        })),\n        retryPolicy: wf.retryPolicy ? serializeRetryPolicy(wf.retryPolicy) : undefined,\n      }));\n  }\n\n  /**\n   * 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.\n   */\n  async synchronize(workflowMap: Map<string, WorkflowMetadata[]>) {\n    // 1. 삭제된 파일은 일괄 삭제\n    await Promise.allSettled(\n      Array.from(this.#workflowsMap.entries())\n        .filter(([key]) => !workflowMap.has(key))\n        .flatMap(([_, workflows]) =>\n          workflows.map((workflow) => {\n            return Promise.allSettled([\n              ...workflow.schedules.map((schedule) => this.unscheduleTask(schedule.name)),\n              this.unregisterWorkflow(workflow),\n            ]);\n          }),\n        ),\n    );\n\n    // 2. 새로 추가된 파일은 일괄 등록\n    await Promise.allSettled(\n      Array.from(workflowMap.entries())\n        .filter(([key]) => !this.#workflowsMap.has(key))\n        .flatMap(([_, workflows]) =>\n          workflows.map((workflow) => {\n            this.registerWorkflow({\n              id: workflow.id,\n              name: workflow.name,\n              version: workflow.version ?? null,\n              schema: workflow.schema,\n              function: workflow.fn,\n              retryPolicy: workflow.retryPolicy,\n            });\n\n            return Promise.allSettled(\n              workflow.schedules.map((schedule) => this.scheduleTask(workflow, schedule)),\n            );\n          }),\n        ),\n    );\n\n    // 3. 기존과 다른 것을 diff친 다음, 삭제 후 재등록\n    await Promise.allSettled(\n      Array.from(workflowMap.entries())\n        .filter(([key]) => this.#workflowsMap.has(key))\n        .map<[string, [WorkflowMetadata[], WorkflowMetadata[]]]>(([key, newWorkflows]) => {\n          const previousWorkflows = this.#workflowsMap.get(key);\n          assert(previousWorkflows, \"previous workflows not found\");\n          return [key, [previousWorkflows, newWorkflows]];\n        })\n        .map(async ([_, [previousWorkflows, newWorkflows]]) => {\n          // 기존 것들을 삭제부터 해야함.\n          await Promise.allSettled(\n            previousWorkflows\n              .filter((prevItem) => !newWorkflows.some((newItem) => newItem.id === prevItem.id))\n              .map((prevItem) => {\n                return Promise.allSettled([\n                  ...prevItem.schedules.map((schedule) => this.unscheduleTask(schedule.name)),\n                  this.unregisterWorkflow(prevItem),\n                ]);\n              }),\n          );\n\n          // 새로 추가된 것들을 등록\n          await Promise.allSettled(\n            newWorkflows\n              .filter(\n                (newItem) => !previousWorkflows.some((prevItem) => prevItem.id === newItem.id),\n              )\n              .map(async (newItem) => {\n                this.registerWorkflow({\n                  id: newItem.id,\n                  name: newItem.name,\n                  version: newItem.version ?? null,\n                  schema: newItem.schema,\n                  function: newItem.fn,\n                  retryPolicy: newItem.retryPolicy,\n                });\n\n                return Promise.allSettled(\n                  newItem.schedules.map((schedule) => this.scheduleTask(newItem, schedule)),\n                );\n              }),\n          );\n        }),\n    );\n\n    this.#workflowsMap = workflowMap;\n  }\n\n  // 워크플로우를 실행\n  run<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    options: Omit<WorkflowCreateOptions<Input, Output, TSchema>, \"function\" | \"schema\" | \"id\">,\n    input: SchemaInput<TSchema, Input>,\n  ): Promise<WorkflowRunHandle<Output>> {\n    return this.#ow.runWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n      },\n      input,\n    );\n  }\n\n  // cron task를 등록\n  async scheduleTask(\n    workflow: Pick<WorkflowMetadata, \"id\" | \"name\" | \"version\">,\n    schedule: WorkflowMetadata[\"schedules\"][number],\n  ) {\n    // Worker가 활성화된 노드에서만 처리\n    if (!this.#worker) {\n      return;\n    }\n\n    const task = cronSchedule(\n      schedule.expression,\n      (async (\n        { name, version }: Pick<WorkflowMetadata, \"name\" | \"version\">,\n        { input }: WorkflowMetadata[\"schedules\"][number],\n      ) => {\n        const inputData = await (typeof input === \"function\"\n          ? Promise.resolve(input())\n          : Promise.resolve(input));\n\n        return this.run({ name, version: version ?? null }, inputData);\n      }).bind(this, workflow, schedule),\n      {\n        name: schedule.name,\n        timezone: Sonamu.config.api.timezone,\n        noOverlap: false,\n      },\n    );\n\n    this.#scheduledTasks.set(schedule.name, {\n      task,\n      inputFn: schedule.input,\n      workflowId: workflow.id,\n    });\n    await task.start();\n  }\n\n  // cron task를 중지\n  async unscheduleTask(name: string) {\n    // Worker가 활성화된 노드에서만 처리\n    if (!this.#worker) {\n      return;\n    }\n\n    const taskItem = this.#scheduledTasks.get(name);\n    if (!taskItem) {\n      console.error(\"scheduled task not found\", name);\n      return;\n    }\n\n    this.#scheduledTasks.delete(name);\n    await taskItem.task.stop();\n    await taskItem.task.destroy();\n  }\n\n  // 워크플로우를 등록, 관련된 스케줄은 별도로 등록해야 함.\n  registerWorkflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(\n    options: WorkflowCreateOptions<Input, Output, TSchema>,\n  ): RunnableWorkflow<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>> {\n    const fn = async (\n      params: Readonly<{\n        input: SchemaOutput<TSchema, Input>;\n        step: StepApi;\n        version: string | null;\n      }>,\n    ) => {\n      const baseContext = {\n        request: null,\n        reply: null,\n        headers: {},\n        createSSE: (schema: ZodObject) => createMockSSEFactory(schema),\n        naiteStore: Naite.createStore(),\n        locale: \"\",\n        user: null,\n        session: null,\n      } as unknown as Context;\n\n      const contextProvider = Sonamu.config.tasks?.contextProvider;\n      const context: Context = contextProvider\n        ? await Promise.resolve(contextProvider(baseContext))\n        : baseContext;\n\n      const step = new StepWrapper(params.step);\n      return Sonamu.asyncLocalStorage.run({ context }, () =>\n        options.function({\n          input: params.input,\n          step,\n          version: params.version,\n          logger: getLogger(convertDomainToCategory(options.name, \"workflow\")),\n        }),\n      );\n    };\n\n    const workflow = this.#ow.defineWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n        schema: options.schema,\n        retryPolicy: options.retryPolicy,\n      },\n      fn,\n    );\n    return workflow;\n  }\n\n  // 워크플로우를 등록 해제, 관련된 스케줄은 별도로 해제해야 함.\n  async unregisterWorkflow(workflow: Pick<WorkflowMetadata, \"name\" | \"version\" | \"id\">) {\n    this.#ow.unregisterWorkflow(workflow.name, workflow.version ?? null);\n  }\n\n  // Worker를 설정 후 시작\n  setupWorker(options: WorkflowOptions) {\n    this.#worker = this.#ow.newWorker(options);\n  }\n\n  // Worker가 있으면 Worker까지 초기화, 아니면 백엔드만 초기화\n  async startWorker() {\n    await this.#backend.initialize();\n    await this.#worker?.start();\n  }\n\n  // Worker를 중지\n  async stopWorker() {\n    await this.#worker?.stop();\n  }\n\n  // cron task들을 모두 중지\n  async stopSchedules() {\n    await Promise.allSettled(\n      Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.stop())),\n    );\n  }\n\n  // cron task들을 모두 정리\n  async destroySchedules() {\n    await Promise.allSettled(\n      Array.from(this.#scheduledTasks.values()).map(({ task }) => Promise.resolve(task.destroy())),\n    );\n    this.#scheduledTasks.clear();\n  }\n\n  async destroy() {\n    await this.stopSchedules();\n    await this.stopWorker();\n    await this.destroySchedules();\n    await this.#backend.stop();\n  }\n\n  [Symbol.asyncDispose]() {\n    return this.destroy();\n  }\n}\n"],"mappings":"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"}

package/dist/template/entity-converter.d.ts

@@ -1,5 +1,5 @@
 import z from "zod";
-import type { EntityPropNode, RenderingNode } from "../types/types";
+import { type EntityPropNode, type RenderingNode } from "../types/types";
 /**
  * 엔티티의 특정 subset을 RenderingNode로 변환합니다.
  * subset의 필드들을 Zod 타입으로 변환한 후 UI 렌더링용 노드로 만듭니다.

package/dist/template/entity-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"entity-converter.d.ts","sourceRoot":"","sources":["../../src/template/entity-converter.ts"],"names":[],"mappings":"AACA,OAAO,CAAC,MAAM,KAAK,CAAC;AAIpB,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGpE;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAyDhG;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAsCvF"}
+{"version":3,"file":"entity-converter.d.ts","sourceRoot":"","sources":["../../src/template/entity-converter.ts"],"names":[],"mappings":"AAEA,OAAO,CAAC,MAAM,KAAK,CAAC;AAKpB,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAGzE;;;;GAIG;AACH,wBAAsB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,aAAa,CAAC,CAyDhG;AAED;;;GAGG;AACH,wBAAsB,iBAAiB,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,CAsCvF"}