target-supabase-sdk 0.1.7 → 0.1.8

package/src/node/node.api.ts

@@ -0,0 +1,161 @@
+import { CategoryTask, Task, TaskDetails, TaskStatus } from "../task/task.interface";
+import { createTarget, getPossibleTarget, updateTargetDetails } from "../core.api";
+import { generateResponse } from "../core.interface";
+import { BaseValidator } from "../core.utils";
+import { CategoryNode, Node, NodeDetails, NodeStatus } from "./node.interface";
+
+export interface PostRegisterNodePayload {
+}
+
+export class PostListValidator extends BaseValidator<PostRegisterNodePayload> {
+    protected requiredFields: (keyof PostRegisterNodePayload)[] = [];
+    protected optionalFields: (keyof PostRegisterNodePayload)[] = [];
+
+    constructor() {
+        super();
+        // Add custom
+        this.addCustomValidator((val) => {
+            return true;
+        });
+    }
+}
+
+
+
+export const postRegisterNode = async (payload: PostRegisterNodePayload) => {
+    return createTarget<Node, PostRegisterNodePayload>({
+        payload: payload,
+        validator: PostListValidator,
+        createFn: (validPayload) => {
+            const details: NodeDetails = {
+                manifestVersion: 0,
+                status: NodeStatus.READY,
+                lastHeartBeat: Date.now(),
+            };
+            return {
+                name: '',
+                category: CategoryNode.NODE,
+                value: '',
+                tagList: [],
+                details,
+            };
+        },
+    });
+};
+
+export const patchNodeHeartBeat = async ({ nodeId }: { nodeId: string }) => {
+    const lastHeartBeat = Date.now();
+    await updateTargetDetails<Node, NodeDetails>({
+        id: nodeId,
+        updateFn: (details) => {
+            return {
+                ...details,
+                lastHeartBeat,
+            };
+        },
+    });
+    return generateResponse.success(lastHeartBeat);
+};
+
+export const patchStopNode = async ({ nodeId }: { nodeId: string }) => {
+    const lastHeartBeat = Date.now();
+    // TODO 等待任務全部完成才下綫 應該先使用NodeStatus.DRAINING
+    await updateTargetDetails<Node, NodeDetails>({
+        id: nodeId,
+        updateFn: (details) => {
+            return {
+                ...details,
+                lastHeartBeat,
+                status: NodeStatus.LOST,
+            };
+        },
+    });
+    return generateResponse.success(lastHeartBeat);
+};
+
+export interface PatchClaimTaskPayload {
+    nodeId: string;
+    availableTaskList: string[];
+}
+
+/**
+ * Atomically claim one TODO task for this node.
+ *
+ * Flow: find a candidate (TODO + value in availableTaskList) → UPDATE with optimistic lock
+ * (status must still be TODO) → return the updated Task row for the executor to run.
+ *
+ * Returns `data: null` when no TODO task matches. On optimistic lock conflict,
+ * `updateTargetDetails` throws — callers may catch `isOptimisticLockError` to retry.
+ */
+export const patchClaimTask = async ({
+    nodeId,
+    availableTaskList,
+}: PatchClaimTaskPayload) => {
+    if (availableTaskList.length === 0) {
+        console.log("[patchClaimTask] skipped: availableTaskList is empty", { nodeId });
+        return generateResponse.success(null);
+    }
+
+    // Step 1: Pick one matching TODO task (not locked; another node may claim the same row next).
+    const { data: possibleTask } = await getPossibleTarget({
+        filterList: [
+            {
+                field: "category",
+                operator: "eq",
+                value: CategoryTask.TASK,
+            },
+            {
+                field: "details->>status",
+                operator: "eq",
+                value: TaskStatus.TODO,
+            },
+            {
+                field: "value",
+                operator: "in",
+                value: availableTaskList,
+            },
+        ],
+    });
+
+    if (possibleTask == null) {
+        console.log("[patchClaimTask] no TODO task for node capabilities", {
+            nodeId,
+            availableTaskList,
+        });
+        return generateResponse.success(null);
+    }
+
+    const todoTask = possibleTask as Task;
+    console.log("[patchClaimTask] attempting claim", {
+        nodeId,
+        taskId: todoTask.id,
+        taskValue: todoTask.value,
+    });
+
+    // Step 2: Claim with DB optimistic lock — UPDATE only if status is still TODO.
+    const data = await updateTargetDetails<Task, TaskDetails>({
+        id: todoTask.id,
+        optimisticLockFilterList: [
+            {
+                field: "details->>status",
+                operator: "eq",
+                value: TaskStatus.TODO,
+            },
+        ],
+        updateFn: (details) => ({
+            ...details,
+            status: TaskStatus.DOING,
+            nodeId,
+        }),
+    });
+
+    console.log("[patchClaimTask] claim succeeded", {
+        nodeId,
+        taskId: data.id,
+        taskValue: data.value,
+        status: (data as Task).details.status,
+    });
+
+    // Return full updated row so executor can read repo/params without another fetch.
+    return generateResponse.success(data);
+};

package/src/node/node.interface.ts

@@ -0,0 +1,32 @@
+import { Target } from "../core.interface";
+
+export enum NodeStatus {
+    READY = "READY",
+    BUSY = "BUSY",
+    /** Heartbeat lost or voluntarily offline; considered unavailable by the scheduler. */
+    LOST = "LOST",
+    /** TODO Gracefully draining: not accepting new tasks, waiting for in-flight tasks to complete. */
+    DRAINING = "DRAINING",
+    /** TODO Disabled by an administrator; excluded from scheduling. */
+    DISABLED = "DISABLED",
+}
+
+export enum CategoryNode {
+    NODE = "node",
+}
+
+export interface Node extends Target {
+    /** Empty */
+    name: string;
+    /** Empty */
+    value: string;
+    details: NodeDetails;
+    category: CategoryNode;
+}
+
+export interface NodeDetails {
+    manifestVersion: number;
+    status: NodeStatus;
+    lastHeartBeat: number;
+};
+

package/src/question-list/question-list.api.ts

@@ -9,7 +9,7 @@ export class PostCreateQuestionListValidator extends BaseValidator<PostCreateQue
   constructor() {
     super();
     // Add custom
-    this.addValidator((val) => {
+    this.addCustomValidator((val) => {
       return true;
     });
   }

package/src/repo/repo.interface.ts

@@ -0,0 +1,23 @@
+import { Target } from "../core.interface";
+
+export enum CategoryRepo {
+    /** Project */
+    REPO = "repo",
+    SCRIPT = "script",
+}
+
+export interface Repo extends Target {
+    /** Key */
+    name: string;
+    /** Url */
+    value: string;
+    details: RepoDetails;
+    category: CategoryRepo;
+}
+
+export interface RepoDetails {
+    manifestVersion: number;
+    context?: unknown;
+    hash: string;
+};
+

package/src/review/review.api.ts

@@ -1,6 +1,6 @@
 import { cloneDeep } from "lodash-es";
 import { createTarget, getPossibleTarget, updateTargetDetails } from "../core.api";
-import { createResponse } from "../core.interface";
+import { generateResponse } from "../core.interface";
 import { BaseValidator } from "../core.utils";
 import { CategoryReview, Review, ReviewDetails } from "./review.interface";
 
@@ -12,7 +12,7 @@ class PatchUpsertReviewValidator extends BaseValidator<ReviewDetails> {
   constructor() {
     super();
     // Add custom
-    this.addValidator((val) => {
+    this.addCustomValidator((val) => {
       if (val.reviewResult == null || Object.values(val.reviewResult).some((v) => typeof v !== "number")) {
         return "[Check reviewResult] reviewResult invalid";
       }
@@ -69,7 +69,7 @@ export const patchUpsertReview = async (payload: ReviewDetails) => {
         return details;
       },
     });
-    return createResponse.success<Review>(data);
+    return generateResponse.success<Review>(data);
   }
   // Create
   const { data: newReview } = await postReview({
@@ -81,7 +81,7 @@ export const patchUpsertReview = async (payload: ReviewDetails) => {
     console.error(msg);
     throw new Error(msg);
   }
-  return createResponse.success<Review>(newReview);
+  return generateResponse.success<Review>(newReview);
 };
 
 export interface PostReviewPayload {
@@ -96,7 +96,7 @@ export class PostReviewValidator extends BaseValidator<PostReviewPayload> {
   constructor() {
     super();
     // Add custom
-    this.addValidator((val) => {
+    this.addCustomValidator((val) => {
       return true;
     });
   }

package/src/task/task.interface.ts

@@ -0,0 +1,60 @@
+import { Target } from "../core.interface";
+import { Repo } from "../repo/repo.interface";
+
+export enum CategoryTask {
+    TASK = "task",
+}
+
+export enum TaskStatus {
+    OPEN = "OPEN",
+    TODO = "TODO",
+    DOING = "DOING",
+    DONE = "DONE",
+    CLOSED = "CLOSED",
+}
+
+export enum ResultCode {
+    SUCCESS = 1000,
+
+    /** 3xxx 依赖 / 外部 */
+    PARAMS_NOT_VALID = 3001,
+    REPO_NOT_VALID = 3002,
+
+    /** 4xxx — 运行环境 */
+    TIMEOUT = 4001,
+    CANCELLED = 4002,
+    NODE_UNAVAILABLE = 4003,
+
+    UNKNOWN_ERROR = 9999,
+}
+
+export interface Task extends Target {
+    /** Readable */
+    name: string;
+    /** Unique key, as TaskType */
+    value: string;
+    details: TaskDetails;
+    category: CategoryTask;
+}
+
+export interface TaskDetails {
+    manifestVersion: number;
+    status: TaskStatus;
+    repo: Repo;
+    params: unknown;
+    /** [0,100] */
+    progress: number;
+    nodeId: null | string;
+    result?: {
+        cost: number;
+        code: ResultCode;
+        errorMessage?: string;
+        data?: unknown;
+    }
+};
+
+// TODO loop condition combination
+export interface TaskFlow extends Target {
+
+}
+

package/src/word/word.api.ts

@@ -2,16 +2,16 @@ import { createTarget } from "../core.api";
 import { BaseValidator } from "../core.utils";
 import { Word, WordDetails } from "./word.interface";
 
-export interface PostWordCreatePayload {
+export interface PostWordPayload {
   name: Word["name"];
   value: Word["value"];
   category: Word["category"];
   details: WordDetails;
 }
 
-export class PostWordValidator extends BaseValidator<PostWordCreatePayload> {
-  protected requiredFields: (keyof PostWordCreatePayload)[] = ["name", "value", "category", "details"];
-  protected optionalFields: (keyof PostWordCreatePayload)[] = [];
+export class PostWordValidator extends BaseValidator<PostWordPayload> {
+  protected requiredFields: (keyof PostWordPayload)[] = ["name", "value", "category", "details"];
+  protected optionalFields: (keyof PostWordPayload)[] = [];
 
   constructor() {
     super();
@@ -24,8 +24,8 @@ export class PostWordValidator extends BaseValidator<PostWordCreatePayload> {
 
 
 
-export const postWordCreate = async (payload: PostWordCreatePayload) => {
-  return createTarget<Word, PostWordCreatePayload>({
+export const postWord = async (payload: PostWordPayload) => {
+  return createTarget<Word, PostWordPayload>({
     payload: payload,
     validator: PostWordValidator,
     createFn: (validPayload) => {