@xezzon/zeroweb-sdk 0.9.0 → 0.10.0

package/dist/{typings/index.d.ts → index.d.ts}

@@ -1,10 +1,10 @@
-export { default as ZerowebMetadataClient, MenuType, ServiceType, } from './metadata';
+export { default as ZerowebMetadataClient, MenuType, ServiceType } from './metadata';
 export type * from './metadata';
 export { default as ZerowebAdminClient } from './admin';
 export type * from './admin';
-export { default as ZerowebOpenClient, OpenapiStatus, SubscriptionStatus, } from './open';
+export { default as ZerowebOpenClient, OpenapiStatus, SubscriptionStatus } from './open';
 export type * from './open';
-export { default as ZerowebFileClient, FileProvider, AttachmentStatus, } from './file';
+export { default as ZerowebFileClient, checksum, FileProvider, AttachmentStatus } from './file';
 export type * from './file';
 export { default as ZerowebDevClient } from './dev';
 export type * from './dev';

package/dist/index.mjs

@@ -0,0 +1,644 @@
+import axios from "axios";
+import crypto_js from "crypto-js";
+import { crc32 } from "js-crc";
+var types_ErrorSource = /*#__PURE__*/ function(ErrorSource) {
+    ErrorSource[ErrorSource["NETWORK"] = 1] = "NETWORK";
+    ErrorSource[ErrorSource["INFRA"] = 2] = "INFRA";
+    ErrorSource[ErrorSource["INTERNAL"] = 3] = "INTERNAL";
+    ErrorSource[ErrorSource["BAD_REQUEST"] = 4] = "BAD_REQUEST";
+    return ErrorSource;
+}({});
+const ERROR_CODE_HEADER = 'x-error-code';
+const ErrorCodeEnum = {
+    ARGUMENT_INVALID: 'C0005'
+};
+function zerowebErrorHandler(error) {
+    const response = error.response;
+    if (!response) {
+        error.source = types_ErrorSource.NETWORK;
+        return Promise.reject(error);
+    }
+    const errorCode = response.headers[ERROR_CODE_HEADER];
+    if (!errorCode) {
+        error.source = types_ErrorSource.INFRA;
+        return Promise.reject(error);
+    }
+    error.errorCode = errorCode;
+    const responseBody = response.data;
+    if (response.status >= 500) {
+        error.source = types_ErrorSource.INTERNAL;
+        error.message = responseBody.message;
+        return Promise.reject(error);
+    }
+    error.source = types_ErrorSource.BAD_REQUEST;
+    if (errorCode !== ErrorCodeEnum.ARGUMENT_INVALID) error.notification = responseBody.message;
+    error.parameters = responseBody.parameters;
+    error.details = responseBody.details;
+    return Promise.reject(error);
+}
+var metadata_ServiceType = /*#__PURE__*/ function(ServiceType) {
+    ServiceType["CLIENT"] = "CLIENT";
+    ServiceType["SERVER"] = "SERVER";
+    return ServiceType;
+}({});
+var metadata_MenuType = /*#__PURE__*/ function(MenuType) {
+    MenuType["ROUTE"] = "ROUTE";
+    MenuType["EXTERNAL_LINK"] = "EXTERNAL_LINK";
+    MenuType["EMBEDDED"] = "EMBEDDED";
+    MenuType["PERMISSION"] = "PERMISSION";
+    MenuType["GROUP_PERMISSION"] = "GROUP_PERMISSION";
+    return MenuType;
+}({});
+const metadata = (config)=>{
+    const instance = axios.create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    return {
+        interceptors,
+        loadServiceInfo () {
+            return instance.request({
+                url: '/metadata/info.json',
+                method: 'GET'
+            });
+        },
+        loadResourceInfo () {
+            return instance.request({
+                url: '/metadata/menu.json',
+                method: 'GET'
+            });
+        }
+    };
+};
+const admin_app = (client)=>({
+        addApp: (app)=>client.request({
+                url: '/app',
+                method: 'POST',
+                data: app
+            }),
+        listApp: ()=>client.request({
+                url: '/app',
+                method: 'GET'
+            }),
+        queryAppById: (id)=>client.request({
+                url: `/app/${id}`,
+                method: 'GET'
+            }),
+        updateApp: (app)=>client.request({
+                url: '/app',
+                method: 'PUT',
+                data: app
+            }),
+        deleteApp: (id)=>client.request({
+                url: `/app/${id}`,
+                method: 'DELETE'
+            })
+    });
+const authn = (client)=>({
+        basicLogin: (user)=>client.request({
+                url: '/auth/login/basic',
+                method: 'POST',
+                auth: {
+                    username: user.username,
+                    password: user.password
+                },
+                data: user
+            }),
+        self: ()=>client.request({
+                url: '/auth/self',
+                method: 'GET'
+            }),
+        token: ()=>client.request({
+                url: '/auth/token',
+                method: 'GET'
+            }),
+        logout: ()=>client.request({
+                url: '/auth/logout',
+                method: 'PUT'
+            })
+    });
+const authz = (client)=>({
+        queryUserByRole: (roleId)=>client.request({
+                url: `/auth/role/${roleId}/user`,
+                method: 'GET'
+            }),
+        bindUserToRole: (roleUsers)=>client.request({
+                url: '/auth/role/-/user',
+                method: 'PUT',
+                data: roleUsers
+            }),
+        releaseRoleUser: (roleUsers)=>client.request({
+                url: '/auth/role/-/user',
+                method: 'DELETE',
+                data: roleUsers
+            }),
+        queryPermissionByRole: (roleId)=>client.request({
+                url: `/auth/role/${roleId}/permission`,
+                method: 'GET'
+            }),
+        bindPermissionToRole: (rolePermissions)=>client.request({
+                url: '/auth/role/-/permission',
+                method: 'PUT',
+                data: rolePermissions
+            }),
+        releaseRolePermission: (rolePermissions)=>client.request({
+                url: '/auth/role/-/permission',
+                method: 'DELETE',
+                data: rolePermissions
+            }),
+        queryRoleByUser: (userId)=>client.request({
+                url: `/auth/user/${userId}/role`,
+                method: 'GET'
+            }),
+        queryRoleByPermission: (permission)=>client.request({
+                url: '/auth/permission/-/role',
+                method: 'GET',
+                params: {
+                    permission
+                }
+            })
+    });
+const admin_crypto = ({ request })=>({
+        passwordStrength: (password, { username })=>request({
+                url: '/password-strength',
+                method: 'GET',
+                params: {
+                    password,
+                    username
+                }
+            })
+    });
+const admin_dict = (client)=>({
+        addDict: (dict)=>client.request({
+                url: '/dict',
+                method: 'POST',
+                data: dict
+            }),
+        getDictTagList: (odata)=>client.request({
+                url: '/dict',
+                method: 'GET',
+                params: odata
+            }),
+        getDictTreeByTag: (tag)=>client.request({
+                url: `/dict/tag/${tag}`,
+                method: 'GET'
+            }),
+        modifyDict: (dict)=>client.request({
+                url: '/dict',
+                method: 'PUT',
+                data: dict
+            }),
+        updateDictStatus: (ids, enabled)=>client.request({
+                url: '/dict/update-status',
+                method: 'PUT',
+                params: {
+                    enabled
+                },
+                data: ids
+            }),
+        removeDict: (ids)=>client.request({
+                url: '/dict',
+                method: 'DELETE',
+                data: ids
+            })
+    });
+const admin_role = (client)=>({
+        addRole: (role)=>client.request({
+                url: '/role',
+                method: 'POST',
+                data: role
+            }),
+        listAllRole: ()=>client.request({
+                url: '/role',
+                method: 'GET'
+            }),
+        deleteRole: (id)=>client.request({
+                url: `/role/${id}`,
+                method: 'DELETE'
+            }),
+        listMyRole: ()=>client.request({
+                url: '/role/mine',
+                method: 'GET'
+            })
+    });
+const admin_setting = (client)=>({
+        addSetting: (setting)=>client.request({
+                url: '/setting',
+                method: 'POST',
+                data: setting
+            }),
+        listSetting: ()=>client.request({
+                url: '/setting',
+                method: 'GET'
+            }),
+        querySettingByCode: (code)=>client.request({
+                url: `/setting/${code}`,
+                method: 'GET'
+            }),
+        updateSchema: (setting)=>client.request({
+                url: '/setting/schema',
+                method: 'PUT',
+                data: setting
+            }),
+        updateValue: (setting)=>client.request({
+                url: '/setting/value',
+                method: 'PUT',
+                data: setting
+            }),
+        deleteSetting: (id)=>client.request({
+                url: `/setting/${id}`,
+                method: 'DELETE'
+            })
+    });
+const admin_user = ({ request })=>({
+        register: (user)=>request({
+                url: '/user/register',
+                method: 'POST',
+                data: user
+            }),
+        getMyInfo: ()=>request({
+                url: '/user/me',
+                method: 'GET'
+            }),
+        queryUserList: (odata)=>request({
+                url: '/user',
+                method: 'GET',
+                params: odata
+            }),
+        queryUserById: (id)=>request({
+                url: `/user/${id}`,
+                method: 'GET'
+            })
+    });
+const admin = (config)=>{
+    const instance = axios.create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    return {
+        interceptors,
+        app: admin_app(instance),
+        authn: authn(instance),
+        authz: authz(instance),
+        crypto: admin_crypto(instance),
+        dict: admin_dict(instance),
+        role: admin_role(instance),
+        setting: admin_setting(instance),
+        user: admin_user(instance)
+    };
+};
+var openapi_OpenapiStatus = /*#__PURE__*/ function(OpenapiStatus) {
+    OpenapiStatus["DRAFT"] = "DRAFT";
+    OpenapiStatus["PUBLISHED"] = "PUBLISHED";
+    return OpenapiStatus;
+}({});
+const open_openapi = (client)=>({
+        addOpenapi: (openapi)=>client.request({
+                url: '/openapi',
+                method: 'POST',
+                data: openapi
+            }),
+        getOpenapiList: (odata)=>client.request({
+                url: '/openapi',
+                method: 'GET',
+                params: odata
+            }),
+        modifyOpenapi: (openapi)=>client.request({
+                url: '/openapi',
+                method: 'PUT',
+                data: openapi
+            }),
+        publishOpenapi: (id)=>client.request({
+                url: `/openapi/${id}/publish`,
+                method: 'PUT'
+            }),
+        deleteOpenapi: (id)=>client.request({
+                url: `/openapi/${id}`,
+                method: 'DELETE'
+            })
+    });
+const BASE_URL = '/third-party-app';
+const third_party_app = (client)=>({
+        addThirdPartyApp: (thirdPartyApp)=>client.request({
+                url: `${BASE_URL}`,
+                method: 'POST',
+                data: thirdPartyApp
+            }),
+        listMyThirdPartyApp: (odata)=>client.request({
+                url: `${BASE_URL}/mine`,
+                method: 'GET',
+                params: odata
+            }),
+        queryThirdPartyAppById: (id)=>client.request({
+                url: `${BASE_URL}/${id}`,
+                method: 'GET'
+            }),
+        listThirdPartyApp: (odata)=>client.request({
+                url: `${BASE_URL}`,
+                method: 'GET',
+                params: odata
+            }),
+        rollAccessSecret: (id)=>client.request({
+                url: `${BASE_URL}/${id}/roll`,
+                method: 'PATCH'
+            }),
+        inviteMember: (appId, timeout)=>client.request({
+                url: `/third-party-app/${appId}/member`,
+                method: 'POST',
+                params: {
+                    timeout
+                }
+            }),
+        inviteParticularMember: (appId, userId, timeout)=>client.request({
+                url: `/third-party-app/${appId}/member`,
+                method: 'POST',
+                params: {
+                    userId,
+                    timeout
+                }
+            }),
+        addThirdPartyAppMember: (token)=>client.request({
+                url: "/third-party-app/-/member",
+                method: 'PUT',
+                params: {
+                    token
+                }
+            }),
+        listThirdPartyAppMember: (appId)=>client.request({
+                url: `/third-party-app/${appId}/member`,
+                method: 'GET'
+            }),
+        moveOwnerShip: (appId, userId)=>client.request({
+                url: `/third-party-app/${appId}/owner`,
+                method: 'PATCH',
+                params: {
+                    userId
+                }
+            }),
+        deleteMember: (appId, memberId)=>client.request({
+                url: `/third-party-app/${appId}/member/${memberId}`,
+                method: 'DELETE'
+            })
+    });
+const subscription_BASE_URL = "/subscription";
+var subscription_SubscriptionStatus = /*#__PURE__*/ function(SubscriptionStatus) {
+    SubscriptionStatus["NONE"] = "NONE";
+    SubscriptionStatus["AUDITING"] = "AUDITING";
+    SubscriptionStatus["SUBSCRIBED"] = "SUBSCRIBED";
+    return SubscriptionStatus;
+}({});
+const open_subscription = (client)=>({
+        subscribe: (subscription)=>client.request({
+                url: `${subscription_BASE_URL}`,
+                method: 'POST',
+                data: subscription
+            }),
+        listSubscription: (appId)=>client.request({
+                url: `${subscription_BASE_URL}`,
+                method: 'GET',
+                params: {
+                    appId
+                }
+            }),
+        listSubscriptionWithOpenapi: (appId, odata)=>client.request({
+                url: `${BASE_URL}/${appId}/subscription`,
+                method: 'GET',
+                params: odata
+            }),
+        auditSubscription: (id)=>client.request({
+                url: `${subscription_BASE_URL}/${id}/audit`,
+                method: 'PUT'
+            })
+    });
+const src_open = (config)=>{
+    const instance = axios.create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    return {
+        interceptors: instance.interceptors,
+        openapi: open_openapi(instance),
+        subscription: open_subscription(instance),
+        thirdPartyApp: third_party_app(instance)
+    };
+};
+async function upload_checksum(file) {
+    if (file.checksum && file.crc) return file;
+    return file.arrayBuffer().then((arrayBuffer)=>Promise.all([
+            Promise.resolve().then(()=>crypto_js.SHA256(crypto_js.lib.WordArray.create(arrayBuffer)).toString(crypto_js.enc.Base64)).then((checksum)=>{
+                file.checksum = checksum;
+            }),
+            Promise.resolve().then(()=>crypto_js.enc.Base64.stringify(crypto_js.enc.Hex.parse(crc32.hex(arrayBuffer)))).then((crc)=>{
+                file.crc = crc;
+            })
+        ])).then(()=>file);
+}
+function upload(client, attachmentApi) {
+    return async (file, uploadInfo)=>file.arrayBuffer().then((arrayBuffer)=>{
+            const partCount = uploadInfo.partCount;
+            const partSize = uploadInfo.partSize;
+            const parts = [];
+            for(let index = 0; index < partCount - 1; index++){
+                const content = arrayBuffer.slice(index * partSize, (index + 1) * partSize);
+                const crc = crypto_js.enc.Base64.stringify(crypto_js.enc.Hex.parse(crc32.hex(content)));
+                parts.push({
+                    content,
+                    crc
+                });
+            }
+            const content = arrayBuffer.slice((partCount - 1) * partSize, file.size);
+            const crc = crypto_js.enc.Base64.stringify(crypto_js.enc.Hex.parse(crc32.hex(content)));
+            parts.push({
+                content,
+                crc
+            });
+            return parts;
+        }).then((parts)=>Promise.all(parts.map(async (part, index)=>Promise.resolve().then(()=>{
+                    if (uploadInfo.partCount > 1) return attachmentApi.getMultipartUploadEndpoint(uploadInfo.id, index + 1, part.crc);
+                    return attachmentApi.getUploadEndpoint(uploadInfo.id);
+                }).then((response)=>response.data).then(async ({ endpoint })=>{
+                    if (!endpoint) return;
+                    const partChecksum = crypto_js.SHA256(crypto_js.lib.WordArray.create(part.content)).toString(crypto_js.enc.Base64);
+                    let headers;
+                    headers = uploadInfo.partCount > 1 ? {
+                        'x-amz-sdk-checksum-algorithm': 'CRC32',
+                        'x-amz-checksum-crc32': part.crc
+                    } : {
+                        'x-amz-sdk-checksum-algorithm': 'SHA256',
+                        'x-amz-checksum-sha256': partChecksum,
+                        'x-amz-meta-id': uploadInfo.id,
+                        'x-amz-meta-filename': file.name,
+                        'Content-Type': file.type
+                    };
+                    return client.request({
+                        url: endpoint,
+                        method: 'PUT',
+                        data: part.content,
+                        headers: headers
+                    });
+                })))).then(()=>attachmentApi.finishUpload(uploadInfo.id));
+}
+function resolveDownloadUrl(attachmentApi, baseURL = '') {
+    return async (attachment)=>attachmentApi.getDownloadEndpoint(attachment.id).then((response)=>response.data).then(({ endpoint, filename })=>({
+                endpoint: attachment.provider === file_FileProvider.FS ? `${baseURL}${endpoint}` : endpoint,
+                filename
+            }));
+}
+var attachment_AttachmentStatus = /*#__PURE__*/ function(AttachmentStatus) {
+    AttachmentStatus["UPLOADING"] = "UPLOADING";
+    AttachmentStatus["DONE"] = "DONE";
+    return AttachmentStatus;
+}({});
+const file_attachment = (client)=>({
+        addAttachment: async (file, bizType, bizId)=>{
+            await upload_checksum(file);
+            const req = {
+                name: file.name,
+                checksum: file.checksum,
+                size: file.size,
+                type: file.type,
+                bizType,
+                bizId
+            };
+            return client.request({
+                url: '/attachment',
+                method: 'POST',
+                data: req,
+                params: {
+                    crc: file.crc
+                }
+            });
+        },
+        getUploadInfo: (id, checksum, fileSize)=>client.request({
+                url: `/attachment/${id}/resume`,
+                method: 'GET',
+                params: {
+                    checksum,
+                    fileSize
+                }
+            }),
+        getUploadEndpoint: (id)=>client.request({
+                url: `/attachment/${id}/endpoint/upload`,
+                method: 'GET',
+                params: {
+                    partNumber: 0
+                }
+            }),
+        getMultipartUploadEndpoint: (id, partNumber, crc)=>client.request({
+                url: `/attachment/${id}/endpoint/upload`,
+                method: 'GET',
+                params: {
+                    partNumber,
+                    crc
+                }
+            }),
+        finishUpload: (id)=>client.request({
+                url: `/attachment/${id}/status/done`,
+                method: 'PUT'
+            }),
+        queryAttachmentByBiz: (bizType, bizId)=>client.request({
+                url: "/attachment/list",
+                method: 'GET',
+                params: {
+                    bizType,
+                    bizId
+                }
+            }),
+        queryById: (id)=>client.request({
+                url: `/attachment/${id}`,
+                method: 'GET'
+            }),
+        getDownloadEndpoint: (id)=>client.request({
+                url: `/attachment/${id}/endpoint/download`,
+                method: 'GET'
+            }),
+        deleteAttachment: (id)=>client.request({
+                url: `/attachment/${id}`,
+                method: 'DELETE'
+            }),
+        queryPage: (odata)=>client.request({
+                url: '/attachment/page',
+                method: 'GET',
+                params: odata
+            })
+    });
+const src_file = (config)=>{
+    const instance = axios.create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    const attachmentApi = file_attachment(instance);
+    return {
+        interceptors,
+        attachment: attachmentApi,
+        upload: upload(instance, attachmentApi),
+        resolveDownloadUrl: resolveDownloadUrl(attachmentApi, config.baseURL)
+    };
+};
+var file_FileProvider = /*#__PURE__*/ function(FileProvider) {
+    FileProvider["FS"] = "FS";
+    FileProvider["S3"] = "S3";
+    return FileProvider;
+}({});
+const locale = (client)=>({
+        addLanguage: (language)=>client.request({
+                url: '/language',
+                method: 'POST',
+                data: language
+            }),
+        queryLanguageList: ()=>client.request({
+                url: '/language',
+                method: 'GET'
+            }),
+        updateLanguage: (language)=>client.request({
+                url: '/language',
+                method: 'PUT',
+                data: language
+            }),
+        deleteLanguage: (id)=>client.request({
+                url: `/language/${id}`,
+                method: 'DELETE'
+            }),
+        addI18nMessage: (i18nMessage)=>client.request({
+                url: '/i18n',
+                method: 'POST',
+                data: i18nMessage
+            }),
+        listI18nNamespace: ()=>client.request({
+                url: '/i18n',
+                method: 'GET'
+            }),
+        queryI18nMessageList: (namespace, odata)=>client.request({
+                url: `/i18n/${namespace}`,
+                method: 'GET',
+                params: odata
+            }),
+        updateI18nMessage: (i18nMessage)=>client.request({
+                url: '/i18n',
+                method: 'PUT',
+                data: i18nMessage
+            }),
+        deleteI18nMessage: (id)=>client.request({
+                url: `/i18n/${id}`,
+                method: 'DELETE'
+            }),
+        queryTranslation: (namespace, messageKey)=>client.request({
+                url: `/i18n/${namespace}/${messageKey}`,
+                method: 'GET'
+            }),
+        upsertTranslation: (translation)=>client.request({
+                url: '/locale',
+                method: 'PUT',
+                data: translation
+            }),
+        loadTranslation: (language, namespace)=>client.request({
+                url: `/locale/${language}/${namespace}`,
+                method: 'GET'
+            })
+    });
+const dev = (config)=>{
+    const instance = axios.create(config);
+    const interceptors = instance.interceptors;
+    interceptors.response.use(null, zerowebErrorHandler);
+    return {
+        interceptors,
+        locale: locale(instance)
+    };
+};
+export { ErrorCodeEnum, admin as ZerowebAdminClient, attachment_AttachmentStatus as AttachmentStatus, dev as ZerowebDevClient, file_FileProvider as FileProvider, metadata as ZerowebMetadataClient, metadata_MenuType as MenuType, metadata_ServiceType as ServiceType, openapi_OpenapiStatus as OpenapiStatus, src_file as ZerowebFileClient, src_open as ZerowebOpenClient, subscription_SubscriptionStatus as SubscriptionStatus, types_ErrorSource as ErrorSource, upload_checksum as checksum, zerowebErrorHandler };

package/dist/{typings/interceptors.d.ts → interceptors.d.ts}

@@ -1,5 +1,5 @@
-import type { AxiosError } from "axios";
-import type { ErrorResult, StructuredError } from "./types";
+import type { AxiosError } from 'axios';
+import type { ErrorResult, StructuredError } from './types';
 export declare const ErrorCodeEnum: {
     ARGUMENT_INVALID: string;
 };

package/dist/{typings/metadata → metadata}/index.d.ts

@@ -1,4 +1,4 @@
-import type { InstanceConfig } from "../types";
+import type { InstanceConfig } from '../types';
 /**
  * 服务类型
  */

package/dist/{typings/open → open}/index.d.ts

@@ -1,4 +1,4 @@
-import type { InstanceConfig } from "../types";
+import type { InstanceConfig } from '../types';
 declare const _default: (config: InstanceConfig) => {
     /**
      * 拦截器方法

package/dist/{typings/open → open}/openapi.d.ts

@@ -1,4 +1,4 @@
-import type { HttpClient, Id, OData, Page, PResponse } from "../types";
+import type { HttpClient, Id, OData, Page, PResponse } from '../types';
 /**
  * 对外接口状态
  */