@byted-apaas/server-sdk-node 1.1.23 → 1.1.24

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

@@ -0,0 +1,35 @@
+import { ITransactionGetter } from './transaction';
+import { IDBV3 } from '../db';
+import { metadataMap } from '../../../data/index';
+import { _IKAllEndpointV3, _IKQueryV3 } from './IObjectV3';
+export declare class DBV3<T, mt = metadataMap> implements IDBV3<T, mt> {
+    objectApiName: string;
+    constructor(objectApiName?: string);
+    /**
+     * 操作指定对象的记录数据
+     * @param objectApiName 指定对象的 ApiName
+     * @example
+     * ```
+     * context.db.object('_user').where({
+     *     gender: 'male'
+     * }).find()
+     * ```
+     */
+    object<K extends keyof mt>(objectApiName: K): _IKAllEndpointV3<mt[K]> & _IKQueryV3<mt[K]>;
+    /**
+     * 创建一个新的空事务
+     * @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>;
+}

package/context/db/impl/dbV3.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DBV3 = void 0;
+const object_1 = require("./object");
+const index_1 = require("./transaction/index");
+class DBV3 {
+    constructor(objectApiName) {
+        this.objectApiName = objectApiName;
+    }
+    /**
+     * 操作指定对象的记录数据
+     * @param objectApiName 指定对象的 ApiName
+     * @example
+     * ```
+     * context.db.object('_user').where({
+     *     gender: 'male'
+     * }).find()
+     * ```
+     */
+    object(objectApiName) {
+        const appCtx = {
+            dataVersion: 'v3',
+        };
+        return new object_1._KObject(objectApiName, appCtx);
+    }
+    ;
+    /**
+     * 创建一个新的空事务
+     * @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() {
+        const appCtx = {
+            dataVersion: 'v3',
+        };
+        return new index_1.Transaction(this.objectApiName, appCtx);
+    }
+    ;
+}
+exports.DBV3 = DBV3;

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

@@ -0,0 +1,123 @@
+import { _Cond, _Record, _WhereCond } from '../../../types/types';
+import { _IKAsyncEndpoint, _IKQuery, _IKSyncEndpoint } from './IObject';
+import { AppCtx } from '../../../application/application';
+import { BatchResult } from '../../../common/structs';
+import { _IKQueryV3, _IKSyncEndpointV3 } from './IObjectV3';
+/**
+ * _KObject is kunlun object, every method new a _KQuery object to deal.
+ */
+export interface _KObject<T> extends _KObjectSync<T>, _KObjectAsync<T>, _KObjectQuery<T> {
+}
+export declare class _KObject<T> {
+    apiName: string;
+    constructor(objectApiName: string, appCtx?: AppCtx);
+}
+/**
+ * _KApplicationObject is open sdk object implement.
+ */
+export interface _KApplicationObject<T> extends _KObjectSync<T>, _KObjectQuery<T> {
+}
+export declare class _KApplicationObject<T> {
+    apiName: string;
+    appCtx: AppCtx;
+    constructor(objectApiName: string, appCtx: AppCtx);
+}
+declare class _KObjectSync<T> implements _IKSyncEndpoint<T>, _IKSyncEndpointV3<T> {
+    apiName: string;
+    appCtx: AppCtx;
+    authType: string;
+    create(recordMap: _Cond<T>): Promise<{
+        _id: number | string;
+    }>;
+    delete(recordID: number | string): Promise<void>;
+    delete(record: _Cond<T>): Promise<void>;
+    private deleteV3;
+    update(_id: number | string, recordMap: _Cond<T>): Promise<void>;
+    update(recordMap: _Cond<T>): Promise<void>;
+    private updateV3;
+    batchCreate(recordMapList: _Cond<T>[]): Promise<number[] | string[]>;
+    private batchCreateV3;
+    batchDelete(recordIdList: string[]): Promise<BatchResult>;
+    batchDelete(recordIdList: number[]): Promise<BatchResult>;
+    batchDelete(recordList: _Cond<T>[]): Promise<BatchResult>;
+    private batchDeleteV3;
+    batchUpdate(recordMapList: _Cond<T>[]): Promise<BatchResult>;
+    private batchUpdateV3;
+    useUserAuth(): this;
+    useSystemAuth(): this;
+}
+declare class _KObjectAsync<T> implements _IKAsyncEndpoint<T> {
+    apiName: string;
+    authType: string;
+    batchCreateAsync(recordMapList: _Cond<T>[]): Promise<{
+        taskID: number;
+    }>;
+    batchDeleteAsync(recordIDList: number[]): Promise<{
+        taskID: number;
+    }>;
+    batchDeleteAsync(recordList: _Cond<T>[]): Promise<{
+        taskID: number;
+    }>;
+    batchUpdateAsync(recordMapList: _Cond<T>[]): Promise<{
+        taskID: number;
+    }>;
+    useUserAuth(): this;
+    useSystemAuth(): this;
+}
+declare class _KObjectQuery<T> implements _IKQuery<T>, _IKQueryV3<T> {
+    apiName: string;
+    appCtx: AppCtx;
+    authType: string;
+    find(): Promise<_Record<T>[]>;
+    findOne(): Promise<_Record<T>>;
+    findAll(): Promise<_Record<T>[]>;
+    findStream(handler: (records: object[]) => Promise<void>): Promise<void>;
+    orderBy<K extends keyof T>(fieldApiNames: K[]): _KQuery<T>;
+    orderBy<K extends keyof T>(...fieldApiNames: K[]): _KQuery<T>;
+    orderByDesc<K extends keyof T>(fieldApiNames: K[]): _KQuery<T>;
+    orderByDesc<K extends keyof T>(...fieldApiNames: K[]): _KQuery<T>;
+    select<K extends keyof T>(fieldApiNames: K[]): _KQuery<T>;
+    select<K extends keyof T>(...fieldApiNames: K[]): _KQuery<T>;
+    where(conditionMap: _WhereCond<T>): _KQuery<T>;
+    where(): _KQuery<T>;
+    fuzzySearch(keyword: string, fieldAPINames: string[]): _KQuery<T>;
+    limit(limit: number): _KQuery<T>;
+    offset(offset: number): _KQuery<T>;
+    count(): Promise<number>;
+    useSystemAuth(): this;
+    useUserAuth(): this;
+}
+/**
+ * _KQuery is kunlun query implement, implements ORM operations.
+ */
+declare class _KQuery<T> implements _IKQuery<T>, _IKQueryV3<T> {
+    private authType;
+    constructor(objectApiName: string, appCtx?: AppCtx, authType?: string);
+    find(): Promise<_Record<T>[]>;
+    findOne(): Promise<_Record<T>>;
+    /**
+     * @Deprecated Use FindStream instead.
+     */
+    findAll(): Promise<_Record<T>[]>;
+    findStream(handler: (records: object[]) => Promise<void>, pageLimit?: number): Promise<void>;
+    private walkRecordsByID;
+    private walkRecordsByLimitOffset;
+    private getRecordsByPage;
+    orderBy<K extends keyof T>(fieldApiNames: K[]): this;
+    orderBy<K extends keyof T>(...fieldApiNames: K[]): this;
+    orderByDesc<K extends keyof T>(fieldApiNames: K[]): this;
+    orderByDesc<K extends keyof T>(...fieldApiNames: K[]): this;
+    select<K extends keyof T>(fieldApiNames: K[]): this;
+    select<K extends keyof T>(...fieldApiNames: K[]): this;
+    where(conditionMap: _WhereCond<T>): this;
+    where(): this;
+    fuzzySearch(keyword: string, fieldAPINames: string[]): this;
+    limit(limit: number): this;
+    offset(offset: number): this;
+    count(): Promise<number>;
+    private findV3;
+    private findPreCheck;
+    useSystemAuth(): this;
+    useUserAuth(): this;
+}
+export {};