@byted-apaas/server-sdk-node 0.0.2-beta.1

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

@@ -0,0 +1,337 @@
+import { ITransaction, ITransactionWithCurrentObject, TransactionObject } from "../transaction";
+import { exceptions, checkUtils } from '@byted-apaas/server-common-node'
+import * as Request from '../../../../request/interface'
+import {
+    CreateOperation,
+    UpdateOperation,
+    DeleteOperation,
+    TransactionOperation,
+    BatchCreateOperation, BatchDeleteOperation, BatchUpdateSameValueOperation, BatchUpdateOperation
+} from './operation'
+import { _Cond, _CondRequireID } from "../../../../types/types";
+import { currentObjApiName } from '../../../../data'
+
+const assert = require('assert')
+
+const { v4: uuidv4 } = require("uuid");
+
+type uuidOrRecordIDResult = {
+    _id: uuidOrRecordID
+}
+
+type uuidOrRecordID = number | string
+
+export class Transaction<T, mt> implements ITransaction<mt>, ITransactionWithCurrentObject<mt> {
+    objectApiName: string
+    placeholders: Record<string, number>
+    operations: TransactionOperation[]
+    // 单个创建 uuid 到 result 的映射
+    uuid2result: Record<string, uuidOrRecordIDResult>
+    isCommit: boolean
+
+    // 批量创建 uuid 数组，commit 后变成真实 _id 的数组
+    batchResults: (string | number)[][];
+
+    constructor(objectApiName: string) {
+        this.objectApiName = objectApiName;
+        this.placeholders = {};
+        this.operations = [];
+        this.uuid2result = {};
+        this.isCommit = false;
+        this.batchResults = [];
+    }
+
+    // @ts-ignore
+    currentObject(): TransactionObject<mt[currentObjApiName]> {
+        if (!this.objectApiName) {
+            throw new exceptions.InternalError(`objectApiName is empty`);
+        }
+        return this.object(this.objectApiName as any);
+    }
+
+    object<T extends keyof mt>(objectApiName: T): TransactionObject<mt[T]> {
+        if (!objectApiName) {
+            throw new exceptions.InvalidParamError(`objectApiName is empty`);
+        }
+
+        return {
+            // 注册创建的逻辑:
+            // 事务中进行创建和不使用事务其实是一样的，特别之处在于返回的 ID 是由 SDK 生成的 uuid。
+            // SDK 生成的 uuid 只是为了 Mock 住 ID 这个字段，在事务执行后并不会落库。
+            registerCreate: (oldRecord: _Cond<T>) => {
+                if (this.isCommit) {
+                    throw new exceptions.InvalidParamError("Committed transaction cannot register operations");
+                }
+
+                if (!oldRecord) {
+                    throw new exceptions.InvalidParamError("record is empty");
+                }
+
+                if (checkUtils.isNotObject(oldRecord)) {
+                    throw new exceptions.InvalidParamError("record is not object");
+                }
+
+                let record = { ...oldRecord };
+
+                let uuid: string = uuidv4();
+                let result = { _id: uuid };
+                (record as _Cond<T> & { _id: string })._id = uuid;
+                this.placeholders[uuid] = 0;
+                this.operations.push(new CreateOperation(objectApiName as string, record));
+                this.uuid2result[uuid] = result;
+                return result;
+            },
+
+            // 注册更新的逻辑：
+            // 由于事务中创建的 Record 的 ID 是 uuid，而已经创建的 Record 的 ID 是 number 类型，因此在传入 ID 的情况下类型为 string | number
+            registerUpdate: (idOrRecord: string | number | _Cond<T>, record?: _Cond<T>) => {
+                let recordMap: _CondRequireID<T>
+                if (this.isCommit) {
+                    throw new exceptions.InvalidParamError("Committed transaction cannot register operations");
+                }
+
+                if (typeof idOrRecord === "number" || typeof idOrRecord === "string") {
+                    recordMap = record as _CondRequireID<T>
+                    recordMap["_id"] = idOrRecord as number
+                } else {
+                    recordMap = idOrRecord as _CondRequireID<T>
+                }
+
+                if (!recordMap) {
+                    throw new exceptions.InvalidParamError("record is empty");
+                }
+
+                let recordID: number = recordMap['_id'];
+                if (!recordID) {
+                    throw new exceptions.InvalidParamError("record._id is empty");
+                }
+                this.operations.push(new UpdateOperation(objectApiName as string, recordMap));
+            },
+
+            // 注册删除的逻辑:
+            // 注册删除和注册更新一样，ID 有可能是事务中创建的 Record，也有可能是现存的 Record，因此 ID 的类型是 string | number
+            registerDelete: (idOrRecord: string | number | _Cond<T>) => {
+                if (this.isCommit) {
+                    throw new exceptions.InvalidParamError("Committed transaction cannot register operations");
+                }
+
+                if (!idOrRecord) {
+                    throw new exceptions.InvalidParamError("record is empty");
+                }
+
+                let recordId: number | string = null;
+                if (typeof idOrRecord === "number" || typeof idOrRecord === "string") {
+                    recordId = idOrRecord
+                } else {
+                    if (checkUtils.isObject(idOrRecord)) {
+                        if (!(idOrRecord as _CondRequireID<T>)._id) {
+                            throw new exceptions.InvalidParamError("record._id is empty");
+                        }
+                        recordId = (idOrRecord as _CondRequireID<T>)._id;
+                    } else {
+                        throw new exceptions.InvalidParamError("param type should be number | string | Object. ")
+                    }
+                }
+                this.operations.push(new DeleteOperation(objectApiName as string, { _id: recordId }));
+            },
+
+            // 注册批量创建
+            registerBatchCreate: (recordMaps: _Cond<T>[]) => {
+                if (this.isCommit) {
+                    throw new exceptions.InvalidParamError("Committed transaction cannot register operations");
+                }
+
+                if (!recordMaps) {
+                    throw new exceptions.InvalidParamError("recordMaps is empty");
+                }
+
+                if (!Array.isArray(recordMaps)) {
+                    throw new exceptions.InvalidParamError("recordMaps is not Array");
+                }
+
+                if (recordMaps.length < 1) {
+                    return [];
+                }
+
+                let result: (string | number)[] = [];
+                let records = [];
+                for (let oldRecord of recordMaps) {
+                    let record = { ...oldRecord };
+                    let uuid: string = uuidv4();
+                    this.placeholders[uuid] = 0;
+                    (record as any)['_id'] = uuid;
+                    result.push(uuid);
+                    records.push(record);
+                }
+
+                this.operations.push(new BatchCreateOperation(objectApiName as string, records));
+
+                this.batchResults.push(result);
+
+                return result;
+            },
+
+            registerBatchUpdate: (recordMaps: _Cond<T>[]) => {
+                if (this.isCommit) {
+                    throw new exceptions.InvalidParamError("Committed transaction cannot register operations");
+                }
+
+                if (!recordMaps) {
+                    throw new exceptions.InvalidParamError("recordMaps is empty");
+                }
+
+                if (!Array.isArray(recordMaps)) {
+                    throw new exceptions.InvalidParamError("recordMaps is not Array");
+                }
+
+                if (recordMaps.length < 1) {
+                    return;
+                }
+
+                // 判断同字段同值更新标志
+                let isSameValue: boolean = true;
+                let ids = [];
+                let flag = recordMaps[0];
+                for (let record of recordMaps as _CondRequireID<T>[]) {
+                    if (checkUtils.isNotObject(record)) {
+                        throw new exceptions.InvalidParamError("one record of recordMaps is not object")
+                    }
+                    if (!record["_id"]) {
+                        throw new exceptions.InvalidParamError(`one record of recordMaps has no _id ${JSON.stringify(record)}`)
+                    }
+                    ids.push(record["_id"])
+                    if (!deepEqualExceptID(flag, record)) {
+                        isSameValue = false;
+                        break;
+                    }
+                }
+
+                if (isSameValue) {
+                    this.operations.push(new BatchUpdateSameValueOperation(objectApiName as string, {
+                        'ids': ids,
+                        'value': flag,
+                    }))
+                } else {
+                    for (const i in ids) {
+                        (recordMaps as _CondRequireID<T>[])[i]["_id"] = ids[i]
+                    }
+                    this.operations.push(new BatchUpdateOperation(objectApiName as string, recordMaps));
+                }
+            },
+
+            // 注册批量删除
+            registerBatchDelete: (idOrRecords: (string | number | _Cond<T>)[]) => {
+                if (this.isCommit) {
+                    throw new exceptions.InvalidParamError("Committed transaction cannot register operations");
+                }
+
+                if (!idOrRecords) {
+                    throw new exceptions.InvalidParamError("idOrRecords is empty");
+                }
+
+                if (!Array.isArray(idOrRecords)) {
+                    throw new exceptions.InvalidParamError("idOrRecords is not Array");
+                }
+
+                if (idOrRecords.length < 1) {
+                    return;
+                }
+
+                let ids: (string | number)[] = [];
+                for (const idOrRecord of idOrRecords) {
+                    switch (typeof idOrRecord) {
+                        case "string":
+                        case "number":
+                            ids.push(idOrRecord as (string | number));
+                            break;
+                        case "object":
+                            if (!(idOrRecord as _CondRequireID<T>)['_id']) {
+                                throw new exceptions.InvalidParamError("_id of one record is empty");
+                            } else {
+                                ids.push((idOrRecord as _CondRequireID<T>)['_id']);
+                            }
+                            break;
+                        default:
+                            throw new exceptions.InvalidParamError("type of one param is not string | number | object")
+                    }
+                }
+
+                this.operations.push(new BatchDeleteOperation(objectApiName as string, { 'ids': ids }))
+            },
+        }
+    }
+
+    async commit(): Promise<void> {
+        if (this.isCommit) {
+            throw new exceptions.InvalidParamError("The transaction cannot be committed repeatedly");
+        }
+        this.isCommit = true;
+
+        if (!this.operations || this.operations.length === 0) {
+            return;
+        }
+
+        let uuid2recordId: Map<string, number> = await Request.GetInstance().modifyRecordsWithTransaction(this.placeholders, this.operations);
+        if (!uuid2recordId) {
+            throw new exceptions.InternalError("uuid2recordId is empty");
+        }
+
+        // 单个注册结果映射
+        for (let uuid of Object.keys(this.uuid2result)) {
+            let preResult: uuidOrRecordIDResult = this.uuid2result[uuid];
+            let recordId = uuid2recordId.get(uuid);
+            if (!recordId) {
+                throw new exceptions.InternalError(`uuid (${uuid}) is not in uuid2recordId (${JSON.stringify(uuid2recordId)})`);
+            }
+
+            if (typeof (recordId) !== "number") {
+                throw new exceptions.InternalError(`the type (${typeof (recordId)}) of recordId (${recordId}) must be number`);
+            }
+            preResult._id = recordId;
+        }
+
+        if (!this.batchResults) {
+            return
+        }
+
+        // 批量注册结果映射
+        for (let i = 0; i < this.batchResults.length; i++) {
+            if (!this.batchResults[i]) {
+                continue
+            }
+            for (let j = 0; j < this.batchResults[i].length; j++) {
+                if (!this.batchResults[i][j]) {
+                    continue
+                }
+                let recordId = uuid2recordId.get(this.batchResults[i][j] as string);
+                if (!recordId) {
+                    throw new exceptions.InternalError(`uuid (${this.batchResults[i][j]}) is not in uuid2recordId (${JSON.stringify(uuid2recordId)})`);
+                }
+
+                if (typeof (recordId) !== "number") {
+                    throw new exceptions.InternalError(`the type (${typeof (recordId)}) of recordId (${recordId}) must be number`);
+                }
+                this.batchResults[i][j] = recordId;
+            }
+        }
+    }
+}
+
+function deepEqualExceptID(left: any, right: any): boolean {
+    let leftID = left["_id"], rightID = right["_id"];
+    delete left["_id"];
+    delete right["_id"];
+    let result: boolean = deepEqual(left, right);
+    left["_id"] = leftID;
+    right["_id"] = rightID;
+    return result;
+}
+
+function deepEqual(left: any, right: any): boolean {
+    try {
+        assert.deepStrictEqual(left, right);
+    } catch (e) {
+        return false
+    }
+    return true;
+}

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

@@ -0,0 +1,27 @@
+export declare class TransactionOperation {
+    operationType: number;
+    objectApiName: string;
+    input: string;
+    constructor(operationType: number, objectApiName: string, input: any);
+}
+export declare class CreateOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any);
+}
+export declare class UpdateOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any);
+}
+export declare class DeleteOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any);
+}
+export declare class BatchCreateOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any);
+}
+export declare class BatchUpdateOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any);
+}
+export declare class BatchDeleteOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any);
+}
+export declare class BatchUpdateSameValueOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any);
+}

package/context/db/impl/transaction/operation.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchUpdateSameValueOperation = exports.BatchDeleteOperation = exports.BatchUpdateOperation = exports.BatchCreateOperation = exports.DeleteOperation = exports.UpdateOperation = exports.CreateOperation = exports.TransactionOperation = void 0;
+const exceptions = require('@byted-apaas/server-common-node').exceptions;
+var OperationType;
+(function (OperationType) {
+    OperationType[OperationType["OPERATION_TYPE_CREATE"] = 1] = "OPERATION_TYPE_CREATE";
+    OperationType[OperationType["OPERATION_TYPE_UPDATE"] = 2] = "OPERATION_TYPE_UPDATE";
+    OperationType[OperationType["OPERATION_TYPE_DELETE"] = 3] = "OPERATION_TYPE_DELETE";
+    OperationType[OperationType["OPERATION_TYPE_BATCH_CREATE"] = 4] = "OPERATION_TYPE_BATCH_CREATE";
+    OperationType[OperationType["OPERATION_TYPE_BATCH_UPDATE"] = 5] = "OPERATION_TYPE_BATCH_UPDATE";
+    OperationType[OperationType["OPERATION_TYPE_BATCH_DELETE"] = 6] = "OPERATION_TYPE_BATCH_DELETE";
+    OperationType[OperationType["OPERATION_TYPE_BATCH_UPDATE_SAME_VALUE"] = 7] = "OPERATION_TYPE_BATCH_UPDATE_SAME_VALUE";
+})(OperationType || (OperationType = {}));
+class TransactionOperation {
+    constructor(operationType, objectApiName, input) {
+        this.operationType = operationType;
+        this.objectApiName = objectApiName;
+        try {
+            this.input = JSON.stringify(input);
+        }
+        catch (e) {
+            throw new exceptions.InvalidParamError(e.message);
+        }
+    }
+}
+exports.TransactionOperation = TransactionOperation;
+class CreateOperation extends TransactionOperation {
+    constructor(objectApiName, input) {
+        super(OperationType.OPERATION_TYPE_CREATE, objectApiName, input);
+    }
+}
+exports.CreateOperation = CreateOperation;
+class UpdateOperation extends TransactionOperation {
+    constructor(objectApiName, input) {
+        super(OperationType.OPERATION_TYPE_UPDATE, objectApiName, input);
+    }
+}
+exports.UpdateOperation = UpdateOperation;
+class DeleteOperation extends TransactionOperation {
+    constructor(objectApiName, input) {
+        super(OperationType.OPERATION_TYPE_DELETE, objectApiName, input);
+    }
+}
+exports.DeleteOperation = DeleteOperation;
+class BatchCreateOperation extends TransactionOperation {
+    constructor(objectApiName, input) {
+        super(OperationType.OPERATION_TYPE_BATCH_CREATE, objectApiName, input);
+    }
+}
+exports.BatchCreateOperation = BatchCreateOperation;
+class BatchUpdateOperation extends TransactionOperation {
+    constructor(objectApiName, input) {
+        super(OperationType.OPERATION_TYPE_BATCH_UPDATE, objectApiName, input);
+    }
+}
+exports.BatchUpdateOperation = BatchUpdateOperation;
+class BatchDeleteOperation extends TransactionOperation {
+    constructor(objectApiName, input) {
+        super(OperationType.OPERATION_TYPE_BATCH_DELETE, objectApiName, input);
+    }
+}
+exports.BatchDeleteOperation = BatchDeleteOperation;
+class BatchUpdateSameValueOperation extends TransactionOperation {
+    constructor(objectApiName, input) {
+        super(OperationType.OPERATION_TYPE_BATCH_UPDATE_SAME_VALUE, objectApiName, input);
+    }
+}
+exports.BatchUpdateSameValueOperation = BatchUpdateSameValueOperation;
+//# sourceMappingURL=operation.js.map

package/context/db/impl/transaction/operation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"operation.js","sourceRoot":"","sources":["operation.ts"],"names":[],"mappings":";;;AAAA,MAAM,UAAU,GAAG,OAAO,CAAC,iCAAiC,CAAC,CAAC,UAAU,CAAC;AAEzE,IAAK,aAUJ;AAVD,WAAK,aAAa;IACd,mFAAyB,CAAA;IACzB,mFAAyB,CAAA;IACzB,mFAAyB,CAAA;IAEzB,+FAA+B,CAAA;IAC/B,+FAA+B,CAAA;IAC/B,+FAA+B,CAAA;IAE/B,qHAA0C,CAAA;AAC9C,CAAC,EAVI,aAAa,KAAb,aAAa,QAUjB;AAED,MAAa,oBAAoB;IAK7B,YAAY,aAAqB,EAAE,aAAqB,EAAE,KAAU;QAChE,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QACnC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QAEnC,IAAI;YACA,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;SACtC;QAAC,OAAO,CAAC,EAAE;YACR,MAAM,IAAI,UAAU,CAAC,iBAAiB,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;SACrD;IACL,CAAC;CACJ;AAfD,oDAeC;AAED,MAAa,eAAgB,SAAQ,oBAAoB;IACrD,YAAY,aAAqB,EAAE,KAAU;QACzC,KAAK,CAAC,aAAa,CAAC,qBAAqB,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;IACrE,CAAC;CACJ;AAJD,0CAIC;AAED,MAAa,eAAgB,SAAQ,oBAAoB;IACrD,YAAY,aAAqB,EAAE,KAAU;QACzC,KAAK,CAAC,aAAa,CAAC,qBAAqB,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;IACrE,CAAC;CACJ;AAJD,0CAIC;AAED,MAAa,eAAgB,SAAQ,oBAAoB;IACrD,YAAY,aAAqB,EAAE,KAAU;QACzC,KAAK,CAAC,aAAa,CAAC,qBAAqB,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;IACrE,CAAC;CACJ;AAJD,0CAIC;AAED,MAAa,oBAAqB,SAAQ,oBAAoB;IAC1D,YAAY,aAAqB,EAAE,KAAU;QACzC,KAAK,CAAC,aAAa,CAAC,2BAA2B,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;IAC3E,CAAC;CACJ;AAJD,oDAIC;AAED,MAAa,oBAAqB,SAAQ,oBAAoB;IAC1D,YAAY,aAAqB,EAAE,KAAU;QACzC,KAAK,CAAC,aAAa,CAAC,2BAA2B,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;IAC3E,CAAC;CACJ;AAJD,oDAIC;AAED,MAAa,oBAAqB,SAAQ,oBAAoB;IAC1D,YAAY,aAAqB,EAAE,KAAU;QACzC,KAAK,CAAC,aAAa,CAAC,2BAA2B,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;IAC3E,CAAC;CACJ;AAJD,oDAIC;AAED,MAAa,6BAA8B,SAAQ,oBAAoB;IACnE,YAAY,aAAqB,EAAE,KAAU;QACzC,KAAK,CAAC,aAAa,CAAC,sCAAsC,EAAE,aAAa,EAAE,KAAK,CAAC,CAAC;IACtF,CAAC;CACJ;AAJD,sEAIC"}

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

@@ -0,0 +1,72 @@
+const exceptions = require('@byted-apaas/server-common-node').exceptions;
+
+enum OperationType {
+    OPERATION_TYPE_CREATE = 1,
+    OPERATION_TYPE_UPDATE = 2,
+    OPERATION_TYPE_DELETE = 3,
+
+    OPERATION_TYPE_BATCH_CREATE = 4,
+    OPERATION_TYPE_BATCH_UPDATE = 5,
+    OPERATION_TYPE_BATCH_DELETE = 6,
+
+    OPERATION_TYPE_BATCH_UPDATE_SAME_VALUE = 7,
+}
+
+export class TransactionOperation {
+    operationType: number
+    objectApiName: string
+    input: string
+
+    constructor(operationType: number, objectApiName: string, input: any) {
+        this.operationType = operationType;
+        this.objectApiName = objectApiName;
+
+        try {
+            this.input = JSON.stringify(input);
+        } catch (e) {
+            throw new exceptions.InvalidParamError(e.message);
+        }
+    }
+}
+
+export class CreateOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any) {
+        super(OperationType.OPERATION_TYPE_CREATE, objectApiName, input);
+    }
+}
+
+export class UpdateOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any) {
+        super(OperationType.OPERATION_TYPE_UPDATE, objectApiName, input);
+    }
+}
+
+export class DeleteOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any) {
+        super(OperationType.OPERATION_TYPE_DELETE, objectApiName, input);
+    }
+}
+
+export class BatchCreateOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any) {
+        super(OperationType.OPERATION_TYPE_BATCH_CREATE, objectApiName, input);
+    }
+}
+
+export class BatchUpdateOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any) {
+        super(OperationType.OPERATION_TYPE_BATCH_UPDATE, objectApiName, input);
+    }
+}
+
+export class BatchDeleteOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any) {
+        super(OperationType.OPERATION_TYPE_BATCH_DELETE, objectApiName, input);
+    }
+}
+
+export class BatchUpdateSameValueOperation extends TransactionOperation {
+    constructor(objectApiName: string, input: any) {
+        super(OperationType.OPERATION_TYPE_BATCH_UPDATE_SAME_VALUE, objectApiName, input);
+    }
+}

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

@@ -0,0 +1,67 @@
+import { _Cond } from '../../../types/types';
+import { currentObjApiName } from "../../../data/index";
+export declare 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>;
+}
+export interface ITransactionWithCurrentObject<mt> {
+    /**
+     * 无需入参，操作当前对象的记录数据
+     */
+    currentObject(): TransactionObject<mt[currentObjApiName]>;
+}
+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,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=transaction.js.map

package/context/db/impl/transaction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.js","sourceRoot":"","sources":["transaction.ts"],"names":[],"mappings":""}

package/context/db/impl/transaction.ts

@@ -0,0 +1,76 @@
+import {_Cond} from '../../../types/types'
+import {currentObjApiName} from "../../../data/index";
+
+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>;
+}
+
+export interface ITransactionWithCurrentObject<mt> {
+    /**
+     * 无需入参，操作当前对象的记录数据
+     */
+    // @ts-ignore
+    currentObject(): TransactionObject<mt[currentObjApiName]>;
+}
+
+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/globalConfig/globalConfig.d.ts

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