target-supabase-sdk 0.2.0 → 0.2.2

package/src/task/index.ts

@@ -3,46 +3,43 @@
  * Internal modules (local-task-registry, task-repo-context, task.utils) stay private.
  */
 
-// task.interface
-export {
-	CategoryTask,
-	ResultCode,
-	TaskStatus,
-	TaskStatusAction,
-} from "./task.interface";
-export type { Task, TaskDetails, TaskFlow } from "./task.interface";
-
+export type {
+    PatchChangeTaskStatusPayload,
+    PatchClaimTaskPayload,
+    PatchTaskProgressPayload,
+} from "./task.api";
 // task.api
 export {
-	patchChangeTaskStatus,
-	patchChangeTaskStatusSchema,
-	patchClaimTask,
-	patchClaimTaskSchema,
-	patchTaskProgress,
-	patchTaskProgressSchema,
+    patchChangeTaskStatus,
+    patchChangeTaskStatusSchema,
+    patchClaimTask,
+    patchClaimTaskSchema,
+    patchTaskProgress,
+    patchTaskProgressSchema,
 } from "./task.api";
+export type { Task, TaskDetails, TaskFlow } from "./task.interface";
+// task.interface
+export {
+    CategoryTask,
+    ResultCode,
+    TaskStatus,
+    TaskStatusAction,
+} from "./task.interface";
 export type {
-	PatchChangeTaskStatusPayload,
-	PatchClaimTaskPayload,
-	PatchTaskProgressPayload,
-} from "./task.api";
-export { postTask, postTaskSchema } from "./task-post.api";
-export type { PostTaskPayload } from "./task-post.api";
-
+    PrepareTaskParams,
+    PrepareTaskResponse,
+    RegisterTasksOptions,
+    RegisterTasksResult,
+} from "./task-manager";
 // task-manager
 export { TaskManager } from "./task-manager";
+export type { PostTaskPayload } from "./task-post.api";
+export { postTask, postTaskSchema } from "./task-post.api";
+export { postTaskWithValidation } from "./task-post-validated.api";
 export type {
-	PrepareTaskFailureReason,
-	PrepareTaskParams,
-	PrepareTaskResponse,
-	RegisterTasksOptions,
-	RegisterTasksResult,
-} from "./task-manager";
-
+    TaskRepoValidationFailureReason,
+    ValidateTaskRepoAndParamsInput,
+    ValidateTaskRepoAndParamsResult,
+} from "./task-repo-validation";
 // task-repo-validation
 export { TaskRepoValidation } from "./task-repo-validation";
-export type {
-	TaskRepoValidationFailureReason,
-	ValidateTaskRepoAndParamsInput,
-	ValidateTaskRepoAndParamsResult,
-} from "./task-repo-validation";

package/src/task/local-task-registry.ts

@@ -10,12 +10,12 @@ import {
     resolvePathFromConfigFile,
 } from "../shared/utils/config-path.utils";
 import {
-    BootstrapLocalTasksResult,
+    type BootstrapLocalTasksResult,
     TASK_LOCAL_PACKAGE_CONFIG_FILENAME,
     TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH,
     TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH,
-    TaskLocalPackageConfig,
-    TaskRunnerRootConfig,
+    type TaskLocalPackageConfig,
+    type TaskRunnerRootConfig,
 } from "./task-repo-context";
 
 export interface BootstrapLocalTasksOptions {
@@ -77,7 +77,7 @@ function parseTaskPackageConfig(raw: unknown, configPath: string): TaskLocalPack
         entry: entry.trim(),
         exportName: typeof record.exportName === "string" ? record.exportName : undefined,
         displayName: typeof record.displayName === "string" ? record.displayName : undefined,
-        enabled: record.enabled === false ? false : true,
+        enabled: record.enabled !== false,
     };
 }
 
@@ -114,7 +114,7 @@ async function computeConfigFingerprint(rootConfigPath: string, tasksRoot: strin
 
 function canUseCachedBootstrap(
     fingerprint: string,
-    forTaskTypeKey: string | undefined
+    forTaskTypeKey: string | undefined,
 ): BootstrapLocalTasksResult | null {
     if (bootstrapCache.fingerprint !== fingerprint || bootstrapCache.lastResult == null) {
         return null;
@@ -129,17 +129,12 @@ function canUseCachedBootstrap(
     return { ...bootstrapCache.lastResult, cached: true };
 }
 
-async function runBootstrapScan(
-    options: BootstrapLocalTasksOptions
-): Promise<BootstrapLocalTasksResult> {
+async function runBootstrapScan(options: BootstrapLocalTasksOptions): Promise<BootstrapLocalTasksResult> {
     const cwd = options.cwd ?? process.cwd();
 
     const rootConfigPath = await resolveFirstExistingPath(cwd, {
         explicitPath: options.rootConfigPath,
-        candidatePaths: [
-            TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH,
-            TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH,
-        ],
+        candidatePaths: [TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH, TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH],
     });
     if (rootConfigPath == null) {
         const result: BootstrapLocalTasksResult = {
@@ -218,10 +213,7 @@ async function runBootstrapScan(
         const status = finalizeStatus(result);
         const finalResult: BootstrapLocalTasksResult = {
             status,
-            message:
-                status === "empty"
-                    ? `Root config loaded but no tasks registered under ${tasksRoot}`
-                    : undefined,
+            message: status === "empty" ? `Root config loaded but no tasks registered under ${tasksRoot}` : undefined,
             ...result,
         };
         bootstrapCache = { fingerprint, lastResult: finalResult };
@@ -257,7 +249,7 @@ async function runBootstrapScan(
  * Legacy fallback: `./task.config.js` at project root (`taskDir: "./tasks"`).
  */
 export async function bootstrapLocalTasks(
-    options: BootstrapLocalTasksOptions = {}
+    options: BootstrapLocalTasksOptions = {},
 ): Promise<BootstrapLocalTasksResult> {
     if (bootstrapInFlight != null) {
         return bootstrapInFlight;

package/src/task/task-manager.ts

@@ -1,41 +1,40 @@
 import { getScanRemoteRepoValues } from "../repo/repo.api";
 import { TASK_REPO_USAGE } from "../repo/repo.interface";
-import { LoggerWithScope } from "../shared/log";
-import { ResultCode, Task } from "./task.interface";
-import { TaskFn, TaskRunResult, ExecutableTaskFn } from "./task-repo-context";
+import type { LoggerWithScope } from "../shared/log";
+import type { ResultCode, Task } from "./task.interface";
+import type { ExecutableTaskFn, TaskFn } from "./task-repo-context";
 
 export type {
+    BootstrapLocalTasksResult,
+    BootstrapLocalTasksStatus,
+    ExecutableTaskFn,
     TaskFn,
+    TaskLocalPackageConfig,
     TaskRepoContext,
-    TaskRunResult,
-    ExecutableTaskFn,
     TaskRepoScriptDetails,
     TaskRepoScriptRecord,
     TaskRunnerRootConfig,
-    TaskLocalPackageConfig,
-    BootstrapLocalTasksResult,
-    BootstrapLocalTasksStatus,
+    TaskRunResult,
 } from "./task-repo-context";
 export {
+    TASK_LOCAL_PACKAGE_CONFIG_FILENAME,
     TASK_REPO_SCRIPT_CATEGORY,
     TASK_RUNNER_CONFIG_DIR,
     TASK_RUNNER_ROOT_CONFIG_FILENAME,
-    TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH,
     TASK_RUNNER_ROOT_CONFIG_LEGACY_RELATIVE_PATH,
-    TASK_LOCAL_PACKAGE_CONFIG_FILENAME,
+    TASK_RUNNER_ROOT_CONFIG_RELATIVE_PATH,
 } from "./task-repo-context";
+
 import {
+    type BootstrapLocalTasksOptions,
     bootstrapLocalTasks,
-    BootstrapLocalTasksOptions,
     clearBootstrapLocalTasksCache,
     getRegisteredLocalTaskTypeKeys,
 } from "./local-task-registry";
+import { LOG_TOPIC_TASK } from "./task.constant";
 import type { BootstrapLocalTasksResult } from "./task-repo-context";
 import { TaskRepoValidation, type TaskRepoValidationFailureReason } from "./task-repo-validation";
 
-/** @deprecated use {@link TaskRepoValidationFailureReason} */
-export type PrepareTaskFailureReason = TaskRepoValidationFailureReason;
-
 export type {
     TaskRepoValidationFailureReason,
     ValidateTaskRepoAndParamsInput,
@@ -48,7 +47,7 @@ export interface PrepareTaskResponse {
     taskFn: ExecutableTaskFn | null;
     code?: ResultCode;
     message?: string;
-    reason?: PrepareTaskFailureReason;
+    reason?: TaskRepoValidationFailureReason;
     /** Pipeline step for log aggregation */
     step?: string;
 }
@@ -82,25 +81,25 @@ function logLocalBootstrap(logger: LoggerWithScope, bootstrap: BootstrapLocalTas
     switch (bootstrap.status) {
         case "not_configured":
             logger.info("未找到本地任務配置，跳過本地註冊", {
-                topic: "task",
+                topic: LOG_TOPIC_TASK,
                 data: { message: bootstrap.message },
             });
             break;
         case "failed":
             logger.warn("本地任務註冊失敗", {
-                topic: "task",
+                topic: LOG_TOPIC_TASK,
                 data: { message: bootstrap.message, errors: bootstrap.errors },
             });
             break;
         case "empty":
             logger.info("本地任務掃描完成，無已註冊任務", {
-                topic: "task",
+                topic: LOG_TOPIC_TASK,
                 data: { message: bootstrap.message, skipped: bootstrap.skipped },
             });
             break;
         case "loaded":
             logger.info("本地任務註冊完成", {
-                topic: "task",
+                topic: LOG_TOPIC_TASK,
                 data: {
                     registered: bootstrap.registered,
                     skipped: bootstrap.skipped,
@@ -125,15 +124,15 @@ async function registerTasks({
     local: localOptions,
     includeRemote = true,
 }: RegisterTasksOptions): Promise<RegisterTasksResult> {
-    logger.info("開始註冊任務（本地 + 遠程）", { topic: "task" });
+    logger.debug("開始註冊任務（本地 + 遠程）", { topic: LOG_TOPIC_TASK });
 
     const local = await bootstrapLocalTasks(localOptions ?? {});
     logLocalBootstrap(logger, local);
 
     let remoteValues: string[] = [];
     if (includeRemote) {
-        logger.info("查詢遠程 Repo 列表", {
-            topic: "task",
+        logger.debug("查詢遠程 Repo 列表", {
+            topic: LOG_TOPIC_TASK,
             data: { usage: TASK_REPO_USAGE },
         });
         const { data, error: remoteError } = await getScanRemoteRepoValues({ usage: TASK_REPO_USAGE });
@@ -141,19 +140,19 @@ async function registerTasks({
             throw new Error(remoteError.message);
         }
         remoteValues = data ?? [];
-        logger.info("遠程 Repo 查詢完成", {
-            topic: "task",
+        logger.debug("遠程 Repo 查詢完成", {
+            topic: LOG_TOPIC_TASK,
             data: { count: remoteValues.length, values: remoteValues },
         });
     }
 
     const availableTaskList = [...new Set([...local.registered, ...remoteValues])];
     if (availableTaskList.length === 0) {
-        throw new Error("[registerTasks] 任務註冊失敗：本地與遠程均無可用任務類型");
+        throw new Error("任務註冊失敗：本地與遠程均無可用任務類型");
     }
 
     logger.success("任務註冊完成", {
-        topic: "task",
+        topic: LOG_TOPIC_TASK,
         data: {
             availableTaskList,
             localRegistered: local.registered,
@@ -196,13 +195,13 @@ const prepareTask = async ({
     bootstrapLocalOptions,
 }: PrepareTaskParams): Promise<PrepareTaskResponse> => {
     const fail = (params: {
-        reason: PrepareTaskFailureReason;
+        reason: TaskRepoValidationFailureReason;
         code: ResultCode;
         message: string;
         step: string;
     }): PrepareTaskResponse => {
         logger.warn(params.message, {
-            topic: "task",
+            topic: LOG_TOPIC_TASK,
             data: {
                 taskId: task.id,
                 taskTypeKey: task.value,
@@ -221,8 +220,8 @@ const prepareTask = async ({
     };
 
     const { id: taskId, name: taskName, value: taskTypeKey, details } = task;
-    logger.info(`開始準備任務 ${taskName}-${taskTypeKey}`, {
-        topic: "task",
+    logger.debug(`開始準備任務 ${taskName}-${taskTypeKey}`, {
+        topic: LOG_TOPIC_TASK,
         data: { taskId, taskName, taskTypeKey },
     });
 
@@ -234,7 +233,7 @@ const prepareTask = async ({
             forTaskTypeKey: taskTypeKey,
         });
         logger.debug("本地 registry 未命中，補掃本地任務", {
-            topic: "task",
+            topic: LOG_TOPIC_TASK,
             data: {
                 taskId,
                 taskTypeKey,
@@ -264,8 +263,8 @@ const prepareTask = async ({
 
     const { repoContext } = validation;
 
-    logger.info("Repo 上下文加載成功", {
-        topic: "task",
+    logger.debug("Repo 上下文加載成功", {
+        topic: LOG_TOPIC_TASK,
         data: {
             taskTypeKey,
             taskFnDisplayName: repoContext.taskFn.displayName,
@@ -274,8 +273,8 @@ const prepareTask = async ({
     });
 
     const boundTaskFn = bindTaskFn(repoContext.taskFn, taskParams);
-    logger.success("任務準備完成", {
-        topic: "task",
+    logger.debug("任務準備完成", {
+        topic: LOG_TOPIC_TASK,
         data: {
             taskId,
             taskTypeKey,

package/src/{node → task}/task-node.ts

@@ -1,15 +1,11 @@
-import {
-    logManager,
-    withModule,
-    type LoggerWithScope,
-} from "../shared/log";
-import { scopeForNodeLoop } from "./node-log-scope";
+import { isOptimisticLockResponse } from "../core.api";
+import { BaseNodeRuntime, LOG_TOPIC_NODE, type NodeLoopContext } from "../node/node-runtime.base";
+import { createLogger, createScope, type LoggerWithScope, withModule } from "../shared/log";
 import { getErrorMessage, toError } from "../shared/utils/error.utils";
-import { TaskManager, type TaskRunResult } from "../task/task-manager";
-import { patchChangeTaskStatus, patchClaimTask } from "../task/task.api";
-import { TaskStatusAction } from "../task/task.interface";
-import { NodeLoopContext } from "./node.interface";
-import { BaseNodeRuntime } from "./node-runtime.base";
+import { patchChangeTaskStatus, patchClaimTask } from "./task.api";
+import { CRITICAL_UNKNOWN_TASK_TRACE_ID, LOG_TOPIC_TASK } from "./task.constant";
+import { TaskStatusAction } from "./task.interface";
+import { TaskManager, type TaskRunResult } from "./task-manager";
 
 /**
  * Task worker node: commands → heartbeat → claim & execute tasks.
@@ -28,39 +24,39 @@ class TaskNode extends BaseNodeRuntime {
     }
 
     protected async onBeforeRegisterNode(logger: LoggerWithScope): Promise<void> {
-        logger.info("開始註冊任務", { topic: "node" });
         const { availableTaskList, includeRemote } = await TaskManager.registerTasks({ logger });
         this._availableTaskList = availableTaskList;
         this._includeRemote = includeRemote;
     }
 
     protected async runLoopSteps(ctx: NodeLoopContext, heartbeatOk: boolean): Promise<void> {
-        const loopScope = scopeForNodeLoop({
-            module: `${this.runtimeModule}-loop-iteration`,
-            traceId: ctx.loopTraceId,
-            nodeId: ctx.nodeId,
-        });
         if (!heartbeatOk) {
-            const { logger } = logManager.withScope(loopScope);
-            logger.warn("心跳失敗，本輪跳過任務認領", { topic: "node" });
+            const logger = createLogger({
+                scope: createScope({
+                    module: `${this.runtimeModule}-runLoopSteps`,
+                    traceId: ctx.loopTraceId,
+                    labels: { nodeId: ctx.nodeId },
+                }),
+            });
+            logger.warn("心跳失敗，本輪跳過任務認領", { topic: LOG_TOPIC_NODE });
             return;
         }
         await this.runAsWorker(ctx);
     }
 
-    async runAsWorker(ctx: NodeLoopContext) {
+    private async runAsWorker(ctx: NodeLoopContext): Promise<void> {
         const { loopTraceId, nodeId } = ctx;
-        const loopScope = scopeForNodeLoop({ module: "runAsWorker", traceId: loopTraceId, nodeId });
-        const { logger } = logManager.withScope(loopScope);
+        const loopScope = createScope({ module: "runAsWorker", traceId: loopTraceId, labels: { nodeId } });
+        const logger = createLogger({ scope: loopScope });
 
         const availableTaskList = this.availableTaskList;
         if (availableTaskList.length === 0) {
-            logger.warn("未配置可認領任務類型，跳過本輪", { topic: "task" });
+            logger.warn("未配置可認領任務類型，跳過本輪", { topic: LOG_TOPIC_TASK });
             return;
         }
 
-        logger.info("向 Supabase 認領任務", {
-            topic: "task",
+        logger.debug("向 Supabase 認領任務", {
+            topic: LOG_TOPIC_TASK,
             data: { availableTaskList },
         });
         const { data: task, error: claimError } = await patchClaimTask({
@@ -69,25 +65,41 @@ class TaskNode extends BaseNodeRuntime {
             traceId: loopTraceId,
         });
         if (claimError) {
-            logger.error("認領任務 API 失敗", {
-                topic: "task",
+            if (isOptimisticLockResponse(claimError)) {
+                logger.debug("認領競爭失敗，本輪無可認領任務", {
+                    topic: LOG_TOPIC_TASK,
+                    data: { availableTaskList },
+                });
+                return;
+            }
+            logger.error("認領任務失敗", {
+                topic: LOG_TOPIC_TASK,
                 data: {
                     availableTaskList,
                     error: claimError.message,
+                    code: claimError.code,
                 },
             });
             return;
         }
         if (task == null) {
-            logger.info("本輪無匹配的 TODO 任務", {
-                topic: "task",
+            logger.debug("本輪無匹配的 TODO 任務", {
+                topic: LOG_TOPIC_TASK,
                 data: { availableTaskList },
             });
             return;
         }
 
-        logger.info("認領任務成功，準備執行", {
-            topic: "task",
+        const taskTraceId = task.details.traceId ?? CRITICAL_UNKNOWN_TASK_TRACE_ID;
+        const taskScope = createScope({
+            module: "runAsWorker",
+            traceId: loopTraceId,
+            labels: { nodeId },
+            traceParentId: taskTraceId,
+        });
+        const taskLogger = createLogger({ scope: taskScope });
+        taskLogger.success("認領任務成功，準備執行", {
+            topic: LOG_TOPIC_TASK,
             data: {
                 taskId: task.id,
                 taskName: task.name,
@@ -96,14 +108,7 @@ class TaskNode extends BaseNodeRuntime {
             },
         });
 
-        const taskTraceId = task.details.traceId ?? loopTraceId;
-        const taskScope = scopeForNodeLoop({
-            module: "prepareTask",
-            traceId: taskTraceId,
-            nodeId,
-            traceParentId: loopTraceId,
-        });
-        const { logger: prepareLogger } = logManager.withScope(taskScope);
+        const prepareLogger = createLogger({ scope: withModule(taskScope, "prepareTask") });
         const prepareResult = await TaskManager.prepareTask({
             logger: prepareLogger,
             task,
@@ -112,7 +117,7 @@ class TaskNode extends BaseNodeRuntime {
         const { isSuccess: isPrepareSuccess, taskFn, code, message, reason, step } = prepareResult;
         if (!isPrepareSuccess || taskFn == null) {
             prepareLogger.critical("任務準備失敗，無法繼續執行，中止任務並 RESET 為 OPEN", {
-                topic: "task",
+                topic: LOG_TOPIC_TASK,
                 data: {
                     taskId: task.id,
                     taskTypeKey: task.value,
@@ -130,15 +135,25 @@ class TaskNode extends BaseNodeRuntime {
             });
             return;
         }
+        logger.success("任務準備完成", {
+            topic: LOG_TOPIC_TASK,
+            data: {
+                taskId: task.id,
+                taskName: task.name,
+                taskTypeKey: task.value,
+                displayName: taskFn.displayName,
+            },
+        });
 
-        const { logger: executeLogger } = logManager.withScope(withModule(taskScope, "executeTask"));
+        const executeLogger = createLogger({ scope: withModule(taskScope, "executeTask") });
         const onExecuteAbort = async (error?: Error) => {
-            logger.critical("任務執行遇到未知錯誤，中止任務並 RESET 為 OPEN", {
-                topic: "task",
+            executeLogger.critical("任務執行遇到未知錯誤，中止任務並 RESET 為 OPEN", {
+                topic: LOG_TOPIC_TASK,
                 data: {
                     taskId: task.id,
-                    taskName: task.name,
                     taskTypeKey: task.value,
+                    taskName: task.name,
+                    displayName: taskFn.displayName,
                     error: getErrorMessage(error),
                 },
             });
@@ -151,7 +166,7 @@ class TaskNode extends BaseNodeRuntime {
         };
 
         executeLogger.info("開始執行業務邏輯", {
-            topic: "task",
+            topic: LOG_TOPIC_TASK,
             data: { taskId: task.id, displayName: taskFn.displayName },
         });
         const startTime = Date.now();
@@ -167,10 +182,6 @@ class TaskNode extends BaseNodeRuntime {
             return;
         }
 
-        executeLogger.info("任務執行完成", {
-            topic: "task",
-            data: { taskId: task.id, displayName: taskFn.displayName },
-        });
         const { isSuccess: isTaskSuccess, cost, extra } = result ?? { isSuccess: false, cost: 0, extra: null };
         if (isTaskSuccess) {
             await this.finalizeTaskRun("success", {
@@ -194,9 +205,15 @@ class TaskNode extends BaseNodeRuntime {
             });
         }
         const duration = Date.now() - startTime;
-        executeLogger.info("業務邏輯執行完成", {
-            topic: "task",
-            data: { taskId: task.id, durationMs: duration },
+        executeLogger.info("業務邏輯執行結束", {
+            topic: LOG_TOPIC_TASK,
+            data: {
+                taskId: task.id,
+                taskName: task.name,
+                taskTypeKey: task.value,
+                displayName: taskFn.displayName,
+                durationMs: duration,
+            },
         });
     }
 
@@ -220,10 +237,10 @@ class TaskNode extends BaseNodeRuntime {
         });
 
         if (error) {
-            logger.error(error.message, { topic: "task", data: logData });
+            logger.error(error.message, { topic: LOG_TOPIC_TASK, data: logData });
             return false;
         }
-        logger.info("任務已中止並 RESET 為 OPEN", { topic: "task", data: logData });
+        logger.info("任務已中止並 RESET 為 OPEN", { topic: LOG_TOPIC_TASK, data: logData });
         return true;
     }
 
@@ -235,9 +252,9 @@ class TaskNode extends BaseNodeRuntime {
             taskTypeKey: string;
             nodeId: string;
             cost: TaskRunResult["cost"];
-            extra: TaskRunResult["extr\a"];
+            extra: TaskRunResult["extra"];
             traceId: string;
-        }
+        },
     ): Promise<void> {
         const { logger, taskId, nodeId, taskTypeKey, cost, extra, traceId } = params;
         const outcomePrefix = outcome === "success" ? "任務成功" : "任務失敗";
@@ -252,31 +269,32 @@ class TaskNode extends BaseNodeRuntime {
         const { error: changeTaskStatusError } =
             outcome === "success"
                 ? await patchChangeTaskStatus({
-                    id: taskId,
-                    action: TaskStatusAction.FINISH,
-                    nodeId,
-                    cost,
-                    extra: extraValue,
-                    traceId,
-                })
+                      id: taskId,
+                      action: TaskStatusAction.FINISH,
+                      nodeId,
+                      cost,
+                      extra: extraValue,
+                      traceId,
+                  })
                 : await patchChangeTaskStatus({
-                    id: taskId,
-                    action: TaskStatusAction.RESET,
-                    nodeId,
-                    extra: extraValue,
-                    traceId,
-                });
+                      id: taskId,
+                      action: TaskStatusAction.RESET,
+                      nodeId,
+                      extra: extraValue,
+                      traceId,
+                  });
 
         if (changeTaskStatusError) {
             const upperMessage = `${outcomePrefix}但是更新 TaskStatus 失敗，產生孤兒 Task，請儘快排查問題`;
-            logger.critical(upperMessage, { topic: "task", data: logData });
+            logger.critical(upperMessage, { topic: LOG_TOPIC_TASK, data: logData });
+            // TODO: 需要處理孤兒 Task
             throw new Error(upperMessage);
         }
-        logger.info("更新 TaskStatus 成功", { topic: "task", data: logData });
+        logger.info("更新 TaskStatus 成功", { topic: LOG_TOPIC_TASK, data: logData });
         if (outcome === "success") {
-            logger.success("任務執行結束，業務邏輯成功", { topic: "task", data: logData });
+            logger.success("任務執行結束，業務邏輯成功", { topic: LOG_TOPIC_TASK, data: logData });
         } else {
-            logger.warn("任務執行結束，業務邏輯失敗", { topic: "task", data: logData });
+            logger.warn("任務執行結束，業務邏輯失敗", { topic: LOG_TOPIC_TASK, data: logData });
         }
     }
 }