@byted-apaas/server-sdk-node 1.1.23 → 1.1.24-beta.0

package/context/db/impl/transaction.d.ts

@@ -0,0 +1,70 @@
+import { _Cond } from '../../../types/types';
+export type ITransactionGetter<T, mt> = T extends {
+    'objectApiName': string;
+} ? ITransaction<mt> : ITransaction<mt> & ITransactionWithCurrentObject<mt>;
+export interface ITransaction<mt> {
+    /**
+     * 操作指定对象的记录数据
+     * @param objectApiName 指定对象的 ApiName
+     */
+    object<T extends keyof mt>(objectApiName: T): TransactionObject<mt[T]>;
+    /**
+     * 提交事务
+     */
+    commit(): Promise<void>;
+    /**
+     * 用户级鉴权
+     */
+    useUserAuth(): this;
+    /**
+     * 系统级鉴权
+     */
+    useSystemAuth(): this;
+}
+export interface ITransactionWithCurrentObject<mt> {
+}
+export interface TransactionObject<T> {
+    /**
+     * 注册创建单条记录，返回仅在事务中生效的临时记录 ID，该 ID 将在事务执行完毕后更新为实际记录 ID
+     * @param recordMap 用于创建的一条记录
+     */
+    registerCreate(recordMap: _Cond<T>): {
+        _id: string | number;
+    };
+    /**
+     * 注册删除单条记录
+     * @param recordID 用于删除的一条记录的 ID
+     */
+    registerDelete(recordID: (string | number)): void;
+    /**
+     * 注册删除单条记录
+     * @param record 用于删除的一条完整记录
+     */
+    registerDelete(record: _Cond<T>): void;
+    /**
+     * 注册更新单条记录
+     * @param recordMap 用于更新的一条记录，需对 _id 赋值
+     */
+    registerUpdate(recordMap: _Cond<T>): void;
+    /**
+     * 注册更新单条记录
+     * @param _id 主键
+     * @param recordMap 用于更新的一条记录
+     */
+    registerUpdate(_id: (string | number), recordMap: _Cond<T>): void;
+    /**
+     * 注册批量创建记录，返回仅在事务中生效的临时记录 ID 数组，该 ID 将在事务执行完毕后更新为实际记录 ID
+     * @param recordMaps 用于批量创建的一批记录
+     */
+    registerBatchCreate(recordMaps: _Cond<T>[]): (string | number)[];
+    /**
+     * 注册批量删除记录
+     * @param recordIDs 用于删除的一批记录的 ID or 完整记录
+     */
+    registerBatchDelete(recordIDs: (string | number | _Cond<T>)[]): void;
+    /**
+     * 注册批量更新记录
+     * @param recordMaps 用于更新的一批记录，需对每个记录的 _id 赋值
+     */
+    registerBatchUpdate(recordMaps: _Cond<T>[]): void;
+}

package/context/db/impl/transaction.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });

package/context/globalConfig/globalConfig.d.ts

@@ -0,0 +1,7 @@
+export declare class GlobalConfig {
+    /**
+     * 根据 key 获取对应的全局变量
+     * @param key 全局变量的 key
+     */
+    getVar<valueT>(key: string): Promise<valueT>;
+}

package/context/globalConfig/globalConfig.js

@@ -0,0 +1,16 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalConfig = void 0;
+const Request = require("../../request/interface");
+class GlobalConfig {
+    /**
+     * 根据 key 获取对应的全局变量
+     * @param key 全局变量的 key
+     */
+    async getVar(key) {
+        return await Request.GetInstance().getGlobalConfigByKey(key);
+    }
+}
+exports.GlobalConfig = GlobalConfig;

package/context/integration/IIntegration.d.ts

@@ -0,0 +1,30 @@
+export type AppAccessToken = {
+    expire: number;
+    appAccessToken: string;
+    appId: string;
+};
+export type TenantAccessToken = {
+    expire: number;
+    tenantAccessToken: string;
+    appId: string;
+};
+export interface _IIntegration {
+    /**
+     * 获取飞书集成 app access token
+     * @param apiName 飞书集成的 API Name
+     */
+    getAppAccessToken(apiName: string): Promise<AppAccessToken>;
+    /**
+     * 获取飞书集成 tenant access token
+     * @param apiName 飞书集成的 API Name
+     */
+    getTenantAccessToken(apiName: string): Promise<TenantAccessToken>;
+    /**
+     * 获取默认飞书集成 app access token
+     */
+    getDefaultAppAccessToken(): Promise<AppAccessToken>;
+    /**
+     * 获取默认飞书集成 tenant access token
+     */
+    getDefaultTenantAccessToken(): Promise<TenantAccessToken>;
+}

package/context/integration/IIntegration.js

@@ -0,0 +1,4 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });

package/context/integration/impl/integration.d.ts

@@ -0,0 +1,16 @@
+import { _IIntegration, AppAccessToken, TenantAccessToken } from '../IIntegration';
+import { AppCtx } from '../../../application/application';
+export declare class _OpenSDKIntegration implements _IIntegration {
+    appCtx: AppCtx;
+    constructor(appCtx: AppCtx);
+    getAppAccessToken(apiName: string): Promise<AppAccessToken>;
+    getDefaultAppAccessToken(): Promise<AppAccessToken>;
+    getDefaultTenantAccessToken(): Promise<TenantAccessToken>;
+    getTenantAccessToken(apiName: string): Promise<TenantAccessToken>;
+}
+export declare class _Integration implements _IIntegration {
+    getAppAccessToken(apiName: string): Promise<AppAccessToken>;
+    getDefaultAppAccessToken(): Promise<AppAccessToken>;
+    getDefaultTenantAccessToken(): Promise<TenantAccessToken>;
+    getTenantAccessToken(apiName: string): Promise<TenantAccessToken>;
+}

package/context/integration/impl/integration.js

@@ -0,0 +1,62 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._Integration = exports._OpenSDKIntegration = void 0;
+const common = require("@byted-apaas/server-common-node");
+const common_1 = require("../../../application/impl/common");
+const Request = require("../../../request/interface");
+const exceptions = common.exceptions;
+class _OpenSDKIntegration {
+    constructor(appCtx) {
+        this.appCtx = appCtx;
+    }
+    async getAppAccessToken(apiName) {
+        if (!apiName) {
+            throw new exceptions.InvalidParamError(`apiName is null`);
+        }
+        return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+            return await Request.GetInstance().getIntegrationAppAccessToken(apiName);
+        });
+    }
+    async getDefaultAppAccessToken() {
+        return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+            return await Request.GetInstance().getDefaultIntegrationAppAccessToken();
+        });
+    }
+    async getDefaultTenantAccessToken() {
+        return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+            return await Request.GetInstance().getDefaultIntegrationTenantAccessToken();
+        });
+    }
+    async getTenantAccessToken(apiName) {
+        if (!apiName) {
+            throw new exceptions.InvalidParamError(`apiName is null`);
+        }
+        return await (0, common_1.runCtxForOpenSDK)(this.appCtx, async () => {
+            return await Request.GetInstance().getIntegrationTenantAccessToken(apiName);
+        });
+    }
+}
+exports._OpenSDKIntegration = _OpenSDKIntegration;
+class _Integration {
+    async getAppAccessToken(apiName) {
+        if (!apiName) {
+            throw new exceptions.InvalidParamError(`apiName is null`);
+        }
+        return await Request.GetInstance().getIntegrationAppAccessToken(apiName);
+    }
+    async getDefaultAppAccessToken() {
+        return await Request.GetInstance().getDefaultIntegrationAppAccessToken();
+    }
+    async getDefaultTenantAccessToken() {
+        return await Request.GetInstance().getDefaultIntegrationTenantAccessToken();
+    }
+    async getTenantAccessToken(apiName) {
+        if (!apiName) {
+            throw new exceptions.InvalidParamError(`apiName is null`);
+        }
+        return await Request.GetInstance().getIntegrationTenantAccessToken(apiName);
+    }
+}
+exports._Integration = _Integration;

package/context/metadata/components/common.d.ts

@@ -0,0 +1,6 @@
+declare const componentTypes: Record<string, string>;
+declare class Component {
+    private type;
+    constructor(type: string);
+}
+export { Component, componentTypes, };

package/context/metadata/components/common.js

@@ -0,0 +1,17 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.componentTypes = exports.Component = void 0;
+const componentTypes = {
+    desktopList: 'desktopList',
+    desktopRecordDetail: 'desktopRecordDetail',
+    mobileList: 'mobileList',
+};
+exports.componentTypes = componentTypes;
+class Component {
+    constructor(type) {
+        this.type = type;
+    }
+}
+exports.Component = Component;

package/context/metadata/components/components.d.ts

@@ -0,0 +1,12 @@
+import { Component } from './common';
+import { RecordDetail as DesktopRecordDetail } from './desktop/recordDetail';
+import { List as DesktopList } from './desktop/list';
+import { List as MobileList } from './mobile/list';
+declare const desktop: {
+    RecordDetail: typeof DesktopRecordDetail;
+    List: typeof DesktopList;
+};
+declare const mobile: {
+    List: typeof MobileList;
+};
+export { Component, desktop, mobile, };

package/context/metadata/components/components.js

@@ -0,0 +1,19 @@
+"use strict";
+// Copyright 2022 ByteDance Ltd. and/or its affiliates
+// SPDX-License-Identifier: MIT
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mobile = exports.desktop = exports.Component = void 0;
+const common_1 = require("./common");
+Object.defineProperty(exports, "Component", { enumerable: true, get: function () { return common_1.Component; } });
+const recordDetail_1 = require("./desktop/recordDetail");
+const list_1 = require("./desktop/list");
+const list_2 = require("./mobile/list");
+const desktop = {
+    RecordDetail: recordDetail_1.RecordDetail,
+    List: list_1.List,
+};
+exports.desktop = desktop;
+const mobile = {
+    List: list_2.List,
+};
+exports.mobile = mobile;

package/context/metadata/components/desktop/list.d.ts

@@ -0,0 +1,16 @@
+import { Component } from '../common';
+import { UIMetaFilterType, UIMetaDesktopType, DeskListDetailField, DeskListSubtitleField, DeskListTitleField } from '../../types/components';
+import { I18ns } from '../../types/common';
+declare class List extends Component {
+    titleAreaText: I18ns;
+    objectApiName: string;
+    isCompositeType: boolean;
+    titleFields: DeskListTitleField[];
+    subtitleFields: DeskListSubtitleField[];
+    detailFields: DeskListDetailField[];
+    filter: UIMetaFilterType;
+    sortConditions: object[];
+    constructor(params: UIMetaDesktopType);
+    static parse(input: Record<string, any>): List;
+}
+export { List, };

package/context/metadata/components/desktop/list.js

@@ -0,0 +1,402 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.List = void 0;
+const common = require("@byted-apaas/server-common-node");
+const commonUtils = common.utils;
+const common_1 = require("../common");
+const common_2 = require("../../types/common");
+/*
+titleAreaText: i18n;
+objectApiName: string;
+isCompositeType: boolean;
+titleFields: [{
+    fieldApiName: string;
+},...]
+subtitleFields: [{
+    type: 'field'|'concatText'
+    fieldApiName: string;
+    alias: i18n;
+    concatText: {
+        zh_CN: [{
+            dataType: 'fieldApiName'|'text'
+            fieldApiName: string;
+            text: string;
+        },...]
+        en_US: [{
+            dataType: 'fieldApiName'|'text'
+            fieldApiName: string;
+            text: string;
+        },...]
+    }
+},...]
+detailFields: [{
+    fieldApiName: string;
+    alias: i18n;
+},...]
+filter: {
+    conditions: object[];
+    logic: string;
+};
+sortConditions: object[];
+ */
+class List extends common_1.Component {
+    constructor(params) {
+        super(common_1.componentTypes.desktopList);
+        // TODO check
+        this.titleAreaText = params.titleAreaText;
+        this.objectApiName = params.objectApiName;
+        this.isCompositeType = params.isCompositeType;
+        this.titleFields = params.titleFields;
+        this.subtitleFields = params.subtitleFields;
+        this.detailFields = params.detailFields;
+        this.filter = params.filter;
+        this.sortConditions = params.sortConditions;
+    }
+    static parse(input) {
+        if (input.dataType === 'object') {
+            return convertUIMetaListObject(input);
+        }
+        else if (input.dataType === 'compositeType') {
+            return convertUIMetaListCompositeType(input);
+        }
+        return input;
+    }
+}
+exports.List = List;
+function convertUIMetaListObject(input) {
+    return {
+        isCompositeType: false,
+        titleAreaText: input.titleLabel,
+        objectApiName: input.objectApiName,
+        titleFields: getListObjectTitleFields(input),
+        subtitleFields: getListObjectSubtitleFields(input),
+        detailFields: getListObjectDetailFields(input),
+        filter: getListFilter(input),
+        sortConditions: getListSort(input),
+    };
+}
+function convertUIMetaListCompositeType(input) {
+    return {
+        isCompositeType: true,
+        titleAreaText: input.titleLabel,
+        objectApiName: getListCompositeTypeObjectApiName(input),
+        titleFields: getListCompositeTypeTitleFields(input),
+        subtitleFields: getListCompositeTypeSubtitleFields(input),
+        detailFields: getListCompositeTypeDetailFields(input),
+        filter: getListCompositeTypeFilter(input),
+        sortConditions: getListSort(input),
+    };
+}
+function getListObjectTitleFields(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.title)) {
+        return [];
+    }
+    let titles = [];
+    try {
+        let inputTitles = JSON.parse(input.title);
+        if (!inputTitles || !(inputTitles instanceof Array)) {
+            return [];
+        }
+        for (let inputTitle of inputTitles) {
+            titles.push({
+                fieldApiName: inputTitle.columnApiName,
+            });
+        }
+    }
+    catch (err) {
+        return [];
+    }
+    return titles;
+}
+function getListObjectSubtitleFields(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.subTitle)) {
+        return [];
+    }
+    let subtitles = [];
+    try {
+        let inputSubtitles = JSON.parse(input.subTitle);
+        if (!inputSubtitles || !Array.isArray(inputSubtitles)) {
+            return [];
+        }
+        for (let inputSubtitle of inputSubtitles) {
+            subtitles.push({
+                fieldApiName: inputSubtitle.columnApiName,
+                alias: inputSubtitle.alias,
+            });
+        }
+    }
+    catch (err) {
+        return [];
+    }
+    return subtitles;
+}
+function getListObjectDetailFields(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.detail)) {
+        return [];
+    }
+    let details = [];
+    try {
+        let inputDetails = JSON.parse(input.detail);
+        if (!inputDetails || !Array.isArray(inputDetails)) {
+            return [];
+        }
+        for (let inputDetail of inputDetails) {
+            details.push({
+                fieldApiName: inputDetail.columnApiName,
+                alias: inputDetail.alias,
+            });
+        }
+    }
+    catch (err) {
+        return [];
+    }
+    return details;
+}
+function getListFilter(input) {
+    if (!input || !input.describeFilter || (0, common_2.isNullOrUndefined)(input.describeFilter.filter)) {
+        return {};
+    }
+    try {
+        let inputFilter = JSON.parse(input.describeFilter.filter);
+        if (!inputFilter) {
+            return {};
+        }
+        return {
+            conditions: inputFilter.conditions,
+            logic: inputFilter.logic,
+        };
+    }
+    catch (err) {
+        return {};
+    }
+}
+function getListSort(input) {
+    if (!input || !input.sort || !Array.isArray(input.sort)) {
+        return [];
+    }
+    let sortFields = [];
+    for (let field of input.sort) {
+        sortFields.push({
+            fieldApiName: field.field,
+            sort: field.direction,
+        });
+    }
+    return sortFields;
+}
+function getListCompositeTypeObjectApiName(input) {
+    if ((0, common_2.isNullOrUndefined)(input)) {
+        return '';
+    }
+    let objectApiName = getObjectApiNameFromTitle(input);
+    if (objectApiName) {
+        return objectApiName;
+    }
+    objectApiName = getObjectApiNameFromSubTitle(input);
+    if (objectApiName) {
+        return objectApiName;
+    }
+    objectApiName = getObjectApiNameFromDetail(input);
+    if (objectApiName) {
+        return objectApiName;
+    }
+    return '';
+}
+function getObjectApiNameFromTitle(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.title)) {
+        return '';
+    }
+    try {
+        return JSON.parse(input.title)[0].picker.fieldPath[0].objectApiName;
+    }
+    catch (err) {
+        return '';
+    }
+}
+function getObjectApiNameFromDetail(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.detail)) {
+        return '';
+    }
+    try {
+        return JSON.parse(input.detail)[0].picker.fieldPath[0].objectApiName;
+    }
+    catch (err) {
+        return '';
+    }
+}
+function getObjectApiNameFromSubTitle(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.subTitle)) {
+        return '';
+    }
+    try {
+        return JSON.parse(input.subTitle)[0].picker.fieldPath[0].objectApiName;
+    }
+    catch (err) {
+        return '';
+    }
+}
+function getListCompositeTypeTitleFields(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.title)) {
+        return [];
+    }
+    let inputFields = [];
+    try {
+        let inputTitles = JSON.parse(input.title);
+        if (!inputTitles || !(inputTitles instanceof Array)) {
+            return [];
+        }
+        for (let title of inputTitles) {
+            try {
+                inputFields.push({
+                    fieldApiName: title.picker.fieldPath[0].fieldApiName,
+                });
+            }
+            catch (e) {
+                continue;
+            }
+        }
+    }
+    catch (err) {
+        return [];
+    }
+    return inputFields;
+}
+function parsePrimitive(element) {
+    try {
+        return {
+            type: 'field',
+            fieldApiName: element.picker.fieldPath[0].fieldApiName,
+            alias: [],
+            concatText: {
+                zh_CN: [],
+                en_US: [],
+            }
+        };
+    }
+    catch (e) {
+        return null;
+    }
+}
+function getListCompositeTypeSubtitleFields(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.subTitle)) {
+        return [];
+    }
+    let fields = [], subTitle;
+    try {
+        subTitle = JSON.parse(input.subTitle);
+    }
+    catch (err) {
+        return [];
+    }
+    if (!subTitle || !Array.isArray(subTitle)) {
+        return [];
+    }
+    for (let element of subTitle) {
+        let field = null;
+        if (element.type === 'primitive') {
+            field = parsePrimitive(element);
+        }
+        else if (element.type === 'concatenate') {
+            field = parseConcatenate(element);
+        }
+        if (field) {
+            fields.push(field);
+        }
+    }
+    return fields;
+}
+function getListCompositeTypeDetailFields(input) {
+    if (!input || (0, common_2.isNullOrUndefined)(input.detail)) {
+        return [];
+    }
+    let fields = [];
+    try {
+        let detail = JSON.parse(input.detail);
+        if (!detail || !(detail instanceof Array)) {
+            return [];
+        }
+        for (let element of detail) {
+            try {
+                fields.push({
+                    fieldApiName: element.picker.fieldPath[0].fieldApiName,
+                    alias: [], // TODO
+                });
+            }
+            catch (e) {
+                continue;
+            }
+        }
+    }
+    catch (err) {
+        return [];
+    }
+    return fields;
+}
+function getListCompositeTypeFilter(input) {
+    if (!input || !input.describeFilter || (0, common_2.isNullOrUndefined)(input.describeFilter.filter)) {
+        return {};
+    }
+    try {
+        let inputFilter = JSON.parse(input.describeFilter.filter);
+        if (!inputFilter) {
+            return {};
+        }
+        return {
+            conditions: inputFilter.conditions,
+            logic: inputFilter.logic,
+        };
+    }
+    catch (err) {
+        return {};
+    }
+}
+function parseLangValues(values) {
+    let lang = [];
+    for (let value of values) {
+        if (value.type === 'text') {
+            lang.push({
+                dataType: 'text',
+                fieldApiName: '',
+                text: value.value,
+            });
+        }
+        else if (value.type === 'field') {
+            if (value && value.picker && commonUtils.getArrayLength(value.picker.fieldPath) > 0
+                && value.picker.fieldPath[0].fieldApiName) {
+                lang.push({
+                    dataType: 'fieldApiName',
+                    fieldApiName: value.picker.fieldPath[0].fieldApiName,
+                    text: '',
+                });
+            }
+        }
+    }
+    return lang;
+}
+function parseConcatenate(element) {
+    if (!element || (0, common_2.isNullOrUndefined)(element.content)) {
+        return null;
+    }
+    let concatEle = {
+        type: 'concatText',
+        fieldApiName: '',
+        alias: [],
+        concatText: {
+            zh_CN: [],
+            en_US: [],
+        }
+    };
+    for (let code of Object.keys(element.content)) {
+        let values = element.content[code];
+        if (code === '2052') {
+            concatEle.concatText.zh_CN = parseLangValues(values);
+        }
+        else if (code === '1033') {
+            concatEle.concatText.en_US = parseLangValues(values);
+        }
+    }
+    if (commonUtils.getArrayLength(concatEle.concatText.zh_CN) > 0 ||
+        commonUtils.getArrayLength(concatEle.concatText.en_US) > 0) {
+        return concatEle;
+    }
+    return null;
+}