@turinhub/tale-js-sdk 1.3.0 → 2.1.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/app/index.d.ts

@@ -0,0 +1,10 @@
+import type { AppDetail, AppInfo, AppUserLike, CommonOptions, CreateAppRequest, CreateAppResponse, CurrentAppUser, UpdateAppRequest } from "./types.js";
+export type { AppDetail, AppDetailResponse, AppInfo, AppPrivilege, AppRole, AppUserLike, CommonOptions, CreateAppRequest, CreateAppResponse, CurrentAppUser, UpdateAppRequest, } from "./types.js";
+export declare function normalizeAppInfo(value: unknown): AppInfo;
+export declare function normalizeAppDetail(value: unknown): AppDetail;
+export declare function normalizeCurrentAppUser(value: unknown): CurrentAppUser;
+export declare function getCurrentUser(options?: CommonOptions): Promise<AppUserLike>;
+export declare function listAppsByOrg(orgId: string, options?: CommonOptions): Promise<AppInfo[]>;
+export declare function createApp(request: CreateAppRequest, options?: CommonOptions): Promise<CreateAppResponse>;
+export declare function getAppDetail(appKey: string, options?: CommonOptions): Promise<AppDetail>;
+export declare function updateApp(request: UpdateAppRequest, options?: CommonOptions): Promise<AppDetail>;

package/dist/app/index.js

@@ -0,0 +1,198 @@
+import { assertRequiredString, pickBoolean, pickString, requestJson, toRecord, } from "../common/http.js";
+function normalizeRole(value) {
+    const role = toRecord(value);
+    return {
+        roleId: pickString(role.roleId),
+        roleName: pickString(role.roleName),
+        roleType: pickString(role.roleType) || undefined,
+        roleProperty: toRecord(role.roleProperty),
+        roleConfig: toRecord(role.roleConfig),
+        rolePrivileges: Array.isArray(role.rolePrivileges)
+            ? role.rolePrivileges.map(normalizePrivilege)
+            : undefined,
+        privilegeIds: Array.isArray(role.privilegeIds)
+            ? role.privilegeIds.map(String)
+            : undefined,
+        resourceIds: Array.isArray(role.resourceIds)
+            ? role.resourceIds.map(String)
+            : undefined,
+        expiredAt: pickString(role.expiredAt) || undefined,
+        remark: pickString(role.remark) || undefined,
+    };
+}
+function normalizePrivilege(value) {
+    const privilege = toRecord(value);
+    return {
+        privilegeId: pickString(privilege.privilegeId),
+        privilegeName: pickString(privilege.privilegeName),
+        privilegeType: pickString(privilege.privilegeType) || undefined,
+        privilegeProperty: toRecord(privilege.privilegeProperty),
+        privilegeConfig: toRecord(privilege.privilegeConfig),
+        resourceIds: Array.isArray(privilege.resourceIds)
+            ? privilege.resourceIds.map(String)
+            : undefined,
+        expiredAt: pickString(privilege.expiredAt) || undefined,
+        remark: pickString(privilege.remark) || undefined,
+    };
+}
+function normalizeUserGroup(value) {
+    const group = toRecord(value);
+    return {
+        groupId: pickString(group.groupId),
+        name: pickString(group.name, group.groupName),
+        description: pickString(group.description) || undefined,
+        type: pickString(group.type) || undefined,
+        remark: pickString(group.remark) || undefined,
+    };
+}
+export function normalizeAppInfo(value) {
+    const app = toRecord(value);
+    const appKey = pickString(app.appKey);
+    const appName = pickString(app.appName, app.name);
+    const appId = pickString(app.appId, app.id);
+    return {
+        appId,
+        appKey,
+        appName,
+        id: pickString(app.id, appId, appKey),
+        name: pickString(app.name, appName, appKey),
+        description: pickString(app.description, app.remark) || undefined,
+        icon: pickString(app.icon) || undefined,
+        plan: pickString(app.plan) || undefined,
+        orgId: pickString(app.orgId) || undefined,
+        appProperty: toRecord(app.appProperty),
+        appConfig: toRecord(app.appConfig),
+        appAdmins: toRecord(app.appAdmins),
+        roleConfig: toRecord(app.roleConfig),
+        userGroupConfig: toRecord(app.userGroupConfig),
+        createdAt: pickString(app.createdAt) || undefined,
+        updatedAt: pickString(app.updatedAt) || undefined,
+        remark: pickString(app.remark) || undefined,
+    };
+}
+function normalizeAppRole(value) {
+    return normalizeRole(value);
+}
+function normalizeAppPrivilege(value) {
+    return normalizePrivilege(value);
+}
+export function normalizeAppDetail(value) {
+    const app = toRecord(value);
+    const info = normalizeAppInfo(app);
+    return {
+        ...info,
+        appRoles: Array.isArray(app.appRoles)
+            ? app.appRoles.map(normalizeAppRole)
+            : [],
+        appPrivileges: Array.isArray(app.appPrivileges)
+            ? app.appPrivileges.map(normalizeAppPrivilege)
+            : [],
+        wechatConfig: toRecord(app.wechatConfig),
+        feishuConfig: toRecord(app.feishuConfig),
+        openaiConfig: toRecord(app.openaiConfig),
+    };
+}
+export function normalizeCurrentAppUser(value) {
+    const payload = toRecord(value);
+    const app = toRecord(payload.app);
+    const user = toRecord(payload.user);
+    return {
+        app: {
+            appName: pickString(app.appName),
+            appKey: pickString(app.appKey),
+            orgId: pickString(app.orgId, payload.orgId),
+            appId: pickString(app.appId),
+        },
+        user: {
+            latestLoginTime: pickString(user.latestLoginTime) || undefined,
+            registeredAt: pickString(user.registeredAt) || undefined,
+            isFrozen: pickBoolean(user.isFrozen),
+            userId: pickString(user.userId, payload.userId),
+            phone: pickString(user.phone) || undefined,
+            username: pickString(user.username) || undefined,
+            email: pickString(user.email) || undefined,
+            nickname: pickString(user.nickname) || undefined,
+            remark: pickString(user.remark) || undefined,
+            avatarUrl: pickString(user.avatarUrl) || undefined,
+        },
+        thirdParty: toRecord(payload.thirdParty),
+        userRoles: Array.isArray(payload.userRoles)
+            ? payload.userRoles.map(normalizeRole)
+            : [],
+        userPrivileges: Array.isArray(payload.userPrivileges)
+            ? payload.userPrivileges.map(normalizePrivilege)
+            : [],
+        userGroups: Array.isArray(payload.userGroups)
+            ? payload.userGroups.map(normalizeUserGroup)
+            : [],
+    };
+}
+function normalizeCreateAppResponse(value) {
+    const app = toRecord(value);
+    return {
+        appId: pickString(app.appId, app.id),
+        appName: pickString(app.appName, app.name),
+        orgId: pickString(app.orgId),
+        appKey: pickString(app.appKey),
+        createdAt: pickString(app.createdAt) || undefined,
+    };
+}
+function toUpdateAppPayload(request) {
+    return {
+        appId: request.appId,
+        appName: request.appName,
+        remark: request.remark,
+        appProperty: request.appProperty,
+        appConfig: request.appConfig,
+        wechatConfig: request.wechatConfig,
+        appAdmins: request.appAdmins,
+        roleConfig: request.roleConfig,
+        userGroupConfig: request.userGroupConfig,
+        feishuConfig: request.feishuConfig,
+        openaiConfig: request.openaiConfig,
+    };
+}
+export async function getCurrentUser(options) {
+    const payload = await requestJson("/account/v2/user", options, {
+        authMode: "taleToken",
+        errorMessage: "Failed to get current user",
+    });
+    return normalizeCurrentAppUser(payload);
+}
+export async function listAppsByOrg(orgId, options) {
+    assertRequiredString(orgId, "orgId");
+    const payload = await requestJson(`/app/v2/org/${encodeURIComponent(orgId)}/apps`, options, {
+        authMode: "taleToken",
+        errorMessage: "Failed to list apps",
+    });
+    return Array.isArray(payload) ? payload.map(normalizeAppInfo) : [];
+}
+export async function createApp(request, options) {
+    assertRequiredString(request?.appName, "appName");
+    assertRequiredString(request?.orgId, "orgId");
+    const payload = await requestJson("/app/v2/app", options, {
+        method: "POST",
+        body: request,
+        authMode: "taleToken",
+        errorMessage: "Failed to create app",
+    });
+    return normalizeCreateAppResponse(payload);
+}
+export async function getAppDetail(appKey, options) {
+    assertRequiredString(appKey, "appKey");
+    const payload = await requestJson(`/app/v2/app/${encodeURIComponent(appKey)}`, options, {
+        authMode: "taleToken",
+        errorMessage: "Failed to get app detail",
+    });
+    return normalizeAppDetail(payload);
+}
+export async function updateApp(request, options) {
+    assertRequiredString(request?.appId, "appId");
+    const payload = await requestJson("/app/v2/app", options, {
+        method: "PUT",
+        body: toUpdateAppPayload(request),
+        authMode: "taleToken",
+        errorMessage: "Failed to update app",
+    });
+    return normalizeAppDetail(payload);
+}

package/dist/app/types.d.ts

@@ -0,0 +1,101 @@
+import type { CommonOptions, Privilege, Role, UserGroup } from "../common/types.js";
+export type { CommonOptions, Privilege, Role, UserGroup };
+export interface AppInfo {
+    appId: string;
+    appKey: string;
+    appName: string;
+    id: string;
+    name: string;
+    description?: string;
+    icon?: string;
+    plan?: string;
+    orgId?: string;
+    appProperty?: Record<string, unknown>;
+    appConfig?: Record<string, unknown>;
+    appAdmins?: Record<string, unknown>;
+    roleConfig?: Record<string, unknown>;
+    userGroupConfig?: Record<string, unknown>;
+    createdAt?: string;
+    updatedAt?: string;
+    remark?: string;
+}
+export interface CreateAppRequest {
+    appName: string;
+    orgId: string;
+    remark?: string;
+}
+export interface CreateAppResponse {
+    appId: string;
+    appName: string;
+    orgId: string;
+    appKey: string;
+    createdAt?: string;
+}
+export interface UpdateAppRequest {
+    appId: string;
+    appName?: string;
+    remark?: string;
+    appProperty?: Record<string, unknown>;
+    appConfig?: Record<string, unknown>;
+    wechatConfig?: Record<string, unknown>;
+    appAdmins?: Record<string, unknown>;
+    roleConfig?: Record<string, unknown>;
+    userGroupConfig?: Record<string, unknown>;
+    feishuConfig?: Record<string, unknown>;
+    openaiConfig?: Record<string, unknown>;
+}
+export interface AppRole {
+    roleId: string;
+    roleName: string;
+    roleType?: string;
+    roleProperty?: Record<string, unknown>;
+    roleConfig?: Record<string, unknown>;
+    expiredAt?: string;
+    remark?: string;
+}
+export interface AppPrivilege {
+    privilegeId: string;
+    privilegeName: string;
+    privilegeType?: string;
+    privilegeProperty?: Record<string, unknown>;
+    privilegeConfig?: Record<string, unknown>;
+    expiredAt?: string;
+    remark?: string;
+}
+export interface AppDetail extends AppInfo {
+    appRoles: AppRole[];
+    appPrivileges: AppPrivilege[];
+    wechatConfig?: Record<string, unknown>;
+    feishuConfig?: Record<string, unknown>;
+    openaiConfig?: Record<string, unknown>;
+}
+export interface AppDetailResponse {
+    data: AppDetail;
+    code: number;
+    msg: string;
+}
+export interface CurrentAppUser {
+    app: {
+        appName: string;
+        appKey: string;
+        orgId: string;
+        appId: string;
+    };
+    user: {
+        latestLoginTime?: string;
+        registeredAt?: string;
+        isFrozen?: boolean;
+        userId: string;
+        phone?: string;
+        username?: string;
+        email?: string;
+        nickname?: string;
+        remark?: string;
+        avatarUrl?: string;
+    };
+    thirdParty: Record<string, unknown>;
+    userRoles: Role[];
+    userPrivileges: Privilege[];
+    userGroups: UserGroup[];
+}
+export type AppUserLike = CurrentAppUser;

package/dist/app/types.js

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

package/dist/app-token/index.d.ts

@@ -0,0 +1,7 @@
+import type { PageResponse } from "../common/types.js";
+import type { AppToken, CommonOptions, IssueAppTokenRequest, IssueAppTokenResponse, ListAppTokensRequest } from "./types.js";
+export type { AppSecretResponse, AppToken, CommonOptions, IssueAppTokenRequest, IssueAppTokenResponse, ListAppTokensRequest, PageResponse, } from "./types.js";
+export declare function normalizeAppToken(value: unknown): AppToken;
+export declare function listAppTokens(request?: ListAppTokensRequest & CommonOptions): Promise<PageResponse<AppToken>>;
+export declare function getAppSecret(appKey: string, options?: CommonOptions): Promise<string>;
+export declare function issueAppToken(request: IssueAppTokenRequest): Promise<IssueAppTokenResponse>;

package/dist/app-token/index.js

@@ -0,0 +1,58 @@
+import { assertRequiredString, normalizePageResponse, pickString, requestJson, toRecord, } from "../common/http.js";
+export function normalizeAppToken(value) {
+    const token = toRecord(value);
+    return {
+        type: pickString(token.type),
+        appKey: pickString(token.appKey),
+        token: pickString(token.token),
+        status: pickString(token.status),
+        expiredAt: pickString(token.expiredAt),
+    };
+}
+function toListQuery(request) {
+    if (!request) {
+        return undefined;
+    }
+    const sortProperty = request.sort === "expiredAt" ? "expiredTime" : request.sort;
+    const sort = sortProperty && request.sortDirection
+        ? `${sortProperty},${request.sortDirection}`
+        : sortProperty;
+    return {
+        page: request.page,
+        size: request.size,
+        isValid: request.isValid,
+        sort,
+        search: request.search,
+    };
+}
+export async function listAppTokens(request) {
+    const { appToken, taleToken, baseUrl, ...listRequest } = request ?? {};
+    const payload = await requestJson("/app/v2/app/tokens", request, {
+        query: toListQuery(listRequest),
+        errorMessage: "Failed to list app tokens",
+    });
+    return normalizePageResponse(payload, normalizeAppToken);
+}
+export async function getAppSecret(appKey, options) {
+    assertRequiredString(appKey, "appKey");
+    const payload = await requestJson(`/app/v2/app/${encodeURIComponent(appKey)}/secret`, options, {
+        authMode: "taleToken",
+        errorMessage: "Failed to get app secret",
+    });
+    const response = toRecord(payload);
+    const appSecret = pickString(response.appSecret);
+    if (!appSecret) {
+        return pickString(payload);
+    }
+    return appSecret;
+}
+export async function issueAppToken(request) {
+    assertRequiredString(request?.appKey, "appKey");
+    const { appKey, ...options } = request;
+    const payload = await requestJson("/app/v2/token/by-appkey", options, {
+        query: { appKey },
+        authMode: "taleToken",
+        errorMessage: "Failed to issue app token",
+    });
+    return normalizeAppToken(payload);
+}

package/dist/app-token/types.d.ts

@@ -0,0 +1,25 @@
+import type { CommonOptions } from "../common/types.js";
+export type { CommonOptions, PageResponse } from "../common/types.js";
+export interface AppToken {
+    type: string;
+    appKey: string;
+    token: string;
+    status: string;
+    expiredAt: string;
+}
+export interface ListAppTokensRequest {
+    page?: number;
+    size?: number;
+    isValid?: boolean;
+    sort?: string;
+    sortDirection?: "asc" | "desc" | "ASC" | "DESC";
+    search?: string;
+}
+export interface AppSecretResponse {
+    appSecret: string;
+}
+export interface IssueAppTokenRequest extends CommonOptions {
+    appKey: string;
+}
+export interface IssueAppTokenResponse extends AppToken {
+}

package/dist/app-token/types.js

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

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>;