target-supabase-sdk 0.1.8 → 0.2.0

package/src/task/task.api.ts

@@ -0,0 +1,369 @@
+import { createTarget, getPossibleTarget, QueryFilter, updateTargetDetails, validateWithSchema, isOptimisticLockError, OPTIMISTIC_LOCK_FAILED_MESSAGE } from "../core.api";
+import { generateResponse, type SupabaseResponse } from "../core.interface";
+import { createApiLogger, logManager, type LoggerWithScope } from "../shared/log";
+import { z } from "zod";
+import { CategoryTask, ResultCode, Task, TaskDetails, TaskStatus, TaskStatusAction } from "./task.interface";
+
+const TASK_STATUS_FIELD = "details->>status" as const;
+const TASK_NODE_ID_FIELD = "details->>nodeId" as const;
+
+// ─── State machine ───────────────────────────────────────────────────────────
+
+/**
+ * Task state machine (field: `details.status`)
+ *
+ * ```text
+ *   publish          claim (CLAIM / patchClaimTask)     finish
+ * OPEN ──────► TODO ──────────────────► DOING ─────────────► DONE
+ *   │                │ reset                  │ cancel           │ close
+ *   │                │                        └──────► TODO      │
+ *   └──────── reset ─┴──────────────────────── reset ────────────┘
+ *   |                                                            │
+ *   └──────────────────── close ─────────────────────────────────┘
+ *                                                               ▼
+ *                                                            CLOSED
+ * ```
+ *
+ * | TaskStatusAction | from              | to     | lock filters                   | caller        |
+ * |------------------|-------------------|--------|--------------------------------|---------------|
+ * | PUBLISH          | OPEN              | TODO   | status = OPEN                  | scheduler     |
+ * | CLAIM            | TODO              | DOING  | status = TODO                  | worker        |
+ * | RESET            | TODO              | OPEN   | status = TODO (no nodeId)      | admin         |
+ * | RESET            | DOING, DONE       | OPEN   | status ∈ {DOING,DONE} + nodeId | worker        |
+ * | CANCEL           | DOING             | TODO   | DOING + nodeId                 | worker        |
+ * | FINISH           | DOING             | DONE   | DOING + nodeId                 | worker        |
+ * | CLOSE            | OPEN, DONE        | CLOSED | status ∈ {OPEN, DONE}          | scheduler     |
+ *
+ * RESET: omit `nodeId` to reset from **TODO**; pass `nodeId` to reset from **DOING** or **DONE**.
+ *
+ * All public APIs validate input with Zod (`validateWithSchema`). Optimistic locks live in
+ * `optimisticLockFilterList` on UPDATE — see `.cursor/skills/optimistic-lock-update/SKILL.md`.
+ */
+
+// ─── Zod schemas ─────────────────────────────────────────────────────────────
+
+const taskIdSchema = z.string().trim().min(1);
+const nodeIdSchema = z.string().trim().min(1);
+/** Optional — orchestrator (e.g. TaskNode loop) passes its trace to correlate logs. */
+const traceIdSchema = z.string().trim().min(1).optional();
+const traceParentIdSchema = z.string().trim().min(1).nullable().optional();
+
+const patchChangeTaskStatusBaseSchema = {
+    id: taskIdSchema,
+    extra: z.string().optional(),
+    traceId: traceIdSchema,
+};
+
+/** Shared by CLAIM / CANCEL / FINISH — worker-side actions that require nodeId */
+const patchChangeTaskStatusNodeOwnedSchema = {
+    ...patchChangeTaskStatusBaseSchema,
+    nodeId: nodeIdSchema,
+};
+
+export const patchChangeTaskStatusSchema = z.discriminatedUnion("action", [
+    z.object({
+        ...patchChangeTaskStatusBaseSchema,
+        action: z.literal(TaskStatusAction.PUBLISH),
+    }),
+    z.object({
+        ...patchChangeTaskStatusBaseSchema,
+        action: z.literal(TaskStatusAction.CLOSE),
+    }),
+    z.object({
+        ...patchChangeTaskStatusNodeOwnedSchema,
+        action: z.literal(TaskStatusAction.CLAIM),
+    }),
+    z.object({
+        ...patchChangeTaskStatusBaseSchema,
+        action: z.literal(TaskStatusAction.RESET),
+        nodeId: nodeIdSchema.optional(),
+    }),
+    z.object({
+        ...patchChangeTaskStatusNodeOwnedSchema,
+        action: z.literal(TaskStatusAction.CANCEL),
+    }),
+    z.object({
+        ...patchChangeTaskStatusNodeOwnedSchema,
+        action: z.literal(TaskStatusAction.FINISH),
+        cost: z.number().min(0),
+    }),
+]);
+
+export type PatchChangeTaskStatusPayload = z.infer<typeof patchChangeTaskStatusSchema>;
+
+export const patchTaskProgressSchema = z.object({
+    id: taskIdSchema,
+    progress: z.number().min(0).max(100),
+    nodeId: nodeIdSchema,
+    traceId: traceIdSchema,
+});
+
+export type PatchTaskProgressPayload = z.infer<typeof patchTaskProgressSchema>;
+
+export const patchClaimTaskSchema = z.object({
+    nodeId: nodeIdSchema,
+    availableTaskList: z.array(z.string()).min(1),
+    traceId: traceIdSchema,
+});
+
+export type PatchClaimTaskPayload = z.infer<typeof patchClaimTaskSchema>;
+
+// ─── Optimistic lock helpers ─────────────────────────────────────────────────
+
+function lockOnStatus(...allowed: TaskStatus[]): QueryFilter[] {
+    if (allowed.length === 1) {
+        return [{ field: TASK_STATUS_FIELD, operator: "eq", value: allowed[0] }];
+    }
+    return [{ field: TASK_STATUS_FIELD, operator: "in", value: allowed }];
+}
+
+function lockOnOwnerNode(nodeId: string): QueryFilter {
+    return { field: TASK_NODE_ID_FIELD, operator: "eq", value: nodeId };
+}
+
+/** DOING row owned by `nodeId` — used by FINISH, CANCEL, patchTaskProgress */
+function lockOnDoingOwner(nodeId: string): QueryFilter[] {
+    return [...lockOnStatus(TaskStatus.DOING), lockOnOwnerNode(nodeId)];
+}
+
+/** TODO without nodeId; DOING/DONE with owner when nodeId is provided */
+function lockOnReset(nodeId?: string): QueryFilter[] {
+    if (nodeId != null) {
+        return [...lockOnStatus(TaskStatus.DOING, TaskStatus.DONE), lockOnOwnerNode(nodeId)];
+    }
+    return lockOnStatus(TaskStatus.TODO);
+}
+
+function clearExecutionState(): Pick<TaskDetails, "progress" | "nodeId" | "result"> {
+    return { progress: 0, nodeId: null, result: undefined };
+}
+
+// ─── Internal transitions ────────────────────────────────────────────────────
+
+async function transitionTask({
+    id,
+    optimisticLockFilterList,
+    updateFn,
+    updateExtraFn,
+}: {
+    id: string;
+    optimisticLockFilterList: QueryFilter[];
+    updateFn: (details: TaskDetails) => TaskDetails;
+    updateExtraFn?: (existing: TaskDetails) => string;
+}): Promise<Task> {
+    return updateTargetDetails<Task, TaskDetails>({
+        id,
+        optimisticLockFilterList,
+        updateFn,
+        updateExtraFn,
+    });
+}
+
+function logTaskTransition(
+    logger: LoggerWithScope,
+    action: TaskStatusAction | "patchTaskProgress" | "patchClaimTask",
+    task: Task,
+    data?: Record<string, unknown>
+): void {
+    logger.info("任务状态迁移成功", {
+        topic: "task",
+        data: {
+            action,
+            taskId: task.id,
+            taskValue: task.value,
+            status: task.details.status,
+            nodeId: task.details.nodeId,
+            ...data,
+        },
+    });
+}
+
+/** TODO → DOING — lock status only (no owner yet); used by CLAIM and {@link patchClaimTask} */
+async function claimTaskById({
+    taskId,
+    nodeId,
+    updateExtraFn,
+}: {
+    taskId: string;
+    nodeId: string;
+    updateExtraFn?: (existing: TaskDetails) => string;
+}): Promise<Task> {
+    return transitionTask({
+        id: taskId,
+        optimisticLockFilterList: lockOnStatus(TaskStatus.TODO),
+        updateFn: (details) => ({
+            ...details,
+            status: TaskStatus.DOING,
+            nodeId,
+        }),
+        updateExtraFn,
+    });
+}
+
+// ─── patchChangeTaskStatus ───────────────────────────────────────────────────
+
+export const patchChangeTaskStatus = validateWithSchema(
+    patchChangeTaskStatusSchema,
+    "patchChangeTaskStatusSchema"
+)(async (params) => {
+    const logger = createApiLogger("patchChangeTaskStatus", { traceId: params.traceId });
+    const { id, action, extra } = params;
+    const updateExtraFn = extra == null ? undefined : () => extra;
+
+    switch (action) {
+        case TaskStatusAction.PUBLISH: {
+            const data = await transitionTask({
+                id,
+                optimisticLockFilterList: lockOnStatus(TaskStatus.OPEN),
+                updateFn: (details) => ({
+                    ...details,
+                    ...clearExecutionState(),
+                    status: TaskStatus.TODO,
+                }),
+                updateExtraFn,
+            });
+            logTaskTransition(logger, action, data);
+            return generateResponse.success<Task>(data);
+        }
+        case TaskStatusAction.CLAIM: {
+            const { nodeId } = params;
+            const data = await claimTaskById({ taskId: id, nodeId, updateExtraFn });
+            logTaskTransition(logger, action, data);
+            return generateResponse.success<Task>(data);
+        }
+        case TaskStatusAction.RESET: {
+            const { nodeId } = params;
+            const data = await transitionTask({
+                id,
+                optimisticLockFilterList: lockOnReset(nodeId),
+                updateFn: (details) => ({
+                    ...details,
+                    ...clearExecutionState(),
+                    status: TaskStatus.OPEN,
+                }),
+                updateExtraFn,
+            });
+            logTaskTransition(logger, action, data, nodeId != null ? undefined : { resetFrom: "TODO" });
+            return generateResponse.success<Task>(data);
+        }
+        case TaskStatusAction.CANCEL: {
+            const { nodeId } = params;
+            const data = await transitionTask({
+                id,
+                optimisticLockFilterList: lockOnDoingOwner(nodeId),
+                updateFn: (details) => ({
+                    ...details,
+                    ...clearExecutionState(),
+                    status: TaskStatus.TODO,
+                }),
+                updateExtraFn,
+            });
+            logTaskTransition(logger, action, data);
+            return generateResponse.success<Task>(data);
+        }
+        case TaskStatusAction.CLOSE: {
+            const data = await transitionTask({
+                id,
+                optimisticLockFilterList: lockOnStatus(TaskStatus.OPEN, TaskStatus.DONE),
+                updateFn: (details) => ({
+                    ...details,
+                    status: TaskStatus.CLOSED,
+                }),
+                updateExtraFn,
+            });
+            logTaskTransition(logger, action, data);
+            return generateResponse.success<Task>(data);
+        }
+        case TaskStatusAction.FINISH: {
+            const { cost, nodeId } = params;
+            const data = await transitionTask({
+                id,
+                optimisticLockFilterList: lockOnDoingOwner(nodeId),
+                updateFn: (details) => ({
+                    ...details,
+                    progress: 100,
+                    status: TaskStatus.DONE,
+                    nodeId,
+                    result: {
+                        cost,
+                        code: ResultCode.SUCCESS,
+                    },
+                }),
+                updateExtraFn,
+            });
+            logTaskTransition(logger, action, data, { cost });
+            return generateResponse.success<Task>(data);
+        }
+        default: {
+            const _exhaustive: never = action;
+            const message = `[patchChangeTaskStatus] Unknown action: ${String(_exhaustive)}`;
+            logger.error(message, { topic: "task", data: { action: String(_exhaustive) } });
+            return generateResponse.error(message);
+        }
+    }
+});
+
+// ─── patchTaskProgress ───────────────────────────────────────────────────────
+
+/** Update progress on a DOING task; only the owning node may write (see `lockOnDoingOwner`). */
+export const patchTaskProgress = validateWithSchema(
+    patchTaskProgressSchema,
+    "patchTaskProgressSchema"
+)(async ({ id, progress, nodeId, traceId }) => {
+    const logger = createApiLogger("patchTaskProgress", { traceId, labels: { nodeId } });
+    const data = await transitionTask({
+        id,
+        optimisticLockFilterList: lockOnDoingOwner(nodeId),
+        updateFn: (details) => ({
+            ...details,
+            progress,
+        }),
+    });
+    logTaskTransition(logger, "patchTaskProgress", data, { progress });
+    return generateResponse.success<Task>(data);
+});
+
+// ─── patchClaimTask ──────────────────────────────────────────────────────────
+
+/**
+ * Discover and claim one TODO task for this node.
+ *
+ * Flow: filter by `availableTaskList` → {@link claimTaskById} (same as `action: CLAIM`).
+ * Equivalent to `patchChangeTaskStatus({ id, action: CLAIM, nodeId })` when `id` is already known.
+ *
+ * Returns `data: null` when no TODO task matches.
+ * Optimistic lock conflicts return `{ error }` with `code: "OPTIMISTIC_LOCK"` (not thrown).
+ */
+export const patchClaimTask = validateWithSchema(
+    patchClaimTaskSchema,
+    "patchClaimTaskSchema"
+)(async ({ nodeId, availableTaskList, traceId }): Promise<SupabaseResponse<Task | null>> => {
+    const logger = createApiLogger("patchClaimTask", { traceId, labels: { nodeId } });
+
+    try {
+        const { data: possibleTask } = await getPossibleTarget({
+            filterList: [
+                { field: "category", operator: "eq", value: CategoryTask.TASK },
+                { field: TASK_STATUS_FIELD, operator: "eq", value: TaskStatus.TODO },
+                { field: "value", operator: "in", value: availableTaskList },
+            ],
+        });
+
+        if (possibleTask == null) {
+            return generateResponse.success(null);
+        }
+
+        const todoTask = possibleTask as Task;
+        const data = await claimTaskById({ taskId: todoTask.id, nodeId });
+        logTaskTransition(logger, "patchClaimTask", data);
+        return generateResponse.success(data);
+    } catch (error) {
+        if (isOptimisticLockError(error)) {
+            logger.debug("認領競爭失敗，本輪無可認領任務", { topic: "task" });
+            return generateResponse.error(OPTIMISTIC_LOCK_FAILED_MESSAGE, undefined, "OPTIMISTIC_LOCK") as SupabaseResponse<Task | null>;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error("認領任務失敗", { topic: "task", data: { error: message } });
+        return generateResponse.error(message) as SupabaseResponse<Task | null>;
+    }
+});

package/src/task/task.interface.ts

@@ -1,5 +1,4 @@
 import { Target } from "../core.interface";
-import { Repo } from "../repo/repo.interface";
 
 export enum CategoryTask {
     TASK = "task",
@@ -13,6 +12,16 @@ export enum TaskStatus {
     CLOSED = "CLOSED",
 }
 
+/** Named transitions for {@link patchChangeTaskStatus} — verb aligned with state machine edges */
+export enum TaskStatusAction {
+    PUBLISH = "publish",
+    CLAIM = "claim",
+    RESET = "reset",
+    CANCEL = "cancel",
+    CLOSE = "close",
+    FINISH = "finish",
+}
+
 export enum ResultCode {
     SUCCESS = 1000,
 
@@ -40,11 +49,12 @@ export interface Task extends Target {
 export interface TaskDetails {
     manifestVersion: number;
     status: TaskStatus;
-    repo: Repo;
     params: unknown;
     /** [0,100] */
     progress: number;
     nodeId: null | string;
+    /** Task lifecycle correlation id (written at postTask). */
+    traceId?: string;
     result?: {
         cost: number;
         code: ResultCode;

package/src/trigger/trigger.api.ts

@@ -0,0 +1,166 @@
+import { createTarget, scanTargetList, updateTargetDetails, validateWithSchema } from "../core.api";
+import { generateResponse, type SupabaseResponse } from "../core.interface";
+import { TaskStatus } from "../task/task.interface";
+import { createApiLogger } from "../shared/log";
+import { z } from "zod";
+import {
+    CategoryTrigger,
+    Trigger,
+    TriggerStatus,
+    type TriggerAction,
+    type TriggerSchedule,
+} from "./trigger.interface";
+
+const TRIGGER_STATUS_FIELD = "details->>status" as const;
+
+const traceIdSchema = z.string().trim().min(1).optional();
+
+const dailyScheduleSchema = z.object({
+    kind: z.literal("daily"),
+    hour: z.number().int().min(0).max(23),
+    minute: z.number().int().min(0).max(59),
+});
+
+const postTaskActionSchema = z.object({
+    kind: z.literal("post_task"),
+    taskTypeKey: z.string().trim().min(1),
+    taskParams: z.unknown(),
+    taskName: z.string().trim().min(1).optional(),
+    taskStatus: z.enum([TaskStatus.OPEN, TaskStatus.TODO]).optional(),
+});
+
+export const postTriggerSchema = z.object({
+    name: z.string().trim().min(1),
+    value: z.string().trim().min(1),
+    status: z.nativeEnum(TriggerStatus).optional().default(TriggerStatus.ENABLED),
+    schedule: dailyScheduleSchema,
+    action: postTaskActionSchema,
+    tagList: z.array(z.string()).optional().default([]),
+    traceId: traceIdSchema,
+});
+
+export type PostTriggerPayload = z.infer<typeof postTriggerSchema>;
+
+export const scanEnabledTriggersSchema = z.object({
+    traceId: traceIdSchema,
+});
+
+export type ScanEnabledTriggersPayload = z.infer<typeof scanEnabledTriggersSchema>;
+
+export const patchTriggerFiredSchema = z.object({
+    triggerId: z.string().trim().min(1),
+    fireKey: z.string().trim().min(1),
+    expectedLastFireKey: z.string().nullable().optional(),
+    traceId: traceIdSchema,
+});
+
+export type PatchTriggerFiredPayload = z.infer<typeof patchTriggerFiredSchema>;
+
+function enabledTriggerFilter() {
+    return [{ field: TRIGGER_STATUS_FIELD, operator: "eq" as const, value: TriggerStatus.ENABLED }];
+}
+
+/** List all ENABLED triggers (Phase 1: in-memory due check). */
+export const scanEnabledTriggers = validateWithSchema(
+    scanEnabledTriggersSchema,
+    "scanEnabledTriggersSchema"
+)(async ({ traceId }) => {
+    const logger = createApiLogger("scanEnabledTriggers", { traceId });
+
+    try {
+        const { data: triggerList } = await scanTargetList<Trigger>({
+            category: CategoryTrigger.TRIGGER,
+            filterList: enabledTriggerFilter(),
+            orderBy: { field: "created_at", ascending: true },
+        });
+
+        const rows = triggerList ?? [];
+        logger.info("已掃描 ENABLED Trigger", {
+            topic: "trigger",
+            data: { count: rows.length },
+        });
+
+        return generateResponse.success(rows);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return generateResponse.error(message) as SupabaseResponse<Trigger[]>;
+    }
+});
+
+/** Create a trigger row (scheduler / admin). */
+export const postTrigger = validateWithSchema(
+    postTriggerSchema,
+    "postTriggerSchema"
+)(async ({ name, value, status, schedule, action, tagList, traceId }) => {
+    const logger = createApiLogger("postTrigger", { traceId });
+
+    const details = {
+        manifestVersion: 0,
+        status,
+        schedule: schedule as TriggerSchedule,
+        action: action as TriggerAction,
+        lastFiredAt: null,
+        lastFireKey: null,
+    };
+
+    const result = await createTarget<Trigger, PostTriggerPayload>({
+        payload: { name, value, status, schedule, action, tagList, traceId },
+        createFn: () => ({
+            name,
+            value,
+            category: CategoryTrigger.TRIGGER,
+            tagList,
+            details,
+        }),
+    });
+
+    logger.info("Trigger 已創建", {
+        topic: "trigger",
+        data: { triggerId: result.data?.id, triggerKey: value, status },
+    });
+
+    return result;
+});
+
+/**
+ * Mark trigger as fired for `fireKey`.
+ * When `expectedLastFireKey` is set, uses optimistic lock on that field.
+ */
+export const patchTriggerFired = validateWithSchema(
+    patchTriggerFiredSchema,
+    "patchTriggerFiredSchema"
+)(async ({ triggerId, fireKey, expectedLastFireKey, traceId }) => {
+    const logger = createApiLogger("patchTriggerFired", { traceId });
+    const now = Date.now();
+
+    try {
+        const optimisticLockFilterList =
+            expectedLastFireKey != null && expectedLastFireKey !== ""
+                ? [{ field: "details->>lastFireKey" as const, operator: "eq" as const, value: expectedLastFireKey }]
+                : [];
+
+        const data = await updateTargetDetails<Trigger, Trigger["details"]>({
+            id: triggerId,
+            optimisticLockFilterList,
+            updateFn: (current) => ({
+                ...current,
+                lastFireKey: fireKey,
+                lastFiredAt: now,
+            }),
+        });
+
+        logger.success("Trigger 觸發記錄已更新", {
+            topic: "trigger",
+            data: { triggerId, fireKey },
+        });
+
+        return generateResponse.success(data);
+    } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.warn("Trigger 觸發記錄更新失敗", {
+            topic: "trigger",
+            data: { triggerId, fireKey, error: message },
+        });
+        return generateResponse.error(message);
+    }
+});

package/src/trigger/trigger.interface.ts

@@ -0,0 +1,50 @@
+import { Target } from "../core.interface";
+import { TaskStatus } from "../task/task.interface";
+
+export enum CategoryTrigger {
+    TRIGGER = "trigger",
+}
+
+export enum TriggerStatus {
+    ENABLED = "ENABLED",
+    DISABLED = "DISABLED",
+    PAUSED = "PAUSED",
+}
+
+/** Phase 1: daily fire at `hour`:`minute` UTC. */
+export interface TriggerDailySchedule {
+    kind: "daily";
+    hour: number;
+    minute: number;
+}
+
+export type TriggerSchedule = TriggerDailySchedule;
+
+export interface TriggerPostTaskAction {
+    kind: "post_task";
+    taskTypeKey: string;
+    taskParams: unknown;
+    taskName?: string;
+    taskStatus?: TaskStatus.OPEN | TaskStatus.TODO;
+}
+
+export type TriggerAction = TriggerPostTaskAction;
+
+export interface Trigger extends Target {
+    /** Human readable */
+    name: string;
+    /** Unique trigger key */
+    value: string;
+    details: TriggerDetails;
+    category: CategoryTrigger;
+}
+
+export interface TriggerDetails {
+    manifestVersion: number;
+    status: TriggerStatus;
+    schedule: TriggerSchedule;
+    action: TriggerAction;
+    lastFiredAt?: number | null;
+    /** Idempotency key for the last successful fire, e.g. `daily:2026-06-18` (UTC date). */
+    lastFireKey?: string | null;
+}

package/src/trigger/trigger.utils.ts

@@ -0,0 +1,56 @@
+import type { Trigger, TriggerDailySchedule } from "./trigger.interface";
+
+interface UtcDateParts {
+    year: number;
+    month: number;
+    day: number;
+    hour: number;
+    minute: number;
+}
+
+function parseUtcDateParts(now: Date): UtcDateParts {
+    return {
+        year: now.getUTCFullYear(),
+        month: now.getUTCMonth() + 1,
+        day: now.getUTCDate(),
+        hour: now.getUTCHours(),
+        minute: now.getUTCMinutes(),
+    };
+}
+
+export function buildDailyFireKey(_schedule: TriggerDailySchedule, now: Date): string {
+    const { year, month, day } = parseUtcDateParts(now);
+    const yyyy = String(year).padStart(4, "0");
+    const mm = String(month).padStart(2, "0");
+    const dd = String(day).padStart(2, "0");
+    return `daily:${yyyy}-${mm}-${dd}`;
+}
+
+export function isDailyScheduleDue(
+    schedule: TriggerDailySchedule,
+    now: Date,
+    lastFireKey: string | null | undefined
+): boolean {
+    const parts = parseUtcDateParts(now);
+    if (parts.hour !== schedule.hour || parts.minute !== schedule.minute) {
+        return false;
+    }
+    const fireKey = buildDailyFireKey(schedule, now);
+    return lastFireKey !== fireKey;
+}
+
+export function isTriggerDue(trigger: Trigger, now: Date = new Date()): boolean {
+    const { schedule, lastFireKey } = trigger.details;
+    if (schedule.kind !== "daily") {
+        throw new Error(`Unsupported trigger schedule kind: ${String((schedule as { kind?: string }).kind)}`);
+    }
+    return isDailyScheduleDue(schedule, now, lastFireKey);
+}
+
+export function buildFireKey(trigger: Trigger, now: Date = new Date()): string {
+    const { schedule } = trigger.details;
+    if (schedule.kind !== "daily") {
+        throw new Error(`Unsupported trigger schedule kind: ${String((schedule as { kind?: string }).kind)}`);
+    }
+    return buildDailyFireKey(schedule, now);
+}

package/dist/task/task-node-manager.d.ts

@@ -1 +0,0 @@
-//# sourceMappingURL=task-node-manager.d.ts.map

package/dist/task/task-node-manager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"task-node-manager.d.ts","sourceRoot":"","sources":["../../src/task/task-node-manager.ts"],"names":[],"mappings":""}

package/dist/task/task-node-manager.js

@@ -1,2 +0,0 @@
-"use strict";
-//# sourceMappingURL=task-node-manager.js.map

package/dist/task/task-node-manager.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"task-node-manager.js","sourceRoot":"","sources":["../../src/task/task-node-manager.ts"],"names":[],"mappings":""}