@turinhub/tale-js-sdk 1.3.0

package/dist/task/types.d.ts

@@ -0,0 +1,116 @@
+import type { CommonOptions, Attachment } from "../common/types.js";
+/**
+ * UserTask entity (matches backend UserTaskVO)
+ */
+export interface UserTask {
+    task_id: string;
+    app_id: string;
+    user_id: string;
+    task_title: string;
+    task_input: Record<string, unknown>;
+    task_output: Record<string, unknown>;
+    task_type: string;
+    task_status: string;
+    parent_task_id?: string;
+    created_at: string;
+    updated_at: string;
+    attachments?: Attachment[];
+    sub_tasks?: UserTask[];
+}
+/**
+ * Request for creating a user task
+ */
+export interface CreateUserTaskRequest {
+    user_id: string;
+    task_title: string;
+    task_input?: Record<string, unknown>;
+    task_output?: Record<string, unknown>;
+    task_type?: string;
+    task_status?: string;
+    parent_task_id?: string;
+    remark?: string;
+}
+/**
+ * Request for updating a user task
+ */
+export interface UpdateUserTaskRequest {
+    task_title?: string;
+    task_input?: Record<string, unknown>;
+    task_output?: Record<string, unknown>;
+    task_status?: string;
+    remark?: string;
+}
+/**
+ * Request for batch creating user tasks
+ */
+export interface BatchCreateUserTasksRequest {
+    tasks: CreateUserTaskRequest[];
+}
+/**
+ * Request for batch querying user tasks
+ */
+export interface BatchQueryUserTasksRequest {
+    task_ids: string[];
+    user_ids?: string[];
+    task_status?: string;
+    include_attachments?: boolean;
+    include_sub_tasks?: boolean;
+}
+/**
+ * Request for listing user tasks
+ */
+export interface ListUserTasksRequest {
+    page?: number;
+    size?: number;
+    sort?: string;
+    user_ids?: string;
+    task_status?: string;
+    task_type?: string;
+    include_attachments?: boolean;
+    include_sub_tasks?: boolean;
+}
+/**
+ * Request for updating task status
+ */
+export interface UpdateTaskStatusRequest {
+    task_status: string;
+}
+/**
+ * Result of a single task creation in batch
+ */
+export interface UserTaskCreateResult {
+    index: number;
+    success: boolean;
+    task_id?: string;
+    message?: string;
+}
+/**
+ * Response for batch task creation
+ */
+export interface BatchCreateUserTasksResponse {
+    success_count: number;
+    failure_count: number;
+    results: UserTaskCreateResult[];
+}
+/**
+ * Task statistics response
+ */
+export interface TaskStatistics {
+    pending_count: number;
+    running_count: number;
+    completed_count: number;
+    failed_count: number;
+    cancelled_count: number;
+    total_count: number;
+}
+/**
+ * Task status response
+ */
+export interface TaskStatusResponse {
+    task_status: string;
+}
+/**
+ * Options for user task operations
+ */
+export interface UserTaskOptions extends CommonOptions {
+}

package/dist/task/types.js

@@ -0,0 +1 @@
+export {};

package/dist/task-type/index.d.ts

@@ -0,0 +1,92 @@
+import type { TaskType, CreateTaskTypeRequest, UpdateTaskTypeRequest, ListTaskTypesRequest, TaskTypeOptions } from "./types.js";
+import type { PageResponse } from "../common/types.js";
+export type { TaskType, CreateTaskTypeRequest, UpdateTaskTypeRequest, ListTaskTypesRequest, TaskTypeOptions, };
+/**
+ * Creates a new task type.
+ *
+ * @param request - Task type creation request
+ * @param options - Optional configuration
+ * @returns Promise resolving to created task type
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * const taskType = await createTaskType({
+ *   type_code: "daily_review",
+ *   type_name: "Daily Review",
+ *   description: "Daily review tasks",
+ *   allow_multiple: true,
+ *   is_enabled: true,
+ * });
+ * ```
+ */
+export declare function createTaskType(request: CreateTaskTypeRequest, options?: TaskTypeOptions): Promise<TaskType>;
+/**
+ * Updates an existing task type.
+ *
+ * @param typeId - Task type ID
+ * @param request - Task type update request
+ * @param options - Optional configuration
+ * @returns Promise resolving to updated task type
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ */
+export declare function updateTaskType(typeId: string, request: UpdateTaskTypeRequest, options?: TaskTypeOptions): Promise<TaskType>;
+/**
+ * Deletes a task type.
+ *
+ * @param typeId - Task type ID
+ * @param options - Optional configuration
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ */
+export declare function deleteTaskType(typeId: string, options?: TaskTypeOptions): Promise<void>;
+/**
+ * Gets a task type by ID or code.
+ *
+ * @param typeId - Task type ID or code
+ * @param options - Optional configuration
+ * @returns Promise resolving to task type
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ */
+export declare function getTaskType(typeId: string, options?: TaskTypeOptions): Promise<TaskType>;
+/**
+ * Lists task types with pagination and optional filtering.
+ *
+ * @param request - List request parameters
+ * @param options - Optional configuration
+ * @returns Promise resolving to paginated list of task types
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * const result = await listTaskTypes({
+ *   page: 0,
+ *   size: 20,
+ *   is_enabled: true,
+ *   sort_by: "createdAt",
+ *   sort_direction: "desc",
+ * });
+ * console.log(result.content); // Array of task types
+ * console.log(result.total); // Total count
+ * ```
+ */
+export declare function listTaskTypes(request?: ListTaskTypesRequest & TaskTypeOptions): Promise<PageResponse<TaskType>>;
+/**
+ * Lists all enabled task types (no pagination).
+ *
+ * @param options - Optional configuration
+ * @returns Promise resolving to array of enabled task types
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ */
+export declare function listEnabledTaskTypes(options?: TaskTypeOptions): Promise<TaskType[]>;

package/dist/task-type/index.js

@@ -0,0 +1,256 @@
+import { getAppToken } from "../token.js";
+import { ApiError, ConfigurationError, NetworkError } from "../errors.js";
+// ==================== Helper Functions ====================
+function parseApiResponse(json, errorMessage, statusCode) {
+    if (typeof json !== "object" || json === null) {
+        throw new ApiError(`Invalid response: ${errorMessage} - not an object`, statusCode);
+    }
+    const response = json;
+    if (response.code !== 200) {
+        const errorMsg = typeof response.msg === "string" ? response.msg : errorMessage;
+        throw new ApiError(errorMsg, statusCode, response.code);
+    }
+    if (!response.data) {
+        throw new ApiError(`Invalid response: ${errorMessage} - missing data`, statusCode);
+    }
+    return response.data;
+}
+function getBaseUrl(options) {
+    const env = globalThis?.process?.env ?? import.meta?.env ?? undefined;
+    const base = options?.baseUrl ?? env?.TALE_BASE_URL ?? undefined;
+    if (!base) {
+        throw new ConfigurationError("Missing required environment variable: TALE_BASE_URL");
+    }
+    return String(base).replace(/\/+$/, "");
+}
+// ==================== TaskType CRUD Operations ====================
+/**
+ * Creates a new task type.
+ *
+ * @param request - Task type creation request
+ * @param options - Optional configuration
+ * @returns Promise resolving to created task type
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * const taskType = await createTaskType({
+ *   type_code: "daily_review",
+ *   type_name: "Daily Review",
+ *   description: "Daily review tasks",
+ *   allow_multiple: true,
+ *   is_enabled: true,
+ * });
+ * ```
+ */
+export async function createTaskType(request, options) {
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + "/task-type/v1/types");
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(request),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to create task type: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to create task type", response.status);
+}
+/**
+ * Updates an existing task type.
+ *
+ * @param typeId - Task type ID
+ * @param request - Task type update request
+ * @param options - Optional configuration
+ * @returns Promise resolving to updated task type
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ */
+export async function updateTaskType(typeId, request, options) {
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + `/task-type/v1/types/${encodeURIComponent(typeId)}`);
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "PUT",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(request),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to update task type: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to update task type", response.status);
+}
+/**
+ * Deletes a task type.
+ *
+ * @param typeId - Task type ID
+ * @param options - Optional configuration
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ */
+export async function deleteTaskType(typeId, options) {
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + `/task-type/v1/types/${encodeURIComponent(typeId)}`);
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "DELETE",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to delete task type: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    if (typeof json !== "object" || json === null) {
+        throw new ApiError("Invalid task type deletion response", response.status);
+    }
+    const apiResponse = json;
+    if (apiResponse.code !== 200) {
+        const errorMsg = typeof apiResponse.msg === "string"
+            ? apiResponse.msg
+            : "Failed to delete task type";
+        throw new ApiError(errorMsg, response.status, apiResponse.code);
+    }
+}
+/**
+ * Gets a task type by ID or code.
+ *
+ * @param typeId - Task type ID or code
+ * @param options - Optional configuration
+ * @returns Promise resolving to task type
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ */
+export async function getTaskType(typeId, options) {
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + `/task-type/v1/types/${encodeURIComponent(typeId)}`);
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to get task type: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to get task type", response.status);
+}
+/**
+ * Lists task types with pagination and optional filtering.
+ *
+ * @param request - List request parameters
+ * @param options - Optional configuration
+ * @returns Promise resolving to paginated list of task types
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ *
+ * @example
+ * ```typescript
+ * const result = await listTaskTypes({
+ *   page: 0,
+ *   size: 20,
+ *   is_enabled: true,
+ *   sort_by: "createdAt",
+ *   sort_direction: "desc",
+ * });
+ * console.log(result.content); // Array of task types
+ * console.log(result.total); // Total count
+ * ```
+ */
+export async function listTaskTypes(request) {
+    const token = request?.appToken ?? (await getAppToken(request));
+    const base = getBaseUrl(request);
+    const url = new URL(base + "/task-type/v2/types");
+    const { appToken, baseUrl, ...requestParams } = request || {};
+    const queryParams = {
+        page: 0,
+        size: 20,
+        sort: "createdAt,desc",
+        ...requestParams,
+    };
+    Object.entries(queryParams).forEach(([key, value]) => {
+        if (value !== undefined) {
+            url.searchParams.append(key, String(value));
+        }
+    });
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to list task types: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to list task types", response.status);
+}
+/**
+ * Lists all enabled task types (no pagination).
+ *
+ * @param options - Optional configuration
+ * @returns Promise resolving to array of enabled task types
+ * @throws {ConfigurationError} When required environment variables are missing
+ * @throws {ApiError} When API request fails
+ * @throws {NetworkError} When network request fails
+ */
+export async function listEnabledTaskTypes(options) {
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + "/task-type/v1/types/enabled");
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to list enabled task types: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    const result = parseApiResponse(json, "Failed to list enabled task types", response.status);
+    if (!Array.isArray(result)) {
+        throw new ApiError("Invalid enabled task types response: not an array", response.status);
+    }
+    return result;
+}

package/dist/task-type/types.d.ts

@@ -0,0 +1,54 @@
+import type { CommonOptions } from "../common/types.js";
+/**
+ * TaskType entity (matches backend TaskTypeVO)
+ */
+export interface TaskType {
+    type_id: string;
+    app_id: string;
+    type_code: string;
+    type_name: string;
+    description?: string;
+    allow_multiple: boolean;
+    is_enabled: boolean;
+    parent_task_type_id?: string;
+    created_at: string;
+    updated_at: string;
+    remark?: string;
+}
+/**
+ * Request for creating a task type
+ * Note: type_code is auto-generated by the backend
+ */
+export interface CreateTaskTypeRequest {
+    type_name: string;
+    description?: string;
+    allow_multiple?: boolean;
+    is_enabled?: boolean;
+    parent_task_type_id?: string;
+    remark?: string;
+}
+/**
+ * Request for updating a task type
+ */
+export interface UpdateTaskTypeRequest {
+    type_name?: string;
+    description?: string;
+    allow_multiple?: boolean;
+    is_enabled?: boolean;
+    parent_task_type_id?: string;
+    remark?: string;
+}
+/**
+ * Request for listing task types
+ */
+export interface ListTaskTypesRequest {
+    page?: number;
+    size?: number;
+    sort?: string;
+    is_enabled?: boolean;
+}
+/**
+ * Options for task type operations
+ */
+export interface TaskTypeOptions extends CommonOptions {
+}

package/dist/task-type/types.js

@@ -0,0 +1 @@
+export {};

package/dist/token.d.ts

@@ -0,0 +1,21 @@
+import { TaleSdkError, ConfigurationError, ApiError, EnvironmentError, TokenError, NetworkError, ValidationError, isTaleSdkError, createErrorFromUnknown } from "./errors.js";
+export { TaleSdkError, ConfigurationError, ApiError, EnvironmentError, TokenError, NetworkError, ValidationError, isTaleSdkError, createErrorFromUnknown, };
+export type AppTokenData = {
+    type: string;
+    app_key: string;
+    app_name: string;
+    token: string;
+    status: string;
+    expired_at: string;
+};
+export type AppTokenJson = {
+    data: AppTokenData;
+    code: number;
+    msg: string;
+};
+export type TokenRequestOptions = {
+    baseUrl?: string;
+    appKey?: string;
+    appSecret?: string;
+};
+export declare function getAppToken(options?: TokenRequestOptions): Promise<string>;

package/dist/token.js

@@ -0,0 +1,114 @@
+import { TaleSdkError, ConfigurationError, ApiError, EnvironmentError, TokenError, NetworkError, ValidationError, isTaleSdkError, createErrorFromUnknown, } from "./errors.js";
+export { TaleSdkError, ConfigurationError, ApiError, EnvironmentError, TokenError, NetworkError, ValidationError, isTaleSdkError, createErrorFromUnknown, };
+let cached;
+let expiryTimer;
+let inFlight;
+let inFlightKey;
+function getEnv() {
+    return (globalThis?.process?.env ?? import.meta?.env ?? undefined);
+}
+function clearCache() {
+    cached = undefined;
+    if (expiryTimer) {
+        clearTimeout(expiryTimer);
+        expiryTimer = undefined;
+    }
+}
+function scheduleExpiry(expiredAt) {
+    const t = new Date(expiredAt).getTime();
+    const safetyMs = 10000;
+    const fallbackMs = 10 * 60 * 1000;
+    const now = Date.now();
+    // 修复时间戳溢出问题
+    let delay;
+    if (Number.isFinite(t)) {
+        const rawDelay = t - now - safetyMs;
+        // 检查是否在 32 位有符号整数范围内（-2^31 到 2^31-1，即 -2147483648 到 2147483647）
+        // Node.js setTimeout 的最大延迟值受限于系统，通常在 32 位范围内
+        const maxSafeDelay = 2147483647; // 最大 32 位有符号整数
+        if (rawDelay > maxSafeDelay) {
+            // 如果延迟时间过大，使用回退延迟
+            console.warn(`Token expiry delay too large (${rawDelay}ms), using fallback delay`);
+            delay = fallbackMs;
+        }
+        else {
+            delay = Math.max(rawDelay, 0);
+        }
+    }
+    else {
+        delay = fallbackMs;
+    }
+    if (expiryTimer)
+        clearTimeout(expiryTimer);
+    expiryTimer = setTimeout(clearCache, delay);
+    const unref = expiryTimer?.unref;
+    if (typeof unref === "function")
+        unref.call(expiryTimer);
+}
+async function fetchAppToken(options) {
+    const env = getEnv();
+    const base = options?.baseUrl ?? env?.TALE_BASE_URL ?? undefined;
+    const appKey = options?.appKey ?? env?.TALE_APP_KEY ?? undefined;
+    const appSecret = options?.appSecret ?? env?.TALE_APP_SECRET ?? undefined;
+    if (!base || !appKey || !appSecret) {
+        throw new ConfigurationError("Missing required environment variables: TALE_BASE_URL, TALE_APP_KEY, TALE_APP_SECRET");
+    }
+    const url = String(base).replace(/\/+$/, "") + "/app/v1/token";
+    let response;
+    try {
+        response = await globalThis.fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ app_key: appKey, app_secret: appSecret }),
+        });
+    }
+    catch (error) {
+        throw new ApiError(`Failed to fetch token: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = (await response.json());
+    if (json?.code !== 200 || !json?.data?.token) {
+        const errorMsg = typeof json?.msg === "string" ? json.msg : "Token request failed";
+        throw new ApiError(errorMsg, json?.code);
+    }
+    return json;
+}
+function isTokenValid(info) {
+    if (!info)
+        return false;
+    const t = new Date(info.expired_at).getTime();
+    return Number.isFinite(t) && t > Date.now();
+}
+function isServerEnv() {
+    const hasWindow = typeof globalThis.window !== "undefined" &&
+        typeof globalThis.window.document !== "undefined";
+    const hasNode = typeof globalThis.process !== "undefined" &&
+        !!globalThis.process.versions?.node;
+    return !hasWindow && hasNode;
+}
+export async function getAppToken(options) {
+    if (!isServerEnv()) {
+        throw new EnvironmentError("getAppToken is server-only");
+    }
+    if (isTokenValid(cached)) {
+        return cached.token;
+    }
+    const env = getEnv();
+    const base = options?.baseUrl ?? env?.TALE_BASE_URL ?? undefined;
+    const appKey = options?.appKey ?? env?.TALE_APP_KEY ?? undefined;
+    const appSecret = options?.appSecret ?? env?.TALE_APP_SECRET ?? undefined;
+    const reqKey = JSON.stringify([base, appKey, appSecret]);
+    if (!inFlight || inFlightKey !== reqKey) {
+        inFlight = fetchAppToken(options);
+        inFlightKey = reqKey;
+    }
+    try {
+        const json = await inFlight;
+        cached = json.data;
+        scheduleExpiry(cached.expired_at);
+        return cached.token;
+    }
+    finally {
+        inFlight = undefined;
+        inFlightKey = undefined;
+    }
+}