@byted-apaas/server-sdk-node 0.0.2-beta.2 → 0.0.2-beta.5

package/context/db/impl/IObject.ts

@@ -1,244 +0,0 @@
-import { _Cond, _Record, _WhereCond } from '../../../types/types'
-
-export interface _IKAllEndpoint<T> extends _IKSyncEndpoint<T>, _IKAsyncEndpoint<T> { };
-
-export interface _IKSyncEndpoint<T> {
-    /**
-     * 创建记录
-     * @param recordMap 用于创建的一条记录
-     * @paramExample {_name: "John", age: 19, gender: "male"}
-     * @example
-     * ```
-     * context.db.object("_department").create({
-     *     _name: new kunlun.type.Multilingual({ zh: "部门" }),
-     *     _manager: { _id: 1660000000 },
-     *     _status: "_active"
-     * })
-     * ```
-     */
-    create(recordMap: _Cond<T>): Promise<{ _id: number }>;
-    /**
-     * 删除记录
-     * @param recordID 用于删除的一条记录的 ID
-     * @example
-     * ```
-     * context.db.object("_user").delete(123456789123)
-     * ```
-     */
-    delete(recordID: number): Promise<void>;
-    /**
-     * 删除记录
-     * @param record 用于删除的一条完整记录
-     * @example
-     * ```
-     * context.db.object("_user").delete(context.targetRecord.original)
-     * ```
-     */
-    delete(record: _Cond<T>): Promise<void>;
-    /**
-     * 指定 _id 后，更新对应记录
-     * @param _id 主键
-     * @param recordMap 用于更新的一条记录
-     * @paramExample {_name: "John", age: 19, gender: "male"}
-     * @example
-     * ```
-     * context.db.object("_user").update(1660000000, {
-     *     gender: "male"
-     * })
-     * ```
-     */
-    update(_id: number, recordMap: _Cond<T>): Promise<void>;
-    /**
-     * 指定 _id 后，更新对应记录
-     * @param recordMap 用于更新的一条记录，需对 _id 赋值
-     * @paramExample {_id: 1660000000, _name: "John", age: 19, gender: "male"}
-     * @example
-     * ```
-     * context.db.object("_user").update({
-     *     _id: 1660000000,
-     *     gender: "male"
-     * })
-     * ```
-     */
-    update(recordMap: _Cond<T>): Promise<void>;
-    /**
-     * 批量创建记录
-     * @param recordMapList 多条用于创建的记录数据组成的数组
-     * @paramExample [{_name: "John", age: 19, gender: "male"}, {_name: "Alis", age: 16, gender: "female"}]
-     */
-    batchCreate(recordMapList: _Cond<T>[]): Promise<number[]>;
-    /**
-     * 批量删除记录
-     * @param recordIdList 多个用于删除的记录 ID 组成的数组
-     * @paramExample [1001, 1002, 1003]
-     */
-    batchDelete(recordIdList: number[]): Promise<void>;
-    /**
-     * 批量删除记录
-     * @param recordList 多条用于删除的记录数据组成的数组，记录数据需对 _id 赋值
-     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
-     */
-    batchDelete(recordList: _Cond<T>[]): Promise<void>;
-    /**
-     * 根据 _id 批量更新记录
-     * @param recordMapList 多条用于更新的记录数据组成的数组，记录数据需对 _id 赋值
-     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
-     */
-    batchUpdate(recordMapList: _Cond<T>[]): Promise<void>;
-}
-
-export interface _IKAsyncEndpoint<T> {
-    /**
-     * 批量创建记录（为异步任务）
-     * @param recordMapList 用于创建的多条记录
-     * @paramExample [{_name: "John", age: 19, gender: "male"}, {_name: "Alis", age: 16, gender: "female"}]
-     */
-    batchCreateAsync(recordMapList: _Cond<T>[]): Promise<{ taskID: number }>;
-    /**
-     * 批量删除记录（为异步任务）
-     * @param recordIDList 用于删除的多条记录的 ID 列表
-     */
-    batchDeleteAsync(recordIDList: number[]): Promise<{ taskID: number }>;
-    /**
-     * 批量删除记录（为异步任务）
-     * @param recordList 用于删除的多条完整记录的列表
-     */
-    batchDeleteAsync(recordList: _Cond<T>[]): Promise<{ taskID: number }>;
-    /**
-     * 根据 _id 批量更新记录（为异步任务）
-     * @param recordMapList 用于更新的多条记录，需对 _id 赋值
-     * @paramExample [{_id: 1001, _name: "John", gender: "male"}, {_id: 1002, _name: "Alis", gender: "female"}]
-     */
-    batchUpdateAsync(recordMapList: _Cond<T>[]): Promise<{ taskID: number }>;
-}
-
-export interface _IKQuery<T> {
-    /**
-     * 无需入参，返回全部符合条件的记录
-     * @example
-     * ```
-     * context.db.object("_user").where({
-     *     gender: "male"
-     * }).findAll()
-     * ```
-     */
-    findAll(): Promise<_Record<T>[]>;
-    /**
-     * 无需入参，返回符合条件的记录，单次返回 200 条
-     * @example
-     * ```
-     * context.db.object("_user").where({
-     *     gender: "male"
-     * }).find()
-     * ```
-     */
-    find(): Promise<_Record<T>[]>;
-    /**
-     * 无需入参，返回排在第一位的记录
-     * @example
-     * ```
-     * context.db.object("_user").where({
-     *     gender: "male"
-     * }).findOne()
-     * ```
-     */
-    findOne(): Promise<_Record<T>>;
-    /**
-     * 根据指定字段升序排序（a -> z, 0 -> 9）
-     * @param fieldApiNames 排序依据的字段数组，按先后顺序确定优先级
-     * @example
-     * ```
-     * context.db.object("_user").orderBy(["_email", "_phoneNumber"]).find()
-     * ```
-     */
-    orderBy<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
-    /**
-     * 根据指定字段升序排序（a -> z, 0 -> 9）
-     * @param fieldApiNames 排序依据的字段，按先后顺序确定优先级，用逗号分隔
-     * @example
-     * ```
-     * context.db.object("_user").orderBy("_email", "_phoneNumber").find()
-     * ```
-     */
-    orderBy<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
-    /**
-     * 根据指定字段降序排序（z -> a, 9 -> 0）
-     * @param fieldApiNames 排序依据的字段数组，按先后顺序确定优先级
-     * @example
-     * ```
-     * context.db.object("_user").orderByDesc("_email", "_phoneNumber").find()
-     * ```
-     */
-    orderByDesc<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
-    /**
-     * 根据指定字段降序排序（z -> a, 9 -> 0）
-     * @param fieldApiNames 排序依据的字段，按先后顺序确定优先级，用逗号分隔
-     * @example
-     * ```
-     * context.db.object("_user").orderByDesc("_email", "_phoneNumber").find()
-     * ```
-     */
-    orderByDesc<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
-    /**
-     * 指定需返回的字段
-     * @param fieldApiNames 需返回的字段数组
-     * @example
-     * ```
-     * context.db.object("_user").select(["_name", "_email"]).find()
-     * ```
-     */
-    select<K extends keyof T>(fieldApiNames: K[]): _IKQuery<T>;
-    /**
-     * 指定需返回的字段
-     * @param fieldApiNames 需返回的字段，用逗号分隔
-     * @example
-     * ```
-     * context.db.object("_user").select("_name", "_email").find()
-     * ```
-     */
-    select<K extends keyof T>(...fieldApiNames: K[]): _IKQuery<T>;
-    /**
-     * 设置查询条件
-     * @param conditionMap 对字段赋值以指定查询筛选条件
-     * @paramExample {gender: "male"}
-     * @example
-     * ```
-     * context.db.object("_user").where({
-     *     gender: "male"
-     * }).find()
-     * ```
-     */
-    where(conditionMap: _WhereCond<T>): _IKQuery<T>;
-    /**
-     * 设置查询条件
-     */
-    where(): _IKQuery<T>;
-    /**
-     * 指定分页查询的数量
-     * @param limit 分页查询的数量
-     * @paramExample 10
-     * @example
-     * ```
-     * context.db.object("_user").limit(10)
-     * ```
-     */
-    limit(limit: number): _IKQuery<T>;
-    /**
-     * 指定分页查询的偏移量
-     * @param offset 分页查询的偏移量
-     * @paramExample 0
-     * @example
-     * ```
-     * context.db.object("_user").offset(0)
-     * ```
-     */
-    offset(offset: number): _IKQuery<T>;
-    /**
-     * 指定条件的行数
-     * @example
-     * ```
-     * context.db.object("_user").count()
-     * ```
-     */
-    count(): Promise<number>;
-}

package/context/db/impl/db.ts

@@ -1,95 +0,0 @@
-import { _KObject, _KApplicationObject } from './object'
-import { _IKAllEndpoint, _IKSyncEndpoint, _IKQuery } from './IObject'
-import { ITransactionGetter } from './transaction'
-import { IDB, IDBSync, IDBWithCurrentObject } from '../db'
-import { currentObjApiName, metadataMap } from '../../../data/index'
-import { exceptions } from '@byted-apaas/server-common-node'
-import { Transaction } from './transaction/index'
-import { IOql } from "./oql/ioql";
-import { Oql } from "./oql/oql";
-import { AppCtx } from "../../../application/application";
-
-export class DB<T, mt = metadataMap> implements IDB<T, mt> {
-    objectApiName: string
-
-    constructor(objectApiName?: string) {
-        this.objectApiName = objectApiName
-    }
-
-    /**
-     * 操作指定对象的记录数据
-     * @param objectApiName 指定对象的 ApiName
-     * @example
-     * ```
-     * context.db.object("_user").where({
-     *     gender: "male"
-     * }).find()
-     * ```
-     */
-    object<K extends keyof mt>(objectApiName: K): _IKAllEndpoint<mt[K]> & _IKQuery<mt[K]> {
-        return new _KObject<mt[K]>(objectApiName as string)
-    };
-
-    /**
-     * 创建一个新的空事务
-     * @example
-     * ```
-     * let tx = context.db.newTransaction();
-     * let user = tx.object("_user").registerCreate({
-     *     _name: new kunlun.type.Multilingual({ zh: "用户1", en: "user1" }),
-     * });
-     * let contract = tx.object("contract").registerCreate({
-     *     _name: new kunlun.type.Multilingual({ zh: "用户1的合同", en: "user1's contract" }),
-     *     user: {id: user._id}
-     * });
-     * await tx.commit();
-     * ```
-     */
-    newTransaction(): ITransactionGetter<T, mt> {
-        return new Transaction(this.objectApiName) as unknown as ITransactionGetter<T, mt>
-    };
-
-    /**
-     * OQL 操作
-     * @param oql 指定 OQL 语句
-     * @example
-     * ```
-     * let users = await context.db.oql("select _email from _user").execute();
-     * ```
-     */
-    oql(oql: string): IOql {
-        return new Oql(oql);
-    }
-}
-
-export class DBWithCurrentObject<T, mt = metadataMap> extends DB<T, mt> implements IDB<T, mt>, IDBWithCurrentObject<T, mt> {
-    /**
-     * 无需入参，操作当前对象的记录数据
-     */
-    // @ts-ignore
-    currentObject(): _IKAllEndpoint<mt[currentObjApiName]> & _IKQuery<mt[currentObjApiName]> {
-        if (!this.objectApiName) {
-            throw new exceptions.InternalError(`context.objectApiName is empty`);
-        }
-        return new _KObject(this.objectApiName);
-    };
-
-    constructor(objectApiName: string) {
-        super(objectApiName)
-    }
-}
-
-/**
- * ApplicationDB: 用于支持 OpenSDK 相关能力的 DB 相关类，目前仅实现 DB 同步操作接口
- */
-export class ApplicationDB implements IDBSync {
-    appCtx: AppCtx
-
-    constructor(appCtx: AppCtx) {
-        this.appCtx = appCtx
-    }
-
-    object(objectApiName: string): _IKSyncEndpoint<{}> & _IKQuery<{}> {
-        return new _KApplicationObject(objectApiName, this.appCtx);
-    }
-}