sonamu 0.7.11 → 0.7.13

package/dist/tasks/step-wrapper.js

@@ -0,0 +1,38 @@
+import inflection from "inflection";
+export class StepWrapper {
+    #stepApi;
+    constructor(stepApi){
+        this.#stepApi = stepApi;
+    }
+    get(...args) {
+        let config;
+        let fn;
+        if (args.length === 2) {
+            const [rawObject, methodName] = args;
+            const method = rawObject[methodName];
+            config = {
+                name: inflection.underscore(methodName.toString())
+            };
+            fn = (...args)=>method.bind(rawObject)(...args);
+        } else {
+            const [rawConfig, rawObject, name] = args;
+            const method = rawObject[name];
+            config = {
+                name: rawConfig.name ?? inflection.underscore(name.toString())
+            };
+            fn = (...args)=>method.bind(rawObject)(...args);
+        }
+        return {
+            run: ((stepApi)=>{
+                return (...args)=>{
+                    return stepApi.run(config, ()=>fn(...args));
+                };
+            })(this.#stepApi)
+        };
+    }
+    sleep(name, duration) {
+        return this.#stepApi.sleep(name, duration);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/dist/tasks/workflow-manager.d.ts

@@ -0,0 +1,40 @@
+import type { RunnableWorkflow, SchemaInput, SchemaOutput, StandardSchemaV1, WorkflowRunHandle, WorkflowSpec } from "@sonamu-kit/tasks/internal";
+import type { Knex } from "knex";
+import type { WorkflowMetadata } from "./decorator";
+import { StepWrapper } from "./step-wrapper";
+export interface WorkflowOptions {
+    concurrency?: number;
+    usePubSub?: boolean;
+    listenDelay?: number;
+}
+export type WorkflowFunction<Input, Output> = (params: Readonly<{
+    input: Input;
+    step: StepWrapper;
+    version: string | null;
+}>) => Promise<Output> | Output;
+export type WorkflowCreateOptions<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined> = Omit<WorkflowSpec<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>>, "version"> & {
+    id: string;
+    version: string | null;
+    function: WorkflowFunction<SchemaOutput<TSchema, Input>, Output>;
+};
+export declare class WorkflowManager {
+    #private;
+    private constructor();
+    /**
+     * 정의된 워크플로우 및 워크플로우에 대한 scheduled tasks를 동기화합니다.
+     */
+    synchronize(workflowMap: Map<string, WorkflowMetadata[]>): Promise<void>;
+    run<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(options: Omit<WorkflowCreateOptions<Input, Output, TSchema>, "function" | "schema" | "id">, input: SchemaInput<TSchema, Input>): Promise<WorkflowRunHandle<Output>>;
+    scheduleTask(workflow: Pick<WorkflowMetadata, "id" | "name" | "version">, schedule: WorkflowMetadata["schedules"][number]): Promise<void>;
+    unscheduleTask(name: string): Promise<void>;
+    registerWorkflow<Input, Output, TSchema extends StandardSchemaV1 | undefined = undefined>(options: WorkflowCreateOptions<Input, Output, TSchema>): RunnableWorkflow<SchemaOutput<TSchema, Input>, Output, SchemaInput<TSchema, Input>>;
+    unregisterWorkflow(workflow: Pick<WorkflowMetadata, "name" | "version" | "id">): Promise<void>;
+    setupWorker(options: WorkflowOptions): Promise<void>;
+    stopWorker(): Promise<void>;
+    stopSchedules(): Promise<void>;
+    destroySchedules(): Promise<void>;
+    destroy(): Promise<void>;
+    [Symbol.asyncDispose](): Promise<void>;
+    static create(dbConf: Knex.Config, runMigrations?: boolean): Promise<WorkflowManager>;
+}
+//# sourceMappingURL=workflow-manager.d.ts.map

package/dist/tasks/workflow-manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-manager.d.ts","sourceRoot":"","sources":["../../src/tasks/workflow-manager.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,gBAAgB,EAChB,WAAW,EACX,YAAY,EACZ,gBAAgB,EAEhB,iBAAiB,EACjB,YAAY,EACb,MAAM,4BAA4B,CAAC;AAEpC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAQjC,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAE7C,MAAM,WAAW,eAAe;IAE9B,WAAW,CAAC,EAAE,MAAM,CAAC;IAGrB,SAAS,CAAC,EAAE,OAAO,CAAC;IAGpB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAGD,MAAM,MAAM,gBAAgB,CAAC,KAAK,EAAE,MAAM,IAAI,CAC5C,MAAM,EAAE,QAAQ,CAAC;IACf,KAAK,EAAE,KAAK,CAAC;IACb,IAAI,EAAE,WAAW,CAAC;IAClB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;CACxB,CAAC,KACC,OAAO,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC;AAG9B,MAAM,MAAM,qBAAqB,CAC/B,KAAK,EACL,MAAM,EACN,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,IACtD,IAAI,CACN,YAAY,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,EAC/E,SAAS,CACV,GAAG;IACF,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,QAAQ,EAAE,gBAAgB,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,CAAC;CAClE,CAAC;AAEF,qBAAa,eAAe;;IAuB1B,OAAO;IAQP;;OAEG;IACG,WAAW,CAAC,WAAW,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC;IAqF9D,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,EACzE,OAAO,EAAE,IAAI,CAAC,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,UAAU,GAAG,QAAQ,GAAG,IAAI,CAAC,EAC1F,KAAK,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,GACjC,OAAO,CAAC,iBAAiB,CAAC,MAAM,CAAC,CAAC;IAW/B,YAAY,CAChB,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,IAAI,GAAG,MAAM,GAAG,SAAS,CAAC,EAC3D,QAAQ,EAAE,gBAAgB,CAAC,WAAW,CAAC,CAAC,MAAM,CAAC;IA8B3C,cAAc,CAAC,IAAI,EAAE,MAAM;IAajC,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,SAAS,gBAAgB,GAAG,SAAS,GAAG,SAAS,EACtF,OAAO,EAAE,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,GACrD,gBAAgB,CAAC,YAAY,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,WAAW,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IA4ChF,kBAAkB,CAAC,QAAQ,EAAE,IAAI,CAAC,gBAAgB,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;IAK9E,WAAW,CAAC,OAAO,EAAE,eAAe;IAMpC,UAAU;IAKV,aAAa;IAOb,gBAAgB;IAOhB,OAAO;IAOb,CAAC,MAAM,CAAC,YAAY,CAAC;WAKR,MAAM,CACjB,MAAM,EAAE,IAAI,CAAC,MAAM,EACnB,aAAa,GAAE,OAAc,GAC5B,OAAO,CAAC,eAAe,CAAC;CAI5B"}

package/dist/tasks/workflow-manager.js

@@ -0,0 +1,193 @@
+import { BackendPostgres, OpenWorkflow } from "@sonamu-kit/tasks";
+import assert from "assert";
+import { schedule as cronSchedule } from "node-cron";
+import { Sonamu } from "../api/sonamu.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;
+    constructor(backend){
+        this.#backend = backend;
+        this.#ow = new OpenWorkflow({
+            backend
+        });
+        this.#worker = null;
+        this.#workflowsMap = new Map();
+        this.#scheduledTasks = new Map();
+    }
+    /**
+   * 정의된 워크플로우 및 워크플로우에 대한 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
+                });
+                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
+                });
+                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) {
+        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) {
+        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
+                }));
+        };
+        const workflow = this.#ow.defineWorkflow({
+            name: options.name,
+            version: options.version ?? undefined,
+            schema: options.schema
+        }, fn);
+        return workflow;
+    }
+    // 워크플로우를 등록 해제, 관련된 스케줄은 별도로 해제해야 함.
+    async unregisterWorkflow(workflow) {
+        this.#ow.unregisterWorkflow(workflow.name, workflow.version ?? null);
+    }
+    // Worker를 설정 후 시작
+    async setupWorker(options) {
+        this.#worker = this.#ow.newWorker(options);
+        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();
+    }
+    // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.
+    static async create(dbConf, runMigrations = true) {
+        const backend = await BackendPostgres.connect(dbConf, {
+            runMigrations
+        });
+        return new WorkflowManager(backend);
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../src/tasks/workflow-manager.ts"],"sourcesContent":["import { BackendPostgres, OpenWorkflow, type Worker } from \"@sonamu-kit/tasks\";\nimport type {\n  RunnableWorkflow,\n  SchemaInput,\n  SchemaOutput,\n  StandardSchemaV1,\n  StepApi,\n  WorkflowRunHandle,\n  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 { 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    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  private constructor(backend: BackendPostgres) {\n    this.#backend = backend;\n    this.#ow = new OpenWorkflow({ backend });\n    this.#worker = null;\n    this.#workflowsMap = new Map();\n    this.#scheduledTasks = new Map();\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            });\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                });\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    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    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({ input: params.input, step, version: params.version }),\n      );\n    };\n\n    const workflow = this.#ow.defineWorkflow(\n      {\n        name: options.name,\n        version: options.version ?? undefined,\n        schema: options.schema,\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  async setupWorker(options: WorkflowOptions) {\n    this.#worker = this.#ow.newWorker(options);\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  // BackendPostgres에서 처리하는 것들이 있어서 Knex 커넥션이 아니라 설정값을 넣어줘야함.\n  static async create(\n    dbConf: Knex.Config,\n    runMigrations: boolean = true,\n  ): Promise<WorkflowManager> {\n    const backend = await BackendPostgres.connect(dbConf, { runMigrations });\n    return new WorkflowManager(backend);\n  }\n}\n"],"names":["BackendPostgres","OpenWorkflow","assert","schedule","cronSchedule","Sonamu","Naite","createMockSSEFactory","StepWrapper","WorkflowManager","backend","Map","synchronize","workflowMap","Promise","allSettled","Array","from","entries","filter","key","has","flatMap","_","workflows","map","workflow","schedules","unscheduleTask","name","unregisterWorkflow","registerWorkflow","id","version","schema","function","fn","scheduleTask","newWorkflows","previousWorkflows","get","prevItem","some","newItem","run","options","input","runWorkflow","undefined","task","expression","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","defineWorkflow","setupWorker","newWorker","stopWorker","stopSchedules","values","destroySchedules","clear","Symbol","asyncDispose","create","dbConf","runMigrations","connect"],"mappings":"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"}

package/dist/template/implementations/generated.template.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generated.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated.template.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAKlD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,qBAAa,mBAAoB,SAAQ,QAAQ;;IAK/C,gBAAgB;;;;IAOhB,MAAM;;;;;;;IAmGN,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAqBrD,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,EAAO,GAAG,UAAU;IA+F9E,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAiD9D,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;CA8CvD"}
+{"version":3,"file":"generated.template.d.ts","sourceRoot":"","sources":["../../../src/template/implementations/generated.template.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAKlD,OAAO,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAGvC,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,UAAU,EAAE,MAAM,EAAE,CAAC;CACtB,CAAC;AACF,qBAAa,mBAAoB,SAAQ,QAAQ;;IAK/C,gBAAgB;;;;IAOhB,MAAM;;;;;;;IAmGN,kBAAkB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAqBrD,uBAAuB,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,GAAE,MAAM,EAAO,GAAG,UAAU;IA6G9E,2BAA2B,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAgD9D,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;CA8CvD"}

package/dist/template/implementations/generated.template.js

@@ -163,13 +163,17 @@ export class Template__generated extends Template {
      * - relation이 아니거나, relation이어도 nullable이면 포함
      */ const hasDefaultColumns = entity.props.filter((prop)=>(prop.type !== "relation" || prop.nullable === true) && (prop.nullable === true || prop.type !== "relation" && prop.dbDefault !== undefined)).map((prop)=>prop.type === "relation" ? `${prop.name}_id` : prop.name).concat("id");
         /**
+     * hasVector props
+     * - vector 타입인 컬럼
+     */ const hasVectorColumns = entity.props.filter((prop)=>prop.type === "vector" || prop.type === "vector[]").map((prop)=>prop.name);
+        /**
      * generated props
      * - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)
      */ const generatedColumns = entity.props.filter((prop)=>prop.type !== "relation" && prop.generated !== undefined).map((prop)=>prop.name);
-        const hasMetadata = fulltextColumns.length > 0 || virtualProps.length > 0 || hasDefaultColumns.length > 0 || generatedColumns.length > 0;
+        const hasMetadata = fulltextColumns.length > 0 || virtualProps.length > 0 || hasDefaultColumns.length > 0 || generatedColumns.length > 0 || hasVectorColumns.length > 0;
         const lines = [
             `export const ${schemaName} = ${schemaBody};`,
-            `export type ${schemaName} = z.infer<typeof ${schemaName}>` + (hasMetadata ? ` & {${(fulltextColumns.length > 0 ? `readonly __fulltext__: readonly [${fulltextColumns.map((col)=>`"${col}"`).join(", ")}],` : "") + (virtualProps.length > 0 ? `readonly __virtual__: readonly [${virtualProps.map((prop)=>`"${prop}"`).join(", ")}],` : "") + (hasDefaultColumns.length > 0 ? `readonly __hasDefault__: readonly [${hasDefaultColumns.map((col)=>`"${col}"`).join(", ")}],` : "") + (generatedColumns.length > 0 ? `readonly __generated__: readonly [${generatedColumns.map((col)=>`"${col}"`).join(", ")}],` : "")}}` : "") + ";"
+            `export type ${schemaName} = z.infer<typeof ${schemaName}>` + (hasMetadata ? ` & {${(fulltextColumns.length > 0 ? `readonly __fulltext__: readonly [${fulltextColumns.map((col)=>`"${col}"`).join(", ")}],` : "") + (virtualProps.length > 0 ? `readonly __virtual__: readonly [${virtualProps.map((prop)=>`"${prop}"`).join(", ")}],` : "") + (hasDefaultColumns.length > 0 ? `readonly __hasDefault__: readonly [${hasDefaultColumns.map((col)=>`"${col}"`).join(", ")}],` : "") + (generatedColumns.length > 0 ? `readonly __generated__: readonly [${generatedColumns.map((col)=>`"${col}"`).join(", ")}],` : "") + (hasVectorColumns.length > 0 ? `readonly __vector__: readonly [${hasVectorColumns.map((col)=>`"${col}"`).join(", ")}],` : "")}}` : "") + ";"
         ];
         return {
             label: `BaseSchema: ${entity.id}`,
@@ -257,4 +261,4 @@ z.object({
     }
 }
 
-//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/generated.template.ts"],"sourcesContent":["import assert from \"assert\";\nimport { unique } from \"radashi\";\nimport { Sonamu } from \"../../api\";\nimport type { Entity } from \"../../entity/entity\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { Naite } from \"../../naite/naite\";\nimport { type EntityIndex, type EntityPropNode, isVirtualProp } from \"../../types/types\";\nimport { nonNullable } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { propNodeToZodTypeDef, zodTypeToZodCode } from \"../zod-converter\";\n\nexport type SourceCode = {\n  label: string;\n  lines: string[];\n  importKeys: string[];\n};\nexport class Template__generated extends Template {\n  constructor() {\n    super(\"generated\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.ts`,\n    };\n  }\n  render() {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    // 전체 SourceCode 생성\n    const sourceCodes = entities.flatMap((entity) => {\n      return [\n        this.getEnumsSourceCode(entity),\n        this.getBaseSchemaSourceCode(entity),\n        this.getBaseListParamsSourceCode(entity),\n        this.getSubsetSourceCode(entity),\n      ].filter(nonNullable);\n    });\n    Naite.t(\"Template__generated:sourceCodes\", sourceCodes);\n\n    // Sort\n    const LABEL_KEY_ORDER = [\"Enums\", \"BaseSchema\", \"BaseListParams\", \"Subsets\", \"SubsetQueries\"];\n    sourceCodes.sort((a, b) => {\n      const [aKey] = a.label.split(\":\");\n      const [bKey] = b.label.split(\":\");\n      const aIndex = LABEL_KEY_ORDER.indexOf(aKey);\n      const bIndex = LABEL_KEY_ORDER.indexOf(bKey);\n      if (aIndex > bIndex) {\n        return 1;\n      } else if (aIndex < bIndex) {\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n\n    const sourceCode = sourceCodes.reduce(\n      (result, ts) => {\n        if (ts === null) {\n          return result;\n        }\n        return {\n          lines: [...result.lines, `// ${ts.label}`, ...ts.lines, \"\"],\n          importKeys: unique([...result.importKeys, ...ts.importKeys].sort()),\n        };\n      },\n      {\n        lines: [],\n        importKeys: [],\n      } as Omit<SourceCode, \"label\">,\n    );\n\n    // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 타입을 가져와 인라인 처리\n    const allTypeKeys = entities.flatMap((entity) => Object.keys(entity.types));\n    const cdImportKeys = sourceCode.importKeys.filter((importKey) =>\n      allTypeKeys.includes(importKey),\n    );\n    if (cdImportKeys.length > 0) {\n      const customScalarLines = cdImportKeys.flatMap((importKey) => {\n        const entity = entities.find((entity) => entity.types[importKey]);\n        if (!entity) {\n          throw new Error(`ZodType not found ${importKey}`);\n        }\n        const zodType = entity.types[importKey];\n        assert(zodType);\n\n        return [\n          `// CustomScalar: ${importKey}`,\n          `const ${importKey} = ${zodTypeToZodCode(zodType)};`,\n          `type ${importKey} = z.infer<typeof ${importKey}>`,\n          \"\",\n        ];\n      });\n      sourceCode.lines = [...customScalarLines, ...sourceCode.lines];\n      sourceCode.importKeys = sourceCode.importKeys.filter(\n        (importKey) => !cdImportKeys.includes(importKey),\n      );\n    }\n\n    const body = sourceCode.lines.join(\"\\n\");\n    Naite.t(\"Template__generated:body\", body);\n\n    // import\n    const sonamuImports = [\n      \"zArrayable\",\n      \"SQLDateTimeString\",\n      \"SubsetQuery\",\n      \"SonamuQueryMode\",\n    ].filter((mod) => body.includes(mod));\n\n    return {\n      ...this.getTargetAndPath(),\n      body,\n      importKeys: sourceCode.importKeys,\n      customHeaders: [\n        \"/** biome-ignore-all lint: generated는 무시 */\",\n        \"/** biome-ignore-all assist: generated는 무시 */\",\n        \"\",\n        `import { z } from 'zod';`,\n        `import { ${sonamuImports.join(\",\")} } from \"sonamu\";`,\n      ],\n    };\n  }\n\n  getEnumsSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.enumLabels).length === 0) {\n      return null;\n    }\n    return {\n      label: `Enums: ${entity.id}`,\n      lines: [\n        ...Object.entries(entity.enumLabels)\n          .filter(([_, enumLabel]) => Object.keys(enumLabel).length > 0)\n          .flatMap(([enumId, enumLabel]) => [\n            `export const ${enumId} = z.enum([${Object.keys(enumLabel).map(\n              (el) => `\"${el}\"`,\n            )}]).describe(\"${enumId}\");`,\n            `export type ${enumId} = z.infer<typeof ${enumId}>;`,\n            `export const ${enumId}Label = ${JSON.stringify(enumLabel)};`,\n          ]),\n      ],\n      importKeys: [],\n    };\n  }\n\n  getBaseSchemaSourceCode(entity: Entity, importKeys: string[] = []): SourceCode {\n    const schemaName = `${entity.names.module}BaseSchema`;\n    const propNode: EntityPropNode = {\n      nodeType: \"object\",\n      children: entity.props.map((prop) => {\n        return {\n          nodeType: \"plain\",\n          prop,\n        };\n      }),\n    };\n\n    const schemaBody = (() => {\n      const result = propNodeToZodTypeDef(propNode, importKeys);\n      if (result.endsWith(\",\")) {\n        return result.slice(0, -1);\n      }\n\n      return result;\n    })();\n\n    // fulltext index에 포함된 컬럼들 추출\n    // TODO: GIN/GiST 인덱스 생성된 컬럼 추출\n    const fulltextColumns: EntityIndex[\"columns\"][] = [];\n\n    // virtual props\n    const virtualProps = entity.props\n      .filter((prop) => isVirtualProp(prop))\n      .map((prop) => prop.name);\n\n    /**\n     * hasDefault props\n     * - nullable 또는 dbDefault가 있는 컬럼 (id 포함)\n     * - relation이 아니거나, relation이어도 nullable이면 포함\n     */\n    const hasDefaultColumns = entity.props\n      .filter(\n        (prop) =>\n          (prop.type !== \"relation\" || prop.nullable === true) &&\n          (prop.nullable === true || (prop.type !== \"relation\" && prop.dbDefault !== undefined)),\n      )\n      .map((prop) => (prop.type === \"relation\" ? `${prop.name}_id` : prop.name))\n      .concat(\"id\");\n\n    /**\n     * generated props\n     * - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)\n     */\n    const generatedColumns = entity.props\n      .filter((prop) => prop.type !== \"relation\" && prop.generated !== undefined)\n      .map((prop) => prop.name);\n\n    const hasMetadata =\n      fulltextColumns.length > 0 ||\n      virtualProps.length > 0 ||\n      hasDefaultColumns.length > 0 ||\n      generatedColumns.length > 0;\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody};`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>` +\n        (hasMetadata\n          ? ` & {${\n              (fulltextColumns.length > 0\n                ? `readonly __fulltext__: readonly [${fulltextColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (virtualProps.length > 0\n                ? `readonly __virtual__: readonly [${virtualProps.map((prop) => `\"${prop}\"`).join(\", \")}],`\n                : \"\") +\n              (\n                hasDefaultColumns.length > 0\n                  ? `readonly __hasDefault__: readonly [${hasDefaultColumns\n                      .map((col) => `\"${col}\"`)\n                      .join(\", \")}],`\n                  : \"\"\n              ) +\n              (generatedColumns.length > 0\n                ? `readonly __generated__: readonly [${generatedColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\")\n            }}`\n          : \"\") +\n        \";\",\n    ];\n\n    return {\n      label: `BaseSchema: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getBaseListParamsSourceCode(entity: Entity): SourceCode | null {\n    // Prop 없는 MD인 경우 생성 제외\n    if (entity.props.length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const schemaName = `${entity.names.module}BaseListParams`;\n\n    const filterProps = entity.props.filter((prop) => prop.toFilter === true);\n\n    const propNodes: EntityPropNode[] = filterProps.map((prop) => {\n      return {\n        nodeType: \"plain\" as const,\n        prop,\n        children: [],\n      };\n    });\n\n    const importKeys: string[] = [];\n    const filterBody = propNodes\n      .map((propNode) => propNodeToZodTypeDef(propNode, importKeys))\n      .join(\"\\n\");\n\n    const schemaBody = `\nz.object({\n  num: z.number().int().nonnegative(),\n  page: z.number().int().min(1),\n  search: ${entity.id}SearchField,\n  keyword: z.string(),\n  orderBy: ${entity.id}OrderBy,\n  queryMode: SonamuQueryMode,\n  id: zArrayable(z.number().int().positive()),${filterBody}\n}).partial();\n`.trim();\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody}`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n    ];\n\n    return {\n      label: `BaseListParams: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getSubsetSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.subsets).length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const subsetKeys = Object.keys(entity.subsets);\n    const importKeys: string[] = [];\n    const lines: string[] = [\n      ...subsetKeys.flatMap((subsetKey) => {\n        // 서브셋에서 FieldExpr[] 가져옴\n        const fieldExprs = entity.subsets[subsetKey];\n\n        // FieldExpr[]로 EntityPropNode[] 가져옴\n        const propNodes = entity.fieldExprsToPropNodes(fieldExprs);\n        const schemaName = `${entity.names.module}Subset${subsetKey}`;\n        const propNode: EntityPropNode = {\n          nodeType: \"object\",\n          children: propNodes,\n        };\n\n        // EntityPropNode[]로 ZodTypeDef(string)을 가져옴\n        const body = propNodeToZodTypeDef(propNode, importKeys);\n\n        return [\n          `export const ${schemaName} = ${body.replace(/,$/, \"\")};`,\n          `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n        ];\n      }),\n      `export type ${entity.names.module}SubsetMapping = {`,\n      ...subsetKeys.map((subsetKey) => `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`),\n      \"};\",\n      `export const ${entity.names.module}SubsetKey = z.enum([${subsetKeys\n        .map((k) => `\"${k}\"`)\n        .join(\",\")}]);`,\n      `export type ${entity.names.module}SubsetKey = z.infer<typeof ${entity.names.module}SubsetKey>;`,\n      \"\",\n    ];\n\n    return {\n      label: `Subsets: ${entity.id}`,\n      lines,\n      importKeys: unique(importKeys),\n    };\n  }\n}\n"],"names":["assert","unique","Sonamu","EntityManager","Naite","isVirtualProp","nonNullable","Template","propNodeToZodTypeDef","zodTypeToZodCode","Template__generated","getTargetAndPath","dir","config","api","target","path","render","entityIds","getAllIds","entities","map","id","get","sourceCodes","flatMap","entity","getEnumsSourceCode","getBaseSchemaSourceCode","getBaseListParamsSourceCode","getSubsetSourceCode","filter","t","LABEL_KEY_ORDER","sort","a","b","aKey","label","split","bKey","aIndex","indexOf","bIndex","sourceCode","reduce","result","ts","lines","importKeys","allTypeKeys","Object","keys","types","cdImportKeys","importKey","includes","length","customScalarLines","find","Error","zodType","body","join","sonamuImports","mod","customHeaders","enumLabels","entries","_","enumLabel","enumId","el","JSON","stringify","schemaName","names","module","propNode","nodeType","children","props","prop","schemaBody","endsWith","slice","fulltextColumns","virtualProps","name","hasDefaultColumns","type","nullable","dbDefault","undefined","concat","generatedColumns","generated","hasMetadata","col","parentId","filterProps","toFilter","propNodes","filterBody","trim","subsets","subsetKeys","subsetKey","fieldExprs","fieldExprsToPropNodes","replace","k"],"mappings":"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"}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../../../src/template/implementations/generated.template.ts"],"sourcesContent":["import assert from \"assert\";\nimport { unique } from \"radashi\";\nimport { Sonamu } from \"../../api\";\nimport type { Entity } from \"../../entity/entity\";\nimport { EntityManager } from \"../../entity/entity-manager\";\nimport { Naite } from \"../../naite/naite\";\nimport { type EntityIndex, type EntityPropNode, isVirtualProp } from \"../../types/types\";\nimport { nonNullable } from \"../../utils/utils\";\nimport { Template } from \"../template\";\nimport { propNodeToZodTypeDef, zodTypeToZodCode } from \"../zod-converter\";\n\nexport type SourceCode = {\n  label: string;\n  lines: string[];\n  importKeys: string[];\n};\nexport class Template__generated extends Template {\n  constructor() {\n    super(\"generated\");\n  }\n\n  getTargetAndPath() {\n    const { dir } = Sonamu.config.api;\n    return {\n      target: `${dir}/src/application`,\n      path: `sonamu.generated.ts`,\n    };\n  }\n  render() {\n    const entityIds = EntityManager.getAllIds();\n    const entities = entityIds.map((id) => EntityManager.get(id));\n\n    // 전체 SourceCode 생성\n    const sourceCodes = entities.flatMap((entity) => {\n      return [\n        this.getEnumsSourceCode(entity),\n        this.getBaseSchemaSourceCode(entity),\n        this.getBaseListParamsSourceCode(entity),\n        this.getSubsetSourceCode(entity),\n      ].filter(nonNullable);\n    });\n    Naite.t(\"Template__generated:sourceCodes\", sourceCodes);\n\n    // Sort\n    const LABEL_KEY_ORDER = [\"Enums\", \"BaseSchema\", \"BaseListParams\", \"Subsets\", \"SubsetQueries\"];\n    sourceCodes.sort((a, b) => {\n      const [aKey] = a.label.split(\":\");\n      const [bKey] = b.label.split(\":\");\n      const aIndex = LABEL_KEY_ORDER.indexOf(aKey);\n      const bIndex = LABEL_KEY_ORDER.indexOf(bKey);\n      if (aIndex > bIndex) {\n        return 1;\n      } else if (aIndex < bIndex) {\n        return -1;\n      } else {\n        return 0;\n      }\n    });\n\n    const sourceCode = sourceCodes.reduce(\n      (result, ts) => {\n        if (ts === null) {\n          return result;\n        }\n        return {\n          lines: [...result.lines, `// ${ts.label}`, ...ts.lines, \"\"],\n          importKeys: unique([...result.importKeys, ...ts.importKeys].sort()),\n        };\n      },\n      {\n        lines: [],\n        importKeys: [],\n      } as Omit<SourceCode, \"label\">,\n    );\n\n    // .types.ts의 타입을 참조하는 경우 순환참조(상호참조)가 발생하므로 타입을 가져와 인라인 처리\n    const allTypeKeys = entities.flatMap((entity) => Object.keys(entity.types));\n    const cdImportKeys = sourceCode.importKeys.filter((importKey) =>\n      allTypeKeys.includes(importKey),\n    );\n    if (cdImportKeys.length > 0) {\n      const customScalarLines = cdImportKeys.flatMap((importKey) => {\n        const entity = entities.find((entity) => entity.types[importKey]);\n        if (!entity) {\n          throw new Error(`ZodType not found ${importKey}`);\n        }\n        const zodType = entity.types[importKey];\n        assert(zodType);\n\n        return [\n          `// CustomScalar: ${importKey}`,\n          `const ${importKey} = ${zodTypeToZodCode(zodType)};`,\n          `type ${importKey} = z.infer<typeof ${importKey}>`,\n          \"\",\n        ];\n      });\n      sourceCode.lines = [...customScalarLines, ...sourceCode.lines];\n      sourceCode.importKeys = sourceCode.importKeys.filter(\n        (importKey) => !cdImportKeys.includes(importKey),\n      );\n    }\n\n    const body = sourceCode.lines.join(\"\\n\");\n    Naite.t(\"Template__generated:body\", body);\n\n    // import\n    const sonamuImports = [\n      \"zArrayable\",\n      \"SQLDateTimeString\",\n      \"SubsetQuery\",\n      \"SonamuQueryMode\",\n    ].filter((mod) => body.includes(mod));\n\n    return {\n      ...this.getTargetAndPath(),\n      body,\n      importKeys: sourceCode.importKeys,\n      customHeaders: [\n        \"/** biome-ignore-all lint: generated는 무시 */\",\n        \"/** biome-ignore-all assist: generated는 무시 */\",\n        \"\",\n        `import { z } from 'zod';`,\n        `import { ${sonamuImports.join(\",\")} } from \"sonamu\";`,\n      ],\n    };\n  }\n\n  getEnumsSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.enumLabels).length === 0) {\n      return null;\n    }\n    return {\n      label: `Enums: ${entity.id}`,\n      lines: [\n        ...Object.entries(entity.enumLabels)\n          .filter(([_, enumLabel]) => Object.keys(enumLabel).length > 0)\n          .flatMap(([enumId, enumLabel]) => [\n            `export const ${enumId} = z.enum([${Object.keys(enumLabel).map(\n              (el) => `\"${el}\"`,\n            )}]).describe(\"${enumId}\");`,\n            `export type ${enumId} = z.infer<typeof ${enumId}>;`,\n            `export const ${enumId}Label = ${JSON.stringify(enumLabel)};`,\n          ]),\n      ],\n      importKeys: [],\n    };\n  }\n\n  getBaseSchemaSourceCode(entity: Entity, importKeys: string[] = []): SourceCode {\n    const schemaName = `${entity.names.module}BaseSchema`;\n    const propNode: EntityPropNode = {\n      nodeType: \"object\",\n      children: entity.props.map((prop) => {\n        return {\n          nodeType: \"plain\",\n          prop,\n        };\n      }),\n    };\n\n    const schemaBody = (() => {\n      const result = propNodeToZodTypeDef(propNode, importKeys);\n      if (result.endsWith(\",\")) {\n        return result.slice(0, -1);\n      }\n\n      return result;\n    })();\n\n    // fulltext index에 포함된 컬럼들 추출\n    // TODO: GIN/GiST 인덱스 생성된 컬럼 추출\n    const fulltextColumns: EntityIndex[\"columns\"][] = [];\n\n    // virtual props\n    const virtualProps = entity.props\n      .filter((prop) => isVirtualProp(prop))\n      .map((prop) => prop.name);\n\n    /**\n     * hasDefault props\n     * - nullable 또는 dbDefault가 있는 컬럼 (id 포함)\n     * - relation이 아니거나, relation이어도 nullable이면 포함\n     */\n    const hasDefaultColumns = entity.props\n      .filter(\n        (prop) =>\n          (prop.type !== \"relation\" || prop.nullable === true) &&\n          (prop.nullable === true || (prop.type !== \"relation\" && prop.dbDefault !== undefined)),\n      )\n      .map((prop) => (prop.type === \"relation\" ? `${prop.name}_id` : prop.name))\n      .concat(\"id\");\n\n    /**\n     * hasVector props\n     * - vector 타입인 컬럼\n     */\n    const hasVectorColumns = entity.props\n      .filter((prop) => prop.type === \"vector\" || prop.type === \"vector[]\")\n      .map((prop) => prop.name);\n\n    /**\n     * generated props\n     * - generated 속성이 있는 컬럼 (INSERT/UPDATE 시 값 제공 불가)\n     */\n    const generatedColumns = entity.props\n      .filter((prop) => prop.type !== \"relation\" && prop.generated !== undefined)\n      .map((prop) => prop.name);\n\n    const hasMetadata =\n      fulltextColumns.length > 0 ||\n      virtualProps.length > 0 ||\n      hasDefaultColumns.length > 0 ||\n      generatedColumns.length > 0 ||\n      hasVectorColumns.length > 0;\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody};`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>` +\n        (hasMetadata\n          ? ` & {${\n              (fulltextColumns.length > 0\n                ? `readonly __fulltext__: readonly [${fulltextColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (virtualProps.length > 0\n                ? `readonly __virtual__: readonly [${virtualProps.map((prop) => `\"${prop}\"`).join(\", \")}],`\n                : \"\") +\n              (hasDefaultColumns.length > 0\n                ? `readonly __hasDefault__: readonly [${hasDefaultColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\") +\n              (\n                generatedColumns.length > 0\n                  ? `readonly __generated__: readonly [${generatedColumns\n                      .map((col) => `\"${col}\"`)\n                      .join(\", \")}],`\n                  : \"\"\n              ) +\n              (hasVectorColumns.length > 0\n                ? `readonly __vector__: readonly [${hasVectorColumns\n                    .map((col) => `\"${col}\"`)\n                    .join(\", \")}],`\n                : \"\")\n            }}`\n          : \"\") +\n        \";\",\n    ];\n\n    return {\n      label: `BaseSchema: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getBaseListParamsSourceCode(entity: Entity): SourceCode | null {\n    // Prop 없는 MD인 경우 생성 제외\n    if (entity.props.length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const schemaName = `${entity.names.module}BaseListParams`;\n\n    const filterProps = entity.props.filter((prop) => prop.toFilter === true);\n\n    const propNodes: EntityPropNode[] = filterProps.map((prop) => {\n      return {\n        nodeType: \"plain\" as const,\n        prop,\n        children: [],\n      };\n    });\n\n    const importKeys: string[] = [];\n    const filterBody = propNodes\n      .map((propNode) => propNodeToZodTypeDef(propNode, importKeys))\n      .join(\"\\n\");\n    const schemaBody = `\nz.object({\n  num: z.number().int().nonnegative(),\n  page: z.number().int().min(1),\n  search: ${entity.id}SearchField,\n  keyword: z.string(),\n  orderBy: ${entity.id}OrderBy,\n  queryMode: SonamuQueryMode,\n  id: zArrayable(z.number().int().positive()),${filterBody}\n}).partial();\n`.trim();\n\n    const lines = [\n      `export const ${schemaName} = ${schemaBody}`,\n      `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n    ];\n\n    return {\n      label: `BaseListParams: ${entity.id}`,\n      importKeys,\n      lines,\n    };\n  }\n\n  getSubsetSourceCode(entity: Entity): SourceCode | null {\n    if (Object.keys(entity.subsets).length === 0) {\n      return null;\n    } else if (entity.parentId !== undefined) {\n      return null;\n    }\n\n    const subsetKeys = Object.keys(entity.subsets);\n    const importKeys: string[] = [];\n    const lines: string[] = [\n      ...subsetKeys.flatMap((subsetKey) => {\n        // 서브셋에서 FieldExpr[] 가져옴\n        const fieldExprs = entity.subsets[subsetKey];\n\n        // FieldExpr[]로 EntityPropNode[] 가져옴\n        const propNodes = entity.fieldExprsToPropNodes(fieldExprs);\n        const schemaName = `${entity.names.module}Subset${subsetKey}`;\n        const propNode: EntityPropNode = {\n          nodeType: \"object\",\n          children: propNodes,\n        };\n\n        // EntityPropNode[]로 ZodTypeDef(string)을 가져옴\n        const body = propNodeToZodTypeDef(propNode, importKeys);\n\n        return [\n          `export const ${schemaName} = ${body.replace(/,$/, \"\")};`,\n          `export type ${schemaName} = z.infer<typeof ${schemaName}>;`,\n        ];\n      }),\n      `export type ${entity.names.module}SubsetMapping = {`,\n      ...subsetKeys.map((subsetKey) => `  ${subsetKey}: ${entity.names.module}Subset${subsetKey};`),\n      \"};\",\n      `export const ${entity.names.module}SubsetKey = z.enum([${subsetKeys\n        .map((k) => `\"${k}\"`)\n        .join(\",\")}]);`,\n      `export type ${entity.names.module}SubsetKey = z.infer<typeof ${entity.names.module}SubsetKey>;`,\n      \"\",\n    ];\n\n    return {\n      label: `Subsets: ${entity.id}`,\n      lines,\n      importKeys: unique(importKeys),\n    };\n  }\n}\n"],"names":["assert","unique","Sonamu","EntityManager","Naite","isVirtualProp","nonNullable","Template","propNodeToZodTypeDef","zodTypeToZodCode","Template__generated","getTargetAndPath","dir","config","api","target","path","render","entityIds","getAllIds","entities","map","id","get","sourceCodes","flatMap","entity","getEnumsSourceCode","getBaseSchemaSourceCode","getBaseListParamsSourceCode","getSubsetSourceCode","filter","t","LABEL_KEY_ORDER","sort","a","b","aKey","label","split","bKey","aIndex","indexOf","bIndex","sourceCode","reduce","result","ts","lines","importKeys","allTypeKeys","Object","keys","types","cdImportKeys","importKey","includes","length","customScalarLines","find","Error","zodType","body","join","sonamuImports","mod","customHeaders","enumLabels","entries","_","enumLabel","enumId","el","JSON","stringify","schemaName","names","module","propNode","nodeType","children","props","prop","schemaBody","endsWith","slice","fulltextColumns","virtualProps","name","hasDefaultColumns","type","nullable","dbDefault","undefined","concat","hasVectorColumns","generatedColumns","generated","hasMetadata","col","parentId","filterProps","toFilter","propNodes","filterBody","trim","subsets","subsetKeys","subsetKey","fieldExprs","fieldExprsToPropNodes","replace","k"],"mappings":"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"}