@turinhub/tale-js-sdk 1.3.0 → 2.0.0

package/dist/acl/types.d.ts

@@ -1,142 +1,107 @@
 import type { CommonOptions } from "../common/types.js";
-/**
- * ACL Record (Access Control List Record)
- * Represents a single access control rule
- */
 export interface AclRecord {
-    record_id: string;
-    app_id: string;
-    template_id?: string;
-    subject_type: string;
-    subject_id?: string;
-    subject_identifier?: string;
-    resource_type: string;
-    resource_id?: string;
-    resource_identifier?: string;
-    effect_type: string;
+    recordId: string;
+    appId: string;
+    templateId?: string;
+    subjectType: string;
+    subjectId?: string;
+    subjectIdentifier?: string;
+    resourceType: string;
+    resourceId?: string;
+    resourceIdentifier?: string;
+    effectType: string;
     priority?: number;
-    data_scope?: Record<string, unknown>;
+    dataScope?: Record<string, unknown>;
     description?: string;
-    created_at: string;
-    updated_at: string;
+    createdAt: string;
+    updatedAt: string;
 }
-/**
- * Request for creating an ACL record
- */
 export interface CreateAclRecordRequest {
-    template_id?: string;
-    subject_type: string;
-    subject_id?: string;
-    subject_identifier?: string;
-    resource_type: string;
-    resource_id?: string;
-    resource_identifier?: string;
-    effect_type: string;
+    templateId?: string;
+    subjectType: string;
+    subjectId?: string;
+    subjectIdentifier?: string;
+    resourceType: string;
+    resourceId?: string;
+    resourceIdentifier?: string;
+    effectType: string;
     priority?: number;
-    data_scope?: Record<string, unknown>;
+    dataScope?: Record<string, unknown>;
     description?: string;
 }
-/**
- * Request for updating an ACL record
- */
 export interface UpdateAclRecordRequest {
-    template_id?: string;
-    effect_type?: string;
+    templateId?: string;
+    effectType?: string;
     priority?: number;
-    data_scope?: Record<string, unknown>;
+    dataScope?: Record<string, unknown>;
     description?: string;
 }
-/**
- * Request for listing ACL records
- */
 export interface ListAclRecordsRequest {
     page?: number;
     size?: number;
     sort?: string;
-    template_id?: string;
-    subject_type?: string;
-    subject_id?: string;
-    subject_identifier?: string;
-    resource_type?: string;
-    resource_id?: string;
-    resource_identifier?: string;
+    templateId?: string;
+    subjectType?: string;
+    subjectId?: string;
+    subjectIdentifier?: string;
+    resourceType?: string;
+    resourceId?: string;
+    resourceIdentifier?: string;
 }
-/**
- * Batch creation response for ACL records
- */
 export interface AclBatchCreateResponse {
-    success_count: number;
-    failure_count: number;
-    success_records: AclRecord[];
+    successCount: number;
+    failureCount: number;
+    successRecords: AclRecord[];
     failures: AclBatchFailure[];
 }
-/**
- * Failure details for batch creation
- */
 export interface AclBatchFailure {
     index: number;
     request: CreateAclRecordRequest;
-    error_message: string;
+    errorMessage: string;
 }
-/**
- * ACL Template
- * Represents a reusable ACL configuration template
- */
 export interface AclTemplate {
-    template_id: string;
-    app_id: string;
-    template_name: string;
-    template_code: string;
-    subject_type?: string;
-    subject_filter?: Record<string, unknown>;
-    resource_type?: string;
-    resource_filter?: Record<string, unknown>;
-    effect_type?: string;
+    templateId: string;
+    appId: string;
+    templateName: string;
+    templateCode: string;
+    subjectType?: string;
+    subjectFilter?: Record<string, unknown>;
+    resourceType?: string;
+    resourceFilter?: Record<string, unknown>;
+    effectType?: string;
     priority?: number;
-    data_scope?: Record<string, unknown>;
+    dataScope?: Record<string, unknown>;
     description?: string;
-    created_at: string;
-    updated_at: string;
+    createdAt: string;
+    updatedAt: string;
 }
-/**
- * Request for creating an ACL template
- */
 export interface CreateAclTemplateRequest {
-    template_name: string;
-    template_code: string;
-    subject_type?: string;
-    subject_filter?: Record<string, unknown>;
-    resource_type?: string;
-    resource_filter?: Record<string, unknown>;
-    effect_type?: string;
+    templateName: string;
+    templateCode: string;
+    subjectType?: string;
+    subjectFilter?: Record<string, unknown>;
+    resourceType?: string;
+    resourceFilter?: Record<string, unknown>;
+    effectType?: string;
     priority?: number;
-    data_scope?: Record<string, unknown>;
+    dataScope?: Record<string, unknown>;
     description?: string;
 }
-/**
- * Request for updating an ACL template
- */
 export interface UpdateAclTemplateRequest {
-    template_name?: string;
-    subject_filter?: Record<string, unknown>;
-    resource_filter?: Record<string, unknown>;
-    effect_type?: string;
+    templateName?: string;
+    subjectFilter?: Record<string, unknown>;
+    resourceFilter?: Record<string, unknown>;
+    effectType?: string;
     priority?: number;
-    data_scope?: Record<string, unknown>;
+    dataScope?: Record<string, unknown>;
     description?: string;
 }
-/**
- * Request for listing ACL templates
- */
 export interface ListAclTemplatesRequest {
     page?: number;
     size?: number;
     sort?: string;
-    resource_type?: string;
-    subject_type?: string;
+    resourceType?: string;
+    subjectType?: string;
 }
-/**
- * Options for ACL operations
- */
 export interface AclOptions extends CommonOptions {
 }

package/dist/attachment/index.d.ts

@@ -0,0 +1,17 @@
+import type { PageResponse } from "../common/types.js";
+import type { Attachment, ListAttachmentsByRefRequest, UploadAttachmentRequest, UploadAuthorizationRequest, UploadAuthorizationResponse, CompleteUploadRequest, DeleteAttachmentRequest, DownloadAttachmentUrlRequest, DownloadUrlResponse, AttachmentOptions } from "./types.js";
+export type { AttachmentRefType, Attachment, ListAttachmentsByRefRequest, UploadAttachmentRequest, UploadAuthorizationRequest, UploadAuthorizationResponse, CompleteUploadRequest, DeleteAttachmentRequest, DownloadAttachmentUrlRequest, DownloadUrlResponse, AttachmentOptions, } from "./types.js";
+/** Get attachment by ID */
+export declare function getAttachment(attachmentId: string, options?: AttachmentOptions): Promise<Attachment>;
+/** List attachments by reference */
+export declare function listAttachmentsByRef(request: ListAttachmentsByRefRequest & AttachmentOptions): Promise<PageResponse<Attachment>>;
+/** Upload attachment directly (multipart) */
+export declare function uploadAttachment(request: UploadAttachmentRequest & AttachmentOptions): Promise<Attachment>;
+/** Delete attachment */
+export declare function deleteAttachment(request: DeleteAttachmentRequest & AttachmentOptions): Promise<void>;
+/** Get upload URL for two-phase upload */
+export declare function getAttachmentUploadUrl(request: UploadAuthorizationRequest & AttachmentOptions): Promise<UploadAuthorizationResponse>;
+/** Complete two-phase upload */
+export declare function completeAttachmentUpload(attachmentId: string, request: CompleteUploadRequest, options?: AttachmentOptions): Promise<Attachment>;
+/** Get download URL */
+export declare function getAttachmentDownloadUrl(request: DownloadAttachmentUrlRequest & AttachmentOptions): Promise<DownloadUrlResponse>;

package/dist/attachment/index.js

@@ -0,0 +1,247 @@
+import { getAppToken } from "../token.js";
+import { ApiError, ConfigurationError, NetworkError } from "../errors.js";
+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 assertRequiredString(value, fieldName) {
+    if (!value || value.trim() === "") {
+        throw new ApiError(`${fieldName} is required`, 400, "9400");
+    }
+}
+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(/\/+$/, "");
+}
+/** Get attachment by ID */
+export async function getAttachment(attachmentId, options) {
+    assertRequiredString(attachmentId, "attachmentId");
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base + `/attachment/v2/attachments/${encodeURIComponent(attachmentId)}`);
+    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 attachment: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to get attachment", response.status);
+}
+/** List attachments by reference */
+export async function listAttachmentsByRef(request) {
+    assertRequiredString(request?.refType, "refType");
+    assertRequiredString(request?.refId, "refId");
+    const token = request.appToken ?? (await getAppToken(request));
+    const base = getBaseUrl(request);
+    const url = new URL(base + "/attachment/v2/attachments/by-ref");
+    const { appToken, baseUrl, refType, refId, ...pagination } = request;
+    url.searchParams.append("refType", refType);
+    url.searchParams.append("refId", refId);
+    const queryParams = {
+        page: 0,
+        size: 20,
+        sort: "createdAt,desc",
+        ...pagination,
+    };
+    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 attachments: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to list attachments", response.status);
+}
+/** Upload attachment directly (multipart) */
+export async function uploadAttachment(request) {
+    assertRequiredString(request?.attachmentTypeId, "attachmentTypeId");
+    assertRequiredString(request?.refType, "refType");
+    assertRequiredString(request?.refId, "refId");
+    if (!request?.file) {
+        throw new ApiError("file is required", 400, "9400");
+    }
+    const { appToken, baseUrl, attachmentTypeId, refType, refId, file, remark } = request;
+    const token = appToken ?? (await getAppToken(request));
+    const base = getBaseUrl(request);
+    const url = new URL(base + "/attachment/v2/attachments");
+    const formData = new FormData();
+    formData.append("attachmentTypeId", attachmentTypeId);
+    formData.append("refType", refType);
+    formData.append("refId", refId);
+    if (remark) {
+        formData.append("remark", remark);
+    }
+    if (typeof File !== "undefined" && file instanceof File) {
+        formData.append("file", file, file.name);
+    }
+    else {
+        formData.append("file", file);
+    }
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "POST",
+            headers: {
+                "x-t-token": token,
+            },
+            body: formData,
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to upload attachment: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to upload attachment", response.status);
+}
+/** Delete attachment */
+export async function deleteAttachment(request) {
+    assertRequiredString(request?.attachmentId, "attachmentId");
+    assertRequiredString(request?.refType, "refType");
+    assertRequiredString(request?.refId, "refId");
+    const { appToken, baseUrl, attachmentId, refType, refId } = request;
+    const token = appToken ?? (await getAppToken(request));
+    const base = getBaseUrl(request);
+    const url = new URL(base + `/attachment/v2/attachments/${encodeURIComponent(attachmentId)}`);
+    url.searchParams.append("refType", refType);
+    url.searchParams.append("refId", refId);
+    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 attachment: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = (await response.json());
+    if (json.code !== 200) {
+        const errorMsg = typeof json.msg === "string" ? json.msg : "Failed to delete attachment";
+        throw new ApiError(errorMsg, response.status, json.code);
+    }
+}
+/** Get upload URL for two-phase upload */
+export async function getAttachmentUploadUrl(request) {
+    assertRequiredString(request?.refType, "refType");
+    assertRequiredString(request?.attachmentTypeId, "attachmentTypeId");
+    assertRequiredString(request?.refId, "refId");
+    assertRequiredString(request?.fileName, "fileName");
+    assertRequiredString(request?.fileType, "fileType");
+    const { appToken, baseUrl, ...body } = request;
+    const token = appToken ?? (await getAppToken(request));
+    const base = getBaseUrl(request);
+    const url = new URL(base + "/attachment/v2/attachments/upload-url");
+    let response;
+    try {
+        response = await globalThis.fetch(url.toString(), {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                "x-t-token": token,
+            },
+            body: JSON.stringify(body),
+        });
+    }
+    catch (error) {
+        throw new NetworkError(`Failed to get upload URL: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to get upload URL", response.status);
+}
+/** Complete two-phase upload */
+export async function completeAttachmentUpload(attachmentId, request, options) {
+    assertRequiredString(attachmentId, "attachmentId");
+    assertRequiredString(request?.refType, "refType");
+    assertRequiredString(request?.refId, "refId");
+    assertRequiredString(request?.ossKey, "ossKey");
+    if (!request || request.fileSize === undefined || request.fileSize === null) {
+        throw new ApiError("fileSize is required", 400, "9400");
+    }
+    assertRequiredString(request.etag, "etag");
+    const token = options?.appToken ?? (await getAppToken(options));
+    const base = getBaseUrl(options);
+    const url = new URL(base +
+        `/attachment/v2/attachments/${encodeURIComponent(attachmentId)}/complete`);
+    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 complete upload: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to complete upload", response.status);
+}
+/** Get download URL */
+export async function getAttachmentDownloadUrl(request) {
+    assertRequiredString(request?.attachmentId, "attachmentId");
+    assertRequiredString(request?.refType, "refType");
+    assertRequiredString(request?.refId, "refId");
+    const { appToken, baseUrl, attachmentId, refType, refId, expiresInSeconds = 3600, } = request;
+    const token = appToken ?? (await getAppToken(request));
+    const base = getBaseUrl(request);
+    const url = new URL(base +
+        `/attachment/v2/attachments/${encodeURIComponent(attachmentId)}/download-url`);
+    url.searchParams.append("refType", refType);
+    url.searchParams.append("refId", refId);
+    url.searchParams.append("expiresInSeconds", String(expiresInSeconds));
+    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 download URL: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    const json = await response.json();
+    return parseApiResponse(json, "Failed to get download URL", response.status);
+}

package/dist/attachment/types.d.ts

@@ -0,0 +1,82 @@
+import type { CommonOptions } from "../common/types.js";
+/** Discriminator for the domain entity an attachment belongs to. */
+export type AttachmentRefType = "task" | "cms_file" | "acl_record";
+export interface Attachment {
+    attachmentId: string;
+    appId: string;
+    typeId: string;
+    refId: string;
+    refType: string;
+    fileName: string;
+    fileOriginalName: string;
+    fileExtension: string;
+    fileOssKey: string;
+    fileSize: number;
+    fileHash: string;
+    mimeType: string;
+    uploadStatus: string;
+    sortOrder: number;
+    remark?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface ListAttachmentsByRefRequest {
+    refType: AttachmentRefType;
+    refId: string;
+    page?: number;
+    size?: number;
+    sort?: string;
+}
+export interface UploadAttachmentRequest {
+    attachmentTypeId: string;
+    refType: AttachmentRefType;
+    refId: string;
+    file: File | Blob;
+    remark?: string;
+}
+export interface UploadAuthorizationRequest {
+    attachmentTypeId: string;
+    refType: AttachmentRefType;
+    refId: string;
+    fileName: string;
+    fileType: string;
+    mimeType?: string;
+    fileSize?: number;
+    remark?: string;
+    expireTimeInSeconds?: number;
+}
+export interface UploadAuthorizationResponse {
+    attachmentId: string;
+    ossKey: string;
+    uploadUrl: string;
+    fileName: string;
+    fileType: string;
+    expiresInSeconds: number;
+}
+export interface CompleteUploadRequest {
+    refType: AttachmentRefType;
+    refId: string;
+    ossKey: string;
+    fileSize: number;
+    etag: string;
+}
+export interface DeleteAttachmentRequest {
+    attachmentId: string;
+    refType: AttachmentRefType;
+    refId: string;
+}
+export interface DownloadAttachmentUrlRequest {
+    attachmentId: string;
+    refType: AttachmentRefType;
+    refId: string;
+    expiresInSeconds?: number;
+}
+export interface DownloadUrlResponse {
+    attachmentId: string;
+    fileName: string;
+    ossKey: string;
+    downloadUrl: string;
+    expiresInSeconds: number;
+}
+export interface AttachmentOptions extends CommonOptions {
+}

package/dist/attachment/types.js

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

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

@@ -0,0 +1,15 @@
+import type { PageResponse } from "../common/types.js";
+import type { AttachmentType, CreateAttachmentTypeRequest, UpdateAttachmentTypeRequest, ListAttachmentTypesRequest, ListAttachmentTypesByRefRequest, AttachmentTypeOptions } from "./types.js";
+export type { AttachmentRefType, AttachmentType, CreateAttachmentTypeRequest, UpdateAttachmentTypeRequest, ListAttachmentTypesRequest, ListAttachmentTypesByRefRequest, AttachmentTypeOptions, } from "./types.js";
+/** List attachment types */
+export declare function listAttachmentTypes(request?: ListAttachmentTypesRequest & AttachmentTypeOptions): Promise<PageResponse<AttachmentType>>;
+/** List attachment types by reference */
+export declare function listAttachmentTypesByRef(request: ListAttachmentTypesByRefRequest & AttachmentTypeOptions): Promise<PageResponse<AttachmentType>>;
+/** Get attachment type by ID */
+export declare function getAttachmentType(typeId: string, options?: AttachmentTypeOptions): Promise<AttachmentType>;
+/** Create attachment type */
+export declare function createAttachmentType(request: CreateAttachmentTypeRequest, options?: AttachmentTypeOptions): Promise<AttachmentType>;
+/** Update attachment type */
+export declare function updateAttachmentType(typeId: string, request: UpdateAttachmentTypeRequest, options?: AttachmentTypeOptions): Promise<AttachmentType>;
+/** Delete attachment type */
+export declare function deleteAttachmentType(typeId: string, options?: AttachmentTypeOptions): Promise<void>;