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

package/kunlun/operator/IOperator.d.ts

@@ -1,158 +0,0 @@
-import { _Cond, _BooleanCond, _LogicalCond } from '../../types/types';
-import { UserDataType } from './impl/expression';
-export interface IOperator {
-    /**
-     * 逻辑与
-     * @param conditions 多个条件，用逗号分隔
-     * @example
-     * ```
-     * context.db.object('_user').where(kunlun.operator.and({
-     *     age: '22'
-     * },{
-     *     gender: 'male'
-     * }))
-     * ```
-     */
-    and<T>(...conditions: (_Cond<T> | _BooleanCond<T>)[]): _LogicalCond<T>;
-    /**
-     * 逻辑或
-     * @param conditions 多个条件，用逗号分隔
-     * @example
-     * ```
-     * context.db.object('_user').where(kunlun.operator.or({
-     *     age: '22'
-     * },{
-     *     age: '25'
-     * }))
-     * ```
-     */
-    or<T>(...conditions: (_Cond<T> | _BooleanCond<T>)[]): _LogicalCond<T>;
-    /**
-     * 包含
-     * @param value 判定是否包含的文本值
-     * @example
-     * ```
-     * context.db.object('_user').where({_name: kunlun.operator.contain('a')})
-     * ```
-     */
-    contain<T>(value: UserDataType): _BooleanCond<T>;
-    /**
-     * 不包含
-     * @param value 判定是否不包含的文本值
-     * @example
-     * ```
-     * context.db.object('_user').where({_name: kunlun.operator.notContain('a')})
-     * ```
-     */
-    notContain<T>(value: UserDataType): _BooleanCond<T>;
-    /**
-     * 无需入参，判断是否为空
-     * @example
-     * ```
-     * context.db.object('_user').where({employeeType: kunlun.operator.empty()})
-     * ```
-     */
-    empty(): _BooleanCond<any>;
-    /**
-     * 无需入参，判断是否为空
-     * @example
-     * ```
-     * context.db.object('_user').where({employeeType: kunlun.operator.notEmpty()})
-     * ```
-     */
-    notEmpty(): _BooleanCond<any>;
-    /**
-     * 等于
-     * @param value 判定是否相等的值
-     * @example
-     * ```
-     * context.db.object('_user').where({age: kunlun.operator.eq(20)})
-     * ```
-     */
-    eq<T>(value: UserDataType): _BooleanCond<T>;
-    /**
-     * 不等于
-     * @param value 判定是否不相等的值
-     * @example
-     * ```
-     * context.db.object('_user').where({age: kunlun.operator.neq(20)})
-     * ```
-     */
-    neq<T>(value: UserDataType): _BooleanCond<T>;
-    /**
-     * 大于或晚于
-     * @param value 判定是否大于或晚于的值
-     * @example
-     * ```
-     * kunlun.operator.gt(new Date('2020-11-26').getTime())
-     * ```
-     */
-    gt<T>(value: number | Date): _BooleanCond<T>;
-    /**
-     * 大于等于或晚于等于
-     * @param value 判定是否大于等于或晚于等于的值
-     * @example
-     * ```
-     * kunlun.operator.gte(new Date('2020-11-26').getTime())
-     * ```
-     */
-    gte<T>(value: number | Date): _BooleanCond<T>;
-    /**
-     * 小于或早于
-     * @param value 判定是否小于或早于的值
-     * @example
-     * ```
-     * kunlun.operator.lt(new Date('2020-11-26').getTime())
-     * ```
-     */
-    lt<T>(value: number | Date): _BooleanCond<T>;
-    /**
-     * 小于等于或早于等于
-     * @param value 判定是否小于等于或早于等于的值
-     * @example
-     * ```
-     * kunlun.operator.lte(new Date('2020-11-26').getTime())
-     * ```
-     */
-    lte<T>(value: number | Date): _BooleanCond<T>;
-    /**
-     * 存在于给定的数组内
-     * @param values 判定是否存在于的一组值，用数组传递
-     */
-    in<T>(values: UserDataType[]): _BooleanCond<T>;
-    /**
-     * 存在于给定的数组内
-     * @param values 判定是否存在于的一组值，用逗号分隔
-     */
-    in<T>(...values: UserDataType[]): _BooleanCond<T>;
-    /**
-     * 不存在于给定的数组内
-     * @param values 判定是否不存在于的一组值，用数组传递
-     */
-    notIn<T>(values: UserDataType[]): _BooleanCond<T>;
-    /**
-     * 不存在于给定的数组内
-     * @param values 判定是否不存在于的一组值，用逗号分隔
-     */
-    notIn<T>(...values: UserDataType[]): _BooleanCond<T>;
-    /**
-     * 存在给定的多个值中的任何一个值
-     * @param values 判定是否不存在于的一组值，用逗号分隔
-     */
-    hasAnyOf<T>(values: number[] | string[]): _BooleanCond<T>;
-    /**
-     * 存在给定的多个值中的任何一个值
-     * @param values 判定是否不存在于的一组值，用逗号分隔
-     */
-    hasAnyOf<T>(...values: number[] | string[]): _BooleanCond<T>;
-    /**
-     * 不存在给定的多个值中的任何值
-     * @param values 判定是否不存在于的一组值，用逗号分隔
-     */
-    hasNoneOf<T>(values: number[] | string[]): _BooleanCond<T>;
-    /**
-     * 不存在给定的多个值中的任何值
-     * @param values 判定是否不存在于的一组值，用逗号分隔
-     */
-    hasNoneOf<T>(...values: number[] | string[]): _BooleanCond<T>;
-}

package/kunlun/operator/IOperator.js

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

package/kunlun/operator/impl/expression.d.ts

@@ -1,75 +0,0 @@
-export type UserDataType = null | string | boolean | number | Date | object;
-export declare class Expression {
-    index: number;
-    left: ExpressionField;
-    operator: string;
-    right: ExpressionField;
-    constructor(left: ExpressionField, operator: string, right: ExpressionField, index: number);
-}
-type SettingType = {
-    data?: UserDataType;
-    fieldPath?: PathType[];
-};
-export type PathType = {
-    objectApiName: string;
-    fieldApiName: string;
-    extendLogicTags: string[];
-};
-/**
- * 总共有4种类型，当前仅支持constant，metadataVariable
- *
- * constant：不可为左值
- * metadataVariable
- * function
- * customizedVariable
- */
-declare class ExpressionField {
-    type: string;
-    settings: SettingType;
-    constructor(type: string, settings: SettingType);
-}
-/**
- * 常量表达式字段
- *
- * 比如在 condition: user.name equal 'bob' 中，'bob' 将被构建为 ConstantExpressionField
- */
-export declare class ConstantExpressionField extends ExpressionField {
-    constructor(data: UserDataType);
-}
-/**
- * 元数据表达式字段
- *
- * 比如在 condition: user.name equal 'bob' 中，'user.name' 将被构建为 MetadataExpressionField
- */
-export declare class MetadataExpressionField extends ExpressionField {
-    constructor(objectApiName: string, fieldApiName: string);
-}
-export declare class ExpressionV3 {
-    index: number;
-    left: ExpressionFieldV3;
-    operator: string;
-    right: ExpressionFieldV3;
-    constructor(left: ExpressionFieldV3, operator: string, right: ExpressionFieldV3, index: number);
-}
-declare class ExpressionFieldV3 {
-    type: string;
-    settings: string;
-    constructor(type: string, settings: string);
-}
-/**
- * 常量表达式字段
- *
- * 比如在 condition: user.name equal 'bob' 中，'bob' 将被构建为 ConstantExpressionField
- */
-export declare class ConstantExpressionFieldV3 extends ExpressionFieldV3 {
-    constructor(data?: UserDataType);
-}
-/**
- * 元数据表达式字段
- *
- * 比如在 condition: user.name equal 'bob' 中，'user.name' 将被构建为 MetadataExpressionField
- */
-export declare class MetadataExpressionFieldV3 extends ExpressionFieldV3 {
-    constructor(filedPath?: PathType[]);
-}
-export {};

package/kunlun/operator/impl/expression.js

@@ -1,96 +0,0 @@
-"use strict";
-// Copyright 2022 ByteDance Ltd. and/or its affiliates
-// SPDX-License-Identifier: MIT
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MetadataExpressionFieldV3 = exports.ConstantExpressionFieldV3 = exports.ExpressionV3 = exports.MetadataExpressionField = exports.ConstantExpressionField = exports.Expression = void 0;
-class Expression {
-    constructor(left, operator, right, index) {
-        this.index = index;
-        this.left = left;
-        this.operator = operator;
-        this.right = right;
-    }
-}
-exports.Expression = Expression;
-/**
- * 总共有4种类型，当前仅支持constant，metadataVariable
- *
- * constant：不可为左值
- * metadataVariable
- * function
- * customizedVariable
- */
-class ExpressionField {
-    constructor(type, settings) {
-        this.type = type;
-        this.settings = settings;
-    }
-}
-/**
- * 常量表达式字段
- *
- * 比如在 condition: user.name equal 'bob' 中，'bob' 将被构建为 ConstantExpressionField
- */
-class ConstantExpressionField extends ExpressionField {
-    constructor(data) {
-        super('constant', { data });
-    }
-}
-exports.ConstantExpressionField = ConstantExpressionField;
-/**
- * 元数据表达式字段
- *
- * 比如在 condition: user.name equal 'bob' 中，'user.name' 将被构建为 MetadataExpressionField
- */
-class MetadataExpressionField extends ExpressionField {
-    constructor(objectApiName, fieldApiName) {
-        super('metadataVariable', {
-            'fieldPath': [{
-                    objectApiName: objectApiName,
-                    fieldApiName: fieldApiName,
-                    extendLogicTags: [],
-                }]
-        });
-    }
-}
-exports.MetadataExpressionField = MetadataExpressionField;
-class ExpressionV3 {
-    constructor(left, operator, right, index) {
-        this.index = index;
-        this.left = left;
-        this.operator = operator;
-        this.right = right;
-    }
-}
-exports.ExpressionV3 = ExpressionV3;
-class ExpressionFieldV3 {
-    constructor(type, settings) {
-        this.type = type;
-        this.settings = settings;
-    }
-}
-/**
- * 常量表达式字段
- *
- * 比如在 condition: user.name equal 'bob' 中，'bob' 将被构建为 ConstantExpressionField
- */
-class ConstantExpressionFieldV3 extends ExpressionFieldV3 {
-    constructor(data) {
-        const d = { 'data': data };
-        super('constant', JSON.stringify(d));
-    }
-}
-exports.ConstantExpressionFieldV3 = ConstantExpressionFieldV3;
-/**
- * 元数据表达式字段
- *
- * 比如在 condition: user.name equal 'bob' 中，'user.name' 将被构建为 MetadataExpressionField
- */
-class MetadataExpressionFieldV3 extends ExpressionFieldV3 {
-    constructor(filedPath) {
-        const filedPathV3 = filedPath.map(({ extendLogicTags, ...item }) => item);
-        const fp = { 'fieldPath': filedPathV3 };
-        super('metadataVariable', JSON.stringify(fp));
-    }
-}
-exports.MetadataExpressionFieldV3 = MetadataExpressionFieldV3;

package/kunlun/operator/impl/logic.d.ts

@@ -1,68 +0,0 @@
-import { Expression, UserDataType, ExpressionV3 } from './expression';
-export declare class Condition {
-    left: string;
-    right: Condition | UserDataType;
-    op: string;
-    /**
-     *
-     * @param objectApiName 对象的ApiName
-     * @param fieldApiName  字段的ApiName，指左值，即key
-     * @param index         条件的排序
-     * @returns {Expression}
-     */
-    toExpression(objectApiName: string, fieldApiName: string, index: number): Expression;
-    constructor(left: string, right: Condition | UserDataType, op?: string);
-}
-export type Criterion = {
-    conditions: Expression[];
-    logic: string;
-};
-export type CriterionV3 = {
-    conditions: ExpressionV3[];
-    expression: string;
-};
-/**
- * 构造 criterion
- *
- * @param logic
- * @param objectApiName
- * @param maxId 添加 _id>maxId 条件，为 -1 表示不使用该参数
- */
-export declare function buildCriterion(logic: Logic, objectApiName: string): Criterion;
-export declare function buildExpression(objectApiName: string, left: string, right: Condition | UserDataType, index?: number): Expression;
-/**
- * 在 criterion 中添加 _id>maxId 的判断条件
- *
- * @param criterion
- * @param apiName
- * @param maxId 添加 _id>maxId 条件
- */
-export declare function addIDCriterion(criterion: Criterion, apiName: string, maxId: number): Criterion;
-/**
- * 构造 convertCriterionToCriterionV3
- *
- * @param criterion v1 版本的条件
- */
-export declare function convertCriterionToCriterionV3(criterion: Criterion): CriterionV3;
-export declare class Logic {
-    value: string;
-    expressions: {
-        [index: string]: any;
-    };
-    logics: Logic[];
-    constructor(expressions?: {
-        [index: string]: any;
-    }, logicValue?: string);
-    /**
-     * 处理：右值包含逻辑表达式and|or的情况
-     *
-     * @param expressions
-     * @param lookupField
-     */
-    handleRightLogic(expressions: {
-        [index: string]: any;
-    }, lookupField?: string): void;
-    addLogic(logic: Logic): void;
-}
-export declare function buildLogic(param: (Logic | object)[], logicValue?: string): Logic;
-export declare function handleCriterion(criterion: Criterion): Promise<Criterion>;