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

package/kunlun/kunlun.ts

@@ -1,69 +0,0 @@
-import { IOperator } from './operator/IOperator';
-import { globalVariables } from '../data/index'
-import { GMTOffset as GMT } from "@byted-apaas/server-common-node/constants/timeZone";
-import { area2code } from "@byted-apaas/server-common-node/constants/countryCode";
-import { ITool, IToolsExtra } from "@byted-apaas/server-common-node/kunlun/tool/Itool";
-import { Tool } from "@byted-apaas/server-common-node/kunlun/tool/impl/tool";
-import { errCodes } from "@byted-apaas/server-common-node/utils/exceptions";
-import { Operator } from "./operator/impl/operator";
-import * as common from "@byted-apaas/server-common-node";
-import * as Request from "../request/interface";
-
-declare global {
-    export namespace kunlun {
-        /**
-         * 指令操作符
-         */
-        export let operator: IOperator;
-    }
-}
-
-export namespace kunlun {
-    /**
-     * 引用时区信息
-     */
-    export const GMTOffset: typeof GMT = GMT;
-
-    /**
-     * 引用国际区号
-     */
-    export const countryCode: typeof area2code = area2code;
-
-    /**
-     * 工具方法
-     */
-    export let tool: ITool & IToolsExtra = new Tool();
-
-    /**
-     * 生成复杂数据结构
-     */
-    export namespace type {
-        export import Multilingual = common.fieldType.Multilingual
-        export import Phone = common.fieldType.Phone
-        export import Date = common.fieldType.Date
-        export import DateTime = common.fieldType.DateTime
-    }
-
-    /**
-     * 错误码
-     */
-    export const errorCode = {
-        /**
-         * 限流错误码
-         */
-        RATE_LIMIT_ERROR: errCodes.RATE_LIMIT_ERROR,
-    }
-
-    /**
-     * 根据 key 获取对应的全局变量
-     * @param key 全局变量的 key
-     */
-    export async function getVar(key: string): Promise<string> {
-        return await Request.GetInstance().getGlobalConfigByKey(key);
-    }
-
-    /**
-     * 指令操作符
-     */
-    export const operator: IOperator = new Operator();
-}

package/kunlun/operator/IOperator.ts

@@ -1,163 +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/impl/expression.ts

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